Beiträge von CHXHMZ

#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_MAX400

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_KEY_AGREEMENT= 0xfb, // _IMPROVED_PACKET_ENCRYPTION_
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,

#ifdef ENABLE_SEND_TARGET_INFO
HEADER_GC_TARGET_INFO= 58,
HEADER_CG_TARGET_INFO_LOAD= 59,
#endif

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_KEY_AGREEMENT_COMPLETED= 0xfa, // _IMPROVED_PACKET_ENCRYPTION_
HEADER_GC_KEY_AGREEMENT= 0xfb, // _IMPROVED_PACKET_ENCRYPTION_
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
{
BYTEheader;
DWORDvid;
} TPacketCGOnClick;

enum
{
SHOP_SUBHEADER_CG_END,
SHOP_SUBHEADER_CG_BUY,
SHOP_SUBHEADER_CG_SELL,
SHOP_SUBHEADER_CG_SELL2,
};

typedef struct command_shop
{
BYTE header;
BYTEsubheader;
} 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
{
BYTEheader;
BYTEsubheader;
DWORDarg1;
BYTEarg2;
TItemPos Pos;
} TPacketCGExchange;

typedef struct command_position
{
BYTE header;
BYTE position;
} TPacketCGPosition;

typedef struct command_script_answer
{
BYTE header;
BYTEanswer;
} TPacketCGScriptAnswer;

typedef struct command_script_button
{
BYTE header;
unsigned intidx;
} TPacketCGScriptButton;

typedef struct command_target
{
BYTE header;
DWORD dwVID;
} TPacketCGTarget;

typedef struct command_move
{
BYTEbHeader;
BYTEbFunc;
BYTEbArg;
BYTEbRot;
LONGlX;
LONGlY;
DWORDdwTime;
} TPacketCGMove;

typedef struct command_sync_position_element
{
DWORD dwVID;
long lX;
long lY;
} TPacketCGSyncPositionElement;

typedef struct command_sync_position
{
BYTE bHeader;
WORDwSize;
} TPacketCGSyncPosition;

typedef struct command_fly_targeting
{
BYTEbHeader;
DWORDdwTargetVID;
longlX;
longlY;
} TPacketCGFlyTargeting;

typedef struct packet_fly_targeting
{
BYTE bHeader;
DWORDdwShooterVID;
DWORDdwTargetVID;
longlX;
longlY;
} TPacketGCFlyTargeting;

typedef struct packet_shoot
{
BYTEbHeader;
BYTEbType;
} TPacketCGShoot;

typedef struct command_warp
{
BYTEbHeader;
} 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;
DWORDdwTargetVID;
} 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
{
BYTEbHeader;
WORDsize;
} TPacketCGDungeon;

