#pragma once #ifdef USE_AHNLAB_HACKSHIELD #include "Hackshield.h" #include METIN2HS_INCLUDE_ANTICPXSVR #else #pragma pack(push) //기존 alignment 저장 #pragma pack(8) #define ANTICPX_TRANS_BUFFER_MAX 400 typedef struct _AHNHS_TRANS_BUFFER { unsigned char byBuffer[ANTICPX_TRANS_BUFFER_MAX/* 송수신 패킷의 최대 크기 */]; unsigned short nLength; } AHNHS_TRANS_BUFFER, *PAHNHS_TRANS_BUFFER; #pragma pack(pop) // 기존 alignment 복구. #endif /* !USE_AHNLAB_HACKSHIELD */ #include "../gamelib/RaceData.h" typedef BYTE TPacketHeader; enum { ///////////////////////////////////////////////// // To Server // HEADER_BLANK is the not use(for future use) HEADER_CG_LOGIN = 1, HEADER_CG_ATTACK = 2, HEADER_CG_CHAT = 3, HEADER_CG_PLAYER_CREATE = 4, // 새로운 플래이어를 생성 HEADER_CG_PLAYER_DESTROY = 5, // 플래이어를 삭제. HEADER_CG_PLAYER_SELECT = 6, HEADER_CG_CHARACTER_MOVE = 7, HEADER_CG_SYNC_POSITION = 8, HEADER_CG_DIRECT_ENTER = 9, 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_BLANK21 = 21, //HEADER_BLANK22 = 22, //HEADER_BLANK22 = 23, //HEADER_BLANK24 = 24, //HEADER_BLANK25 = 25, 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_BLANK32 = 32, //HEADER_BLANK33 = 33, //HEADER_BLANK34 = 34, //HEADER_BLANK35 = 35, //HEADER_BLANK36 = 36, //HEADER_BLANK37 = 37, //HEADER_BLANK38 = 38, //HEADER_BLANK39 = 39, //HEADER_BLANK40 = 40, HEADER_CG_PVP = 41, //HEADER_BLANK42 = 42, //HEADER_BLANK43 = 43, //HEADER_BLANK44 = 44, //HEADER_BLANK45 = 45, //HEADER_BLANK46 = 46, //HEADER_BLANK47 = 47, //HEADER_BLANK48 = 48, //HEADER_BLANK49 = 49, 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_BLANK56 = 56, //HEADER_BLANK57 = 57, //HEADER_BLANK58 = 58, //HEADER_BLANK59 = 59, HEADER_CG_ITEM_USE_TO_ITEM = 60, HEADER_CG_TARGET = 61, //HEADER_BLANK62 = 62, //HEADER_BLANK63 = 63, //HEADER_BLANK64 = 64, HEADER_CG_WARP = 65, HEADER_CG_SCRIPT_BUTTON = 66, HEADER_CG_MESSENGER = 67, //HEADER_BLANK68 = 68, 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_BLANK68 = 79, HEADER_CG_GUILD = 80, HEADER_CG_ANSWER_MAKE_GUILD = 81, HEADER_CG_FISHING = 82, HEADER_CG_GIVE_ITEM = 83, //HEADER_BLANK84 = 84, //HEADER_BLANK85 = 85, //HEADER_BLANK86 = 86, //HEADER_BLANK87 = 87, //HEADER_BLANK88 = 88, //HEADER_BLANK89 = 89, HEADER_CG_EMPIRE = 90, //HEADER_BLANK91 = 91, //HEADER_BLANK92 = 92, //HEADER_BLANK93 = 93, //HEADER_BLANK94 = 94, //HEADER_BLANK95 = 95, HEADER_CG_REFINE = 96, //HEADER_BLANK97 = 97, //HEADER_BLANK98 = 98, //HEADER_BLANK99 = 99, HEADER_CG_MARK_LOGIN = 100, HEADER_CG_MARK_CRCLIST = 101, HEADER_CG_MARK_UPLOAD = 102, HEADER_CG_MARK_IDXLIST = 104, HEADER_CG_CRC_REPORT = 103, HEADER_CG_HACK = 105, HEADER_CG_CHANGE_NAME = 106, HEADER_CG_SMS = 107, HEADER_CG_CHINA_MATRIX_CARD = 108, HEADER_CG_LOGIN2 = 109, HEADER_CG_DUNGEON = 110, HEADER_CG_LOGIN3 = 111, HEADER_CG_GUILD_SYMBOL_UPLOAD = 112, HEADER_CG_GUILD_SYMBOL_CRC = 113, HEADER_CG_SCRIPT_SELECT_ITEM = 114, HEADER_CG_LOGIN4 = 115, HEADER_CG_LOGIN5_OPENID = 116, //OpenID : 실행시 받은 인증키를 서버에 보냄. HEADER_CG_RUNUP_MATRIX_ANSWER = 201, HEADER_CG_NEWCIBN_PASSPOD_ANSWER = 202, HEADER_CG_HS_ACK = 203, HEADER_CG_XTRAP_ACK = 204, HEADER_CG_DRAGON_SOUL_REFINE = 205, HEADER_CG_STATE_CHECKER = 206, #ifdef __AUCTION__ HEADER_CG_AUCTION_CMD = 205, #endif HEADER_CG_TIME_SYNC = 0xfc, HEADER_CG_CLIENT_VERSION = 0xfd, HEADER_CG_CLIENT_VERSION2 = 0xf1, HEADER_CG_PONG = 0xfe, HEADER_CG_HANDSHAKE = 0xff, ///////////////////////////////////////////////// // From Server HEADER_GC_CHARACTER_ADD = 1, HEADER_GC_CHARACTER_DEL = 2, HEADER_GC_CHARACTER_MOVE = 3, HEADER_GC_CHAT = 4, HEADER_GC_SYNC_POSITION = 5, HEADER_GC_LOGIN_SUCCESS3 = 6, HEADER_GC_LOGIN_FAILURE = 7, HEADER_GC_PLAYER_CREATE_SUCCESS = 8, HEADER_GC_PLAYER_CREATE_FAILURE = 9, HEADER_GC_PLAYER_DELETE_SUCCESS = 10, HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID = 11, // 12 HEADER_GC_STUN = 13, HEADER_GC_DEAD = 14, HEADER_GC_MAIN_CHARACTER = 15, HEADER_GC_PLAYER_POINTS = 16, HEADER_GC_PLAYER_POINT_CHANGE = 17, HEADER_GC_CHANGE_SPEED = 18, HEADER_GC_CHARACTER_UPDATE = 19, #if defined(GAIDEN) HEADER_GC_ITEM_DEL = 20, // 아이템 창에 추가 HEADER_GC_ITEM_SET = 21, // 아이템 창에 추가 #else HEADER_GC_ITEM_SET = 20, // 아이템 창에 추가 HEADER_GC_ITEM_SET2 = 21, // 아이템 창에 추가 #endif 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_LOGIN_SUCCESS4 = 32, HEADER_GC_ITEM_UNBIND_TIME = 33, HEADER_GC_WHISPER = 34, HEADER_GC_ALERT = 35, HEADER_GC_MOTION = 36, HEADER_GC_SHOP = 38, HEADER_GC_SHOP_SIGN = 39, // 39 ~ 41 Balnk 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 = 72, HEADER_GC_SKILL_COOLTIME_END = 73, HEADER_GC_MESSENGER = 74, HEADER_GC_GUILD = 75, HEADER_GC_SKILL_LEVEL_NEW = 76, 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_MONEY_CHANGE = 84, 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 = 95, HEADER_GC_OBSERVER_ADD = 96, HEADER_GC_OBSERVER_REMOVE = 97, HEADER_GC_OBSERVER_MOVE = 98, HEADER_GC_VIEW_EQUIP = 99, HEADER_GC_MARK_BLOCK = 100, HEADER_GC_MARK_DIFF_DATA = 101, HEADER_GC_MARK_IDXLIST = 102, //HEADER_GC_SLOW_TIMER = 105, HEADER_GC_TIME = 106, HEADER_GC_CHANGE_NAME = 107, HEADER_GC_DUNGEON = 110, HEADER_GC_WALK_MODE = 111, HEADER_GC_CHANGE_SKILL_GROUP = 112, #if defined(GAIDEN) HEADER_GC_MAIN_CHARACTER = 113, HEADER_GC_MAIN_CHARACTER3_BGM = 137, HEADER_GC_MAIN_CHARACTER4_BGM_VOL = 138, #else // SUPPORT_BGM HEADER_GC_MAIN_CHARACTER2_EMPIRE = 113, // END_OF_SUPPORT_BGM #endif HEADER_GC_SEPCIAL_EFFECT = 114, HEADER_GC_NPC_POSITION = 115, HEADER_GC_CHINA_MATRIX_CARD = 116, HEADER_GC_CHARACTER_UPDATE2 = 117, HEADER_GC_LOGIN_KEY = 118, HEADER_GC_REFINE_INFORMATION_NEW = 119, HEADER_GC_CHARACTER_ADD2 = 120, HEADER_GC_CHANNEL = 121, HEADER_GC_MALL_OPEN = 122, HEADER_GC_TARGET_UPDATE = 123, HEADER_GC_TARGET_DELETE = 124, HEADER_GC_TARGET_CREATE_NEW = 125, HEADER_GC_AFFECT_ADD = 126, HEADER_GC_AFFECT_REMOVE = 127, 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_GUILD_SYMBOL_DATA = 133, HEADER_GC_DIG_MOTION = 134, 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 HEADER_GC_AUTH_SUCCESS_OPENID = 154, HEADER_GC_RUNUP_MATRIX_QUIZ = 201, HEADER_GC_NEWCIBN_PASSPOD_REQUEST = 202, HEADER_GC_NEWCIBN_PASSPOD_FAILURE = 203, #if defined(GAIDEN) HEADER_GC_ONTIME = 204, HEADER_GC_RESET_ONTIME = 205, // AUTOBAN HEADER_GC_AUTOBAN_QUIZ = 206, // END_OF_AUTOBAN HEADER_GC_HS_REQUEST = 207, // Origially it's 204 on devel branch #else HEADER_GC_HS_REQUEST = 204, HEADER_GC_XTRAP_CS1_REQUEST = 205, #endif #ifdef __AUCTION__ HEADER_GC_AUCTOIN_ITEM_LIST = 206, #endif HEADER_GC_SPECIFIC_EFFECT = 208, HEADER_GC_DRAGON_SOUL_REFINE = 209, HEADER_GC_RESPOND_CHANNELSTATUS = 210, HEADER_GC_HANDSHAKE_OK = 0xfc, // 252 HEADER_GC_PHASE = 0xfd, // 253 HEADER_GC_BINDUDP = 0xfe, // 254 HEADER_GC_HANDSHAKE = 0xff, // 255 ///////////////////////////////////////////////// // Client To Client for UDP /* HEADER_CC_STATE_WAITING = 1, HEADER_CC_STATE_WALKING = 2, HEADER_CC_STATE_GOING = 3, HEADER_CC_EVENT_NORMAL_ATTACKING = 4, HEADER_CC_EVENT_COMBO_ATTACKING = 5, HEADER_CC_EVENT_HIT = 6, */ }; enum { ID_MAX_NUM = 30, PASS_MAX_NUM = 16, CHAT_MAX_NUM = 128, PATH_NODE_MAX_NUM = 64, SHOP_SIGN_MAX_LEN = 32, PLAYER_PER_ACCOUNT3 = 3, PLAYER_PER_ACCOUNT4 = 4, PLAYER_ITEM_SLOT_MAX_NUM = 20, // 플래이어의 슬롯당 들어가는 갯수. QUICKSLOT_MAX_LINE = 4, QUICKSLOT_MAX_COUNT_PER_LINE = 8, // 클라이언트 임의 결정값 QUICKSLOT_MAX_COUNT = QUICKSLOT_MAX_LINE * QUICKSLOT_MAX_COUNT_PER_LINE, QUICKSLOT_MAX_NUM = 36, // 서버와 맞춰져 있는 값 SHOP_HOST_ITEM_MAX_NUM = 40, METIN_SOCKET_COUNT = 6, PARTY_AFFECT_SLOT_MAX_NUM = 7, GUILD_GRADE_NAME_MAX_LEN = 8, GUILD_NAME_MAX_LEN = 12, GUILD_GRADE_COUNT = 15, GULID_COMMENT_MAX_LEN = 50, MARK_CRC_NUM = 8*8, MARK_DATA_SIZE = 16*12, SYMBOL_DATA_SIZE = 128*256, QUEST_INPUT_STRING_MAX_NUM = 64, PRIVATE_CODE_LENGTH = 8, REFINE_MATERIAL_MAX_NUM = 5, CHINA_MATRIX_ANSWER_MAX_LEN = 8, RUNUP_MATRIX_QUIZ_MAX_LEN = 8, RUNUP_MATRIX_ANSWER_MAX_LEN = 4, NEWCIBN_PASSPOD_ANSWER_MAX_LEN = 8, NEWCIBN_PASSPOD_FAILURE_MAX_LEN = 128, WEAR_MAX_NUM = 11, OPENID_AUTHKEY_LEN = 32, SHOP_TAB_NAME_MAX = 32, SHOP_TAB_COUNT_MAX = 3, }; #pragma pack(push) #pragma pack(1) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 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 handle; } TPacketCGSymbolUpload; typedef struct command_symbol_crc { BYTE header; DWORD dwGuildID; DWORD dwCRC; DWORD dwSize; } TPacketCGSymbolCRC; typedef struct packet_symbol_data { BYTE header; WORD size; DWORD guild_id; } TPacketGCGuildSymbolData; // // // typedef struct packet_observer_add { BYTE header; DWORD vid; WORD x; WORD y; } TPacketGCObserverAdd; typedef struct packet_observer_move { BYTE header; DWORD vid; WORD x; WORD y; } TPacketGCObserverMove; typedef struct packet_observer_remove { BYTE header; DWORD vid; } TPacketGCObserverRemove; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // To Server typedef struct command_checkin { BYTE header; char name[ID_MAX_NUM+1]; char pwd[PASS_MAX_NUM+1]; } TPacketCGCheckin; typedef struct command_login { BYTE header; char name[ID_MAX_NUM + 1]; char pwd[PASS_MAX_NUM + 1]; } TPacketCGLogin; // start - 권한 서버 접속을 위한 패킷들 typedef struct command_login2 { BYTE header; char name[ID_MAX_NUM + 1]; DWORD login_key; DWORD adwClientKey[4]; } TPacketCGLogin2; typedef struct command_login3 { BYTE header; char name[ID_MAX_NUM + 1]; char pwd[PASS_MAX_NUM + 1]; DWORD adwClientKey[4]; } TPacketCGLogin3; typedef struct command_login5 { BYTE header; char authKey[OPENID_AUTHKEY_LEN + 1]; DWORD adwClientKey[4]; } TPacketCGLogin5; // end - 권한 서버 접속을 위한 패킷들 typedef struct command_direct_enter { BYTE bHeader; char login[ID_MAX_NUM + 1]; char passwd[PASS_MAX_NUM + 1]; BYTE index; } TPacketCGDirectEnter; typedef struct command_player_select { BYTE header; BYTE player_index; } TPacketCGSelectCharacter; typedef struct command_attack { BYTE header; BYTE bType; // 공격 유형 DWORD dwVictimVID; // 적 VID BYTE bCRCMagicCubeProcPiece; BYTE bCRCMagicCubeFilePiece; } TPacketCGAttack; typedef struct command_chat { BYTE header; WORD length; BYTE type; } TPacketCGChat; typedef struct command_whisper { BYTE bHeader; WORD wSize; char szNameTo[CHARACTER_NAME_MAX_LEN + 1]; } TPacketCGWhisper; typedef struct command_sms { BYTE bHeader; WORD wSize; char szNameTo[CHARACTER_NAME_MAX_LEN + 1]; } TPacketCGSMS; enum EBattleMode { BATTLEMODE_ATTACK = 0, BATTLEMODE_DEFENSE = 1, }; typedef struct command_EnterFrontGame { BYTE header; } TPacketCGEnterFrontGame; typedef struct command_item_use { BYTE header; TItemPos pos; } TPacketCGItemUse; typedef struct command_item_use_to_item { BYTE header; TItemPos source_pos; TItemPos target_pos; } TPacketCGItemUseToItem; typedef struct command_item_drop { BYTE header; TItemPos pos; DWORD elk; } TPacketCGItemDrop; typedef struct command_item_drop2 { BYTE header; TItemPos pos; DWORD gold; BYTE count; } TPacketCGItemDrop2; typedef struct command_item_move { BYTE header; TItemPos pos; TItemPos change_pos; BYTE num; } 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; typedef struct command_on_click { BYTE header; DWORD vid; } TPacketCGOnClick; enum { SHOP_SUBHEADER_CG_END, SHOP_SUBHEADER_CG_BUY, SHOP_SUBHEADER_CG_SELL, SHOP_SUBHEADER_CG_SELL2, }; typedef struct command_shop { BYTE header; BYTE subheader; } TPacketCGShop; 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 elk EXCHANGE_SUBHEADER_CG_ACCEPT, // arg1 == not used EXCHANGE_SUBHEADER_CG_CANCEL, // arg1 == not used }; typedef struct command_exchange { BYTE header; BYTE subheader; 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; } TPacketCGScriptAnswer; typedef struct command_script_button { BYTE header; unsigned int idx; } TPacketCGScriptButton; typedef struct command_target { BYTE header; DWORD dwVID; } TPacketCGTarget; 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; typedef struct command_fly_targeting { BYTE bHeader; DWORD dwTargetVID; long lX; long lY; } TPacketCGFlyTargeting; typedef struct packet_fly_targeting { BYTE bHeader; DWORD dwShooterVID; DWORD dwTargetVID; long lX; long lY; } TPacketGCFlyTargeting; typedef struct packet_shoot { BYTE bHeader; BYTE bType; } TPacketCGShoot; typedef struct command_warp { BYTE bHeader; } TPacketCGWarp; 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_list_offline { BYTE connected; // always 0 BYTE length; } TPacketGCMessengerListOffline; enum { MESSENGER_CONNECTED_STATE_OFFLINE, MESSENGER_CONNECTED_STATE_ONLINE, MESSENGER_CONNECTED_STATE_MOBILE, }; typedef struct packet_messenger_list_online { BYTE connected; BYTE length; //BYTE length_char_name; } TPacketGCMessengerListOnline; typedef struct packet_messenger_login { //BYTE length_login; //BYTE length_char_name; BYTE length; } TPacketGCMessengerLogin; typedef struct packet_messenger_logout { BYTE length; } TPacketGCMessengerLogout; enum { MESSENGER_SUBHEADER_CG_ADD_BY_VID, MESSENGER_SUBHEADER_CG_ADD_BY_NAME, MESSENGER_SUBHEADER_CG_REMOVE, }; typedef struct command_messenger { BYTE header; BYTE subheader; } TPacketCGMessenger; typedef struct command_messenger_remove { BYTE length; } TPacketCGMessengerRemove; enum { SAFEBOX_MONEY_STATE_SAVE, SAFEBOX_MONEY_STATE_WITHDRAW, }; typedef struct command_safebox_money { BYTE bHeader; BYTE bState; DWORD dwMoney; } TPacketCGSafeboxMoney; typedef struct command_safebox_checkout { BYTE bHeader; BYTE bSafePos; TItemPos ItemPos; } TPacketCGSafeboxCheckout; typedef struct command_safebox_checkin { BYTE bHeader; BYTE bSafePos; TItemPos ItemPos; } TPacketCGSafeboxCheckin; typedef struct command_mall_checkout { BYTE bHeader; BYTE bMallPos; TItemPos ItemPos; } TPacketCGMallCheckout; /////////////////////////////////////////////////////////////////////////////////// // Party typedef struct command_use_skill { BYTE bHeader; DWORD dwVnum; DWORD dwTargetVID; } TPacketCGUseSkill; typedef struct command_party_invite { BYTE header; DWORD vid; } TPacketCGPartyInvite; typedef struct command_party_invite_answer { BYTE header; DWORD leader_pid; BYTE accept; } TPacketCGPartyInviteAnswer; typedef struct command_party_remove { BYTE header; DWORD pid; } TPacketCGPartyRemove; typedef struct command_party_set_state { BYTE byHeader; DWORD dwVID; BYTE byState; BYTE byFlag; } TPacketCGPartySetState; 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_use_skill { BYTE byHeader; BYTE bySkillIndex; DWORD dwTargetVID; } TPacketCGPartyUseSkill; enum { 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 command_guild { BYTE byHeader; BYTE bySubHeader; } TPacketCGGuild; typedef struct command_guild_answer_make_guild { BYTE header; char guild_name[GUILD_NAME_MAX_LEN+1]; } TPacketCGAnswerMakeGuild; typedef struct command_give_item { BYTE byHeader; DWORD dwTargetVID; TItemPos ItemPos; BYTE byItemCount; } TPacketCGGiveItem; typedef struct SPacketCGHack { BYTE bHeader; char szBuf[255 + 1]; } TPacketCGHack; typedef struct command_dungeon { BYTE bHeader; WORD size; } TPacketCGDungeon; // Private Shop typedef struct SShopItemTable { DWORD vnum; BYTE count; TItemPos pos; // PC 상점에만 이용 DWORD price; // PC 상점에만 이용 BYTE display_pos; // PC 상점에만 이용, 보일 위치. } TShopItemTable; typedef struct SPacketCGMyShop { BYTE bHeader; char szSign[SHOP_SIGN_MAX_LEN + 1]; BYTE bCount; // count of TShopItemTable, max 39 } TPacketCGMyShop; typedef struct SPacketCGRefine { BYTE header; BYTE pos; BYTE type; } TPacketCGRefine; typedef struct SPacketCGChangeName { BYTE header; BYTE index; char name[CHARACTER_NAME_MAX_LEN+1]; } TPacketCGChangeName; 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 command_crc_report { BYTE header; BYTE byPackMode; DWORD dwBinaryCRC32; DWORD dwProcessCRC32; DWORD dwRootPackCRC32; } TPacketCGCRCReport; typedef struct command_china_matrix_card { BYTE bHeader; char szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN + 1]; } TPacketCGChinaMatrixCard; typedef struct command_runup_matrix_answer { BYTE bHeader; char szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN + 1]; } TPacketCGRunupMatrixAnswer; typedef struct command_newcibn_passpod_answer { BYTE bHeader; char szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN + 1]; } TPacketCGNEWCIBNPasspodAnswer; enum EPartyExpDistributionType { PARTY_EXP_DISTRIBUTION_NON_PARITY, PARTY_EXP_DISTRIBUTION_PARITY, }; typedef struct command_party_parameter { BYTE bHeader; BYTE bDistributeMode; } TPacketCGPartyParameter; typedef struct command_quest_input_string { BYTE bHeader; char szString[QUEST_INPUT_STRING_MAX_NUM+1]; } TPacketCGQuestInputString; typedef struct command_quest_confirm { BYTE header; BYTE answer; DWORD requestPID; } TPacketCGQuestConfirm; typedef struct command_script_select_item { BYTE header; DWORD selection; } TPacketCGScriptSelectItem; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // From Server enum EPhase { PHASE_CLOSE, // 끊기는 상태 (또는 끊기 전 상태) PHASE_HANDSHAKE, // 악수..;; PHASE_LOGIN, // 로그인 중 PHASE_SELECT, // 캐릭터 선택 화면 PHASE_LOADING, // 선택 후 로딩 화면 PHASE_GAME, // 게임 화면 PHASE_DEAD, // 죽었을 때.. (게임 안에 있는 것일 수도..) PHASE_DBCLIENT_CONNECTING, // 서버용 PHASE_DBCLIENT, // 서버용 PHASE_P2P, // 서버용 PHASE_AUTH, // 로그인 인증 용 }; typedef struct packet_phase { BYTE header; BYTE phase; } TPacketGCPhase; typedef struct packet_blank // 공백패킷. { BYTE header; } TPacketGCBlank; typedef struct packet_blank_dynamic { BYTE header; WORD size; } TPacketGCBlankDynamic; typedef struct packet_header_handshake { BYTE header; DWORD dwHandshake; DWORD dwTime; LONG lDelta; } TPacketGCHandshake; typedef struct packet_header_bindudp { BYTE header; DWORD addr; WORD port; } TPacketGCBindUDP; typedef struct packet_header_dynamic_size { BYTE header; WORD size; } TDynamicSizePacketHeader; typedef struct SSimplePlayerInformation { DWORD dwID; char szName[CHARACTER_NAME_MAX_LEN + 1]; BYTE byJob; BYTE byLevel; DWORD dwPlayMinutes; BYTE byST, byHT, byDX, byIQ; // WORD wParts[CRaceData::PART_MAX_NUM]; WORD wMainPart; BYTE bChangeName; WORD wHairPart; BYTE bDummy[4]; long x, y; LONG lAddr; WORD wPort; BYTE bySkillGroup; } TSimplePlayerInformation; typedef struct packet_login_success3 { BYTE header; TSimplePlayerInformation akSimplePlayerInformation[PLAYER_PER_ACCOUNT3]; DWORD guild_id[PLAYER_PER_ACCOUNT3]; char guild_name[PLAYER_PER_ACCOUNT3][GUILD_NAME_MAX_LEN+1]; DWORD handle; DWORD random_key; } TPacketGCLoginSuccess3; typedef struct packet_login_success4 { BYTE header; TSimplePlayerInformation akSimplePlayerInformation[PLAYER_PER_ACCOUNT4]; DWORD guild_id[PLAYER_PER_ACCOUNT4]; char guild_name[PLAYER_PER_ACCOUNT4][GUILD_NAME_MAX_LEN+1]; DWORD handle; DWORD random_key; } TPacketGCLoginSuccess4; enum { LOGIN_STATUS_MAX_LEN = 8 }; typedef struct packet_login_failure { BYTE header; char szStatus[LOGIN_STATUS_MAX_LEN + 1]; } TPacketGCLoginFailure; 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; } TPacketCGCreateCharacter; typedef struct command_player_create_success { BYTE header; BYTE bAccountCharacterSlot; TSimplePlayerInformation kSimplePlayerInfomation; } TPacketGCPlayerCreateSuccess; typedef struct command_create_failure { BYTE header; BYTE bType; } TPacketGCCreateFailure; typedef struct command_player_delete { BYTE header; BYTE index; char szPrivateCode[PRIVATE_CODE_LENGTH]; } TPacketCGDestroyCharacter; typedef struct packet_player_delete_success { BYTE header; BYTE account_index; } TPacketGCDestroyCharacterSuccess; 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 EPKModes { PK_MODE_PEACE, PK_MODE_REVENGE, PK_MODE_FREE, PK_MODE_PROTECT, PK_MODE_GUILD, PK_MODE_MAX_NUM, }; // 2004.11.20.myevan.CRaceData::PART_MAX_NUM 사용안하게 수정 - 서버에서 사용하는것과 일치하지 않음 enum ECharacterEquipmentPart { CHR_EQUIPPART_ARMOR, CHR_EQUIPPART_WEAPON, CHR_EQUIPPART_HEAD, CHR_EQUIPPART_HAIR, CHR_EQUIPPART_NUM, }; 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; short sAlignment; //선악치 BYTE bPKMode; DWORD dwMountVnum; } TPacketGCCharacterAdditionalInfo; typedef struct packet_add_char { BYTE header; DWORD dwVID; //char name[CHARACTER_NAME_MAX_LEN + 1]; float angle; long x; long y; long z; BYTE bType; WORD wRaceNum; //WORD awPart[CHR_EQUIPPART_NUM]; BYTE bMovingSpeed; BYTE bAttackSpeed; BYTE bStateFlag; DWORD dwAffectFlag[2]; // ?? //BYTE bEmpire; //DWORD dwGuild; //short sAlignment; //BYTE bPKMode; //DWORD dwMountVnum; } TPacketGCCharacterAdd; typedef struct packet_add_char2 { BYTE header; DWORD dwVID; char name[CHARACTER_NAME_MAX_LEN + 1]; float angle; long x; long y; long z; BYTE bType; WORD wRaceNum; WORD awPart[CHR_EQUIPPART_NUM]; BYTE bMovingSpeed; BYTE bAttackSpeed; BYTE bStateFlag; DWORD dwAffectFlag[2]; // ?? BYTE bEmpire; DWORD dwGuild; short sAlignment; BYTE bPKMode; DWORD dwMountVnum; } TPacketGCCharacterAdd2; 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; short sAlignment; BYTE bPKMode; DWORD dwMountVnum; } TPacketGCCharacterUpdate; typedef struct packet_update_char2 { BYTE header; DWORD dwVID; WORD awPart[CHR_EQUIPPART_NUM]; BYTE bMovingSpeed; BYTE bAttackSpeed; BYTE bStateFlag; DWORD dwAffectFlag[2]; DWORD dwGuildID; short sAlignment; BYTE bPKMode; DWORD dwMountVnum; } TPacketGCCharacterUpdate2; typedef struct packet_del_char { BYTE header; DWORD dwVID; } TPacketGCCharacterDelete; typedef struct packet_GlobalTime { BYTE header; float GlobalTime; } TPacketGCGlobalTime; enum EChatType { CHAT_TYPE_TALKING, /* 그냥 채팅 */ CHAT_TYPE_INFO, /* 정보 (아이템을 집었다, 경험치를 얻었다. 등) */ CHAT_TYPE_NOTICE, /* 공지사항 */ CHAT_TYPE_PARTY, /* 파티말 */ CHAT_TYPE_GUILD, /* 길드말 */ CHAT_TYPE_COMMAND, /* 명령 */ CHAT_TYPE_SHOUT, /* 외치기 */ CHAT_TYPE_WHISPER, // 서버와는 연동되지 않는 Only Client Enum CHAT_TYPE_BIG_NOTICE, CHAT_TYPE_MAX_NUM, }; typedef struct packet_chatting { BYTE header; WORD size; BYTE type; DWORD dwVID; BYTE bEmpire; } TPacketGCChat; typedef struct packet_whisper // 가변 패킷 { BYTE bHeader; WORD wSize; BYTE bType; char szNameFrom[CHARACTER_NAME_MAX_LEN + 1]; } TPacketGCWhisper; typedef struct packet_stun { BYTE header; DWORD vid; } TPacketGCStun; typedef struct packet_dead { BYTE header; DWORD vid; } TPacketGCDead; typedef struct packet_main_character { BYTE header; DWORD dwVID; WORD wRaceNum; char szName[CHARACTER_NAME_MAX_LEN + 1]; long lX, lY, lZ; BYTE bySkillGroup; } TPacketGCMainCharacter; // SUPPORT_BGM typedef struct packet_main_character2_empire { BYTE header; DWORD dwVID; WORD wRaceNum; char szName[CHARACTER_NAME_MAX_LEN + 1]; long lX, lY, lZ; BYTE byEmpire; BYTE bySkillGroup; } TPacketGCMainCharacter2_EMPIRE; typedef struct packet_main_character3_bgm { enum { MUSIC_NAME_MAX_LEN = 24, }; BYTE header; DWORD dwVID; WORD wRaceNum; char szUserName[CHARACTER_NAME_MAX_LEN + 1]; char szBGMName[MUSIC_NAME_MAX_LEN + 1]; long lX, lY, lZ; BYTE byEmpire; BYTE bySkillGroup; } TPacketGCMainCharacter3_BGM; typedef struct packet_main_character4_bgm_vol { enum { MUSIC_NAME_MAX_LEN = 24, }; BYTE header; DWORD dwVID; WORD wRaceNum; char szUserName[CHARACTER_NAME_MAX_LEN + 1]; char szBGMName[MUSIC_NAME_MAX_LEN + 1]; float fBGMVol; long lX, lY, lZ; BYTE byEmpire; BYTE bySkillGroup; } TPacketGCMainCharacter4_BGM_VOL; // END_OF_SUPPORT_BGM enum EPointTypes { POINT_NONE, // 0 POINT_LEVEL, // 1 POINT_VOICE, // 2 POINT_EXP, // 3 POINT_NEXT_EXP, // 4 POINT_HP, // 5 POINT_MAX_HP, // 6 POINT_SP, // 7 POINT_MAX_SP, // 8 POINT_STAMINA, // 9 스테미너 POINT_MAX_STAMINA, // 10 최대 스테미너 POINT_GOLD, // 11 POINT_ST, // 12 근력 POINT_HT, // 13 체력 POINT_DX, // 14 민첩성 POINT_IQ, // 15 정신력 POINT_ATT_POWER, // 16 공격력 POINT_ATT_SPEED, // 17 공격속도 POINT_EVADE_RATE, // 18 회피율 POINT_MOV_SPEED, // 19 이동속도 POINT_DEF_GRADE, // 20 방어등급 POINT_CASTING_SPEED, // 21 주문속도 (쿨다운타임*100) / (100 + 이값) = 최종 쿨다운 타임 POINT_MAGIC_ATT_GRADE, // 22 마법공격력 POINT_MAGIC_DEF_GRADE, // 23 마법방어력 POINT_EMPIRE_POINT, // 24 제국점수 POINT_LEVEL_STEP, // 25 한 레벨에서의 단계.. (1 2 3 될 때 보상, 4 되면 레벨 업) POINT_STAT, // 26 능력치 올릴 수 있는 개수 POINT_SUB_SKILL, // 27 보조 스킬 포인트 POINT_SKILL, // 28 액티브 스킬 포인트 // POINT_SKILL_PASV, // 27 패시브 기술 올릴 수 있는 개수 // POINT_SKILL_ACTIVE, // 28 액티브 스킬 포인트 POINT_MIN_ATK, // 29 최소 파괴력 POINT_MAX_ATK, // 30 최대 파괴력 POINT_PLAYTIME, // 31 플레이시간 POINT_HP_REGEN, // 32 HP 회복률 POINT_SP_REGEN, // 33 SP 회복률 POINT_BOW_DISTANCE, // 34 활 사정거리 증가치 (meter) POINT_HP_RECOVERY, // 35 체력 회복 증가량 POINT_SP_RECOVERY, // 36 정신력 회복 증가량 POINT_POISON_PCT, // 37 독 확률 POINT_STUN_PCT, // 38 기절 확률 POINT_SLOW_PCT, // 39 슬로우 확률 POINT_CRITICAL_PCT, // 40 크리티컬 확률 POINT_PENETRATE_PCT, // 41 관통타격 확률 POINT_CURSE_PCT, // 42 저주 확률 POINT_ATTBONUS_HUMAN, // 43 인간에게 강함 POINT_ATTBONUS_ANIMAL, // 44 동물에게 데미지 % 증가 POINT_ATTBONUS_ORC, // 45 웅귀에게 데미지 % 증가 POINT_ATTBONUS_MILGYO, // 46 밀교에게 데미지 % 증가 POINT_ATTBONUS_UNDEAD, // 47 시체에게 데미지 % 증가 POINT_ATTBONUS_DEVIL, // 48 마귀(악마)에게 데미지 % 증가 POINT_ATTBONUS_INSECT, // 49 벌레족 POINT_ATTBONUS_FIRE, // 50 화염족 POINT_ATTBONUS_ICE, // 51 빙설족 POINT_ATTBONUS_DESERT, // 52 사막족 POINT_ATTBONUS_UNUSED0, // 53 UNUSED0 POINT_ATTBONUS_UNUSED1, // 54 UNUSED1 POINT_ATTBONUS_UNUSED2, // 55 UNUSED2 POINT_ATTBONUS_UNUSED3, // 56 UNUSED3 POINT_ATTBONUS_UNUSED4, // 57 UNUSED4 POINT_ATTBONUS_UNUSED5, // 58 UNUSED5 POINT_ATTBONUS_UNUSED6, // 59 UNUSED6 POINT_ATTBONUS_UNUSED7, // 60 UNUSED7 POINT_ATTBONUS_UNUSED8, // 61 UNUSED8 POINT_ATTBONUS_UNUSED9, // 62 UNUSED9 POINT_STEAL_HP, // 63 생명력 흡수 POINT_STEAL_SP, // 64 정신력 흡수 POINT_MANA_BURN_PCT, // 65 마나 번 /// 피해시 보너스 /// POINT_DAMAGE_SP_RECOVER, // 66 공격당할 시 정신력 회복 확률 POINT_BLOCK, // 67 블럭율 POINT_DODGE, // 68 회피율 POINT_RESIST_SWORD, // 69 POINT_RESIST_TWOHAND, // 70 POINT_RESIST_DAGGER, // 71 POINT_RESIST_BELL, // 72 POINT_RESIST_FAN, // 73 POINT_RESIST_BOW, // 74 화살 저항 : 대미지 감소 POINT_RESIST_FIRE, // 75 화염 저항 : 화염공격에 대한 대미지 감소 POINT_RESIST_ELEC, // 76 전기 저항 : 전기공격에 대한 대미지 감소 POINT_RESIST_MAGIC, // 77 술법 저항 : 모든술법에 대한 대미지 감소 POINT_RESIST_WIND, // 78 바람 저항 : 바람공격에 대한 대미지 감소 POINT_REFLECT_MELEE, // 79 공격 반사 /// 특수 피해시 /// POINT_REFLECT_CURSE, // 80 저주 반사 POINT_POISON_REDUCE, // 81 독데미지 감소 /// 적 소멸시 /// POINT_KILL_SP_RECOVER, // 82 적 소멸시 MP 회복 POINT_EXP_DOUBLE_BONUS, // 83 POINT_GOLD_DOUBLE_BONUS, // 84 POINT_ITEM_DROP_BONUS, // 85 /// 회복 관련 /// POINT_POTION_BONUS, // 86 POINT_KILL_HP_RECOVER, // 87 POINT_IMMUNE_STUN, // 88 POINT_IMMUNE_SLOW, // 89 POINT_IMMUNE_FALL, // 90 ////////////////// POINT_PARTY_ATT_GRADE, // 91 POINT_PARTY_DEF_GRADE, // 92 POINT_ATT_BONUS, // 93 POINT_DEF_BONUS, // 94 POINT_ATT_GRADE_BONUS, // 95 POINT_DEF_GRADE_BONUS, // 96 POINT_MAGIC_ATT_GRADE_BONUS, // 97 POINT_MAGIC_DEF_GRADE_BONUS, // 98 POINT_RESIST_NORMAL_DAMAGE, // 99 POINT_STAT_RESET_COUNT = 112, POINT_HORSE_SKILL = 113, POINT_MALL_ATTBONUS, // 114 공격력 +x% POINT_MALL_DEFBONUS, // 115 방어력 +x% POINT_MALL_EXPBONUS, // 116 경험치 +x% POINT_MALL_ITEMBONUS, // 117 아이템 드롭율 x/10배 POINT_MALL_GOLDBONUS, // 118 돈 드롭율 x/10배 POINT_MAX_HP_PCT, // 119 최대생명력 +x% POINT_MAX_SP_PCT, // 120 최대정신력 +x% POINT_SKILL_DAMAGE_BONUS, // 121 스킬 데미지 *(100+x)% POINT_NORMAL_HIT_DAMAGE_BONUS, // 122 평타 데미지 *(100+x)% POINT_SKILL_DEFEND_BONUS, // 123 스킬 방어 데미지 POINT_NORMAL_HIT_DEFEND_BONUS, // 124 평타 방어 데미지 POINT_PC_BANG_EXP_BONUS, // 125 POINT_PC_BANG_DROP_BONUS, // 126 PC방 전용 드롭률 보너스 POINT_ENERGY = 128, // 128 기력 // 기력 ui 용. // 이렇게 하고 싶지 않았지만, // uiTaskBar에서는 affect에 접근할 수 없고, // 더구나 클라리언트에서는 blend_affect는 관리하지 않아, // 임시로 이렇게 둔다. POINT_ENERGY_END_TIME = 129, // 129 기력 종료 시간 // 클라이언트 포인트 POINT_MIN_WEP = 200, POINT_MAX_WEP, POINT_MIN_MAGIC_WEP, POINT_MAX_MAGIC_WEP, POINT_HIT_RATE, //POINT_MAX_NUM = 255,=>stdafx.h 로/ }; typedef struct packet_points { BYTE header; long points[POINT_MAX_NUM]; } TPacketGCPoints; typedef struct packet_point_change { BYTE header; DWORD dwVID; BYTE Type; long amount; // 바뀐 값 long value; // 현재 값 } TPacketGCPointChange; typedef struct packet_motion { BYTE header; DWORD vid; DWORD victim_vid; WORD motion; } TPacketGCMotion; #if defined(GAIDEN) struct TPacketGCItemDelDeprecate { TPacketGCItemDelDeprecate() : header(HEADER_GC_ITEM_DEL), pos(0), vnum(0), count(0) { memset(&alSockets, 0, sizeof(alSockets)); memset(&aAttr, 0, sizeof(aAttr)); } BYTE header; BYTE pos; DWORD vnum; BYTE count; long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; }; typedef struct packet_set_item { BYTE header; BYTE pos; DWORD vnum; BYTE count; DWORD flags; // 플래그 추가 long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TPacketGCItemSet; typedef struct packet_item_del { BYTE header; BYTE pos; } TPacketGCItemDel; #else typedef struct packet_set_item { BYTE header; TItemPos Cell; DWORD vnum; BYTE count; long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TPacketGCItemSet; typedef struct packet_set_item2 { BYTE header; TItemPos Cell; DWORD vnum; BYTE count; DWORD flags; // 플래그 추가 DWORD anti_flags; // 플래그 추가 bool highlight; long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TPacketGCItemSet2; #endif typedef struct packet_item_del { BYTE header; BYTE pos; } TPacketGCItemDel; typedef struct packet_use_item { BYTE header; TItemPos Cell; DWORD ch_vid; DWORD victim_vid; DWORD vnum; } TPacketGCItemUse; typedef struct packet_update_item { BYTE header; TItemPos Cell; BYTE count; long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TPacketGCItemUpdate; typedef struct packet_ground_add_item { BYTE bHeader; long lX; long lY; long lZ; DWORD dwVID; DWORD dwVnum; } TPacketGCItemGroundAdd; typedef struct packet_ground_del_item { BYTE header; DWORD vid; } TPacketGCItemGroundDel; typedef struct packet_item_ownership { BYTE bHeader; DWORD dwVID; char szName[CHARACTER_NAME_MAX_LEN + 1]; } TPacketGCItemOwnership; typedef struct packet_quickslot_add { BYTE header; BYTE pos; TQuickSlot slot; } TPacketGCQuickSlotAdd; typedef struct packet_quickslot_del { BYTE header; BYTE pos; } TPacketGCQuickSlotDel; typedef struct packet_quickslot_swap { BYTE header; BYTE pos; BYTE change_pos; } TPacketGCQuickSlotSwap; typedef struct packet_shop_start { 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 iElkAmount; } TPacketGCShopUpdatePrice; 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, }; typedef struct packet_shop { BYTE header; WORD size; BYTE subheader; } TPacketGCShop; typedef struct packet_exchange { BYTE header; BYTE subheader; BYTE is_me; DWORD arg1; TItemPos arg2; DWORD arg3; long alValues[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TPacketGCExchange; enum { EXCHANGE_SUBHEADER_GC_START, // arg1 == vid EXCHANGE_SUBHEADER_GC_ITEM_ADD, // arg1 == vnum arg2 == pos arg3 == count EXCHANGE_SUBHEADER_GC_ITEM_DEL, // arg1 == pos EXCHANGE_SUBHEADER_GC_ELK_ADD, // arg1 == elk EXCHANGE_SUBHEADER_GC_ACCEPT, // arg1 == accept EXCHANGE_SUBHEADER_GC_END, // arg1 == not used EXCHANGE_SUBHEADER_GC_ALREADY, // arg1 == not used EXCHANGE_SUBHEADER_GC_LESS_ELK, // arg1 == not used }; typedef struct packet_position { BYTE header; DWORD vid; BYTE position; } TPacketGCPosition; typedef struct packet_ping { BYTE header; } TPacketGCPing; typedef struct packet_pong { BYTE bHeader; } TPacketCGPong; typedef struct packet_script { BYTE header; WORD size; BYTE skin; WORD src_size; } TPacketGCScript; typedef struct packet_target { BYTE header; DWORD dwVID; BYTE bHPPercent; } TPacketGCTarget; typedef struct packet_damage_info { BYTE header; DWORD dwVID; BYTE flag; int damage; } TPacketGCDamageInfo; typedef struct packet_mount { BYTE header; DWORD vid; DWORD mount_vid; BYTE pos; DWORD _x, _y; } TPacketGCMount; typedef struct packet_change_speed { BYTE header; DWORD vid; WORD moving_speed; } TPacketGCChangeSpeed; typedef struct packet_move { BYTE bHeader; BYTE bFunc; BYTE bArg; BYTE bRot; DWORD dwVID; LONG lX; LONG lY; DWORD dwTime; DWORD dwDuration; } TPacketGCMove; enum { QUEST_SEND_IS_BEGIN = 1 << 0, QUEST_SEND_TITLE = 1 << 1, // 28자 까지 QUEST_SEND_CLOCK_NAME = 1 << 2, // 16자 까지 QUEST_SEND_CLOCK_VALUE = 1 << 3, QUEST_SEND_COUNTER_NAME = 1 << 4, // 16자 까지 QUEST_SEND_COUNTER_VALUE = 1 << 5, QUEST_SEND_ICON_FILE = 1 << 6, // 24자 까지 }; typedef struct packet_quest_info { BYTE header; WORD size; WORD index; BYTE flag; } TPacketGCQuestInfo; typedef struct packet_quest_confirm { BYTE header; char msg[64+1]; long timeout; DWORD requestPID; } TPacketGCQuestConfirm; typedef struct packet_attack { BYTE header; DWORD dwVID; DWORD dwVictimVID; // 적 VID BYTE bType; // 공격 유형 } TPacketGCAttack; typedef struct packet_c2c { BYTE header; WORD wSize; } TPacketGCC2C; typedef struct packetd_sync_position_element { DWORD dwVID; long lX; long lY; } TPacketGCSyncPositionElement; typedef struct packetd_sync_position { BYTE bHeader; WORD wSize; } TPacketGCSyncPosition; typedef struct packet_ownership { BYTE bHeader; DWORD dwOwnerVID; DWORD dwVictimVID; } TPacketGCOwnership; #define SKILL_MAX_NUM 255 typedef struct packet_skill_level { BYTE bHeader; BYTE abSkillLevels[SKILL_MAX_NUM]; } TPacketGCSkillLevel; typedef struct SPlayerSkill { BYTE bMasterType; BYTE bLevel; time_t tNextRead; } TPlayerSkill; typedef struct packet_skill_level_new { BYTE bHeader; TPlayerSkill skills[SKILL_MAX_NUM]; } TPacketGCSkillLevelNew; // fly typedef struct packet_fly { BYTE bHeader; BYTE bType; DWORD dwStartVID; DWORD dwEndVID; } TPacketGCCreateFly; enum EPVPModes { PVP_MODE_NONE, PVP_MODE_AGREE, PVP_MODE_FIGHT, PVP_MODE_REVENGE, }; typedef struct packet_duel_start { BYTE header ; WORD wSize ; // DWORD가 몇개? 개수 = (wSize - sizeof(TPacketGCPVPList)) / 4 } TPacketGCDuelStart ; typedef struct packet_pvp { BYTE header; DWORD dwVIDSrc; DWORD dwVIDDst; BYTE bMode; } TPacketGCPVP; typedef struct packet_skill_cooltime_end { BYTE header; BYTE bSkill; } TPacketGCSkillCoolTimeEnd; typedef struct packet_warp { BYTE bHeader; LONG lX; LONG lY; LONG lAddr; WORD wPort; } TPacketGCWarp; typedef struct packet_party_invite { BYTE header; DWORD leader_pid; } TPacketGCPartyInvite; typedef struct packet_party_add { BYTE header; DWORD pid; char name[CHARACTER_NAME_MAX_LEN+1]; } TPacketGCPartyAdd; typedef struct packet_party_update { BYTE header; DWORD pid; BYTE state; BYTE percent_hp; short affects[PARTY_AFFECT_SLOT_MAX_NUM]; } TPacketGCPartyUpdate; typedef struct packet_party_remove { BYTE header; DWORD pid; } TPacketGCPartyRemove; typedef TPacketCGSafeboxCheckout TPacketGCSafeboxCheckout; typedef TPacketCGSafeboxCheckin TPacketGCSafeboxCheckin; typedef struct packet_safebox_wrong_password { BYTE bHeader; } TPacketGCSafeboxWrongPassword; typedef struct packet_safebox_size { BYTE bHeader; BYTE bSize; } TPacketGCSafeboxSize; typedef struct packet_safebox_money_change { BYTE bHeader; DWORD dwMoney; } TPacketGCSafeboxMoneyChange; typedef struct command_empire { BYTE bHeader; BYTE bEmpire; } TPacketCGEmpire; typedef struct packet_empire { BYTE bHeader; BYTE bEmpire; } TPacketGCEmpire; 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 packet_fishing { BYTE header; BYTE subheader; DWORD info; BYTE dir; } TPacketGCFishing; typedef struct paryt_parameter { BYTE bHeader; BYTE bDistributeMode; } TPacketGCPartyParameter; ////////////////////////////////////////////////////////////////////////// // 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_POINT, GUILD_SUBHEADER_GC_MONEY_CHANGE, }; typedef struct packet_guild { BYTE header; WORD size; BYTE subheader; } TPacketGCGuild; // SubHeader - Grade enum { GUILD_AUTH_ADD_MEMBER = (1 << 0), GUILD_AUTH_REMOVE_MEMBER = (1 << 1), GUILD_AUTH_NOTICE = (1 << 2), GUILD_AUTH_SKILL = (1 << 3), }; typedef struct packet_guild_sub_grade { char grade_name[GUILD_GRADE_NAME_MAX_LEN+1]; // 8+1 길드장, 길드원 등의 이름 BYTE auth_flag; } TPacketGCGuildSubGrade; typedef struct packet_guild_sub_member { DWORD pid; BYTE byGrade; BYTE byIsGeneral; BYTE byJob; BYTE byLevel; DWORD dwOffer; BYTE byNameFlag; // if NameFlag is TRUE, name is sent from server. // char szName[CHARACTER_ME_MAX_LEN+1]; } TPacketGCGuildSubMember; typedef struct packet_guild_sub_info { WORD member_count; WORD max_member_count; DWORD guild_id; DWORD master_pid; DWORD exp; BYTE level; char name[GUILD_NAME_MAX_LEN+1]; DWORD gold; BYTE hasLand; } TPacketGCGuildInfo; enum EGuildWarState { GUILD_WAR_NONE, GUILD_WAR_SEND_DECLARE, GUILD_WAR_REFUSE, GUILD_WAR_RECV_DECLARE, GUILD_WAR_WAIT_START, GUILD_WAR_CANCEL, GUILD_WAR_ON_WAR, GUILD_WAR_END, GUILD_WAR_DURATION = 2*60*60, // 2시간 }; typedef struct packet_guild_war { DWORD dwGuildSelf; DWORD dwGuildOpp; BYTE bType; BYTE bWarState; } TPacketGCGuildWar; typedef struct SPacketGuildWarPoint { DWORD dwGainGuildID; DWORD dwOpponentGuildID; long lPoint; } TPacketGuildWarPoint; // 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; // Private Shop typedef struct SPacketGCShopSign { BYTE bHeader; DWORD dwVID; char szSign[SHOP_SIGN_MAX_LEN + 1]; } TPacketGCShopSign; 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; struct TMaterial { DWORD vnum; DWORD count; }; typedef struct SRefineTable { DWORD src_vnum; DWORD result_vnum; BYTE material_count; int cost; // 소요 비용 int prob; // 확률 TMaterial materials[REFINE_MATERIAL_MAX_NUM]; } TRefineTable; typedef struct SPacketGCRefineInformation { BYTE header; BYTE pos; TRefineTable refine_table; } TPacketGCRefineInformation; typedef struct SPacketGCRefineInformationNew { BYTE header; BYTE type; BYTE pos; TRefineTable refine_table; } TPacketGCRefineInformationNew; enum SPECIAL_EFFECT { SE_NONE, SE_HPUP_RED, SE_SPUP_BLUE, SE_SPEEDUP_GREEN, SE_DXUP_PURPLE, SE_CRITICAL, SE_PENETRATE, SE_BLOCK, SE_DODGE, SE_CHINA_FIREWORK, SE_SPIN_TOP, SE_SUCCESS, SE_FAIL, SE_FR_SUCCESS, SE_LEVELUP_ON_14_FOR_GERMANY, //레벨업 14일때 ( 독일전용 ) SE_LEVELUP_UNDER_15_FOR_GERMANY,//레벨업 15일때 ( 독일전용 ) SE_PERCENT_DAMAGE1, SE_PERCENT_DAMAGE2, SE_PERCENT_DAMAGE3, SE_AUTO_HPUP, SE_AUTO_SPUP, SE_EQUIP_RAMADAN_RING, // 초승달의 반지를 착용하는 순간에 발동하는 이펙트 SE_EQUIP_HALLOWEEN_CANDY, // 할로윈 사탕을 착용(-_-;)한 순간에 발동하는 이펙트 SE_EQUIP_HAPPINESS_RING, // 크리스마스 행복의 반지를 착용하는 순간에 발동하는 이펙트 SE_EQUIP_LOVE_PENDANT, // 발렌타인 사랑의 팬던트(71145) 착용할 때 이펙트 (발동이펙트임, 지속이펙트 아님) }; typedef struct SPacketGCSpecialEffect { BYTE header; BYTE type; DWORD vid; } TPacketGCSpecialEffect; typedef struct SPacketGCNPCPosition { BYTE header; WORD size; WORD count; } TPacketGCNPCPosition; struct TNPCPosition { BYTE bType; char name[CHARACTER_NAME_MAX_LEN+1]; long x; long y; }; typedef struct SPacketGCChangeName { BYTE header; DWORD pid; char name[CHARACTER_NAME_MAX_LEN+1]; } TPacketGCChangeName; enum EBlockAction { BLOCK_EXCHANGE = (1 << 0), BLOCK_PARTY_INVITE = (1 << 1), BLOCK_GUILD_INVITE = (1 << 2), BLOCK_WHISPER = (1 << 3), BLOCK_MESSENGER_INVITE = (1 << 4), BLOCK_PARTY_REQUEST = (1 << 5), }; typedef struct packet_china_matrixd_card { BYTE bHeader; DWORD dwRows; DWORD dwCols; } TPacketGCChinaMatrixCard; typedef struct packet_runup_matrixd_quiz { BYTE bHeader; char szQuiz[RUNUP_MATRIX_QUIZ_MAX_LEN + 1]; } TPacketGCRunupMatrixQuiz; typedef struct packet_newcibn_passpod_request { BYTE bHeader; } TPacketGCNEWCIBNPasspodRequest; typedef struct packet_newcibn_passpod_failure { BYTE bHeader; char szMessage[NEWCIBN_PASSPOD_FAILURE_MAX_LEN + 1]; } TPacketGCNEWCIBNPasspodFailure; typedef struct packet_login_key { BYTE bHeader; DWORD dwLoginKey; } TPacketGCLoginKey; typedef struct packet_auth_success { BYTE bHeader; DWORD dwLoginKey; BYTE bResult; } TPacketGCAuthSuccess; typedef struct packet_auth_success_openid { BYTE bHeader; DWORD dwLoginKey; BYTE bResult; char login[ID_MAX_NUM + 1]; } TPacketGCAuthSuccessOpenID; typedef struct packet_channel { BYTE header; BYTE channel; } TPacketGCChannel; typedef struct SEquipmentItemSet { DWORD vnum; BYTE count; long alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM]; } TEquipmentItemSet; typedef struct pakcet_view_equip { BYTE header; DWORD dwVID; TEquipmentItemSet equips[WEAR_MAX_NUM]; } TPacketGCViewEquip; 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 szTargetName[32+1]; } TPacketGCTargetCreate; enum { CREATE_TARGET_TYPE_NONE, CREATE_TARGET_TYPE_LOCATION, CREATE_TARGET_TYPE_CHARACTER, }; typedef struct { BYTE bHeader; long lID; char szTargetName[32+1]; DWORD dwVID; BYTE byType; } TPacketGCTargetCreateNew; typedef struct { BYTE bHeader; long lID; long lX, lY; } TPacketGCTargetUpdate; typedef struct { BYTE bHeader; long lID; } TPacketGCTargetDelete; typedef struct { DWORD dwType; BYTE bPointIdxApplyOn; long lApplyValue; DWORD dwFlag; long lDuration; long lSPCost; } TPacketAffectElement; typedef struct { BYTE bHeader; TPacketAffectElement elem; } TPacketGCAffectAdd; typedef struct { BYTE bHeader; DWORD dwType; BYTE bApplyOn; } TPacketGCAffectRemove; typedef struct packet_mall_open { BYTE bHeader; BYTE bSize; } TPacketGCMallOpen; typedef struct packet_lover_info { BYTE bHeader; char szName[CHARACTER_NAME_MAX_LEN + 1]; BYTE byLovePoint; } TPacketGCLoverInfo; typedef struct packet_love_point_update { BYTE bHeader; BYTE byLovePoint; } TPacketGCLovePointUpdate; typedef struct packet_dig_motion { BYTE header; DWORD vid; DWORD target_vid; BYTE count; } TPacketGCDigMotion; typedef struct SPacketGCOnTime { BYTE header; int ontime; // sec } TPacketGCOnTime; typedef struct SPacketGCResetOnTime { BYTE header; } TPacketGCResetOnTime; typedef struct SPacketGCPanamaPack { BYTE bHeader; char szPackName[256]; BYTE abIV[32]; } TPacketGCPanamaPack; typedef struct SPacketGCHybridCryptKeys { private: SPacketGCHybridCryptKeys() : m_pStream(NULL) {} public: SPacketGCHybridCryptKeys(int iStreamSize) : iKeyStreamLen(iStreamSize) { m_pStream = new BYTE[iStreamSize]; } ~SPacketGCHybridCryptKeys() { if( m_pStream ) { delete[] m_pStream; m_pStream = NULL; } } static int GetFixedHeaderSize() { return sizeof(BYTE)+sizeof(WORD)+sizeof(int); } BYTE bHeader; WORD wDynamicPacketSize; int iKeyStreamLen; BYTE* m_pStream; } TPacketGCHybridCryptKeys; typedef struct SPacketGCHybridSDB { private: SPacketGCHybridSDB() : m_pStream(NULL) {} public: SPacketGCHybridSDB(int iStreamSize) : iSDBStreamLen(iStreamSize) { m_pStream = new BYTE[iStreamSize]; } ~SPacketGCHybridSDB() { delete[] m_pStream; m_pStream = NULL; } static int GetFixedHeaderSize() { return sizeof(BYTE)+sizeof(WORD)+sizeof(int); } BYTE bHeader; WORD wDynamicPacketSize; int iSDBStreamLen; BYTE* m_pStream; } TPacketGCHybridSDB; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Client To Client typedef struct packet_state { BYTE bHeader; BYTE bFunc; BYTE bArg; BYTE bRot; DWORD dwVID; DWORD dwTime; TPixelPosition kPPos; } TPacketCCState; typedef struct packet_hs_check_req { BYTE bHeader; AHNHS_TRANS_BUFFER Req; } TPacketHSCheck; //NOTE : recv/send에 공통으로 생김, bPacketData의 내용만 바뀐다. typedef struct packet_xtrap_verify { BYTE bHeader; BYTE bPacketData[128]; } TPacketXTrapCSVerify; // AUTOBAN typedef struct packet_autoban_quiz { BYTE bHeader; BYTE bDuration; BYTE bCaptcha[64*32]; char szQuiz[256]; } TPacketGCAutoBanQuiz; // END_OF_AUTOBAN #ifdef __AUCTION__ // Argument의 용도는 cmd에 따라 다르다. typedef struct SPacketCGAuctionCmd { BYTE bHeader; BYTE cmd; int arg1; int arg2; int arg3; int arg4; } TPacketCGAuctionCmd; typedef struct SPacketGCAuctionItemListPack { BYTE bHeader; BYTE bNumbers; } TPacketGCAuctionItemListPack; #endif typedef struct SPacketGCSpecificEffect { BYTE header; DWORD vid; char effect_file[128]; } TPacketGCSpecificEffect; // 용혼석 enum EDragonSoulRefineWindowRefineType { DragonSoulRefineWindow_UPGRADE, DragonSoulRefineWindow_IMPROVEMENT, DragonSoulRefineWindow_REFINE, }; enum EPacketCGDragonSoulSubHeaderType { DS_SUB_HEADER_OPEN, DS_SUB_HEADER_CLOSE, DS_SUB_HEADER_DO_UPGRADE, DS_SUB_HEADER_DO_IMPROVEMENT, DS_SUB_HEADER_DO_REFINE, 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[DS_REFINE_WINDOW_MAX_NUM]; } TPacketCGDragonSoulRefine; typedef struct SPacketGCDragonSoulRefine { SPacketGCDragonSoulRefine() : header(HEADER_GC_DRAGON_SOUL_REFINE) {} BYTE header; BYTE bSubType; TItemPos Pos; } TPacketGCDragonSoulRefine; typedef struct SChannelStatus { short nPort; BYTE bStatus; } TChannelStatus; #pragma pack(pop)