Unknown Packet Header on a Header that not exists

[Cyclone_DE 9]

Hello M2D Community,
Recently I found that on my syssers there are some errors like this one:

Process: UNKNOWN HEADER: 220, LAST HEADER: 0(0), REMAIN BYTES: 923, fd: 26

I managed to find a solution on this forum, but i did not find something useful. Can somebody help me?
There are Headers with different numbers on everytime...

My main problem in this specific Unknown header, is that, 220 not exist in none of the files that are responsible, have this header on them (packet.h (clientside), tables.h (serverside), packet.h(serverside))

In the spoiler below there are these files. Can you find me a solution or at least give me a hint? I can pay if that is a problem.

tables.h

Spoiler

#ifndef __INC_TABLES_H__
#define __INC_TABLES_H__

#include "length.h"

typedef    DWORD IDENT;

/**
 * @version 05/06/10    Bang2ni - Myshop Pricelist 관련 패킷 HEADER_XX_MYSHOP_PRICELIST_XXX 추가
 */
enum
{
    HEADER_GD_LOGIN                = 1,
    HEADER_GD_LOGOUT            = 2,

    HEADER_GD_PLAYER_LOAD        = 3,
    HEADER_GD_PLAYER_SAVE        = 4,
    HEADER_GD_PLAYER_CREATE        = 5,
    HEADER_GD_PLAYER_DELETE        = 6,

    HEADER_GD_LOGIN_KEY            = 7,
    // 8 empty
    HEADER_GD_BOOT                = 9,
    HEADER_GD_PLAYER_COUNT        = 10,
    HEADER_GD_QUEST_SAVE        = 11,
    HEADER_GD_SAFEBOX_LOAD        = 12,
    HEADER_GD_SAFEBOX_SAVE        = 13,
    HEADER_GD_SAFEBOX_CHANGE_SIZE    = 14,
    HEADER_GD_EMPIRE_SELECT        = 15,

    HEADER_GD_SAFEBOX_CHANGE_PASSWORD        = 16,
    HEADER_GD_SAFEBOX_CHANGE_PASSWORD_SECOND    = 17, // Not really a packet, used internal
    HEADER_GD_DIRECT_ENTER        = 18,

    HEADER_GD_GUILD_SKILL_UPDATE    = 19,
    HEADER_GD_GUILD_EXP_UPDATE        = 20,
    HEADER_GD_GUILD_ADD_MEMBER        = 21,
    HEADER_GD_GUILD_REMOVE_MEMBER    = 22,
    HEADER_GD_GUILD_CHANGE_GRADE    = 23,
    HEADER_GD_GUILD_CHANGE_MEMBER_DATA    = 24,
    HEADER_GD_GUILD_DISBAND        = 25,
    HEADER_GD_GUILD_WAR            = 26,
    HEADER_GD_GUILD_WAR_SCORE        = 27,
    HEADER_GD_GUILD_CREATE        = 28,

    HEADER_GD_ITEM_SAVE            = 30,
    HEADER_GD_ITEM_DESTROY        = 31,

    HEADER_GD_ADD_AFFECT        = 32,
    HEADER_GD_REMOVE_AFFECT        = 33,

    HEADER_GD_HIGHSCORE_REGISTER    = 34,
    HEADER_GD_ITEM_FLUSH        = 35,

    HEADER_GD_PARTY_CREATE        = 36,
    HEADER_GD_PARTY_DELETE        = 37,
    HEADER_GD_PARTY_ADD            = 38,
    HEADER_GD_PARTY_REMOVE        = 39,
    HEADER_GD_PARTY_STATE_CHANGE    = 40,
    HEADER_GD_PARTY_HEAL_USE        = 41,

    HEADER_GD_FLUSH_CACHE        = 42,
    HEADER_GD_RELOAD_PROTO        = 43,

    HEADER_GD_CHANGE_NAME        = 44,
    HEADER_GD_SMS                = 45,

    HEADER_GD_GUILD_CHANGE_LADDER_POINT    = 46,
    HEADER_GD_GUILD_USE_SKILL        = 47,

    HEADER_GD_REQUEST_EMPIRE_PRIV    = 48,
    HEADER_GD_REQUEST_GUILD_PRIV    = 49,

    HEADER_GD_MONEY_LOG                = 50,

    HEADER_GD_GUILD_DEPOSIT_MONEY                = 51,
    HEADER_GD_GUILD_WITHDRAW_MONEY                = 52,
    HEADER_GD_GUILD_WITHDRAW_MONEY_GIVE_REPLY    = 53,

    HEADER_GD_REQUEST_CHARACTER_PRIV    = 54,

    HEADER_GD_SET_EVENT_FLAG            = 55,

    HEADER_GD_PARTY_SET_MEMBER_LEVEL    = 56,

    HEADER_GD_GUILD_WAR_BET        = 57,

    HEADER_GD_CREATE_OBJECT        = 60,
    HEADER_GD_DELETE_OBJECT        = 61,
    HEADER_GD_UPDATE_LAND        = 62,

    HEADER_GD_MARRIAGE_ADD        = 70,
    HEADER_GD_MARRIAGE_UPDATE    = 71,
    HEADER_GD_MARRIAGE_REMOVE    = 72,

    HEADER_GD_WEDDING_REQUEST    = 73,
    HEADER_GD_WEDDING_READY        = 74,
    HEADER_GD_WEDDING_END        = 75,

    HEADER_GD_AUTH_LOGIN        = 100,
    HEADER_GD_LOGIN_BY_KEY        = 101,
    HEADER_GD_BILLING_EXPIRE    = 104,
    HEADER_GD_VCARD                = 105,
    HEADER_GD_BILLING_CHECK        = 106,
    HEADER_GD_MALL_LOAD            = 107,

    HEADER_GD_MYSHOP_PRICELIST_UPDATE    = 108,        ///< 가격정보 갱신 요청
    HEADER_GD_MYSHOP_PRICELIST_REQ        = 109,        ///< 가격정보 리스트 요청

    HEADER_GD_BLOCK_CHAT                = 110,

    // PCBANG_IP_LIST_BY_AUTH
    HEADER_GD_PCBANG_REQUEST_IP_LIST    = 111,
    HEADER_GD_PCBANG_CLEAR_IP_LIST        = 112,
    HEADER_GD_PCBANG_INSERT_IP            = 113,
    // END_OF_PCBANG_IP_LIST_BY_AUTH

    HEADER_GD_HAMMER_OF_TOR            = 114,
    HEADER_GD_RELOAD_ADMIN            = 115,            ///<운영자 정보 요청
    HEADER_GD_BREAK_MARRIAGE        = 116,            ///< 결혼 파기
    HEADER_GD_ELECT_MONARCH            = 117,            ///< 군주 투표
    HEADER_GD_CANDIDACY                = 118,            ///< 군주 등록
    HEADER_GD_ADD_MONARCH_MONEY        = 119,            ///< 군주 돈 증가
    HEADER_GD_TAKE_MONARCH_MONEY    = 120,            ///< 군주 돈 감소
    HEADER_GD_COME_TO_VOTE            = 121,            ///< 표결
    HEADER_GD_RMCANDIDACY            = 122,            ///< 후보 제거 (운영자)
    HEADER_GD_SETMONARCH            = 123,            ///<군주설정 (운영자)
    HEADER_GD_RMMONARCH            = 124,            ///<군주삭제
    HEADER_GD_DEC_MONARCH_MONEY = 125,

    HEADER_GD_CHANGE_MONARCH_LORD = 126,
    HEADER_GD_BLOCK_COUNTRY_IP        = 127,        // 광대역 IP-Block
    HEADER_GD_BLOCK_EXCEPTION        = 128,        // 광대역 IP-Block 예외

    HEADER_GD_REQ_CHANGE_GUILD_MASTER    = 129,

    HEADER_GD_REQ_SPARE_ITEM_ID_RANGE    = 130,

    HEADER_GD_UPDATE_HORSE_NAME        = 131,
    HEADER_GD_REQ_HORSE_NAME        = 132,

    HEADER_GD_DC                    = 133,        // Login Key를 지움

    HEADER_GD_VALID_LOGOUT            = 134,

    // AUCTION
#ifdef __AUCTION__
    HEADER_GD_GET_AUCTION_LIST        = 135,
    HEADER_GD_COMMAND_AUCTION        = 136,
#endif

    HEADER_GD_REQUEST_CHARGE_CASH    = 137,

    HEADER_GD_DELETE_AWARDID    = 138,    // delete gift notify icon
    
    HEADER_GD_UPDATE_CHANNELSTATUS    = 139,
    HEADER_GD_REQUEST_CHANNELSTATUS    = 140,

    HEADER_GD_SETUP            = 0xff,

    ///////////////////////////////////////////////
    HEADER_DG_NOTICE            = 1,

    HEADER_DG_LOGIN_SUCCESS            = 30,
    HEADER_DG_LOGIN_NOT_EXIST        = 31,
    HEADER_DG_LOGIN_WRONG_PASSWD    = 33,
    HEADER_DG_LOGIN_ALREADY            = 34,

    HEADER_DG_PLAYER_LOAD_SUCCESS    = 35,
    HEADER_DG_PLAYER_LOAD_FAILED    = 36,
    HEADER_DG_PLAYER_CREATE_SUCCESS    = 37,
    HEADER_DG_PLAYER_CREATE_ALREADY    = 38,
    HEADER_DG_PLAYER_CREATE_FAILED    = 39,
    HEADER_DG_PLAYER_DELETE_SUCCESS    = 40,
    HEADER_DG_PLAYER_DELETE_FAILED    = 41,

    HEADER_DG_ITEM_LOAD            = 42,

    HEADER_DG_BOOT                = 43,
    HEADER_DG_QUEST_LOAD        = 44,

    HEADER_DG_SAFEBOX_LOAD                    = 45,
    HEADER_DG_SAFEBOX_CHANGE_SIZE            = 46,
    HEADER_DG_SAFEBOX_WRONG_PASSWORD        = 47,
    HEADER_DG_SAFEBOX_CHANGE_PASSWORD_ANSWER = 48,

    HEADER_DG_EMPIRE_SELECT        = 49,

    HEADER_DG_AFFECT_LOAD        = 50,
    HEADER_DG_MALL_LOAD            = 51,

    HEADER_DG_DIRECT_ENTER        = 55,

    HEADER_DG_GUILD_SKILL_UPDATE    = 56,
    HEADER_DG_GUILD_SKILL_RECHARGE    = 57,
    HEADER_DG_GUILD_EXP_UPDATE        = 58,

    HEADER_DG_PARTY_CREATE        = 59,
    HEADER_DG_PARTY_DELETE        = 60,
    HEADER_DG_PARTY_ADD            = 61,
    HEADER_DG_PARTY_REMOVE        = 62,
    HEADER_DG_PARTY_STATE_CHANGE    = 63,
    HEADER_DG_PARTY_HEAL_USE        = 64,
    HEADER_DG_PARTY_SET_MEMBER_LEVEL    = 65,

    HEADER_DG_TIME            = 90,
    HEADER_DG_ITEM_ID_RANGE        = 91,

    HEADER_DG_GUILD_ADD_MEMBER        = 92,
    HEADER_DG_GUILD_REMOVE_MEMBER    = 93,
    HEADER_DG_GUILD_CHANGE_GRADE    = 94,
    HEADER_DG_GUILD_CHANGE_MEMBER_DATA    = 95,
    HEADER_DG_GUILD_DISBAND        = 96,
    HEADER_DG_GUILD_WAR            = 97,
    HEADER_DG_GUILD_WAR_SCORE        = 98,
    HEADER_DG_GUILD_TIME_UPDATE        = 99,
    HEADER_DG_GUILD_LOAD        = 100,
    HEADER_DG_GUILD_LADDER        = 101,
    HEADER_DG_GUILD_SKILL_USABLE_CHANGE    = 102,
    HEADER_DG_GUILD_MONEY_CHANGE    = 103,
    HEADER_DG_GUILD_WITHDRAW_MONEY_GIVE    = 104,

    HEADER_DG_SET_EVENT_FLAG        = 105,

    HEADER_DG_GUILD_WAR_RESERVE_ADD    = 106,
    HEADER_DG_GUILD_WAR_RESERVE_DEL    = 107,
    HEADER_DG_GUILD_WAR_BET        = 108,

    HEADER_DG_RELOAD_PROTO        = 120,
    HEADER_DG_CHANGE_NAME        = 121,

    HEADER_DG_AUTH_LOGIN        = 122,

    HEADER_DG_CHANGE_EMPIRE_PRIV    = 124,
    HEADER_DG_CHANGE_GUILD_PRIV        = 125,

    HEADER_DG_MONEY_LOG            = 126,

    HEADER_DG_CHANGE_CHARACTER_PRIV    = 127,

    HEADER_DG_BILLING_REPAIR        = 128,
    HEADER_DG_BILLING_EXPIRE        = 129,
    HEADER_DG_BILLING_LOGIN        = 130,
    HEADER_DG_VCARD            = 131,
    HEADER_DG_BILLING_CHECK        = 132,

    HEADER_DG_CREATE_OBJECT        = 140,
    HEADER_DG_DELETE_OBJECT        = 141,
    HEADER_DG_UPDATE_LAND        = 142,

    HEADER_DG_MARRIAGE_ADD        = 150,
    HEADER_DG_MARRIAGE_UPDATE        = 151,
    HEADER_DG_MARRIAGE_REMOVE        = 152,

    HEADER_DG_WEDDING_REQUEST        = 153,
    HEADER_DG_WEDDING_READY        = 154,
    HEADER_DG_WEDDING_START        = 155,
    HEADER_DG_WEDDING_END        = 156,

    HEADER_DG_MYSHOP_PRICELIST_RES    = 157,        ///< 가격정보 리스트 응답
    HEADER_DG_RELOAD_ADMIN = 158,                 ///< 운영자 정보 리로드
    HEADER_DG_BREAK_MARRIAGE = 159,                ///< 결혼 파기
    HEADER_DG_ELECT_MONARCH            = 160,            ///< 군주 투표
    HEADER_DG_CANDIDACY                = 161,            ///< 군주 등록
    HEADER_DG_ADD_MONARCH_MONEY        = 162,            ///< 군주 돈 증가
    HEADER_DG_TAKE_MONARCH_MONEY    = 163,            ///< 군주 돈 감소
    HEADER_DG_COME_TO_VOTE            = 164,            ///< 표결
    HEADER_DG_RMCANDIDACY            = 165,            ///< 후보 제거 (운영자)
    HEADER_DG_SETMONARCH            = 166,            ///<군주설정 (운영자)
    HEADER_DG_RMMONARCH            = 167,            ///<군주삭제
    HEADER_DG_DEC_MONARCH_MONEY = 168,

    HEADER_DG_CHANGE_MONARCH_LORD_ACK = 169,
    HEADER_DG_UPDATE_MONARCH_INFO    = 170,
    HEADER_DG_BLOCK_COUNTRY_IP        = 171,        // 광대역 IP-Block
    HEADER_DG_BLOCK_EXCEPTION        = 172,        // 광대역 IP-Block 예외 account

