RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure repository to include all source folders

Browse Source 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
tindevil
2025-11-29 20:17:20 +09:00
parent 5d3cd64a25
commit dd97ddec92
11602 changed files with 1446576 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/AddressPacket.h Normal file
View File

@@ -0,0 +1,95 @@
#ifndef _ADDRESS_PACKET_H_
#define _ADDRESS_PACKET_H_
// AddressPacket.h
#include <Network/Packet/PacketBase.h>
#pragma pack(1)
// UDP 주소 서버 업데이트 ( Update Address )
// : 클라이언트가 로그인 후에 UDP로 서버로 한번 보내준다.
// : 서버는 클라이언트의 패킷으로 외부 UDP 주소를 얻는다.
typedef struct PktUA* LPPktUA;
struct PktUA : public PktBase
{
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// UDP 주소 서버 업데이트 Ack
typedef struct PktUAAck* LPPktUAAck;
struct PktUAAck : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
};
// 주소 구조체
typedef struct AddressInfo* LPAddressInfo;
struct AddressInfo
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
AddressInfo() : m_dwCharID(0)
{
memset(&m_PublicAddress, 0, sizeof(m_PublicAddress));
memset(&m_PrivateAddress, 0, sizeof(m_PrivateAddress));
}
AddressInfo(const SOCKADDR_IN& PublicAddress, const SOCKADDR_IN& PrivateAddress, const unsigned long dwCharID)
: m_PublicAddress(PublicAddress), m_PrivateAddress(PrivateAddress), m_dwCharID(dwCharID) { }
};
// 인터넷 주소 구조체
typedef struct INETAddressInfo* LPINETAddressInfo;
struct INETAddressInfo
{
unsigned long m_dwCharID;
unsigned long m_dwPublicAddr;
unsigned long m_dwPrivateAddr;
unsigned short m_usPublicPort;
unsigned short m_usPrivatePort;
INETAddressInfo() { m_dwCharID = m_dwPublicAddr = m_dwPrivateAddr = m_usPublicPort = m_usPrivatePort = 0; }
SOCKADDR_IN GetPublicAddress()
{
SOCKADDR_IN PublicAddress;
memset(&PublicAddress, 0, sizeof(SOCKADDR_IN));
PublicAddress.sin_family = PF_INET;
PublicAddress.sin_addr.S_un.S_addr = m_dwPublicAddr;
PublicAddress.sin_port = m_usPublicPort;
return PublicAddress;
}
SOCKADDR_IN GetPrivateAddress()
{
SOCKADDR_IN PrivateAddress;
memset(&PrivateAddress, 0, sizeof(SOCKADDR_IN));
PrivateAddress.sin_family = PF_INET;
PrivateAddress.sin_addr.S_un.S_addr = m_dwPrivateAddr;
PrivateAddress.sin_port = m_usPrivatePort;
return PrivateAddress;
}
};
// UDP 주소 정보 패킷 ( Address Info )
// - 어드레스 구조체
typedef struct PktAI* LPPktAI;
struct PktAI : public PktBase
{
AddressInfo m_AddressInfo;
};
#pragma pack()
#endif

371
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharAdminPacket.h Normal file
View File

@@ -0,0 +1,371 @@
#ifndef _CHAR_ADMIN_PACKET_H_
#define _CHAR_ADMIN_PACKET_H_
// CharAdminPacket.h
#include <winsock2.h>
#include <windows.h>
#include <Network/Packet/PacketBase.h>
#include <Item/ItemStructure.h>
#include <DB/DBdefine.h>
#pragma pack(1)
typedef struct PktAdmin* LPPktAdmin;
struct PktAdmin : public PktBase
{
enum { MAX_NAME_LEN = 16 };
enum CMD
{
NONE = 0, // 운영자 명령
MOVE_ZONE_CHAR = 1, // 캐릭터 존 이동
MOVE_ZONE_PARTY = 2, // 파티 존 이동
MOVE_CHAR = 3, // 캐릭터 이동
MOVE_PARTY = 4, // 파티 이동
RESPAWN_CHAR = 5, // 캐릭터 리스폰
RESPAWN_PARTY = 6, // 파티 리스폰
KILL_CHAR = 7, // 캐릭터 킬
KILL_PARTY = 8, // 파티 킬
DUEL_INIT = 9, // 듀얼 초기화
CREATE_ITEM = 10, // 아이템 드롭
CREATE_MON = 11, // 몬스터 생성
INFO_CHAR = 12, // 캐릭터 정보
GET_EXP = 13, // 경험치 얻기
GET_GOLD = 14, // 돈 얻기
LEVEL_UP = 15, // 레벨업
PEACE_MODE = 16, // 반전단체 가입
WAR_MODE = 17, // 반전단체 탈퇴
GET_FAME = 18, // 명성 얻기
GET_MILEAGE = 19, // 마일리지 얻기
TRACE_CHAR = 20, // 캐릭터 추적
HIDE_CHAR = 21, // 캐릭터 투명
SHOW_CHAR = 22, // 캐릭터 투명 해제
INVINCIBLE_CHAR = 23, // 캐릭터 무적
NORMAL_CHAR = 24, // 캐릭터 무적 해제
LOGOUT_CHAR = 25, // 캐릭터 강제 로그아웃
APOCALYPSE = 26, // 주위 생물체 모두 킬
CREATE_EQUIP = 27, // 랜덤 옵션이 붙는 장비 드롭
ELITE_BONUS = 28, // 엘리트 보너스 조절
STATUE_INIT = 29, // 명예의 석상 초기화
RESPAWN_ALL = 30, // 모든 캐릭터 리스폰
CHANGE_CLASS = 31, // 전직 하기
LEARN_SKILL = 32, // 해당 스킬 배우기
ERASE_SKILL = 33, // 해당 스킬 지우기
LEVEL_DOWN = 34, // 레벨 다운
GET_QUEST = 35, // 퀘스트 받음
ADD_QUEST = 36, // 완료 퀘스트에 추가
DELETE_QUEST = 37, // 수행/완료 퀘스트를 삭제
// BATTLEGROUND_SERVER 운영자 명령
FINISH_GAME = 38, // 해당 방의 경기 종료 (승패 결정)
DRAW_GAME = 39, // 해당 방의 경기 종료 (무승부)
IGNORE_GAME = 40, // 해당 방의 경기 종료 (승패 무시)
SET_MAX = 41, // 해당 방의 최대 인원수 설정
SET_SCORE = 42, // 해당 방의 목표 점수 설정
SET_LIMIT_TIME = 43, // 해당 방의 시간 제한 설정
SET_REST_TIME = 44, // 해당 방의 쉬는 시간 설정
SET_ITEM_TEMP_INVEN = 45, // 임시 인벤토리에 아이템 넣기
ADD_SPELL = 46, // 해당 스펠을 부여
DELETE_SPELL = 47, // 부여된 해당 스펠을 파괴
STOP = 48, // 해당 캐릭터 묶어두기
STOP_OFF = 49, // 묶어둔 해당 캐릭터를 풀어주기
CHAT_BAN = 50, // 채팅 금지
CHAT_OK = 51, // 채금 해제
NEO = 52, // 네오
SMITH = 53, // 스미스
RELATION = 55, // 적아군 식별.
GM_FORM = 56, // PC 에서 GM 으로.
PC_FORM = 57, // GM 에서 PC 로.
REALM_POINT = 58, // 국가 전쟁 공헌 훈장.
DBAGENT_KILL = 59, // 중계 서버 강제 종료
LEARN_ABILITY = 60, // 해당 스킬 배우기
ERASE_ABILITY = 61, // 해당 스킬 지우기
REQUEST_TRACE_POS = 100 // DBAgent 가 게임 서버에게 추적할 캐릭터의 위치를 요청하는 명령
// 해당 게임 서버가 DBAgent 에게 추적한 캐릭터의 좌표를 넘겨줄때의 명령
};
enum eError
{
E_LOGOUT_CHAR = 2, // 로그아웃한 캐릭터 입니다.
};
unsigned short m_usCmd; // 운영자 명령
char m_stName[MAX_NAME_LEN]; // 이름
union
{
struct ZoneInfo
{
char m_cZone; // 존 번호
char m_cChannel; // 채널 번호
} m_ZoneInfo;
struct EliteBonusInfo
{
char m_cNation; // 국가
char m_cLevel; // 레벨
} m_EliteBonusInfo;
unsigned short m_usProtoTypeID; // 타입 아이디
};
POS m_Position; // 위치
unsigned long m_dwAmount; // 양
unsigned long m_dwAdminCID; // Action 의 주체가 되는 Admin 캐릭터의 CID
unsigned long m_dwAmount2; // 양2
unsigned long m_dwAmount3; // 양3
};
// 어드민 툴에 데이터 업데이트하기.
struct PktAdminToolGetData : public PktBase
{
enum GetDataType
{
// DB중계 -> 운영서버
CHAR_BASIC_DATA = 10, // 캐릭터 정보. 다음 정보들이 들어감.
// CHAR_INFOST 캐릭터 기본 정보
// CHAR_POS 캐릭터 위치 정보
// SKILL 캐릭터 스킬 정보
// QUICK 캐릭터 퀵 슬롯
// EQUIP 캐릭터 장비
// INVEN 캐릭터 인벤
// EXTRA 캐릭터 여분
// EXCHANGE 캐릭터 교환
CHAR_EXTRA_DATA = 11, // 캐릭터 추가 정보들. 다음 정보들이 들어감.
// CHAR_INFOEX 캐릭터 추가 정보
// QUEST 퀘스트
// HISTORY 히스토리
// CONFIG 설정
// STORE_INFO 창고 정보
CHAR_FRIEND_DATA = 12, // 캐릭터 친구 정보
CHAR_BAN_DATA = 13, // 캐릭터 거부 정보
STORE_12_DATA = 14, // 창고 1, 2탭 데이터
STORE_34_DATA = 15, // 창고 3, 4탭 데이터
FINISH_GET_DATA = 19, // DB중계에서 운영서버로 데이터를 전부 보냈음.
// 운영서버 -> DB중계
GET_CHAR_DATA = 20, // 캐릭터 데이터 요청 패킷
CHANGE_CHAR_NAME = 30 // 캐릭터 이름 바꾸기
};
enum GetError
{
UNKNOWN_ERROR = 1, // 알 수 없는 에러
INVALID_REQUEST = 2, // 잘못된 데이터 패킷
GET_UIDCID_QUERY_FAILED = 3, // DB에서 이름으로 UID, CID를 얻어오는 데 실패했다.
INVALID_UID_CID_DATA = 4, // DB에서 이름으로 얻어온 UID, CID데이터가 이상하다.
GET_STORE_QUERY_FAILED = 5, // DB에서 창고 데이터를 얻어오는 데 실패했다.
GET_CHAR_DATA_QUERY_FAILED = 6 // DB에서 캐릭터 데이터를 얻어오는 데 실패했다.
};
char m_szName[CHAR_INFOST::MAX_NAME_LEN];
unsigned long m_dwRequestKey;
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned char m_cType;
unsigned char m_cOldServerGroupID;
};
struct PktAdminToolGetDataAck : public PktBase
{
unsigned long m_dwRequestKey;
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned char m_cType;
unsigned char m_cOldServerGroupID;
};
// 어드민 툴에서 데이터 업데이트하기. (뒤에 데이터를 넣음)
struct PktAdminToolSetData : public PktBase
{
enum SetDataType
{
CHAR_BASIC_DATA = 10, // 캐릭터 정보. 다음 정보들이 들어감.
// CHAR_INFOST 캐릭터 기본 정보
// CHAR_POS 캐릭터 위치 정보
// SKILL 캐릭터 스킬 정보
// QUICK 캐릭터 퀵 슬롯
// EQUIP 캐릭터 장비
// INVEN 캐릭터 인벤
// EXTRA 캐릭터 여분
// EXCHANGE 캐릭터 교환
CHAR_EXTRA_DATA = 11, // 캐릭터 추가 정보들. 다음 정보들이 들어감.
// CHAR_INFOEX 캐릭터 추가 정보
// QUEST 퀘스트
// HISTORY 히스토리
// CONFIG 설정
// STORE_INFO 창고 정보
CHAR_FRIEND_DATA = 12, // 캐릭터 친구 정보
CHAR_BAN_DATA = 13, // 캐릭터 거부 정보
STORE_12_DATA = 14, // 창고 1, 2탭 데이터
STORE_34_DATA = 15, // 창고 3, 4탭 데이터
OPEN_UPDATE_DATA = 20, // 세션을 열고 DB에 업데이트하려 시도한다.
FINISH_UPDATE_DATA = 21, // 데이터를 DB에 업데이트하고 세션을 닫는다.
RELOAD_ADMINLIST = 30
};
enum SetError
{
UNKNOWN_ERROR = 1, // 알 수 없는 에러.
INVALID_UID_CID_ERROR = 2, // 알 수 없는 UID/CID
LOGIN_ANOTHER_GAMESERVER = 3, // 다른 게임 서버에 로그인 해 있어서 업데이트 불가.
SESSION_OPEN_FAILED = 4, // 세션 열기 실패
ALREADY_LOGIN_USER_SESSION_OPEN = 5, // 이미 로그인 되어 있는 유저 세션을 열려고 했음
ANOTHER_CHAR_LOAD_FAILED = 6, // 캐릭터 정보를 DB에서 읽어오는 데 실패
SETTING_DATA_FAILED = 7, // 데이터 세팅 실패 (데이터 길이등이 맞지 않음)
SESSION_START_FAILED = 8 // 세션 시작 실패.
};
unsigned __int64 m_dwSerial;
unsigned long m_dwRequestKey;
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned char m_cType;
unsigned char m_cOldServerGroupID;
};
struct PktAdminToolSetDataAck : public PktBase
{
unsigned long m_dwRequestKey;
unsigned char m_cType;
};
struct PktNewAdminToolSetDataAck : public PktBase
{
unsigned long m_dwRequestKey;
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned char m_cType;
};
struct GiveItemInfo
{
enum GiveItemType
{
MIN_DAMAGE = 0,
MAX_DAMAGE = 1,
ARMOR = 2,
HIT_RATE = 3,
EVADE = 4,
MAX_HP = 5,
HP_REGEN = 6,
MAX_MP = 7,
MP_REGEN = 8,
CRITICAL = 9,
BLOCK = 10,
SPEED = 11,
MAGIC_POWER = 12,
MAGIC_RESIST = 13,
MAX_GIVEITEM_ATTRIBUTE = 14
};
unsigned long m_dwCreateID;
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned short m_usPrototypeID;
unsigned char m_cAmount;
unsigned char m_cAttribute[MAX_GIVEITEM_ATTRIBUTE];
unsigned __int64 m_dwItemUID;
};
struct UpdateItemUID
{
unsigned __int64 m_dwItemUID;
unsigned long m_dwCreateID;
};
struct PktGiveItemToTempInven : public PktBase
{
enum Const
{
MAX_GIVE_ITEM = 10
};
GiveItemInfo m_GiveItemInfo[MAX_GIVE_ITEM];
unsigned char m_cGiveItemNum;
};
struct PktCharNameChange : public PktBase
{
enum Error
{
ERR_SERVER = 1, // 서버 에러
ERR_CANNOT_FIND_CHARACTER = 2, // 캐릭터 찾을 수 없음(로그인된 캐릭터가 아님)
ERR_NAMECHANGE_ITEM = 3, // 이름 변경 아이템 없음
ERR_INVALID_NAME = 4, // 만들 수 없는 이름(특수문자등이 들어간 이상한 이름)
ERR_CANNOT_USE_NAME = 5, // 사용할 수 없는 이름
ERR_ALREADY_USE_NAME = 6 // 이미 사용하고 있는 이름
};
char m_szCharName[CHAR_INFOST::MAX_NAME_LEN]; // 바꿀 이름
unsigned long m_dwUID; // 자기 캐릭터 UID
unsigned long m_dwCID; // 자기 캐릭터 CID
unsigned char m_cNameChangeCount; // 갱신된 이름 변경 카운트 숫자.
Item::ItemPos m_ItemPos; // 계명허가서 (추가작업됨)
};
struct PktAdminCommandLog : public PktBase
{
enum Const
{
MAX_COMMAND_SIZE = 128
};
unsigned long m_dwAdminCID; // 해당 GM UID
unsigned long m_dwCID; // 해당 캐릭터 CID.
char m_szCommand[MAX_COMMAND_SIZE]; // 해당 명령어 텍스트.
};
#pragma pack()
#endif

