#pragma once

#include <mmo/ArType.h>
#include <mmo/ArTime.h>

#include "ItemBase.h"
#include "ItemInstance.h"
#include "CreatureBase.h"
#include "QuestBase.h"
#include "QuestInstance.h"
#include "BattleArenaBase.h"
#include "MessageType.h"

#include "FieldPropManager.h"

#include <hack_shield/AntiCpXSvr.h>
#include <xtrap/Xtrap_S_Interface.h>

#include "GameRule.h"
#include "GameType.h"

#define _INIT(_id)  { memset( this, 0, sizeof(*this) ); id = _id; size = sizeof( *this ); }

#pragma pack( 1 )



const	unsigned short TM_COMMON				= 9998;
const	unsigned short TM_NONE					= 9999;
const	unsigned short TM_CS_VERSION_OLD		= 50;
const	unsigned short TM_CS_VERSION			= 51;
const	unsigned short TM_SC_INFO				= 52;

const	unsigned short TM_SC_ANTI_HACK					= 53;
const	unsigned short TM_CS_ANTI_HACK					= 54;
const	unsigned short TM_SC_GAME_GUARD_AUTH_QUERY		= 55;
const	unsigned short TM_CS_GAME_GUARD_AUTH_ANSWER		= 56;
const	unsigned short TM_CS_CHECK_ILLEGAL_USER			= 57;
const	unsigned short TM_SC_XTRAP_CHECK				= 58;
const	unsigned short TM_CS_XTRAP_CHECK				= 59;

const	unsigned short TM_CS_REQUEST			= 60;

const	unsigned short TM_SC_RESULT				= 0;

const	unsigned short TM_CS_LOGIN = 1;	//1  - 61
const	unsigned short TM_SC_LOGIN_RESULT = 4;	//4  - 64

const	unsigned short TM_TIMESYNC = 2;
const	unsigned short TM_SC_ENTER = 3;
const	unsigned short TM_CS_QUERY = 13;

const	unsigned short TM_CS_MOVE_REQUEST = 5;	//5  - 65
const	unsigned short TM_SC_MOVE_ACK = 6;	//6  - 66
const	unsigned short TM_CS_REGION_UPDATE = 7;	//7  - 67
const	unsigned short TM_SC_REGION_ACK = 11;

const	unsigned short TM_CS_ENTER_EVENT_AREA	= 15;
const	unsigned short TM_CS_LEAVE_EVENT_AREA	= 16;

const	unsigned short TM_SC_MOVE				= 8;
const	unsigned short TM_SC_FORCE_MOVE			= 14;
const	unsigned short TM_SC_LEAVE				= 9;
const	unsigned short TM_SC_WARP				= 12;

const	unsigned short TM_SC_SET_TIME			= 10;

const	unsigned short TM_CS_CHAT_REQUEST		= 20;
const	unsigned short TM_SC_CHAT_LOCAL			= 21;
const	unsigned short TM_SC_CHAT				= 22;
const	unsigned short TM_SC_CHAT_RESULT		= 24;

const	unsigned short TM_CS_RETURN_LOBBY		= 23;
const	unsigned short TM_CS_REQUEST_RETURN_LOBBY= 25;
const	unsigned short TM_CS_REQUEST_LOGOUT		= 26;
const	unsigned short TM_CS_LOGOUT				= 27;
const	unsigned short TM_SC_DISCONNECT_DESC	= 28;

const	unsigned short TM_SC_CHANGE_NAME		= 30;
const	unsigned short TM_CS_CHANGE_ALIAS		= 31;

const	unsigned short TM_CS_ATTACK_REQUEST		= 100;
const	unsigned short TM_SC_ATTACK_EVENT		= 101;
const	unsigned short TM_SC_CANT_ATTACK		= 102;
const	unsigned short TM_SC_KNOCK_BACK			= 104;

const	unsigned short TM_CS_CANCEL_ACTION		= 150;

const	unsigned short TM_CS_PUTON_ITEM			= 200;		// 아이템 장비 요청
const	unsigned short TM_CS_PUTOFF_ITEM		= 201;		// 아이템 장비해제 요청
const	unsigned short TM_SC_WEAR_INFO			= 202;		// 아이템 장비 정보 - 첫 enter 시, 혹은 장비 변경시 방송됨
const	unsigned short TM_CS_DROP_ITEM			= 203;		// 아이템 버림 요청
const	unsigned short TM_CS_TAKE_ITEM			= 204;		// Item pickup request
const	unsigned short TM_SC_DROP_RESULT		= 205;		// 아이템 버림 결과
const	unsigned short TM_SC_INVENTORY			= 207;		// 인벤 내용
const	unsigned short TM_CS_ERASE_ITEM			= 208;		// 아이템 파기
const	unsigned short TM_SC_ERASE_ITEM			= 209;		// 아이템 파기 결과
const	unsigned short TM_SC_TAKE_ITEM_RESULT	= 210;
const	unsigned short TM_SC_OPEN_STORAGE		= 211;		// 창고를 여셈~
const	unsigned short TM_CS_STORAGE			= 212;		// 창고 아이템 이동

const	unsigned short TM_SC_GET_CHAOS			= 213;		// 혼돈 얻음
const	unsigned short TM_CS_PUTON_CARD			= 214;		// 벨트 슬롯에 아이템 장착
const	unsigned short TM_CS_PUTOFF_CARD		= 215;		// 벨트 슬롯에 아이템 장착
const	unsigned short TM_SC_BELT_SLOT_INFO		= 216;		// 벨트 슬롯 정보

const	unsigned short TM_SC_ITEM_COOL_TIME		= 217;		// 아이템 쿨타임
const	unsigned short TM_CS_CHANGE_ITEM_POSITION	= 218;	// 아이템 위치 변경(정렬)

const	unsigned short TM_CS_ARRANGE_ITEM		= 219;		// 인벤토리/창고 아이템 정렬

const	unsigned short TM_SC_HAIR_INFO			= 220;		// 헤어 정보 방송 - 첫 enter 시, 혹은 염색/헤어 스타일 변경 시 방송됨
const	unsigned short TM_CS_HIDE_EQUIP_INFO	= 221;		// 장비 숨기기 정보 변경 요청
const	unsigned short TM_SC_HIDE_EQUIP_INFO	= 222;		// 장비 숨기기 정보 방송 - TM_CS_HIDE_EQUIP_INFO 처리 시 방송됨

const	unsigned short TM_CS_SWAP_EQUIP			= 223;		// 장비 스왑
const	unsigned short TM_SC_SKIN_INFO			= 224;		// 피부 색상 변경

const	unsigned short TM_SC_NPC_TRADE_INFO		= 240;		// 아이템 상점(NPC) 판매/구매 결과

const	unsigned short TM_SC_MARKET				= 250;		// 상점 아이템 리스트
const	unsigned short TM_CS_BUY_ITEM			= 251;		// 아이템 구입
const	unsigned short TM_CS_SELL_ITEM			= 252;		// 아이템 판매
const	unsigned short TM_CS_USE_ITEM			= 253;		// 아이템 사용
const	unsigned short TM_SC_DESTROY_ITEM		= 254;		// 아이템 제거
const	unsigned short TM_SC_UPDATE_ITEM_COUNT	= 255;		// 아이템 제거
const	unsigned short TM_CS_MIX				= 256;		// 아이템 조합
const	unsigned short TM_SC_MIX_RESULT			= 257;		// 아이템 조합 결과
const	unsigned short TM_CS_DONATE_ITEM		= 258;		// 아이템 기부
const	unsigned short TM_CS_DONATE_REWARD		= 259;		// 아이템 기부 보상 받기 요청

const	unsigned short TM_SC_SHOW_SOULSTONE_CRAFT_WINDOW	= 259;		// 아이템 소켓 UI 표시 요청
const	unsigned short TM_CS_SOULSTONE_CRAFT				= 260;		// 소켓 UI에 의한 소울스톤 세공
const	unsigned short TM_SC_SHOW_SOULSTONE_REPAIR_WINDOW	= 261;		// 아이템 소울스톤 내구도 수리 UI 표시 요청
const	unsigned short TM_CS_REPAIR_SOULSTONE				= 262;		// 소켓 아이템 내구도 수리
const	unsigned short TM_CS_TRANSMIT_ETHEREAL_DURABILITY	= 263;		// 아이템 내구도 충전
const	unsigned short TM_CS_TRANSMIT_ETHEREAL_DURABILITY_TO_EQUIPMENT	= 264;	// 장비 전체 수리

const	unsigned short TM_CS_DECOMPOSE			= 265;		// 아이템 분해
const	unsigned short TM_SC_DECOMPOSE_RESULT	= 266;		// 아이템 분해 결과

const	unsigned short TM_TRADE					= 280;		// 트레이드
const	unsigned short TM_CS_PUTON_ITEM_SET		= 281;		// 풀셋 아이템 장착 요청
const	unsigned short TM_SC_ITEM_DROP_INFO		= 282;		// 어떤 몹이 어떤 아템 떨어트리는건지 정보
const	unsigned short TM_SC_USE_ITEM_RESULT	= 283;		// 아이템 사용 결과
const	unsigned short TM_CS_BIND_SKILLCARD		= 284;
const	unsigned short TM_CS_UNBIND_SKILLCARD	= 285;
const	unsigned short TM_SC_SKILLCARD_INFO		= 286;
const	unsigned short TM_SC_ITEM_WEAR_INFO		= 287;		// 아이템 장비 정보  - 첫 enter 시, 혹은 장비 변경시 방송됨

//const	unsigned short TM_SC_ADD_SUMMON			= 300;		// 소환수 생성됨 통지

const	unsigned short TM_SC_ADD_SUMMON_INFO	= 301;		// 편성된 소환수 정보 추가
const	unsigned short TM_SC_REMOVE_SUMMON_INFO	= 302;		// 편성된 소환수 정보 제거
const	unsigned short TM_EQUIP_SUMMON			= 303;		// 소환수 편성 정보
const	unsigned short TM_CS_SUMMON				= 304;		// 소환/역소환 요청
const	unsigned short TM_SC_UNSUMMON			= 305;		// 역소환 통지
const	unsigned short TM_SC_UNSUMMON_NOTICE	= 306;		// 역소환 알림( x시간 후에 역소환 됨 )
const	unsigned short TM_SC_SUMMON_EVOLUTION	= 307;
const	unsigned short TM_SC_TAMING_INFO		= 310;		// 테이밍 정보
const	unsigned short TM_SC_MOUNT_SUMMON		= 320;
const	unsigned short TM_SC_UNMOUNT_SUMMON		= 321;
const	unsigned short TM_SC_SHOW_SUMMON_NAME_CHANGE	= 322;	// 소환수 이름 변경 UI 출력 요청
const	unsigned short TM_CS_CHANGE_SUMMON_NAME	= 323;		// 변경될 소환수 이름(대상은 StructPlayer가 들고 있음)
const	unsigned short TM_CS_GET_SUMMON_SETUP_INFO		= 324;	// 소환수 편성 정보를 포함하는 메시지 요청(편성 창 띄우기로 사용)

const	unsigned short TM_SC_UNSUMMON_PET		= 350;		// 펫 역소환 통지
const	unsigned short TM_SC_ADD_PET_INFO		= 351;		// 보유 중인 펫 정보 추가
const	unsigned short TM_SC_REMOVE_PET_INFO	= 352;		// 보유 중인 펫 정보 제거
const	unsigned short TM_SC_SHOW_SET_PET_NAME	= 353;		// 펫 이름 설정 창 표시
const	unsigned short TM_CS_SET_PET_NAME		= 354;		// 펫 이름 설정

const	unsigned short TM_CS_SKILL				= 400;
const	unsigned short TM_SC_SKILL				= 401;
const	unsigned short TM_CS_LEARN_SKILL		= 402;
const	unsigned short TM_SC_SKILL_LIST			= 403;
const	unsigned short TM_SC_ADDED_SKILL_LIST	= 404;
const	unsigned short TM_CS_JOB_LEVEL_UP		= 410;
const	unsigned short TM_SC_SKILL_EFFECT		= 404;
//const	unsigned short TM_SC_SKILL_CASTING_TIME	= 405;
const	unsigned short TM_SC_STATE_RESULT		= 406;
const	unsigned short TM_SC_AURA				= 407;
const	unsigned short TM_CS_REQUEST_REMOVE_STATE		= 408;

//const	unsigned short TM_CS_SKILL_LEVEL_LIST			= 450;
const	unsigned short TM_SC_SKILL_LEVEL_LIST			= 451;
const	unsigned short TM_CS_SUMMON_CARD_SKILL_LIST		= 452;

const	unsigned short TM_SC_STATUS_CHANGE		= 500;
//const	unsigned short TM_SC_HP					= 501;
//const	unsigned short TM_SC_MP					= 502;
const	unsigned short TM_CS_UPDATE				= 503;		// HP/MP 채우는거나 기타등등. 30초가량마다 한번씩 다오~
const	unsigned short TM_SC_DEAD				= 504;		// 사망~
const	unsigned short TM_SC_STATE				= 505;		// 상태이상 메시지
const	unsigned short TM_SC_PROPERTY			= 507;		// 프로퍼티
const	unsigned short TM_CS_SET_PROPERTY		= 508;		// 프로퍼티
const	unsigned short TM_SC_HPMP				= 509;
const	unsigned short TM_SC_REGEN_INFO			= 510;
const	unsigned short TM_CS_TARGETING			= 511;
const	unsigned short TM_SC_TARGET				= 512;
const	unsigned short TM_CS_RESURRECTION		= 513;		// 
const	unsigned short TM_SC_SP					= 514;
const	unsigned short TM_SC_ENERGY				= 515;
const	unsigned short TM_SC_REGEN_HPMP			= 516;
const	unsigned short TM_CS_MONSTER_RECOGNIZE	= 517;		// 선공 몬스터의 시야 범위 내에 캐릭터가 들어갔을 때 클라에서 서버로 알려주는 패킷(서버에서는 주기적인 선공 체크밖에 못하므로 실시간 체크는 클라에 의존)

const	unsigned short TM_CS_GET_REGION_INFO	= 550;

const	unsigned short TM_SC_QUEST_LIST				= 600;
const	unsigned short TM_SC_QUEST_STATUS			= 601;
const	unsigned short TM_SC_QUEST_INFOMATION		= 602;
const	unsigned short TM_CS_DROP_QUEST				= 603;
const	unsigned short TM_CS_QUEST_INFO				= 604;
const	unsigned short TM_CS_END_QUEST				= 605;

const	unsigned short TM_SC_TITLE_LIST				= 625;
const	unsigned short TM_SC_TITLE_CONDITION_LIST	= 626;
const	unsigned short TM_SC_REMAIN_TITLE_TIME		= 627;
const	unsigned short TM_CS_SET_MAIN_TITLE			= 628;
const	unsigned short TM_SC_SET_MAIN_TITLE			= 629;
const	unsigned short TM_CS_SET_SUB_TITLE			= 630;
const	unsigned short TM_SC_SET_SUB_TITLE			= 631;
const	unsigned short TM_CS_BOOKMARK_TITLE			= 632;
const	unsigned short TM_SC_BOOKMARK_TITLE			= 633;
const	unsigned short TM_SC_ACHIEVE_TITLE			= 634;
const	unsigned short TM_SC_OPEN_TITLE				= 635;
const	unsigned short TM_SC_CHANGE_TITLE_CONDITION	= 636;

const	unsigned short TM_SC_SHOW_CREATE_GUILD		= 650;
const	unsigned short TM_SC_OPEN_GUILD_WINDOW		= 651;
const	unsigned short TM_SC_UPDATE_GUILD_ICON		= 652;
const	unsigned short TM_SC_UPDATE_GUILD_BANNER	= 653;

const	unsigned short TM_SC_SHOW_CREATE_ALLIANCE	= 660;

const	unsigned short TM_CS_START_BOOTH		= 700;		// 개설
const	unsigned short TM_CS_STOP_BOOTH			= 701;		// 중지
const	unsigned short TM_CS_WATCH_BOOTH		= 702;		// 내용 보기
const	unsigned short TM_SC_WATCH_BOOTH		= 703;		// 내용 보내주기
const	unsigned short TM_CS_STOP_WATCH_BOOTH	= 704;		// 그만 보기
const	unsigned short TM_CS_BUY_FROM_BOOTH		= 705;		// 물건 구입
const	unsigned short TM_CS_SELL_TO_BOOTH		= 706;		// 물건 판매
const	unsigned short TM_CS_GET_BOOTHS_NAME	= 707;		// 노점 이름 얻어오기
const	unsigned short TM_SC_GET_BOOTHS_NAME	= 708;		// 노점 이름들
const	unsigned short TM_SC_BOOTH_CLOSED		= 709;		// 노점 닫힘 알림
const	unsigned short TM_SC_BOOTH_TRADE_INFO	= 710;		// 노점상에게 물건 거래 알림.
const	unsigned short TM_CS_CHECK_BOOTH_STARTABLE = 711;	// 노점 개설 가능 여부 확인(클라 UI 출력 전 확인)

const	unsigned short TM_CS_TURN_ON_PK_MODE	= 800;
const	unsigned short TM_CS_TURN_OFF_PK_MODE	= 801;

const	unsigned short TM_CS_CHANGE_LOCATION	= 900;
const	unsigned short TM_SC_CHANGE_LOCATION	= 901;
const	unsigned short TM_SC_WEATHER_INFO		= 902;
const	unsigned short TM_CS_GET_WEATHER_INFO	= 903;


const	unsigned short TM_SC_STAT_INFO			= 1000;		// 스탯정보
const	unsigned short TM_SC_GOLD_UPDATE		= 1001;		// 돈 바뀜
const	unsigned short TM_SC_LEVEL_UPDATE		= 1002;		// 레벨 바뀜
const	unsigned short TM_SC_EXP_UPDATE			= 1003;		// 경험치 바뀜
const	unsigned short TM_SC_BONUS_EXP_JP		= 1004;		// 보너스 경험치/잡포 획득 방송
const	unsigned short TM_SC_DETECT_RANGE_UPDATE= 1005;		// 은신 감지 범위 변경

const	unsigned short TM_CS_GAME_TIME			= 1100;
const	unsigned short TM_SC_GAME_TIME			= 1101;

const	unsigned short TM_SC_EMOTION			= 1201;
const	unsigned short TM_CS_EMOTION			= 1202;

const	unsigned short TM_CS_AUCTION_SEARCH				= 1300;		// 경매 물품 검색 요청
const	unsigned short TM_SC_AUCTION_SEARCH				= 1301;		// 경매 물품 검색 결과
const	unsigned short TM_CS_AUCTION_SELLING_LIST		= 1302;		// 자신이 등록한 경매 물품 목록 요청
const	unsigned short TM_SC_AUCTION_SELLING_LIST		= 1303;		// 자신이 등록한 경매 물품 목록 결과
const	unsigned short TM_CS_AUCTION_BIDDED_LIST		= 1304;		// 자신이 입찰한 경매 목록 요청
const	unsigned short TM_SC_AUCTION_BIDDED_LIST		= 1305;		// 자신이 입찰한 경매 목록 결과
const	unsigned short TM_CS_AUCTION_BID				= 1306;		// 경매 입찰 요청(결과는 TS_SC_RESULT로 보내고 성공시 최고 입찰가는 TS_SC_RESULT 메시지의 value로 전달함)
const	unsigned short TM_CS_AUCTION_INSTANT_PURCHASE	= 1308;		// 경매 물품 즉시구매 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
const	unsigned short TM_CS_AUCTION_REGISTER			= 1309;		// 경매 물품 등록 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
const	unsigned short TM_CS_AUCTION_CANCEL				= 1310;		// 자신이 등록한 경매 취소 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)

const	unsigned short TM_CS_ITEM_KEEPING_LIST		= 1350;		// 자신 소유 보관 아이템 목록 요청
const	unsigned short TM_SC_ITEM_KEEPING_LIST		= 1351;		// 자신 소유 보관 아이템 목록 결과
const	unsigned short TM_CS_ITEM_KEEPING_TAKE		= 1352;		// 자신 소유 보관 아이템 회수 요청(결과는 TS_SC_RESULT로 보냄)

//const	unsigned short TM_CS_ACCOUNT			= 2000;
const	unsigned short TM_CS_CHARACTER_LIST		= 2001;
const	unsigned short TM_CS_CREATE_CHARACTER	= 2002;
const	unsigned short TM_CS_DELETE_CHARACTER	= 2003;
const	unsigned short TM_SC_CHARACTER_LIST		= 2004;
const	unsigned short TM_CS_ACCOUNT_WITH_AUTH	= 2005;
const	unsigned short TM_CS_CHECK_CHARACTER_NAME	= 2006;

const	unsigned short TM_SC_DIALOG					= 3000;
const	unsigned short TM_CS_DIALOG					= 3001;
const	unsigned short TM_CS_CONTACT				= 3002;
const	unsigned short TM_SC_SHOW_WINDOW			= 3003;
const	unsigned short TM_SC_GENERAL_MESSAGE_BOX	= 3004;