    HEADER_DG_ACK_CHANGE_GUILD_MASTER = 173,

    HEADER_DG_ACK_SPARE_ITEM_ID_RANGE = 174,

    HEADER_DG_UPDATE_HORSE_NAME     = 175,
    HEADER_DG_ACK_HORSE_NAME        = 176,

    HEADER_DG_NEED_LOGIN_LOG        = 177,
#ifdef __AUCTION__
    HEADER_DG_AUCTION_RESULT    =    178,
#endif
    HEADER_DG_RESULT_CHARGE_CASH    = 179,
    HEADER_DG_ITEMAWARD_INFORMER    = 180,    //gift notify
    HEADER_DG_RESPOND_CHANNELSTATUS        = 181,

    HEADER_DG_MAP_LOCATIONS        = 0xfe,
    HEADER_DG_P2P            = 0xff,

    HEADER_GP_CONFIRM_PASSPOD = 1,
    HEADER_PG_CONFIRM_PASSPOD = 2,

};

enum E_PASSPOD
{
    E_PASSPOD_SUCCESS = 0,
    E_PASSPOD_FAILED_PASSPOD_ERROR,
    E_PASSPOD_FAILED_USER_NOT_FOUND,
    E_PASSPOD_FAILED_SYSTEM_NOT_FOUND,
    E_PASSPOD_FAILED_TOKEN_DISABLED,
    E_PASSPOD_FAILED_EMPTY,
};

typedef struct SRequestConfirmPasspod
{
    int pid;
    char passpod[MAX_PASSPOD + 1];
    char login[LOGIN_MAX_LEN + 1];

} RequestConfirmPasspod;

typedef struct SResultConfirmPasspod
{
    int pid;
    int ret_code;
    char login[LOGIN_MAX_LEN + 1];
} ResultConfirmPasspod;
/* ----------------------------------------------
 * table
 * ----------------------------------------------
 */

/* game Server -> DB Server */
#pragma pack(1)
enum ERequestChargeType
{
    ERequestCharge_Cash = 0,
    ERequestCharge_Mileage,
};

typedef struct SRequestChargeCash
{
    DWORD        dwAID;        // id(primary key) - Account Table
    DWORD        dwAmount;
    ERequestChargeType    eChargeType;

} TRequestChargeCash;

typedef struct SSimplePlayer
{
    DWORD        dwID;
    char        szName[CHARACTER_NAME_MAX_LEN + 1];
    BYTE        byJob;
    BYTE        byLevel;
    DWORD        dwPlayMinutes;
    BYTE        byST, byHT, byDX, byIQ;
    WORD        wMainPart;
    BYTE        bChangeName;
    WORD        wHairPart;
    BYTE        bDummy[4];
    long        x, y;
    long        lAddr;
    WORD        wPort;
    BYTE        skill_group;
} TSimplePlayer;

typedef struct SAccountTable
{
    DWORD        id;
    char        login[LOGIN_MAX_LEN + 1];
    char        passwd[PASSWD_MAX_LEN + 1];
    char        social_id[SOCIAL_ID_MAX_LEN + 1];
    char        status[ACCOUNT_STATUS_MAX_LEN + 1];
    BYTE        bEmpire;
    TSimplePlayer    players[PLAYER_PER_ACCOUNT];
} TAccountTable;

typedef struct SPacketDGCreateSuccess
{
    BYTE        bAccountCharacterIndex;
    TSimplePlayer    player;
} TPacketDGCreateSuccess;

typedef struct TPlayerItemAttribute
{
    BYTE    bType;
    short    sValue;
} TPlayerItemAttribute;

typedef struct SPlayerItem
{
    DWORD    id;
    BYTE    window;
    WORD    pos;
    DWORD    count;

    DWORD    vnum;
    long    alSockets[ITEM_SOCKET_MAX_NUM];    // 소켓번호

    TPlayerItemAttribute    aAttr[ITEM_ATTRIBUTE_MAX_NUM];

    DWORD    owner;
} TPlayerItem;

typedef struct SQuickslot
{
    BYTE    type;
    BYTE    pos;
} TQuickslot;

typedef struct SPlayerSkill
{
    BYTE    bMasterType;
    BYTE    bLevel;
    time_t    tNextRead;
} TPlayerSkill;

struct    THorseInfo
{
    BYTE    bLevel;
    BYTE    bRiding;
    short    sStamina;
    short    sHealth;
    DWORD    dwHorseHealthDropTime;
};

typedef struct SPlayerTable
{
    DWORD    id;

    char    name[CHARACTER_NAME_MAX_LEN + 1];
    char    ip[IP_ADDRESS_LENGTH + 1];

    WORD    job;
    BYTE    voice;

    BYTE    level;
    BYTE    level_step;
    short    st, ht, dx, iq;

    DWORD    exp;
    long long        gold;

    BYTE    dir;
    INT        x, y, z;
    INT        lMapIndex;

    long    lExitX, lExitY;
    long    lExitMapIndex;

    int       hp;
    int       sp;

    short    sRandomHP;
    short    sRandomSP;

    int         playtime;

    short    stat_point;
    short    skill_point;
    short    sub_skill_point;
    short    horse_skill_point;

    TPlayerSkill skills[SKILL_MAX_NUM];

    TQuickslot  quickslot[QUICKSLOT_MAX_NUM];

    BYTE    part_base;
    WORD    parts[PART_MAX_NUM];

    short    stamina;

    BYTE    skill_group;
    long    lAlignment;
    char    szMobile[MOBILE_MAX_LEN + 1];

    short    stat_reset_count;

    THorseInfo    horse;

    DWORD    logoff_interval;

    int        aiPremiumTimes[PREMIUM_MAX_NUM];
} TPlayerTable;

typedef struct SMobSkillLevel
{
    DWORD    dwVnum;
    BYTE    bLevel;
} TMobSkillLevel;

typedef struct SEntityTable
{
    DWORD dwVnum;
} TEntityTable;

typedef struct SMobTable : public SEntityTable
{
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    char    szLocaleName[CHARACTER_NAME_MAX_LEN + 1];

    BYTE    bType;            // Monster, NPC
    BYTE    bRank;            // PAWN, KNIGHT, KING
    BYTE    bBattleType;        // MELEE, etc..
    BYTE    bLevel;            // Level
    BYTE    bSize;

    DWORD    dwGoldMin;
    DWORD    dwGoldMax;
    DWORD    dwExp;
    DWORD    dwMaxHP;
    BYTE    bRegenCycle;
    BYTE    bRegenPercent;
    WORD    wDef;

    DWORD    dwAIFlag;
    DWORD    dwRaceFlag;
    DWORD    dwImmuneFlag;

    BYTE    bStr, bDex, bCon, bInt;
    DWORD    dwDamageRange[2];

    short    sAttackSpeed;
    short    sMovingSpeed;
    BYTE    bAggresiveHPPct;
    WORD    wAggressiveSight;
    WORD    wAttackRange;

    char    cEnchants[MOB_ENCHANTS_MAX_NUM];
    char    cResists[MOB_RESISTS_MAX_NUM];

    DWORD    dwResurrectionVnum;
    DWORD    dwDropItemVnum;

    BYTE    bMountCapacity;
    BYTE    bOnClickType;

    BYTE    bEmpire;
    char    szFolder[64 + 1];

    float    fDamMultiply;

    DWORD    dwSummonVnum;
    DWORD    dwDrainSP;
    DWORD    dwMobColor;
    DWORD    dwPolymorphItemVnum;

    TMobSkillLevel Skills[MOB_SKILL_MAX_NUM];

    BYTE    bBerserkPoint;
    BYTE    bStoneSkinPoint;
    BYTE    bGodSpeedPoint;
    BYTE    bDeathBlowPoint;
    BYTE    bRevivePoint;
} TMobTable;

typedef struct SSkillTable
{
    DWORD    dwVnum;
    char    szName[32 + 1];
    BYTE    bType;
    BYTE    bMaxLevel;
    DWORD    dwSplashRange;

    char    szPointOn[64];
    char    szPointPoly[100 + 1];
    char    szSPCostPoly[100 + 1];
    char    szDurationPoly[100 + 1];
    char    szDurationSPCostPoly[100 + 1];
    char    szCooldownPoly[100 + 1];
    char    szMasterBonusPoly[100 + 1];
    //char    szAttackGradePoly[100 + 1];
    char    szGrandMasterAddSPCostPoly[100 + 1];
    DWORD    dwFlag;
    DWORD    dwAffectFlag;

    // Data for secondary skill
    char     szPointOn2[64];
    char     szPointPoly2[100 + 1];
    char     szDurationPoly2[100 + 1];
    DWORD     dwAffectFlag2;

    // Data for grand master point
    char     szPointOn3[64];
    char     szPointPoly3[100 + 1];
    char     szDurationPoly3[100 + 1];

    BYTE    bLevelStep;
    BYTE    bLevelLimit;
    DWORD    preSkillVnum;
    BYTE    preSkillLevel;

    long    lMaxHit;
    char    szSplashAroundDamageAdjustPoly[100 + 1];

    BYTE    bSkillAttrType;

    DWORD    dwTargetRange;
} TSkillTable;

typedef struct SShopItemTable
{
    DWORD        vnum;
    BYTE        count;

    TItemPos    pos;            // PC 상점에만 이용
    DWORD        price;    // PC, shop_table_ex.txt 상점에만 이용
    BYTE        display_pos; // PC, shop_table_ex.txt 상점에만 이용, 보일 위치.
} TShopItemTable;

typedef struct SShopTable
{
    DWORD        dwVnum;
    DWORD        dwNPCVnum;

    BYTE        byItemCount;
    TShopItemTable    items[SHOP_HOST_ITEM_MAX_NUM];
} TShopTable;

#define QUEST_NAME_MAX_LEN    32
#define QUEST_STATE_MAX_LEN    64

typedef struct SQuestTable
{
    DWORD        dwPID;
    char        szName[QUEST_NAME_MAX_LEN + 1];
    char        szState[QUEST_STATE_MAX_LEN + 1];
    long        lValue;
} TQuestTable;

typedef struct SItemLimit
{
    BYTE    bType;
    long    lValue;
} TItemLimit;

typedef struct SItemApply
{
    BYTE    bType;
    long    lValue;
} TItemApply;

typedef struct SItemTable : public SEntityTable
{
    DWORD        dwVnumRange;
    char        szName[ITEM_NAME_MAX_LEN + 1];
    char    szLocaleName[ITEM_NAME_MAX_LEN + 1];
    BYTE    bType;
    BYTE    bSubType;

    BYTE        bWeight;
    BYTE    bSize;

    DWORD    dwAntiFlags;
    DWORD    dwFlags;
    DWORD    dwWearFlags;
    DWORD    dwImmuneFlag;

    DWORD       dwGold;
    DWORD       dwShopBuyPrice;

    TItemLimit    aLimits[ITEM_LIMIT_MAX_NUM];
    TItemApply    aApplies[ITEM_APPLY_MAX_NUM];
    long        alValues[ITEM_VALUES_MAX_NUM];
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    DWORD    dwRefinedVnum;
    WORD    wRefineSet;
    BYTE    bAlterToMagicItemPct;
    BYTE    bSpecular;
    BYTE    bGainSocketPct;

    short int    sAddonType; // 기본 속성

    // 아래 limit flag들은 realtime에 체크 할 일이 많고, 아이템 VNUM당 고정된 값인데,
    // 현재 구조대로 매번 아이템마다 필요한 경우에 LIMIT_MAX_NUM까지 루프돌면서 체크하는 부하가 커서 미리 저장 해 둠.
    char        cLimitRealTimeFirstUseIndex;        // 아이템 limit 필드값 중에서 LIMIT_REAL_TIME_FIRST_USE 플래그의 위치 (없으면 -1)
    char        cLimitTimerBasedOnWearIndex;        // 아이템 limit 필드값 중에서 LIMIT_TIMER_BASED_ON_WEAR 플래그의 위치 (없으면 -1)

} TItemTable;

struct TItemAttrTable
{
    TItemAttrTable() :
        dwApplyIndex(0),
        dwProb(0)
    {
        szApply[0] = 0;
        memset(&lValues, 0, sizeof(lValues));
        memset(&bMaxLevelBySet, 0, sizeof(bMaxLevelBySet));
    }

    char    szApply[APPLY_NAME_MAX_LEN + 1];
    DWORD   dwApplyIndex;
    DWORD   dwProb;
    long    lValues[5];
    BYTE    bMaxLevelBySet[ATTRIBUTE_SET_MAX_NUM];
};

typedef struct SConnectTable
{
    char    login[LOGIN_MAX_LEN + 1];
    IDENT    ident;
} TConnectTable;

typedef struct SLoginPacket
{
    char    login[LOGIN_MAX_LEN + 1];
    char    passwd[PASSWD_MAX_LEN + 1];
} TLoginPacket;

typedef struct SPlayerLoadPacket
{
    DWORD    account_id;
    DWORD    player_id;
    BYTE    account_index;    /* account 에서의 위치 */
} TPlayerLoadPacket;

typedef struct SPlayerCreatePacket
{
    char        login[LOGIN_MAX_LEN + 1];
    char        passwd[PASSWD_MAX_LEN + 1];
    DWORD        account_id;
    BYTE        account_index;
    TPlayerTable    player_table;
} TPlayerCreatePacket;

typedef struct SPlayerDeletePacket
{
    char    login[LOGIN_MAX_LEN + 1];
    DWORD    player_id;
    BYTE    account_index;
    //char    name[CHARACTER_NAME_MAX_LEN + 1];
    char    private_code[8];
} TPlayerDeletePacket;

typedef struct SLogoutPacket
{
    char    login[LOGIN_MAX_LEN + 1];
    char    passwd[PASSWD_MAX_LEN + 1];
} TLogoutPacket;

typedef struct SPlayerCountPacket
{
    DWORD    dwCount;
} TPlayerCountPacket;

#define SAFEBOX_MAX_NUM            135
#define SAFEBOX_PASSWORD_MAX_LEN    6

typedef struct SSafeboxTable
{
    DWORD    dwID;
    BYTE    bSize;
    DWORD    dwGold;
    WORD    wItemCount;
} TSafeboxTable;

typedef struct SSafeboxChangeSizePacket
{
    DWORD    dwID;
    BYTE    bSize;
} TSafeboxChangeSizePacket;

typedef struct SSafeboxLoadPacket
{
    DWORD    dwID;
    char    szLogin[LOGIN_MAX_LEN + 1];
    char    szPassword[SAFEBOX_PASSWORD_MAX_LEN + 1];
} TSafeboxLoadPacket;

typedef struct SSafeboxChangePasswordPacket
{
    DWORD    dwID;
    char    szOldPassword[SAFEBOX_PASSWORD_MAX_LEN + 1];
    char    szNewPassword[SAFEBOX_PASSWORD_MAX_LEN + 1];
} TSafeboxChangePasswordPacket;