413
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharAttackPacket.h Normal file
View File

@@ -0,0 +1,413 @@
#ifndef _CHAR_ATTACK_PACKET_H_
#define _CHAR_ATTACK_PACKET_H_
// CharAttackPacket.h
#include <DB/DBDefine.h>
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#include "CharAttackPacketStruct.h"
#include <Community/Guild/GuildConstants.h>
#pragma pack(1)
// 캐릭터 공격 패킷
typedef struct PktAt* LPPktAt;
struct PktAt : public PktBase
{
POS m_Postion; // 공격자 캐릭터 위치
float m_fDir; // 공격자 방향
unsigned long m_dwCharID; // 공격자 캐릭터 아이디
AtType m_AtType; // 공격 타입
AtNode m_AtNode; // 방어자 정보
};
// 캐릭터 공격 패킷 Ack (가변 길이) + 방어자 노드
typedef struct PktAtAck* LPPktAtAck;
struct PktAtAck : public PktBase
{
enum PktAtAckErr
{
FAIL_ALREADY_DEAD = 2, // 이미 죽은 크리쳐에게 공격
FAIL_TOO_FAR = 3, // 거리가 멀어져서 스킬 사용 불가
FAIL_SUICIDE = 4, // 스킬을 사용하면 자살하게 된다.
FAIL_PEACE_TO_WAR = 5, // 반전 모드 캐릭터가 전투 모드 캐릭터에게 긍정적인 인챈트 부여 시도
FAIL_SPELL = 6, // 스펠 사용 실패
FAIL_TO_SIEGE_OBJECT = 7, // 공성 오브젝트에게 할수 없는 공격 시도
FAIL_TO_MONSTER = 8, // 몬스터에게 할수 없는 공격 시도
FAIL_FRIENDLY_ATTACK = 9, // 아군에게 공격할수 없다
FAIL_NOT_SIEGE_ATTACK = 10, // 공성병기의 공격이 잘못되었다.
FAIL_NOT_STEALTH = 11, // 스텔스를 사용할 수 없다.
};
unsigned long m_dwCharID; // 공격자 캐릭터 아이디
AtType m_AtType; // 공격 타입
unsigned short m_wHP; // 공격자 HP
unsigned short m_wMP; // 공격자 MP
unsigned short m_wMPHeal; // 공격자 MP 회복량
unsigned char m_cJudge; // 플래그
unsigned char m_cDefenserNum; // 방어자 수
};
// 캐릭터 공격 정보 (가변 길이) + 방어자 노드
typedef struct PktAtInfo* LPPktAtInfo;
struct PktAtInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
AtType m_AtType; // 공격 타입
unsigned char m_cDefenserNum; // 방어자 수
};
// 캐릭터 공격 받음 패킷
typedef struct PktAted* LPPktAted;
struct PktAted : public PktBase
{
POS m_Postion; // 공격자 위치
float m_fDir; // 공격자 방향
unsigned long m_dwCharID; // 공격자 아이디
unsigned long m_dwMyID; // 방어자 아이디
AtType m_AtType; // 공격 타입
unsigned short m_wMyHP; // 방어자 HP
unsigned short m_wMyMP; // 방어자 MP
unsigned short m_wMyMPHeal; // 방어자 MP 회복량
unsigned char m_cJudge; // 판정 값
};
// 캐릭터 장비 내구도
typedef struct PktEquipDurability* LPPktEquipDurability;
struct PktEquipDurability : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cIndex; // 장비 위치
unsigned char m_cValue; // 남은 내구도
unsigned char m_cValueMax; // 남은 최대내구도
};
// 듀얼 명령
//
// 명령 :
// 0 = 제안, 1 = 수락, 2 = 거절, 3 = 로그아웃, 4 = 사망
//
// 에러 :
// 0 = 성공, 1 = 서버 에러, 2 = 이미 듀얼중인 캐릭터에게 듀얼 신청,
// 3 = 거부 옵션이 켜진 상태
typedef struct PktDuC* LPPktDuC;
struct PktDuC : public PktBase
{
enum DuelCmd
{
DUC_PROPOSE = 0, DUC_READY = 1, DUC_REFUSE = 2,
DUC_LOGOUT = 3, DUC_DEAD = 4, DUC_PARTY_PROPOSE = 5,
DUC_PARTY_READY = 6, DUC_REQUEST_PARTY_INFO = 7, DUC_CANCEL = 8
};
enum PktDuCError
{
NO_SERVER_ERR = 0, SERVER_ERROR = 1, FAIL_DUELING_CHAR = 2,
FAIL_REJECT = 3, FAIL_NOT_LEADER = 4, FAIL_NOT_PARTY = 5
};
unsigned long m_dwSenderID; // 보낸이 아이디
unsigned long m_dwRecverID; // 받는이 아이디
unsigned char m_cCmd; // 명령
};
// 팀배틀 정보
typedef struct PktTBInfo* LPPktTBInfo;
struct PktTBInfo : public PktBase
{
enum DuelCmd
{
DUC_PROPOSE = 0, DUC_READY = 1, DUC_REFUSE = 2,
DUC_LOGOUT = 3, DUC_DEAD = 4, DUC_PARTY_PROPOSE = 5,
DUC_PARTY_READY = 6, DUC_REQUEST_PARTY_INFO = 7
};
unsigned long m_dwCharID;
char m_strChallengerName[CHAR_INFOST::MAX_NAME_LEN];
unsigned char m_cCmd;
unsigned char m_cMemberNum;
};
// 캐릭터 챈트&인챈트 정보
typedef struct PktSpInfo* LPPktSpInfo;
struct PktSpInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_nEnchantLevel; // 주문 레벨
unsigned char m_cSpellType; // 주문 타입 ( namespace Skill::SpellType참조 )
unsigned long m_dwEnchantTime; // 주문 유지시간
bool m_bOnOff; // 켜짐/꺼짐
};
// 캐릭터 리스폰
typedef struct PktRs* LPPktRs;
struct PktRs : public PktBase
{
enum RespawnCmd
{
RS_NORMAL = 0, // 일반적인 방식 (기본 리스폰 장소에서 리스폰)
RS_SELECT = 1, // 리스폰 장소 선택 확정
RS_FORMER_PLACE = 2, // 제자리 리스폰 (스킬에 의해)
RS_BG_HUMAN1 = 3, // 휴먼 포인트1 (배틀그라운드)
RS_BG_HUMAN2 = 4, // 휴먼 포인트2 (배틀그라운드)
RS_BG_HUMAN3 = 5, // 휴먼 포인트3 (배틀그라운드)
RS_BG_AKHAN1 = 6, // 아칸 포인트1 (배틀그라운드)
RS_BG_AKHAN2 = 7, // 아칸 포인트2 (배틀그라운드)
RS_BG_AKHAN3 = 8, // 아칸 포인트3 (배틀그라운드)
RS_BGSERVER_RANDOM = 9, // 배틀 그라운드 서버군
RS_BG_EXIT = 10 // 배틀그라운드 탈출
};
unsigned long m_dwCharID;
unsigned char m_cCmd;
unsigned long m_dwTownID;
POS m_Position;
};
// 캐릭터 리스폰 Ack
typedef struct PktRsAck* LPPktRsAck;
struct PktRsAck : public PktBase
{
enum Error
{
ERR_NOT_EXIST_CAMP = 2, // 존재하지 않는 요새
};
POS m_Position; // 현재 위치
__int64 m_dlExp; // 현재 경험점
unsigned long m_dwGold; // 현재 보유 금액
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wHP; // HP
unsigned short m_wMP; // MP
};
// 리스폰 Ack (배틀그라운드 대기중)
typedef struct PktBGRsAck* LPPktBGRsAck;
struct PktBGRsAck : public PktBase
{
enum PktBGRsAckErr
{
FAIL_PERSONNEL_OVER = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wTurn; // 캐릭터 순서
unsigned short m_wWaitNum; // 전체 대기인 수
unsigned short m_wLeftTime; // 남은 시간
unsigned short m_wHumanNum; // 전체 휴먼 수
unsigned short m_wAkhanNum; // 전체 아칸 수
};
// 리스폰 큐 대기인 정보 (배틀그라운드용)
typedef struct PktRsWaitQueue* LPPktRsWaitQueue;
struct PktRsWaitQueue : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 리스폰 큐 대기인 정보 Ack (배틀그라운드용)
typedef struct PktRsWaitQueueAck* LPPktRsWaitQueueAck;
struct PktRsWaitQueueAck : public PktBase
{
enum { MAX_POINT_NUM_PER_RACE = 3};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wWaitNum[MAX_POINT_NUM_PER_RACE]; // 각 리스폰 위치별 대기인 수
};
// 캐릭터 리스폰 정보 (리스폰 위치들)
// 추가 정보가 뒤에 따라 붙어서 간다.
typedef struct PktRsInfo* LPPktRsInfo;
struct PktRsInfo : public PktBase
{
unsigned long m_dwCharID;
};
// 캐릭터 리스폰 정보 Ack (리스폰 위치들)
// 추가 정보가 뒤에 따라 붙어서 간다.
typedef struct PktRsInfoAck* LPPktRsInfoAck;
struct PktRsInfoAck : public PktBase
{
enum Const
{
MAX_RESPAWN_POINT = 50
};
unsigned long m_dwCharID;
unsigned char m_cRsAreaNum;
unsigned short m_wSize;
};
struct RespawnArea
{
unsigned long m_dwTownID;
POS m_RespawnPos;
};
// 캐릭터 리스폰 지역 세부 정보
typedef struct PktRsAreaInfo* LPPktRsAreaInfo;
struct PktRsAreaInfo : public PktBase
{
unsigned long m_dwCharID;
unsigned long m_dwTownID; // 마을, 길드 요새, 성 ID
};
// 캐릭터 리스폰 지역 세부 정보 Ack
typedef struct PktRsAreaInfoAck* LPPktRsAreaInfoAck;
struct PktRsAreaInfoAck : public PktBase
{
unsigned long m_dwCharID;
unsigned long m_dwTownID;
unsigned short m_nWaitOrder; // 대기순위
unsigned char m_cRemainHour; // 남은 시간 (시)
unsigned char m_cRemainMin; // 남은 시간 (분)
unsigned char m_cRemainSec; // 남은 시간 (초)
bool m_bCount; // 시간 카운팅 시작여부
};
// 어워드 처리
typedef struct PktAw* LPPktAw;
struct PktAw : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwExp; // 경험치
};
// 반전/전쟁모드 전환
typedef struct PktPeace* LPPktPeace;
struct PktPeace : public PktBase
{
enum PktPeaceErr
{
FAIL_WRONG_SYNC = 2, // 클라이언트/서버 간의 싱크가 맞지 않음
FAIL_BATTLE_GROUND = 3, // 배틀그라운드에서는 모드 변경 불가능
FAIL_GUILD_MEMBER = 4 // 길드원은 모드 변경 불가능
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cLeftTime; // 남은 시간
bool m_bPeace; // 반전 모드
};
// 소환수 명령
typedef struct PktSummonCmd* LPPktSummonCmd;
struct PktSummonCmd : public PktBase
{
enum SummonCmd
{
SUC_ATTACK = 0,
SUC_RETURN = 1,
SUC_DIE = 2,
SUC_GUARD_ON = 3,
SUC_GUARD_OFF = 4
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwTargetID; // 대상 아이디
unsigned char m_cCmd; // 명령
};
// 석상 정보
typedef struct PktStatueInfo* LPPktStatueInfo;
struct PktStatueInfo : public PktBase
{
unsigned long m_dwMileage; // 보너스가 추가된 공헌메달 (0이면 보너스 없음)
unsigned short m_wHumanNum; // 전체 휴먼 수
unsigned short m_wAkhanNum; // 전체 아칸 수
unsigned short m_wNowHP; // 석상의 남은 HP
unsigned short m_wKID; // 석상 종류 아이디
unsigned char m_cState; // 석상 상태 (몬스터 State와 동일)
unsigned char m_cIndex; // 석상 인덱스
};
// 카메라 스크립트
typedef struct PktCameraScript* LPPktCameraScript;
struct PktCameraScript : public PktBase
{
unsigned long m_dwDeleteObject; // 사라지는 오브젝트 아이디
unsigned long m_dwNewObject; // 생성되는 오브젝트 아이디
POS m_NewPos; // 생성되는 오브젝트 위치
};
// 사망 및 부활 정보
struct PktDeadInfo : public PktDD
{
enum TypeCode
{
DEAD = 0,
RESPAWN = 1,
RESURRECT = 2
};
/*
typecode:00 HP/MP 죽은넘CID / 죽은넘이름 / 살해자CID / 살해자이름 / 살해자길드명
typecode:00 HP/MP 죽은넘CID / 죽은넘이름 / 살해자CID / 살해자이름 /
'XXXXX님이 몬스터 YYYYY에 의해 사망하셨습니다.'
'XXXXX님이 YYYYY길드의 ZZZZZ님에 의해 사망하셨습니다.'
'XXXXX님이 ZZZZZ님에 의해 사망하셨습니다.'
typecode:01 HP/MP 죽은넘CID / 죽은넘이름 /
'XXXXX님이 일반 부활을 선택하셨습니다. 마을이나 요새에서 리스폰하게 됩니다.'
typecode:02 HP/MP 죽은넘CID / 죽은넘이름 / 살린넘CID / 살린넘이름 / 살린넘길드명
typecode:02 HP/MP 죽은넘CID / 죽은넘이름 /
'XXXXX님에 의해 YYYYY님이 부활 하셨습니다.'
'누군가에 의해 YYYYY님이 부활 하셨습니다.'
*/
unsigned char m_cTypeCode; // 타입코드
unsigned short m_usDeadMemCurrHP; // 죽은넘 HP
unsigned short m_usDeadMemCurrMP; // 죽은넘 MP
unsigned long m_dwDeadCID; // 죽은넘 CID
unsigned long m_dwDeadPID; // 죽은넘 PID
unsigned long m_dwReferenceID; // 죽이거나 살린넘 CID
unsigned char m_cDeadNation; // 죽은넘 국적
unsigned char m_cDeadClass; // 죽은넘 클래스
unsigned char m_cRefNation; // 죽이거나 살린넘 국적
unsigned char m_cRefClass; // 죽이거나 살린넘 클래스
char m_szDeadName[CHAR_INFOST::MAX_NAME_LEN];
char m_szRefName[CHAR_INFOST::MAX_NAME_LEN];
char m_szRefGuildName[Guild::MAX_GUILD_NAME_LEN];
};
#pragma pack()
#endif

74
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharAttackPacketStruct.h Normal file
View File

@@ -0,0 +1,74 @@
#ifndef _CHAR_ATTACK_PACKET_STRUCT_H_
#define _CHAR_ATTACK_PACKET_STRUCT_H_
#include <DB/DBDefine.h>
#pragma pack(1)
// 방어자 정보 ( 차후 서버에서 처리 시 없어질 구조체 )
typedef struct AtNode *LPAtNode;
struct AtNode
{
enum
{
MAX_MONSTER_DEFENDER_NUM = 5,
MAX_DEFENDER_NUM = 10
};
unsigned char m_wDefenserNum; // 방어자 수
unsigned long m_dwDefenser[MAX_DEFENDER_NUM]; // 방어자 아이디
unsigned char m_cDefenserJudge[MAX_DEFENDER_NUM]; // 방어자 판정
};
// 공격 정보
typedef struct AtType* LPAtType;
struct AtType
{
enum
{
SKILL_BIT = 0x8000
};
enum AttackType
{
RIGHT_MELEE = 0,
LEFT_MELEE = 1,
BOW = 3,
CROSSBOW = 4,
DEFENCE = 5,
GUARD = 6
};
unsigned short m_wType; // 공격 타입 (또는 스킬 ID)
unsigned char m_cCasting : 1; // 캐스팅 (공격 타입을 스킬 ID로 사용하므로 별도의 공간을 둡니다.)
unsigned char m_cAtCount : 3; // 공격 카운트 (0~7)
unsigned char m_cSkillLockCount : 3; // 스킬 락카운트 (0~7)
unsigned char m_cMissileAttack : 1; // 포탄이 떨어지는 위치에 의한 공격 (특정 타켓이 아님)
char m_cSkillLevel; // 스킬 레벨 (-127 ~ 128)
POS m_DstPos; // 공성 병기의 포탄이 떨어진 위치
};
// 방어자 노드
typedef struct DefenserNode* LPDefenserNode;
struct DefenserNode
{
unsigned long m_dwCharID; // 방어자 캐릭터 아이디
unsigned short m_wMaxHP; // 최대 HP
unsigned short m_sCurrHP; // 현재 HP
unsigned short m_wMaxMP; // 최대 MP
unsigned short m_sCurrMP; // 현재 MP
unsigned short m_wMPHeal; // MP 회복량
unsigned short m_wDamage; // 데미지 값
unsigned char m_cJudge; // 판정 값
};
#pragma pack()
#endif

215
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharBroadcastPacket.h Normal file
View File

@@ -0,0 +1,215 @@
#ifndef _CHAR_BROAD_CAST_PACKET_H_
#define _CHAR_BROAD_CAST_PACKET_H_
#include <winsock2.h>
#include <windows.h>
#include "CharMovePacket.h"
#include <vector>
#include <utility>
#include <Creature/CreatureStructure.h>
// FLAG (32bit, remain 29bit)
// 타입 코드 4bit ( 0 : Object 1 : AggresiveCreature정보
// 2 : Monster정보, 3 : 캐릭터 Phase 1
// 4 : 캐릭터 Phase
//
//
//
// new broadcast
namespace Broadcast2nd
{
#pragma pack(1)
struct PktBroadcast : PktBase
{
enum BroadcastType
{
LOGIN = 0,
LOGOUT = 1,
BROADCAST = 2,
BROADCAST_END = 3
};
enum DataType
{
CHAR_DATA = 0,
CHAR_CID = 1,
ITEM_DATA = 2,
NONE_DATA = 3
};
unsigned long m_dwCurrentPulse;
unsigned char m_cBroadcastType;
unsigned char m_cDataType;
};
#pragma pack()
}
/*
// old broadcast
namespace BroadcastInfo
{
// 생성해야 할 객체 타입.
namespace ObjectType
{
enum Type
{
OBJECT = 0,
AGGRESIVE_CREATURE = 1,
MONSTER = 2,
SUMMON_MONSTER = 4,
MAX_OBJECT_TYPE = 5
};
}
// 현재 가지고 있는 데이터 타입.
namespace DataType
{
enum Type
{
OBJECT = 0,
AGGRESIVE_CREATURE = 1,
MONSTER = 2,
SUMMON_MONSTER = 4,
MAX_OBJECT_TYPE = 5
};
}
#pragma pack(1)
struct SObject
{
// dwFlags 상위 비트 ------------- 하위 비트
// 23 bit(Reserved) / DataType(3bit) / ObjectPhase(3bit) / ObjectType(3bit)
enum TypeMask
{
ObjectTypeMask = 0x00000007, // 0000/0000/0000/0000/0000/0000/0000/0111
ObjectPhaseMask = 0x00000038, // 0000/0000/0000/0000/0000/0000/0011/1000
DataTypeMask = 0x000001C0 // 0000/0000/0000/0000/0000/0001/1100/0000
};
SObject() : m_dwCID(0), m_dwFlags(0) { }
SObject(unsigned long dwCID) : m_dwCID(dwCID), m_dwFlags(0) { }
unsigned long m_dwCID; // CID.
unsigned long m_dwFlags; // 각종 Flag들. 맨 뒤 3bit는 ObjectType임.
CNetworkPos m_NetworkPos; // 크리쳐 위치.
ObjectType::Type GetObjectType() const { return static_cast<ObjectType::Type>(ObjectTypeMask & m_dwFlags); }
void SetObjectType(ObjectType::Type eObjectType) { m_dwFlags = ((m_dwFlags & (~ObjectTypeMask)) | eObjectType); }
DataType::Type GetDataType() const { return static_cast<DataType::Type>((DataTypeMask & m_dwFlags) >> 6); }
void SetDataType(DataType::Type eDataType) { m_dwFlags = ((m_dwFlags & (~DataTypeMask)) | (eDataType << 6)); }
};
struct SAggresiveCreature : public SObject
{
EnchantInfo m_EnchantInfo;
unsigned short m_nNowHP;
};
namespace Monster
{
struct SMonster : public SAggresiveCreature
{
};
struct SSummonMonster : public SMonster
{
unsigned long m_dwMasterID;
};
};
#pragma pack()
inline unsigned long GetObjectSize(const DataType::Type dataType)
{
switch(dataType)
{
case DataType::OBJECT: return sizeof(SObject);
case DataType::AGGRESIVE_CREATURE: return sizeof(SAggresiveCreature);
case DataType::MONSTER: return sizeof(Monster::SMonster);
case DataType::SUMMON_MONSTER: return sizeof(Monster::SSummonMonster);
}
return 0;
}
inline unsigned long GetMaxObjectSize()
{
size_t max_size = max(sizeof(Monster::SMonster), sizeof(Monster::SSummonMonster));
return static_cast<unsigned long>(max_size);
}
inline unsigned long GetObjectSize(const SObject& object)
{ return GetObjectSize(object.GetDataType()); }
inline bool IsAggresiveCreatureInfo(const ObjectType::Type eObjectType)
{
switch(eObjectType)
{
case ObjectType::AGGRESIVE_CREATURE:
case ObjectType::MONSTER:
case ObjectType::SUMMON_MONSTER:
return true;
}
return false;
}
inline bool IsAggresiveCreatureInfo(const DataType::Type eDataType)
{
switch(eDataType)
{
case DataType::AGGRESIVE_CREATURE:
case DataType::MONSTER:
case DataType::SUMMON_MONSTER:
return true;
}
return false;
}
inline bool IsMonsterInfo(const ObjectType::Type eObjectType)
{
switch(eObjectType)
{
case ObjectType::MONSTER:
case ObjectType::SUMMON_MONSTER:
return true;
}
return false;
}
inline bool IsMonsterInfo(const DataType::Type eDataType)
{
switch(eDataType)
{
case DataType::MONSTER:
case DataType::SUMMON_MONSTER:
return true;
}
return false;
}
inline bool IsSummonMonsterInfo(const ObjectType::Type eObjectType) { return (eObjectType == ObjectType::SUMMON_MONSTER); }
inline bool IsSummonMonsterInfo(const DataType::Type eDataType) { return (eDataType == DataType::SUMMON_MONSTER); }
};
*/
#endif

428
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharCommunityPacket.h Normal file
View File

@@ -0,0 +1,428 @@
#ifndef _CHAR_COMMUNITY_PACKET_H_
#define _CHAR_COMMUNITY_PACKET_H_
// CharCommunityPacket.h
// DBDefine필요.
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#include <Network/Packet/PacketStruct/CharItemPacketStruct.h>
#include "AddressPacket.h"
#include "CharCommunityPacketStruct.h"
#pragma pack(1)
// 파티 생성
struct PktPI : public PktBase
{
PARTY_EX m_Party;
};
// 파티 명령
//
// 명령 :
// 0 = 초대, 1 = 가입, 2 = 거절,
// 3 = 퇴장, 4 = 탈퇴, 5 = 양도,
// 6 = 파괴, 7 = 로그인, 8 = 로그아웃,
// 9 = 삭제(캐릭터), 10 = 재로그인,
// 11 = 파티찾기, 12 = 멤버찾기,
// 13 = 오토루팅 켜기, 14 = 오토루팅 끄기
// 15 = 파티 멤버 존 이동
// 16 = 파티 멤버 사망
//
// 에러 :
// 1 = 서버 에러, 2 = 이미 파티에 가입되어 있는 경우, 3 = 가입 실패
// 4 = 퇴장 실패, 5 = 탈퇴 실패, 6 = 양도 실패, 7 = 파티 인원 초과,
// 8 = 초대 실패, 9 = 거부 옵션을 켠 상태
//
struct PktPC : public PktBase
{
enum PartyCmd
{
PC_INVITE = 0, PC_ACCEPT = 1, PC_REFUSE = 2,
PC_BANISH = 3, PC_SECESSION = 4, PC_TRANSFER = 5,
PC_DESTROY = 6, PC_LOGIN = 7, PC_LOGOUT = 8,
PC_DELETE = 9, PC_RELOGIN = 10, PC_FINDPARTY = 11,
PC_FINDMEMBER = 12, PC_AUTOROUTING_ON = 13, PC_AUTOROUTING_OFF = 14,
PC_MOVEZONE = 15
};
enum PktPCError
{
SERVER_ERROR = 1, CHAR_JOINED = 2, FAIL_ACCEPT = 3,
FAIL_BANISH = 4, FAIL_SECESSION = 5, FAIL_TRANSFER = 6,
OVER_MEMBER = 7, FAIL_INVITE = 8, FAIL_REJECT = 9,
ALREADY_PARTY = 10, FAIL_NOT_PARTY = 11, FAIL_NOT_LEADER = 12
};
unsigned long m_dwPartyID; // 파티 아이디
unsigned long m_dwSenderID; // 캐릭터 아이디(주체)
unsigned long m_dwReferenceID; // 참조 아이디(대상 캐릭터/서버 아이디)
unsigned short m_wCmd; // 명령
};
// 파티 명령 Ack
struct PktPCAck : public PktBase
{
AddressInfo m_SenderAddressInfo; // Sender의 주소
char m_strSenderName[CHAR_INFOST::MAX_NAME_LEN]; // Sender의 이름
unsigned long m_dwPartyID; // 파티 아이디
unsigned long m_dwSenderID; // 캐릭터 아이디(주체)
unsigned long m_dwReferenceID; // 참조 아이디(대상 캐릭터/서버 아이디)
unsigned long m_dwReferenceGID; // 파티에 임시 길드 아이디.
unsigned char m_cCmd; // 명령
};
// 파티 정보
struct PktPCInfo : public PktBase
{
unsigned long m_dwPartyID; // 파티 ID
unsigned long m_dwMemberID; // 멤버 ID
unsigned char m_cCmd; // 명령
};
/*
// 파티 멤버 데이터 (+ 가변길이 데이터)
struct PktMD : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wCmd; // 서브 명령
unsigned short m_wLen; // 길이
};
// 파티 멤버 정보
struct PktPM : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwPartyID; // 파티 아이디
unsigned long m_dwChant; // 챈트 상태
unsigned long m_dwEnchant; // 인챈트 상태
unsigned short m_wMaxHP; // 최대 HP
unsigned short m_sCurrHP; // 현재 HP
unsigned short m_wMaxMP; // 최대 MP
unsigned short m_sCurrMP; // 현재 MP
unsigned char m_cClass; // 캐릭터 클래스
unsigned char m_cLevel; // 캐릭터 레벨
POS m_Position; // 현재 좌표
};
// 파티 멤버 주소 Update
struct PktPMA : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID;
unsigned long m_dwPartyID;
};
*/
// 파티 찾기
struct PktPF : public PktBase
{
unsigned long m_dwCharID;
};
// 파티 찾기 Ack
struct PktPFAck : public PktBase
{
enum { MAX_LIST = 30, MAX_DIFF_LEVEL_VIEW = 14 };
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cMemberFindPartyNum; // 파티 찾기 리스트 수
unsigned char m_cPartyFindMemberNum; // 파티원 찾기 리스트 수
};
// 캐릭터 명성(공헌도) 정보
struct PktFI : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 캐릭터 명성(공헌도) 정보 Ack
struct PktFIAck : public PktBase
{
enum
{
MAX_NAME_LEN = 16
};
enum FIAckCmd
{
FAME_INFO = 0, // 일반 정보 요청
FAME_LOSE_DUEL = 1, // 자신이 듀얼 상대에게 살해 당한 경우
FAME_LOSE_CONTINUE = 2, // 자신이 연속 살해 당한 경우
FAME_LOSE = 3, // 자신이 살해 당해서 명성을 잃는 경우
FAME_LOSE_MEMBER = 4, // 파티원이 살해 당한 경우
FAME_WIN_DUEL = 5, // 자신이 듀얼 상대를 살해한 경우
FAME_WIN_LARGE_GAP = 6, // 자신이 살해했지만 명성차가 큰 경우
FAME_WIN_CONTINUE = 7, // 자신이 연속 살해한 경우
FAME_WIN = 8, // 자신이 살해하여 명성과 마일리지를 얻는 경우
FAME_WIN_MEMBER_DUEL = 9, // 파티원이 듀얼 상대를 살해한 경우
FAME_WIN_MEMBER_LARGE_GAP = 10, // 파티원이 살해했지만 명성차가 큰 경우
FAME_WIN_MEMBER_CONTINUE = 11, // 파티원이 연속 살해한 경우
FAME_WIN_MEMBER = 12, // 파티원이 살해하여 명성과 마일리지를 얻는 경우
FAME_LOSE_LEVELMIN = 13, // 자신이 레벨이 높은 유저에게 살해 당한 경우
FAME_WIN_LEVELMIN = 14, // 자신이 레벨이 적은 유저를 죽인경우
FAME_WIN_MEMBER_LEVELMIN = 15 // 파티원이 레벨이 적은 유저를 죽인경우.
};
unsigned long m_dwCharID; // 캐릭터 아이디 (요청한 사람)
unsigned long m_cOtherNation; // 상대방 캐릭터 국적
unsigned char m_cOtherClass; // 상대방 캐릭터 클래스
unsigned long m_dwFame; // 현재 명성
unsigned long m_dwMileage; // 현재 마일리지
unsigned char m_cRankingByRace; // 종족별 순위
unsigned char m_cRankingByClass; // 클래스별 순위
unsigned char m_cCmd; // 명령
char m_szWinCharName[MAX_NAME_LEN]; // 살해한 캐릭터 이름
char m_szLoseCharName[MAX_NAME_LEN]; // 살해당한 캐릭터 이름
};
// 커맨드 / 데이터 갯수 / 데이터, 데이터, 데이터... / 채팅 메시지(최대 PktChatMaxSize)
struct PktChat : public PktBase
{
enum PktChatCmd
{
NORMAL = 0, // 현재 캐릭터 좌표를 가지고 판단.
PARTY = 1, // 파티 채팅
FRIEND = 2, // 친구 채팅 (이름 char[16] * m_cNum - MAX 100개)
GUILD = 3, // 길드 채팅
CLIENT_LOG = 5,
STALL = 6, // 노점상 채팅 (이름 char[16] * m_cNum - MAX 10개)
SHOUT = 7, // 외치기
ADMIN_NORMAL_CHAT = 8, // 운영자 통상 채팅 (Ack로만 사용)
ADMIN_SHOUT = 9, // 운영자 외치기 (Ack로만 사용)
WHISPER = 10, // 이 번호는 쓰이지 않는다.Whisper는 별도의 패킷을 사용하기 때문이다. 단, 로그시에 쓰인다.
TRADE = 11, // 외치기와 동일 (색 구분용으로 다른 커맨드로 만듬)
CAMP_SHOP = 12, // 길드 요새 상점 채팅 (이름 char[16] * m_cNum - MAX 10개)
NOTIFY_CHAR_INFO = 13, // 운영자 명령 hp
FIND_PARTY = 14, // 파티 찾기
ENEMY_CHECK = 15, // 적아군 식별.
DICE = 16, // 주사위 채팅 (파티채팅과 동일)
GMREPORT = 17, // 지엠 채팅
NOTICE = 255,
PktChatMaxSize = 180
};
enum ERR
{
SHOUT_TIMEOUT = 2, // 외침 시간 제한 걸림
CHAT_BAN = 3 // 채팅 금지
};
unsigned long m_dwSenderCID; // 채팅 전송자 CID
unsigned short m_usLang; // 시스템 랭귀지
unsigned char m_cCmd; // 커맨드(커맨드에 따라 데이터 크기가 다름)
unsigned char m_cNum; // 데이터 갯수
};
// 게임서버에서 채팅서버로 채팅 요청을 할 때 쓰이는 패킷이다.
struct PktChatRequest : public PktBase
{
unsigned long m_dwUID; // 유저 ID (서버간 통신에서만 넣음)
unsigned long m_dwCID; // 캐릭터 ID
unsigned short m_usLang; // 시스템 랭귀지
unsigned short m_usXPos; // 캐릭터 좌표 (서버간 통신에서만 넣음)
unsigned short m_usYPos; // 캐릭터 좌표 (서버간 통신에서만 넣음)
unsigned short m_usZPos; // 캐릭터 좌표 (서버간 통신에서만 넣음)
char m_cZone; // 캐릭터 존
unsigned char m_cCmd; // 커맨드(커맨드에 따라 데이터 크기가 다름)
unsigned char m_cNum; // 데이터 갯수
};
struct PktChatBanInfo : public PktBase
{
unsigned long m_dwCID; // 캐릭터 ID
};
// 캐릭터 속삭임 패킷
struct PktWh : public PktBase
{
enum
{
FAIL_CHAR_LOGOUT = 2, // 로그아웃한 캐릭터
FAIL_REJECT = 3, // 귓말 거부
FAIL_ENEMY = 4, // 적군에게는 귓말을 보낼 수 없다.
FAIL_CHAT_BAN = 5, // 채팅 금지
PktWhMaxSize = PktChat::PktChatMaxSize
};
char m_SenderName[CHAR_INFOST::MAX_NAME_LEN];
char m_RecverName[CHAR_INFOST::MAX_NAME_LEN];
};
// 게임서버 -> 채팅서버로 데이터 전달
struct PktChatData : public PktBase
{
enum
{
LOGIN = 0,
LOGOUT = 1,
DELTA = 2
};
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned char m_cType;
};
// 채팅 금지
struct PktChatBan : public PktBase
{
unsigned long m_dwAdminCID; // 채금을 건 운영자 CID
unsigned long m_dwTargetCID; // 채금 대상의 CID
unsigned long m_dwMinutes; // 채금 시간 ( 0이면 해제 )
};
// 캐릭터 노점상 개설 패킷
struct PktStO : public PktBase
{
enum { MAX_STALL_NAME_LEN = 32 };
unsigned long m_dwCharID;
char m_StallName[MAX_STALL_NAME_LEN];
};
// 캐릭터 노점상 물건 등록 패킷
struct PktStRI : public PktBase
{
enum PktStRICmd
{
SC_REGISTER = 0, // 개인 노점상 물품 등록
SC_CANCEL = 1, // 개인 노점상 물품 등록 취소
SC_CAMP_REGISTER = 2, // 길드 요새 상점 물품 등록
SC_CAMP_CANCEL = 3, // 길드 요새 상점 물품 등록 취소
SC_CAMP_SELL = 4 // 길드 요새 상점의 물품이 판매되어 사라짐
};
enum PktStRIEErr
{
FAIL_NOT_ITEM = 2, // 잘못된 아이템입니다.
FAIL_NOT_SELL = 3 // 판매가 불가능합니다.
};
unsigned long m_dwCharID; // 주인 아이디
unsigned long m_dwShopID; // 노점상 아이디 (개인 노점상의 경우 사용하지 않는다.)
TakeType m_TakeType; // 아이템 이동 구조체
unsigned long m_dwPrice; // 등록 가격
unsigned char m_cCmd; // 명령
char m_BuyUser[CHAR_INFOST::MAX_NAME_LEN];
};
// 캐릭터 노점상 입장 패킷
struct PktStE : public PktBase
{
enum PktStEErr
{
SUCCESS = 0,
SERVER_ERROR = 1,
FAIL_FULL_STALL = 2,
FAIL_ENTER = 3,
FAIL_LEAVE = 4
};
unsigned long m_dwCustomerID;
unsigned long m_dwOwnerID;
};
// 캐릭터 노점상 아이템 정보 패킷 (+ 아이템 정보 + 아이템 가격)
struct PktStIInfo : public PktBase
{
enum
{
MAX_CUSTOMER_NUM = 10
};
unsigned long m_dwOwnerID; // 주인 ID
unsigned long m_dwCustomerID[MAX_CUSTOMER_NUM]; // 입장객 ID
unsigned long m_dwTempSafe; // 임시 금고 (길드 요새 상점용)
unsigned char m_cTax; // 세율 (길드 요새 상점용)
unsigned long m_dwItemSize; // 등록된 아이템 크기
unsigned char m_cItemNum; // 등록된 아이템 갯수
};
// 인증 판넬에 대한 승인
struct PktAP : public PktBase
{
enum PktAPCmd
{
AP_RESURRECTION = 1,
AP_RECALL = 2
};
unsigned long m_dwAffectedID;
unsigned long m_dwCasterID;
unsigned char m_cCmd;
};
// 캐릭터 인증 판넬
struct PktAPAck : public PktBase
{
unsigned long m_dwCasterID;
char m_szCasterName[CHAR_INFOST::MAX_NAME_LEN];
unsigned char m_cCmd;
};
// 캐릭터 듀얼시 연사 방지 패킷.
struct PktSaveEnemy : public PktBase
{
unsigned long m_dwCID;
unsigned long m_dwAttackedCID;
unsigned long m_dwTick;
};
#pragma pack()
#endif

29
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharCommunityPacketStruct.h Normal file
View File

@@ -0,0 +1,29 @@
#ifndef _CHAR_COMMUNITY_PACKET_STRUCT_H_
#define _CHAR_COMMUNITY_PACKET_STRUCT_H_
#pragma pack(1)
#include <DB/DBDefine.h>
// 파티 찾기 구조체
typedef struct MemberFindParty* LPMemberFindParty;
struct MemberFindParty
{
char m_strName[CHAR_INFOST::MAX_NAME_LEN]; // 이름
unsigned char m_cLevel; // 레벨
unsigned char m_cClass; // 클래스
};
// 파티원 찾기 구조체
typedef struct PartyFindMember* LPPartyFindMember;
struct PartyFindMember
{
char m_strLeaderName[CHAR_INFOST::MAX_NAME_LEN]; // 리더 이름
unsigned char m_cAverageLevel; // 평균 레벨
unsigned char m_cMemberNum; // 멤버 수
};
#pragma pack()
#endif

48
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharConfigPacket.h Normal file
View File

@@ -0,0 +1,48 @@
#ifndef _CHAR_CONFIG_PACKET_H_
#define _CHAR_CONFIG_PACKET_H_
// CharConfigPacket.h
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#include "CharConfigPacketStruct.h"
#pragma pack(1)
typedef struct PktConfigInfo* LPPktConfigInfo;
struct PktConfigInfo : public PktDD
{
enum { MAX_BUFFER_SIZE = 50 };
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned short m_wSize;
};
// 옵션 조정
typedef struct PktCOp* LPPktCOp;
struct PktCOp : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
RejectOption m_RejectOption; // 거부 옵션 비트셑
};
// 정보 변화
typedef struct PktChatInfoChange* LPPktChatInfoChange;
struct PktChatInfoChange : public PktBase
{
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned long m_dwPID;
unsigned long m_dwGID;
RejectOption m_RejectOption;
unsigned char m_bPeaceMode;
};
#pragma pack()
#endif

78
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharConfigPacketStruct.h Normal file
View File

@@ -0,0 +1,78 @@
#ifndef _CHAR_CONFIG_PACKET_STRUCT_H_
#define _CHAR_CONFIG_PACKET_STRUCT_H_
#pragma pack(1)
#include <winsock2.h>
#include <windows.h>
// 전투/반전 모드 정보 (주의 : 구조체 크기가 변경되면 애로사항 꽃핌)
typedef struct PeaceModeInfo* LPPeaceModeInfo;
struct PeaceModeInfo
{
bool m_bPeace;
FILETIME m_FileTime;
PeaceModeInfo() : m_bPeace(false)
{
m_FileTime.dwHighDateTime = 0;
m_FileTime.dwLowDateTime = 0;
}
};
// 거부 옵션 (주의 : 구조체 크기가 변경되면 애로사항 꽃핌)
typedef struct RejectOption* LPRejectOption;
struct RejectOption
{
union
{
struct RejectStruct
{
unsigned short m_Party : 1; // 파티
unsigned short m_Exchange : 1; // 교환 거부
unsigned short m_Duel : 1; // 일대일 거부
unsigned short m_Whisper : 1; // 귓속말 거부
unsigned short m_Friend : 1; // 친구 거부
unsigned short m_Shout : 1; // 외치기 거부
unsigned short m_Recall : 1; // 리콜 거부
unsigned short m_Remainder : 9;
};
RejectStruct Reject;
unsigned short m_wReject;
};
RejectOption() : m_wReject(0) { }
RejectOption(unsigned short wReject) : m_wReject(wReject) { }
};
// 언어필터 옵션
typedef struct LanguageOption* LPLanguageOption;
struct LanguageOption
{
union
{
struct LangStruct
{
unsigned short m_ENG : 1;
unsigned short m_CHS : 1;
unsigned short m_JPN : 1;
unsigned short m_KOR : 1;
unsigned short m_PRT : 1;
unsigned short m_SPN : 1;
unsigned short m_POL : 1;
unsigned short m_Remainder : 9;
};
LangStruct Lang;
unsigned short m_usLang;
};
LanguageOption() : m_usLang(0) { }
LanguageOption(unsigned short usLang) : m_usLang(usLang) { }
};
#pragma pack()
#endif

671
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharItemPacket.h Normal file
View File

@@ -0,0 +1,671 @@
#ifndef _CHAR_ITEM_PACKET_H_
#define _CHAR_ITEM_PACKET_H_
// CharItemPacket.h
// ItemStructure.h을 포함해야 한다. (집기, 떨구기 등등)
#include <Item/ItemStructure.h>
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#include "CharItemPacketStruct.h"
#pragma pack(1)
// 집기 (응답 필요)
struct PktPU : public PktBase
{
unsigned __int64 m_nObjectID; // 오브젝트 아이디
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_itemPos; // 아이템 위치
};
// 집기 Ack
struct PktPUAck : public PktBase
{
enum ObjectType { Item = 0, Gold = 1 };
enum PktPUAckError
{
NO_SERVER_ERR = 0,
SERVER_ERROR = 1,
FAIL_GET_CELL = 2,
FAIL_GET_ITEM = 3,
FAIL_PICKUP_INVEN = 4,
FAIL_NOT_OWNER_OF_ITEM = 5,
FAIL_NOT_ITEM = 6,
FAIL_CREATE_ITEM = 7,
FAIL_AUTO_ROUTING = 8,
FAIL_GOLD_OVERFLOW = 9
};
unsigned __int64 m_nObjectID; // 오브젝트 아이디
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwSize; // Object크기(혹은 돈 양)
Item::ItemPos m_itemPos; // 아이템이 놓일 위치
unsigned char m_cType; // Object종류(아이템 혹은 돈)
unsigned char m_cNum; // 아이템 갯수
};
// 집기 정보
struct PktPUInfo : public PktBase
{
unsigned __int64 m_nObjectID; // 오브젝트 아이디
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 오토 루팅
struct PktAutoRouting : public PktBase
{
enum PktARCmd
{
ARC_ORDER = 0,
ARC_POSSIBLE = 1,
ARC_IMPOSSIBLE = 2
};
unsigned __int64 m_nObjectID; // 오브젝트 아이디
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_wItemID; // 아이템 아이디
unsigned char m_cNum; // 아이템 갯수
Item::ItemPos m_itemPos; // 아이템 위치
unsigned char m_cCmd; // 명령
};
// 떨구기 (응답 필요)
struct PktPD : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_itemPos; // 아이템 위치 및 인덱스
unsigned char m_cNum; // 아이템 갯수
};
// 떨구기 Ack
struct PktPDAck : public PktBase
{
enum PktPDAckError
{
SERVER_ERROR = 1,
FAIL_GET_CELL = 2,
FAIL_DROP_INVEN = 3,
FAIL_DROP_FIELD = 4,
FAIL_ZERO_ITEM = 5
};
unsigned long m_dwCharID; // 캐릭터 아이디
FieldObject m_FieldObject; // FieldObject
Item::ItemPos m_itemPos; // 아이템 위치 및 인덱스
};
// 떨구기 정보
struct PktPDInfo : public PktBase
{
unsigned long m_dwCharID;
FieldObject m_FieldObject;
};
// 사라지기
struct PktDisappearItem : public PktBase
{
enum PktDICmd
{
DIC_DEFAULT = 0, // 일반적인 아이템 삭제
DIC_LINKED_QUEST = 1 // 퀘스트 종속 아이템의 삭제 (메세지 출력 필요)
};
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_itemPos; // 아이템 위치 및 인덱스
unsigned char m_cNum; // 아이템 갯수
unsigned char m_cCmd; // 명령
};
/* TODO : REMOVE HERE
셀 정보
struct PktCeInfo : public PktBase
{
struct Stall_Info
{
enum { MAX_STALL_NAME = 32 };
unsigned long m_dwCID;
char m_szStallName[MAX_STALL_NAME];
};
unsigned char m_cItemNum; // 뒤에 따라오는 아이템 개수.
unsigned char m_cStallNum; // 뒤에 따라오는 상점 이름 개수.
};
*/
// 아이템 처리 (응답 필요)
struct PktTI : public PktBase
{
enum PktTIError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2,
FAIL_MOVE_FIFTHSKILL_LOCKITEM = 3
};
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
};
// 돈 처리 (응답 필요)
struct PktTG : public PktBase
{
enum PktTGError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2,
GOLD_OVERFLOW = 3
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 돈 액수
unsigned char m_cSrcPos : 4; // Src위치 - TakeType 참조
unsigned char m_cDstPos : 4; // Dst위치 - TakeType 참조
};
// 아이템 처리 (응답 필요)
struct PktTIs : public PktBase
{
enum PktTlsError
{
SERVER_ERROR = 1
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_TakeNum; // 아이템 집기 숫자
};
// 아이템 스왑
struct PktSwI : public PktBase
{
enum PktSwlError
{
SERVER_ERROR = 1,
FAIL_SRC_MOVE = 2,
FAIL_DST_MOVE = 3,
CANT_SWAP = 4
};
unsigned long m_dwCharID; // - 캐릭터 아이디
TakeType m_SwapSrc; // - 스왑 소스 아이템 집기 구조체
TakeType m_SwapDst; // - 스왑 대상 아이템 집기 구조체
};
// 아이템 거래
struct PktTr : public PktBase
{
enum PktTrError
{
FAIL_DROP_INVEN = 2, // 인벤토리에 아이템이 없어 팔기 실패
FAIL_WRONG_NPC = 3, // 잘못된 NPC
FAIL_ITEM_BUY = 4, // 아이템 구입 실패
FAIL_PUT_INVEN = 5, // 인벤토리에 아이템 놓기 실패
FAIL_FULL_INVEN = 6, // 인벤토리가 꽉 찬 상태
FAIL_ENEMY_ITEM = 7, // 공성시간에 적대 길드 요새 상점에서 아이템 구매 실패.
FAIL_GOLD_OVERFLOW = 8 // 거래후 최대 소지금 초과
};
enum PktTrCmd
{
TRC_BUY_WITH_GOLD = 0, // 아이템 구입 (일반 상점)
TRC_BUY_WITH_MILEAGE = 1, // 아이템 구입 (메달 상점)
TRC_SELL = 2, // 아이템 판매
TRC_BUY_EQUIP = 3, // 랜덤 옵션이 붙은 장비 구입
TRC_BUY_WITH_SKILL_COUPON = 4 // 아이템 구입 (상위 트레이너)
};
unsigned long m_dwCustomerID; // 손님 아이디
unsigned long m_dwOwnerID; // 상점 주인 아이디 (NPC 또는 캐릭터)
unsigned char m_cCmd; // 명령
unsigned short m_wBuyItemID; // 사려고 하는 아이템 종류 ID
TakeType m_TakeType; // 아이템 집기 구조체
Item::ItemPos m_CouponPos; // 스킬북 쿠폰 위치 (TRC_BUY_WITH_SKILL_COUPON 명령의 경우 돈 대신 쿠폰을 사용한다.)
unsigned short m_wSize; // 아이템 크기 (TRC_BUY_EQUIP 명령의 경우 '가변길이 아이템'이 덧붙는다.)
// Rodin : 아이템 전체가 아닌 속성 배열을 넣어 패킷 길이 체크와 더불어 해킹 위험을 줄이도록 수정합시다.
};
// 아이템 거래 Ack (+ 가변길이 아이템)
struct PktTrAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwNPCID; // 상점 NPC 아이디
unsigned long m_dwGold; // 현재 소지금
unsigned long m_dwMileage; // 현재 마일리지
Item::ItemPos m_CouponPos; // 스킬북 쿠폰 위치 (TRC_BUY_WITH_SKILL_COUPON 명령의 경우 돈 대신 쿠폰을 사용한다.)
unsigned short m_wSize; // 아이템 크기
Item::ItemPos m_itemPos; // 아이템 위치
unsigned char m_cNum; // 아이템 갯수
};
// NPC 장비 상점 정보 (+ Ack시엔 가변 길이 아이템 목록)
struct PktEquipShopInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwNPCID; // NPC 아이디
unsigned long m_dwTime; // 물품 재진열 시간 (그레이드가 새로 책정된 시간)
unsigned char m_cRace; // 종족
unsigned char m_cTabPage; // 탭
unsigned char m_cNum; // 아이템 갯수
};
// 아이템의 수리 (응답 필요)
struct PktRpI : public PktBase
{
enum Err
{
NOT_ENOUGH_GOLD = 2, // 가지고 있는 돈이 부족
FAIL_NOT_CREATURE = 10, // 크리에이쳐가 존재하지 않습니다.
FAIL_NOT_NPCZONE = 11, // NPC의 존번호가 다릅니다.
FAIL_NOT_REPAIR = 12, // 리페어아이템이없다.
FAIL_NOT_POSITEM = 13, // 아이템이 위치에없다.
FAIL_NOT_STACKABLE = 14, // 소모성아이템이다.
FAIL_NOT_EQUIP = 15, // 장비아이템이아니다.
FAIL_FULL_DRUA = 16, // 내구도가 풀이다.
};
enum Pos
{
EQUIPMENT = 1,
INVENTORY = 2,
EQUIPMENT_ALL = 3,
INVENTORY_ALL = 4,
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 수리 비용
Item::ItemPos m_itemPos; // 수리 아이템 위치
};
// 장비하고 있는 모든 아이템 수리 (응답 필요)
struct PktRpAI : public PktBase
{
enum Err
{
NOT_ENOUGH_GOLD = 2, // 가지고 있는 돈이 부족
FAIL_NOT_CREATURE = 10, // 크리에이쳐가 존재하지 않습니다.
FAIL_NOT_NPCZONE = 11, // NPC의 존번호가 다릅니다.
FAIL_NOT_REPAIR = 12, // 리페어아이템이없다.
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 수리 비용
};
// 아이템의 사용 (응답 필요)
struct PktUI : public PktBase
{
enum PktUIAck
{
USE_FAILED = 2,
/* 공성 관련 아이템 사용 에러 */
NOT_SIEGE_TIME = 3, // 공성 시간이 아님
NOT_EXIST_GUILD = 4, // 길드가 없거나, 길드에 가입하지 않았음
NOT_MASTER = 5, // 길드 마스터가 아님
NOT_ENOUGH_FAME = 6, // 길드 명성 부족
ANOTHER_DEV_CAMP = 7, // 구축중, 취소중, 파괴중인 다른 진지가 있음
INNER_RADIUS = 8, // 다른 진지나 성의 반경 안에 있음
OUTER_RADIUS = 9, // 아군 진지의 영역 밖에 있음
NOT_ENOUGH_MATERIAL = 10, // 공성 병기 생성 자재 부족
IN_SAFETYZONE = 11, // 진지를 세울수 없는 곳임
FAIL_PEACE_GUILD = 12, // 평화 모드 길드
FAIL_CAPITAL_ZONE = 13, // 카나번에만 생성 가능
// FAIL_ALMIGHTY_GROUND = 13, // 신의 대지에는 생성 할수 없음
FAIL_STONE_BATTLE = 14, // 다크 카나번에는 생성 할수 없음
FAIL_EXIST_ANOTHER_WEAPON = 15, // 이미 월드 웨폰이 존재함
FAIL_ALMIGHTY_PIRATE = 16, // 신의 해적단은 생성 불가
FAIL_REMAIN_3_DAY = 17, // 3번의 공성 시간후에 가능
FAIL_REMAIN_2_DAY = 18, // 2번의 공성 시간후에 가능
FAIL_REMAIN_1_DAY = 19, // 1번의 공성 시간후에 가능
FAIL_POSITION = 20, // 위치가 이상함
NOT_EXIST_QUEST = 21, // 퀘스트가 존재하지 않음
FAIL_HAS_QUEST = 22, // 이미 가지고 있는 퀘스트
FAIL_FULL_QUEST = 23, // 받을 수 있는 퀘스트수가 꽉 찼음
FAIL_QUEST_LEVEL = 24, // 퀘스트를 수행할수 있는 레벨 아님
FAIL_NOT_GT_GUILD_WAR_TIME = 25, // 길드전 시간이 아님
OUTER_RADIUS_SIEGE = 26, // 영역 밖에서 공성 병기를 생성
FAIL_HAS_SIEGE_ARMS = 27, // 1개 이상에 공성 병기를 생성 하려고 할때.
FAIL_MATERIAL_COUNT = 28, // 공성용 자재가 부족할때.
NOT_GUILD_MASTER = 29, // 길드 마스터가 아닐 경우.
NOT_CASTLE_NATION = 30, // 공성측일 경우.
FAIL_MAX_SIEGE_OBJECT = 31, // 충차가 최대값으로 생성되었을 경우.
FAIL_NEWZONE = 32, // 신규존에서는 생성 할수 없음
NOT_LIMIT_LEVEL = 33 // 80 레벨 미만 일 경우.
};
unsigned long m_dwSender; // 사용자 아이디
unsigned long m_dwRecver; // 대상자 아이디
Item::ItemPos m_itemPos; // 사용 아이템 위치
unsigned char m_cRemainItemNum; // 남은 아이템 개수. 서버->클라이언트로 보내는 패킷일 경우에만 의미 있음.
};
// 오브젝트 던지기 ( 응답 필요 )
struct PktCO : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // 던지는 사람
unsigned long m_dwReceiverID; // 받는 사람
};
// 오브젝트 던지기 (Cast Object)
struct PktCOInfo : public PktBase
{
CastObject m_sCastObject;
unsigned long m_dwSenderID; // 던지는 사람
unsigned long m_dwReceiverID; // 받는 사람
};
// 소켓 설치
struct PktIS : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_equipPos; // 장비 위치
Item::ItemPos m_gemPos; // 보석 위치
};
// 소켓 설치 Ack (+ 소켓이 설치된 장비 아이템)
struct PktISAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_equipPos; // 장비 위치
Item::ItemPos m_gemPos; // 보석 위치
unsigned char m_cSize; // 아이템 크기
};
// 룬 설치/제거.
struct PktIRS : public PktBase
{
enum
{
RUNE_INSTALL = 0x02,
RUNE_UNINSTALL = 0x03,
};
unsigned long m_dwCharID; // 캐릭터 아이디.
Item::ItemPos m_equipPos; // 장비 위치.
Item::ItemPos m_runePos; // 룬 위치.
unsigned char m_cType; // 패킷 타입(설치/제거).
};
// 룬 설치/제거 Ack.
struct PktIRSAck : public PktBase
{
enum
{
RUNE_INSTALL = 0x02,
RUNE_UNINSTALL = 0x03,
};
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_equipPos; // 장비 위치.
Item::ItemPos m_runePos; // 룬 위치.
unsigned char m_cSize; // 아이템 크기.
unsigned char m_cType; // 패킷 타입(설치/제거).
};
// 아이템 합성
struct PktItemChemical : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_pickkingPos; // 들고 있는 아이템 위치
Item::ItemPos m_targetPos; // 합성 대상 아이템 위치
unsigned char m_cPickkingNum; // 들고 있는 아이템 갯수
};
// 아이템 합성 Ack
struct PktItemChemicalAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
Item::ItemPos m_pickkingPos; // 들고 있는 아이템 위치
Item::ItemPos m_targetPos; // 합성 대상 아이템 위치
unsigned short m_wPickkingID; // 들고 있는 아이템 아이디
unsigned char m_cPickkingNum; // 들고 있는 아이템의 남은 갯수
unsigned char m_cResultSize; // 합성 결과물 크기
};
// 업그레이드 아이템
struct PktUgI : public PktBase
{
unsigned long m_dwNPCID; // 대장장이 NPC 아이디
};
// 업그레이드 아이템 Ack (+ 아이템 구조체)
struct PktUgIAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwCurrentGold; // 현재 인벤토리에 남은 금액, 에러시 의미 없음
unsigned char m_cCurrentMineralNum; // 현재 남은 광물 갯수, 에러시 의미 없음.
unsigned char m_cValue; // 업그레이드 추가 스텟
unsigned char m_cSize; // 장비 아이템 크기
};
// 아이템 옵션 이식
struct PktItemOptionGraft : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cAttributeType; // 이식할 옵션 종류
};
// 아이템 옵션 이식 Ack (+ 아이템 구조체)
struct PktItemOptionGraftAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwGold; // 남은 금액
unsigned char m_cSize; // 결과 아이템 크기
};
// 아이템 보상 판매
struct PktItemCompensation : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 아이템 스플릿 요청 (응답 필요)
struct PktSplt : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
// ( Src : 나눌 아이템, Dst : 나누어서 놓을 자리(항상 비어 있어야 함),
// Num : 나눌 아이템 갯수)
};
// 아이템 스플릿 Ack (응답 필요) (+ 가변길이 아이템 구조체 (나누어서 생긴 아이템 정보))
struct PktSpItAck : public PktBase
{
enum PktSpltAckError
{
SERVER_ERROR = 1,
FAIL_SPLIT = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
TakeType m_TakeType; // 아이템 집기 구조체
unsigned char m_cSize; // 아이템 크기
};
// 퀵 슬롯 이동 (응답 필요)
struct PktQSM : public PktBase
{
enum PktQSMError
{
SERVER_ERROR = 1,
FAIL_MOVE = 2
};
TakeType m_TakeType;
unsigned short m_usSkillID;
unsigned char m_cLockCount;
unsigned char m_cSkillLevel;
};
// 스위치 장비
struct PktSwEQ : public PktBase
{
unsigned char m_cType; // 0 : 핸드, 1 : 말
unsigned char m_cSelect; // 선택 핸드 ( 1 = 무기1 & 방패1, 2 = 무기2 & 방패2 )
};
// 교환 명령
struct PktExC : public PktBase
{
enum ExchageCmd
{
EXC_PROPOSE = 0, // 제안
EXC_ACCEPT = 1, // 수락
EXC_REFUSE = 2, // 거절
EXC_OK = 3, // 확인
EXC_CANCEL = 4, // 확인 취소
EXC_EXCHANGE = 5, // 거래 성립
EXC_QUIT = 6, // 거래 취소
EXC_LOCK = 7, // 락
EXC_UNLOCK = 8 // 언락
};
enum PktExCError
{
FAIL_EXCHANGING_CHAR = 2, // 다른 캐릭터와 교환중인 캐릭터에게 교환 신청
FAIL_NOT_ALL_OK = 3, // 양쪽 모두 확인하지 않은 상태에서 거래 성립
FAIL_REJECT = 4, // 거부 옵션이 켜진 상태
FAIL_EXCHANGING_ID = 5 // 수락했을때와 거래성립때에 아이디가 틀릴경우.
};
unsigned long m_dwSenderID; // 보낸이 아이디
unsigned long m_dwRecverID; // 받는이 아이디
unsigned char m_cCmd; // 명령
};
// 교환 아이템 (+ 아이템 구조체)
struct PktExI : public PktBase
{
enum Type
{
Item = 0,
Gold = 1,
Remove = 2
};
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_dwSize; // 아이템 데이터 크기(혹은 돈 양)
Item::ItemPos m_itemPos; // 아이템 위치
unsigned char m_cType; // 아이템 종류(아이템 = 0, 돈 = 1)
unsigned char m_cNum; // 아이템 갯수(stack아이템인 경우, 개수만 보냄)
};
namespace Deposit
{
enum Const { PASSWORD_LENGTH = 4 };
};
// 창고 (GameServer <--> DBAgent)
// 로그인시에, PktDBUpdate를 보낸 후, PktDepositUpdateDB를 여러개 준다.
// 마지막 패킷에 m_bUpdateComplete를 true로 Set해 준다.
// 게임 중에는 게임 서버가 수시로 Update를 한다.
struct PktDepositUpdateDB : public PktDD
{
enum TabFlag
{
ITEM_TAB1 = ( 1 << 0 ),
ITEM_TAB2 = ( 1 << 1 ),
ITEM_TAB3 = ( 1 << 2 ),
ITEM_TAB4 = ( 1 << 3 ),
USED_DEPOSIT = ( 1 << 30), // 0 : 창고 사용 X, 1 : 창고 사용함.
SAVED_PASSWORD = ( 1 << 31) // 0 : NOSAVE 1 : SAVE
};
enum TabNum
{
TAB_12 = 0,
TAB_34 = 1,
};
unsigned long m_dwUID; // 캐릭터 UID
unsigned long m_dwCID; // 캐릭터 CID
unsigned long m_dwTabFlag; // 현재 탭의 구입 상태를 나타내는 bitset
unsigned short m_usDataSize; // 탭(혹은 암호) 데이터 크기. 암호인 경우는 Deposit::PASSWORD_LENGTH와 같아야 한다.
unsigned char m_cTabNum; // password인 경우는 PASSWORD_TABNUM임
bool m_bUpdateComplete; // 업데이트가 완료되는 경우, true로 set.
};
// 창고 (Client <--> GameServer)
struct PktDeposit : public PktDD
{
enum CMD
{
LOGIN = 1, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]~[3]는 password, 그 다음에 암호 저장 여부 1byte (0, 1)
BUY_TAB = 2, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]에 사용할 탭 번호를 넣어 줌
RETURN_TAB = 3, // Ack있음(Ack데이터 없음) (Client<->GameServer) szData[0]에 사용할 탭 번호를 넣어 줌, 아직 구현되지 않음
LOGOUT = 4, // Ack있음 (Client->GameServer) 데이터 없음.
CHANGE_PASS = 5, // Ack있음 (Client->GameServer) szData[0]~[3]는 password. 인증된 상태에서만 가능.
SAVED_PASS = 6, // Ack없음 (GameServer -> Client) 게임 로그인시 줌. szData[0]~[3]는 Gold, [4]는 암호 저장 여부 1byte (0, 1)
PASSWORD = 7, // AgentServer -> GameServer (CID, Password), GameServer -> AgentServer (UID, Password)
GOLD = 8 // AgentServer -> GameServer (CID, Gold), GameServer -> AgentServer (UID, Gold)
};
enum DepositError
{
INSUFFICIENT_MONEY = 2,
AUTH_FAILED = 3,
INVALID_ARGUMENT = 4
};
enum { MIN_DATA_SIZE = Deposit::PASSWORD_LENGTH + 4 };
unsigned char m_cCmd;
char m_szData[MIN_DATA_SIZE];
};
// 복권 결과
struct PktLotteryResult : public PktBase
{
enum PktLRErr
{
FAIL_BLANK = 2 // 존재하지 않는 상품
};
unsigned long m_dwCharID;
unsigned long m_dwSize;
Item::ItemPos m_itemPos;
};
#pragma pack()
#endif