// 헌터홀릭 관련
//{
const	unsigned short TM_CS_HUNTAHOLIC_INSTANCE_LIST		= 4000;
const	unsigned short TM_SC_HUNTAHOLIC_INSTANCE_LIST		= 4001;
const	unsigned short TM_SC_HUNTAHOLIC_INSTANCE_INFO		= 4002;
const	unsigned short TM_CS_HUNTAHOLIC_CREATE_INSTANCE		= 4003;
const	unsigned short TM_CS_HUNTAHOLIC_JOIN_INSTANCE		= 4004;
const	unsigned short TM_CS_HUNTAHOLIC_LEAVE_INSTANCE		= 4005;
const	unsigned short TM_SC_HUNTAHOLIC_HUNTING_SCORE		= 4006;
const	unsigned short TM_SC_HUNTAHOLIC_UPDATE_SCORE		= 4007;
const	unsigned short TM_CS_HUNTAHOLIC_LEAVE_LOBBY			= 4008;
const	unsigned short TM_SC_HUNTAHOLIC_BEGIN_HUNTING		= 4009;
const	unsigned short TM_SC_HUNTAHOLIC_MAX_POINT_ACHIEVED	= 4010;
const	unsigned short TM_CS_HUNTAHOLIC_BEGIN_HUNTING		= 4011;
const	unsigned short TM_SC_HUNTAHOLIC_BEGIN_COUNTDOWN		= 4012;
//}

// 인스턴스 게임 관련
const	unsigned short TM_CS_INSTANCE_GAME_ENTER				= 4250;
const	unsigned short TM_CS_INSTANCE_GAME_EXIT					= 4251;
const	unsigned short TM_CS_INSTANCE_GAME_SCORE_REQUEST		= 4252;
const	unsigned short TM_SC_INSTANCE_GAME_SCORE_REQUEST		= 4253;

// Compete(필드 대련) 관련
const	unsigned short TM_CS_COMPETE_REQUEST			= 4500;
const	unsigned short TM_SC_COMPETE_REQUEST			= 4501;
const	unsigned short TM_CS_COMPETE_ANSWER				= 4502;
const	unsigned short TM_SC_COMPETE_ANSWER				= 4503;
const	unsigned short TM_SC_COMPETE_COUNTDOWN			= 4504;
const	unsigned short TM_SC_COMPETE_START				= 4505;
const	unsigned short TM_SC_COMPETE_END				= 4506;

// 배틀 아레나 관련
const	unsigned short TM_SC_BATTLE_ARENA_PENALTY_INFO				= 4700;
const	unsigned short TM_CS_BATTLE_ARENA_JOIN_QUEUE				= 4701;
const	unsigned short TM_SC_BATTLE_ARENA_JOIN_QUEUE				= 4702;
const	unsigned short TM_SC_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT	= 4703;
const	unsigned short TM_CS_BATTLE_ARENA_LEAVE						= 4704;
const	unsigned short TM_SC_BATTLE_ARENA_LEAVE						= 4705;
const	unsigned short TM_SC_BATTLE_ARENA_BATTLE_INFO				= 4706;
const	unsigned short TM_CS_BATTLE_ARENA_ENTER_WHILE_COUNTDOWN		= 4707;
const	unsigned short TM_CS_BATTLE_ARENA_EXERCISE_READY			= 4708;
const	unsigned short TM_SC_BATTLE_ARENA_EXERCISE_READY_STATUS		= 4709;
const	unsigned short TM_CS_BATTLE_ARENA_EXERCISE_START			= 4710;
const	unsigned short TM_SC_BATTLE_ARENA_BATTLE_STATUS				= 4711;
const	unsigned short TM_SC_BATTLE_ARENA_BATTLE_SCORE				= 4712;
const	unsigned short TM_SC_BATTLE_ARENA_JOIN_BATTLE				= 4713;
const	unsigned short TM_SC_BATTLE_ARENA_DISCONNECT_BATTLE			= 4714;
const	unsigned short TM_SC_BATTLE_ARENA_RECONNECT_BATTLE			= 4715;
const	unsigned short TM_SC_BATTLE_ARENA_RESULT					= 4716;
const	unsigned short TM_CS_BATTLE_ARENA_ABSENCE_CHECK_REQUEST		= 4717;
const	unsigned short TM_SC_BATTLE_ARENA_ABSENCE_CHECK				= 4718;
const	unsigned short TM_CS_BATTLE_ARENA_ABSENCE_CHECK_ANSWER		= 4719;

// 랭킹 시스템 관련
const	unsigned short TM_CS_RANKING_TOP_RECORD			= 5000;
const	unsigned short TM_SC_RANKING_TOP_RECORD			= 5001;

// 크리처 농장 관련
const	unsigned short TM_CS_REQUEST_FARM_INFO	= 6000;
const	unsigned short TM_SC_FARM_INFO			= 6001;
const	unsigned short TM_CS_FOSTER_CREATURE	= 6002;
const	unsigned short TM_SC_RESULT_FOSTER		= 6003;
const	unsigned short TM_CS_RETRIEVE_CREATURE	= 6004;
const	unsigned short TM_SC_RESULT_RETRIEVE	= 6005;
const	unsigned short TM_CS_NURSE_CREATURE		= 6006;
const	unsigned short TM_SC_RESULT_NURSE		= 6007;
const	unsigned short TM_CS_REQUEST_FARM_MARKET	= 6008;


// 파티매칭
const	unsigned short TM_CS_PARTYMATCH_ACTION	= 7000;
const	unsigned short TM_SC_PARTYMATCH_LIST	= 7001;
const	unsigned short TM_SC_PARTYMATCH_MEMBER	= 7002;


const	unsigned short TM_CS_REPORT				= 8000;
const	unsigned short TM_SC_OPEN_URL			= 9000;
const	unsigned short TM_SC_URL_LIST			= 9001;

//	2009. 8. 11 floyd 보안비밀번호 2차 수정
//const	unsigned short TM_SC_CREATE_SECUTIRY_NO				= 9002;
const	unsigned short TM_SC_REQUEST_SECUTIRY_NO			= 9004;
const	unsigned short TM_CS_SECURITY_NO					= 9005;
//const	unsigned short TM_CS_CREATE_SECURITY_NO				= 9006;
//const	unsigned short TM_CS_CHANGE_SECURITY_NO				= 9007;
//const	unsigned short TM_CS_REQUEST_SECURITY_NO_CHANGE		= 9008;
//const	unsigned short TM_SC_CHANGE_SECURITY_NO				= 9009;
//const	unsigned short TM_CS_REQUEST_CLEAR_SECURITY_NO		= 9010;
//const	unsigned short TM_SC_CLEAR_SECURITY_NO				= 9011;
//const	unsigned short TM_CS_CLEAR_SECURITY_NO				= 9012;

// { 유료화 관련
const	unsigned short TM_CS_OPEN_ITEM_SHOP					= 10000;
const	unsigned short TM_SC_OPEN_ITEM_SHOP					= 10001;
const	unsigned short TM_SC_COMMERCIAL_STORAGE_INFO		= 10003;	// 캐쉬템 창고에 아이템이 뭔가 들어왔을경우 전송됨
const	unsigned short TM_SC_COMMERCIAL_STORAGE_LIST		= 10004;
const	unsigned short TM_CS_TAKEOUT_COMMERCIAL_ITEM		= 10005;
// }

// { Auth Server <-> Game Server
const	unsigned short TM_GA_LOGIN				= 20001;
const	unsigned short TM_AG_LOGIN_RESULT		= 20002;

const	unsigned short TM_GA_CLIENT_LOGIN		= 20010;
const	unsigned short TM_AG_CLIENT_LOGIN		= 20011;
const	unsigned short TM_GA_CLIENT_LOGOUT		= 20012;
const	unsigned short TM_AG_KICK_CLIENT		= 20013;
const	unsigned short TM_GA_CLIENT_KICK_FAILED	= 20014;

const	unsigned short TM_AG_PCBANG_EXPIRE_WARNING = 20020;
const	unsigned short TM_AG_PCBANG_EXPIRED		= 20021;
const	unsigned short TM_AG_PCBANG_CHANGED		= 20022;

const	unsigned short TM_AG_ITEM_PURCHASED		= 30000;
const	unsigned short TM_AG_ITEM_SUPPLIED		= 30001;

const	unsigned short TM_AG_SECURITY_NO_CHECK	= 40000;
const	unsigned short TM_GA_SECURITY_NO_CHECK	= 40001;
// }

// { Upload Server <-> Game Server
const	unsigned short TM_SU_LOGIN				= 50001;
const	unsigned short TM_US_LOGIN_RESULT		= 50002;

const	unsigned short TM_SU_REQUEST_UPLOAD		= 50003;
const	unsigned short TM_US_REQUEST_UPLOAD		= 50004;
//const	unsigned short TM_CU_LOGIN				= 50005;
//const	unsigned short TM_UC_LOGIN_RESULT		= 50006;
//const	unsigned short TM_CU_UPLOAD				= 50007;
//const	unsigned short TM_UC_UPLOAD				= 50008;
const	unsigned short TM_US_UPLOAD				= 50009;
// }


struct TS_MESSAGE
{
	TS_MESSAGE()
	{
		size = sizeof( *this );			
	}

	unsigned int		size;
	unsigned short		id;
	unsigned char		msg_check_sum;

	bool	IsValidMessage() const
	{
		return ( msg_check_sum == get_check_sum() );
	}

	void	set_check_sum()
	{
		msg_check_sum = get_check_sum();
	}

protected:

	unsigned char get_check_sum() const
	{	
		const char *p = reinterpret_cast< const char* >( &size );
		unsigned char check_sum = 0;

		while( p != reinterpret_cast< const char* >( &msg_check_sum ) )
		{
			check_sum += *p;
			++p;
		}

		return check_sum;
	}
};

struct TS_SC_RESULT		: TS_MESSAGE
{
	TS_SC_RESULT( unsigned short _request_msg_id, unsigned short _result, int _value )	:	request_msg_id( _request_msg_id ), result( _result ), value( _value )
	{
		size = sizeof( *this );
		id = TM_SC_RESULT;
		set_check_sum();
	}

	unsigned short		request_msg_id;
	unsigned short		result;
	int					value;
};

struct TS_CS_REPORT			: TS_MESSAGE
{
	TS_CS_REPORT()			_INIT( TM_CS_REPORT )

	unsigned short		report_len;	
};

struct TS_SC_OPEN_URL		: TS_MESSAGE
{
	TS_SC_OPEN_URL()		_INIT( TM_SC_OPEN_URL )

	bool					wait_for_event_scene;

	int						width;
	int						height;

	unsigned short			url_len;
	// 이 뒤로 url_len 만큼의 Url이 붙어감.
};

struct TS_SC_URL_LIST		: TS_MESSAGE
{
	TS_SC_URL_LIST()		_INIT( TM_SC_URL_LIST )

	unsigned short url_list_len;

	// 이 뒤로 길이 url_list_len 의 문자열이 붙어감.
};

struct TS_SC_ANTI_HACK					: TS_MESSAGE
{
	TS_SC_ANTI_HACK()						_INIT( TM_SC_ANTI_HACK )

	AHNHS_TRANS_BUFFER			AhnHSReqBuffer;
};

struct TS_CS_ANTI_HACK					: TS_MESSAGE
{
	TS_CS_ANTI_HACK()						_INIT( TM_CS_ANTI_HACK )

	AHNHS_TRANS_BUFFER			AhnHSAckBuffer;
};

struct TS_SC_GAME_GUARD_AUTH_QUERY		: TS_MESSAGE
{
	TS_SC_GAME_GUARD_AUTH_QUERY()			_INIT( TM_SC_GAME_GUARD_AUTH_QUERY )

	unsigned int				auth_data_size;
	// 뒤에 auth_data_size 만큼 데이터가 추가됨
};

struct TS_CS_GAME_GUARD_AUTH_ANSWER		: TS_MESSAGE
{
	TS_CS_GAME_GUARD_AUTH_ANSWER()			_INIT( TM_CS_GAME_GUARD_AUTH_ANSWER )

	unsigned int				auth_data_size;
	// 뒤에 auth_data_size 만큼 데이터가 추가됨
};

struct TS_CS_CHECK_ILLEGAL_USER		: TS_MESSAGE
{
	TS_CS_CHECK_ILLEGAL_USER()				_INIT( TM_CS_CHECK_ILLEGAL_USER )

	unsigned long				log_code;
};

struct TS_SC_XTRAP_CHECK		: TS_MESSAGE
{
	TS_SC_XTRAP_CHECK()			_INIT( TM_SC_XTRAP_CHECK )

	unsigned char			pCheckBuffer[ XTRAP_SETINFO_PACKETBUFF_SIZE ];
};

struct TS_CS_XTRAP_CHECK		: TS_MESSAGE
{
	TS_CS_XTRAP_CHECK()			_INIT( TM_CS_XTRAP_CHECK )

	unsigned char			pCheckBuffer[ XTRAP_SETINFO_PACKETBUFF_SIZE ];
};

struct TS_AG_PCBANG_EXPIRE_WARNING	: TS_MESSAGE
{
	TS_AG_PCBANG_EXPIRE_WARNING()	_INIT( TM_AG_PCBANG_EXPIRE_WARNING )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
	int					remain_minutes;
};

struct TS_AG_PCBANG_EXPIRE	: TS_MESSAGE
{
	TS_AG_PCBANG_EXPIRE()	_INIT( TM_AG_PCBANG_EXPIRED )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
};

struct TS_AG_PCBANG_CHANGED	: TS_MESSAGE
{
	TS_AG_PCBANG_CHANGED()	_INIT( TM_AG_PCBANG_CHANGED )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
	int					nPCBangMode;
};

struct TS_CS_VERSION		: TS_MESSAGE
{
	TS_CS_VERSION()			_INIT( TM_CS_VERSION )

	char				szVersion[20];

	// szVersion이 서버 정보 값을 요구하는 새 패킷이라면, 그 카운트만큼 뒤에 이 구조체가 따라 붙음.
	struct ServerENVInfo
	{
		ServerENVInfo()
		{
			memset( szData, 0, sizeof( szData ) );
		}
		char	szData[40];
	};
};

struct TS_SC_INFO			: TS_MESSAGE
{
	const static int MAX_QUERY_COUNT = 20;

	TS_SC_INFO()			_INIT( TM_SC_INFO )

	// 뒤에 count만큼 ServerENVResult가 따라 붙음
	int					count;
	
	struct ServerENVResult
	{
		ServerENVResult()
		{
			memset( szData, 0, sizeof( szData ) );
		}

		char	szData[40];
	};
};

struct TS_CS_REQUEST		: TS_MESSAGE
{
	TS_CS_REQUEST()			_INIT( TM_CS_REQUEST )

	char				t;
};

struct TS_LOGIN		: TS_MESSAGE
{
	TS_LOGIN()			_INIT( TM_CS_LOGIN )

	// below is game conetents
	char			szName[19];
	unsigned char	race;
};

struct TS_LOGIN_RESULT	: TS_MESSAGE
{
	TS_LOGIN_RESULT()	_INIT( TM_SC_LOGIN_RESULT )

	unsigned short	result;

	AR_HANDLE		handle;
	AR_UNIT			x,y,z;
	unsigned char	layer;
	float			face_direction;

	int				region_size;

	// below is game conetents
	int				hp;
	int				mp;
	int				max_hp;
	int				max_mp;
	int				sex;
	int				race;
	unsigned long	skin_color;
	ItemBase::ItemCode	faceId;
	ItemBase::ItemCode	hairId;

	char			szName[19];


	int				cell_size;

	int				guild_id;
	int				back_board;
};

struct TS_SC_CHANGE_NAME			: TS_MESSAGE
{
	TS_SC_CHANGE_NAME()		_INIT( TM_SC_CHANGE_NAME );

	AR_HANDLE			handle;
	char				name[19];
};

struct TS_TIMESYNC	: TS_MESSAGE
{
	TS_TIMESYNC()		_INIT( TM_TIMESYNC )

	AR_TIME			time;
};

struct TS_CS_QUERY		: TS_MESSAGE
{
	TS_CS_QUERY()			_INIT( TM_CS_QUERY )

	AR_HANDLE handle;
};

struct TS_ENTER		: TS_MESSAGE
{
	TS_ENTER()			_INIT( TM_SC_ENTER )

	enum
	{
		PLAYER = 0, NPC = 1, STATIC_OBJECT = 2
	};

	enum //Game Obj Type
	{
		GAME_PLAYER = 0,
		GAME_NPC = 1,
		GAME_ITEM = 2,
		GAME_MOB = 3,
		GAME_SUMMON = 4,
		GAME_SKILL_PROP = 5,
		GAME_FIELD_PROP = 6,
		GAME_PET = 7
	};

	unsigned char	type;
	AR_HANDLE		handle;
	AR_UNIT			x,y,z;
	unsigned char	layer;

	// below is game conetents

	unsigned char		ObjType;

	struct TS_ITEM_PICK_UP_ORDER
	{
		AR_TIME					drop_time;
		AR_HANDLE				hPlayer[ 3 ];
		int						nPartyID[ 3 ];
		/*
		먹자 방지 룰

		drop_time부터 30초 이내:
		pickup_order.hPlayer[0] 가 0이 아닐 경우, hPlayer[0]인 사용자만 집을 수 있습니다.
		pickup_order.hPlayer[0] 가 0이고, pickup_order.nPartyID[0] > 0 일 경우, pickup_order.nPartyID[0]인 파티 소속원만 집을 수 있습니다.

		drop_time부터 40초 이내:
		pickup_order.hPlayer[1] 가 0이 아닐 경우, hPlayer[1]인 사용자만 집을 수 있습니다.
		pickup_order.hPlayer[1] 가 0이고, pickup_order.nPartyID[1] > 0 일 경우, pickup_order.nPartyID[1]인 파티 소속원만 집을 수 있습니다.

		drop_time부터 50초 이내:
		pickup_order.hPlayer[2] 가 0이 아닐 경우, hPlayer[2]인 사용자만 집을 수 있습니다.
		pickup_order.hPlayer[2] 가 0이고, pickup_order.nPartyID[2] > 0 일 경우, pickup_order.nPartyID[2]인 파티 소속원만 집을 수 있습니다.

		50초 이후엔 아무나 집을 수 있습니다.
		*/
	};

	struct ItemInfo
	{
		ENC_INT					code;	// code 가 0인것은 돈임. 액수는 cnt
		__int64					cnt;

		TS_ITEM_PICK_UP_ORDER	pick_up_order;
	};

	struct SkillInfo
	{
		AR_HANDLE	caster;
		AR_TIME		start_time;
		int			skill_num;
	};

	struct FieldPropInfo
	{
		int			prop_id;
		float		fZOffset;
		float		fRotateX, fRotateY, fRotateZ;
		float		fScaleX, fScaleY, fScaleZ;
		bool		bLockHeight;
		float		fLockHeight;
	};

	struct CreatureInfo
	{
		enum
		{
			FLAG_BATTLE_MODE	= 1 << 0,
			FLAG_INVISIBLE		= 1 << 1,
		};

		unsigned			status;

		float				face_direction;	// 보고있는 방향
		int					hp;
		int					max_hp;
		int					mp;
		int					max_mp;
		int					level;
		unsigned char		race;
		unsigned long		skin_color;
		bool				is_first_enter;
		int					energy;
	};

	struct MonsterInfo : CreatureInfo
	{
		enum
		{
			FLAG_DEAD						= 1 << 8,
			FLAG_DUNGEON_ORIGINAL_OWNER		= 1 << 15,
			FLAG_DUNGEON_ORIGINAL_SIEGER	= 1 << 17,
		};

		ENC_INT				monster_id;
		bool				is_tamed;		// 테이밍 되었는지 여부
	};

	struct SummonInfo : CreatureInfo
	{
		AR_HANDLE			master_handle;
		ENC_INT				summon_code;
		char				szName[19];
		unsigned char		enhance;
	};

	struct NPCInfo : CreatureInfo
	{	
		enum
		{
			FLAG_HAS_STARTABLE_QUEST	= 1 << 8,
			FLAG_HAS_IN_PROGRESS_QUEST	= 1 << 9,
			FLAG_HAS_FINISHABLE_QUEST	= 1 << 10,
		};

		ENC_INT				npc_id;
		//int					model_id;
		//char				szName[25];
	};

	struct PlayerInfo : CreatureInfo
	{
		enum
		{
			FLAG_SITDOWN					= 1 << 8,
			FLAG_BUY_BOOTH					= 1 << 9,
			FLAG_SELL_BOOTH					= 1 << 10,
			FLAG_PK_ON						= 1 << 11,
			FLAG_BLOODY						= 1 << 12,
			FLAG_DEMONIAC					= 1 << 13,
			FLAG_GM							= 1 << 14,
			FLAG_DUNGEON_ORIGINAL_OWNER		= 1 << 15,
			FLAG_WALKING					= 1 << 16,
			FLAG_DUNGEON_ORIGINAL_SIEGER	= 1 << 17,
			FLAG_SHOVELING_SEARCH			= 1 << 18,
			FLAG_SHOVELING_APPROACH			= 1 << 19,
			FLAG_SHOVELING_DIG				= 1 << 20,
			FLAG_COMPETING					= 1 << 21,
			FLAG_BATTLE_ARENA_TEAM_0		= 1 << 22,
			FLAG_BATTLE_ARENA_TEAM_1		= 1 << 23,
		};
		unsigned char sex;