typedef struct SSafeboxChangePasswordPacketAnswer
{
    BYTE    flag;
} TSafeboxChangePasswordPacketAnswer;

typedef struct SEmpireSelectPacket
{
    DWORD    dwAccountID;
    BYTE    bEmpire;
} TEmpireSelectPacket;

typedef struct SPacketGDSetup
{
    char    szPublicIP[16];    // Public IP which listen to users
    BYTE    bChannel;    // 채널
    WORD    wListenPort;    // 클라이언트가 접속하는 포트 번호
    WORD    wP2PPort;    // 서버끼리 연결 시키는 P2P 포트 번호
    long    alMaps[64];
    DWORD    dwLoginCount;
    BYTE    bAuthServer;
} TPacketGDSetup;

typedef struct SPacketDGMapLocations
{
    BYTE    bCount;
} TPacketDGMapLocations;

typedef struct SMapLocation
{
    long    alMaps[64];
    char    szHost[MAX_HOST_LENGTH + 1];
    WORD    wPort;
} TMapLocation;

typedef struct SPacketDGP2P
{
    char    szHost[MAX_HOST_LENGTH + 1];
    WORD    wPort;
    BYTE    bChannel;
} TPacketDGP2P;

typedef struct SPacketGDDirectEnter
{
    char    login[LOGIN_MAX_LEN + 1];
    char    passwd[PASSWD_MAX_LEN + 1];
    BYTE    index;
} TPacketGDDirectEnter;

typedef struct SPacketDGDirectEnter
{
    TAccountTable accountTable;
    TPlayerTable playerTable;
} TPacketDGDirectEnter;

typedef struct SPacketGuildSkillUpdate
{
    DWORD guild_id;
    int amount;
    BYTE skill_levels[12];
    BYTE skill_point;
    BYTE save;
} TPacketGuildSkillUpdate;

typedef struct SPacketGuildExpUpdate
{
    DWORD guild_id;
    int amount;
} TPacketGuildExpUpdate;

typedef struct SPacketGuildChangeMemberData
{
    DWORD guild_id;
    DWORD pid;
    DWORD offer;
    BYTE level;
    BYTE grade;
} TPacketGuildChangeMemberData;

typedef struct SPacketDGLoginAlready
{
    char    szLogin[LOGIN_MAX_LEN + 1];
} TPacketDGLoginAlready;

typedef struct TPacketAffectElement
{
    DWORD    dwType;
    BYTE    bApplyOn;
    long    lApplyValue;
    DWORD    dwFlag;
    long    lDuration;
    long    lSPCost;
} TPacketAffectElement;

typedef struct SPacketGDAddAffect
{
    DWORD            dwPID;
    TPacketAffectElement    elem;
} TPacketGDAddAffect;

typedef struct SPacketGDRemoveAffect
{
    DWORD    dwPID;
    DWORD    dwType;
    BYTE    bApplyOn;
} TPacketGDRemoveAffect;

typedef struct SPacketGDHighscore
{
    DWORD    dwPID;
    long    lValue;
    char    cDir;
    char    szBoard[21];
} TPacketGDHighscore;

typedef struct SPacketPartyCreate
{
    DWORD    dwLeaderPID;
} TPacketPartyCreate;

typedef struct SPacketPartyDelete
{
    DWORD    dwLeaderPID;
} TPacketPartyDelete;

typedef struct SPacketPartyAdd
{
    DWORD    dwLeaderPID;
    DWORD    dwPID;
    BYTE    bState;
} TPacketPartyAdd;

typedef struct SPacketPartyRemove
{
    DWORD    dwLeaderPID;
    DWORD    dwPID;
} TPacketPartyRemove;

typedef struct SPacketPartyStateChange
{
    DWORD    dwLeaderPID;
    DWORD    dwPID;
    BYTE    bRole;
    BYTE    bFlag;
} TPacketPartyStateChange;

typedef struct SPacketPartySetMemberLevel
{
    DWORD    dwLeaderPID;
    DWORD    dwPID;
    BYTE    bLevel;
} TPacketPartySetMemberLevel;

typedef struct SPacketGDBoot
{
    DWORD    dwItemIDRange[2];
    char    szIP[16];
} TPacketGDBoot;

typedef struct SPacketGuild
{
    DWORD    dwGuild;
    DWORD    dwInfo;
} TPacketGuild;

typedef struct SPacketGDGuildAddMember
{
    DWORD    dwPID;
    DWORD    dwGuild;
    BYTE    bGrade;
} TPacketGDGuildAddMember;

typedef struct SPacketDGGuildMember
{
    DWORD    dwPID;
    DWORD    dwGuild;
    BYTE    bGrade;
    BYTE    isGeneral;
    BYTE    bJob;
    BYTE    bLevel;
    DWORD    dwOffer;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
} TPacketDGGuildMember;

typedef struct SPacketGuildWar
{
    BYTE    bType;
    BYTE    bWar;
    DWORD    dwGuildFrom;
    DWORD    dwGuildTo;
    long    lWarPrice;
    long    lInitialScore;
} TPacketGuildWar;

// Game -> DB : 상대적 변화값
// DB -> Game : 토탈된 최종값
typedef struct SPacketGuildWarScore
{
    DWORD dwGuildGainPoint;
    DWORD dwGuildOpponent;
    long lScore;
    long lBetScore;
} TPacketGuildWarScore;

typedef struct SRefineMaterial
{
    DWORD vnum;
    int count;
} TRefineMaterial;

typedef struct SRefineTable
{
    //DWORD src_vnum;
    //DWORD result_vnum;
    DWORD id;
    BYTE material_count;
    int cost; // 소요 비용
    int prob; // 확률
    TRefineMaterial materials[REFINE_MATERIAL_MAX_NUM];
} TRefineTable;

typedef struct SBanwordTable
{
    char szWord[BANWORD_MAX_LEN + 1];
} TBanwordTable;

typedef struct SPacketGDChangeName
{
    DWORD pid;
    char name[CHARACTER_NAME_MAX_LEN + 1];
} TPacketGDChangeName;

typedef struct SPacketDGChangeName
{
    DWORD pid;
    char name[CHARACTER_NAME_MAX_LEN + 1];
} TPacketDGChangeName;

typedef struct SPacketGuildLadder
{
    DWORD dwGuild;
    long lLadderPoint;
    long lWin;
    long lDraw;
    long lLoss;
} TPacketGuildLadder;

typedef struct SPacketGuildLadderPoint
{
    DWORD dwGuild;
    long lChange;
} TPacketGuildLadderPoint;

typedef struct SPacketGDSMS
{
    char szFrom[CHARACTER_NAME_MAX_LEN + 1];
    char szTo[CHARACTER_NAME_MAX_LEN + 1];
    char szMobile[MOBILE_MAX_LEN + 1];
    char szMsg[SMS_MAX_LEN + 1];
} TPacketGDSMS;

typedef struct SPacketGuildUseSkill
{
    DWORD dwGuild;
    DWORD dwSkillVnum;
    DWORD dwCooltime;
} TPacketGuildUseSkill;

typedef struct SPacketGuildSkillUsableChange
{
    DWORD dwGuild;
    DWORD dwSkillVnum;
    BYTE bUsable;
} TPacketGuildSkillUsableChange;

typedef struct SPacketGDLoginKey
{
    DWORD dwAccountID;
    DWORD dwLoginKey;
} TPacketGDLoginKey;

typedef struct SPacketGDAuthLogin
{
    DWORD    dwID;
    DWORD    dwLoginKey;
    char    szLogin[LOGIN_MAX_LEN + 1];
    char    szSocialID[SOCIAL_ID_MAX_LEN + 1];
    DWORD    adwClientKey[4];
    BYTE    bBillType;
    DWORD    dwBillID;
    int        iPremiumTimes[PREMIUM_MAX_NUM];
} TPacketGDAuthLogin;

typedef struct SPacketGDLoginByKey
{
    char    szLogin[LOGIN_MAX_LEN + 1];
    DWORD    dwLoginKey;
    DWORD    adwClientKey[4];
    char    szIP[MAX_HOST_LENGTH + 1];
} TPacketGDLoginByKey;

/**
 * @version 05/06/08    Bang2ni - 지속시간 추가
 */
typedef struct SPacketGiveGuildPriv
{
    BYTE type;
    int value;
    DWORD guild_id;
    time_t duration_sec;    ///< 지속시간
} TPacketGiveGuildPriv;
typedef struct SPacketGiveEmpirePriv
{
    BYTE type;
    int value;
    BYTE empire;
    time_t duration_sec;
} TPacketGiveEmpirePriv;
typedef struct SPacketGiveCharacterPriv
{
    BYTE type;
    int value;
    DWORD pid;
} TPacketGiveCharacterPriv;
typedef struct SPacketRemoveGuildPriv
{
    BYTE type;
    DWORD guild_id;
} TPacketRemoveGuildPriv;
typedef struct SPacketRemoveEmpirePriv
{
    BYTE type;
    BYTE empire;
} TPacketRemoveEmpirePriv;

typedef struct SPacketDGChangeCharacterPriv
{
    BYTE type;
    int value;
    DWORD pid;
    BYTE bLog;
} TPacketDGChangeCharacterPriv;

/**
 * @version 05/06/08    Bang2ni - 지속시간 추가
 */
typedef struct SPacketDGChangeGuildPriv
{
    BYTE type;
    int value;
    DWORD guild_id;
    BYTE bLog;
    time_t end_time_sec;    ///< 지속시간
} TPacketDGChangeGuildPriv;

typedef struct SPacketDGChangeEmpirePriv
{
    BYTE type;
    int value;
    BYTE empire;
    BYTE bLog;
    time_t end_time_sec;
} TPacketDGChangeEmpirePriv;

typedef struct SPacketMoneyLog
{
    BYTE type;
    DWORD vnum;
    INT gold;
} TPacketMoneyLog;

typedef struct SPacketGDGuildMoney
{
    DWORD dwGuild;
    INT iGold;
} TPacketGDGuildMoney;

typedef struct SPacketDGGuildMoneyChange
{
    DWORD dwGuild;
    INT iTotalGold;
} TPacketDGGuildMoneyChange;

typedef struct SPacketDGGuildMoneyWithdraw
{
    DWORD dwGuild;
    INT iChangeGold;
} TPacketDGGuildMoneyWithdraw;

typedef struct SPacketGDGuildMoneyWithdrawGiveReply
{
    DWORD dwGuild;
    INT iChangeGold;
    BYTE bGiveSuccess;
} TPacketGDGuildMoneyWithdrawGiveReply;

typedef struct SPacketSetEventFlag
{
    char    szFlagName[EVENT_FLAG_NAME_MAX_LEN + 1];
    long    lValue;
} TPacketSetEventFlag;

typedef struct SPacketBillingLogin
{
    DWORD    dwLoginKey;
    BYTE    bLogin;
} TPacketBillingLogin;

typedef struct SPacketBillingRepair
{
    DWORD    dwLoginKey;
    char    szLogin[LOGIN_MAX_LEN + 1];
    char    szHost[MAX_HOST_LENGTH + 1];
} TPacketBillingRepair;

typedef struct SPacketBillingExpire
{
    char    szLogin[LOGIN_MAX_LEN + 1];
    BYTE    bBillType;
    DWORD    dwRemainSeconds;
} TPacketBillingExpire;

typedef struct SPacketLoginOnSetup
{
    DWORD   dwID;
    char    szLogin[LOGIN_MAX_LEN + 1];
    char    szSocialID[SOCIAL_ID_MAX_LEN + 1];
    char    szHost[MAX_HOST_LENGTH + 1];
    DWORD   dwLoginKey;
    DWORD   adwClientKey[4];
} TPacketLoginOnSetup;

typedef struct SPacketGDCreateObject
{
    DWORD    dwVnum;
    DWORD    dwLandID;
    INT        lMapIndex;
    INT         x, y;
    float    xRot;
    float    yRot;
    float    zRot;
} TPacketGDCreateObject;

typedef struct SPacketGDHammerOfTor
{
    DWORD     key;
    DWORD    delay;
} TPacketGDHammerOfTor;

typedef struct SPacketGDVCard
{
    DWORD    dwID;
    char    szSellCharacter[CHARACTER_NAME_MAX_LEN + 1];
    char    szSellAccount[LOGIN_MAX_LEN + 1];
    char    szBuyCharacter[CHARACTER_NAME_MAX_LEN + 1];
    char    szBuyAccount[LOGIN_MAX_LEN + 1];
} TPacketGDVCard;

typedef struct SGuildReserve
{
    DWORD       dwID;
    DWORD       dwGuildFrom;
    DWORD       dwGuildTo;
    DWORD       dwTime;
    BYTE        bType;
    long        lWarPrice;
    long        lInitialScore;
    bool        bStarted;
    DWORD    dwBetFrom;
    DWORD    dwBetTo;
    long    lPowerFrom;
    long    lPowerTo;
    long    lHandicap;
} TGuildWarReserve;

typedef struct
{
    DWORD    dwWarID;
    char    szLogin[LOGIN_MAX_LEN + 1];
    DWORD    dwGold;
    DWORD    dwGuild;
} TPacketGDGuildWarBet;

// Marriage

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
    time_t tMarryTime;
    char szName1[CHARACTER_NAME_MAX_LEN + 1];
    char szName2[CHARACTER_NAME_MAX_LEN + 1];
} TPacketMarriageAdd;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
    INT  iLovePoint;
    BYTE  byMarried;
} TPacketMarriageUpdate;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
} TPacketMarriageRemove;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
} TPacketWeddingRequest;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
    DWORD dwMapIndex;
} TPacketWeddingReady;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
} TPacketWeddingStart;

typedef struct
{
    DWORD dwPID1;
    DWORD dwPID2;
} TPacketWeddingEnd;

/// 개인상점 가격정보의 헤더. 가변 패킷으로 이 뒤에 byCount 만큼의 TItemPriceInfo 가 온다.
typedef struct SPacketMyshopPricelistHeader
{
    DWORD    dwOwnerID;    ///< 가격정보를 가진 플레이어 ID
    BYTE    byCount;    ///< 가격정보 갯수
} TPacketMyshopPricelistHeader;

/// 개인상점의 단일 아이템에 대한 가격정보
typedef struct SItemPriceInfo
{
    DWORD    dwVnum;        ///< 아이템 vnum
    DWORD    dwPrice;    ///< 가격
} TItemPriceInfo;

/// 개인상점 아이템 가격정보 리스트 테이블
typedef struct SItemPriceListTable
{
    DWORD    dwOwnerID;    ///< 가격정보를 가진 플레이어 ID
    BYTE    byCount;    ///< 가격정보 리스트의 갯수

    TItemPriceInfo    aPriceInfo[SHOP_PRICELIST_MAX_NUM];    ///< 가격정보 리스트
} TItemPriceListTable;

typedef struct
{
    char szName[CHARACTER_NAME_MAX_LEN + 1];
    long lDuration;
} TPacketBlockChat;

