forked from metin2/server
2316 lines
41 KiB
C++
2316 lines
41 KiB
C++
#ifndef __INC_PACKET_H__
|
|
#define __INC_PACKET_H__
|
|
|
|
enum
|
|
{
|
|
HEADER_CG_HANDSHAKE = 0xff,
|
|
HEADER_CG_PONG = 0xfe,
|
|
HEADER_CG_TIME_SYNC = 0xfc,
|
|
|
|
HEADER_CG_LOGIN = 1,
|
|
HEADER_CG_ATTACK = 2,
|
|
HEADER_CG_CHAT = 3,
|
|
HEADER_CG_CHARACTER_CREATE = 4,
|
|
HEADER_CG_CHARACTER_DELETE = 5,
|
|
HEADER_CG_CHARACTER_SELECT = 6,
|
|
HEADER_CG_MOVE = 7,
|
|
HEADER_CG_SYNC_POSITION = 8,
|
|
HEADER_CG_ENTERGAME = 10,
|
|
|
|
HEADER_CG_ITEM_USE = 11,
|
|
HEADER_CG_ITEM_DROP = 12,
|
|
HEADER_CG_ITEM_MOVE = 13,
|
|
HEADER_CG_ITEM_PICKUP = 15,
|
|
|
|
HEADER_CG_QUICKSLOT_ADD = 16,
|
|
HEADER_CG_QUICKSLOT_DEL = 17,
|
|
HEADER_CG_QUICKSLOT_SWAP = 18,
|
|
HEADER_CG_WHISPER = 19,
|
|
HEADER_CG_ITEM_DROP2 = 20,
|
|
|
|
HEADER_CG_ON_CLICK = 26,
|
|
HEADER_CG_EXCHANGE = 27,
|
|
HEADER_CG_CHARACTER_POSITION = 28,
|
|
HEADER_CG_SCRIPT_ANSWER = 29,
|
|
HEADER_CG_QUEST_INPUT_STRING = 30,
|
|
HEADER_CG_QUEST_CONFIRM = 31,
|
|
|
|
HEADER_CG_SHOP = 50,
|
|
HEADER_CG_FLY_TARGETING = 51,
|
|
HEADER_CG_USE_SKILL = 52,
|
|
HEADER_CG_ADD_FLY_TARGETING = 53,
|
|
HEADER_CG_SHOOT = 54,
|
|
HEADER_CG_MYSHOP = 55,
|
|
|
|
HEADER_CG_ITEM_USE_TO_ITEM = 60,
|
|
HEADER_CG_TARGET = 61,
|
|
|
|
HEADER_CG_TEXT = 64, // @ 로 시작되면 텍스트를 파싱한다.
|
|
HEADER_CG_WARP = 65,
|
|
HEADER_CG_SCRIPT_BUTTON = 66,
|
|
HEADER_CG_MESSENGER = 67,
|
|
|
|
HEADER_CG_MALL_CHECKOUT = 69,
|
|
HEADER_CG_SAFEBOX_CHECKIN = 70, // 아이템을 창고에 넣??는다.
|
|
HEADER_CG_SAFEBOX_CHECKOUT = 71, // 아이템을 창고로 부터 빼온다.
|
|
|
|
HEADER_CG_PARTY_INVITE = 72,
|
|
HEADER_CG_PARTY_INVITE_ANSWER = 73,
|
|
HEADER_CG_PARTY_REMOVE = 74,
|
|
HEADER_CG_PARTY_SET_STATE = 75,
|
|
HEADER_CG_PARTY_USE_SKILL = 76,
|
|
HEADER_CG_SAFEBOX_ITEM_MOVE = 77,
|
|
HEADER_CG_PARTY_PARAMETER = 78,
|
|
|
|
HEADER_CG_GUILD = 80,
|
|
HEADER_CG_ANSWER_MAKE_GUILD = 81,
|
|
|
|
HEADER_CG_FISHING = 82,
|
|
|
|
HEADER_CG_ITEM_GIVE = 83,
|
|
|
|
HEADER_CG_EMPIRE = 90,
|
|
|
|
HEADER_CG_REFINE = 96,
|
|
|
|
HEADER_CG_MARK_LOGIN = 100,
|
|
HEADER_CG_MARK_CRCLIST = 101,
|
|
HEADER_CG_MARK_UPLOAD = 102,
|
|
HEADER_CG_MARK_IDXLIST = 104,
|
|
|
|
HEADER_CG_CHANGE_NAME = 106,
|
|
HEADER_CG_LOGIN2 = 109,
|
|
HEADER_CG_DUNGEON = 110,
|
|
HEADER_CG_LOGIN3 = 111,
|
|
|
|
HEADER_CG_GUILD_SYMBOL_UPLOAD = 112,
|
|
HEADER_CG_SYMBOL_CRC = 113,
|
|
|
|
// SCRIPT_SELECT_ITEM
|
|
HEADER_CG_SCRIPT_SELECT_ITEM = 114,
|
|
// END_OF_SCRIPT_SELECT_ITEM
|
|
|
|
// HEADER_CG_ROULETTE = 200,
|
|
// HEADER_CG_RUNUP_MATRIX_ANSWER = 201,
|
|
|
|
//NOTE : 이런 개XXX 정말 이거 Packet설계한 사람은 누구냐. 이렇게 코딩하고 밥이 넘어가나.
|
|
//enum을 별도로 구별을 하던가. 아님 namepsace로 구별을 하던가..
|
|
//정말 packet generator까지는 바라지도 않는다. 이런 씨XX
|
|
//이러다가 숫자 겹치면 누가 책임지는데???
|
|
|
|
HEADER_CG_DRAGON_SOUL_REFINE = 205,
|
|
HEADER_CG_STATE_CHECKER = 206,
|
|
|
|
HEADER_CG_CLIENT_VERSION = 0xfd,
|
|
HEADER_CG_CLIENT_VERSION2 = 0xf1,
|
|
|
|
/********************************************************/
|
|
HEADER_GC_TIME_SYNC = 0xfc,
|
|
HEADER_GC_PHASE = 0xfd,
|
|
HEADER_GC_HANDSHAKE = 0xff,
|
|
|
|
HEADER_GC_CHARACTER_ADD = 1,
|
|
HEADER_GC_CHARACTER_DEL = 2,
|
|
HEADER_GC_MOVE = 3,
|
|
HEADER_GC_CHAT = 4,
|
|
HEADER_GC_SYNC_POSITION = 5,
|
|
|
|
HEADER_GC_LOGIN_SUCCESS = 6,
|
|
HEADER_GC_LOGIN_SUCCESS_NEWSLOT = 32,
|
|
HEADER_GC_LOGIN_FAILURE = 7,
|
|
|
|
HEADER_GC_CHARACTER_CREATE_SUCCESS = 8,
|
|
HEADER_GC_CHARACTER_CREATE_FAILURE = 9,
|
|
HEADER_GC_CHARACTER_DELETE_SUCCESS = 10,
|
|
HEADER_GC_CHARACTER_DELETE_WRONG_SOCIAL_ID = 11,
|
|
|
|
HEADER_GC_ATTACK = 12,
|
|
HEADER_GC_STUN = 13,
|
|
HEADER_GC_DEAD = 14,
|
|
|
|
HEADER_GC_MAIN_CHARACTER_OLD = 15,
|
|
HEADER_GC_CHARACTER_POINTS = 16,
|
|
HEADER_GC_CHARACTER_POINT_CHANGE = 17,
|
|
HEADER_GC_CHANGE_SPEED = 18,
|
|
HEADER_GC_CHARACTER_UPDATE = 19,
|
|
HEADER_GC_CHARACTER_UPDATE_NEW = 24,
|
|
|
|
HEADER_GC_ITEM_DEL = 20,
|
|
HEADER_GC_ITEM_SET = 21,
|
|
HEADER_GC_ITEM_USE = 22,
|
|
HEADER_GC_ITEM_DROP = 23,
|
|
HEADER_GC_ITEM_UPDATE = 25,
|
|
|
|
HEADER_GC_ITEM_GROUND_ADD = 26,
|
|
HEADER_GC_ITEM_GROUND_DEL = 27,
|
|
|
|
HEADER_GC_QUICKSLOT_ADD = 28,
|
|
HEADER_GC_QUICKSLOT_DEL = 29,
|
|
HEADER_GC_QUICKSLOT_SWAP = 30,
|
|
|
|
HEADER_GC_ITEM_OWNERSHIP = 31,
|
|
|
|
HEADER_GC_WHISPER = 34,
|
|
|
|
HEADER_GC_MOTION = 36,
|
|
HEADER_GC_PARTS = 37,
|
|
|
|
HEADER_GC_SHOP = 38,
|
|
HEADER_GC_SHOP_SIGN = 39,
|
|
|
|
HEADER_GC_DUEL_START = 40,
|
|
HEADER_GC_PVP = 41,
|
|
HEADER_GC_EXCHANGE = 42,
|
|
HEADER_GC_CHARACTER_POSITION = 43,
|
|
|
|
HEADER_GC_PING = 44,
|
|
HEADER_GC_SCRIPT = 45,
|
|
HEADER_GC_QUEST_CONFIRM = 46,
|
|
|
|
HEADER_GC_MOUNT = 61,
|
|
HEADER_GC_OWNERSHIP = 62,
|
|
HEADER_GC_TARGET = 63,
|
|
|
|
HEADER_GC_WARP = 65,
|
|
|
|
HEADER_GC_ADD_FLY_TARGETING = 69,
|
|
HEADER_GC_CREATE_FLY = 70,
|
|
HEADER_GC_FLY_TARGETING = 71,
|
|
HEADER_GC_SKILL_LEVEL_OLD = 72,
|
|
HEADER_GC_SKILL_LEVEL = 76,
|
|
|
|
HEADER_GC_MESSENGER = 74,
|
|
HEADER_GC_GUILD = 75,
|
|
|
|
HEADER_GC_PARTY_INVITE = 77,
|
|
HEADER_GC_PARTY_ADD = 78,
|
|
HEADER_GC_PARTY_UPDATE = 79,
|
|
HEADER_GC_PARTY_REMOVE = 80,
|
|
HEADER_GC_QUEST_INFO = 81,
|
|
HEADER_GC_REQUEST_MAKE_GUILD = 82,
|
|
HEADER_GC_PARTY_PARAMETER = 83,
|
|
|
|
HEADER_GC_SAFEBOX_SET = 85,
|
|
HEADER_GC_SAFEBOX_DEL = 86,
|
|
HEADER_GC_SAFEBOX_WRONG_PASSWORD = 87,
|
|
HEADER_GC_SAFEBOX_SIZE = 88,
|
|
|
|
HEADER_GC_FISHING = 89,
|
|
|
|
HEADER_GC_EMPIRE = 90,
|
|
|
|
HEADER_GC_PARTY_LINK = 91,
|
|
HEADER_GC_PARTY_UNLINK = 92,
|
|
|
|
HEADER_GC_REFINE_INFORMATION_OLD = 95,
|
|
|
|
HEADER_GC_VIEW_EQUIP = 99,
|
|
|
|
HEADER_GC_MARK_BLOCK = 100,
|
|
HEADER_GC_MARK_IDXLIST = 102,
|
|
|
|
HEADER_GC_TIME = 106,
|
|
HEADER_GC_CHANGE_NAME = 107,
|
|
|
|
HEADER_GC_DUNGEON = 110,
|
|
|
|
HEADER_GC_WALK_MODE = 111,
|
|
HEADER_GC_SKILL_GROUP = 112,
|
|
HEADER_GC_MAIN_CHARACTER = 113,
|
|
|
|
// HEADER_GC_USE_POTION = 114,
|
|
HEADER_GC_SEPCIAL_EFFECT = 114,
|
|
|
|
HEADER_GC_NPC_POSITION = 115,
|
|
|
|
HEADER_GC_MATRIX_CARD = 116,
|
|
HEADER_GC_LOGIN_KEY = 118,
|
|
HEADER_GC_REFINE_INFORMATION = 119,
|
|
HEADER_GC_CHANNEL = 121,
|
|
|
|
// 122 HEADER_GC_MALL_OPEN
|
|
HEADER_GC_TARGET_UPDATE = 123,
|
|
HEADER_GC_TARGET_DELETE = 124,
|
|
HEADER_GC_TARGET_CREATE = 125,
|
|
|
|
HEADER_GC_AFFECT_ADD = 126,
|
|
HEADER_GC_AFFECT_REMOVE = 127,
|
|
|
|
HEADER_GC_MALL_OPEN = 122,
|
|
HEADER_GC_MALL_SET = 128,
|
|
HEADER_GC_MALL_DEL = 129,
|
|
|
|
HEADER_GC_LAND_LIST = 130,
|
|
HEADER_GC_LOVER_INFO = 131,
|
|
HEADER_GC_LOVE_POINT_UPDATE = 132,
|
|
|
|
HEADER_GC_SYMBOL_DATA = 133,
|
|
|
|
// MINING
|
|
HEADER_GC_DIG_MOTION = 134,
|
|
// END_OF_MINING
|
|
|
|
HEADER_GC_DAMAGE_INFO = 135,
|
|
HEADER_GC_CHAR_ADDITIONAL_INFO = 136,
|
|
|
|
// SUPPORT_BGM
|
|
HEADER_GC_MAIN_CHARACTER3_BGM = 137,
|
|
HEADER_GC_MAIN_CHARACTER4_BGM_VOL = 138,
|
|
// END_OF_SUPPORT_BGM
|
|
|
|
HEADER_GC_AUTH_SUCCESS = 150,
|
|
|
|
HEADER_GC_PANAMA_PACK = 151,
|
|
|
|
//HYBRID CRYPT
|
|
HEADER_GC_HYBRIDCRYPT_KEYS = 152,
|
|
HEADER_GC_HYBRIDCRYPT_SDB = 153, // SDB means Supplmentary Data Blocks
|
|
//HYBRID CRYPT
|
|
|
|
// ROULETTE
|
|
HEADER_GC_ROULETTE = 200,
|
|
// END_ROULETTE
|
|
//
|
|
|
|
HEADER_GC_SPECIFIC_EFFECT = 208,
|
|
|
|
HEADER_GC_DRAGON_SOUL_REFINE = 209,
|
|
HEADER_GC_RESPOND_CHANNELSTATUS = 210,
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HEADER_GG_LOGIN = 1,
|
|
HEADER_GG_LOGOUT = 2,
|
|
HEADER_GG_RELAY = 3,
|
|
HEADER_GG_NOTICE = 4,
|
|
HEADER_GG_SHUTDOWN = 5,
|
|
HEADER_GG_GUILD = 6,
|
|
HEADER_GG_DISCONNECT = 7, // 누군가의 접속을 강제로 끊을 때
|
|
HEADER_GG_SHOUT = 8,
|
|
HEADER_GG_SETUP = 9,
|
|
HEADER_GG_MESSENGER_ADD = 10,
|
|
HEADER_GG_MESSENGER_REMOVE = 11,
|
|
HEADER_GG_FIND_POSITION = 12,
|
|
HEADER_GG_WARP_CHARACTER = 13,
|
|
HEADER_GG_MESSENGER_MOBILE = 14,
|
|
HEADER_GG_GUILD_WAR_ZONE_MAP_INDEX = 15,
|
|
HEADER_GG_TRANSFER = 16,
|
|
HEADER_GG_XMAS_WARP_SANTA = 17,
|
|
HEADER_GG_XMAS_WARP_SANTA_REPLY = 18,
|
|
HEADER_GG_RELOAD_CRC_LIST = 19,
|
|
HEADER_GG_LOGIN_PING = 20,
|
|
HEADER_GG_CHECK_CLIENT_VERSION = 21,
|
|
HEADER_GG_BLOCK_CHAT = 22,
|
|
|
|
HEADER_GG_BLOCK_EXCEPTION = 24,
|
|
HEADER_GG_SIEGE = 25,
|
|
HEADER_GG_MONARCH_NOTICE = 26,
|
|
HEADER_GG_MONARCH_TRANSFER = 27,
|
|
HEADER_GG_PCBANG_UPDATE = 28,
|
|
|
|
HEADER_GG_CHECK_AWAKENESS = 29,
|
|
};
|
|
|
|
#pragma pack(1)
|
|
typedef struct SPacketGGSetup
|
|
{
|
|
BYTE bHeader;
|
|
WORD wPort;
|
|
BYTE bChannel;
|
|
} TPacketGGSetup;
|
|
|
|
typedef struct SPacketGGLogin
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
DWORD dwPID;
|
|
BYTE bEmpire;
|
|
LONG lMapIndex;
|
|
BYTE bChannel;
|
|
} TPacketGGLogin;
|
|
|
|
typedef struct SPacketGGLogout
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
} TPacketGGLogout;
|
|
|
|
typedef struct SPacketGGRelay
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
LONG lSize;
|
|
} TPacketGGRelay;
|
|
|
|
typedef struct SPacketGGNotice
|
|
{
|
|
BYTE bHeader;
|
|
LONG lSize;
|
|
} TPacketGGNotice;
|
|
|
|
typedef struct SPacketGGMonarchNotice
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bEmpire;
|
|
LONG lSize;
|
|
} TPacketGGMonarchNotice;
|
|
|
|
//FORKED_ROAD
|
|
typedef struct SPacketGGForkedMapInfo
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bPass;
|
|
BYTE bSungzi;
|
|
} TPacketGGForkedMapInfo;
|
|
//END_FORKED_ROAD
|
|
typedef struct SPacketGGShutdown
|
|
{
|
|
BYTE bHeader;
|
|
} TPacketGGShutdown;
|
|
|
|
typedef struct SPacketGGGuild
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bSubHeader;
|
|
DWORD dwGuild;
|
|
} TPacketGGGuild;
|
|
|
|
enum
|
|
{
|
|
GUILD_SUBHEADER_GG_CHAT,
|
|
GUILD_SUBHEADER_GG_SET_MEMBER_COUNT_BONUS,
|
|
};
|
|
|
|
typedef struct SPacketGGGuildChat
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bSubHeader;
|
|
DWORD dwGuild;
|
|
char szText[CHAT_MAX_LEN + 1];
|
|
} TPacketGGGuildChat;
|
|
|
|
typedef struct SPacketGGParty
|
|
{
|
|
BYTE header;
|
|
BYTE subheader;
|
|
DWORD pid;
|
|
DWORD leaderpid;
|
|
} TPacketGGParty;
|
|
|
|
enum
|
|
{
|
|
PARTY_SUBHEADER_GG_CREATE,
|
|
PARTY_SUBHEADER_GG_DESTROY,
|
|
PARTY_SUBHEADER_GG_JOIN,
|
|
PARTY_SUBHEADER_GG_QUIT,
|
|
};
|
|
|
|
typedef struct SPacketGGDisconnect
|
|
{
|
|
BYTE bHeader;
|
|
char szLogin[LOGIN_MAX_LEN + 1];
|
|
} TPacketGGDisconnect;
|
|
|
|
typedef struct SPacketGGShout
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bEmpire;
|
|
char szText[CHAT_MAX_LEN + 1];
|
|
} TPacketGGShout;
|
|
|
|
typedef struct SPacketGGXmasWarpSanta
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bChannel;
|
|
LONG lMapIndex;
|
|
} TPacketGGXmasWarpSanta;
|
|
|
|
typedef struct SPacketGGXmasWarpSantaReply
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bChannel;
|
|
} TPacketGGXmasWarpSantaReply;
|
|
|
|
typedef struct SMessengerData
|
|
{
|
|
char szMobile[MOBILE_MAX_LEN + 1];
|
|
} TMessengerData;
|
|
|
|
typedef struct SPacketGGMessenger
|
|
{
|
|
BYTE bHeader;
|
|
char szAccount[CHARACTER_NAME_MAX_LEN + 1];
|
|
char szCompanion[CHARACTER_NAME_MAX_LEN + 1];
|
|
} TPacketGGMessenger;
|
|
|
|
typedef struct SPacketGGMessengerMobile
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
char szMobile[MOBILE_MAX_LEN + 1];
|
|
} TPacketGGMessengerMobile;
|
|
|
|
typedef struct SPacketGGFindPosition
|
|
{
|
|
BYTE header;
|
|
DWORD dwFromPID; // 저 위치로 워프하려는 사람
|
|
DWORD dwTargetPID; // 찾는 사람
|
|
} TPacketGGFindPosition;
|
|
|
|
typedef struct SPacketGGWarpCharacter
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
LONG x;
|
|
LONG y;
|
|
} TPacketGGWarpCharacter;
|
|
|
|
// HEADER_GG_GUILD_WAR_ZONE_MAP_INDEX = 15,
|
|
|
|
typedef struct SPacketGGGuildWarMapIndex
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwGuildID1;
|
|
DWORD dwGuildID2;
|
|
LONG lMapIndex;
|
|
} TPacketGGGuildWarMapIndex;
|
|
|
|
typedef struct SPacketGGTransfer
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
LONG lX, lY;
|
|
} TPacketGGTransfer;
|
|
|
|
typedef struct SPacketGGLoginPing
|
|
{
|
|
BYTE bHeader;
|
|
char szLogin[LOGIN_MAX_LEN + 1];
|
|
} TPacketGGLoginPing;
|
|
|
|
typedef struct SPacketGGBlockChat
|
|
{
|
|
BYTE bHeader;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
LONG lBlockDuration;
|
|
} TPacketGGBlockChat;
|
|
|
|
/* 클라이언트 측에서 보내는 패킷 */
|
|
|
|
typedef struct command_text
|
|
{
|
|
BYTE bHeader;
|
|
} TPacketCGText;
|
|
|
|
/* 로그인 (1) */
|
|
typedef struct command_handshake
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwHandshake;
|
|
DWORD dwTime;
|
|
LONG lDelta;
|
|
} TPacketCGHandshake;
|
|
|
|
typedef struct command_login
|
|
{
|
|
BYTE header;
|
|
char login[LOGIN_MAX_LEN + 1];
|
|
char passwd[PASSWD_MAX_LEN + 1];
|
|
} TPacketCGLogin;
|
|
|
|
typedef struct command_login2
|
|
{
|
|
BYTE header;
|
|
char login[LOGIN_MAX_LEN + 1];
|
|
DWORD dwLoginKey;
|
|
DWORD adwClientKey[4];
|
|
} TPacketCGLogin2;
|
|
|
|
typedef struct command_login3
|
|
{
|
|
BYTE header;
|
|
char login[LOGIN_MAX_LEN + 1];
|
|
char passwd[PASSWD_MAX_LEN + 1];
|
|
DWORD adwClientKey[4];
|
|
} TPacketCGLogin3;
|
|
|
|
typedef struct command_matrix_card
|
|
{
|
|
BYTE bHeader;
|
|
char szAnswer[MATRIX_ANSWER_MAX_LEN + 1];
|
|
} TPacketCGMatrixCard;
|
|
|
|
typedef struct packet_matrix_card
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwRows;
|
|
DWORD dwCols;
|
|
} TPacketGCMatrixCard;
|
|
|
|
typedef struct packet_login_key
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwLoginKey;
|
|
} TPacketGCLoginKey;
|
|
|
|
typedef struct command_player_select
|
|
{
|
|
BYTE header;
|
|
BYTE index;
|
|
} TPacketCGPlayerSelect;
|
|
|
|
typedef struct command_player_delete
|
|
{
|
|
BYTE header;
|
|
BYTE index;
|
|
char private_code[8];
|
|
} TPacketCGPlayerDelete;
|
|
|
|
typedef struct command_player_create
|
|
{
|
|
BYTE header;
|
|
BYTE index;
|
|
char name[CHARACTER_NAME_MAX_LEN + 1];
|
|
WORD job;
|
|
BYTE shape;
|
|
BYTE Con;
|
|
BYTE Int;
|
|
BYTE Str;
|
|
BYTE Dex;
|
|
} TPacketCGPlayerCreate;
|
|
|
|
typedef struct command_player_create_success
|
|
{
|
|
BYTE header;
|
|
BYTE bAccountCharacterIndex;
|
|
TSimplePlayer player;
|
|
} TPacketGCPlayerCreateSuccess;
|
|
|
|
// 공격
|
|
typedef struct command_attack
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bType;
|
|
DWORD dwVID;
|
|
BYTE bCRCMagicCubeProcPiece;
|
|
BYTE bCRCMagicCubeFilePiece;
|
|
} TPacketCGAttack;
|
|
|
|
enum EMoveFuncType
|
|
{
|
|
FUNC_WAIT,
|
|
FUNC_MOVE,
|
|
FUNC_ATTACK,
|
|
FUNC_COMBO,
|
|
FUNC_MOB_SKILL,
|
|
_FUNC_SKILL,
|
|
FUNC_MAX_NUM,
|
|
FUNC_SKILL = 0x80,
|
|
};
|
|
|
|
// 이동
|
|
typedef struct command_move
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bFunc;
|
|
BYTE bArg;
|
|
BYTE bRot;
|
|
LONG lX;
|
|
LONG lY;
|
|
DWORD dwTime;
|
|
} TPacketCGMove;
|
|
|
|
typedef struct command_sync_position_element
|
|
{
|
|
DWORD dwVID;
|
|
LONG lX;
|
|
LONG lY;
|
|
} TPacketCGSyncPositionElement;
|
|
|
|
// 위치 동기화
|
|
typedef struct command_sync_position // 가변 패킷
|
|
{
|
|
BYTE bHeader;
|
|
WORD wSize;
|
|
} TPacketCGSyncPosition;
|
|
|
|
/* 채팅 (3) */
|
|
typedef struct command_chat // 가변 패킷
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE type;
|
|
} TPacketCGChat;
|
|
|
|
/* 귓속말 */
|
|
typedef struct command_whisper
|
|
{
|
|
BYTE bHeader;
|
|
WORD wSize;
|
|
char szNameTo[CHARACTER_NAME_MAX_LEN + 1];
|
|
} TPacketCGWhisper;
|
|
|
|
typedef struct command_entergame
|
|
{
|
|
BYTE header;
|
|
} TPacketCGEnterGame;
|
|
|
|
typedef struct command_item_use
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
} TPacketCGItemUse;
|
|
|
|
typedef struct command_item_use_to_item
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
TItemPos TargetCell;
|
|
} TPacketCGItemUseToItem;
|
|
|
|
typedef struct command_item_drop
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
DWORD gold;
|
|
} TPacketCGItemDrop;
|
|
|
|
typedef struct command_item_drop2
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
DWORD gold;
|
|
BYTE count;
|
|
} TPacketCGItemDrop2;
|
|
|
|
typedef struct command_item_move
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
TItemPos CellTo;
|
|
BYTE count;
|
|
} TPacketCGItemMove;
|
|
|
|
typedef struct command_item_pickup
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
} TPacketCGItemPickup;
|
|
|
|
typedef struct command_quickslot_add
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
TQuickslot slot;
|
|
} TPacketCGQuickslotAdd;
|
|
|
|
typedef struct command_quickslot_del
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
} TPacketCGQuickslotDel;
|
|
|
|
typedef struct command_quickslot_swap
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
BYTE change_pos;
|
|
} TPacketCGQuickslotSwap;
|
|
|
|
enum
|
|
{
|
|
SHOP_SUBHEADER_CG_END,
|
|
SHOP_SUBHEADER_CG_BUY,
|
|
SHOP_SUBHEADER_CG_SELL,
|
|
SHOP_SUBHEADER_CG_SELL2
|
|
};
|
|
|
|
typedef struct command_shop_buy
|
|
{
|
|
BYTE count;
|
|
} TPacketCGShopBuy;
|
|
|
|
typedef struct command_shop_sell
|
|
{
|
|
BYTE pos;
|
|
BYTE count;
|
|
} TPacketCGShopSell;
|
|
|
|
typedef struct command_shop
|
|
{
|
|
BYTE header;
|
|
BYTE subheader;
|
|
} TPacketCGShop;
|
|
|
|
typedef struct command_on_click
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
} TPacketCGOnClick;
|
|
|
|
enum
|
|
{
|
|
EXCHANGE_SUBHEADER_CG_START, /* arg1 == vid of target character */
|
|
EXCHANGE_SUBHEADER_CG_ITEM_ADD, /* arg1 == position of item */
|
|
EXCHANGE_SUBHEADER_CG_ITEM_DEL, /* arg1 == position of item */
|
|
EXCHANGE_SUBHEADER_CG_ELK_ADD, /* arg1 == amount of gold */
|
|
EXCHANGE_SUBHEADER_CG_ACCEPT, /* arg1 == not used */
|
|
EXCHANGE_SUBHEADER_CG_CANCEL, /* arg1 == not used */
|
|
};
|
|
|
|
typedef struct command_exchange
|
|
{
|
|
BYTE header;
|
|
BYTE sub_header;
|
|
DWORD arg1;
|
|
BYTE arg2;
|
|
TItemPos Pos;
|
|
} TPacketCGExchange;
|
|
|
|
typedef struct command_position
|
|
{
|
|
BYTE header;
|
|
BYTE position;
|
|
} TPacketCGPosition;
|
|
|
|
typedef struct command_script_answer
|
|
{
|
|
BYTE header;
|
|
BYTE answer;
|
|
//char file[32 + 1];
|
|
//BYTE answer[16 + 1];
|
|
} TPacketCGScriptAnswer;
|
|
|
|
|
|
typedef struct command_script_button
|
|
{
|
|
BYTE header;
|
|
UINT idx;
|
|
} TPacketCGScriptButton;
|
|
|
|
typedef struct command_quest_input_string
|
|
{
|
|
BYTE header;
|
|
char msg[64+1];
|
|
} TPacketCGQuestInputString;
|
|
|
|
typedef struct command_quest_confirm
|
|
{
|
|
BYTE header;
|
|
BYTE answer;
|
|
DWORD requestPID;
|
|
} TPacketCGQuestConfirm;
|
|
|
|
/*
|
|
* 서버 측에서 보내는 패킷
|
|
*/
|
|
typedef struct packet_quest_confirm
|
|
{
|
|
BYTE header;
|
|
char msg[64+1];
|
|
LONG timeout;
|
|
DWORD requestPID;
|
|
} TPacketGCQuestConfirm;
|
|
|
|
typedef struct packet_handshake
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwHandshake;
|
|
DWORD dwTime;
|
|
LONG lDelta;
|
|
} TPacketGCHandshake;
|
|
|
|
enum EPhase
|
|
{
|
|
PHASE_CLOSE,
|
|
PHASE_HANDSHAKE,
|
|
PHASE_LOGIN,
|
|
PHASE_SELECT,
|
|
PHASE_LOADING,
|
|
PHASE_GAME,
|
|
PHASE_DEAD,
|
|
|
|
PHASE_CLIENT_CONNECTING,
|
|
PHASE_DBCLIENT,
|
|
PHASE_P2P,
|
|
PHASE_AUTH,
|
|
PHASE_TEEN,
|
|
};
|
|
|
|
typedef struct packet_phase
|
|
{
|
|
BYTE header;
|
|
BYTE phase;
|
|
} TPacketGCPhase;
|
|
|
|
enum
|
|
{
|
|
LOGIN_FAILURE_ALREADY = 1,
|
|
LOGIN_FAILURE_ID_NOT_EXIST = 2,
|
|
LOGIN_FAILURE_WRONG_PASS = 3,
|
|
LOGIN_FAILURE_FALSE = 4,
|
|
LOGIN_FAILURE_NOT_TESTOR = 5,
|
|
LOGIN_FAILURE_NOT_TEST_TIME = 6,
|
|
LOGIN_FAILURE_FULL = 7
|
|
};
|
|
|
|
typedef struct packet_login_success
|
|
{
|
|
BYTE bHeader;
|
|
TSimplePlayer players[PLAYER_PER_ACCOUNT];
|
|
DWORD guild_id[PLAYER_PER_ACCOUNT];
|
|
char guild_name[PLAYER_PER_ACCOUNT][GUILD_NAME_MAX_LEN+1];
|
|
|
|
DWORD handle;
|
|
DWORD random_key;
|
|
} TPacketGCLoginSuccess;
|
|
|
|
typedef struct packet_auth_success
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwLoginKey;
|
|
BYTE bResult;
|
|
} TPacketGCAuthSuccess;
|
|
|
|
typedef struct packet_login_failure
|
|
{
|
|
BYTE header;
|
|
char szStatus[ACCOUNT_STATUS_MAX_LEN + 1];
|
|
} TPacketGCLoginFailure;
|
|
|
|
typedef struct packet_create_failure
|
|
{
|
|
BYTE header;
|
|
BYTE bType;
|
|
} TPacketGCCreateFailure;
|
|
|
|
enum
|
|
{
|
|
ADD_CHARACTER_STATE_DEAD = (1 << 0),
|
|
ADD_CHARACTER_STATE_SPAWN = (1 << 1),
|
|
ADD_CHARACTER_STATE_GUNGON = (1 << 2),
|
|
ADD_CHARACTER_STATE_KILLER = (1 << 3),
|
|
ADD_CHARACTER_STATE_PARTY = (1 << 4),
|
|
};
|
|
|
|
enum ECharacterEquipmentPart
|
|
{
|
|
CHR_EQUIPPART_ARMOR,
|
|
CHR_EQUIPPART_WEAPON,
|
|
CHR_EQUIPPART_HEAD,
|
|
CHR_EQUIPPART_HAIR,
|
|
CHR_EQUIPPART_NUM,
|
|
};
|
|
|
|
typedef struct packet_add_char
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
|
|
float angle;
|
|
LONG x;
|
|
LONG y;
|
|
LONG z;
|
|
|
|
BYTE bType;
|
|
WORD wRaceNum;
|
|
BYTE bMovingSpeed;
|
|
BYTE bAttackSpeed;
|
|
|
|
BYTE bStateFlag;
|
|
DWORD dwAffectFlag[2]; // 효과
|
|
} TPacketGCCharacterAdd;
|
|
|
|
typedef struct packet_char_additional_info
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
char name[CHARACTER_NAME_MAX_LEN + 1];
|
|
WORD awPart[CHR_EQUIPPART_NUM];
|
|
BYTE bEmpire;
|
|
DWORD dwGuildID;
|
|
DWORD dwLevel;
|
|
sh_int sAlignment;
|
|
BYTE bPKMode;
|
|
DWORD dwMountVnum;
|
|
} TPacketGCCharacterAdditionalInfo;
|
|
|
|
/*
|
|
typedef struct packet_update_char_old
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
|
|
WORD awPart[CHR_EQUIPPART_NUM];
|
|
BYTE bMovingSpeed;
|
|
BYTE bAttackSpeed;
|
|
|
|
BYTE bStateFlag;
|
|
DWORD dwAffectFlag[2];
|
|
|
|
DWORD dwGuildID;
|
|
sh_int sAlignment;
|
|
BYTE bPKMode;
|
|
DWORD dwMountVnum;
|
|
} TPacketGCCharacterUpdateOld;
|
|
*/
|
|
|
|
typedef struct packet_update_char
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
|
|
WORD awPart[CHR_EQUIPPART_NUM];
|
|
BYTE bMovingSpeed;
|
|
BYTE bAttackSpeed;
|
|
|
|
BYTE bStateFlag;
|
|
DWORD dwAffectFlag[2];
|
|
|
|
DWORD dwGuildID;
|
|
sh_int sAlignment;
|
|
BYTE bPKMode;
|
|
DWORD dwMountVnum;
|
|
//WORD wRaceNum;
|
|
} TPacketGCCharacterUpdate;
|
|
|
|
typedef struct packet_del_char
|
|
{
|
|
BYTE header;
|
|
DWORD id;
|
|
} TPacketGCCharacterDelete;
|
|
|
|
typedef struct packet_chat // 가변 패킷
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE type;
|
|
DWORD id;
|
|
BYTE bEmpire;
|
|
} TPacketGCChat;
|
|
|
|
typedef struct packet_whisper // 가변 패킷
|
|
{
|
|
BYTE bHeader;
|
|
WORD wSize;
|
|
BYTE bType;
|
|
char szNameFrom[CHARACTER_NAME_MAX_LEN + 1];
|
|
} TPacketGCWhisper;
|
|
|
|
typedef struct packet_main_character
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
WORD wRaceNum;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
LONG lx, ly, lz;
|
|
BYTE empire;
|
|
BYTE skill_group;
|
|
} TPacketGCMainCharacter;
|
|
|
|
// SUPPORT_BGM
|
|
typedef struct packet_main_character3_bgm
|
|
{
|
|
enum
|
|
{
|
|
MUSIC_NAME_LEN = 24,
|
|
};
|
|
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
WORD wRaceNum;
|
|
char szChrName[CHARACTER_NAME_MAX_LEN + 1];
|
|
char szBGMName[MUSIC_NAME_LEN + 1];
|
|
LONG lx, ly, lz;
|
|
BYTE empire;
|
|
BYTE skill_group;
|
|
} TPacketGCMainCharacter3_BGM;
|
|
|
|
typedef struct packet_main_character4_bgm_vol
|
|
{
|
|
enum
|
|
{
|
|
MUSIC_NAME_LEN = 24,
|
|
};
|
|
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
WORD wRaceNum;
|
|
char szChrName[CHARACTER_NAME_MAX_LEN + 1];
|
|
char szBGMName[MUSIC_NAME_LEN + 1];
|
|
float fBGMVol;
|
|
LONG lx, ly, lz;
|
|
BYTE empire;
|
|
BYTE skill_group;
|
|
} TPacketGCMainCharacter4_BGM_VOL;
|
|
// END_OF_SUPPORT_BGM
|
|
|
|
typedef struct packet_points
|
|
{
|
|
BYTE header;
|
|
INT points[POINT_MAX_NUM];
|
|
} TPacketGCPoints;
|
|
|
|
typedef struct packet_skill_level
|
|
{
|
|
BYTE bHeader;
|
|
TPlayerSkill skills[SKILL_MAX_NUM];
|
|
} TPacketGCSkillLevel;
|
|
|
|
typedef struct packet_point_change
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
BYTE type;
|
|
LONG amount;
|
|
LONG value;
|
|
} TPacketGCPointChange;
|
|
|
|
typedef struct packet_stun
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
} TPacketGCStun;
|
|
|
|
typedef struct packet_dead
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
} TPacketGCDead;
|
|
|
|
struct TPacketGCItemDelDeprecated
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
DWORD vnum;
|
|
BYTE count;
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
};
|
|
|
|
typedef struct packet_item_set
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
DWORD vnum;
|
|
BYTE count;
|
|
DWORD flags;
|
|
DWORD anti_flags;
|
|
bool highlight;
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
} TPacketGCItemSet;
|
|
|
|
typedef struct packet_item_del
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
} TPacketGCItemDel;
|
|
|
|
struct packet_item_use
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
DWORD ch_vid;
|
|
DWORD victim_vid;
|
|
DWORD vnum;
|
|
};
|
|
|
|
struct packet_item_move
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
TItemPos CellTo;
|
|
};
|
|
|
|
typedef struct packet_item_update
|
|
{
|
|
BYTE header;
|
|
TItemPos Cell;
|
|
BYTE count;
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
} TPacketGCItemUpdate;
|
|
|
|
typedef struct packet_item_ground_add
|
|
{
|
|
BYTE bHeader;
|
|
LONG x, y, z;
|
|
DWORD dwVID;
|
|
DWORD dwVnum;
|
|
} TPacketGCItemGroundAdd;
|
|
|
|
typedef struct packet_item_ownership
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwVID;
|
|
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
|
} TPacketGCItemOwnership;
|
|
|
|
typedef struct packet_item_ground_del
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwVID;
|
|
} TPacketGCItemGroundDel;
|
|
|
|
struct packet_quickslot_add
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
TQuickslot slot;
|
|
};
|
|
|
|
struct packet_quickslot_del
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
};
|
|
|
|
struct packet_quickslot_swap
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
BYTE pos_to;
|
|
};
|
|
|
|
struct packet_motion
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
DWORD victim_vid;
|
|
WORD motion;
|
|
};
|
|
|
|
enum EPacketShopSubHeaders
|
|
{
|
|
SHOP_SUBHEADER_GC_START,
|
|
SHOP_SUBHEADER_GC_END,
|
|
SHOP_SUBHEADER_GC_UPDATE_ITEM,
|
|
SHOP_SUBHEADER_GC_UPDATE_PRICE,
|
|
SHOP_SUBHEADER_GC_OK,
|
|
SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY,
|
|
SHOP_SUBHEADER_GC_SOLDOUT,
|
|
SHOP_SUBHEADER_GC_INVENTORY_FULL,
|
|
SHOP_SUBHEADER_GC_INVALID_POS,
|
|
SHOP_SUBHEADER_GC_SOLD_OUT,
|
|
SHOP_SUBHEADER_GC_START_EX,
|
|
SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX,
|
|
};
|
|
|
|
struct packet_shop_item
|
|
{
|
|
DWORD vnum;
|
|
DWORD price;
|
|
BYTE count;
|
|
BYTE display_pos;
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
};
|
|
|
|
typedef struct packet_shop_start
|
|
{
|
|
DWORD owner_vid;
|
|
struct packet_shop_item items[SHOP_HOST_ITEM_MAX_NUM];
|
|
} TPacketGCShopStart;
|
|
|
|
typedef struct packet_shop_start_ex // 다음에 TSubPacketShopTab* shop_tabs 이 따라옴.
|
|
{
|
|
typedef struct sub_packet_shop_tab
|
|
{
|
|
char name[SHOP_TAB_NAME_MAX];
|
|
BYTE coin_type;
|
|
packet_shop_item items[SHOP_HOST_ITEM_MAX_NUM];
|
|
} TSubPacketShopTab;
|
|
DWORD owner_vid;
|
|
BYTE shop_tab_count;
|
|
} TPacketGCShopStartEx;
|
|
|
|
typedef struct packet_shop_update_item
|
|
{
|
|
BYTE pos;
|
|
struct packet_shop_item item;
|
|
} TPacketGCShopUpdateItem;
|
|
|
|
typedef struct packet_shop_update_price
|
|
{
|
|
INT iPrice;
|
|
} TPacketGCShopUpdatePrice;
|
|
|
|
typedef struct packet_shop // 가변 패킷
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE subheader;
|
|
} TPacketGCShop;
|
|
|
|
struct packet_exchange
|
|
{
|
|
BYTE header;
|
|
BYTE sub_header;
|
|
BYTE is_me;
|
|
DWORD arg1; // vnum
|
|
TItemPos arg2; // cell
|
|
DWORD arg3; // count
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
};
|
|
|
|
enum EPacketTradeSubHeaders
|
|
{
|
|
EXCHANGE_SUBHEADER_GC_START, /* arg1 == vid */
|
|
EXCHANGE_SUBHEADER_GC_ITEM_ADD, /* arg1 == vnum arg2 == pos arg3 == count */
|
|
EXCHANGE_SUBHEADER_GC_ITEM_DEL,
|
|
EXCHANGE_SUBHEADER_GC_GOLD_ADD, /* arg1 == gold */
|
|
EXCHANGE_SUBHEADER_GC_ACCEPT, /* arg1 == accept */
|
|
EXCHANGE_SUBHEADER_GC_END, /* arg1 == not used */
|
|
EXCHANGE_SUBHEADER_GC_ALREADY, /* arg1 == not used */
|
|
EXCHANGE_SUBHEADER_GC_LESS_GOLD, /* arg1 == not used */
|
|
};
|
|
|
|
struct packet_position
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
BYTE position;
|
|
};
|
|
|
|
typedef struct packet_ping
|
|
{
|
|
BYTE header;
|
|
} TPacketGCPing;
|
|
|
|
struct packet_script
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE skin;
|
|
WORD src_size;
|
|
};
|
|
|
|
typedef struct packet_change_speed
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
WORD moving_speed;
|
|
} TPacketGCChangeSpeed;
|
|
|
|
struct packet_mount
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
DWORD mount_vid;
|
|
BYTE pos;
|
|
DWORD x, y;
|
|
};
|
|
|
|
typedef struct packet_move
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bFunc;
|
|
BYTE bArg;
|
|
BYTE bRot;
|
|
DWORD dwVID;
|
|
LONG lX;
|
|
LONG lY;
|
|
DWORD dwTime;
|
|
DWORD dwDuration;
|
|
} TPacketGCMove;
|
|
|
|
// 소유권
|
|
typedef struct packet_ownership
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwOwnerVID;
|
|
DWORD dwVictimVID;
|
|
} TPacketGCOwnership;
|
|
|
|
// 위치 동기화 패킷의 bCount 만큼 붙는 단위
|
|
typedef struct packet_sync_position_element
|
|
{
|
|
DWORD dwVID;
|
|
LONG lX;
|
|
LONG lY;
|
|
} TPacketGCSyncPositionElement;
|
|
|
|
// 위치 동기화
|
|
typedef struct packet_sync_position // 가변 패킷
|
|
{
|
|
BYTE bHeader;
|
|
WORD wSize; // 개수 = (wSize - sizeof(TPacketGCSyncPosition)) / sizeof(TPacketGCSyncPositionElement)
|
|
} TPacketGCSyncPosition;
|
|
|
|
typedef struct packet_fly
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bType;
|
|
DWORD dwStartVID;
|
|
DWORD dwEndVID;
|
|
} TPacketGCCreateFly;
|
|
|
|
typedef struct command_fly_targeting
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwTargetVID;
|
|
LONG x, y;
|
|
} TPacketCGFlyTargeting;
|
|
|
|
typedef struct packet_fly_targeting
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwShooterVID;
|
|
DWORD dwTargetVID;
|
|
LONG x, y;
|
|
} TPacketGCFlyTargeting;
|
|
|
|
typedef struct packet_shoot
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bType;
|
|
} TPacketCGShoot;
|
|
|
|
typedef struct packet_duel_start
|
|
{
|
|
BYTE header;
|
|
WORD wSize; // DWORD가 몇개? 개수 = (wSize - sizeof(TPacketGCPVPList)) / 4
|
|
} TPacketGCDuelStart;
|
|
|
|
enum EPVPModes
|
|
{
|
|
PVP_MODE_NONE,
|
|
PVP_MODE_AGREE,
|
|
PVP_MODE_FIGHT,
|
|
PVP_MODE_REVENGE
|
|
};
|
|
|
|
typedef struct packet_pvp
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwVIDSrc;
|
|
DWORD dwVIDDst;
|
|
BYTE bMode; // 0 이면 끔, 1이면 켬
|
|
} TPacketGCPVP;
|
|
|
|
typedef struct command_use_skill
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwVnum;
|
|
DWORD dwVID;
|
|
} TPacketCGUseSkill;
|
|
|
|
typedef struct command_target
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
} TPacketCGTarget;
|
|
|
|
typedef struct packet_target
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
BYTE bHPPercent;
|
|
} TPacketGCTarget;
|
|
|
|
typedef struct packet_warp
|
|
{
|
|
BYTE bHeader;
|
|
LONG lX;
|
|
LONG lY;
|
|
LONG lAddr;
|
|
WORD wPort;
|
|
} TPacketGCWarp;
|
|
|
|
typedef struct command_warp
|
|
{
|
|
BYTE bHeader;
|
|
} TPacketCGWarp;
|
|
|
|
struct packet_quest_info
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
WORD index;
|
|
BYTE flag;
|
|
};
|
|
|
|
enum
|
|
{
|
|
MESSENGER_SUBHEADER_GC_LIST,
|
|
MESSENGER_SUBHEADER_GC_LOGIN,
|
|
MESSENGER_SUBHEADER_GC_LOGOUT,
|
|
MESSENGER_SUBHEADER_GC_INVITE,
|
|
MESSENGER_SUBHEADER_GC_MOBILE
|
|
};
|
|
|
|
typedef struct packet_messenger
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE subheader;
|
|
} TPacketGCMessenger;
|
|
|
|
typedef struct packet_messenger_guild_list
|
|
{
|
|
BYTE connected;
|
|
BYTE length;
|
|
//char login[LOGIN_MAX_LEN+1];
|
|
} TPacketGCMessengerGuildList;
|
|
|
|
typedef struct packet_messenger_guild_login
|
|
{
|
|
BYTE length;
|
|
//char login[LOGIN_MAX_LEN+1];
|
|
} TPacketGCMessengerGuildLogin;
|
|
|
|
typedef struct packet_messenger_guild_logout
|
|
{
|
|
BYTE length;
|
|
|
|
//char login[LOGIN_MAX_LEN+1];
|
|
} TPacketGCMessengerGuildLogout;
|
|
|
|
typedef struct packet_messenger_list_offline
|
|
{
|
|
BYTE connected; // always 0
|
|
BYTE length;
|
|
} TPacketGCMessengerListOffline;
|
|
|
|
typedef struct packet_messenger_list_online
|
|
{
|
|
BYTE connected; // always 1
|
|
BYTE length;
|
|
} TPacketGCMessengerListOnline;
|
|
|
|
enum
|
|
{
|
|
MESSENGER_SUBHEADER_CG_ADD_BY_VID,
|
|
MESSENGER_SUBHEADER_CG_ADD_BY_NAME,
|
|
MESSENGER_SUBHEADER_CG_REMOVE,
|
|
MESSENGER_SUBHEADER_CG_INVITE_ANSWER,
|
|
};
|
|
|
|
typedef struct command_messenger
|
|
{
|
|
BYTE header;
|
|
BYTE subheader;
|
|
} TPacketCGMessenger;
|
|
|
|
typedef struct command_messenger_add_by_vid
|
|
{
|
|
DWORD vid;
|
|
} TPacketCGMessengerAddByVID;
|
|
|
|
typedef struct command_messenger_add_by_name
|
|
{
|
|
BYTE length;
|
|
//char login[LOGIN_MAX_LEN+1];
|
|
} TPacketCGMessengerAddByName;
|
|
|
|
typedef struct command_messenger_remove
|
|
{
|
|
char login[LOGIN_MAX_LEN+1];
|
|
//DWORD account;
|
|
} TPacketCGMessengerRemove;
|
|
|
|
typedef struct command_safebox_checkout
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bSafePos;
|
|
TItemPos ItemPos;
|
|
} TPacketCGSafeboxCheckout;
|
|
|
|
typedef struct command_safebox_checkin
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bSafePos;
|
|
TItemPos ItemPos;
|
|
} TPacketCGSafeboxCheckin;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
// Party
|
|
|
|
typedef struct command_party_parameter
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bDistributeMode;
|
|
} TPacketCGPartyParameter;
|
|
|
|
typedef struct paryt_parameter
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bDistributeMode;
|
|
} TPacketGCPartyParameter;
|
|
|
|
typedef struct packet_party_add
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
char name[CHARACTER_NAME_MAX_LEN+1];
|
|
} TPacketGCPartyAdd;
|
|
|
|
typedef struct command_party_invite
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
} TPacketCGPartyInvite;
|
|
|
|
typedef struct packet_party_invite
|
|
{
|
|
BYTE header;
|
|
DWORD leader_vid;
|
|
} TPacketGCPartyInvite;
|
|
|
|
typedef struct command_party_invite_answer
|
|
{
|
|
BYTE header;
|
|
DWORD leader_vid;
|
|
BYTE accept;
|
|
} TPacketCGPartyInviteAnswer;
|
|
|
|
typedef struct packet_party_update
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
BYTE role;
|
|
BYTE percent_hp;
|
|
sh_int affects[7];
|
|
} TPacketGCPartyUpdate;
|
|
|
|
typedef struct packet_party_remove
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
} TPacketGCPartyRemove;
|
|
|
|
typedef struct packet_party_link
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
DWORD vid;
|
|
} TPacketGCPartyLink;
|
|
|
|
typedef struct packet_party_unlink
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
DWORD vid;
|
|
} TPacketGCPartyUnlink;
|
|
|
|
typedef struct command_party_remove
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
} TPacketCGPartyRemove;
|
|
|
|
typedef struct command_party_set_state
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
BYTE byRole;
|
|
BYTE flag;
|
|
} TPacketCGPartySetState;
|
|
|
|
enum
|
|
{
|
|
PARTY_SKILL_HEAL = 1,
|
|
PARTY_SKILL_WARP = 2
|
|
};
|
|
|
|
typedef struct command_party_use_skill
|
|
{
|
|
BYTE header;
|
|
BYTE bySkillIndex;
|
|
DWORD vid;
|
|
} TPacketCGPartyUseSkill;
|
|
|
|
typedef struct packet_safebox_size
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bSize;
|
|
} TPacketCGSafeboxSize;
|
|
|
|
typedef struct packet_safebox_wrong_password
|
|
{
|
|
BYTE bHeader;
|
|
} TPacketCGSafeboxWrongPassword;
|
|
|
|
typedef struct command_empire
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bEmpire;
|
|
} TPacketCGEmpire;
|
|
|
|
typedef struct packet_empire
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bEmpire;
|
|
} TPacketGCEmpire;
|
|
|
|
enum
|
|
{
|
|
SAFEBOX_MONEY_STATE_SAVE,
|
|
SAFEBOX_MONEY_STATE_WITHDRAW,
|
|
};
|
|
|
|
typedef struct command_safebox_money
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bState;
|
|
LONG lMoney;
|
|
} TPacketCGSafeboxMoney;
|
|
|
|
typedef struct packet_safebox_money_change
|
|
{
|
|
BYTE bHeader;
|
|
LONG lMoney;
|
|
} TPacketGCSafeboxMoneyChange;
|
|
|
|
// Guild
|
|
|
|
enum
|
|
{
|
|
GUILD_SUBHEADER_GC_LOGIN,
|
|
GUILD_SUBHEADER_GC_LOGOUT,
|
|
GUILD_SUBHEADER_GC_LIST,
|
|
GUILD_SUBHEADER_GC_GRADE,
|
|
GUILD_SUBHEADER_GC_ADD,
|
|
GUILD_SUBHEADER_GC_REMOVE,
|
|
GUILD_SUBHEADER_GC_GRADE_NAME,
|
|
GUILD_SUBHEADER_GC_GRADE_AUTH,
|
|
GUILD_SUBHEADER_GC_INFO,
|
|
GUILD_SUBHEADER_GC_COMMENTS,
|
|
GUILD_SUBHEADER_GC_CHANGE_EXP,
|
|
GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE,
|
|
GUILD_SUBHEADER_GC_SKILL_INFO,
|
|
GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL,
|
|
GUILD_SUBHEADER_GC_GUILD_INVITE,
|
|
GUILD_SUBHEADER_GC_WAR,
|
|
GUILD_SUBHEADER_GC_GUILD_NAME,
|
|
GUILD_SUBHEADER_GC_GUILD_WAR_LIST,
|
|
GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST,
|
|
GUILD_SUBHEADER_GC_WAR_SCORE,
|
|
GUILD_SUBHEADER_GC_MONEY_CHANGE,
|
|
};
|
|
|
|
enum GUILD_SUBHEADER_CG
|
|
{
|
|
GUILD_SUBHEADER_CG_ADD_MEMBER,
|
|
GUILD_SUBHEADER_CG_REMOVE_MEMBER,
|
|
GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME,
|
|
GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY,
|
|
GUILD_SUBHEADER_CG_OFFER,
|
|
GUILD_SUBHEADER_CG_POST_COMMENT,
|
|
GUILD_SUBHEADER_CG_DELETE_COMMENT,
|
|
GUILD_SUBHEADER_CG_REFRESH_COMMENT,
|
|
GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE,
|
|
GUILD_SUBHEADER_CG_USE_SKILL,
|
|
GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL,
|
|
GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER,
|
|
GUILD_SUBHEADER_CG_CHARGE_GSP,
|
|
GUILD_SUBHEADER_CG_DEPOSIT_MONEY,
|
|
GUILD_SUBHEADER_CG_WITHDRAW_MONEY,
|
|
};
|
|
|
|
typedef struct packet_guild
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE subheader;
|
|
} TPacketGCGuild;
|
|
|
|
typedef struct packet_guild_name_t
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
BYTE subheader;
|
|
DWORD guildID;
|
|
char guildName[GUILD_NAME_MAX_LEN];
|
|
} TPacketGCGuildName;
|
|
|
|
typedef struct packet_guild_war
|
|
{
|
|
DWORD dwGuildSelf;
|
|
DWORD dwGuildOpp;
|
|
BYTE bType;
|
|
BYTE bWarState;
|
|
} TPacketGCGuildWar;
|
|
|
|
typedef struct command_guild
|
|
{
|
|
BYTE header;
|
|
BYTE subheader;
|
|
} TPacketCGGuild;
|
|
|
|
typedef struct command_guild_answer_make_guild
|
|
{
|
|
BYTE header;
|
|
char guild_name[GUILD_NAME_MAX_LEN+1];
|
|
} TPacketCGAnswerMakeGuild;
|
|
|
|
typedef struct command_guild_use_skill
|
|
{
|
|
DWORD dwVnum;
|
|
DWORD dwPID;
|
|
} TPacketCGGuildUseSkill;
|
|
|
|
// Guild Mark
|
|
typedef struct command_mark_login
|
|
{
|
|
BYTE header;
|
|
DWORD handle;
|
|
DWORD random_key;
|
|
} TPacketCGMarkLogin;
|
|
|
|
typedef struct command_mark_upload
|
|
{
|
|
BYTE header;
|
|
DWORD gid;
|
|
BYTE image[16*12*4];
|
|
} TPacketCGMarkUpload;
|
|
|
|
typedef struct command_mark_idxlist
|
|
{
|
|
BYTE header;
|
|
} TPacketCGMarkIDXList;
|
|
|
|
typedef struct command_mark_crclist
|
|
{
|
|
BYTE header;
|
|
BYTE imgIdx;
|
|
DWORD crclist[80];
|
|
} TPacketCGMarkCRCList;
|
|
|
|
typedef struct packet_mark_idxlist
|
|
{
|
|
BYTE header;
|
|
DWORD bufSize;
|
|
WORD count;
|
|
//뒤에 size * (WORD + WORD)만큼 데이터 붙음
|
|
} TPacketGCMarkIDXList;
|
|
|
|
typedef struct packet_mark_block
|
|
{
|
|
BYTE header;
|
|
DWORD bufSize;
|
|
BYTE imgIdx;
|
|
DWORD count;
|
|
// 뒤에 64 x 48 x 픽셀크기(4바이트) = 12288만큼 데이터 붙음
|
|
} TPacketGCMarkBlock;
|
|
|
|
typedef struct command_symbol_upload
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
DWORD guild_id;
|
|
} TPacketCGGuildSymbolUpload;
|
|
|
|
typedef struct command_symbol_crc
|
|
{
|
|
BYTE header;
|
|
DWORD guild_id;
|
|
DWORD crc;
|
|
DWORD size;
|
|
} TPacketCGSymbolCRC;
|
|
|
|
typedef struct packet_symbol_data
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
DWORD guild_id;
|
|
} TPacketGCGuildSymbolData;
|
|
|
|
// Fishing
|
|
|
|
typedef struct command_fishing
|
|
{
|
|
BYTE header;
|
|
BYTE dir;
|
|
} TPacketCGFishing;
|
|
|
|
typedef struct packet_fishing
|
|
{
|
|
BYTE header;
|
|
BYTE subheader;
|
|
DWORD info;
|
|
BYTE dir;
|
|
} TPacketGCFishing;
|
|
|
|
enum
|
|
{
|
|
FISHING_SUBHEADER_GC_START,
|
|
FISHING_SUBHEADER_GC_STOP,
|
|
FISHING_SUBHEADER_GC_REACT,
|
|
FISHING_SUBHEADER_GC_SUCCESS,
|
|
FISHING_SUBHEADER_GC_FAIL,
|
|
FISHING_SUBHEADER_GC_FISH,
|
|
};
|
|
|
|
typedef struct command_give_item
|
|
{
|
|
BYTE byHeader;
|
|
DWORD dwTargetVID;
|
|
TItemPos ItemPos;
|
|
BYTE byItemCount;
|
|
} TPacketCGGiveItem;
|
|
|
|
// SubHeader - Dungeon
|
|
enum
|
|
{
|
|
DUNGEON_SUBHEADER_GC_TIME_ATTACK_START = 0,
|
|
DUNGEON_SUBHEADER_GC_DESTINATION_POSITION = 1,
|
|
};
|
|
|
|
typedef struct packet_dungeon
|
|
{
|
|
BYTE bHeader;
|
|
WORD size;
|
|
BYTE subheader;
|
|
} TPacketGCDungeon;
|
|
|
|
typedef struct packet_dungeon_dest_position
|
|
{
|
|
LONG x;
|
|
LONG y;
|
|
} TPacketGCDungeonDestPosition;
|
|
|
|
typedef struct SPacketGCShopSign
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwVID;
|
|
char szSign[SHOP_SIGN_MAX_LEN + 1];
|
|
} TPacketGCShopSign;
|
|
|
|
typedef struct SPacketCGMyShop
|
|
{
|
|
BYTE bHeader;
|
|
char szSign[SHOP_SIGN_MAX_LEN + 1];
|
|
BYTE bCount;
|
|
} TPacketCGMyShop;
|
|
|
|
typedef struct SPacketGCTime
|
|
{
|
|
BYTE bHeader;
|
|
time_t time;
|
|
} TPacketGCTime;
|
|
|
|
enum
|
|
{
|
|
WALKMODE_RUN,
|
|
WALKMODE_WALK,
|
|
};
|
|
|
|
typedef struct SPacketGCWalkMode
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
BYTE mode;
|
|
} TPacketGCWalkMode;
|
|
|
|
typedef struct SPacketGCChangeSkillGroup
|
|
{
|
|
BYTE header;
|
|
BYTE skill_group;
|
|
} TPacketGCChangeSkillGroup;
|
|
|
|
typedef struct SPacketCGRefine
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
BYTE type;
|
|
} TPacketCGRefine;
|
|
|
|
typedef struct SPacketCGRequestRefineInfo
|
|
{
|
|
BYTE header;
|
|
BYTE pos;
|
|
} TPacketCGRequestRefineInfo;
|
|
|
|
typedef struct SPacketGCRefineInformaion
|
|
{
|
|
BYTE header;
|
|
BYTE type;
|
|
BYTE pos;
|
|
DWORD src_vnum;
|
|
DWORD result_vnum;
|
|
BYTE material_count;
|
|
INT cost; // 소요 비용
|
|
INT prob; // 확률
|
|
TRefineMaterial materials[REFINE_MATERIAL_MAX_NUM];
|
|
} TPacketGCRefineInformation;
|
|
|
|
struct TNPCPosition
|
|
{
|
|
BYTE bType;
|
|
char name[CHARACTER_NAME_MAX_LEN+1];
|
|
LONG x;
|
|
LONG y;
|
|
};
|
|
|
|
typedef struct SPacketGCNPCPosition
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
WORD count;
|
|
|
|
// array of TNPCPosition
|
|
} TPacketGCNPCPosition;
|
|
|
|
typedef struct SPacketGCSpecialEffect
|
|
{
|
|
BYTE header;
|
|
BYTE type;
|
|
DWORD vid;
|
|
} TPacketGCSpecialEffect;
|
|
|
|
typedef struct SPacketCGChangeName
|
|
{
|
|
BYTE header;
|
|
BYTE index;
|
|
char name[CHARACTER_NAME_MAX_LEN+1];
|
|
} TPacketCGChangeName;
|
|
|
|
typedef struct SPacketGCChangeName
|
|
{
|
|
BYTE header;
|
|
DWORD pid;
|
|
char name[CHARACTER_NAME_MAX_LEN+1];
|
|
} TPacketGCChangeName;
|
|
|
|
|
|
typedef struct command_client_version
|
|
{
|
|
BYTE header;
|
|
char filename[32+1];
|
|
char timestamp[32+1];
|
|
} TPacketCGClientVersion;
|
|
|
|
typedef struct command_client_version2
|
|
{
|
|
BYTE header;
|
|
char filename[32+1];
|
|
char timestamp[32+1];
|
|
} TPacketCGClientVersion2;
|
|
|
|
typedef struct packet_channel
|
|
{
|
|
BYTE header;
|
|
BYTE channel;
|
|
} TPacketGCChannel;
|
|
|
|
typedef struct pakcet_view_equip
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
struct {
|
|
DWORD vnum;
|
|
BYTE count;
|
|
LONG alSockets[ITEM_SOCKET_MAX_NUM];
|
|
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
|
|
} equips[WEAR_MAX_NUM];
|
|
} TPacketViewEquip;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwID;
|
|
LONG x, y;
|
|
LONG width, height;
|
|
DWORD dwGuildID;
|
|
} TLandPacketElement;
|
|
|
|
typedef struct packet_land_list
|
|
{
|
|
BYTE header;
|
|
WORD size;
|
|
} TPacketGCLandList;
|
|
|
|
typedef struct
|
|
{
|
|
BYTE bHeader;
|
|
LONG lID;
|
|
char szName[32+1];
|
|
DWORD dwVID;
|
|
BYTE bType;
|
|
} TPacketGCTargetCreate;
|
|
|
|
typedef struct
|
|
{
|
|
BYTE bHeader;
|
|
LONG lID;
|
|
LONG lX, lY;
|
|
} TPacketGCTargetUpdate;
|
|
|
|
typedef struct
|
|
{
|
|
BYTE bHeader;
|
|
LONG lID;
|
|
} TPacketGCTargetDelete;
|
|
|
|
typedef struct
|
|
{
|
|
BYTE bHeader;
|
|
TPacketAffectElement elem;
|
|
} TPacketGCAffectAdd;
|
|
|
|
typedef struct
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwType;
|
|
BYTE bApplyOn;
|
|
} TPacketGCAffectRemove;
|
|
|
|
typedef struct packet_lover_info
|
|
{
|
|
BYTE header;
|
|
char name[CHARACTER_NAME_MAX_LEN + 1];
|
|
BYTE love_point;
|
|
} TPacketGCLoverInfo;
|
|
|
|
typedef struct packet_love_point_update
|
|
{
|
|
BYTE header;
|
|
BYTE love_point;
|
|
} TPacketGCLovePointUpdate;
|
|
|
|
// MINING
|
|
typedef struct packet_dig_motion
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
DWORD target_vid;
|
|
BYTE count;
|
|
} TPacketGCDigMotion;
|
|
// END_OF_MINING
|
|
|
|
// SCRIPT_SELECT_ITEM
|
|
typedef struct command_script_select_item
|
|
{
|
|
BYTE header;
|
|
DWORD selection;
|
|
} TPacketCGScriptSelectItem;
|
|
// END_OF_SCRIPT_SELECT_ITEM
|
|
|
|
typedef struct packet_damage_info
|
|
{
|
|
BYTE header;
|
|
DWORD dwVID;
|
|
BYTE flag;
|
|
INT damage;
|
|
} TPacketGCDamageInfo;
|
|
|
|
enum
|
|
{
|
|
RUNUP_MATRIX_ANSWER_MAX_LEN = 4,
|
|
RUNUP_MATRIX_QUIZ_MAX_LEN = 8 ,
|
|
|
|
};
|
|
|
|
typedef struct packet_runup_matrix_quiz
|
|
{
|
|
BYTE bHeader;
|
|
char szQuiz[RUNUP_MATRIX_QUIZ_MAX_LEN + 1];
|
|
} TPacketGCRunupMatrixQuiz;
|
|
|
|
typedef struct command_runup_matrix_answer
|
|
{
|
|
BYTE bHeader;
|
|
char szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN + 1];
|
|
} TPacketCGRunupMatrixAnswer;
|
|
|
|
typedef struct tag_GGSiege
|
|
{
|
|
BYTE bHeader;
|
|
BYTE bEmpire;
|
|
BYTE bTowerCount;
|
|
} TPacketGGSiege;
|
|
|
|
typedef struct SPacketGGMonarchTransfer
|
|
{
|
|
BYTE bHeader;
|
|
DWORD dwTargetPID;
|
|
LONG x;
|
|
LONG y;
|
|
} TPacketMonarchGGTransfer;
|
|
|
|
typedef struct SPacketGGPCBangUpdate
|
|
{
|
|
BYTE bHeader;
|
|
ULONG ulPCBangID;
|
|
} TPacketPCBangUpdate;
|
|
|
|
typedef struct SPacketGGCheckAwakeness
|
|
{
|
|
BYTE bHeader;
|
|
} TPacketGGCheckAwakeness;
|
|
|
|
typedef struct SPacketGCPanamaPack
|
|
{
|
|
BYTE bHeader;
|
|
char szPackName[256];
|
|
BYTE abIV[32];
|
|
} TPacketGCPanamaPack;
|
|
|
|
//TODO : 아우 짱나..가변패킷 사이즈 받아들일수 있게 패킷 핸들러 Refactoring 하자.
|
|
typedef struct SPacketGCHybridCryptKeys
|
|
{
|
|
SPacketGCHybridCryptKeys() : m_pStream(NULL) {}
|
|
~SPacketGCHybridCryptKeys()
|
|
{
|
|
//GCC 에선 NULL delete 해도 괜찮나? 일단 안전하게 NULL 체크 하자. ( 근데 이거 C++ 표준아니었나 --a )
|
|
if( m_pStream )
|
|
{
|
|
delete[] m_pStream;
|
|
m_pStream = NULL;
|
|
}
|
|
}
|
|
|
|
DWORD GetStreamSize()
|
|
{
|
|
return sizeof(bHeader) + sizeof(WORD) + sizeof(INT) + KeyStreamLen;
|
|
}
|
|
|
|
BYTE* GetStreamData()
|
|
{
|
|
if( m_pStream )
|
|
delete[] m_pStream;
|
|
|
|
uDynamicPacketSize = (WORD)GetStreamSize();
|
|
|
|
m_pStream = new BYTE[ uDynamicPacketSize ];
|
|
|
|
memcpy( m_pStream, &bHeader, 1 );
|
|
memcpy( m_pStream+1, &uDynamicPacketSize, 2 );
|
|
memcpy( m_pStream+3, &KeyStreamLen, 4 );
|
|
|
|
if( KeyStreamLen > 0 )
|
|
memcpy( m_pStream+7, pDataKeyStream, KeyStreamLen );
|
|
|
|
return m_pStream;
|
|
}
|
|
|
|
BYTE bHeader;
|
|
WORD uDynamicPacketSize; // 빌어먹을 클라 DynamicPacketHeader 구조때문에 맞춰줘야한다 -_-;
|
|
INT KeyStreamLen;
|
|
BYTE* pDataKeyStream;
|
|
|
|
private:
|
|
BYTE* m_pStream;
|
|
|
|
|
|
} TPacketGCHybridCryptKeys;
|
|
|
|
|
|
typedef struct SPacketGCPackageSDB
|
|
{
|
|
SPacketGCPackageSDB() : m_pDataSDBStream(NULL), m_pStream(NULL) {}
|
|
~SPacketGCPackageSDB()
|
|
{
|
|
if( m_pStream )
|
|
{
|
|
delete[] m_pStream;
|
|
m_pStream = NULL;
|
|
}
|
|
}
|
|
|
|
DWORD GetStreamSize()
|
|
{
|
|
return sizeof(bHeader) + sizeof(WORD) + sizeof(INT) + iStreamLen;
|
|
}
|
|
|
|
BYTE* GetStreamData()
|
|
{
|
|
if( m_pStream )
|
|
delete[] m_pStream;
|
|
|
|
uDynamicPacketSize = GetStreamSize();
|
|
|
|
m_pStream = new BYTE[ uDynamicPacketSize ];
|
|
|
|
memcpy( m_pStream, &bHeader, 1 );
|
|
memcpy( m_pStream+1, &uDynamicPacketSize, 2 );
|
|
memcpy( m_pStream+3, &iStreamLen, 4 );
|
|
|
|
if( iStreamLen > 0 )
|
|
memcpy( m_pStream+7, m_pDataSDBStream, iStreamLen );
|
|
|
|
return m_pStream;
|
|
}
|
|
|
|
BYTE bHeader;
|
|
WORD uDynamicPacketSize; // 빌어먹을 클라 DynamicPacketHeader 구조때문에 맞춰줘야한다 -_-;
|
|
INT iStreamLen;
|
|
BYTE* m_pDataSDBStream;
|
|
|
|
private:
|
|
BYTE* m_pStream;
|
|
|
|
|
|
} TPacketGCPackageSDB;
|
|
|
|
#define MAX_EFFECT_FILE_NAME 128
|
|
typedef struct SPacketGCSpecificEffect
|
|
{
|
|
BYTE header;
|
|
DWORD vid;
|
|
char effect_file[MAX_EFFECT_FILE_NAME];
|
|
} TPacketGCSpecificEffect;
|
|
|
|
// 용혼석
|
|
enum EDragonSoulRefineWindowRefineType
|
|
{
|
|
DragonSoulRefineWindow_UPGRADE,
|
|
DragonSoulRefineWindow_IMPROVEMENT,
|
|
DragonSoulRefineWindow_REFINE,
|
|
};
|
|
|
|
enum EPacketCGDragonSoulSubHeaderType
|
|
{
|
|
DS_SUB_HEADER_OPEN,
|
|
DS_SUB_HEADER_CLOSE,
|
|
DS_SUB_HEADER_DO_REFINE_GRADE,
|
|
DS_SUB_HEADER_DO_REFINE_STEP,
|
|
DS_SUB_HEADER_DO_REFINE_STRENGTH,
|
|
DS_SUB_HEADER_REFINE_FAIL,
|
|
DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE,
|
|
DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL,
|
|
DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY,
|
|
DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL,
|
|
DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL,
|
|
DS_SUB_HEADER_REFINE_SUCCEED,
|
|
};
|
|
typedef struct SPacketCGDragonSoulRefine
|
|
{
|
|
SPacketCGDragonSoulRefine() : header (HEADER_CG_DRAGON_SOUL_REFINE)
|
|
{}
|
|
BYTE header;
|
|
BYTE bSubType;
|
|
TItemPos ItemGrid[DRAGON_SOUL_REFINE_GRID_SIZE];
|
|
} TPacketCGDragonSoulRefine;
|
|
|
|
typedef struct SPacketGCDragonSoulRefine
|
|
{
|
|
SPacketGCDragonSoulRefine() : header(HEADER_GC_DRAGON_SOUL_REFINE)
|
|
{}
|
|
BYTE header;
|
|
BYTE bSubType;
|
|
TItemPos Pos;
|
|
} TPacketGCDragonSoulRefine;
|
|
|
|
typedef struct SPacketCGStateCheck
|
|
{
|
|
BYTE header;
|
|
ULONG key;
|
|
ULONG index;
|
|
} TPacketCGStateCheck;
|
|
|
|
typedef struct SPacketGCStateCheck
|
|
{
|
|
BYTE header;
|
|
ULONG key;
|
|
ULONG index;
|
|
unsigned char state;
|
|
} TPacketGCStateCheck;
|
|
|
|
#pragma pack()
|
|
|
|
#endif
|