		ItemBase::ItemCode	faceId;
		int					faceTextureId;
		int					hairId;
		int					hairColorIndex;
		unsigned int		hairColorRGB;

		unsigned int		hideEquipFlag;

		char	szName[19];

		unsigned short	job_id;

		AR_HANDLE		ride_handle;

		int				guild_id;
		int				title_code;
		int				back_board;
	};

	struct PetInfo : CreatureInfo
	{
		AR_HANDLE		master_handle;
		ENC_INT			pet_code;
		char			szName[19];
	};
};

struct TS_SC_STATUS_CHANGE : TS_MESSAGE
{
	TS_SC_STATUS_CHANGE()		_INIT( TM_SC_STATUS_CHANGE )

	AR_HANDLE		handle;
	unsigned		status;
};

struct TS_CS_RESURRECTION : TS_MESSAGE
{
	TS_CS_RESURRECTION()			_INIT( TM_CS_RESURRECTION )

	AR_HANDLE		handle;

	enum
	{
		RESURRECT_TYPE_NORMAL				= 0,	// 일반 부활
		RESURRECT_TYPE_BY_STATE				= 1,	// 버프 부활
		RESURRECT_TYPE_BY_POTION			= 2,	// 대모 요정의 병 부활
		RESURRECT_TYPE_BY_COMPETE			= 3,	// 대련 사망 패배 후 부활
		RESURRECT_TYPE_BY_DEATHMATCH		= 4,	// 데스매치에서 사망 후 부활
	};

	char			type;
};

struct TS_SC_TARGET : TS_MESSAGE
{
	TS_SC_TARGET()			_INIT( TM_SC_TARGET )

	AR_HANDLE		target;
};


struct TS_CS_TARGETING : TS_MESSAGE
{
	TS_CS_TARGETING()			_INIT( TM_CS_TARGETING )

	AR_HANDLE		target;
};

struct TS_SC_STATE : TS_MESSAGE
{
	TS_SC_STATE()			_INIT( TM_SC_STATE )

	AR_HANDLE		handle;			// 대상 크리쳐
	unsigned short	state_handle;	// 상태이상 핸들
	unsigned int	state_code;		// 상태이상 종류

	unsigned short	state_level;	// 상태이상의 레벨 (0이면 풀리는 메시지임)

	AR_TIME			end_time;		// 끝나는 시간 (0이면 영원히) ( -1 : aura )
	AR_TIME			start_time;		// 시작시간

	int				state_value;	// 지속효과 관련 추가값

	char			state_string_value[32];
};

struct TS_SC_PROPERTY : TS_MESSAGE
{
	TS_SC_PROPERTY()					_INIT( TM_SC_PROPERTY )

	AR_HANDLE	handle;

	bool		is_number;				// 이게 참이라면 value 에 숫자가 들어감. 거짓이라면 문자열 값인데 메시지 끝이 '\0' 으로 끝나는 문자열이 들어감.
	char		name[16];
	__int64		value;
};

struct TS_CS_SET_PROPERTY : TS_MESSAGE
{
	TS_CS_SET_PROPERTY()					_INIT( TM_CS_SET_PROPERTY )

	char		name[16];
};

//struct TS_SC_HP : TS_MESSAGE
//{
//	TS_SC_HP()					_INIT( TM_SC_HP )
//
//	AR_HANDLE	handle;
//	int			hp;
//	unsigned char hp_percentage;
//};
//
struct TS_SC_HPMP : TS_MESSAGE
{
	TS_SC_HPMP()					_INIT( TM_SC_HPMP )

	AR_HANDLE	handle;
	int			add_hp;
	int			hp;
	int			max_hp;
	int			add_mp;
	int			mp;
	int			max_mp;
	bool		need_to_display;
};

//struct TS_SC_MP : TS_MESSAGE
//{
//	TS_SC_MP()					_INIT( TM_SC_MP )
//
//	AR_HANDLE	handle;
//	short		mp;
//};

struct TS_SC_SP : TS_MESSAGE
{
	TS_SC_SP()					_INIT( TM_SC_SP )

	AR_HANDLE	handle;
	short		sp;
	short		max_sp;
};

struct TS_SC_ENERGY : TS_MESSAGE
{
	TS_SC_ENERGY()					_INIT( TM_SC_ENERGY )

	AR_HANDLE	handle;
	short		energy;
};

struct TS_SC_REGEN_HPMP : TS_MESSAGE
{
	TS_SC_REGEN_HPMP()					_INIT( TM_SC_REGEN_HPMP )

	AR_HANDLE	handle;
	int			hp_regen;
	int			mp_regen;
	int			hp;
	int			mp;
};

struct TS_CS_MONSTER_RECOGNIZE : TS_MESSAGE
{
	TS_CS_MONSTER_RECOGNIZE()		_INIT( TM_CS_MONSTER_RECOGNIZE )

	AR_HANDLE	recognizer_handle;
	AR_HANDLE	monster_handle;
};

struct TS_CS_UPDATE	: TS_MESSAGE
{
	TS_CS_UPDATE()					_INIT( TM_CS_UPDATE )

	AR_HANDLE		handle;
	int				ar_time;
	int				rtc;
};

struct TS_SC_TAMING_INFO : TS_MESSAGE
{
	TS_SC_TAMING_INFO()				_INIT( TM_SC_TAMING_INFO )

	enum
	{
		START		= 0,	// tamer 가 target 에게 테이밍 스킬을 걸었음
		CLEAR		= 1,	// 테이밍이 초기화됨 (tamer_handle 은 0)
		SUCCESS		= 2,	// target 이 죽어서 tamer 에게 테이밍됨.
		FAILED		= 3,	// target 이 죽었지만 테이밍은 실패!
	};

	unsigned char	mode;

	AR_HANDLE		tamer_handle;
	AR_HANDLE		target_handle;
};

struct TS_WEAR_INFO	: TS_MESSAGE
{
	TS_WEAR_INFO()		_INIT( TM_SC_WEAR_INFO )

	AR_HANDLE			handle;
	ItemBase::ItemCode	itemCode[ItemBase::MAX_ITEM_WEAR];
	int					itemEnhance[ItemBase::MAX_ITEM_WEAR];
	int					itemLevel[ItemBase::MAX_ITEM_WEAR];
	unsigned char		elemental_effect_type[ItemBase::MAX_ITEM_WEAR];
	ItemBase::ItemCode	appearance_code[ItemBase::MAX_ITEM_WEAR];
};

struct TS_SC_ITEM_WEAR_INFO		: TS_MESSAGE
{
	TS_SC_ITEM_WEAR_INFO()		_INIT( TM_SC_ITEM_WEAR_INFO )
	
	AR_HANDLE					item_handle;
	short						wear_position;		// -1이면 장착 안된 아이템
	AR_HANDLE					target_handle;
	int							enhance;
	unsigned char				elemental_effect_type;
	ItemBase::ItemCode			appearance_code;
};

struct TS_LEAVE		: TS_MESSAGE
{
	TS_LEAVE()			_INIT( TM_SC_LEAVE )

	AR_HANDLE		handle;
};

struct TS_MOVE_REQUEST	: TS_MESSAGE
{
	TS_MOVE_REQUEST()	_INIT( TM_CS_MOVE_REQUEST )

	AR_HANDLE	handle;
//	AR_UNIT		tx,ty;

	AR_UNIT		x,y;
	
	AR_TIME		cur_time;
//	unsigned char tlayer;

	bool		speed_sync;

	unsigned short	count;

	struct MOVE_INFO
	{
		AR_UNIT		tx,ty;
	};
	// 이 뒤에 MOVE_INFO가 COUNT만큼 붙어서 온다.
};

struct TS_MOVE			: TS_MESSAGE
{
	TS_MOVE()			_INIT( TM_SC_MOVE )

	AR_TIME			start_time;
	AR_HANDLE		handle;
	//AR_UNIT			tx, ty, tz;

	unsigned char	tlayer;
	unsigned char	speed;

	unsigned short	count;

	struct MOVE_INFO
	{
		AR_UNIT		tx,ty;
	};
};

struct TS_SC_MOUNT_SUMMON	: TS_MESSAGE
{
	TS_SC_MOUNT_SUMMON()	_INIT( TM_SC_MOUNT_SUMMON )

	AR_HANDLE		handle;
	AR_HANDLE		summon_handle;
	AR_UNIT			x, y;
	bool			success;
};

struct TS_SC_UNMOUNT_SUMMON	: TS_MESSAGE
{
	TS_SC_UNMOUNT_SUMMON()	_INIT( TM_SC_UNMOUNT_SUMMON )

	AR_HANDLE		handle;
	AR_HANDLE		summon_handle;

	enum
	{
		NORMAL = 0,
		FALL = 1,
		UNSUMMON = 2,
	};

	char			flag;
};

struct TS_SC_SHOW_SUMMON_NAME_CHANGE : TS_MESSAGE
{
	TS_SC_SHOW_SUMMON_NAME_CHANGE()	_INIT( TM_SC_SHOW_SUMMON_NAME_CHANGE )

	AR_HANDLE		handle;
};

struct TS_CS_CHANGE_SUMMON_NAME : TS_MESSAGE
{
	TS_CS_CHANGE_SUMMON_NAME()		_INIT( TM_CS_CHANGE_SUMMON_NAME )

	char			szName[19];
};

struct TS_CS_GET_SUMMON_SETUP_INFO : TS_MESSAGE
{
	TS_CS_GET_SUMMON_SETUP_INFO()	_INIT( TM_CS_GET_SUMMON_SETUP_INFO )

	bool			show_dialog;
};

struct TS_SC_UNSUMMON_PET : TS_MESSAGE
{
	TS_SC_UNSUMMON_PET()			_INIT( TM_SC_UNSUMMON_PET )

	AR_HANDLE		handle;
};

struct TS_SC_ADD_PET_INFO : TS_MESSAGE
{
	TS_SC_ADD_PET_INFO()			_INIT( TM_SC_ADD_PET_INFO )

	AR_HANDLE		cage_handle;
	AR_HANDLE		pet_handle;
	
	char			name[19];
	int				code;
};

struct TS_SC_REMOVE_PET_INFO : TS_MESSAGE
{
	TS_SC_REMOVE_PET_INFO()			_INIT( TM_SC_REMOVE_PET_INFO )

	AR_HANDLE		handle;
};

struct TS_SC_SHOW_SET_PET_NAME : TS_MESSAGE
{
	TS_SC_SHOW_SET_PET_NAME()		_INIT( TM_SC_SHOW_SET_PET_NAME )

	AR_HANDLE		handle;
};

struct TS_CS_SET_PET_NAME : TS_MESSAGE
{
	TS_CS_SET_PET_NAME()			_INIT( TM_CS_SET_PET_NAME )

	AR_HANDLE		handle;
	char			name[19];
};

struct TS_FORCE_MOVE	: TS_MESSAGE
{
	TS_FORCE_MOVE()			_INIT( TM_SC_FORCE_MOVE )

	AR_HANDLE		handle;
	AR_UNIT			x, y, z;
	unsigned char	layer;
	float			face;
};

struct TS_REGION_UPDATE		: TS_MESSAGE
{
	TS_REGION_UPDATE()	_INIT( TM_CS_REGION_UPDATE )

	AR_TIME			update_time;
	AR_UNIT			x, y, z;
	bool			bIsStopMessage;
};

struct TS_SC_WARP		: TS_MESSAGE
{
	TS_SC_WARP()	_INIT( TM_SC_WARP )

	AR_UNIT			x, y, z;
	unsigned char	layer;
};

struct TS_REGION_ACK		: TS_MESSAGE
{
	TS_REGION_ACK()		_INIT( TM_SC_REGION_ACK )

	unsigned		rx, ry;
};

struct TS_CS_ENTER_EVENT_AREA	: TS_MESSAGE
{
	TS_CS_ENTER_EVENT_AREA()	_INIT( TM_CS_ENTER_EVENT_AREA )

	int				event_area_id;
	int				area_index;
};

struct TS_CS_LEAVE_EVENT_AREA	: TS_MESSAGE
{
	TS_CS_LEAVE_EVENT_AREA()	_INIT( TM_CS_LEAVE_EVENT_AREA )

	int				event_area_id;
	int				area_index;
};

struct TS_MOVE_ACK		: TS_MESSAGE
{
	TS_MOVE_ACK()		_INIT( TM_SC_MOVE_ACK )

	AR_TIME			time;
	unsigned char	speed;
};

struct TS_SET_TIME		: TS_MESSAGE
{
	TS_SET_TIME()		_INIT( TM_SC_SET_TIME )

	int		gap;
};

struct TS_ATTACK_REQUEST		: TS_MESSAGE
{
	TS_ATTACK_REQUEST()		_INIT( TM_CS_ATTACK_REQUEST )

	AR_HANDLE		handle;
	AR_HANDLE		target_handle;	// NULL 이면 공격 중지 메시지
};

struct TS_SC_STATE_RESULT		: TS_MESSAGE
{
	TS_SC_STATE_RESULT()		_INIT( TM_SC_STATE_RESULT )

	AR_HANDLE		caster_handle;
	AR_HANDLE		target_handle;
	
	int				code;
	unsigned short	level;

	// result_type 종류
	enum
	{
		STATE_DAMAGE_HP	= 1,
		STATE_DAMAGE_MP	= 2,
		STATE_DAMAGE_SP	= 3,
		STATE_HEAL_HP	= 4,
		STATE_HEAL_MP	= 5,
		STATE_HEAL_SP	= 6,
	};

	unsigned short	result_type;	// 위의 enum 값 중 하나
	int				value;			// enum에 해당하는 종류의 수치
	int				target_value;	// 처리 후 target의 해당 수치

	bool			final;
	int				total_amount;
};

struct TS_ATTACK_EVENT		: TS_MESSAGE
{
	TS_ATTACK_EVENT()		_INIT( TM_SC_ATTACK_EVENT )

	AR_HANDLE		attacker_handle;
	AR_HANDLE		target_handle;

	enum
	{
		FLAG_CRITICAL			= ( 1 << 3 ),
		FLAG_MISS				= ( 1 << 2 ),
		FLAG_BLOCK				= ( 1 << 1 ),
		FLAG_PERFECT_BLOCK		= ( 1 << 0 ),
	};	

	struct ATTACK_INFO
	{
		int				damage;
		int				mp_damage;
		unsigned char	flag;
		int				elemental_damage[ Elemental::TYPE_COUNT ];
		int				target_hp;
		int				target_mp;
		int				attacker_damage;
		int				attacker_mp_damage;
		int				attacker_hp;
		int				attacker_mp;
	};

	unsigned short	attack_speed;			// ms
	unsigned short	attack_delay;			// ms

	enum
	{
		ATTACK_END				= 1,
		ATTACK_AIMING			= 2,
		ATTACK_ATTACK			= 3,
		ATTACK_CANCEL			= 4,
	};

	char			attack_action;

	enum
	{
		ATTACK_FLAG_BOW				= ( 1 << 0 ),
		ATTACK_FLAG_CROSS_BOW		= ( 1 << 1 ),
		ATTACK_FLAG_DOUBLE_WEAPON	= ( 1 << 2 ),
		ATTACK_FLAG_DOUBLE_ATTACK	= ( 1 << 3 ),
	};

	char			attack_flag;

	unsigned char	count;

	// double weapon의 경우, right, left 순서
	// double weapon, double attack의 경우, right, left, right, left 순서
};

struct TS_SC_KNOCK_BACK		: TS_MESSAGE
{
	TS_SC_KNOCK_BACK()		_INIT( TM_SC_KNOCK_BACK )

	AR_HANDLE		handle;
	AR_UNIT			x, y, z;
	unsigned char	layer;
	float			face;
	AR_TIME			next_movable_time;
};

struct TS_SC_CANT_ATTACK	: TS_MESSAGE
{
	TS_SC_CANT_ATTACK()		_INIT( TM_SC_CANT_ATTACK )

	AR_HANDLE		attacker_handle;
	AR_HANDLE		target_handle;

	int				reason;
};

struct TS_ITEM_BASE_INFO
{
	AR_HANDLE					handle;
	ItemBase::ItemCode			Code;
	ItemUID		uid;

	// TS_SC_ITEM_KEEPING_LIST::TS_ITEM_KEEPING_INFO 에 돈이 들어갈 경우 수량이 액수가 되어야 해서 __int64 타입 사용함
	__int64						count;
	int							ethereal_durability;
	unsigned int				endurance;
	unsigned char				enhance;
	unsigned char				level;
	short						enhance_chance;
	int							Flag;
	int							nAdditionalItemEffect;	// Fraun Sky Accessories 7/12/2025

	int							socket[ ItemBase::MAX_SOCKET_NUMBER ];

	struct AwakenOption
	{
		int		nValue1[ ItemInstance::MAX_AWAKEN_NUMBER ];
		int		nValue2[ ItemInstance::MAX_AWAKEN_NUMBER ];
	};
	AwakenOption				awakenoption;

	struct RandomOption
	{
		int			nType[ ItemInstance::MAX_RANDOM_OPTION_NUMBER ];
		c_fixed10	fValue1[ ItemInstance::MAX_RANDOM_OPTION_NUMBER ];
		c_fixed10	fValue2[ ItemInstance::MAX_RANDOM_OPTION_NUMBER ];
	};
	RandomOption				random_option;

	int							remain_time;

	unsigned char				elemental_effect_type;
	int							elemental_effect_remain_time;
	int							elemental_effect_attack_point;
	int							elemental_effect_magic_point;
	ItemBase::ItemCode			appearance_code;
	int							summon_code;
};

struct TS_ITEM_INFO : TS_ITEM_BASE_INFO
{
	short						wear_position;		// -1이면 장착 안된 아이템, 
													// -2이면 창고 아이템
													// -3이면 캐쉬템 아이템

	AR_HANDLE					own_summon_handle;	// 소환수 장착 아니면 0

	int							index;
};

struct TS_CS_BIND_SKILLCARD		: TS_MESSAGE
{
	TS_CS_BIND_SKILLCARD()		_INIT( TM_CS_BIND_SKILLCARD )
	
	AR_HANDLE		item_handle;
	AR_HANDLE		target_handle;
};

struct TS_CS_UNBIND_SKILLCARD		: TS_MESSAGE
{
	TS_CS_UNBIND_SKILLCARD()		_INIT( TM_CS_UNBIND_SKILLCARD )

	AR_HANDLE		item_handle;
	AR_HANDLE		target_handle;
};

struct TS_SC_SKILLCARD_INFO			: TS_MESSAGE
{
	TS_SC_SKILLCARD_INFO()			_INIT( TM_SC_SKILLCARD_INFO )

	AR_HANDLE		item_handle;
	AR_HANDLE		target_handle;	// 0 이면 장착해지
};

struct TS_CS_PUTON_ITEM		: TS_MESSAGE
{
	TS_CS_PUTON_ITEM()		_INIT( TM_CS_PUTON_ITEM )

	unsigned char	position;
	AR_HANDLE		item_handle;
	AR_HANDLE		target_handle;
};

struct TS_CS_PUTON_ITEM_SET		: TS_MESSAGE
{
	TS_CS_PUTON_ITEM_SET()	_INIT( TM_CS_PUTON_ITEM_SET )

	AR_HANDLE		handle[ItemBase::MAX_ITEM_WEAR];
};

struct TS_CS_PUTON_CARD			: TS_MESSAGE
{
	TS_CS_PUTON_CARD()		_INIT( TM_CS_PUTON_CARD )

	unsigned char	position;
	AR_HANDLE		item_handle;
};

struct TS_CS_PUTOFF_CARD		: TS_MESSAGE
{
	TS_CS_PUTOFF_CARD()		_INIT( TM_CS_PUTOFF_CARD )

	unsigned char	position;
};

struct TS_SC_BELT_SLOT_INFO		: TS_MESSAGE
{
	TS_SC_BELT_SLOT_INFO()	_INIT( TM_SC_BELT_SLOT_INFO )

	AR_HANDLE		handle[8];
};

struct TS_CS_PUTOFF_ITEM		: TS_MESSAGE
{
	TS_CS_PUTOFF_ITEM()		_INIT( TM_CS_PUTOFF_ITEM )

	unsigned char	position;
	AR_HANDLE		target_handle;
};

struct TS_CS_DROP_ITEM			: TS_MESSAGE
{
	TS_CS_DROP_ITEM()		_INIT( TM_CS_DROP_ITEM )

	AR_HANDLE		item_handle;
	int				count;
};

struct TS_CS_TAKE_ITEM			: TS_MESSAGE
{
	TS_CS_TAKE_ITEM()		_INIT( TM_CS_TAKE_ITEM )