// PCBANG_IP_LIST
typedef struct SPacketPCBangIP
{
    DWORD id;
    DWORD ip;
} TPacketPCBangIP;
// END_OF_PCBANG_IP_LIST

//ADMIN_MANAGER
typedef struct TAdminInfo
{
    int m_ID;                //고유ID
    char m_szAccount[32];    //계정
    char m_szName[32];        //캐릭터이름
    char m_szContactIP[16];    //접근아이피
    char m_szServerIP[16];  //서버아이피
    int m_Authority;        //권한
} tAdminInfo;
//END_ADMIN_MANAGER

//BOOT_LOCALIZATION
struct tLocale
{
    char szValue[32];
    char szKey[32];
};
//BOOT_LOCALIZATION

//RELOAD_ADMIN
typedef struct SPacketReloadAdmin
{
    char szIP[16];
} TPacketReloadAdmin;
//END_RELOAD_ADMIN

typedef struct TMonarchInfo
{
    DWORD pid[4];  // 군주의 PID
    int64_t money[4];  // 군주의 별개 돈    
    char name[4][32];  // 군주의 이름    
    char date[4][32];  // 군주 등록 날짜
} MonarchInfo;

typedef struct TMonarchElectionInfo
{
    DWORD pid;  // 투표 한사람 PID
    DWORD selectedpid; // 투표 당한 PID ( 군주 참가자 )
    char date[32]; // 투표 날짜
} MonarchElectionInfo;

// 군주 출마자
typedef struct tMonarchCandidacy
{
    DWORD pid;
    char name[32];
    char date[32];
} MonarchCandidacy;

typedef struct tChangeMonarchLord
{
    BYTE bEmpire;
    DWORD dwPID;
} TPacketChangeMonarchLord;

typedef struct tChangeMonarchLordACK
{
    BYTE bEmpire;
    DWORD dwPID;
    char szName[32];
    char szDate[32];
} TPacketChangeMonarchLordACK;

// Block Country Ip
typedef struct tBlockCountryIp
{
    DWORD    ip_from;
    DWORD    ip_to;
} TPacketBlockCountryIp;

enum EBlockExceptionCommand
{
    BLOCK_EXCEPTION_CMD_ADD = 1,
    BLOCK_EXCEPTION_CMD_DEL = 2,
};

// Block Exception Account
typedef struct tBlockException
{
    BYTE    cmd;    // 1 == add, 2 == delete
    char    login[LOGIN_MAX_LEN + 1];
}TPacketBlockException;

typedef struct tChangeGuildMaster
{
    DWORD dwGuildID;
    DWORD idFrom;
    DWORD idTo;
} TPacketChangeGuildMaster;

typedef struct tItemIDRange
{
    DWORD dwMin;
    DWORD dwMax;
    DWORD dwUsableItemIDMin;
} TItemIDRangeTable;

typedef struct tUpdateHorseName
{
    DWORD dwPlayerID;
    char szHorseName[CHARACTER_NAME_MAX_LEN + 1];
} TPacketUpdateHorseName;

typedef struct tDC
{
    char    login[LOGIN_MAX_LEN + 1];
} TPacketDC;

typedef struct tNeedLoginLogInfo
{
    DWORD dwPlayerID;
} TPacketNeedLoginLogInfo;

//독일 선물 알림 기능 테스트용 패킷 정보
typedef struct tItemAwardInformer
{
    char    login[LOGIN_MAX_LEN + 1];
    char    command[20];        //명령어
    unsigned int vnum;            //아이템
} TPacketItemAwardInfromer;
// 선물 알림 기능 삭제용 패킷 정보
typedef struct tDeleteAwardID
{
    DWORD dwID;
} TPacketDeleteAwardID;

typedef struct SChannelStatus
{
    short nPort;
    BYTE bStatus;
} TChannelStatus;

#pragma pack()
#endif

 

packet.h(serverside)

Spoiler

#ifndef __INC_PACKET_H__
#define __INC_PACKET_H__

enum
{
    HEADER_CG_HANDSHAKE                = 0xff,
    HEADER_CG_PONG                = 0xfe,
    HEADER_CG_TIME_SYNC                = 0xfc,
    HEADER_CG_KEY_AGREEMENT            = 0xfb, // _IMPROVED_PACKET_ENCRYPTION_

    HEADER_CG_LOGIN                = 1,
    HEADER_CG_ATTACK                = 2,
    HEADER_CG_CHAT                = 3,
    HEADER_CG_CHARACTER_CREATE            = 4,
    HEADER_CG_CHARACTER_DELETE            = 5,
    HEADER_CG_CHARACTER_SELECT            = 6,
    HEADER_CG_MOVE                = 7,
    HEADER_CG_SYNC_POSITION            = 8,
    HEADER_CG_ENTERGAME                = 10,

    HEADER_CG_ITEM_USE                = 11,
    HEADER_CG_ITEM_DROP                = 12,
    HEADER_CG_ITEM_MOVE                = 13,
    HEADER_CG_ITEM_PICKUP            = 15,

    HEADER_CG_QUICKSLOT_ADD            = 16,
    HEADER_CG_QUICKSLOT_DEL            = 17,
    HEADER_CG_QUICKSLOT_SWAP            = 18,
    HEADER_CG_WHISPER                = 19,
    HEADER_CG_ITEM_DROP2            = 20,

    HEADER_CG_ON_CLICK                = 26,
    HEADER_CG_EXCHANGE                = 27,
    HEADER_CG_CHARACTER_POSITION        = 28,
    HEADER_CG_SCRIPT_ANSWER            = 29,
    HEADER_CG_QUEST_INPUT_STRING        = 30,
    HEADER_CG_QUEST_CONFIRM            = 31,

    HEADER_CG_SHOP                = 50,
    HEADER_CG_FLY_TARGETING            = 51,
    HEADER_CG_USE_SKILL                = 52,
    HEADER_CG_ADD_FLY_TARGETING            = 53,
    HEADER_CG_SHOOT                = 54,
    HEADER_CG_MYSHOP                = 55,

    HEADER_CG_ITEM_USE_TO_ITEM            = 60,
    HEADER_CG_TARGET                 = 61,

    HEADER_CG_TEXT                = 64,    // @ 로 시작되면 텍스트를 파싱한다.
    HEADER_CG_WARP                = 65,
    HEADER_CG_SCRIPT_BUTTON            = 66,
    HEADER_CG_MESSENGER                = 67,

    HEADER_CG_MALL_CHECKOUT            = 69,
    HEADER_CG_SAFEBOX_CHECKIN            = 70,    // 아이템을 창고에 넣는다.
    HEADER_CG_SAFEBOX_CHECKOUT            = 71,    // 아이템을 창고로 부터 빼온다.

    HEADER_CG_PARTY_INVITE            = 72,
    HEADER_CG_PARTY_INVITE_ANSWER        = 73,
    HEADER_CG_PARTY_REMOVE            = 74,
    HEADER_CG_PARTY_SET_STATE                   = 75,
    HEADER_CG_PARTY_USE_SKILL            = 76,
    HEADER_CG_SAFEBOX_ITEM_MOVE            = 77,
    HEADER_CG_PARTY_PARAMETER            = 78,

    HEADER_CG_GUILD                = 80,
    HEADER_CG_ANSWER_MAKE_GUILD            = 81,

    HEADER_CG_FISHING                = 82,

    HEADER_CG_ITEM_GIVE                = 83,

    HEADER_CG_EMPIRE                = 90,

    HEADER_CG_REFINE                = 96,

    HEADER_CG_MARK_LOGIN            = 100,
    HEADER_CG_MARK_CRCLIST            = 101,
    HEADER_CG_MARK_UPLOAD            = 102,
    HEADER_CG_MARK_IDXLIST            = 104,

    HEADER_CG_HACK                    = 105,
    HEADER_CG_CHANGE_NAME            = 106,
    HEADER_CG_LOGIN2                = 109,
    HEADER_CG_DUNGEON                = 110,
    HEADER_CG_LOGIN3                = 111,

    HEADER_CG_GUILD_SYMBOL_UPLOAD    = 112,
    HEADER_CG_SYMBOL_CRC            = 113,

    // SCRIPT_SELECT_ITEM
    HEADER_CG_SCRIPT_SELECT_ITEM    = 114,
    // END_OF_SCRIPT_SELECT_ITEM
    
    HEADER_CG_LOGIN5_OPENID            = 116,    //OpenID : 클라이언트로부터 OpenID 인증키를 받는다.

//    HEADER_CG_ROULETTE                = 200,
//    HEADER_CG_RUNUP_MATRIX_ANSWER    = 201,

    //
    HEADER_CG_PASSPOD_ANSWER        = 202,

    //NOTE : 이런 개XXX 정말 이거 Packet설계한 사람은 누구냐. 이렇게 코딩하고 밥이 넘어가나.
    //enum을 별도로 구별을 하던가. 아님 namepsace로 구별을 하던가..
    //정말 packet generator까지는 바라지도 않는다. 이런 씨XX
    //이러다가 숫자 겹치면 누가 책임지는데???
    HEADER_CG_HS_ACK                = 203,
    HEADER_CG_XTRAP_ACK                = 204,

    HEADER_CG_DRAGON_SOUL_REFINE            = 205,
    HEADER_CG_STATE_CHECKER                    = 206,

    HEADER_CG_CLIENT_VERSION            = 0xfd,
    HEADER_CG_CLIENT_VERSION2            = 0xf1,

    /********************************************************/
    HEADER_GC_KEY_AGREEMENT_COMPLETED = 0xfa, // _IMPROVED_PACKET_ENCRYPTION_
    HEADER_GC_KEY_AGREEMENT            = 0xfb, // _IMPROVED_PACKET_ENCRYPTION_
    HEADER_GC_TIME_SYNC                = 0xfc,
    HEADER_GC_PHASE                    = 0xfd,
    HEADER_GC_BINDUDP                = 0xfe,
    HEADER_GC_HANDSHAKE                = 0xff,

    HEADER_GC_CHARACTER_ADD            = 1,
    HEADER_GC_CHARACTER_DEL            = 2,
    HEADER_GC_MOVE                    = 3,
    HEADER_GC_CHAT                    = 4,
    HEADER_GC_SYNC_POSITION            = 5,

    HEADER_GC_LOGIN_SUCCESS            = 6,
    HEADER_GC_LOGIN_SUCCESS_NEWSLOT    = 32,
    HEADER_GC_LOGIN_FAILURE            = 7,

    HEADER_GC_CHARACTER_CREATE_SUCCESS        = 8,
    HEADER_GC_CHARACTER_CREATE_FAILURE        = 9,
    HEADER_GC_CHARACTER_DELETE_SUCCESS        = 10,
    HEADER_GC_CHARACTER_DELETE_WRONG_SOCIAL_ID    = 11,

    HEADER_GC_ATTACK                = 12,
    HEADER_GC_STUN                = 13,
    HEADER_GC_DEAD                = 14,

    HEADER_GC_MAIN_CHARACTER_OLD        = 15,
    HEADER_GC_CHARACTER_POINTS            = 16,
    HEADER_GC_CHARACTER_POINT_CHANGE        = 17,
    HEADER_GC_CHANGE_SPEED            = 18,
    HEADER_GC_CHARACTER_UPDATE            = 19,
    HEADER_GC_CHARACTER_UPDATE_NEW        = 24,

    HEADER_GC_ITEM_DEL                = 20,
    HEADER_GC_ITEM_SET                = 21,
    HEADER_GC_ITEM_USE                = 22,
    HEADER_GC_ITEM_DROP                = 23,
    HEADER_GC_ITEM_UPDATE            = 25,

    HEADER_GC_ITEM_GROUND_ADD            = 26,
    HEADER_GC_ITEM_GROUND_DEL            = 27,

    HEADER_GC_QUICKSLOT_ADD            = 28,
    HEADER_GC_QUICKSLOT_DEL            = 29,
    HEADER_GC_QUICKSLOT_SWAP            = 30,

    HEADER_GC_ITEM_OWNERSHIP            = 31,

    HEADER_GC_WHISPER                = 34,

    HEADER_GC_MOTION                = 36,
    HEADER_GC_PARTS                = 37,

    HEADER_GC_SHOP                = 38,
    HEADER_GC_SHOP_SIGN                = 39,

    HEADER_GC_DUEL_START                = 40,
    HEADER_GC_PVP                               = 41,
    HEADER_GC_EXCHANGE                = 42,
    HEADER_GC_CHARACTER_POSITION        = 43,

    HEADER_GC_PING                = 44,
    HEADER_GC_SCRIPT                = 45,
    HEADER_GC_QUEST_CONFIRM            = 46,

    HEADER_GC_MOUNT                = 61,
    HEADER_GC_OWNERSHIP                = 62,
    HEADER_GC_TARGET                 = 63,

    HEADER_GC_WARP                = 65,

    HEADER_GC_ADD_FLY_TARGETING            = 69,
    HEADER_GC_CREATE_FLY            = 70,
    HEADER_GC_FLY_TARGETING            = 71,
    HEADER_GC_SKILL_LEVEL_OLD            = 72,
    HEADER_GC_SKILL_LEVEL            = 76,

    HEADER_GC_MESSENGER                = 74,
    HEADER_GC_GUILD                = 75,

    HEADER_GC_PARTY_INVITE            = 77,
    HEADER_GC_PARTY_ADD                = 78,
    HEADER_GC_PARTY_UPDATE            = 79,
    HEADER_GC_PARTY_REMOVE            = 80,
    HEADER_GC_QUEST_INFO            = 81,
    HEADER_GC_REQUEST_MAKE_GUILD        = 82,
    HEADER_GC_PARTY_PARAMETER            = 83,

    HEADER_GC_SAFEBOX_SET            = 85,
    HEADER_GC_SAFEBOX_DEL            = 86,
    HEADER_GC_SAFEBOX_WRONG_PASSWORD        = 87,
    HEADER_GC_SAFEBOX_SIZE            = 88,

    HEADER_GC_FISHING                = 89,

    HEADER_GC_EMPIRE                = 90,

    HEADER_GC_PARTY_LINK            = 91,
    HEADER_GC_PARTY_UNLINK            = 92,

    HEADER_GC_REFINE_INFORMATION_OLD        = 95,

    HEADER_GC_VIEW_EQUIP            = 99,

    HEADER_GC_MARK_BLOCK            = 100,
    HEADER_GC_MARK_IDXLIST            = 102,

    HEADER_GC_TIME                    = 106,
    HEADER_GC_CHANGE_NAME            = 107,

    HEADER_GC_DUNGEON                = 110,

    HEADER_GC_WALK_MODE                = 111,
    HEADER_GC_SKILL_GROUP            = 112,
    HEADER_GC_MAIN_CHARACTER            = 113,

    //    HEADER_GC_USE_POTION            = 114,
    HEADER_GC_SEPCIAL_EFFECT        = 114,

    HEADER_GC_NPC_POSITION            = 115,

    HEADER_GC_MATRIX_CARD            = 116,
    HEADER_GC_LOGIN_KEY                = 118,
    HEADER_GC_REFINE_INFORMATION        = 119,
    HEADER_GC_CHANNEL                = 121,