59
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharItemPacketStruct.h Normal file
View File

@@ -0,0 +1,59 @@
#ifndef _CHAR_ITEM_PACKET_STRUCT_H_
#define _CHAR_ITEM_PACKET_STRUCT_H_
#include <DB/DBDefine.h>
#include <Item/ItemStructure.h>
#pragma pack(1)
// 필드 오브젝트 구조체
struct FieldObject
{
enum CheckBit { Gold = 0x80000000 };
unsigned __int64 m_nOID; // 오브젝트 아이디 (몬스터 혹은 Object)
unsigned long m_dwTypeID; // 타입 아이디 (상위 1비트 셋이면 돈)
unsigned short m_usXPos; // 아이템 X위치
unsigned short m_usYPos; // 아이템 Y위치
unsigned short m_usZPos; // 아이템 Z위치
unsigned char m_cNum; // 아이템 수
};
struct TakeType
{
enum TakeSource
{
TS_NONE = 0, TS_EQUIP = 1,
TS_INVEN = 2, TS_QSLOT = 3,
TS_SSLOT = 4, TS_TEMP = 6,
TS_EXTRA = 7, TS_EXCHANGE = 8,
TS_DEPOSIT = 9, TS_STALL = 10,
TS_TEMPINVEN = 11, TS_CAMPSHOP = 12,
TS_ADMIN = 13, TS_MAXTYPE = 14
};
Item::ItemPos m_srcPos;
Item::ItemPos m_dstPos;
unsigned char m_cNum;
TakeType() : m_cNum(0) { }
TakeType(Item::ItemPos srcPos, Item::ItemPos dstPos, unsigned char cNum)
: m_srcPos(srcPos), m_dstPos(dstPos), m_cNum(cNum) { }
};
// 캐스트 오브젝트 구조체 (Cast Object)
struct CastObject
{
POS m_DstPos; // 목적 위치
unsigned long m_dwTargetID; // 타겟 아이디
unsigned short m_wTypeID; // 아이디 ( 돈일경우 금액 )
unsigned char m_cObjectType; // 종류 ( 0 = 캐스트, 어텍 류, 2 = 돈 )
unsigned char m_cObjectLevel; // 레벨
};
#pragma pack()
#endif