	AR_HANDLE		taker_handle;
	AR_HANDLE		item_handle;
};

struct TS_SC_TAKE_ITEM_RESULT	: TS_MESSAGE
{
	TS_SC_TAKE_ITEM_RESULT()	_INIT( TM_SC_TAKE_ITEM_RESULT )

	AR_HANDLE		item_handle;
	AR_HANDLE		item_taker;
};


struct TS_SC_DROP_RESULT			: TS_MESSAGE
{
	TS_SC_DROP_RESULT()		_INIT( TM_SC_DROP_RESULT )

	AR_HANDLE		item_handle;
	bool			isAccepted;
};

struct TS_CS_ERASE_ITEM				: TS_MESSAGE
{
	struct EraseItemInfo
	{
		AR_HANDLE	item_handle;
		__int64		count;
		char		is_in_storage;
	};

	TS_CS_ERASE_ITEM()		_INIT( TM_CS_ERASE_ITEM )

	unsigned char	item_count;
};

struct TS_SC_ERASE_ITEM				: TS_MESSAGE
{
	struct EraseItemInfo
	{
		AR_HANDLE	item_handle;
		__int64		count;
	};

	TS_SC_ERASE_ITEM()		_INIT( TM_SC_ERASE_ITEM )

	unsigned char	item_count;
};

struct TS_SC_INVENTORY				: TS_MESSAGE
{
	TS_SC_INVENTORY()		_INIT( TM_SC_INVENTORY )

	unsigned short	count;

	// 이하 TS_ITEM_INFO 가 count 만큼 붙게됨
};

struct TS_SC_OPEN_STORAGE				: TS_MESSAGE
{
	TS_SC_OPEN_STORAGE()		_INIT( TM_SC_OPEN_STORAGE )

	int maxStorageItemCount;
};

struct TS_SC_COMMERCIAL_STORAGE_INFO				: TS_MESSAGE
{
	TS_SC_COMMERCIAL_STORAGE_INFO()		_INIT( TM_SC_COMMERCIAL_STORAGE_INFO )

	unsigned	short total_item_count;
	unsigned	short new_item_count;
};

struct TS_SC_COMMERCIAL_STORAGE_LIST			: TS_MESSAGE
{
	TS_SC_COMMERCIAL_STORAGE_LIST()			_INIT( TM_SC_COMMERCIAL_STORAGE_LIST )

	struct CommercialItemInfo
	{
		unsigned int			commercial_item_uid;	// cuid (캐쉬템 고유번호)
		ItemBase::ItemCode		code;					// 아이템 코드
		unsigned short			count;					// 갯수
	};

	unsigned short count;

	// 이하 CommercialItemInfo 가 count 만큼 붙음
};

struct TS_CS_TAKEOUT_COMMERCIAL_ITEM				: TS_MESSAGE
{
	TS_CS_TAKEOUT_COMMERCIAL_ITEM()			_INIT( TM_CS_TAKEOUT_COMMERCIAL_ITEM )

	unsigned int	commercial_item_uid;		// 꺼낼 아이템 cuid
	unsigned short	count;						// 꺼낼 갯수
};

struct TS_CS_GET_REGION_INFO				: TS_MESSAGE
{
	TS_CS_GET_REGION_INFO()			_INIT( TM_CS_GET_REGION_INFO )

	AR_UNIT x;
	AR_UNIT y;
};

struct TS_SC_SHOW_CREATE_GUILD				: TS_MESSAGE
{
	TS_SC_SHOW_CREATE_GUILD()		_INIT( TM_SC_SHOW_CREATE_GUILD )
};

struct TS_SC_SHOW_CREATE_ALLIANCE			: TS_MESSAGE
{
	TS_SC_SHOW_CREATE_ALLIANCE()		_INIT( TM_SC_SHOW_CREATE_ALLIANCE )
};

struct TS_SC_OPEN_GUILD_WINDOW : TS_MESSAGE
{
	TS_SC_OPEN_GUILD_WINDOW()			_INIT( TM_SC_OPEN_GUILD_WINDOW )

	int			client_id;
	int			account_id;
	int			one_time_password;
	char		raw_server_name[32];
};

struct TS_SC_UPDATE_GUILD_ICON : TS_MESSAGE
{
	TS_SC_UPDATE_GUILD_ICON()			_INIT( TM_SC_UPDATE_GUILD_ICON )

	int			client_id;
	int			account_id;
	int			one_time_password;
	char		raw_server_name[32];
};

struct TS_SC_UPDATE_GUILD_BANNER : TS_MESSAGE
{
	TS_SC_UPDATE_GUILD_BANNER()			_INIT( TM_SC_UPDATE_GUILD_BANNER )

	int			client_id;
	int			account_id;
	int			one_time_password;
	char		raw_server_name[32];
};

struct TS_CS_CHANGE_ITEM_POSITION		: TS_MESSAGE
{
	TS_CS_CHANGE_ITEM_POSITION()	_INIT( TM_CS_CHANGE_ITEM_POSITION )

	bool		is_storage;

	AR_HANDLE	item_handle_1;
	AR_HANDLE	item_handle_2;
};

struct TS_CS_STORAGE					: TS_MESSAGE
{
	TS_CS_STORAGE()				_INIT( TM_CS_STORAGE )

	enum
	{
		ITEM_INVENTORY_TO_STORAGE		= 0,
		ITEM_STORAGE_TO_INVENTORY		= 1,
		GOLD_INVENTORY_TO_STORAGE		= 2,
		GOLD_STORAGE_TO_INVENTORY		= 3,
		CLOSE							= 4,
	};

	AR_HANDLE				item_handle;
	unsigned char			mode;
	__int64					count;
};

struct TS_SC_ITEM_COOL_TIME			: TS_MESSAGE
{
	TS_SC_ITEM_COOL_TIME()		_INIT( TM_SC_ITEM_COOL_TIME )

	enum
	{
		MAX_ITEM_COOLTIME_GROUP = 40,
	};

	AR_TIME	cool_time[MAX_ITEM_COOLTIME_GROUP];
};

struct TS_SC_GET_CHAOS				: TS_MESSAGE
{
	TS_SC_GET_CHAOS()			_INIT( TM_SC_GET_CHAOS );

	AR_HANDLE				hPlayer;
	AR_HANDLE				hCorpse;
	int						nChaos;

	enum CHAOS_BONUS_TYPE
	{
		CHAOS_BONUS_NONE			= 0,
		CHAOS_BONUS_PCBANG			= 1,
		CHAOS_BONUS_PREMIUM_PCBANG	= 2,
	};

	char				nBonusType;
	unsigned char		nBonusPercent;
	int					nBonus;
};

struct TS_CS_ARRANGE_ITEM			: TS_MESSAGE
{
	TS_CS_ARRANGE_ITEM()		_INIT( TM_CS_ARRANGE_ITEM );

	bool			bIsStorage;
};

struct TS_SC_HAIR_INFO				: TS_MESSAGE
{
	TS_SC_HAIR_INFO()		_INIT( TM_SC_HAIR_INFO )

	AR_HANDLE		hPlayer;
	int				nHairID;
	int				nHairColorIndex;
	unsigned int	nHairColorRGB;
};

struct TS_SC_SKIN_INFO				: TS_MESSAGE
{
	TS_SC_SKIN_INFO()		_INIT( TM_SC_SKIN_INFO )

	AR_HANDLE		hPlayer;
	int				nSkinColor;
};

struct TS_CS_HIDE_EQUIP_INFO		: TS_MESSAGE
{
	TS_CS_HIDE_EQUIP_INFO()		_INIT( TM_CS_HIDE_EQUIP_INFO )

	unsigned int	nHideEquipFlag;
};

struct TS_SC_HIDE_EQUIP_INFO		: TS_MESSAGE
{
	TS_SC_HIDE_EQUIP_INFO()		_INIT( TM_SC_HIDE_EQUIP_INFO )

	AR_HANDLE		hPlayer;
	unsigned int	nHideEquipFlag;
};

struct TS_CS_SWAP_EQUIP				: TS_MESSAGE
{
	TS_CS_SWAP_EQUIP()			_INIT( TM_CS_SWAP_EQUIP )
};

struct TS_CS_MIX					: TS_MESSAGE
{
	TS_CS_MIX()				_INIT( TM_CS_MIX )

	struct MIX_INFO
	{
		AR_HANDLE		handle;
		unsigned short	count;
	};

	MIX_INFO main_item;

	unsigned short count;

	// 이하 MIX_INFO 타입이 count 만큼 붙게 됨.
};

struct TS_SC_MIX_RESULT				: TS_MESSAGE
{
	TS_SC_MIX_RESULT()		_INIT( TM_SC_MIX_RESULT )

	enum MIX_TYPE
	{
		MIX_TYPE_NONE,
		MIX_TYPE_AWAKEN,		// 각성
		MIX_TYPE_RANDOM_OPTION,	// 랜덤옵션
	};

	unsigned		count;		// 이하 AR_HANDLE 이 count 만큼 붙게 됨. count 가 0 이면 조합 실패.
	unsigned char	type;		// 각성 Type
};

struct TS_CS_DECOMPOSE				: TS_MESSAGE
{
	TS_CS_DECOMPOSE()		_INIT( TM_CS_DECOMPOSE )
	
	struct DECOMPOSE_INFO
	{
		DECOMPOSE_INFO( AR_HANDLE _handle = 0, unsigned int _count = 0) : handle( _handle ), count( _count )
		{}

		AR_HANDLE			handle;
		unsigned int 		count;
	};

	unsigned int		count;		// 이하 DECOMPOSE_INFO 가 count 만큼 붙게 됨.
};

struct TS_SC_DECOMPOSE_RESULT		: TS_MESSAGE
{
	TS_SC_DECOMPOSE_RESULT()	_INIT( TM_SC_DECOMPOSE_RESULT )

	struct DECOMPOSE_INFO
	{
		DECOMPOSE_INFO( AR_HANDLE _handle = 0, unsigned int _count = 0) : handle( _handle ), count( _count )
		{}

		AR_HANDLE			handle;
		unsigned int 		count;
	};

	unsigned int		total_count;		// 이하 DECOMPOSE_INFO 가 total_count 만큼 붙게 됨. total_count는 항상 1 이상 (분해실패하면 TS_SC_RESULT 패킷 보냄)
};

struct TS_SC_CHAT_LOCAL			: TS_MESSAGE
{
	TS_SC_CHAT_LOCAL()			_INIT( TM_SC_CHAT_LOCAL )

	AR_HANDLE		handle;

	unsigned char	len;
	unsigned char	type;
};

struct TS_SC_CHAT_RESULT		: TS_MESSAGE
{
	TS_SC_CHAT_RESULT()			_INIT( TM_SC_CHAT_RESULT )

	enum CHAT_RESULT
	{
		RESULT_DECREASE_HPMP		= 0,
		RESULT_COOLTIME				= 1,
		RESULT_NEED_MORE_HPMP		= 2,
		RESULT_LEVEL_RESTRICT		= 3,
	};

	unsigned char	type;
	unsigned char	percentage;
	int				result;
	int				reserved;
};


enum CHAT_TYPE
{
	CHAT_NORMAL				= 0,	// 일반채팅
	CHAT_YELL				= 1,	// 외치기
	CHAT_ADV				= 2,	// 광고채팅
	CHAT_WHISPER			= 3,	// 귓속말
	CHAT_GLOBAL				= 4,	// 전체메시지
	CHAT_EMOTION			= 5,	// 이모션
	CHAT_GM					= 6,	// GM 메시지(색상 분리를 위해)
	CHAT_GM_WHISPER			= 7,	// GM 귓말 메시지(색상 분리를 위해)
	CHAT_PARTY				= 10,	// 파티
	CHAT_GUILD				= 11,	// 길드
	CHAT_ATTACKTEAM			= 12,	// 동맹(시즈 공대)
	CHAT_FRIEND				= 13,	// 친구
	CHAT_NOTICE				= 20,	// 공지
	CHAT_ANNOUNCE			= 21,	// 알림 This is the green one if that's what you want
	CHAT_CENTER_NOTICE		= 22,	// 중앙 공지(UI 팀에서 추가한 화면 중앙 상단에 위치한 별도의 공지 공간에 출력됨)
	CHAT_EXP				= 30,	// 경험치 관련
	CHAT_DAMAGE				= 31,	// 데미지	(공격&마법데미지양)
	CHAT_ITEM				= 32,	// 아이템 관련
	CHAT_BATTLE				= 33,	// 전투관련
	CHAT_SUMMON				= 34,	// 소환수 관련
	CHAT_ETC				= 35,	// 기타
	CHAT_TITLE				= 36,	// 호칭
	CHAT_NPC				= 40,	// NPC 메시지
	CHAT_DEBUG				= 50,	// 디버그 메시지 (개발용. 콘솔에 출력)

	CHAT_PARTY_SYSTEM			= 100,	// 파티 시스템 메시지
	CHAT_GUILD_SYSTEM			= 110,	// 길드 시스템 메시지
	CHAT_QUEST_SYSTEM			= 120,	// 퀘스트 메시지
	CHAT_RAID_SYSTEM			= 130,	// 레이드 시스템 메시지
	CHAT_FRIEND_SYSTEM			= 140,	// 친구 시스템 메시지
	CHAT_ALLIANCE_SYSTEM		= 150,	// 길드 연합 시스템 메시지
	CHAT_HUNTAHOLIC_SYSTEM		= 160,	// 헌터홀릭 시스템 메시지
	CHAT_DUNGEON_SYSTEM			= 170,	// 인스턴스 던전 시스템 메시지

	//AziaMafia Tchat Helper
	CHAT_HELPER = 56,
	CHAT_HELPER_WHISPER = 57,
};

struct TS_SC_CHAT			: TS_MESSAGE
{
	TS_SC_CHAT()			_INIT( TM_SC_CHAT )

	char			szSender[21];

	unsigned short	len;
	unsigned char	type;
};

struct TS_CS_CHAT_REQUEST			: TS_MESSAGE
{
	TS_CS_CHAT_REQUEST()			_INIT( TM_CS_CHAT_REQUEST )

	char			szTarget[21];

	unsigned char	request_id;
	unsigned char	len;
	unsigned char	type;
};

struct TS_SC_STAT_INFO				: TS_MESSAGE
{
	TS_SC_STAT_INFO()				_INIT( TM_SC_STAT_INFO )

	AR_HANDLE				handle;

	CreatureStat			stat;
	CreatureAttribute		attribute;

	enum
	{
		TOTAL	= 0,
		BY_ITEM	= 1,
	};

	unsigned char	type;
};

struct TS_SC_REGEN_INFO				: TS_MESSAGE
{
	TS_SC_REGEN_INFO()				_INIT( TM_SC_REGEN_INFO )

	AR_HANDLE		handle;
	short			hp_regen_percentage;
	int				hp_regen_point;
	short			mp_regen_percentage;
	int				mp_regen_point;
};

struct TS_CS_CANCEL_ACTION		: TS_MESSAGE
{
	TS_CS_CANCEL_ACTION()		_INIT( TM_CS_CANCEL_ACTION )

	AR_HANDLE		handle;
};

struct TS_CS_SKILL				: TS_MESSAGE
{
	TS_CS_SKILL()				_INIT( TM_CS_SKILL )

	int						skill_id;

	AR_HANDLE				caster;
	AR_HANDLE				target;

	AR_UNIT					x,y,z;
	unsigned char			layer;
/*
	enum
	{
		CASTING = 1,
		CANCEL	= 2,
	};
	char					type;
*/
	char					skill_level;
};
/*
struct TS_SC_SKILL_CASTING_TIME	: TS_MESSAGE
{
	TS_SC_SKILL_CASTING_TIME()				_INIT( TM_SC_SKILL_CASTING_TIME )

	AR_HANDLE				caster;
	AR_TIME					tm;
};
*/


struct TS_SC_SKILL				: TS_MESSAGE
{
	TS_SC_SKILL()				_INIT( TM_SC_SKILL )	

	int						skill_id;

	char					skill_level;

	AR_HANDLE				caster;
	AR_HANDLE				target;

	AR_UNIT					x,y,z;
	unsigned char			layer;

	char					type;

	int						hp_cost;
	int						mp_cost;

	int						caster_hp;
	int						caster_mp;

	enum
	{
		FIRE	= 0,
		CASTING = 1,
		CASTING_UPDATE = 2,
		CANCEL	= 3,
		REGION_FIRE = 4,	// 지역 스킬의 fire
		COMPLETE = 5,
	};

	struct CancelType
	{
		// 내용 없음
	};

	struct CompleteType
	{
		// 내용 없음
	};

	struct CastType				// Casting 이거나 Casting_update일 경우 날아감.
	{
		AR_TIME					tm;			// 캐스팅 타임
		unsigned short			nErrorCode;	// 성공 여부 ( 0이면 성공 )
	};

	struct FireType				// Region Fire일 경우에도 얘가 날아감.
	{
		bool					bMultiple;
		AR_UNIT					range;			// 스킬 효과 범위

		unsigned char			target_count;
		unsigned char			fire_count;
		unsigned short			count;
	};

	union
	{
		CancelType				cancel;
		CompleteType			complete;
		CastType				cast;
		FireType				fire;
	};
	// Fire나 Region Fire일 경우 추가로 뒤에 SkillResult 가 count 만큼 따라간다
};

struct TS_SC_AURA				: TS_MESSAGE
{
	TS_SC_AURA()						_INIT( TM_SC_AURA )

	AR_HANDLE			caster;

	int					skill_id;
	bool				status;
};

struct TS_CS_REQUEST_REMOVE_STATE	: TS_MESSAGE
{
	TS_CS_REQUEST_REMOVE_STATE()		_INIT( TM_CS_REQUEST_REMOVE_STATE )

	AR_HANDLE			target;

	int					state_code;
};

struct TS_CS_SUMMON_CARD_SKILL_LIST	: TS_MESSAGE
{
	TS_CS_SUMMON_CARD_SKILL_LIST()			_INIT( TM_CS_SUMMON_CARD_SKILL_LIST )

	AR_HANDLE			item_handle;
};

struct TS_SC_SKILL_LEVEL_LIST	: TS_MESSAGE
{
	TS_SC_SKILL_LEVEL_LIST()		_INIT( TM_SC_SKILL_LEVEL_LIST )

	struct SkillLevelInfo
	{
		int				skill_id;
		unsigned char	skill_level;
	};

	unsigned short		count;
};

struct TS_SC_SKILL_EFFECT		: TS_MESSAGE
{
	TS_SC_SKILL_EFFECT()				_INIT( TM_SC_SKILL_EFFECT )

	AR_HANDLE			caster;
	AR_HANDLE			target;

	int			  skill_id;
	unsigned char skill_level;
	
	int var1;				// Damage 양
	unsigned char var2;		// HP Percentage
	char var3;				// Flag
};

// 라크 갱신도 같이 처리
struct TS_SC_GOLD_UPDATE		: TS_MESSAGE
{
	TS_SC_GOLD_UPDATE()				_INIT( TM_SC_GOLD_UPDATE )

	__int64					gold;
	int						chaos;
};

struct TS_SC_EXP_UPDATE		: TS_MESSAGE
{
	TS_SC_EXP_UPDATE()				_INIT( TM_SC_EXP_UPDATE )

	AR_HANDLE				handle;

	__int64					exp;
	__int64					jp;
};

struct TS_SC_BONUS_EXP_JP	: TS_MESSAGE
{
	TS_SC_BONUS_EXP_JP()				_INIT( TM_SC_BONUS_EXP_JP )

	AR_HANDLE				handle;

	unsigned short			count;

	struct BONUS_INFO
	{
		int				type;	// 보너스 종류
		int				rate;	// 보너스 비율(메시지 출력용)
		__int64			exp;	// 보너스 경험치
		__int64			jp;		// 보너스 JP
	};

	// 이 뒤로 count개 만큼의 BONUS_INFO가 붙어서 감
};

struct TS_SC_DETECT_RANGE_UPDATE	: TS_MESSAGE
{
	TS_SC_DETECT_RANGE_UPDATE()		_INIT( TM_SC_DETECT_RANGE_UPDATE )

	AR_HANDLE				handle;

	AR_UNIT					detect_range;
};

struct TS_SC_LEVEL_UPDATE		: TS_MESSAGE
{
	TS_SC_LEVEL_UPDATE()				_INIT( TM_SC_LEVEL_UPDATE )

	AR_HANDLE				handle;

	int						level;
	int						job_level;
};

/////////////////////////////////////////////////////////////////////////////
//  로비에서 쓰기 위한것들

struct MODEL_INFO
{
	int				sex;
	int				race;
	int				model_id[5];
	int				hair_color_index;
	unsigned int	hair_color_rgb;
	unsigned int	hide_equip_flag;
	int				texture_id;
	int				wear_info[ItemBase::MAX_ITEM_WEAR];
};