    // 122 HEADER_GC_MALL_OPEN
    HEADER_GC_TARGET_UPDATE            = 123,
    HEADER_GC_TARGET_DELETE            = 124,
    HEADER_GC_TARGET_CREATE            = 125,

    HEADER_GC_AFFECT_ADD            = 126,
    HEADER_GC_AFFECT_REMOVE            = 127,

    HEADER_GC_MALL_OPEN                = 122,
    HEADER_GC_MALL_SET                = 128,
    HEADER_GC_MALL_DEL                = 129,

    HEADER_GC_LAND_LIST                = 130,
    HEADER_GC_LOVER_INFO            = 131,
    HEADER_GC_LOVE_POINT_UPDATE            = 132,

    HEADER_GC_SYMBOL_DATA            = 133,

    // MINING
    HEADER_GC_DIG_MOTION            = 134,
    // END_OF_MINING

    HEADER_GC_DAMAGE_INFO           = 135,
    HEADER_GC_CHAR_ADDITIONAL_INFO    = 136,

    // SUPPORT_BGM
    HEADER_GC_MAIN_CHARACTER3_BGM        = 137,
    HEADER_GC_MAIN_CHARACTER4_BGM_VOL    = 138,
    // END_OF_SUPPORT_BGM

    HEADER_GC_AUTH_SUCCESS            = 150,

    HEADER_GC_PANAMA_PACK            = 151,

    //HYBRID CRYPT
    HEADER_GC_HYBRIDCRYPT_KEYS        = 152,
    HEADER_GC_HYBRIDCRYPT_SDB        = 153, // SDB means Supplmentary Data Blocks
    //HYBRID CRYPT

    HEADER_GC_AUTH_SUCCESS_OPENID    = 154,

    // ROULETTE
    HEADER_GC_ROULETTE                    = 200,
    // END_ROULETTE            
    //
    HEADER_GC_REQUEST_PASSPOD                = 202,
    HEADER_GC_REQUEST_PASSPOD_FAILED        = 203,

    HEADER_GC_HS_REQUEST                    = 204,
    HEADER_GC_XTRAP_CS1_REQUEST                = 205,

    HEADER_GC_SPECIFIC_EFFECT                = 208,

    HEADER_GC_DRAGON_SOUL_REFINE            = 209,
    HEADER_GC_RESPOND_CHANNELSTATUS            = 210,

 

 

    /////////////////////////////////////////////////////////////////////////////

    HEADER_GG_LOGIN                = 1,
    HEADER_GG_LOGOUT                = 2,
    HEADER_GG_RELAY                = 3,
    HEADER_GG_NOTICE                = 4,
    HEADER_GG_SHUTDOWN                = 5,
    HEADER_GG_GUILD                = 6,
    HEADER_GG_DISCONNECT            = 7,    // 누군가의 접속을 강제로 끊을 때
    HEADER_GG_SHOUT                = 8,
    HEADER_GG_SETUP                = 9,
    HEADER_GG_MESSENGER_ADD                     = 10,
    HEADER_GG_MESSENGER_REMOVE                  = 11,
    HEADER_GG_FIND_POSITION            = 12,
    HEADER_GG_WARP_CHARACTER            = 13,
    HEADER_GG_MESSENGER_MOBILE            = 14,
    HEADER_GG_GUILD_WAR_ZONE_MAP_INDEX        = 15,
    HEADER_GG_TRANSFER                = 16,
    HEADER_GG_XMAS_WARP_SANTA            = 17,
    HEADER_GG_XMAS_WARP_SANTA_REPLY        = 18,
    HEADER_GG_RELOAD_CRC_LIST            = 19,
    HEADER_GG_LOGIN_PING            = 20,
    HEADER_GG_CHECK_CLIENT_VERSION        = 21,
    HEADER_GG_BLOCK_CHAT            = 22,

    HEADER_GG_BLOCK_EXCEPTION        = 24,
    HEADER_GG_SIEGE                    = 25,
    HEADER_GG_MONARCH_NOTICE        = 26,
    HEADER_GG_MONARCH_TRANSFER        = 27,
    HEADER_GG_PCBANG_UPDATE            = 28,

    HEADER_GG_CHECK_AWAKENESS        = 29,
};

#pragma pack(1)
typedef struct SPacketGGSetup
{
    BYTE    bHeader;
    WORD    wPort;
    BYTE    bChannel;
} TPacketGGSetup;

typedef struct SPacketGGLogin
{
    BYTE    bHeader;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    DWORD    dwPID;
    BYTE    bEmpire;
    long    lMapIndex;
    BYTE    bChannel;
} TPacketGGLogin;

typedef struct SPacketGGLogout
{
    BYTE    bHeader;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
} TPacketGGLogout;

typedef struct SPacketGGRelay
{
    BYTE    bHeader;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    long    lSize;
} TPacketGGRelay;

typedef struct SPacketGGNotice
{
    BYTE    bHeader;
    long    lSize;
    bool    bIsBig;    
} TPacketGGNotice;

typedef struct SPacketGGMonarchNotice
{
    BYTE    bHeader;
    BYTE    bEmpire;
    long    lSize;
} TPacketGGMonarchNotice;

//FORKED_ROAD
typedef struct SPacketGGForkedMapInfo
{
    BYTE    bHeader;
    BYTE    bPass;
    BYTE    bSungzi;
} TPacketGGForkedMapInfo;
//END_FORKED_ROAD
typedef struct SPacketGGShutdown
{
    BYTE    bHeader;
} TPacketGGShutdown;

typedef struct SPacketGGGuild
{
    BYTE    bHeader;
    BYTE    bSubHeader;
    DWORD    dwGuild;
} TPacketGGGuild;

enum
{
    GUILD_SUBHEADER_GG_CHAT,
    GUILD_SUBHEADER_GG_SET_MEMBER_COUNT_BONUS,
};

typedef struct SPacketGGGuildChat
{
    BYTE    bHeader;
    BYTE    bSubHeader;
    DWORD    dwGuild;
    char    szText[CHAT_MAX_LEN + 1];
} TPacketGGGuildChat;

typedef struct SPacketGGParty
{
    BYTE    header;
    BYTE    subheader;
    DWORD    pid;
    DWORD    leaderpid;
} TPacketGGParty;

enum
{
    PARTY_SUBHEADER_GG_CREATE,
    PARTY_SUBHEADER_GG_DESTROY,
    PARTY_SUBHEADER_GG_JOIN,
    PARTY_SUBHEADER_GG_QUIT,
};

typedef struct SPacketGGDisconnect
{
    BYTE    bHeader;
    char    szLogin[LOGIN_MAX_LEN + 1];
} TPacketGGDisconnect;

typedef struct SPacketGGShout
{
    BYTE    bHeader;
    BYTE    bEmpire;
    char    szText[CHAT_MAX_LEN + 1];
} TPacketGGShout;

typedef struct SPacketGGXmasWarpSanta
{
    BYTE    bHeader;
    BYTE    bChannel;
    long    lMapIndex;
} TPacketGGXmasWarpSanta;

typedef struct SPacketGGXmasWarpSantaReply
{
    BYTE    bHeader;
    BYTE    bChannel;
} TPacketGGXmasWarpSantaReply;

typedef struct SMessengerData
{
    char        szMobile[MOBILE_MAX_LEN + 1];
} TMessengerData;

typedef struct SPacketGGMessenger
{   
    BYTE        bHeader;
    char        szAccount[CHARACTER_NAME_MAX_LEN + 1];
    char        szCompanion[CHARACTER_NAME_MAX_LEN + 1];
} TPacketGGMessenger;

typedef struct SPacketGGMessengerMobile
{   
    BYTE        bHeader;
    char        szName[CHARACTER_NAME_MAX_LEN + 1];
    char        szMobile[MOBILE_MAX_LEN + 1];
} TPacketGGMessengerMobile;

typedef struct SPacketGGFindPosition
{
    BYTE header;
    DWORD dwFromPID; // 저 위치로 워프하려는 사람
    DWORD dwTargetPID; // 찾는 사람
} TPacketGGFindPosition;

typedef struct SPacketGGWarpCharacter
{
    BYTE header;
    DWORD pid;
    long x;
    long y;
} TPacketGGWarpCharacter;

//  HEADER_GG_GUILD_WAR_ZONE_MAP_INDEX        = 15,

typedef struct SPacketGGGuildWarMapIndex
{
    BYTE bHeader;
    DWORD dwGuildID1;
    DWORD dwGuildID2;
    long lMapIndex;
} TPacketGGGuildWarMapIndex;

typedef struct SPacketGGTransfer
{
    BYTE    bHeader;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    long    lX, lY;
} TPacketGGTransfer;

typedef struct SPacketGGLoginPing
{
    BYTE    bHeader;
    char    szLogin[LOGIN_MAX_LEN + 1];
} TPacketGGLoginPing;

typedef struct SPacketGGBlockChat
{
    BYTE    bHeader;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    long    lBlockDuration;
} TPacketGGBlockChat;

/* 클라이언트 측에서 보내는 패킷 */

typedef struct command_text
{
    BYTE    bHeader;
} TPacketCGText;

/* 로그인 (1) */
typedef struct command_handshake
{
    BYTE    bHeader;
    DWORD    dwHandshake;
    DWORD    dwTime;
    long    lDelta;
} TPacketCGHandshake;

typedef struct command_login
{
    BYTE    header;
    char    login[LOGIN_MAX_LEN + 1];
    char    passwd[PASSWD_MAX_LEN + 1];
} TPacketCGLogin;

typedef struct command_login2
{
    BYTE    header;
    char    login[LOGIN_MAX_LEN + 1];
    DWORD    dwLoginKey;
    DWORD    adwClientKey[4];
} TPacketCGLogin2;

typedef struct command_login3
{
    BYTE    header;
    char    login[LOGIN_MAX_LEN + 1];
    char    passwd[PASSWD_MAX_LEN + 1];
    DWORD    adwClientKey[4];
} TPacketCGLogin3;

typedef struct command_login5
{
    BYTE    header;
    char    authKey[OPENID_AUTHKEY_LEN + 1];
    DWORD    adwClientKey[4];
} TPacketCGLogin5;

typedef struct command_matrix_card
{
    BYTE    bHeader;
    char    szAnswer[MATRIX_ANSWER_MAX_LEN + 1];
} TPacketCGMatrixCard;

typedef struct packet_matrix_card
{
    BYTE    bHeader;
    DWORD    dwRows;
    DWORD    dwCols;
} TPacketGCMatrixCard;

typedef struct packet_login_key
{
    BYTE    bHeader;
    DWORD    dwLoginKey;
} TPacketGCLoginKey;

typedef struct command_player_select
{
    BYTE    header;
    BYTE    index;
} TPacketCGPlayerSelect;

typedef struct command_player_delete
{
    BYTE    header;
    BYTE    index;
    char    private_code[8];
} TPacketCGPlayerDelete;

typedef struct command_player_create
{
    BYTE        header;
    BYTE        index;
    char        name[CHARACTER_NAME_MAX_LEN + 1];
    WORD        job;
    BYTE    shape;
    BYTE    Con;
    BYTE    Int;
    BYTE    Str;
    BYTE    Dex;
} TPacketCGPlayerCreate;

typedef struct command_player_create_success
{
    BYTE        header;
    BYTE        bAccountCharacterIndex;
    TSimplePlayer    player;
} TPacketGCPlayerCreateSuccess;

// 공격
typedef struct command_attack
{
    BYTE    bHeader;
    BYTE    bType;
    DWORD    dwVID;
    BYTE    bCRCMagicCubeProcPiece;
    BYTE    bCRCMagicCubeFilePiece;
} TPacketCGAttack;

enum EMoveFuncType
{
    FUNC_WAIT,
    FUNC_MOVE,
    FUNC_ATTACK,
    FUNC_COMBO,
    FUNC_MOB_SKILL,
    _FUNC_SKILL,
    FUNC_MAX_NUM,
    FUNC_SKILL = 0x80,
};

// 이동
typedef struct command_move
{
    BYTE    bHeader;
    BYTE    bFunc;
    BYTE    bArg;
    BYTE    bRot;
    long    lX;
    long    lY;
    DWORD    dwTime;
} TPacketCGMove;

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

// 위치 동기화
typedef struct command_sync_position    // 가변 패킷
{
    BYTE    bHeader;
    WORD    wSize;
} TPacketCGSyncPosition;

/* 채팅 (3) */
typedef struct command_chat    // 가변 패킷
{
    BYTE    header;
    WORD    size;
    BYTE    type;
} TPacketCGChat;

/* 귓속말 */
typedef struct command_whisper
{
    BYTE    bHeader;
    WORD    wSize;
    char     szNameTo[CHARACTER_NAME_MAX_LEN + 1];
} TPacketCGWhisper;

typedef struct command_entergame
{
    BYTE    header;
} TPacketCGEnterGame;

typedef struct command_item_use
{
    BYTE     header;
    TItemPos     Cell;
} TPacketCGItemUse;

typedef struct command_item_use_to_item
{
    BYTE    header;
    TItemPos    Cell;
    TItemPos    TargetCell;
} TPacketCGItemUseToItem;

typedef struct command_item_drop
{
    BYTE     header;
    TItemPos     Cell;
    DWORD    gold;
} TPacketCGItemDrop;

typedef struct command_item_drop2
{
    BYTE     header;
    TItemPos     Cell;
    DWORD    gold;
    BYTE    count;
} TPacketCGItemDrop2;

typedef struct command_item_move
{
    BYTE     header;
    TItemPos    Cell;
    TItemPos    CellTo;
    BYTE    count;
} TPacketCGItemMove;

typedef struct command_item_pickup
{
    BYTE     header;
    DWORD    vid;
} TPacketCGItemPickup;

typedef struct command_quickslot_add
{
    BYTE    header;
    BYTE    pos;
    TQuickslot    slot;
} TPacketCGQuickslotAdd;

typedef struct command_quickslot_del
{
    BYTE    header;
    BYTE    pos;
} TPacketCGQuickslotDel;

typedef struct command_quickslot_swap
{
    BYTE    header;
    BYTE    pos;
    BYTE    change_pos;
} TPacketCGQuickslotSwap;

enum
{
    SHOP_SUBHEADER_CG_END,
    SHOP_SUBHEADER_CG_BUY,
    SHOP_SUBHEADER_CG_SELL,
    SHOP_SUBHEADER_CG_SELL2
};

typedef struct command_shop_buy
{
    BYTE    count;
} TPacketCGShopBuy;

typedef struct command_shop_sell
{
    BYTE    pos;
    BYTE    count;
} TPacketCGShopSell;

typedef struct command_shop
{
    BYTE    header;
    BYTE    subheader;
} TPacketCGShop;

typedef struct command_on_click
{
    BYTE    header;
    DWORD    vid;
} TPacketCGOnClick;