124
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharLoginOutPacket.h Normal file
View File

@@ -0,0 +1,124 @@
#ifndef _CHAR_LOGIN_OUT_PACKET_H_
#define _CHAR_LOGIN_OUT_PACKET_H_
// CharLoginOutPacket.h
#include <winsock2.h>
#include <windows.h>
#include <DB/DBDefine.h>
#include <GameGuardLib/ggsrv.h>
#include <Network/Packet/PacketBase.h>
#include "CharLoginOutPacketStruct.h"
// 전방 참조
class CSession;
#pragma pack(1)
typedef struct PktDBUpdate* LPPktDBUpdate;
struct PktDBUpdate : public PktBase
{
unsigned __int64 m_dlItemSerial; // 가장 마지막으로 업데이트한 아이템 시리얼
unsigned long m_dwSessionID; // 세션 ID
unsigned long m_dwUserID; // 유저 ID
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwRequestKey; // DB요청 키
char m_szAccountName[CHAR_INFOST::MAX_ACCOUNT_LEN]; // 접속 계정명
IN_ADDR m_Address; // 주소
unsigned char m_cAdminLevel; // 운영자 레벨
unsigned char m_cAdminFlag;
// WORK_LIST 2.4 계정 국적을 게임서버의 캐릭터가 가지도록 구현
unsigned char m_cAccountNation; // 계정 국적 (추가하면서 패딩값을 삭제했음)
unsigned char m_cNameChangeCount; // 이름 바꿀 수 있는 횟수
unsigned char m_cGuildWarFlag; // 길드 전쟁 참여 플래그
unsigned char m_cRealmWarFlag; // 국가 전쟁 참여 플래그
unsigned char m_cTacticsFlag; // 욥병 플래그.
unsigned char m_cRealmPoint; // 국가 전쟁 훈장공헌 포인트.
unsigned short m_TypeCode; // 업데이트 타입
unsigned short m_usUpdate[DBUpdateData::MAX_UPDATE_DB]; // 업데이트 데이터 크기
unsigned int m_PlayTime; // 게임을 연속 몇분이나 했는지 (중국판을 위한 패킷)
long m_PremiumTime; // 프리미엄 서비스를 위한 정보
int m_PremiumType; // 프리미엄 서비스를 위한 정보
};
// 캐릭터 로그인 (Char Login)
typedef struct PktCLi* LPPktCLi;
struct PktCLi : public PktBase
{
unsigned long m_dwUserID;
unsigned long m_dwCharID;
unsigned long m_dwSessionID;
};
// 캐릭터 로그인 Ack (1 = 서버 에러, 2 = 데이터 얻기 실패)
typedef struct PktCLiAck* LPPktCLiAck;
struct PktCLiAck : public PktBase
{
enum { MAX_ADDRESS_LEN = 16 };
sockaddr_in m_GameServerUDPAddr; // 더 이상 사용하징 않음 (UDP Removed 2004/09/24)
sockaddr_in m_ChatServerTCPAddr; // 더 이상 사용하징 않음 (ChatServer Connection Removed 2004/09/24)
unsigned long m_dwUID;
unsigned long m_dwServerID;
unsigned long m_dwServerTime;
bool m_bPeaceMode; // 반전/전투 모드
bool m_bCheckRelation; // 신청/ 신청 받음 길드 관계 체크
unsigned char m_cNameChangeCount; // 이름 변경 가능한 횟수
unsigned char m_cAdminFlag; // GM 모델 관련.
unsigned char m_cGuildWarFlag; // 길드 전쟁 참여 플래그
unsigned char m_cRealmWarFlag; // 국가 전쟁 참여 플래그
unsigned char m_cRealmPoint; // 국가 전쟁 공헌훈장 포인트.
unsigned char m_cTacticsFlag; // 용병 플레그.
unsigned short m_usUpdate[DBUpdateData::MAX_UPDATE_DB];
unsigned int m_PlayTime; // 게임을 연속 몇분이나 했는지 (중국판을 위한 패킷)
long m_PremiumTime; // 프리미엄 서비스를 위한 정보
int m_PremiumType; // 프리미엄 서비스를 위한 정보
};
typedef struct PktCSAuth* LPPktCSAuth;
struct PktCSAuth : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned long m_AuthCodeType; // 인증코드 타입. 타입에 맞지 않는 값이 있으면 접속 해제. (1혹은 2)
unsigned long m_dwAuthCode; // 인증 코드 (게임 가드)
GG_AUTH_DATA m_AuthCode2; // 인증 코드2 (게임 가드)
};
// 캐릭터 로그아웃 (Char Logout)
typedef struct PktCLo* LPPktCLo;
struct PktCLo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 캐릭터 로그아웃 (Char Logout)
typedef struct PktCLoAck* LPPktCLoAck;
struct PktCLoAck : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
#pragma pack()
#endif