struct LOBBY_CHARACTER_INFO : MODEL_INFO
{
	int					level;
	int					job;
	int					job_level;
	int					exp_percentage;	// ( 0 ~ 100 )
	int					hp;
	int					mp;
	int					permission;
	bool				is_banned;
	char				name[19];
	unsigned long		skin_color;
	char				szCreateTime[30];
	char				szDeleteTime[30];
	int					wear_item_enhance_info[ItemBase::MAX_ITEM_WEAR];
	int					wear_item_level_info[ItemBase::MAX_ITEM_WEAR];
	char				wear_item_elemental_type[ItemBase::MAX_ITEM_WEAR];
	ItemBase::ItemCode	wear_appearance_code[ItemBase::MAX_ITEM_WEAR];
};


struct TS_CS_CHARACTER_LIST : TS_MESSAGE
{
	TS_CS_CHARACTER_LIST()			_INIT( TM_CS_CHARACTER_LIST )

	char			account[GameRule::MAX_ACCOUNT_LEN + 1];
};

struct TS_CS_CHECK_CHARACTER_NAME : TS_MESSAGE
{
	TS_CS_CHECK_CHARACTER_NAME()	_INIT( TM_CS_CHECK_CHARACTER_NAME )

	char			name[19];
};

struct TS_CS_CHANGE_ALIAS : TS_MESSAGE
{
	TS_CS_CHANGE_ALIAS()			_INIT( TM_CS_CHANGE_ALIAS )

	char			alias[ 19 ];
};

struct TS_CS_CREATE_CHARACTER : TS_MESSAGE
{
	TS_CS_CREATE_CHARACTER()		_INIT( TM_CS_CREATE_CHARACTER )

	LOBBY_CHARACTER_INFO		info;
};

struct TS_CS_DELETE_CHARACTER : TS_MESSAGE
{
	TS_CS_DELETE_CHARACTER()		_INIT( TM_CS_DELETE_CHARACTER )

	char		name[19];
};

struct TS_SC_CHARACTER_LIST : TS_MESSAGE
{
	TS_SC_CHARACTER_LIST()			_INIT( TM_SC_CHARACTER_LIST )
	
	unsigned int		current_server_time;	// 1970년 1월 1일 0시 0분 0초로부터 몇초가 경과되었는지를 알려줌.
												// ( CRT 의 time() 리턴값임)
	unsigned short		last_login_index;

	unsigned short		count;

	// 이하 LOBBY_CHARACTER_INFO 가 count 만큼 붙게됨
};

struct TS_CS_ACCOUNT_WITH_AUTH : TS_MESSAGE
{
	TS_CS_ACCOUNT_WITH_AUTH()			_INIT( TM_CS_ACCOUNT_WITH_AUTH )

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
	__int64		one_time_key;
};

// NPC 다이얼로그
struct TS_SC_DIALOG : TS_MESSAGE
{
	TS_SC_DIALOG()				_INIT( TM_SC_DIALOG )

	enum DIALOG_TYPE
	{
		TYPE_NPC									= 0,
		TYPE_DUNGEON_STONE							= 1,
		TYPE_DONATION_PROP							= 2,
		TYPE_QUEST_INFO_AND_START					= 3,
		TYPE_AUCTION_WINDOW							= 4,
		TYPE_HUNTAHOLIC_LOBBY						= 5,
		TYPE_DONATION_REWARD_NOTIFY					= 6,
		TYPE_QUEST_INFO_IN_PROGRESS					= 7,
		TYPE_QUEST_INFO_AND_END						= 8,
		TYPE_CREATURE_FARM_WINDOW					= 9,
		TYPE_OTHER_INSTANCE_DUNGEON_CONFIRM_WINDOW	= 10,
	};

	int							type;

	AR_HANDLE					npc_handle;	// NULL 일수도 있음.

	// 만약 length가 모두 0일경우는 열려 있던 다이얼로그를 닫을것.
	unsigned short				title_length;
	unsigned short				text_length;
	unsigned short				menu_length;

	// 이하 다이얼로그 정보가 text string 으로 붙게됨. 메뉴는   |문자열|트리거|  의 형식으로 붙게 된다.
	/*

	 +-----------------------+   title_length : 6
	 |        경비병         |   text_length  : 20
	 +-----------------------+   menu_length  : 41
	 |                       |
	 | 위험하니 돌아가세요.  |   data : 경비병위험하니 돌아가세요.|예|on_click_yes()||아니오|on_click_no()|
	 |                       |
	 |                       |
	 |         [예] [아니오] |
	 +-----------------------+
	*/

};

// 다이얼로그 메뉴 클릭 결과를 전송한다. 이 헤더 이후에 스트링이 따라 붙어 오게 된다.
struct TS_CS_DIALOG : TS_MESSAGE
{
	TS_CS_DIALOG()					_INIT( TM_CS_DIALOG )

	unsigned short				trigger_length;
};

// 프랍이나 NPC 를 클릭했을때 서버로 보낸다. 결과로는 TS_SC_DIALOG 나 기타등등의 메시지가 갈 수 있다.
struct TS_CS_CONTACT : TS_MESSAGE
{
	TS_CS_CONTACT()					_INIT( TM_CS_CONTACT )

	AR_HANDLE					handle;
};

// 특수 다이얼로그 처리
struct TS_SC_SHOW_WINDOW			: TS_MESSAGE
{
	TS_SC_SHOW_WINDOW()			_INIT( TM_SC_SHOW_WINDOW )

	unsigned short				window_length;
	unsigned short				argument_length;
	unsigned short				trigger_length;
};

// 메시지 박스 처리
struct TS_SC_GENERAL_MESSAGE_BOX	: TS_MESSAGE
{
	TS_SC_GENERAL_MESSAGE_BOX()	_INIT( TM_SC_GENERAL_MESSAGE_BOX )

	unsigned short				text_length;
};

struct TS_SC_NPC_TRADE_INFO	: TS_MESSAGE
{
	TS_SC_NPC_TRADE_INFO()		_INIT( TM_SC_NPC_TRADE_INFO )

	bool				is_sell;
	ItemBase::ItemCode	code;
	__int64				count;
	__int64				price;
	int					huntaholic_point;
	int					arena_point;

	AR_HANDLE			target;
};

struct TS_SC_MARKET : TS_MESSAGE
{
	struct ItemInfo
	{
		ItemBase::ItemCode	code;				// 상점 물품 아이템 코드
		__int64				price;				// 상점 판매가 - 루피(플레이어 입장 구매가)
		int					huntaholic_point;	// 상점 판매가 - 헌터홀릭 포인트(플레이어 입장 구매가)
		int					arena_point;		// 상점 판매가 - 아레나 포인트(플레이어 입장 구매가)
	};

	TS_SC_MARKET()				_INIT( TM_SC_MARKET )

	AR_HANDLE					npc_handle;

	unsigned short				item_count;
};

struct TS_CS_BUY_ITEM : TS_MESSAGE
{
	TS_CS_BUY_ITEM()			_INIT( TM_CS_BUY_ITEM )

	ItemBase::ItemCode		item_code;
	unsigned short			buy_count;
};


struct TS_CS_SELL_ITEM : TS_MESSAGE
{
	TS_CS_SELL_ITEM()			_INIT( TM_CS_SELL_ITEM )

	AR_HANDLE	handle;
	__int64		sell_count;
};

struct TS_CS_DONATE_ITEM : TS_MESSAGE
{
	struct DonateItemInfo
	{
		AR_HANDLE		handle;
		__int64			count;
	};

	TS_CS_DONATE_ITEM()			_INIT( TM_CS_DONATE_ITEM )

	__int64					gold;
	int						jp;
	unsigned char			item_count;

	// 이 뒤로 DonateItemInfo가 item_count 개수만큼 붙음
};

struct TS_CS_DONATE_REWARD : TS_MESSAGE
{
	TS_CS_DONATE_REWARD()		_INIT( TM_CS_DONATE_REWARD )

	struct RewardInfo
	{
		unsigned char			reward_type;
		unsigned short			count;
	};

	unsigned char		reward_count;
	// 이 뒤로 reward_count개 만큼의 RewardInfo가 붙어서 옴
};

struct TS_SC_SHOW_SOULSTONE_CRAFT_WINDOW : TS_MESSAGE
{
	TS_SC_SHOW_SOULSTONE_CRAFT_WINDOW()	_INIT( TM_SC_SHOW_SOULSTONE_CRAFT_WINDOW );
};

struct TS_CS_SOULSTONE_CRAFT : TS_MESSAGE
{
	TS_CS_SOULSTONE_CRAFT()		_INIT( TM_CS_SOULSTONE_CRAFT );

	AR_HANDLE				craft_item_handle;

	enum
	{
		MAX_SOULSTONE_NUM		= 8, //4
	};

	AR_HANDLE				soulstone_handle[ MAX_SOULSTONE_NUM ];
};

struct TS_SC_SHOW_SOULSTONE_REPAIR_WINDOW : TS_MESSAGE
{
	TS_SC_SHOW_SOULSTONE_REPAIR_WINDOW()	_INIT( TM_SC_SHOW_SOULSTONE_REPAIR_WINDOW );
};

struct TS_CS_REPAIR_SOULSTONE : TS_MESSAGE
{
	TS_CS_REPAIR_SOULSTONE()				_INIT( TM_CS_REPAIR_SOULSTONE );

	enum
	{
		MAX_REPAIR_COUNT		= 6,
	};
	
	AR_HANDLE				item_handle[ MAX_REPAIR_COUNT ];
};

struct TS_CS_TRANSMIT_ETHEREAL_DURABILITY : TS_MESSAGE
{
	TS_CS_TRANSMIT_ETHEREAL_DURABILITY()	_INIT( TM_CS_TRANSMIT_ETHEREAL_DURABILITY );

	AR_HANDLE	handle;
};

struct TS_CS_TRANSMIT_ETHEREAL_DURABILITY_TO_EQUIPMENT : TS_MESSAGE
{
	TS_CS_TRANSMIT_ETHEREAL_DURABILITY_TO_EQUIPMENT()	_INIT( TM_CS_TRANSMIT_ETHEREAL_DURABILITY_TO_EQUIPMENT );

	float	rate;
	char	target;
};

struct TS_CS_USE_ITEM : TS_MESSAGE
{
	TS_CS_USE_ITEM()			_INIT( TM_CS_USE_ITEM )

	AR_HANDLE				item_handle;
	AR_HANDLE				target_handle;	// 혼자 쓰는거라면 0
	char					szParameter[32];
};

struct TS_SC_USE_ITEM_RESULT : TS_MESSAGE
{
	TS_SC_USE_ITEM_RESULT()			_INIT( TM_SC_USE_ITEM_RESULT )

	AR_HANDLE				item_handle;
	AR_HANDLE				target_handle;
};


struct TS_SC_DESTROY_ITEM : TS_MESSAGE
{
	TS_SC_DESTROY_ITEM()			_INIT( TM_SC_DESTROY_ITEM )

	AR_HANDLE				item_handle;
};

struct TS_SC_UPDATE_ITEM_COUNT : TS_MESSAGE
{
	TS_SC_UPDATE_ITEM_COUNT()			_INIT( TM_SC_UPDATE_ITEM_COUNT )

	AR_HANDLE				item_handle;
	__int64					count;
};


struct TS_TRADE	: TS_MESSAGE
{
	TS_TRADE()					_INIT( TM_TRADE )

	enum {
		REQUEST_TRADE = 0,			// 트레이드 요청을 시작한다
		ACCEPT_TRADE  = 1,			// 트레이드 요청을 수락한다
		BEGIN_TRADE	  = 2,			// 트레이드 시작
		CANCEL_TRADE  = 3,			// 트레이드 취소
		REJECT_TRADE  = 4,			// 트레이드 거부
		ADD_ITEM	  = 5,			// 아이템을 올린다.
		ADD_GOLD	  = 6,			// 돈을 올린다. 돈을 올릴때는 item_info 를 모두 0 으로 채우고 count 만 액수로 설정한다.
		FREEZE_TRADE  = 7,			// 확인버튼을 누른다.
		CONFIRM_TRADE = 8,			// 최종결정 버튼을 누른다.
		PROCESS_TRADE = 9,			// 거래 완료
		REMOVE_ITEM	  = 10,			// 아이템을 내린다(확인 버튼 누르기 이전에 아이템 올릴 수 있을 때만 가능)
		MODIFY_COUNT  = 11,			// 아이템 수량을 바꾼다
	};

	/* 트레이드 진행 순서의 예

	   . 트레이드 요청하는이를 A, 대상을 B 라고 한다.
	 
	 1. A 가 B 의 핸들을 적어 서버에게 REQUEST_TRADE 를 보낸다. 
	 2. B 에게는 REQUEST_TRADE 메시지가 도착한다. 
	 3. 만약 B 가 거부하려면 서버에게 REJECT_TRADE 메시지를 보낸다. 그러면 A 에게 REJECT_TRADE 메시지가 전달됨.
	 4. 만약 B 가 승락하려면 서버에게 ACCEPT_TRADE 메시지를 보낸다. 그러면 A 와 B 에게 BEGIN_TRADE 메시지가 전달됨.
     5. 이후 아이템이나 돈을 올려 놓으려면 서버에게 ADD_ITEM 이나 ADD_GOLD 메시지를 보낸다. 그러면 A 와 B 에게 해당 메시지가 전달됨.
	 6. 만약 중도에 트레이드를 취소하려면 서버에 CANCEL_TRADE 버튼을 누른다. 그러면 A 와 B 에게 CANCEL_TRADE 메시지가 전달됨.
	 7. 확인 버튼을 누르려면 서버에게 FREEZE_TRADE 메시지를 보낸다. 그러면 A 와 B 에게 FREEZE_TRADE 메시지가 전달됨.
	 8. 둘다 확인버튼을 누른 상태에서 또 둘다 CONFIRM_TRADE 메시지를 보내면 트레이드가 성사된다. 
	    A 와 B 에게 PROCESS_TRADE 가 전송되며 바뀐 인벤 데이터와 금액 데이터는 다른 메시지로 전송된다.

	*/


	AR_HANDLE			target_player;
	char				mode;
	TS_ITEM_INFO		item_info;
};

struct TS_SC_SKILL_LIST	: TS_MESSAGE
{
	TS_SC_SKILL_LIST()		_INIT( TM_SC_SKILL_LIST );

	struct SkillInfo
	{
		int				skill_id;
		unsigned char	base_skill_level;
		unsigned char	current_skill_level;
		AR_TIME			total_cool_time;
		AR_TIME			remain_cool_time;
	};

	AR_HANDLE			target;	// 플레이어 혹은 크리쳐
	unsigned short		count;
	unsigned char		modification_type; // enum ModificationType

	// 이후 따라오는 스킬 리스트가 어떤 의미를 가지는가를 의미하는 열거형
	enum ModificationType
	{		
		UPDATE	= 0,	// 스킬이 업데이트됨
		REFRESH	= 1,	// 스킬 리스트를 갱신
	};

	// 이후 count만큼의 SkillInfo가 따라옴
};

// 스킬 레벨의 변동이 발생
struct TS_SC_ADDED_SKILL_LIST : TS_MESSAGE
{
	TS_SC_ADDED_SKILL_LIST()	_INIT( TM_SC_ADDED_SKILL_LIST );

	struct AddedSkillInfo
	{

		int skill_id;	// 스킬 ID
		bool restricted_to_type;
		char added_skill_level;
	};

	AR_HANDLE			target;
	unsigned short		count;
};

// 스킬을 배우거나, 스킬레벨을 올린다.
struct TS_CS_LEARN_SKILL : TS_MESSAGE
{
	TS_CS_LEARN_SKILL()		_INIT( TM_CS_LEARN_SKILL )

	AR_HANDLE			target;				// 자기 자신 혹은 자신의 크리쳐
	int					skill_id;			// 배우려는 목표 스킬 ID
	int					original_skill_id;	// 랜덤 스킬로 찍혔을 때 원본 랜덤 스킬 ID(껍데기스킬), 아니면 0
	short				skill_level;		// 배울 스킬 레벨
};

// 잡레벨을 올린다 (1씩)
struct TS_CS_JOB_LEVEL_UP : TS_MESSAGE
{
	TS_CS_JOB_LEVEL_UP()		_INIT( TM_CS_JOB_LEVEL_UP )

	AR_HANDLE			target;	// 자기 자신 혹은 자신의 크리쳐
};



//////////////////////////////////////////////////////////////////////////////
// 이하 소환수

struct TS_SC_SUMMON_EVOLUTION		: TS_MESSAGE
{
	TS_SC_SUMMON_EVOLUTION()		_INIT( TM_SC_SUMMON_EVOLUTION )

	AR_HANDLE				card_handle;
	AR_HANDLE				summon_handle;

	char					name[19];
	int						code;
};

struct TS_SC_ADD_SUMMON_INFO			: TS_MESSAGE
{
	TS_SC_ADD_SUMMON_INFO()			_INIT( TM_SC_ADD_SUMMON_INFO )

	AR_HANDLE				card_handle;
	AR_HANDLE				summon_handle;
	
	char					name[19];
	int						code;
	
	// 이하 정보 필요
	int						level;
	int						sp;
};

struct TS_SC_REMOVE_SUMMON_INFO			: TS_MESSAGE
{
	TS_SC_REMOVE_SUMMON_INFO()		_INIT( TM_SC_REMOVE_SUMMON_INFO )

	AR_HANDLE				card_handle;
};

struct TS_EQUIP_SUMMON		: TS_MESSAGE
{
	TS_EQUIP_SUMMON()			_INIT( TM_EQUIP_SUMMON )

	bool				open_dialog;
	AR_HANDLE			card_handle[ 6 ];
};

struct TS_CS_SUMMON		: TS_MESSAGE
{
	TS_CS_SUMMON()			_INIT( TM_CS_SUMMON )

	unsigned char		is_summon;	// 1이면 소환, 0이면 역소환
	AR_HANDLE			card_handle;
};

struct TS_SC_UNSUMMON_NOTICE	: TS_MESSAGE
{
	TS_SC_UNSUMMON_NOTICE()			_INIT( TM_SC_UNSUMMON_NOTICE )

	AR_HANDLE			summon_handle;
	AR_TIME				unsummon_duration;
};

struct TS_SC_UNSUMMON		: TS_MESSAGE
{
	TS_SC_UNSUMMON()			_INIT( TM_SC_UNSUMMON )

	AR_HANDLE			summon_handle;
};

struct TS_SC_ITEM_DROP_INFO	: TS_MESSAGE // Broadcast only
{
	TS_SC_ITEM_DROP_INFO()			_INIT( TM_SC_ITEM_DROP_INFO )

	AR_HANDLE			monster_handle;
	AR_HANDLE			item_handle;
};

struct TS_SC_QUEST_LIST : TS_MESSAGE
{
	enum
	{
		MAX_VALUE		= 6,
	};

	struct TS_QUEST_INFO
	{
		QuestBase::QuestCode	code;
		int						nStartID;
		int						nValue[MAX_VALUE];
		int						nStatus[QuestInstance::MAX_STATUS];
		unsigned char			nProgress;
		AR_TIME					nTimeLimit;
	};

	struct TS_PENDING_QUEST_INFO
	{
		QuestBase::QuestCode	code;
		int						nStartID;
	};

	TS_SC_QUEST_LIST()				_INIT( TM_SC_QUEST_LIST )

	unsigned short	count_active;
	unsigned short	count_pending;

	// 이하 TS_QUEST_INFO가 count_active만큼 붙고 그 뒤로 TS_PENDING_QUEST_INFO가 count_pending만큼 붙게 됨.
};

struct TS_SC_QUEST_STATUS : TS_MESSAGE
{
	TS_SC_QUEST_STATUS()	_INIT( TM_SC_QUEST_STATUS )

	QuestBase::QuestCode	code;
	int						nStatus[QuestInstance::MAX_STATUS];
	unsigned char			nProgress;
	AR_TIME					nTimeLimit;
};

struct TS_SC_QUEST_INFOMATION : TS_MESSAGE
{
	enum QUEST_PROGRESS
	{
		IS_STARTABLE		= 0,
		IS_IN_PROGRESS		= 1,
		IS_FINISHABLE		= 2,
	};

	TS_SC_QUEST_INFOMATION()	_INIT( TM_SC_QUEST_INFOMATION )

	QuestBase::QuestCode	code;
	QUEST_PROGRESS			nProgress;
	unsigned short			trigger_length;
};

struct TS_CS_DROP_QUEST	: TS_MESSAGE
{
	TS_CS_DROP_QUEST()	_INIT( TM_CS_DROP_QUEST )

	QuestBase::QuestCode	code;
};

struct TS_CS_QUEST_INFO : TS_MESSAGE
{
	TS_CS_QUEST_INFO()				_INIT( TM_CS_QUEST_INFO )

	QuestBase::QuestCode	code;
};

struct TS_CS_END_QUEST : TS_MESSAGE
{
	TS_CS_END_QUEST()	_INIT( TM_CS_END_QUEST )

	QuestBase::QuestCode	code;
	unsigned char			nOptionalReward;
};

struct TS_SC_TITLE_LIST : TS_MESSAGE
{
	struct TS_TITLE_INFO
	{
		int	code;
		int	status;
	};

	TS_SC_TITLE_LIST()				_INIT( TM_SC_TITLE_LIST )