enum
{
    EXCHANGE_SUBHEADER_CG_START,    /* arg1 == vid of target character */
    EXCHANGE_SUBHEADER_CG_ITEM_ADD,    /* arg1 == position of item */
    EXCHANGE_SUBHEADER_CG_ITEM_DEL,    /* arg1 == position of item */
    EXCHANGE_SUBHEADER_CG_ELK_ADD,    /* arg1 == amount of gold */
    EXCHANGE_SUBHEADER_CG_ACCEPT,    /* arg1 == not used */
    EXCHANGE_SUBHEADER_CG_CANCEL,    /* arg1 == not used */
};

typedef struct command_exchange
{
    BYTE    header;
    BYTE    sub_header;
    DWORD    arg1;
    BYTE    arg2;
    TItemPos    Pos;
} TPacketCGExchange;

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

typedef struct command_script_answer
{
    BYTE    header;
    BYTE    answer;
    //char    file[32 + 1];
    //BYTE    answer[16 + 1];
} TPacketCGScriptAnswer;

 

typedef struct command_script_button
{
    BYTE        header;
    unsigned int    idx;
} TPacketCGScriptButton;

typedef struct command_quest_input_string
{
    BYTE header;
    char msg[64+1];
} TPacketCGQuestInputString;

typedef struct command_quest_confirm
{
    BYTE header;
    BYTE answer;
    DWORD requestPID;
} TPacketCGQuestConfirm;

/*
 * 서버 측에서 보내는 패킷
 */
typedef struct packet_quest_confirm
{
    BYTE header;
    char msg[64+1];
    long timeout;
    DWORD requestPID;
} TPacketGCQuestConfirm;

typedef struct packet_handshake
{
    BYTE    bHeader;
    DWORD    dwHandshake;
    DWORD    dwTime;
    long    lDelta;
} TPacketGCHandshake;

enum EPhase
{
    PHASE_CLOSE,
    PHASE_HANDSHAKE,
    PHASE_LOGIN,
    PHASE_SELECT,
    PHASE_LOADING,
    PHASE_GAME,
    PHASE_DEAD,

    PHASE_CLIENT_CONNECTING,
    PHASE_DBCLIENT,
    PHASE_P2P,
    PHASE_AUTH,
    PHASE_TEEN,
    PHASE_PASSPOD,
};

typedef struct packet_phase
{
    BYTE    header;
    BYTE    phase;
} TPacketGCPhase;

typedef struct packet_bindudp
{
    BYTE    header;
    DWORD    addr;
    WORD    port;
} TPacketGCBindUDP;

enum
{
    LOGIN_FAILURE_ALREADY    = 1,
    LOGIN_FAILURE_ID_NOT_EXIST    = 2,
    LOGIN_FAILURE_WRONG_PASS    = 3,
    LOGIN_FAILURE_FALSE        = 4,
    LOGIN_FAILURE_NOT_TESTOR    = 5,
    LOGIN_FAILURE_NOT_TEST_TIME    = 6,
    LOGIN_FAILURE_FULL        = 7
};

typedef struct packet_login_success
{
    BYTE        bHeader;
    TSimplePlayer    players[PLAYER_PER_ACCOUNT];
    DWORD        guild_id[PLAYER_PER_ACCOUNT];
    char        guild_name[PLAYER_PER_ACCOUNT][GUILD_NAME_MAX_LEN+1];

    DWORD        handle;
    DWORD        random_key;
} TPacketGCLoginSuccess;

typedef struct packet_auth_success
{
    BYTE    bHeader;
    DWORD    dwLoginKey;
    BYTE    bResult;
} TPacketGCAuthSuccess;

typedef struct packet_auth_success_openid
{
    BYTE    bHeader;
    DWORD    dwLoginKey;
    BYTE    bResult;
    char    login[LOGIN_MAX_LEN + 1];
} TPacketGCAuthSuccessOpenID;

typedef struct packet_login_failure
{
    BYTE    header;
    char    szStatus[ACCOUNT_STATUS_MAX_LEN + 1];
} TPacketGCLoginFailure;

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

enum
{
    ADD_CHARACTER_STATE_DEAD        = (1 << 0),
    ADD_CHARACTER_STATE_SPAWN        = (1 << 1),
    ADD_CHARACTER_STATE_GUNGON        = (1 << 2),
    ADD_CHARACTER_STATE_KILLER        = (1 << 3),
    ADD_CHARACTER_STATE_PARTY        = (1 << 4),
};

enum ECharacterEquipmentPart
{
    CHR_EQUIPPART_ARMOR,
    CHR_EQUIPPART_WEAPON,
    CHR_EQUIPPART_HEAD,
    CHR_EQUIPPART_HAIR,
    CHR_EQUIPPART_WING,
    CHR_EQUIPPART_NUM,
};

typedef struct packet_add_char
{
    BYTE    header;
    DWORD    dwVID;

    float    angle;
    long    x;
    long    y;
    long    z;

    BYTE    bType;
    WORD    wRaceNum;
    BYTE    bMovingSpeed;
    BYTE    bAttackSpeed;

    BYTE    bStateFlag;
    DWORD    dwAffectFlag[2];    // 효과
} TPacketGCCharacterAdd;

typedef struct packet_char_additional_info
{
    BYTE    header;
    DWORD   dwVID;
    char    name[CHARACTER_NAME_MAX_LEN + 1];
    WORD    awPart[CHR_EQUIPPART_NUM];
    BYTE    bEmpire;
    DWORD   dwGuildID;
    DWORD   dwLevel;
    short    sAlignment;
    BYTE    bPKMode;
    DWORD    dwMountVnum;
} TPacketGCCharacterAdditionalInfo;

/*
   typedef struct packet_update_char_old
   {
   BYTE    header;
   DWORD    dwVID;

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

   BYTE    bStateFlag;
   DWORD    dwAffectFlag[2];

   DWORD    dwGuildID;
   short    sAlignment;
   BYTE    bPKMode;
   DWORD    dwMountVnum;
   } TPacketGCCharacterUpdateOld;
 */

typedef struct packet_update_char
{
    BYTE    header;
    DWORD    dwVID;

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

    BYTE    bStateFlag;
    DWORD    dwAffectFlag[2];

    DWORD    dwGuildID;
    short    sAlignment;
    BYTE    bPKMode;
    DWORD    dwMountVnum;
    //WORD    wRaceNum;
} TPacketGCCharacterUpdate;

typedef struct packet_del_char
{
    BYTE    header;
    DWORD    id;
} TPacketGCCharacterDelete;

typedef struct packet_chat    // 가변 패킷
{
    BYTE    header;
    WORD    size;
    BYTE    type;
    DWORD    id;
    BYTE    bEmpire;
} TPacketGCChat;

typedef struct packet_whisper    // 가변 패킷
{
    BYTE    bHeader;
    WORD    wSize;
    BYTE    bType;
    char    szNameFrom[CHARACTER_NAME_MAX_LEN + 1];
} TPacketGCWhisper;

typedef struct packet_main_character
{
    BYTE        header;
    DWORD    dwVID;
    WORD    wRaceNum;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
    long    lx, ly, lz;
    BYTE    empire;
    BYTE    skill_group;
} TPacketGCMainCharacter;

// SUPPORT_BGM
typedef struct packet_main_character3_bgm
{
    enum
    {
        MUSIC_NAME_LEN = 24,
    };

    BYTE    header;
    DWORD    dwVID;
    WORD    wRaceNum;
    char    szChrName[CHARACTER_NAME_MAX_LEN + 1];
    char    szBGMName[MUSIC_NAME_LEN + 1];
    long    lx, ly, lz;
    BYTE    empire;
    BYTE    skill_group;
} TPacketGCMainCharacter3_BGM;

typedef struct packet_main_character4_bgm_vol
{
    enum
    {
        MUSIC_NAME_LEN = 24,
    };

    BYTE    header;
    DWORD    dwVID;
    WORD    wRaceNum;
    char    szChrName[CHARACTER_NAME_MAX_LEN + 1];
    char    szBGMName[MUSIC_NAME_LEN + 1];
    float    fBGMVol;
    long    lx, ly, lz;
    BYTE    empire;
    BYTE    skill_group;
} TPacketGCMainCharacter4_BGM_VOL;
// END_OF_SUPPORT_BGM

typedef struct packet_points
{
    BYTE    header;
    long long        points[POINT_MAX_NUM];
} TPacketGCPoints;

typedef struct packet_skill_level
{
    BYTE        bHeader;
    TPlayerSkill    skills[SKILL_MAX_NUM];
} TPacketGCSkillLevel;

typedef struct packet_point_change
{
    int        header;
    DWORD    dwVID;
    BYTE    type;
    long long    amount;
    long long    value;
} TPacketGCPointChange;

typedef struct packet_stun
{
    BYTE    header;
    DWORD    vid;
} TPacketGCStun;

typedef struct packet_dead
{
    BYTE    header;
    DWORD    vid;
} TPacketGCDead;

struct TPacketGCItemDelDeprecated
{
    BYTE    header;
    TItemPos Cell;
    DWORD    vnum;
    BYTE    count;
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
};

typedef struct packet_item_set
{
    BYTE    header;
    TItemPos Cell;
    DWORD    vnum;
    BYTE    count;
    DWORD    flags;
    DWORD    anti_flags;
    bool    highlight;
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
} TPacketGCItemSet;

typedef struct packet_item_del
{
    BYTE    header;
    BYTE    pos;
} TPacketGCItemDel;

struct packet_item_use
{
    BYTE    header;
    TItemPos Cell;
    DWORD    ch_vid;
    DWORD    victim_vid;
    DWORD    vnum;
};

struct packet_item_move
{
    BYTE    header;
    TItemPos Cell;
    TItemPos CellTo;
};

typedef struct packet_item_update
{
    BYTE    header;
    TItemPos Cell;
    BYTE    count;
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
} TPacketGCItemUpdate;

typedef struct packet_item_ground_add
{
    BYTE    bHeader;
    long     x, y, z;
    DWORD    dwVID;
    DWORD    dwVnum;
} TPacketGCItemGroundAdd;

typedef struct packet_item_ownership
{
    BYTE    bHeader;
    DWORD    dwVID;
    char    szName[CHARACTER_NAME_MAX_LEN + 1];
} TPacketGCItemOwnership;

typedef struct packet_item_ground_del
{
    BYTE    bHeader;
    DWORD    dwVID;
} TPacketGCItemGroundDel;

struct packet_quickslot_add
{
    BYTE    header;
    BYTE    pos;
    TQuickslot    slot;
};

struct packet_quickslot_del
{
    BYTE    header;
    BYTE    pos;
};

struct packet_quickslot_swap
{
    BYTE    header;
    BYTE    pos;
    BYTE    pos_to;
};

struct packet_motion
{
    BYTE    header;
    DWORD    vid;
    DWORD    victim_vid;
    WORD    motion;
};

enum EPacketShopSubHeaders
{
    SHOP_SUBHEADER_GC_START,
    SHOP_SUBHEADER_GC_END,
    SHOP_SUBHEADER_GC_UPDATE_ITEM,
    SHOP_SUBHEADER_GC_UPDATE_PRICE,
    SHOP_SUBHEADER_GC_OK,
    SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY,
    SHOP_SUBHEADER_GC_SOLDOUT,
    SHOP_SUBHEADER_GC_INVENTORY_FULL,
    SHOP_SUBHEADER_GC_INVALID_POS,
    SHOP_SUBHEADER_GC_SOLD_OUT,
    SHOP_SUBHEADER_GC_START_EX,
    SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX,
};

struct packet_shop_item
{   
    DWORD       vnum;
    DWORD       price;
    BYTE        count;
    BYTE        display_pos;
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
};

typedef struct packet_shop_start
{
    DWORD   owner_vid;
    struct packet_shop_item    items[SHOP_HOST_ITEM_MAX_NUM];
} TPacketGCShopStart;

typedef struct packet_shop_start_ex // 다음에 TSubPacketShopTab* shop_tabs 이 따라옴.
{
    typedef struct sub_packet_shop_tab
    {
        char name[SHOP_TAB_NAME_MAX];
        BYTE coin_type;
        packet_shop_item items[SHOP_HOST_ITEM_MAX_NUM];
    } TSubPacketShopTab;
    DWORD owner_vid;
    BYTE shop_tab_count;
} TPacketGCShopStartEx;

typedef struct packet_shop_update_item
{
    BYTE            pos;
    struct packet_shop_item    item;
} TPacketGCShopUpdateItem;

typedef struct packet_shop_update_price
{
    int                iPrice;
} TPacketGCShopUpdatePrice;

typedef struct packet_shop    // 가변 패킷
{
    BYTE        header;
    WORD    size;
    BYTE        subheader;
} TPacketGCShop;

struct packet_exchange
{
    BYTE    header;
    BYTE    sub_header;
    BYTE    is_me;
    DWORD    arg1;    // vnum
    TItemPos    arg2;    // cell
    DWORD    arg3;    // count
    long    alSockets[ITEM_SOCKET_MAX_NUM];
    TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
};

enum EPacketTradeSubHeaders
{
    EXCHANGE_SUBHEADER_GC_START,    /* arg1 == vid */
    EXCHANGE_SUBHEADER_GC_ITEM_ADD,    /* arg1 == vnum  arg2 == pos  arg3 == count */
    EXCHANGE_SUBHEADER_GC_ITEM_DEL,
    EXCHANGE_SUBHEADER_GC_GOLD_ADD,    /* arg1 == gold */
    EXCHANGE_SUBHEADER_GC_ACCEPT,    /* arg1 == accept */
    EXCHANGE_SUBHEADER_GC_END,        /* arg1 == not used */
    EXCHANGE_SUBHEADER_GC_ALREADY,    /* arg1 == not used */
    EXCHANGE_SUBHEADER_GC_LESS_GOLD,    /* arg1 == not used */
};

struct packet_position
{
    BYTE    header;
    DWORD    vid;
    BYTE    position;
};

typedef struct packet_ping
{
    BYTE    header;
} TPacketGCPing;

struct packet_script
{
    BYTE    header;
    WORD    size;
    BYTE    skin;
    WORD    src_size;
};

typedef struct packet_change_speed
{
    BYTE        header;
    DWORD        vid;
    WORD        moving_speed;
} TPacketGCChangeSpeed;

struct packet_mount
{
    BYTE    header;
    DWORD    vid;
    DWORD    mount_vid;
    BYTE    pos;
    DWORD    x, y;
};

typedef struct packet_move
{    
    BYTE        bHeader;
    BYTE        bFunc;
    BYTE        bArg;
    BYTE        bRot;
    DWORD        dwVID;
    long        lX;
    long        lY;
    DWORD        dwTime;
    DWORD        dwDuration;
} TPacketGCMove;

// 소유권
typedef struct packet_ownership
{
    BYTE        bHeader;
    DWORD        dwOwnerVID;
    DWORD        dwVictimVID;
} TPacketGCOwnership;

// 위치 동기화 패킷의 bCount 만큼 붙는 단위
typedef struct packet_sync_position_element
{
    DWORD    dwVID;
    long    lX;
    long    lY;
} TPacketGCSyncPositionElement;