44
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharLoginOutPacketStruct.h Normal file
View File

@@ -0,0 +1,44 @@
#ifndef _CHAR_LOGIN_OUT_PACKET_STRUCT_
#define _CHAR_LOGIN_OUT_PACKET_STRUCT_
#include <DB/DBDefine.h>
namespace DBUpdateData
{
enum UpdateList
{
STATUS_UPDATE = 0,
POSITION_UPDATE = 1,
SKILL_UPDATE = 2,
QUICKSLOT_UPDATE = 3,
SPELL_UPDATE = 4,
ITEM_EQUIP_UPDATE = 5,
ITEM_INVEN_UPDATE = 6,
ITEM_EXTRA_UPDATE = 7,
ITEM_EXCHANGE_UPDATE = 8,
ITEM_TEMPINVEN_UPDATE = 9,
MAX_UPDATE_DB = 10
};
enum UpdateType
{
LOGIN = 0,
LOGOUT = 1,
UPDATE = 2,
ADMIN_LOGIN = 3,
ZONEMOVE = 4,
ABNORMAL_LOGOUT = 5,
MAX_UPDATE_TYPE = 6
};
enum Limit
{
MAX_DBUPDATE_SIZE =
sizeof(CHAR_INFOST) + sizeof(CHAR_POS) + sizeof(SKILL) + sizeof(QUICK) + sizeof(SPELL) +
sizeof(EQUIP) + sizeof(INVEN) + sizeof(EXTRA) + sizeof(EXCHANGE) + sizeof(TEMPINVEN)
};
};
#endif