	unsigned short	count;
	// 이하 TS_TITLE_INFO가 count만큼 붙는다.
};

struct TS_SC_TITLE_CONDITION_LIST : TS_MESSAGE
{
	struct TS_TITLE_CONDITION_INFO
	{
		int type;
		__int64 count;
	};

	TS_SC_TITLE_CONDITION_LIST()	_INIT( TM_SC_TITLE_CONDITION_LIST )

	unsigned short	count;
	// 이하 TS_TITLE_CONDITION_INFO가 count만큼 붙는다.
};

struct TS_SC_REMAIN_TITLE_TIME : TS_MESSAGE
{
	TS_SC_REMAIN_TITLE_TIME()		_INIT( TM_SC_REMAIN_TITLE_TIME )

	AR_TIME remain_title_time;
};

struct TS_CS_SET_MAIN_TITLE : TS_MESSAGE
{
	TS_CS_SET_MAIN_TITLE()	_INIT( TM_CS_SET_MAIN_TITLE )

	int code;
};

struct TS_SC_SET_MAIN_TITLE : TS_MESSAGE
{
	TS_SC_SET_MAIN_TITLE()	_INIT( TM_SC_SET_MAIN_TITLE )

	int handle;
	int code;
};

struct TS_CS_SET_SUB_TITLE : TS_MESSAGE
{
	TS_CS_SET_SUB_TITLE()	_INIT( TM_CS_SET_SUB_TITLE )

	int index;
	int code;
};

struct TS_SC_SET_SUB_TITLE : TS_MESSAGE
{
	TS_SC_SET_SUB_TITLE()	_INIT( TM_SC_SET_SUB_TITLE )

	int index;
	int code;
};

struct TS_CS_BOOKMARK_TITLE : TS_MESSAGE
{
	TS_CS_BOOKMARK_TITLE()	_INIT( TM_CS_BOOKMARK_TITLE )

	int code;
};

struct TS_SC_BOOKMARK_TITLE : TS_MESSAGE
{
	TS_SC_BOOKMARK_TITLE()	_INIT( TM_SC_BOOKMARK_TITLE )

	int code;
	bool bookmarked;
};

struct TS_SC_ACHIEVE_TITLE : TS_MESSAGE
{
	TS_SC_ACHIEVE_TITLE()	_INIT( TM_SC_ACHIEVE_TITLE )

	int code;
};

struct TS_SC_OPEN_TITLE : TS_MESSAGE
{
	TS_SC_OPEN_TITLE()	_INIT( TM_SC_OPEN_TITLE )

	int code;
};

struct TS_SC_CHANGE_TITLE_CONDITION : TS_MESSAGE
{
	TS_SC_CHANGE_TITLE_CONDITION()	_INIT( TM_SC_CHANGE_TITLE_CONDITION )

	int condition_id;
	__int64 count;
};

struct TS_CS_RETURN_LOBBY : TS_MESSAGE
{
	TS_CS_RETURN_LOBBY()	_INIT( TM_CS_RETURN_LOBBY )
};

struct TS_CS_REQUEST_RETURN_LOBBY : TS_MESSAGE
{
	TS_CS_REQUEST_RETURN_LOBBY()	_INIT( TM_CS_REQUEST_RETURN_LOBBY )
};

struct TS_CS_REQUEST_LOGOUT : TS_MESSAGE
{
	TS_CS_REQUEST_LOGOUT()	_INIT( TM_CS_REQUEST_LOGOUT )
};

struct TS_CS_LOGOUT : TS_MESSAGE
{
	TS_CS_LOGOUT()	_INIT( TM_CS_LOGOUT )
};

struct TS_SC_DISCONNECT_DESC : TS_MESSAGE
{
	TS_SC_DISCONNECT_DESC()		_INIT( TM_SC_DISCONNECT_DESC )

	enum _DISCONNECT_TYPE
	{
		// { TS_AG_KICK_CLIENT::_KICK_TYPE
		DISCONNECT_TYPE_ANOTHER_LOGIN		= 0,	// 다른 유저의 접속으로 인한 접속 종료
		DISCONNECT_TYPE_DUPLICATED_LOGIN	= 1,	// 인증 서버에서 게임 서버 로그인 처리 시 중복된 로그인 감지로 인한 접속 종료(내부 오류 또는 해킹에 의한 발생)
		DISCONNECT_TYPE_BILLING_EXPIRED		= 2,	// 결재 정보 만료로 인한 접속 종료
		DISCONNECT_TYPE_GAME_ADDICTION		= 3,	// 게임 중독 방지로 인한 접속 종료
		// } TS_AG_KICK_CLIENT::_KICK_TYPE

		DISCONNECT_TYPE_DB_ERROR			= 100,	// DB 오류로 인한 예외 처리로 인한 접속 종료
		DISCONNECT_TYPE_ANTI_HACK			= 101,	// 게임 보안 솔루션 오류로 인한 접속 종료
		DISCONNECT_TYPE_SCRIPT				= 102,	// 스크립트 명령어(SCRIPT_Kick)으로 인한 접속 종료
	};

	char		desc_id;
};

struct TS_CS_START_BOOTH : TS_MESSAGE
{
	struct TS_BOOTH_OPEN_ITEM_INFO
	{
		AR_HANDLE		item_handle;
		int				cnt;
		__int64			gold;
	};

	TS_CS_START_BOOTH()		_INIT( TM_CS_START_BOOTH )
	
	char					name[49];
	char					type;			// If 1 → Selling booth, If 2 → Buying booth

	unsigned short			cnt;


	// After this, TS_BOOTH_ITEM_OPEN_INFO structures follow,
	// as many times as the value of CNT.
};

struct TS_CS_STOP_BOOTH : TS_MESSAGE
{
	TS_CS_STOP_BOOTH()		_INIT( TM_CS_STOP_BOOTH )
};

struct TS_CS_WATCH_BOOTH : TS_MESSAGE
{
	TS_CS_WATCH_BOOTH()		_INIT( TM_CS_WATCH_BOOTH )

	AR_HANDLE	target;			// 보고 싶은 사용자
};

struct TS_SC_WATCH_BOOTH : TS_MESSAGE
{
	struct TS_BOOTH_ITEM_INFO : TS_ITEM_BASE_INFO
	{
		__int64			gold;
	};

	TS_SC_WATCH_BOOTH()		_INIT( TM_SC_WATCH_BOOTH )

	AR_HANDLE	target;			// 노점을 연 사용자
	char		type;			// 1이면 판매 부스. 2이면 구매 부스

	unsigned short cnt;			// 아이템 숫자

	// 아래로 TS_BOOTH_ITEM_INFO가 CNT만큼 붙게 됨
};

struct TS_CS_STOP_WATCH_BOOTH : TS_MESSAGE
{
	TS_CS_STOP_WATCH_BOOTH()		_INIT( TM_CS_STOP_WATCH_BOOTH )

	AR_HANDLE	target;			// 보고 싶은 사용자
};

struct TS_CS_BUY_FROM_BOOTH : TS_MESSAGE
{
	TS_CS_BUY_FROM_BOOTH()		_INIT( TM_CS_BUY_FROM_BOOTH )

	AR_HANDLE	target;			// 노점을 연 사용자
	short		cnt;

	// 이하 TS_ITEM_BASE_INFO	가 count만큼 들어감.
};

struct TS_BOOTH_TRADE_ITEM_INFO : TS_ITEM_BASE_INFO
{
	__int64		price;
};

struct TS_SC_BOOTH_TRADE_INFO : TS_MESSAGE
{
	TS_SC_BOOTH_TRADE_INFO()	_INIT( TM_SC_BOOTH_TRADE_INFO )

	AR_HANDLE	target;		// 거래가 이루어진 대상
	bool		is_sell;	// 판매인지 구매인지 여부. true이면 판매. false이면 구매.
	short		cnt;

	// 이하 TS_BOOTH_TRADE_ITEM_INFO 가 count만큼 들어감.
};

struct TS_CS_SELL_TO_BOOTH : TS_MESSAGE
{
	TS_CS_SELL_TO_BOOTH()		_INIT( TM_CS_SELL_TO_BOOTH )

	AR_HANDLE	target;			// 노점을 연 사용자
	AR_HANDLE	item_handle;	// 판매할 사용자의 아이템 핸들 (노점에 있는 아이템 핸들이 아님!)
	int			cnt; 
};

struct TS_CS_GET_BOOTHS_NAME : TS_MESSAGE
{
	TS_CS_GET_BOOTHS_NAME()		_INIT( TM_CS_GET_BOOTHS_NAME )

	unsigned	cnt;

	// 이하 cnt만큼의 AR_HANDLE(플레이어 핸들) 이 달려오게 된다.
};

struct TS_SC_GET_BOOTHS_NAME : TS_MESSAGE
{
	TS_SC_GET_BOOTHS_NAME()		_INIT( TM_SC_GET_BOOTHS_NAME )

	struct TS_BOOTH_NAME
	{
		AR_HANDLE	handle;
		char		name[49];
	};

	unsigned	cnt;

	// 이하 cnt만큼의 TS_BOOTH_NAME 이 달려오게 된다.
};

struct TS_SC_BOOTH_CLOSED : TS_MESSAGE
{
	TS_SC_BOOTH_CLOSED()		_INIT( TM_SC_BOOTH_CLOSED )

	AR_HANDLE	target;			// 노점을 연 사용자
};

struct TS_CS_CHECK_BOOTH_STARTABLE : TS_MESSAGE
{
	TS_CS_CHECK_BOOTH_STARTABLE()		_INIT( TM_CS_CHECK_BOOTH_STARTABLE )
};

struct TS_CS_TURN_ON_PK_MODE : TS_MESSAGE
{
	TS_CS_TURN_ON_PK_MODE()		_INIT( TM_CS_TURN_ON_PK_MODE )
};

struct TS_CS_TURN_OFF_PK_MODE : TS_MESSAGE
{
	TS_CS_TURN_OFF_PK_MODE()	_INIT( TM_CS_TURN_OFF_PK_MODE )
};

struct TS_CS_CHANGE_LOCATION : TS_MESSAGE
{
	TS_CS_CHANGE_LOCATION()	_INIT( TM_CS_CHANGE_LOCATION )

	AR_UNIT x;
	AR_UNIT y;
};

struct TS_SC_CHANGE_LOCATION : TS_MESSAGE
{
	TS_SC_CHANGE_LOCATION()	_INIT( TM_SC_CHANGE_LOCATION )

	int prev_location_id;
	int cur_location_id;
};

struct TS_CS_GET_WEATHER_INFO : TS_MESSAGE
{
	TS_CS_GET_WEATHER_INFO()	_INIT( TM_CS_GET_WEATHER_INFO )

	unsigned int	region_id;
};

struct TS_SC_WEATHER_INFO : TS_MESSAGE
{
	TS_SC_WEATHER_INFO()	_INIT( TM_SC_WEATHER_INFO )

	enum
	{
		CLEAR = 0, LIGHT_RAINY = 1, RAINY = 2, HEAVY_RAINY = 3, LIGHT_SNOWY = 4, SNOWY = 5, HEAVY_SNOWY = 6
	};

	unsigned int	region_id;
	unsigned short	weather_id;
};

struct TS_SC_EMOTION : TS_MESSAGE
{
	TS_SC_EMOTION()		_INIT( TM_SC_EMOTION )

	AR_HANDLE handle;
	int emotion;
};

struct TS_CS_EMOTION : TS_MESSAGE
{
	TS_CS_EMOTION()		_INIT( TM_CS_EMOTION )

	int emotion;
};

struct TS_CS_GAME_TIME : TS_MESSAGE
{
	TS_CS_GAME_TIME()	_INIT( TM_CS_GAME_TIME )
};

struct TS_SC_GAME_TIME : TS_MESSAGE
{
	TS_SC_GAME_TIME()	_INIT( TM_SC_GAME_TIME )

	AR_TIME	t;
	time_t game_time;
};

// 경매 데이터
struct TS_AUCTION_INFO
{
	enum AUCTION_DURATION_TYPE
	{
		DURATION_SHORTTERM		= 1,	// 마감 시한: 단기
		DURATION_MIDTERM		= 2,	// 마감 시한: 중기
		DURATION_LONGTERM		= 3		// 마감 시한: 장기
	};

	int					auction_uid;				// 경매 번호
	TS_ITEM_BASE_INFO	item_info;					// 아이템 정보

	unsigned char		duration_type;				// 마감 시한 타입(AUCTION_DURATION_TYPE 값이 들어감)
	__int64				bidded_price;				// 현재 입찰가
	__int64				instant_purchase_price;		// 즉시 구매가
};

// 경매 물품 검색 요청
struct TS_CS_AUCTION_SEARCH : TS_MESSAGE
{
	TS_CS_AUCTION_SEARCH()				_INIT( TM_CS_AUCTION_SEARCH )

	int		category_id;			// 검색 카테고리(-1: 전체 혹은 기타인데 sub_category_id에 의해 결정 / 0 이상: 상위 카테고리 번호)
	int		sub_category_id;		// 검색 카테고리(category_id가 -1인 경우: -1은 전체, 0은 기타 / 그외: -1은 상위 카테고리임, 0 이상: 하위 카테고리임)
	char	keyword[31];			// 검색 키워드(없으면 빈 문자열이면 됨)
	int		page_num;				// 요청 페이지 번호
	bool	is_equipable;			// 착용 가능한 장비 검색 여부
};

// 경매 물품 검색 결과
struct TS_SC_AUCTION_SEARCH : TS_MESSAGE
{
	TS_SC_AUCTION_SEARCH()				_INIT( TM_SC_AUCTION_SEARCH )

	struct SEARCHED_AUCTION_INFO : TS_AUCTION_INFO
	{
		char				seller_name[31];
		char				flag;

		enum SEARCHED_AUCTION_INFO_FLAG
		{
			FLAG_IS_HIGHEST_BIDDER		= 1 << 0,		// 자신이 최고 입찰자인지 여부
			FLAG_NO_OTHER_BIDDER		= 1 << 1		// 자신이 최초 입찰자인지 여부(현재 최고 입찰가로 입찰이 가능 - 5% 높은 가격 룰 제외됨)
		};
	};

	int						page_num;															// 현재 페이지 번호
	int						total_page_count;													// 전체 페이지 수
	int						auction_info_count;													// 현재 페이지에 해당하는 경매 데이터 수
	SEARCHED_AUCTION_INFO	auction_info[ GameRule::AUCTION_INFO_COUNT_PER_PAGE_FOR_SEARCHED ];	// 현재 페이지에 해당하는 경매 데이터
};

// 자신이 등록한 경매 물품 목록 요청
struct TS_CS_AUCTION_SELLING_LIST : TS_MESSAGE
{
	TS_CS_AUCTION_SELLING_LIST()		_INIT( TM_CS_AUCTION_SELLING_LIST )

	int			page_num;		// 요청 페이지 번호
};

// 자신이 등록한 경매 물품 목록 결과
struct TS_SC_AUCTION_SELLING_LIST : TS_MESSAGE
{
	TS_SC_AUCTION_SELLING_LIST()		_INIT( TM_SC_AUCTION_SELLING_LIST )

	struct REGISTERED_AUCTION_INFO : TS_AUCTION_INFO
	{
		enum REGISTERED_AUCTION_STATUS
		{
			STATUS_NO_BIDDER		= 1,	// 상태: 입찰자 없음
			STATUS_BID_CALLING		= 2		// 상태: 입찰 진행중
		};

		unsigned char		status;		// REGISTERED_AUCTION_STATUS 값이 들어감
	};

	int						page_num;																// 현재 페이지 번호
	int						total_page_count;														// 전체 페이지 수
	int						auction_info_count;														// 현재 페이지에 해당하는 경매 데이터 수
	REGISTERED_AUCTION_INFO	auction_info[ GameRule::AUCTION_INFO_COUNT_PER_PAGE_FOR_REGISTERED ];	// 현재 페이지에 해당하는 경매 데이터
};

// 자신이 입찰한 경매 목록 요청
struct TS_CS_AUCTION_BIDDED_LIST : TS_MESSAGE
{
	TS_CS_AUCTION_BIDDED_LIST()			_INIT( TM_CS_AUCTION_BIDDED_LIST )

	int			page_num;		// 요청 페이지 번호
};

// 자신이 입찰한 경매 목록 결과
struct TS_SC_AUCTION_BIDDED_LIST : TS_MESSAGE
{
	TS_SC_AUCTION_BIDDED_LIST()			_INIT( TM_SC_AUCTION_BIDDED_LIST )

	struct BIDDED_AUCTION_LIST : TS_AUCTION_INFO
	{
		enum BIDDED_AUCTION_STATUS
		{
			STATUS_MINE		= 1,	// 입찰 현황: 본인 입찰
			STATUS_OTHERS	= 2		// 입찰 현황: 타인 입찰
		};

		unsigned char		status;		// BIDDED_AUCTION_STATUS 값이 들어감
	};

	int						page_num;															// 현재 페이지 번호
	int						total_page_count;													// 전체 페이지 수
	int						auction_info_count;													// 현재 페이지에 해당하는 경매 데이터 수
	BIDDED_AUCTION_LIST		auction_info[ GameRule::AUCTION_INFO_COUNT_PER_PAGE_FOR_BIDDED ];	// 현재 페이지에 해당하는 경매 데이터
};

// 경매 입찰 요청
struct TS_CS_AUCTION_BID : TS_MESSAGE
{
	TS_CS_AUCTION_BID()					_INIT( TM_CS_AUCTION_BID )

	int			auction_uid;	// 입찰 대상 경매 번호
	__int64		bidding_price;	// 입찰 요청 가격
};

// 경매 물품 즉시구매 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
struct TS_CS_AUCTION_INSTANT_PURCHASE : TS_MESSAGE
{
	TS_CS_AUCTION_INSTANT_PURCHASE()	_INIT( TM_CS_AUCTION_INSTANT_PURCHASE )

	int			auction_uid;	// 즉시 구매 대상 경매 번호
};

// 경매 물품 등록 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
struct TS_CS_AUCTION_REGISTER : TS_MESSAGE
{
	TS_CS_AUCTION_REGISTER()			_INIT( TM_CS_AUCTION_REGISTER )

	enum AUCTION_DURATION_TYPE
	{
		DURATION_SHORTTERM		= 1,	// 경매 기간: 단기
		DURATION_MIDTERM		= 2,	// 경매 기간: 중기
		DURATION_LONGTERM		= 3		// 경매 기간: 장기
	};

	AR_HANDLE				item_handle;				// 경매 등록할 아이템 핸들
	int						item_count;					// 경매 등록할 아이템 수량
	__int64					start_price;				// 경매 시작가
	__int64					instant_purchase_price;		// 경매 물품 즉구가
	unsigned char			duration_type;				// Auction duration type (stores a value from AUCTION_DURATION_TYPE)
};

// 자신이 등록한 경매 취소 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
struct TS_CS_AUCTION_CANCEL : TS_MESSAGE
{
	TS_CS_AUCTION_CANCEL()				_INIT( TM_CS_AUCTION_CANCEL )

	int			auction_uid;	// 취소할 경매 번호
};

// 자신 소유 보관 아이템 목록 요청
struct TS_CS_ITEM_KEEPING_LIST : TS_MESSAGE
{
	TS_CS_ITEM_KEEPING_LIST()			_INIT( TM_CS_ITEM_KEEPING_LIST )

	int			page_num;		// 요청 페이지 번호
};

// 자신 소유 보관 아이템 목록 결과
struct TS_SC_ITEM_KEEPING_LIST : TS_MESSAGE
{
	TS_SC_ITEM_KEEPING_LIST()			_INIT( TM_SC_ITEM_KEEPING_LIST )

	// 아이템 보관 데이터
	struct TS_ITEM_KEEPING_INFO
	{
		int					keeping_uid;				// 아이템 보관 번호
		TS_ITEM_BASE_INFO	item_info;					// 아이템 정보
		int					duration;					// 보관 기간
		unsigned char		keeping_type;				// 보관 타입(AuctionBase.h의 enum KEEPING_TYPE 참조)
		ItemBase::ItemCode	related_item_code;			// 관련 아이템 코드(보관 아이템이 돈일 경우만 사용됨)
		int					related_item_enhance;		// 관련 아이템 강화 레벨(보관 아이템이 돈일 경우만 사용됨)
		int					related_item_level;			// 관련 아이템 대장작 레벨(보관 아이템이 돈일 경우만 사용됨)
	};

	int						page_num;																// 현재 페이지 번호
	int						total_page_count;														// 전체 페이지 수
	int						keeping_info_count;														// 현재 페이지에 해당하는 아이템 보관 데이터 수
	TS_ITEM_KEEPING_INFO	keeping_info[ GameRule::AUCTION_INFO_COUNT_PER_PAGE_FOR_ITEM_KEEPING ];	// 현재 페이지에 해당하는 아이템 보관 데이터
};