// 위치 동기화
typedef struct packet_sync_position    // 가변 패킷
{
    BYTE    bHeader;
    WORD    wSize;    // 개수 = (wSize - sizeof(TPacketGCSyncPosition)) / sizeof(TPacketGCSyncPositionElement)
} TPacketGCSyncPosition;

typedef struct packet_fly
{
    BYTE    bHeader;
    BYTE    bType;
    DWORD    dwStartVID;
    DWORD    dwEndVID;
} TPacketGCCreateFly;

typedef struct command_fly_targeting
{
    BYTE        bHeader;
    DWORD        dwTargetVID;
    long        x, y;
} TPacketCGFlyTargeting;

typedef struct packet_fly_targeting
{
    BYTE        bHeader;
    DWORD        dwShooterVID;
    DWORD        dwTargetVID;
    long        x, y;
} TPacketGCFlyTargeting;

typedef struct packet_shoot
{
    BYTE        bHeader;
    BYTE        bType;
} TPacketCGShoot;

typedef struct packet_duel_start
{
    BYTE    header;
    WORD    wSize;    // DWORD가 몇개? 개수 = (wSize - sizeof(TPacketGCPVPList)) / 4
} TPacketGCDuelStart;

enum EPVPModes
{
    PVP_MODE_NONE,
    PVP_MODE_AGREE,
    PVP_MODE_FIGHT,
    PVP_MODE_REVENGE
};

typedef struct packet_pvp
{
    BYTE        bHeader;
    DWORD       dwVIDSrc;
    DWORD       dwVIDDst;
    BYTE        bMode;    // 0 이면 끔, 1이면 켬
} TPacketGCPVP;

typedef struct command_use_skill
{
    BYTE    bHeader;
    DWORD    dwVnum;
    DWORD    dwVID;
} TPacketCGUseSkill;

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

typedef struct packet_target
{
    BYTE    header;
    DWORD    dwVID;
    BYTE    bHPPercent;
} TPacketGCTarget;

typedef struct packet_warp
{
    BYTE    bHeader;
    long    lX;
    long    lY;
    long    lAddr;
    WORD    wPort;
} TPacketGCWarp;

typedef struct command_warp
{
    BYTE    bHeader;
} TPacketCGWarp;

struct packet_quest_info
{
    BYTE header;
    WORD size;
    WORD index;
    BYTE flag;
};

enum
{
    MESSENGER_SUBHEADER_GC_LIST,
    MESSENGER_SUBHEADER_GC_LOGIN,
    MESSENGER_SUBHEADER_GC_LOGOUT,
    MESSENGER_SUBHEADER_GC_INVITE,
    MESSENGER_SUBHEADER_GC_MOBILE
};

typedef struct packet_messenger
{
    BYTE header;
    WORD size;
    BYTE subheader;
} TPacketGCMessenger;

typedef struct packet_messenger_guild_list
{
    BYTE connected;
    BYTE length;
    //char login[LOGIN_MAX_LEN+1];
} TPacketGCMessengerGuildList;

typedef struct packet_messenger_guild_login
{
    BYTE length;
    //char login[LOGIN_MAX_LEN+1];
} TPacketGCMessengerGuildLogin;

typedef struct packet_messenger_guild_logout
{
    BYTE length;

    //char login[LOGIN_MAX_LEN+1];
} TPacketGCMessengerGuildLogout;

typedef struct packet_messenger_list_offline
{
    BYTE connected; // always 0
    BYTE length;
} TPacketGCMessengerListOffline;

typedef struct packet_messenger_list_online
{
    BYTE connected; // always 1
    BYTE length;
} TPacketGCMessengerListOnline;

enum
{
    MESSENGER_SUBHEADER_CG_ADD_BY_VID,
    MESSENGER_SUBHEADER_CG_ADD_BY_NAME,
    MESSENGER_SUBHEADER_CG_REMOVE,
    MESSENGER_SUBHEADER_CG_INVITE_ANSWER,
};

typedef struct command_messenger
{
    BYTE header;
    BYTE subheader;
} TPacketCGMessenger;

typedef struct command_messenger_add_by_vid
{
    DWORD vid;
} TPacketCGMessengerAddByVID;

typedef struct command_messenger_add_by_name
{
    BYTE length;
    //char login[LOGIN_MAX_LEN+1];
} TPacketCGMessengerAddByName;

typedef struct command_messenger_remove
{
    char login[LOGIN_MAX_LEN+1];
    //DWORD account;
} TPacketCGMessengerRemove;

typedef struct command_safebox_checkout
{
    BYTE    bHeader;
    BYTE    bSafePos;
    TItemPos    ItemPos;
} TPacketCGSafeboxCheckout;

typedef struct command_safebox_checkin
{
    BYTE    bHeader;
    BYTE    bSafePos;
    TItemPos    ItemPos;
} TPacketCGSafeboxCheckin;

///////////////////////////////////////////////////////////////////////////////////
// Party

typedef struct command_party_parameter
{
    BYTE    bHeader;
    BYTE    bDistributeMode;
} TPacketCGPartyParameter;

typedef struct paryt_parameter
{
    BYTE    bHeader;
    BYTE    bDistributeMode;
} TPacketGCPartyParameter;

typedef struct packet_party_add
{
    BYTE    header;
    DWORD    pid;
    char    name[CHARACTER_NAME_MAX_LEN+1];
} TPacketGCPartyAdd;

typedef struct command_party_invite
{
    BYTE    header;
    DWORD    vid;
} TPacketCGPartyInvite;

typedef struct packet_party_invite
{
    BYTE    header;
    DWORD    leader_vid;
} TPacketGCPartyInvite;

typedef struct command_party_invite_answer
{
    BYTE    header;
    DWORD    leader_vid;
    BYTE    accept;
} TPacketCGPartyInviteAnswer;

typedef struct packet_party_update
{
    BYTE    header;
    DWORD    pid;
    BYTE    role;
    BYTE    percent_hp;
    short    affects[7];
} TPacketGCPartyUpdate;

typedef struct packet_party_remove
{
    BYTE header;
    DWORD pid;
} TPacketGCPartyRemove;

typedef struct packet_party_link
{
    BYTE header;
    DWORD pid;
    DWORD vid;
} TPacketGCPartyLink;

typedef struct packet_party_unlink
{
    BYTE header;
    DWORD pid;
    DWORD vid;
} TPacketGCPartyUnlink;

typedef struct command_party_remove
{
    BYTE header;
    DWORD pid;
} TPacketCGPartyRemove;

typedef struct command_party_set_state
{
    BYTE header;
    DWORD pid;
    BYTE byRole;
    BYTE flag;
} TPacketCGPartySetState;

enum
{
    PARTY_SKILL_HEAL = 1,
    PARTY_SKILL_WARP = 2
};

typedef struct command_party_use_skill
{
    BYTE header;
    BYTE bySkillIndex;
    DWORD vid;
} TPacketCGPartyUseSkill;

typedef struct packet_safebox_size
{
    BYTE bHeader;
    BYTE bSize;
} TPacketCGSafeboxSize;

typedef struct packet_safebox_wrong_password
{
    BYTE    bHeader;
} TPacketCGSafeboxWrongPassword;

typedef struct command_empire
{
    BYTE    bHeader;
    BYTE    bEmpire;
} TPacketCGEmpire;

typedef struct packet_empire
{
    BYTE    bHeader;
    BYTE    bEmpire;
} TPacketGCEmpire;

enum
{
    SAFEBOX_MONEY_STATE_SAVE,
    SAFEBOX_MONEY_STATE_WITHDRAW,
};

typedef struct command_safebox_money
{
    BYTE        bHeader;
    BYTE        bState;
    long    lMoney;
} TPacketCGSafeboxMoney;

typedef struct packet_safebox_money_change
{
    BYTE    bHeader;
    long    lMoney;
} TPacketGCSafeboxMoneyChange;

// Guild

enum
{
    GUILD_SUBHEADER_GC_LOGIN,
    GUILD_SUBHEADER_GC_LOGOUT,
    GUILD_SUBHEADER_GC_LIST,
    GUILD_SUBHEADER_GC_GRADE,
    GUILD_SUBHEADER_GC_ADD,
    GUILD_SUBHEADER_GC_REMOVE,
    GUILD_SUBHEADER_GC_GRADE_NAME,
    GUILD_SUBHEADER_GC_GRADE_AUTH,
    GUILD_SUBHEADER_GC_INFO,
    GUILD_SUBHEADER_GC_COMMENTS,
    GUILD_SUBHEADER_GC_CHANGE_EXP,
    GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE,
    GUILD_SUBHEADER_GC_SKILL_INFO,
    GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL,
    GUILD_SUBHEADER_GC_GUILD_INVITE,
    GUILD_SUBHEADER_GC_WAR,
    GUILD_SUBHEADER_GC_GUILD_NAME,
    GUILD_SUBHEADER_GC_GUILD_WAR_LIST,
    GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST,
    GUILD_SUBHEADER_GC_WAR_SCORE,
    GUILD_SUBHEADER_GC_MONEY_CHANGE,
};

enum GUILD_SUBHEADER_CG
{
    GUILD_SUBHEADER_CG_ADD_MEMBER,
    GUILD_SUBHEADER_CG_REMOVE_MEMBER,
    GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME,
    GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY,
    GUILD_SUBHEADER_CG_OFFER,
    GUILD_SUBHEADER_CG_POST_COMMENT,
    GUILD_SUBHEADER_CG_DELETE_COMMENT,    
    GUILD_SUBHEADER_CG_REFRESH_COMMENT,
    GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE,
    GUILD_SUBHEADER_CG_USE_SKILL,
    GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL,
    GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER,
    GUILD_SUBHEADER_CG_CHARGE_GSP,
    GUILD_SUBHEADER_CG_DEPOSIT_MONEY,
    GUILD_SUBHEADER_CG_WITHDRAW_MONEY,
};

typedef struct packet_guild
{
    BYTE header;
    WORD size;
    BYTE subheader;
} TPacketGCGuild;

typedef struct packet_guild_name_t
{
    BYTE header;
    WORD size;
    BYTE subheader;
    DWORD    guildID;
    char    guildName[GUILD_NAME_MAX_LEN];
} TPacketGCGuildName;

typedef struct packet_guild_war
{
    DWORD    dwGuildSelf;
    DWORD    dwGuildOpp;
    BYTE    bType;
    BYTE     bWarState;
} TPacketGCGuildWar;

typedef struct command_guild
{
    BYTE header;
    BYTE subheader;
} TPacketCGGuild;

typedef struct command_guild_answer_make_guild
{
    BYTE header;
    char guild_name[GUILD_NAME_MAX_LEN+1];
} TPacketCGAnswerMakeGuild;

typedef struct command_guild_use_skill
{
    DWORD    dwVnum;
    DWORD    dwPID;
} TPacketCGGuildUseSkill;

// Guild Mark
typedef struct command_mark_login
{
    BYTE    header;
    DWORD   handle;
    DWORD   random_key;
} TPacketCGMarkLogin;

typedef struct command_mark_upload
{
    BYTE    header;
    DWORD    gid;
    BYTE    image[16*12*4];
} TPacketCGMarkUpload;

typedef struct command_mark_idxlist
{
    BYTE    header;
} TPacketCGMarkIDXList;

typedef struct command_mark_crclist
{
    BYTE    header;
    BYTE    imgIdx;
    DWORD    crclist[80];
} TPacketCGMarkCRCList;

typedef struct packet_mark_idxlist
{
    BYTE    header;
    DWORD    bufSize;
    WORD    count;
    //뒤에 size * (WORD + WORD)만큼 데이터 붙음
} TPacketGCMarkIDXList;

typedef struct packet_mark_block
{
    BYTE    header;
    DWORD    bufSize;
    BYTE    imgIdx;
    DWORD    count;
    // 뒤에 64 x 48 x 픽셀크기(4바이트) = 12288만큼 데이터 붙음
} TPacketGCMarkBlock;

typedef struct command_symbol_upload
{
    BYTE    header;
    WORD    size;
    DWORD    guild_id;
} TPacketCGGuildSymbolUpload;

typedef struct command_symbol_crc
{
    BYTE header;
    DWORD guild_id;
    DWORD crc;
    DWORD size;
} TPacketCGSymbolCRC;

typedef struct packet_symbol_data
{
    BYTE header;
    WORD size;
    DWORD guild_id;
} TPacketGCGuildSymbolData;

// Fishing

typedef struct command_fishing
{
    BYTE header;
    BYTE dir;
} TPacketCGFishing;

typedef struct packet_fishing
{
    BYTE header;
    BYTE subheader;
    DWORD info;
    BYTE dir;
} TPacketGCFishing;

enum
{
    FISHING_SUBHEADER_GC_START,
    FISHING_SUBHEADER_GC_STOP,
    FISHING_SUBHEADER_GC_REACT,
    FISHING_SUBHEADER_GC_SUCCESS,
    FISHING_SUBHEADER_GC_FAIL,
    FISHING_SUBHEADER_GC_FISH,
};

typedef struct command_give_item
{
    BYTE byHeader;
    DWORD dwTargetVID;
    TItemPos ItemPos;
    BYTE byItemCount;
} TPacketCGGiveItem;

typedef struct SPacketCGHack
{
    BYTE    bHeader;
    char    szBuf[255 + 1];
} TPacketCGHack;

// SubHeader - Dungeon
enum
{
    DUNGEON_SUBHEADER_GC_TIME_ATTACK_START = 0,
    DUNGEON_SUBHEADER_GC_DESTINATION_POSITION = 1,
};

typedef struct packet_dungeon
{
    BYTE bHeader;
    WORD size;
    BYTE subheader;
} TPacketGCDungeon;

typedef struct packet_dungeon_dest_position
{
    long x;
    long y;
} TPacketGCDungeonDestPosition;

typedef struct SPacketGCShopSign
{
    BYTE    bHeader;
    DWORD    dwVID;
    char    szSign[SHOP_SIGN_MAX_LEN + 1];
} TPacketGCShopSign;

typedef struct SPacketCGMyShop
{
    BYTE    bHeader;
    char    szSign[SHOP_SIGN_MAX_LEN + 1];
    BYTE    bCount;
} TPacketCGMyShop;

typedef struct SPacketGCTime
{
    BYTE    bHeader;
    time_t    time;
} TPacketGCTime;

enum
{
    WALKMODE_RUN,
    WALKMODE_WALK,
};

typedef struct SPacketGCWalkMode
{
    BYTE    header;
    DWORD    vid;
    BYTE    mode;
} TPacketGCWalkMode;

typedef struct SPacketGCChangeSkillGroup
{
    BYTE        header;
    BYTE        skill_group;
} TPacketGCChangeSkillGroup;

typedef struct SPacketCGRefine
{
    BYTE    header;
    BYTE    pos;
    BYTE    type;
} TPacketCGRefine;

typedef struct SPacketCGRequestRefineInfo
{
    BYTE    header;
    BYTE    pos;
} TPacketCGRequestRefineInfo;