8
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharMovePacket.cpp Normal file
View File

@@ -0,0 +1,8 @@
#include "stdafx.h"
#include "CharMovePacket.h"
#include "GMMemory.h"
const float CNetworkPos::ms_fToAngle = 180.0f / 3.141592f;
const float CNetworkPos::ms_fToRadian = 3.141592f / 180.0f;
const float CNetworkPos::ms_fPositionDetail = 10.0f;
const float CNetworkPos::ms_fVelocityDetail = 1000.0f;

200
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharMovePacket.h Normal file
View File

@@ -0,0 +1,200 @@
#ifndef _CHAR_MOVE_PACKET_H_
#define _CHAR_MOVE_PACKET_H_
// CharMovePacket.h
#include <winsock2.h>
#include <windows.h>
#include <Network/Packet/PacketBase.h>
#include <DB/DBdefine.h>
#include <cmath>
#pragma pack(1)
class CNetworkPos
{
private:
static const float ms_fToRadian;
static const float ms_fToAngle;
static const float ms_fPositionDetail;
static const float ms_fVelocityDetail;
unsigned short m_usXPos;
unsigned short m_usYPos;
unsigned short m_usZPos;
unsigned char m_cDirection; // 정밀도 - 0~180 (1에 2도)
unsigned char m_cVelocity; // 속도/프레임(1프레임에 움직일 수 있는 최대거리.)
// 속도 = 초당 이동거리 = 1~5미터.
// 프레임 = 최대 60프레임.
// 최대 가능한 속도/프레임 * 1000 = 0 ~ 255
// 속도/프레임 = 0 ~ 0.255미터
// TODO : maximum 10meter/sec
public:
CNetworkPos() : m_usXPos(0), m_usYPos(0), m_usZPos(0), m_cDirection(0), m_cVelocity(0) { }
CNetworkPos(float fXPos, float fYPos, float fZPos, float fDir = 0.0f, float fVel = 0.0f) { Initialize(fXPos, fYPos, fZPos, fDir, fVel); }
CNetworkPos(const POS& pos, float fDir = 0.0f, float fVel = 0.0f) { Initialize(pos.fPointX, pos.fPointY, pos.fPointZ, fDir, fVel); }
void Initialize(float fXPos, float fYPos, float fZPos, float fDir, float fVel);
float GetXPos() const { return static_cast<float>(m_usXPos) / ms_fPositionDetail; }
float GetYPos() const { return static_cast<float>(m_usYPos) / ms_fPositionDetail; }
float GetZPos() const { return static_cast<float>(m_usZPos) / ms_fPositionDetail; }
float GetDirection() const { return static_cast<float>(m_cDirection) * 2 * ms_fToRadian; }
float GetVelocity() const { return static_cast<float>(m_cVelocity) / ms_fVelocityDetail; }
float GetSquaredRange(const CNetworkPos& lhs) const
{
const float xDiff = GetXPos() - lhs.GetXPos();
const float yDiff = GetYPos() - lhs.GetYPos();
const float zDiff = GetZPos() - lhs.GetZPos();
return (xDiff * xDiff) + (yDiff * yDiff) + (zDiff * zDiff);
}
float GetRange(const CNetworkPos& lhs) const { return std::sqrtf(GetSquaredRange(lhs)); }
inline bool operator == (const CNetworkPos& lhs)
{
return (m_usXPos == lhs.m_usXPos && m_usYPos == lhs.m_usYPos && m_usZPos == lhs.m_usZPos
&& m_cDirection == lhs.m_cDirection && m_cVelocity == lhs.m_cVelocity);
}
inline bool operator != (const CNetworkPos& lhs) { return !(*this == lhs); }
};
inline void CNetworkPos::Initialize(float fXPos, float fYPos, float fZPos, float fDir, float fVel)
{
float fbuf;
fbuf = fXPos * ms_fPositionDetail;
m_usXPos = static_cast<unsigned short>(fbuf);
fbuf = fYPos * ms_fPositionDetail;
m_usYPos = static_cast<unsigned short>(fbuf);
fbuf = fZPos * ms_fPositionDetail;
m_usZPos = static_cast<unsigned short>(fbuf);
/*
// float의 소숫점 연산에 오차가 있어 반올림합니다.
m_usXPos = static_cast<unsigned short>(fXPos * ms_fPositionDetail + 0.5f);
m_usYPos = static_cast<unsigned short>(fYPos * ms_fPositionDetail + 0.5f);
m_usZPos = static_cast<unsigned short>(fZPos * ms_fPositionDetail + 0.5f);
*/
float fAngle = fDir * ms_fToAngle;
while (360 <= fAngle) { fAngle -= 360; }
m_cDirection = static_cast<unsigned char>(fAngle/2);
unsigned int nVelocity = static_cast<unsigned int>(fVel * ms_fVelocityDetail);
if(255 < nVelocity) { nVelocity = 255; }
m_cVelocity = static_cast<unsigned char>(nVelocity);
}
// 캐릭터 이동 패킷 Ex (CharMove, TCP)
typedef struct PktMVEx* LPPktMVEx;
struct PktMVEx : public PktBase
{
// CID는 PktBase의 dwServerInfo에 담는다.
CNetworkPos m_NetworkPos;
unsigned char m_cUAct;
unsigned char m_cLAct;
};
/*
Deplicated
// 캐릭터 이동 패킷 (CharMove, UDP)
typedef struct PktMV* LPPktMV;
struct PktMV : public PktBase
{
POS m_Position; // 캐릭터 위치
float m_fDir; // 캐릭터 방향
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwChantEf; // Chant Effect
unsigned long m_dwEnchantEf; // Enchant Effect
unsigned short m_wUAct; // 액션 번호
unsigned short m_wLAct; // 액션 번호
unsigned char m_wLevel; // 캐릭터 레벨
};
// 캐릭터 이동 업데이트 패킷 ( Char Move Update )
typedef struct PktMU* LPPktMU;
struct PktMU : public PktBase
{
POS m_Position; // 위치
float m_fDir; // 방향
unsigned long m_dwTick; // 클라이언트 틱
bool m_bSitMode; // 앉기 (true = 앉아 있음.)
};
// 캐릭터 이동 업데이트 패킷 Ack ( Char Move Update )
typedef struct PktMUAck* LPPktMUAck;
struct PktMUAck : public PktBase
{
unsigned long m_dwTick; // 클라이언트 틱 (처리 시간 퍼포 측정)
unsigned char m_cFlag; // - 플래그 (0 = 이동, 1 = 셀이동)
};
*/
// 소환
typedef struct PktSummon* LPPktSummon;
struct PktSummon : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwTargetID; // 대상 ID
CNetworkPos m_NetworkPos; // 네트워크 위치
};
// 몬스터 움직임 ( Monster Move )
typedef struct PktMM* LPPktMM;
struct PktMM : public PktBase
{
unsigned long m_dwMonID; // 몬스터 아이디
CNetworkPos m_NetworkPos; // 네트워크 위치
unsigned char m_cAct; // 몬스터 행동
unsigned char m_cAniNum; // 몬스터 이동 횟수
};
namespace CellCommand
{
enum Type
{
CELL_MOVE = 0,
CELL_LOGIN = 1,
RESPAWN = 2
};
};
// 캐릭터 셀 로그인 패킷 (Char Cell Login)
typedef struct PktCCLi* LPPktCCLi;
struct PktCCLi : public PktBase
{
unsigned char m_cCmd; // see namespace CellCommand
// 패킷 뒤에 BroadcastInfo::CharInfo::SLoginPhase가 붙어 온다.
};
// 캐릭터 셀 로그아웃 패킷 ( Char Cell Logout )
typedef struct PktCCLo* LPPktCCLo;
struct PktCCLo : public PktBase
{
unsigned long m_dwCharID;
unsigned char m_cCmd; // see namespace CellCommand
};
// 셀 브로드 캐스팅 + Address구조체
typedef struct PktCB PktCB, *LPPktCB;
struct PktCB : public PktBase
{
unsigned char m_cCharacterPhase; // 셀 브로드캐스팅 Phase(캐릭터).
unsigned short m_usBufferSize; // 셀 버퍼 크기
};
#pragma pack()
#endif