// 자신 소유 보관 아이템 회수 요청(결과는 TS_SC_RESULT로 보내고 페이지 갱신은 클라에서 요청 따로 보냄)
struct TS_CS_ITEM_KEEPING_TAKE : TS_MESSAGE
{
	TS_CS_ITEM_KEEPING_TAKE()			_INIT( TM_CS_ITEM_KEEPING_TAKE )

	int			keeping_uid;	// 요청 아이템 보관 번호
};

// 헌터홀릭 인스턴스 던전 목록 송신 요청
struct TS_CS_HUNTAHOLIC_INSTANCE_LIST : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_INSTANCE_LIST()			_INIT( TM_CS_HUNTAHOLIC_INSTANCE_LIST )

	int		page;		// 목록 페이지 번호
};

// 헌터홀릭 인스턴스 던전 정보 보관용(메시지/데이터 공용)
struct TS_HUNTAHOLIC_INSTANCE_INFO
{
	int				instance_no;													// 방 번호
	char			name[ GameRule::HUNTAHOLIC_MAX_INSTANCE_NAME_LENGTH + 1 ];		// 방 이름
	unsigned char	current_member_count;											// 현재 참가 인원
	unsigned char	max_member_count;												// 최대 참가 인원
	bool			require_password;												// 비번방 여부(true: 비번방, false: 공개방)
};

// 헌터홀릭 인스턴스 던전 목록
struct TS_SC_HUNTAHOLIC_INSTANCE_LIST : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_INSTANCE_LIST()			_INIT( TM_SC_HUNTAHOLIC_INSTANCE_LIST )

	int		huntaholic_id;	// 헌터홀릭 ID
	int		page;			// 현재 페이지 번호
	int		count;			// 현재 페이지에 해당하는 인스턴스 던전 개수
	int		total_page;		// 전체 인스턴스 목록의 페이지 수

	// 이 뒤로 TS_HUNTAHOLIC_INSTANCE_INFO 가 count 개 만큼 이어 붙음
};

// 헌터홀릭 인스턴스 던전 정보(현재 소속된 던전만)
struct TS_SC_HUNTAHOLIC_INSTANCE_INFO : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_INSTANCE_INFO()			_INIT( TM_SC_HUNTAHOLIC_INSTANCE_INFO )

	TS_HUNTAHOLIC_INSTANCE_INFO	info;
};

// 헌터홀릭 인스턴스 던전 생성 요청
struct TS_CS_HUNTAHOLIC_CREATE_INSTANCE : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_CREATE_INSTANCE()			_INIT( TM_CS_HUNTAHOLIC_CREATE_INSTANCE )

	char			name[ GameRule::HUNTAHOLIC_MAX_INSTANCE_NAME_LENGTH + 1 ];
	unsigned char	max_member_count;
	char			password[ GameRule::HUNTAHOLIC_MAX_INSTANCE_PASSWORD_LENGTH + 1 ];
};

// 헌터홀릭 인스턴스 던전 참가 요청
struct TS_CS_HUNTAHOLIC_JOIN_INSTANCE : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_JOIN_INSTANCE()			_INIT( TM_CS_HUNTAHOLIC_JOIN_INSTANCE )

	int			instance_no;
	char		password[ GameRule::HUNTAHOLIC_MAX_INSTANCE_PASSWORD_LENGTH + 1 ];
};

// 헌터홀릭 인스턴스 던전 탈퇴 요청
struct TS_CS_HUNTAHOLIC_LEAVE_INSTANCE : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_LEAVE_INSTANCE()			_INIT( TM_CS_HUNTAHOLIC_LEAVE_INSTANCE )
};

// 헌터홀릭 인스턴스 던전 사냥 결과
struct TS_SC_HUNTAHOLIC_HUNTING_SCORE : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_HUNTING_SCORE()			_INIT( TM_SC_HUNTAHOLIC_HUNTING_SCORE )

	int		huntaholic_id;			// 헌터홀릭 ID
	int		personal_kill_count;	// 개인 킬 수
	int		personal_score;			// 개인 점수
	int		kill_count;				// 킬 수(해당 인스턴스 던전 내의 합산)
	int		score;					// 점수(해당 인스턴스 던전 내의 합산)
	double	point_advantage;		// 방 레벨대에 따른 점수 증폭치
	double	point_rate;				// 올림방 여부에 따른 증폭치(사용되지 않음. 무조건 1.0)
	int		gain_point;				// 최종 계산된 획득 포인트
	char	result_type;			// 사냥 결과(0: 성공, 1: 사망, 2: 리타이어)
};

// 헌터홀릭 인스턴스 던전 사냥 중 점수 갱신
struct TS_SC_HUNTAHOLIC_UPDATE_SCORE : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_UPDATE_SCORE()				_INIT( TM_SC_HUNTAHOLIC_UPDATE_SCORE )

	int		kill_count;			// 킬 수
	int		score;				// 킬 수에 따른 점수
};

// 헌터홀릭 로비에서 로비 입장 지점으로 귀환
struct TS_CS_HUNTAHOLIC_LEAVE_LOBBY : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_LEAVE_LOBBY()				_INIT( TM_CS_HUNTAHOLIC_LEAVE_LOBBY )
};

// 헌터홀릭 로비에서 던전으로 입장, 사냥 시작을 클라이언트에 알림
struct TS_SC_HUNTAHOLIC_BEGIN_HUNTING : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_BEGIN_HUNTING()			_INIT( TM_SC_HUNTAHOLIC_BEGIN_HUNTING )

	AR_TIME		begin_time;
};

// 헌터홀릭 던전에서 최대 획득 가능 점수에 도달
struct TS_SC_HUNTAHOLIC_MAX_POINT_ACHIEVED : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_MAX_POINT_ACHIEVED()		_INIT( TM_SC_HUNTAHOLIC_MAX_POINT_ACHIEVED )
};

// 헌터홀릭 로비에서 던전으로 입장 요청(방에 참여 중인 유저들이 사냥 던전으로 진입)
struct TS_CS_HUNTAHOLIC_BEGIN_HUNTING : TS_MESSAGE
{
	TS_CS_HUNTAHOLIC_BEGIN_HUNTING()			_INIT( TM_CS_HUNTAHOLIC_BEGIN_HUNTING )
};

// 헌터홀릭 로비에서 던전으로 입장을 위한 카운트 다운 시작(이후 10초간 카운트하고 TS_SC_HUNTAHOLIC_BEGIN_HUNTING 메시지 날아감)
struct TS_SC_HUNTAHOLIC_BEGIN_COUNTDOWN : TS_MESSAGE
{
	TS_SC_HUNTAHOLIC_BEGIN_COUNTDOWN()			_INIT( TM_SC_HUNTAHOLIC_BEGIN_COUNTDOWN )
};

// 인스턴스 게임으로 워프
struct TS_CS_INSTANCE_GAME_ENTER : TS_MESSAGE
{
	enum MAP_TYPE
	{
		HUNTAHOLIC_BEAR_ROAD		= 0,
		RANKED_DEATHMATCH			= 1,
		FREED_DEATHMATCH			= 2,
	};

	TS_CS_INSTANCE_GAME_ENTER()			_INIT( TM_CS_INSTANCE_GAME_ENTER )

	int					instance_game_type;
};

// 인스턴스 게임에서 원래 맵으로 복귀
struct TS_CS_INSTANCE_GAME_EXIT : TS_MESSAGE
{
	TS_CS_INSTANCE_GAME_EXIT()				_INIT( TM_CS_INSTANCE_GAME_EXIT )
};

// 인스턴스 게임의 스코어 요청
struct TS_CS_INSTANCE_GAME_SCORE_REQUEST : TS_MESSAGE
{
	TS_CS_INSTANCE_GAME_SCORE_REQUEST()		_INIT( TM_CS_INSTANCE_GAME_SCORE_REQUEST )
};

// 인스턴스 게임의 스코어 전달
struct TS_SC_INSTANCE_GAME_SCORE_REQUEST : TS_MESSAGE
{
	TS_SC_INSTANCE_GAME_SCORE_REQUEST()		_INIT( TM_SC_INSTANCE_GAME_SCORE_REQUEST )

	// 베어로드
	unsigned int		holicpoint;
	unsigned int		bearroad_ranking;

	// 데스매치
	unsigned int		deathmatch_kill_count;
	unsigned int		deathmatch_death_count;

	// 배틀 아레나
	int					battle_arena_point;
	int					battle_arena_mvp_count;
	int					battle_arena_record[ 3 /* _BATTLE_ARENA_TYPE */ ][ 2 /* win, lose */ ];
};

// 플레이어가 타 플레이어에게 대련 요청
struct TS_CS_COMPETE_REQUEST		: TS_MESSAGE
{
	TS_CS_COMPETE_REQUEST()			_INIT( TM_CS_COMPETE_REQUEST )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	char				requestee[ 31 ];	// 도전 받은 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
};

// 대련 요청받은 플레이어에게 요청 전달
struct TS_SC_COMPETE_REQUEST		: TS_MESSAGE
{
	TS_SC_COMPETE_REQUEST()			_INIT( TM_SC_COMPETE_REQUEST )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	char				requester[ 31 ];	// 도전자 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
};

// 대련 요청받은 플레이어가 응답
struct TS_CS_COMPETE_ANSWER			: TS_MESSAGE
{
	TS_CS_COMPETE_ANSWER()			_INIT( TM_CS_COMPETE_ANSWER )

	unsigned char		compete_type;	// _COMPETE_TYPE 값이 사용됨
	unsigned char		answer_type;	// _COMPETE_ANSWER_TYPE 값이 사용됨
};

// 최초 대련 요청에 대한 결과 전달(수락/거부/자동거부)
struct TS_SC_COMPETE_ANSWER			: TS_MESSAGE
{
	TS_SC_COMPETE_ANSWER()			_INIT( TM_SC_COMPETE_ANSWER )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	unsigned char		answer_type;		// _COMPETE_ANSWER_TYPE 값이 사용됨
	char				requestee[ 31 ];	// 도전 받은 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
};

// 대련 시작 전 카운트 다운 개시
struct TS_SC_COMPETE_COUNTDOWN		: TS_MESSAGE
{
	TS_SC_COMPETE_COUNTDOWN()		_INIT( TM_SC_COMPETE_COUNTDOWN )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	char				competitor[ 31 ];	// 상대방 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
	AR_HANDLE			handle_competitor;	// 상대방 플레이어 핸들(1:1 PVP에서만 사용됨)
};

// 대련 시작
struct TS_SC_COMPETE_START			: TS_MESSAGE
{
	TS_SC_COMPETE_START()			_INIT( TM_SC_COMPETE_START )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	char				competitor[ 31 ];	// 상대방 플레이어 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
};

// 대련 종료(결과 방송)
struct TS_SC_COMPETE_END			: TS_MESSAGE
{
	TS_SC_COMPETE_END()				_INIT( TM_SC_COMPETE_END )

	unsigned char		compete_type;		// _COMPETE_TYPE 값이 사용됨
	unsigned char		end_type;			// _COMPETE_END_TYPE 값이 사용됨
	char				winner[ 31 ];		// 승자 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
	char				loser[ 31 ];		// 패자 이름(개인/파티전은 플레이어/파티장 이름, 길드/연합전은 길드/연합의 이름이 사용됨)
};

struct TS_SC_BATTLE_ARENA_PENALTY_INFO		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_PENALTY_INFO()			_INIT( TM_SC_BATTLE_ARENA_PENALTY_INFO )

	AR_TIME			nBlockTime;
	int				nPenaltyCount;
	AR_TIME			nPenaltyCountDecTime;
};

struct TS_CS_BATTLE_ARENA_JOIN_QUEUE		: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_JOIN_QUEUE()				_INIT( TM_CS_BATTLE_ARENA_JOIN_QUEUE )

	int					nArenaID;
};

struct TS_SC_BATTLE_ARENA_JOIN_QUEUE		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_JOIN_QUEUE()				_INIT( TM_SC_BATTLE_ARENA_JOIN_QUEUE )

	int					nArenaID;

	/*
	// 아레나 유저 등급 구분
	enum _BATTLE_GRADE
	{
		BG_INVALID		= -1,

		BG_ROOKIE		= 0,
		BG_GROW			= 1,
		BG_MAJOR		= 2,

		MAX_BATTLE_GRADE,
	};
	*/

	_BATTLE_GRADE		eGrade;
};

struct TS_SC_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT	: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT()		_INIT( TM_SC_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT )

	int			nWaitUserCount;
};

struct TS_CS_BATTLE_ARENA_LEAVE				: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_LEAVE()					_INIT( TM_CS_BATTLE_ARENA_LEAVE )
};

struct TS_SC_BATTLE_ARENA_LEAVE				: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_LEAVE()					_INIT( TM_SC_BATTLE_ARENA_LEAVE )

	/*
	// 아레나 이탈 유형 코드
	enum _ARENA_LEAVE_TYPE
	{
		ALT_UNKNOWN							= 0,
		ALT_USER_REQUEST					= 1,	// 대기열/경기 이탈 두 경우 모두 사용됨
		ALT_GAME_OVER						= 2,	// 경기 이탈 시에만 사용됨
		ALT_PARTICIPATING_SPECIAL_PARTY		= 3,	// 대기열 이탈 시에만 사용됨
		ALT_FAILED_TO_JOIN_BATTLE			= 4,	// 대기열 이탈 시에만 사용됨
		ALT_FAILED_TO_START_BATTLE			= 5,	// 대기열 이탈 시에만 사용됨(경기 시작 실패)
		ALT_DISCONNECT						= 6,	// 대기열 이탈 시에만 사용됨(대기열에 있다가 접속 끊긴 경우)
		ALT_ABSENT							= 7,	// 경기 중에 잠수 신고를 통해 경기에서 이탈된 경우
		ALT_LEAVE_ARENA						= 8,	// 아레나에서 워프를 통해 다른 지역으로 이탈함으로 인해 경기에서 이탈된 경우(워프 자체가 근본적으로 차단되어야 함)
		ALT_ENTER_INSTANCE_DUNGEON			= 9,	// 인스턴스 던전에 입장하기 위해 대기열에서 이탈되는 경우
		ALT_ENTER_DEATHMATCH				= 10,	// 데스매치 존에 입장하기 위해 대기열에서 이탈되는 경우
		ALT_ENTER_HUNTAHOLIC				= 11,	// 헌터홀릭 로비(?)에 입장하기 위해 대기열에서 이탈되는 경우
		ALT_EXERCISE_PARTY_KICK				= 12,	// 연습 경기 파티 구성 중 추방에 의해 이탈되는 경우
	};
	*/

	_ARENA_LEAVE_TYPE	eLeaveType;
	char				szName[ 19 ];
};

struct TS_SC_BATTLE_ARENA_BATTLE_INFO		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_BATTLE_INFO()			_INIT( TM_SC_BATTLE_ARENA_BATTLE_INFO )

	int					nArenaID;

	// 패킷 수신자 개인 종속적인 내용
	AR_TIME				nForceEnterTime;

	// 경기 종속적인 내용(점수는 별도의 패킷이 있으므로 제외)
	AR_TIME				nStartTime;
	_BATTLE_GRADE		eGrade;
	AR_TIME				nEndTime;

	unsigned char		nPlayerCountPerTeam[ 2 ];

	struct PlayerInfo
	{
		AR_HANDLE		handle;				// handle == 0 이면 오프라인 유저
		int				nJobID;
		char			szName[ 19 ];		// 기존에 AR_HANDLE과 묶인 이름 정보가 있더라도 가명에 의해 다른 이름이 지정될 수 있음
	};
	// 이 뒤로 PlayerInfo가 nPlayerCountPerTeam[ 0 ] + nPlayerCountPerTeam[ 1 ]개 만큼 붙음
};

struct TS_CS_BATTLE_ARENA_ENTER_WHILE_COUNTDOWN : TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_ENTER_WHILE_COUNTDOWN()	_INIT( TM_CS_BATTLE_ARENA_ENTER_WHILE_COUNTDOWN )
};

struct TS_CS_BATTLE_ARENA_EXERCISE_READY	: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_EXERCISE_READY()			_INIT( TM_CS_BATTLE_ARENA_EXERCISE_READY )

	bool	bReady;
};

struct TS_SC_BATTLE_ARENA_EXERCISE_READY_STATUS	: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_EXERCISE_READY_STATUS()	_INIT( TM_SC_BATTLE_ARENA_EXERCISE_READY_STATUS )

	int		nReadyState;
};

struct TS_CS_BATTLE_ARENA_EXERCISE_START	: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_EXERCISE_START()			_INIT( TM_CS_BATTLE_ARENA_EXERCISE_START )
};

struct TS_SC_BATTLE_ARENA_BATTLE_STATUS		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_BATTLE_STATUS()			_INIT( TM_SC_BATTLE_ARENA_BATTLE_STATUS )

	int					nStatus;

	/*
	enum _PROP_STATE
	{
		PS_NOT_EXIST		= 0,
		PS_NEUTRAL			= 1,
		PS_OWNED_BY_TEAM_0	= 2,
		PS_OWNED_BY_TEAM_1	= 3,
	};
	*/

	_PROP_STATE GetPropState( int nPropIndex ) const		{ assert( nPropIndex >= 0 && nPropIndex < 9 ); return static_cast< _PROP_STATE >( ( nStatus >> ( nPropIndex * 2 ) ) & 0x3 ); }
	bool IsActivatedBingoLine( int nLineIndex )				{ assert( nLineIndex >= 0 && nLineIndex < 8 ); return ( ( nStatus >> 24 ) & ( 1 << nLineIndex ) ) != 0; }

	// 경기 타입에 따라 nStatus의 의미가 달라짐
	// 클래식 - 이 패킷 자체를 사용하지 않음
	// 슬래터 - 슬래터 프랍 소속 상태(GetPropState( 0 )으로 얻을 수 있음)
	// 빙고  - 3x3 프랍의 소속 정보 및 빙고 달성 정보
	//        1. 뒤에서부터 2 비트( ( nStatus >> ( nPropIndex * 2 ) ) & 0x3 )씩 잘라서 각 프랍의 소속 상태로 사용(0: 프랍 없음, 1: 중립, 2: 연합군, 3: 마녀군)
	//           총 9개의 프랍이 있으므로 32비트 중 18비트가 사용됨
	//           * GetPropState을 사용해 각 프랍별 상태를 확인할 수 있음
	//        2. 최상위의 8비트( int nActivatedLineFlag = (nStatus >> 24) & 0xFF )를 이번 nStatus 변경으로 인해 달성된 빙고 라인이 어느 것인지 표현
	//           0---1---2
	//           |   |   |
	//           3---4---5
	//           |   |   |
	//           6---7---8
	//           위와 같이 각 빙고 프랍에 대해 0 ~ 8 까지 Index가 지정되어 있을 때
	//           0 - 1 - 2 (가로줄 1)이 달성되었으면 최하위 0번째 비트가 On ( nActivatedLineFlag & ( 1 << 0 ) ) != 0
	//           3 - 4 - 5 (가로줄 2)가 달성되었으면 최하위 1번째 비트가 On ( nActivatedLineFlag & ( 1 << 1 ) ) != 0
	//           6 - 7 - 8 (가로줄 3)이 달성되었으면 최하위 2번째 비트가 On ( nActivatedLineFlag & ( 1 << 2 ) ) != 0
	//           0 - 3 - 6 (세로줄 1)이 달성되었으면 최하위 3번째 비트가 On ( nActivatedLineFlag & ( 1 << 3 ) ) != 0
	//           1 - 4 - 7 (세로줄 2)가 달성되었으면 최하위 4번째 비트가 On ( nActivatedLineFlag & ( 1 << 4 ) ) != 0
	//           2 - 5 - 8 (세로줄 3)이 달성되었으면 최하위 5번째 비트가 On ( nActivatedLineFlag & ( 1 << 5 ) ) != 0
	//           0 - 4 - 8 (대각선 1)이 달성되었으면 최하위 6번째 비트가 On ( nActivatedLineFlag & ( 1 << 6 ) ) != 0
	//           2 - 4 - 6 (대각선 2)가 달성되었으면 최하위 7번째 비트가 On ( nActivatedLineFlag & ( 1 << 7 ) ) != 0
	//         * 빙고에 참여된 프랍은 사라져야 하기 때문에 ( ( nStatus >> nPropIdx * 2 ) & 0x3 ) 값이 0이 아니었다가 0이 됨(빙고라는 걸 방송하는 시점에는 0이 된 상태로 방송됨)
	//         * >> (Bit right shift) 연산을 nStatus 에 할 때, signed 변수이기 때문에 만일 최상위 비트가 On 되어있었을 경우(int 값으로는 음수)에는
	//           왼쪽에서부터 1이 채워져 들어오게 되므로 Shift 연산 후의 결과가 음수가 됨. 따라서 Shift 연산 후에는 반드시 & (Bitwise AND) 연산자를 통해 얻고자 하는 값만 잘라내야 함
	//         * IsActivatedBingoLine 함수로 특정 라인이 빙고 상태가 됐는지 확인 가능
};