typedef struct SPacketGCRefineInformaion
{
    BYTE    header;
    BYTE    type;
    BYTE    pos;
    DWORD    src_vnum;
    DWORD    result_vnum;
    BYTE    material_count;
    int        cost; // 소요 비용
    int        prob; // 확률
    TRefineMaterial materials[REFINE_MATERIAL_MAX_NUM];
} TPacketGCRefineInformation;

struct TNPCPosition
{
    BYTE bType;
    char name[CHARACTER_NAME_MAX_LEN+1];
    long x;
    long y;
};

typedef struct SPacketGCNPCPosition
{
    BYTE header;
    WORD size;
    WORD count;

    // array of TNPCPosition
} TPacketGCNPCPosition;

typedef struct SPacketGCSpecialEffect
{
    BYTE header;
    BYTE type;
    DWORD vid;
} TPacketGCSpecialEffect;

typedef struct SPacketCGChangeName
{
    BYTE header;
    BYTE index;
    char name[CHARACTER_NAME_MAX_LEN+1];
} TPacketCGChangeName;

typedef struct SPacketGCChangeName
{
    BYTE header;
    DWORD pid;
    char name[CHARACTER_NAME_MAX_LEN+1];
} TPacketGCChangeName;

 

 

typedef struct command_client_version
{
    BYTE header;
    char filename[32+1];
    char timestamp[32+1];
} TPacketCGClientVersion;

typedef struct command_client_version2
{
    BYTE header;
    char filename[32+1];
    char timestamp[32+1];
} TPacketCGClientVersion2;

typedef struct packet_channel
{
    BYTE header;
    BYTE channel;
} TPacketGCChannel;

typedef struct pakcet_view_equip
{
    BYTE  header;
    DWORD vid;
    struct {
        DWORD    vnum;
        BYTE    count;
        long    alSockets[ITEM_SOCKET_MAX_NUM];
        TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_MAX_NUM];
    } equips[WEAR_MAX_NUM];
} TPacketViewEquip;

typedef struct
{
    DWORD    dwID;
    long    x, y;
    long    width, height;
    DWORD    dwGuildID;
} TLandPacketElement;

typedef struct packet_land_list
{
    BYTE    header;
    WORD    size;
} TPacketGCLandList;

typedef struct
{
    BYTE    bHeader;
    long    lID;
    char    szName[32+1];
    DWORD    dwVID;
    BYTE    bType;
} TPacketGCTargetCreate;

typedef struct
{
    BYTE    bHeader;
    long    lID;
    long    lX, lY;
} TPacketGCTargetUpdate;

typedef struct
{
    BYTE    bHeader;
    long    lID;
} TPacketGCTargetDelete;

typedef struct
{
    BYTE        bHeader;
    TPacketAffectElement elem;
} TPacketGCAffectAdd;

typedef struct
{
    BYTE    bHeader;
    DWORD    dwType;
    BYTE    bApplyOn;
} TPacketGCAffectRemove;

typedef struct packet_lover_info
{
    BYTE header;
    char name[CHARACTER_NAME_MAX_LEN + 1];
    BYTE love_point;
} TPacketGCLoverInfo;

typedef struct packet_love_point_update
{
    BYTE header;
    BYTE love_point;
} TPacketGCLovePointUpdate;

// MINING
typedef struct packet_dig_motion
{
    BYTE header;
    DWORD vid;
    DWORD target_vid;
    BYTE count;
} TPacketGCDigMotion;
// END_OF_MINING

// SCRIPT_SELECT_ITEM
typedef struct command_script_select_item
{
    BYTE header;
    DWORD selection;
} TPacketCGScriptSelectItem;
// END_OF_SCRIPT_SELECT_ITEM

typedef struct packet_damage_info
{
    BYTE header;
    DWORD dwVID;
    BYTE flag;
    int damage;
} TPacketGCDamageInfo;

enum
{
    RUNUP_MATRIX_ANSWER_MAX_LEN = 4,
    RUNUP_MATRIX_QUIZ_MAX_LEN = 8 ,
    
};

typedef struct packet_runup_matrix_quiz
{
    BYTE    bHeader;
    char    szQuiz[RUNUP_MATRIX_QUIZ_MAX_LEN + 1];
} TPacketGCRunupMatrixQuiz;

typedef struct command_runup_matrix_answer
{
    BYTE    bHeader;
    char    szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN + 1];
} TPacketCGRunupMatrixAnswer;

typedef struct packet_passpod
{
    BYTE    bHeader;
    char    szAnswer[8+1];
} TPacketCGPasspod;

typedef struct packet_passpod_failed
{
    BYTE    bHeader;
    char    szMessage[128];
} TPacketCGPasspodFailed;

typedef struct tag_GGSiege
{
    BYTE    bHeader;
    BYTE    bEmpire;
    BYTE    bTowerCount;
} TPacketGGSiege;

typedef struct SPacketGGMonarchTransfer
{
    BYTE    bHeader;
    DWORD    dwTargetPID;
    long    x;
    long    y;
} TPacketMonarchGGTransfer;

typedef struct SPacketGGPCBangUpdate
{
    BYTE bHeader;
    unsigned long ulPCBangID;
} TPacketPCBangUpdate;

typedef struct SPacketGGCheckAwakeness
{
    BYTE bHeader;
} TPacketGGCheckAwakeness;

typedef struct SPacketGCPanamaPack
{
    BYTE    bHeader;
    char    szPackName[256];
    BYTE    abIV[32];
} TPacketGCPanamaPack;

//TODO :  아우 짱나..가변패킷 사이즈 받아들일수 있게 패킷 핸들러 Refactoring 하자.
typedef struct SPacketGCHybridCryptKeys
{
    SPacketGCHybridCryptKeys() : m_pStream(NULL) {}
    ~SPacketGCHybridCryptKeys()
    {
        //GCC 에선 NULL delete 해도 괜찮나? 일단 안전하게 NULL 체크 하자. ( 근데 이거 C++ 표준아니었나 --a )
        if( m_pStream )
        {
            delete[] m_pStream;
            m_pStream = NULL;
        }
    }
    
    DWORD GetStreamSize()
    {
        return sizeof(bHeader) + sizeof(WORD) + sizeof(int) + KeyStreamLen;
    }

    BYTE* GetStreamData()
    {
        if( m_pStream )
            delete[] m_pStream;

        uDynamicPacketSize = (WORD)GetStreamSize();
        
        m_pStream = new BYTE[ uDynamicPacketSize ];

        memcpy( m_pStream, &bHeader, 1 );
        memcpy( m_pStream+1, &uDynamicPacketSize, 2 );
        memcpy( m_pStream+3, &KeyStreamLen, 4 );

        if( KeyStreamLen > 0 )
            memcpy( m_pStream+7, pDataKeyStream, KeyStreamLen );

        return m_pStream;
    }

    BYTE    bHeader;
    WORD    uDynamicPacketSize; // 빌어먹을 클라  DynamicPacketHeader 구조때문에 맞춰줘야한다 -_-;
    int        KeyStreamLen;
    BYTE*   pDataKeyStream;

private:
    BYTE* m_pStream;

} TPacketGCHybridCryptKeys;

typedef struct SPacketGCPackageSDB
{
    SPacketGCPackageSDB() : m_pDataSDBStream(NULL), m_pStream(NULL) {}
    ~SPacketGCPackageSDB()
    {
        if( m_pStream )
        {
            delete[] m_pStream;
            m_pStream = NULL;
        }
    }
    
    DWORD GetStreamSize()
    {
        return sizeof(bHeader) + sizeof(WORD) + sizeof(int) + iStreamLen;
    }

    BYTE* GetStreamData()
    {
        if( m_pStream )
            delete[] m_pStream;

        uDynamicPacketSize =  GetStreamSize();

        m_pStream = new BYTE[ uDynamicPacketSize ];

        memcpy( m_pStream, &bHeader, 1 );
        memcpy( m_pStream+1, &uDynamicPacketSize, 2 );
        memcpy( m_pStream+3, &iStreamLen, 4 );

        if( iStreamLen > 0 )
            memcpy( m_pStream+7, m_pDataSDBStream, iStreamLen );

        return m_pStream;
    }

    BYTE    bHeader;
    WORD    uDynamicPacketSize; // 빌어먹을 클라  DynamicPacketHeader 구조때문에 맞춰줘야한다 -_-;
    int        iStreamLen;
    BYTE*   m_pDataSDBStream;

private:
    BYTE* m_pStream;

} TPacketGCPackageSDB;

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

#define MAX_EFFECT_FILE_NAME 128
typedef struct SPacketGCSpecificEffect
{
    BYTE header;
    DWORD vid;
    char effect_file[MAX_EFFECT_FILE_NAME];
} TPacketGCSpecificEffect;

// 용혼석
enum EDragonSoulRefineWindowRefineType
{
    DragonSoulRefineWindow_UPGRADE,
    DragonSoulRefineWindow_IMPROVEMENT,
    DragonSoulRefineWindow_REFINE,
};

enum EPacketCGDragonSoulSubHeaderType
{
    DS_SUB_HEADER_OPEN,
    DS_SUB_HEADER_CLOSE,
    DS_SUB_HEADER_DO_REFINE_GRADE,
    DS_SUB_HEADER_DO_REFINE_STEP,
    DS_SUB_HEADER_DO_REFINE_STRENGTH,
    DS_SUB_HEADER_REFINE_FAIL,
    DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE,
    DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL,
    DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY,
    DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL,
    DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL,
    DS_SUB_HEADER_REFINE_SUCCEED,
};
typedef struct SPacketCGDragonSoulRefine
{
    SPacketCGDragonSoulRefine() : header (HEADER_CG_DRAGON_SOUL_REFINE)
    {}
    BYTE header;
    BYTE bSubType;
    TItemPos ItemGrid[DRAGON_SOUL_REFINE_GRID_SIZE];
} TPacketCGDragonSoulRefine;

typedef struct SPacketGCDragonSoulRefine
{
    SPacketGCDragonSoulRefine() : header(HEADER_GC_DRAGON_SOUL_REFINE)
    {}
    BYTE header;
    BYTE bSubType;
    TItemPos Pos;
} TPacketGCDragonSoulRefine;

typedef struct SPacketCGStateCheck
{
    BYTE header;
    unsigned long key;    
    unsigned long index;
} TPacketCGStateCheck;

typedef struct SPacketGCStateCheck
{
    BYTE header;
    unsigned long key;
    unsigned long index;
    unsigned char state;
} TPacketGCStateCheck;

#pragma pack()
#endif

 

packet.h(clientside)

Spoiler

#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_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_PARTS                = 37,

    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_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 = 4,
    PLAYER_PER_ACCOUNT4 = 5,

    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_WING,
    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,
    POINT_MAGIC_ATT_GRADE = 22,
    POINT_MAGIC_DEF_GRADE = 23,
    POINT_EMPIRE_POINT = 24,
    POINT_LEVEL_STEP = 25,
    POINT_STAT = 26,
    POINT_SUB_SKILL = 27,
    POINT_SKILL = 28,
//    POINT_SKILL_PASV,
//    POINT_SKILL_ACTIVE,
    POINT_MIN_ATK = 29,
    POINT_MAX_ATK = 30,
    POINT_PLAYTIME = 31,
    POINT_HP_REGEN = 32,
    POINT_SP_REGEN = 33,
    POINT_BOW_DISTANCE = 34,
    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,
    POINT_ATTBONUS_UNUSED1 = 54,
    POINT_ATTBONUS_UNUSED2 = 55,
    POINT_ATTBONUS_UNUSED3 = 56,
    POINT_ATTBONUS_UNUSED4 = 57,
    POINT_ATTBONUS_UNUSED5 = 58,
    POINT_ATTBONUS_UNUSED6 = 59,
    POINT_ATTBONUS_UNUSED7 = 60,
    POINT_ATTBONUS_UNUSED8 = 61,
    POINT_ATTBONUS_UNUSED9 = 62,
    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_CLAW = 75,
    POINT_RESIST_FIRE = 76,
    POINT_RESIST_ELEC,
    POINT_RESIST_MAGIC,
    POINT_RESIST_WIND,
    POINT_REFLECT_MELEE,
    POINT_REFLECT_CURSE,
    POINT_POISON_REDUCE,
    POINT_KILL_SP_RECOVER,
    POINT_EXP_DOUBLE_BONUS,
    POINT_GOLD_DOUBLE_BONUS,
    POINT_ITEM_DROP_BONUS,
    POINT_POTION_BONUS,
    POINT_KILL_HP_RECOVER,
    POINT_IMMUNE_STUN,
    POINT_IMMUNE_SLOW,
    POINT_IMMUNE_FALL,
    POINT_PARTY_ATT_GRADE,
    POINT_PARTY_DEF_GRADE,
    POINT_ATT_BONUS = 93,
    POINT_DEF_BONUS = 94,
    POINT_ATT_GRADE_BONUS,
    POINT_DEF_GRADE_BONUS,
    POINT_MAGIC_ATT_GRADE_BONUS,
    POINT_MAGIC_DEF_GRADE_BONUS,
    POINT_RESIST_NORMAL_DAMAGE,
    POINT_STAT_RESET_COUNT = 112,
    POINT_HORSE_SKILL = 113,
    POINT_MALL_ATTBONUS,
    POINT_MALL_DEFBONUS,
    POINT_MALL_EXPBONUS,
    POINT_MALL_ITEMBONUS,
    POINT_MALL_GOLDBONUS,
    POINT_MAX_HP_PCT,
    POINT_MAX_SP_PCT,
    POINT_SKILL_DAMAGE_BONUS,
    POINT_NORMAL_HIT_DAMAGE_BONUS,
    POINT_SKILL_DEFEND_BONUS,
    POINT_NORMAL_HIT_DEFEND_BONUS,
    POINT_PC_BANG_EXP_BONUS,
    POINT_PC_BANG_DROP_BONUS,
    POINT_ENERGY = 128,
    POINT_ENERGY_END_TIME = 129,
    POINT_MIN_WEP = 200,
    POINT_MAX_WEP,
    POINT_MIN_MAGIC_WEP,
    POINT_MAX_MAGIC_WEP,
    POINT_HIT_RATE,
    POINT_BLEEDING_PCT = 138,
    POINT_BLEEDING_REDUCE = 139,
};

typedef struct packet_points
{
    BYTE        header;
    long long        points[POINT_MAX_NUM];
} TPacketGCPoints;

typedef struct packet_point_change
{
    int         header;

    DWORD        dwVID;
    BYTE        Type;

    long long       amount; // 바뀐 값
    long 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) 착용할 때 이펙트 (발동이펙트임, 지속이펙트 아님)
    SE_EQUIP_ACCE_1,
    SE_EQUIP_ACCE_2,
    SE_EQUIP_ACCE_3,
    SE_EQUIP_ACCE_4,
};

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

 

 

[Unknown 12]

Same problem here https://metin2dev.org/board/index.php?/topic/9706-unknown-packet-header/