// Private Shop
typedef struct SShopItemTable
{
DWORDvnum;
BYTEcount;

TItemPos pos;// PC 상점에만 이용
DWORDprice;// PC 상점에만 이용
BYTEdisplay_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
{
BYTEheader;
BYTEpos;
BYTEtype;
} 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;
charszString[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// 공백패킷.
{
BYTEheader;
} TPacketGCBlank;

typedef struct packet_blank_dynamic
{
BYTEheader;
WORDsize;
} TPacketGCBlankDynamic;

typedef struct packet_header_handshake
{
BYTEheader;
DWORDdwHandshake;
DWORDdwTime;
LONGlDelta;
} TPacketGCHandshake;

typedef struct packet_header_bindudp
{
BYTEheader;
DWORDaddr;
WORDport;
} TPacketGCBindUDP;

typedef struct packet_header_dynamic_size
{
BYTEheader;
WORDsize;
} TDynamicSizePacketHeader;

typedef struct SSimplePlayerInformation
{
DWORD dwID;
char szName[CHARACTER_NAME_MAX_LEN + 1];
BYTE byJob;
BYTE byLevel;
DWORD dwPlayMinutes;
BYTE byST, byHT, byDX, byIQ;
// WORDwParts[CRaceData::PART_MAX_NUM];
WORD wMainPart;
BYTE bChangeName;
WORDwHairPart;
BYTE bDummy[4];
longx, y;
LONGlAddr;
WORDwPort;
BYTEbySkillGroup;
} TSimplePlayerInformation;

typedef struct packet_login_success3
{
BYTEheader;
TSimplePlayerInformation akSimplePlayerInformation[PLAYER_PER_ACCOUNT3];
DWORDguild_id[PLAYER_PER_ACCOUNT3];
charguild_name[PLAYER_PER_ACCOUNT3][GUILD_NAME_MAX_LEN+1];
DWORD handle;
DWORD random_key;
} TPacketGCLoginSuccess3;

typedef struct packet_login_success4
{
BYTEheader;
TSimplePlayerInformation akSimplePlayerInformation[PLAYER_PER_ACCOUNT4];
DWORDguild_id[PLAYER_PER_ACCOUNT4];
charguild_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;
BYTEshape;
BYTECON;
BYTEINT;
BYTESTR;
BYTEDEX;
} TPacketCGCreateCharacter;

typedef struct command_player_create_success
{
BYTEheader;
BYTEbAccountCharacterSlot;
TSimplePlayerInformation kSimplePlayerInfomation;
} TPacketGCPlayerCreateSuccess;

typedef struct command_create_failure
{
BYTE header;
BYTE bType;
} TPacketGCCreateFailure;

typedef struct command_player_delete
{
BYTE header;
BYTE index;
charszPrivateCode[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;

BYTEbType;
WORD wRaceNum;
//WORD awPart[CHR_EQUIPPART_NUM];
BYTE bMovingSpeed;
BYTE bAttackSpeed;

BYTE bStateFlag;
DWORD dwAffectFlag[2]; // ??
//BYTE bEmpire;
//DWORD dwGuild;
//short sAlignment;
//BYTEbPKMode;
//DWORDdwMountVnum;
} 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;

BYTEbType;
WORD wRaceNum;
WORD awPart[CHR_EQUIPPART_NUM];
BYTE bMovingSpeed;
BYTE bAttackSpeed;

BYTE bStateFlag;
DWORD dwAffectFlag[2]; // ??
BYTE bEmpire;

DWORD dwGuild;
short sAlignment;
BYTEbPKMode;
DWORDdwMountVnum;
} TPacketGCCharacterAdd2;

typedef struct packet_update_char
{
BYTE header;
DWORD dwVID;

WORD awPart[CHR_EQUIPPART_NUM];
BYTE bMovingSpeed;
BYTEbAttackSpeed;

BYTE bStateFlag;
DWORD dwAffectFlag[2];

DWORDdwGuildID;
short sAlignment;
BYTEbPKMode;
DWORDdwMountVnum;
} TPacketGCCharacterUpdate;

typedef struct packet_update_char2
{
BYTE header;
DWORD dwVID;

WORD awPart[CHR_EQUIPPART_NUM];
BYTE bMovingSpeed;
BYTEbAttackSpeed;

BYTE bStateFlag;
DWORD dwAffectFlag[2];

DWORDdwGuildID;
short sAlignment;
BYTEbPKMode;
DWORDdwMountVnum;
} 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
{
BYTEheader;
DWORDvid;
} TPacketGCStun;

typedef struct packet_dead
{
BYTEheader;
DWORDvid;
} TPacketGCDead;

typedef struct packet_main_character
{
BYTE header;
DWORD dwVID;
WORDwRaceNum;
char szName[CHARACTER_NAME_MAX_LEN + 1];
long lX, lY, lZ;
BYTEbySkillGroup;
} TPacketGCMainCharacter;

// SUPPORT_BGM
typedef struct packet_main_character2_empire
{
BYTE header;
DWORD dwVID;
WORDwRaceNum;
char szName[CHARACTER_NAME_MAX_LEN + 1];
long lX, lY, lZ;
BYTEbyEmpire;
BYTEbySkillGroup;
} TPacketGCMainCharacter2_EMPIRE;

typedef struct packet_main_character3_bgm
{
enum
{
MUSIC_NAME_MAX_LEN = 24,
};
BYTE header;
DWORD dwVID;
WORDwRaceNum;
char szUserName[CHARACTER_NAME_MAX_LEN + 1];
char szBGMName[MUSIC_NAME_MAX_LEN + 1];
long lX, lY, lZ;
BYTEbyEmpire;
BYTEbySkillGroup;
} TPacketGCMainCharacter3_BGM;

typedef struct packet_main_character4_bgm_vol
{
enum
{
MUSIC_NAME_MAX_LEN = 24,
};
BYTE header;
DWORD dwVID;
WORDwRaceNum;
char szUserName[CHARACTER_NAME_MAX_LEN + 1];
char szBGMName[MUSIC_NAME_MAX_LEN + 1];
floatfBGMVol;
long lX, lY, lZ;
BYTEbyEmpire;
BYTEbySkillGroup;
} 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
{
int header;

DWORDdwVID;
BYTEType;

long amount; // 바뀐 값
long value; // 현재 값
} TPacketGCPointChange;

typedef struct packet_motion
{
BYTEheader;
DWORDvid;
DWORDvictim_vid;
WORDmotion;
} 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
{
BYTEheader;
BYTEpos;
DWORDvnum;
BYTEcount;
DWORDflags; // 플래그 추가
longalSockets[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
{
BYTEheader;
TItemPos Cell;
DWORDvnum;
BYTEcount;
longalSockets[ITEM_SOCKET_SLOT_MAX_NUM];
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
} TPacketGCItemSet;

typedef struct packet_set_item2
{
BYTEheader;
TItemPos Cell;
DWORDvnum;
BYTEcount;
DWORDflags; // 플래그 추가
DWORDanti_flags; // 플래그 추가
boolhighlight;
longalSockets[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
{
BYTEheader;
TItemPos Cell;
DWORDch_vid;
DWORDvictim_vid;

DWORDvnum;
} TPacketGCItemUse;

typedef struct packet_update_item
{
BYTEheader;
TItemPos Cell;
BYTEcount;
longalSockets[ITEM_SOCKET_SLOT_MAX_NUM];
TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
} TPacketGCItemUpdate;

typedef struct packet_ground_add_item
{
BYTE bHeader;
long lX;
longlY;
longlZ;

DWORD dwVID;
DWORD dwVnum;
} TPacketGCItemGroundAdd;

typedef struct packet_ground_del_item
{
BYTEheader;
DWORDvid;
} 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_itemitems[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
{
BYTEpos;
struct packet_shop_itemitem;
} 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;
WORDsize;
BYTE subheader;
} TPacketGCShop;

typedef struct packet_exchange
{
BYTE header;
BYTE subheader;
BYTE is_me;
DWORD arg1;
TItemPos arg2;
DWORD arg3;
longalValues[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;
DWORDvid;
BYTE position;
} TPacketGCPosition;

typedef struct packet_ping
{
BYTEheader;
} TPacketGCPing;

typedef struct packet_pong
{
BYTEbHeader;
} TPacketCGPong;

typedef struct packet_script
{
BYTEheader;
WORD size;
BYTEskin;
WORD src_size;
} TPacketGCScript;

typedef struct packet_target
#ifdef ENABLE_SEND_TARGET_INFO
typedef struct packet_target_info
{
BYTE header;
DWORD dwVID;
DWORD race;
DWORD dwVnum;
BYTE count;
} TPacketGCTargetInfo;

typedef struct packet_target_info_load
{
BYTE header;
DWORD dwVID;
} TPacketCGTargetInfoLoad;
#endif

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
{
BYTEheader;
DWORDvid;
WORDmoving_speed;
} TPacketGCChangeSpeed;

typedef struct packet_move
{
BYTEbHeader;
BYTEbFunc;
BYTEbArg;
BYTEbRot;
DWORDdwVID;
LONGlX;
LONGlY;
DWORDdwTime;
DWORDdwDuration;
} 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
{
BYTEheader;
WORDwSize;
} TPacketGCC2C;

typedef struct packetd_sync_position_element
{
DWORD dwVID;
long lX;
long lY;
} TPacketGCSyncPositionElement;

typedef struct packetd_sync_position
{
BYTE bHeader;
WORDwSize;
} 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
{
BYTEheader;
DWORDdwVIDSrc;
DWORDdwVIDDst;
BYTEbMode;
} TPacketGCPVP;

typedef struct packet_skill_cooltime_end
{
BYTEheader;
BYTEbSkill;
} TPacketGCSkillCoolTimeEnd;

typedef struct packet_warp
{
BYTEbHeader;
LONGlX;
LONGlY;
LONGlAddr;
WORDwPort;
} 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
{
BYTEbHeader;
WORDsize;
BYTEsubheader;
} 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
{
BYTEheader;
BYTEpos;
TRefineTable refine_table;
} TPacketGCRefineInformation;

typedef struct SPacketGCRefineInformationNew
{
BYTEheader;
BYTEtype;
BYTEpos;
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;
charlogin[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
{
BYTEbHeader;
longlID;
charszTargetName[32+1];
DWORDdwVID;
BYTEbyType;
} 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;
intiKeyStreamLen;
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;
intiSDBStreamLen;
BYTE* m_pStream;

} TPacketGCHybridSDB;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Client To Client

typedef struct packet_state
{
BYTEbHeader;
BYTEbFunc;
BYTEbArg;
BYTEbRot;
DWORDdwVID;
DWORDdwTime;
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 _IMPROVED_PACKET_ENCRYPTION_
struct TPacketKeyAgreement
{
static const int MAX_DATA_LEN = 256;
BYTE bHeader;
WORD wAgreedLength;
WORD wDataLength;
BYTE data[MAX_DATA_LEN];
};

struct TPacketKeyAgreementCompleted
{
BYTE bHeader;
BYTE data[3]; // dummy (not used)
};
#endif // _IMPROVED_PACKET_ENCRYPTION_

#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)