struct TS_SC_BATTLE_ARENA_BATTLE_SCORE		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_BATTLE_SCORE()			_INIT( TM_SC_BATTLE_ARENA_BATTLE_SCORE )

	struct TeamScore
	{
		short		nTotalKillCount;	// 각 팀별 킬 수 총합
		short		nTotalDeathCount;	// 각 팀별 데스 수 총합
		short		nScore;				// 각 팀별 현재 점수
	};

	struct PlayerScore
	{
		char		szName[ 19 ];
		short		nKillCount;
		short		nDeathCount;
		short		nPropActivateCount;
		int			nTotalGainAP;
	};

	TeamScore		aTeamScore[ 2 /* GameRule::BATTLE_ARENA_MAX_TEAM_COUNT */ ];

	unsigned char	nPlayerScoreCount;
	// 이 뒤로 PlayerScore가 nPlayerScoreCount개 만큼 붙음
};

struct TS_SC_BATTLE_ARENA_JOIN_BATTLE		: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_JOIN_BATTLE()			_INIT( TM_SC_BATTLE_ARENA_JOIN_BATTLE )

	int				nTeamNo;
	AR_HANDLE		handle;
	int				nJobID;
	char			szName[ 19 ];
};

struct TS_SC_BATTLE_ARENA_DISCONNECT_BATTLE	: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_DISCONNECT_BATTLE()		_INIT( TM_SC_BATTLE_ARENA_DISCONNECT_BATTLE )

	AR_HANDLE		handle;
};

struct TS_SC_BATTLE_ARENA_RECONNECT_BATTLE	: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_RECONNECT_BATTLE()		_INIT( TM_SC_BATTLE_ARENA_RECONNECT_BATTLE )

	// 유저가 로그아웃되었다가 다시 접속될 경우 서버에서 AR_HANDLE값이 재부여되기 때문에
	// 클라이언트에서는 기존의 AR_HANDLE 값을 사용하면 안되고 이 패킷으로 받은 값으로 갱신해서 사용해야 함
	// 이 경우 어떤 유저가 재접속했는지는 szName을 기준으로 처리해야 함
	char			szName[ 19 ];
	AR_HANDLE		newHandle;
};

struct TS_SC_BATTLE_ARENA_RESULT			: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_RESULT()					_INIT( TM_SC_BATTLE_ARENA_RESULT )

	/*
	// 아레나 경기 종료 타입
	enum _ARENA_END_TYPE
	{
		AET_UNKNOWN						= 0,

		AET_ONE_TEAM_NO_MEMBER			= 1,	// 한 팀의 멤버가 모두 이탈하여 경기 종료(종료 유형이지만 보상이 없다는 내용도 포함)
		AET_MAX_SCORE_REACHED			= 2,	// 목표 점수 도달로 경기 종료
		AET_TIME_OVER					= 3,	// 시간 초과로 경기 종료
	};

	// 아레나 경기 보상 타입
	enum _ARENA_REWARD_TYPE
	{
		ART_UNKNOWN						= 0,

		ART_FULL_REWARD					= 1,	// 값 없음(지정 안하면 이거)
		ART_HALF_REWARD_BY_FEW_MEMBER	= 2,	// 한 팀의 멤버 수가 팀 최대 인원의 50% 미만이어서 보상이 절반으로 감소
		ART_NO_REWARD_BY_NO_MEMBER		= 3,	// 한 팀의 멤버가 모두 이탈해서 경기가 중단되어 보상 없음
		ART_NO_REWARD_BY_MIN_TIME		= 4,	// 최소 경기 시간 미달로 인해 보상 없음
		ART_NO_REWARD_BY_EXERCISE		= 5,	// 연습 경기는 보상 없음
	};
	*/

	_ARENA_END_TYPE		eEndType;
	_ARENA_REWARD_TYPE	eRewardType;
	int					nWinnerTeamNo;		// 0: 연합군, 1:마녀군

	unsigned char		nMVPCount;
	// 이 뒤로 char[ 19 ] 가 nMVPCount 만큼 붙음
};

struct TS_CS_BATTLE_ARENA_ABSENCE_CHECK_REQUEST		: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_ABSENCE_CHECK_REQUEST()		_INIT( TM_CS_BATTLE_ARENA_ABSENCE_CHECK_REQUEST )

	AR_HANDLE		hCheckTarget;
};

struct TS_SC_BATTLE_ARENA_ABSENCE_CHECK				: TS_MESSAGE
{
	TS_SC_BATTLE_ARENA_ABSENCE_CHECK()				_INIT( TM_SC_BATTLE_ARENA_ABSENCE_CHECK )

	AR_TIME			nLimitTime;
};

struct TS_CS_BATTLE_ARENA_ABSENCE_CHECK_ANSWER		: TS_MESSAGE
{
	TS_CS_BATTLE_ARENA_ABSENCE_CHECK_ANSWER()		_INIT( TM_CS_BATTLE_ARENA_ABSENCE_CHECK_ANSWER )

	bool			bSuccess;
};

// 랭킹 타입별 상위 랭킹 차트와 자신의 랭크 요청
struct TS_CS_RANKING_TOP_RECORD		: TS_MESSAGE
{
	TS_CS_RANKING_TOP_RECORD()		_INIT( TM_CS_RANKING_TOP_RECORD )

	unsigned char		ranking_type;		// _RANKING_TYPE 값이 사용됨
};

// 랭킹 타입별 상위 랭킹 차트와 요청자의 랭크
struct TS_SC_RANKING_TOP_RECORD		: TS_MESSAGE
{
	TS_SC_RANKING_TOP_RECORD()		_INIT( TM_SC_RANKING_TOP_RECORD )

	unsigned char		ranking_type;		// _RANKING_TYPE 값이 사용됨
	unsigned short		requester_rank;		// 요청자 랭크(0이면 랭킹 미등록)
	__int64				requester_score;	// 요청자 점수

	struct RANKING_RECORD
	{
		unsigned short	rank;
		char			ranker_name[ 31 ];
		__int64			score;
	};

	unsigned short		record_count;

	// 이 뒤로 RANKING_RECORD 가 record_count 개 만큼 이어 붙음
};


// 이하 크리처 농장 관련 패킷

// 크리처 농장 정보 요청
struct TS_CS_REQUEST_FARM_INFO : TS_MESSAGE
{
	TS_CS_REQUEST_FARM_INFO()	_INIT( TM_CS_REQUEST_FARM_INFO )
};

// 크리처 농장 정보 반환
struct TS_SC_FARM_INFO : TS_MESSAGE
{
	TS_SC_FARM_INFO()			_INIT( TM_SC_FARM_INFO )

	char						creature_count;

	struct SUMMON_INFO {
		int index;				// 농장 슬롯
		__int64 exp;
		char name[19];
		int duration;			// 맡기는 기간
		int elasped_time;		// 경과 시간		
		int refresh_time;		// 돌보기할 수 있는 시점까지 남은 시간
		char using_cash;
		char using_cracker;
		TS_ITEM_BASE_INFO card_info; // 크리처 카드의 아이템 정보
	};

	// 이후 creature_count만큼 SUMMON_INFO 구조체가 따라옴.
};

// 크리처 맡기기 요청
struct TS_CS_FOSTER_CREATURE : TS_MESSAGE
{
	TS_CS_FOSTER_CREATURE()		_INIT( TM_CS_FOSTER_CREATURE )

	AR_HANDLE					creature_card_handle;
	int							ticket_info_count;
	int							cracker_info_count;

	struct TICKET_INFO {
		AR_HANDLE				ticket_handle;
		int						ticket_count;
	};

	struct CRACKER_INFO {
		AR_HANDLE				cracker_handle;
		int						cracker_count;
	};

	// 이후 TICKET_INFO, CRACKER_INFO 순서로 관련 정보들이 ticket_info_count, cracker_info_count만큼 따라옴
};

// 크리처 맡기기 결과
struct TS_SC_RESULT_FOSTER : TS_MESSAGE
{
	TS_SC_RESULT_FOSTER()		_INIT( TM_SC_RESULT_FOSTER )

	char						result;
};

// 크리처 꺼내기 요청
struct TS_CS_RETRIEVE_CREATURE : TS_MESSAGE
{
	TS_CS_RETRIEVE_CREATURE()	_INIT( TM_CS_RETRIEVE_CREATURE )

	AR_HANDLE					creature_card_handle;
};

// 크리처 꺼내기 결과 
struct TS_SC_RESULT_RETRIEVE : TS_MESSAGE
{
	TS_SC_RESULT_RETRIEVE()		_INIT( TM_SC_RESULT_RETRIEVE )

	char						result;
};

// 크리처 돌보기 요청
struct TS_CS_NURSE_CREATURE : TS_MESSAGE
{
	TS_CS_NURSE_CREATURE()		_INIT( TM_CS_NURSE_CREATURE )

	AR_HANDLE					creature_card_handle;
};

// 크리처 돌보기 결과
struct TS_SC_RESULT_NURSE : TS_MESSAGE
{
	TS_SC_RESULT_NURSE()		_INIT( TM_SC_RESULT_NURSE )

	char						result;

	enum Result
	{
		FAILED		= 0,	// 무언가 잘못된 정보를 보냈으므로 요청을 무시.
		NO_REWARD	= 1,	// 돌보기를 하였으나 크리처가 보상을 주지는 않음
		REWARDED	= 2,	// 돌보기 결과 크리처가 보상을 줌
	};
};

struct TS_CS_REQUEST_FARM_MARKET : TS_MESSAGE
{
	TS_CS_REQUEST_FARM_MARKET()		_INIT( TM_CS_REQUEST_FARM_MARKET )
};
// 크리처 농장 패킷 끝





///////////////////////////////////////////////////////////////////
// 파티매치 메시지
#define PARTYMATCH_MEMBER_MAX	10
#define PARTYMATCH_ROOM_MAX		100
#define PARTYMATCH_ROOM_PAGE	10
#define PARTYMATCH_ROOM_TITLE	32
struct STRUCT_PARTYMATCH_ROOM
{
	int		nRoom;			// Room 이 0이면 방이 없는것
	int		nParty;
	short   nArea;
	short   nLevel;
	short	nMember;
	short	nMaxMember;
	char	szText[PARTYMATCH_ROOM_TITLE];
};
struct STRUCT_PARTYMATCH_MEMBER
{
	int				nMode;		// 맴버 표시정보. 현재로서는 0x80000000 | (nLevel<<16) | nJobID;
	//short			nLevel;
	//short			nJobID;
	AR_HANDLE		nMember;
	char		    szName[20];
};
struct TS_CS_PARTYMATCH_ACTION : TS_MESSAGE
{
	TS_CS_PARTYMATCH_ACTION()	_INIT( TM_CS_PARTYMATCH_ACTION )
	int				nAction;	// 0:목록요청	1:맴버요청	2:방만들기	3:방없애기   4:Apply
	int				nPage;		// 목록요청에만 사용.
	AR_HANDLE		nMaster;	// Apply 에만 사용.
	STRUCT_PARTYMATCH_ROOM stRoom;
};

struct TS_SC_PARTYMATCH_LIST : TS_MESSAGE
{
	TS_SC_PARTYMATCH_LIST()	_INIT( TM_SC_PARTYMATCH_LIST )
	int	nPage;
	int nRoomTotal;
	STRUCT_PARTYMATCH_ROOM pRoom[PARTYMATCH_ROOM_PAGE];
};

struct TS_SC_PARTYMATCH_MEMBER : TS_MESSAGE
{
	TS_SC_PARTYMATCH_MEMBER()	_INIT( TM_SC_PARTYMATCH_MEMBER )
	int				nRoom;
	AR_HANDLE		nMaster;		// master ID 아래에 pMeber중 하나가 이와 같은 값이다.
	STRUCT_PARTYMATCH_MEMBER pMember[PARTYMATCH_MEMBER_MAX];
};



// { Game Server <-> Auth Server
struct TS_GA_LOGIN : TS_MESSAGE
{
	TS_GA_LOGIN()		_INIT( TM_GA_LOGIN )

	unsigned short	server_idx;
	char			server_name[21];
	char			server_screenshot_url[256];
	bool			is_adult_server;
	char			server_ip[16];
	int				server_port;
};

struct TS_AG_LOGIN_RESULT : TS_MESSAGE
{
	TS_AG_LOGIN_RESULT()		_INIT( TM_AG_LOGIN_RESULT )

	unsigned short		result;
};

struct TS_GA_CLIENT_LOGIN : TS_MESSAGE
{
	TS_GA_CLIENT_LOGIN()		_INIT( TM_GA_CLIENT_LOGIN )

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
	__int64		one_time_key;
};

struct TS_AG_CLIENT_LOGIN : TS_MESSAGE
{
	TS_AG_CLIENT_LOGIN()		_INIT( TM_AG_CLIENT_LOGIN )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
	int					nAccountID;
	unsigned short		result;
	char				nPCBangMode;
	int					nEventCode;
	int					nAge;
	AR_TIME				nContinuousPlayTime;
	AR_TIME				nContinuousLogoutTime;
};

struct TS_GA_CLIENT_LOGOUT : TS_MESSAGE
{
	TS_GA_CLIENT_LOGOUT()		_INIT( TM_GA_CLIENT_LOGOUT )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
	AR_TIME				nContinuousPlayTime;
};

struct TS_AG_KICK_CLIENT : TS_MESSAGE
{
	TS_AG_KICK_CLIENT()			_INIT( TM_AG_KICK_CLIENT )

	enum _KICK_TYPE
	{
		KICK_TYPE_ANOTHER_LOGIN		= 0,	// 다른 유저의 접속으로 인한 접속 종료
		KICK_TYPE_DUPLICATED_LOGIN	= 1,	// 인증 서버에서 게임 서버 로그인 처리 시 중복된 로그인 감지로 인한 접속 종료(내부 오류 또는 해킹에 의한 발생)
		KICK_TYPE_BILLING_EXPIRED	= 2,	// 결재 정보 만료로 인한 접속 종료
		KICK_TYPE_GAME_ADDICTION	= 3,	// 게임 중독 방지로 인한 접속 종료
	};

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
	char		kick_type;		// _KICK_TYPE 값이 사용됨
};

struct TS_GA_CLIENT_KICK_FAILED : TS_MESSAGE
{
	TS_GA_CLIENT_KICK_FAILED()			_INIT( TM_GA_CLIENT_KICK_FAILED )

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
};

struct TS_AG_ITEM_PURCHASED : TS_MESSAGE
{
	TS_AG_ITEM_PURCHASED()		_INIT( TM_AG_ITEM_PURCHASED )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
	int					nAccountID;
};

struct TS_AG_ITEM_SUPPLIED : TS_MESSAGE
{
	TS_AG_ITEM_SUPPLIED()		_INIT( TM_AG_ITEM_SUPPLIED )

	char				account[GameRule::MAX_ACCOUNT_LEN + 1];
};

//	2009. 8. 11 floyd 보안비밀번호 2차 수정
struct TS_AG_SECURITY_NO_CHECK : TS_MESSAGE
{
	TS_AG_SECURITY_NO_CHECK()	_INIT( TM_AG_SECURITY_NO_CHECK )

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
	int			mode;
	int			result;
	
};

//	2009. 8. 11 floyd 보안비밀번호 2차 수정
struct TS_GA_SECURITY_NO_CHECK : TS_MESSAGE
{
	TS_GA_SECURITY_NO_CHECK()	_INIT( TM_GA_SECURITY_NO_CHECK )

	char		account[GameRule::MAX_ACCOUNT_LEN + 1];
	char		password[19];
	int			mode;
};


struct TS_CS_OPEN_ITEM_SHOP : TS_MESSAGE
{
	TS_CS_OPEN_ITEM_SHOP()			_INIT( TM_CS_OPEN_ITEM_SHOP )
};

struct TS_SC_OPEN_ITEM_SHOP : TS_MESSAGE
{
	TS_SC_OPEN_ITEM_SHOP()			_INIT( TM_SC_OPEN_ITEM_SHOP )

	int			client_id;
	int			account_id;
	int			one_time_password;
	char		raw_server_name[32];
};

//	2009. 8. 11 floyd 보안비밀번호 2차 수정
/*
struct TS_SC_CREATE_SECURITY_NO : TS_MESSAGE
{
	TS_SC_CREATE_SECURITY_NO()			_INIT( TM_SC_CREATE_SECUTIRY_NO )
};
*/

struct TS_SC_REQUEST_SECURITY_NO : TS_MESSAGE
{
	TS_SC_REQUEST_SECURITY_NO()		_INIT( TM_SC_REQUEST_SECUTIRY_NO );

	enum { SC_NONE, SC_OPEN_STORAGE, SC_DELETE_CHARACTER };

	int			mode;
};

struct TS_CS_SECURITY_NO : TS_MESSAGE
{
	TS_CS_SECURITY_NO()		_INIT( TM_CS_SECURITY_NO );

	int			mode; // 0 - None, 1 - Storage open
	char		security_no[19];
};

//	2009. 8. 11 floyd 보안비밀번호 2차 수정
/*
struct TS_CS_CREATE_SECURITY_NO : TS_MESSAGE
{
	TS_CS_CREATE_SECURITY_NO() _INIT( TM_CS_CREATE_SECURITY_NO );

	char		password[19];
	char		security_no[19];
};

struct TS_CS_REQUEST_SECURITY_NO_CHANGE : TS_MESSAGE
{
	TS_CS_REQUEST_SECURITY_NO_CHANGE() _INIT( TM_CS_REQUEST_SECURITY_NO_CHANGE );
};

struct TS_SC_CHANGE_SECURITY_NO : TS_MESSAGE
{
	TS_SC_CHANGE_SECURITY_NO() _INIT( TM_SC_CHANGE_SECURITY_NO );
};

struct TS_CS_CHANGE_SECURITY_NO : TS_MESSAGE
{
	TS_CS_CHANGE_SECURITY_NO() _INIT( TM_CS_CHANGE_SECURITY_NO );

	char		security_no_old[19];
	char		security_no[19];
};

struct TS_CS_REQUEST_CLEAR_SECURITY_NO : TS_MESSAGE
{
	TS_CS_REQUEST_CLEAR_SECURITY_NO()	_INIT( TM_CS_REQUEST_CLEAR_SECURITY_NO );
};

struct TS_SC_CLEAR_SECURITY_NO : TS_MESSAGE
{
	TS_SC_CLEAR_SECURITY_NO()			_INIT( TM_SC_CLEAR_SECURITY_NO );

	bool		clearable;
};

struct TS_CS_CLEAR_SECURITY_NO : TS_MESSAGE
{
	TS_CS_CLEAR_SECURITY_NO()			_INIT( TM_CS_CLEAR_SECURITY_NO );

	char		password[19];
	char		security_no[19];
};
*/

// }

// { Upload Server <-> Game Server
struct TS_SU_LOGIN : TS_MESSAGE
{
	TS_SU_LOGIN()			_INIT( TM_SU_LOGIN )

	char					server_name[21];
};

struct TS_US_LOGIN_RESULT : TS_MESSAGE
{
	TS_US_LOGIN_RESULT()	_INIT( TM_US_LOGIN_RESULT )

	unsigned short			result;
};

struct TS_SU_REQUEST_UPLOAD : TS_MESSAGE
{
	TS_SU_REQUEST_UPLOAD()	_INIT( TM_SU_REQUEST_UPLOAD )

	enum
	{
		UPLOAD_TYPE_ICON		= 0,
		UPLOAD_TYPE_BANNER		= 1,
	};

	int						client_id;
	int						account_id;
	int						guild_sid;
	int						one_time_password;
	unsigned char			type;
};

struct TS_US_REQUEST_UPLOAD : TS_MESSAGE
{
	TS_US_REQUEST_UPLOAD()	_INIT( TM_US_REQUEST_UPLOAD )

	unsigned short			result;
};

struct TS_US_UPLOAD : TS_MESSAGE
{
	TS_US_UPLOAD()			_INIT( TM_US_UPLOAD )

	int						guild_id;
	int						file_size;
	unsigned char			filename_length;
	unsigned char			type;
};


// }

#undef _INIT

#pragma pack()


#define BEGIN_COMMAND \
	static SCheatCommand s_Command[] = \
	{

#define END_COMMAND \
		{ NULL, NULL, GameRule::PERMISSION_FOR_PLAYER, 0 } \
	};

#define NORMAL1( message, function ) \
{ message, (SCheatCommand::CMD_FUNCTION)(function), GameRule::PERMISSION_FOR_PLAYER, 1 },

#define NORMAL2( message, function ) \
	{ message, (SCheatCommand::CMD_FUNCTION)(function), GameRule::PERMISSION_FOR_PLAYER, 2 },

#define NORMALA( message, function ) \
	{ message, (SCheatCommand::CMD_FUNCTION)(function), GameRule::PERMISSION_FOR_PLAYER, 0 },

#define GM1( message, function, permission ) \
	{ message, (SCheatCommand::CMD_FUNCTION)(function), permission, 1 },

#define GM2( message, function, permission ) \
	{ message, (SCheatCommand::CMD_FUNCTION)(function), permission, 2 },

#define GMA( message, function, permission ) \
	{ message, (SCheatCommand::CMD_FUNCTION)(function), permission, 0 },