106
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharQuestPacket.h Normal file
View File

@@ -0,0 +1,106 @@
#ifndef _CHAR_QUEST_PACKET_H_
#define _CHAR_QUEST_PACKET_H_
// CharQuestPacket.h
#include <Network/Packet/PacketBase.h>
#include <Network/Packet/PacketStruct/DataPacket.h>
#pragma pack(1)
// 퀘스트 시작
typedef struct PktStartQuest* LPPktStartQuest;
struct PktStartQuest : public PktBase
{
enum PktStartQuestError
{
FAIL_NOT_NPC = 2,
FAIL_NOT_HAVE_QUEST = 3,
FAIL_FULL_QUEST = 4,
FAIL_HAS_QUEST = 5,
FAIL_TOO_FAR = 6,
NOT_EXIST_QUEST = 7,
FAIL_TOO_FAR_PARTY = 8,
FAIL_MIN_LEVEL = 9,
FAIL_MAX_LEVEL = 10,
FAIL_WRONG_NATION = 11,
FAIL_WRONG_CLASS = 12,
FAIL_NOT_COMPLETE_PRIOR_QUEST = 13,
FAIL_MIN_FAME = 14,
FAIL_MAX_FAME = 15
};
unsigned long m_dwCharID;
unsigned long m_dwNPCID;
unsigned short m_wQuestID;
};
// 트리거 발동
typedef struct PktOperateTrigger* LPPktOperateTrigger;
struct PktOperateTrigger : public PktBase
{
enum PktOperateTriggerError
{
FAIL_WRONG_QUEST = 2,
FAIL_WRONG_PHASE = 3,
FAIL_WRONG_TRIGGER = 4,
FAIL_EVENT_ERROR = 5,
FAIL_EVENT_GET_ERROR = 6
};
unsigned long m_dwCharID;
unsigned short m_wQuestID;
unsigned char m_cPhase;
unsigned char m_cTriggerKind;
unsigned char m_cTrigger;
unsigned char m_cCount;
};
// 퀘스트 정보 (DB에 세이브/로드, 캐릭터 로긴시)
typedef struct PktQuestDB* LPPktQuestDB;
struct PktQuestDB : public PktDD
{
enum Const
{
MAX_HISTORY_QUEST = 200,
MAX_EXECUTING_QUEST = 20,
MAX_TRIGGER = 10
};
struct ExecutingQuest
{
unsigned short m_wQuestID;
unsigned char m_cPhase;
unsigned char m_cTriggerCount[MAX_TRIGGER];
};
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned short m_wExecuteQuestSize;
unsigned short m_wHistoryQuestSize;
};
// 퀘스트 종료
typedef struct PktEndQuest* LPPktEndQuest;
struct PktEndQuest : public PktBase
{
unsigned long m_dwCharID;
unsigned short m_wQuestID;
bool m_bSave;
};
typedef struct PktCancelQuest* LPPktCancelQuest;
struct PktCancelQuest : public PktBase
{
enum PktOperateTriggerError
{
FAIL_NOT_HAVE_QUEST = 2,
FAIL_DISABLE_CANCEL = 3
};
unsigned long m_dwCharID;
unsigned short m_wQuestID;
};
#pragma pack()
#endif

281
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharStatusPacket.h Normal file
View File

@@ -0,0 +1,281 @@
#ifndef _CHAR_STATUS_PACKET_H_
#define _CHAR_STATUS_PACKET_H_
// CharStatusPacket.h
#include <Network/Packet/PacketBase.h>
#include <DB/DBdefine.h>
#include <Item/ItemStructure.h>
#include "CharStatusPacketStruct.h"
#pragma pack(1)
// 캐릭터 자살
typedef struct PktSC* LPPktSC;
struct PktSC : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 캐릭터 자살 Ack
typedef struct PktSCAck PktSCAck, *LPPktSCAck;
struct PktSCAck : public PktBase
{
POS m_Pos;
unsigned long m_dwCharID; // 캐릭터 아이디
};
// 바인드 포지션
typedef struct PktBP* LPPktBP;
struct PktBP : public PktBase
{
enum PktBPCmd
{
BP_SAVE_POSITION = 0,
BP_WARP = 1,
BP_RECALL = 2
};
POS m_Pos; // 바인드할 위치
char m_cZone; // 바인드할 존
unsigned long m_dwNPCID; // 바인드할 NPC ID
unsigned char m_cCmd; // 포지션 명령 (0 = 세이브 위치, 1 = 위치 이동)
};
// 레벨업
typedef struct PktLU* LPPktLU;
struct PktLU : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cLevel; // 레벨
};
// 레벨업 정보
typedef struct PktLUInfo* LPPktLUInfo;
struct PktLUInfo : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned char m_cLevel; // 캐릭터 레벨
};
// 스탯 초기화
typedef struct PktSR* LPPktSR;
struct PktSR : public PktBase
{
ChState m_State;
};
// 스탯 초기화
typedef struct PktSRAck* LPPktSRAck;
struct PktSRAck : public PktBase
{
enum PktSRAckErr
{
FAIL_NO_CHANCE = 2
};
ChState m_State;
SKILL m_Skill;
};
// 스테이터스 재분배
typedef struct PktSRT* LPPktSRT;
struct PktSRT : public PktBase
{
ChState m_State;
Item::ItemPos m_ItemPos; // 망각의 돌 위치
};
// 스테이터스 재분배 Ack
typedef struct PktSRTAck* LPPktSRTAck;
struct PktSRTAck : public PktBase
{
enum PktSRTAckErr
{
FAIL_INVALID_IP = 2, // 재분배 할 수 있는 포인트를 초과하여 재분배하려 한 경우
FAIL_NO_ITEM = 3, // 요청한 위치에 아이템(망각의 돌)이 없음 (혹은 갯수가 이상하거나 서버에서 아이템 제거에 실패한 경우)
FAIL_INVALID_ITEM = 4, // 요청한 위치에 있는 아이템이 올바른 아이템(망각의 돌)이 아닌 경우
FAIL_NOT_ENOUGH_GOLD = 5, // 금액 부족
FAIL_INVALID_STATUS = 6 // 재분배된 스탯에 문제가 있는 경우 (총 IP가 맞지 않거나 클래스 최소 스탯에 못 미치는 경우)
};
enum Const
{
MAX_STATUS_RETRAIN = 800
};
ChState m_State;
SKILL m_Skill;
Item::ItemPos m_ItemPos; // 망각의 돌 위치
unsigned long m_dwGold; // 소비 금액
};
// 능력치 증가
typedef struct PktIP* LPPktIP;
struct PktIP : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned char m_cStateType; // 능력치 타입
};
// 능력치 증가 Ack
typedef struct PktIPAck* LPPktIPAck;
struct PktIPAck : public PktBase
{
ChState m_State;
unsigned long m_dwCharID; // 캐릭터 ID
};
// 클래스 업그레이드
typedef struct PktCU* LPPktCU;
struct PktCU : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 ID
unsigned char m_cClass; // 클래스 번호
};
// 클래스 업그레이드 Ack
typedef struct PktCUAck* LPPktCUAck;
struct PktCUAck : public PktBase
{
ChState m_State; // 캐릭터 상태
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwFame; // 명성
unsigned char m_cLevel; // 레벨
unsigned char m_cClass; // 클래스 번호
};
// 액스트라 이벤트
// edith 2009.09.05 신규 이벤트 제작부분
typedef struct PktExtraEvent* LPPktExtraEvent;
struct PktExtraEvent : public PktBase
{
enum PktExtraEventErr
{
EVENT_NONE = 2, // 처리되지 않는 이벤트
EVENT_CLEAR = 3, // 클리어했다.
FAIL_EVENT = 4, // 이벤트 실패
FAIL_REWARD = 5, // 이벤트 보상 실패
};
unsigned long m_dwUserID; // 유저 ID
unsigned long m_dwCharID; // 캐릭터 ID
unsigned long m_dwEventID; // 이벤트 ID
unsigned long m_dwValue1; // 추가값
unsigned long m_dwValue2; // 추가값
};
// 스킬 (생성/지우기/락/락해제)
typedef struct PktSk* LPPktSk;
struct PktSk : public PktBase
{
enum PktSkError
{
// TODO : 겹치는 상수들은 클라이언트와 상의하여 유니크하게 수정합시다.
// 스킬 관련 공통 에러
FAIL_NOT_SKILL = 2,
FAIL_ERASE_CLASS_SKILL = 5, // 클래스 스킬 삭제
FAIL_NO_ITEM = 6, // 요청한 위치에 아이템(망각의 돌)이 없음 (혹은 갯수가 이상하거나 서버에서 아이템 제거에 실패한 경우)
FAIL_INVALID_ITEM = 7, // 요청한 위치에 있는 아이템이 올바른 아이템(망각의 돌)이 아닌 경우
// 생성 에러
FAIL_MAX_LEVEL = 2, // 최대 레벨임 (락해야함)
FAIL_NOT_CURRENT_LOCK_COUNT = 3, // 익힐 단계가 아닌 스킬
FAIL_NOT_ENOUGH_SLOT = 4, // 슬롯 부족
FAIL_NOT_CURRENT_CLASS = 5, // 해당 클래스가 아님
FAIL_NOT_ENOUGH_STATUS = 6, // 스탯이 모자람
FAIL_NOT_ENOUGH_SKILL_POINT = 7, // 스킬 포인트 부족
// 지우기 에러
FAIL_NON_LEVEL = 3, // 레벨이 없음
FAIL_ALREADY_LOCK = 4, // 이미 락한 스킬
// 락 에러
FAIL_FULL_LOCK = 3, // 락을 모두한 스킬
FAIL_NOT_ENOUGH_LEVEL = 4, // 레벨이 다 차지않은 스킬
// 락 해제 에러
FAIL_NON_LOCK = 3, // 락하지 않은 스킬
FAIL_FIFTHSKILL_UNLOCK = 4 // 5단계 스킬은 지우기로 4단계로 내릴수 없다.
};
unsigned long m_dwCharID; // 캐릭터 ID
unsigned short m_wSkill; // 스킬 번호
unsigned char m_cIndex; // 스킬 위치
unsigned char m_cSkillLevel; // 스킬 레벨
Item::ItemPos m_ItemPos; // 망각의 돌 위치
};
/*
// 스킬 락 해제
typedef struct PktSkUL* LPPktSkUL;
struct PktSkUL : public PktSk
{
Item::ItemPos m_itemPos; // 망각의 돌 위치 PktSk에 정의
};
*/
// 스킬 락 해제 Ack
typedef struct PktSkULAck* LPPktSkULAck;
struct PktSkULAck : public PktSk
{
unsigned long m_dwGold; // 소비 금액
// Item::ItemPos m_itemPos; // 망각의 돌 위치 PktSk에 정의
};
// HP 리젠 패킷 ( Char HP Regen )
typedef struct PktHP* LPPktHP;
struct PktHP : public PktBase
{
unsigned long m_dwCharID; // 캐릭터 아이디
unsigned short m_sHP; // 현재 hp
unsigned short m_sMP; // 현재 mp
};
// 정보 요청 ( Require Info )
// - P2P로 다른 클라이언트에게 직접 보낼 시에는 주소내용이 추가 되며,
// 해당 클라이언트 아이디는 보내는 이의 캐릭터 아이디가 되겠다.
typedef struct PktRI* LPPktRI;
struct PktRI : public PktBase
{
SOCKADDR_IN m_PublicAddress;
SOCKADDR_IN m_PrivateAddress;
unsigned long m_dwCharID; // 해당 캐릭터 아이디
unsigned char m_cCmd; // 커맨드 (0 : HP, MP 정보, 1 : UDP 주소, 2 : 모양)
};
// 캐릭터 겉모습 정보
typedef struct PktSI* LPPktSI;
struct PktSI : public PktBase
{
enum { MAX_STALL_NAME_LEN = 32 };
enum WEAPON_HAND
{
WEAPON_HAND1 = 1,
WEAPON_HAND2 = 2
};
CHAR_VIEW m_CharView; // 캐릭터 겉모습
unsigned long m_dwStatusFlag; // 캐릭터에 걸려 있는 chant, enchant Flag
bool m_bPeace; // 반전 모드
unsigned char m_cSelectedHands; // 현재 사용중인 손 (1 = 무기1 & 방패1, 2 = 무기2 & 방패2)
char m_StallName[MAX_STALL_NAME_LEN]; // 노점상 이름
};
// 엘리트 보너스
typedef struct PktEB* LPPktEB;
struct PktEB : public PktBase
{
char m_cEliteBonus; // 엘리트 보너스
};
#pragma pack()
#endif

20
Server/RylServerProject/RylGameLibrary/Network/Packet/PacketStruct/CharStatusPacketStruct.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef _CHAR_STATUS_PACKET_STRUCT_H_
#define _CHAR_STATUS_PACKET_STRUCT_H_
#pragma pack(1)
// 캐릭터 능력치
typedef struct ChState* LPChState;
struct ChState
{
unsigned short m_wIP;
unsigned short m_wSTR;
unsigned short m_wDEX;
unsigned short m_wCON;
unsigned short m_wINT;
unsigned short m_wWIS;
};
#pragma pack()
#endif