#pragma once

//#include <vector>
#include <mmo/ArMove.h>
#include "SkillBase.h"
#include "SMessage.h"
#include "SNetMessage.h"
#include "SNetMessageBill.h"

#include "K3DTypes.h"
#include "Util.h"
#include "Enc.h"

#pragma pack( 1 )
  

struct SMSG_AC_RESULT : public SGameMessage
{
	SMSG_AC_RESULT()	:	SGameMessage(MSG_AC_RESULT)
	{
		request_msg_id = 0;
		result         = 0;
		value          = 0;
	}

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

/// 2011.05.20 GNE 인증 방식 - prodongi
struct SMSG_AC_RESULT_WITH_STRING : public SGameMessage
{
	SMSG_AC_RESULT_WITH_STRING()	:	SGameMessage(MSG_AC_RESULT_WITH_STRING)
	{
		request_msg_id = 0;
		result         = 0;
		value          = 0;
		str			   = NULL;
	}
	virtual ~SMSG_AC_RESULT_WITH_STRING()
	{
		SAFE_DELETE_ARRAY(str);
	}

	unsigned short         request_msg_id;
	unsigned short         result;
	int                    value;
	char*				   str;
};

struct SMSG_AC_SERVER_LIST : public SGameMessage
{
	SMSG_AC_SERVER_LIST() : SGameMessage(MSG_AC_SERVER_LIST)
	{
		count = 0;
		m_pServerInfo = NULL;
	}
	~SMSG_AC_SERVER_LIST()
	{
		SAFE_DELETE_ARRAY( m_pServerInfo );
	}
	unsigned short last_login_server_idx;
	unsigned short count;
	
	struct TS_SERVER_INFO * m_pServerInfo;	///< 이 아래로 TS_SERVER_INFO 들이 붙게 됨
};

struct SMSG_AC_SELECT_SERVER : public SGameMessage
{
	SMSG_AC_SELECT_SERVER() : SGameMessage(MSG_AC_SELECT_SERVER)
	{
		result       = 0;
		one_time_key_en_len = 0;
		memset( one_time_key, 0, sizeof( one_time_key ) );
		pending_time = 0;
	}	
	unsigned short		result;
	size_t				one_time_key_en_len;
	unsigned char		one_time_key[sizeof( __int64 ) + GameRule::MAX_CRYPTO_BLOCK_LEN];
	AR_TIME				pending_time; ///< 대기 할 시간 
};

struct SMSG_AC_UPDATE_PENDING_TIME : public SGameMessage
{
	SMSG_AC_UPDATE_PENDING_TIME() : SGameMessage(MSG_AC_UPDATE_PENDING_TIME)
	{
		pending_time = 0;
	}	
	AR_TIME                pending_time; ///< 대기 할 시간 
};


struct SMSG_RESULT		: public SGameMessage
{
	SMSG_RESULT()	:	SGameMessage(MSG_RESULT)
	{
		request_msg_id = 0;
		result         = 0;
		value          = 0;
	}

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


struct SMSG_SECRET_KEY	: public SGameMessage
{
	SMSG_SECRET_KEY()	:	SGameMessage(MSG_SECRET_KEY)
	{
		nEncryptSize = 0;
		pEncryptData = NULL;
	}
	~SMSG_SECRET_KEY()
	{
		delete pEncryptData;
	}

	size_t			nEncryptSize;
	unsigned char*	pEncryptData;
};

struct SMSG_ACCOUNT_INFO	: public SGameMessage
{
	SMSG_ACCOUNT_INFO()	:	SGameMessage(MSG_ACCOUNT_INFO)
	{
	}
	~SMSG_ACCOUNT_INFO()
	{
	}

	std::string	strAccount;
	int user_no; // 유럽 db 통합 account id 중복 버그 방지위해 크루샵에서 사용할 고유값
};


struct SMSG_MOVE : public SGameMessage
{
	SMSG_MOVE() : SGameMessage(MSG_MOVE)
	{ 
		handle     = 0;
		start_time = 0;
		bReqMove   = false;
		pos_target = K3DVector(0,0,0); 
		speed      = 0; 
	}
	~SMSG_MOVE()
	{
		m_vecMoveInfo.clear();
	}

	AR_HANDLE    handle;
	AR_TIME		start_time;

	bool		bReqMove;

	K3DVector pos_target; ///< 이동 할 위치

	unsigned char speed;
	
	std::vector< ArPosition >	m_vecMoveInfo;
};

/// Local Player 이동 응답
struct SMSG_MOVE_ACK : public SGameMessage
{
	SMSG_MOVE_ACK() : SGameMessage(MSG_MOVE_ACK)
	{
		time  = 0;
		speed = 0;
	}

	AR_TIME		  time;
	unsigned char speed;

};

struct SMSG_REGION_ACK : public SGameMessage
{
	SMSG_REGION_ACK() : SGameMessage(MSG_REGION_ACK) 
	{
		rx = 0;
		ry = 0;
	}
	unsigned rx;
	unsigned ry;
};

struct SMSG_LOGIN :  public SGameMessage 
{
	SMSG_LOGIN() : SGameMessage(MSG_LOGIN) 
	{
		// 2010.05.20 - prodongi
		result = 0;
		//bIsAccepted = 0;
		handle      = 0;
		x=y=z       = 0;
		layer       = 0;
		region_size = 0;
		hp          = 0;
		mp			= 0;
		max_hp		= 0;
		max_mp		= 0;
		race		= 0;
		skin_color  = 0;
		ZeroMemory( szName, sizeof(szName) );
		cell_size   = 6;
		// 2010.05.20 - prodongi
		hideEquipInfo = 0;
	}

	//char			bIsAccepted;
	//unsigned short	bIsAccepted;
	unsigned short	result;

	AR_HANDLE		handle;
	AR_UNIT			x,y,z;
	unsigned char	layer;
	float			face_direction;	///< 보고있는 방향
	int				region_size;

	// blow 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;

	int				hairColorIndex;
    unsigned long	hairColorRGB;
	// 2010.05.20 - prodongi
	unsigned int	hideEquipInfo;

	char			szName[19];

	int             cell_size;
	int             guild_id;
	int				back_board;
};

struct SMSG_CHARLIST : public SGameMessage
{
	SMSG_CHARLIST() : SGameMessage( MSG_CHARLIST ), current_server_time(0), nCharCount( 0 ), pCharInfo( NULL ) { }
	~SMSG_CHARLIST() { SAFE_DELETE_ARRAY( pCharInfo ); }

	unsigned int		current_server_time;	///< 1970년 1월 1일 0시 0분 0초로부터 몇초가 경과되었는지를 알려줌.
	// ( CRT 의 time() 리턴값임)

	unsigned short         last_login_index;

	int nCharCount;
	LOBBY_CHARACTER_INFO* pCharInfo;
};

struct SMSG_LEAVE :  public SGameMessage
{
	SMSG_LEAVE() : SGameMessage(MSG_LEAVE) 
	{
		handle = 0;
	}
	AR_HANDLE	handle;
};
	
struct SMSG_ENTER :  public SGameMessage											
{
	SMSG_ENTER() : SGameMessage(MSG_ENTER) 
	{
		type   = 0;
		handle = 0; 
		x=y=z  = 0;
		layer  = 0;

		// blow is game conetents
		ObjType = 0;
	}
	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 ];
	};

	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 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,	// 2010.07.15 - prodongi
			FLAG_DUNGEON_ORIGINAL_OWNER = 1 << 15,
			FLAG_DUNGEON_ORIGINAL_SIEGER = 1 << 17,
		};

		//int			monster_id;
		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 PetInfo : CreatureInfo	///< sonador 10.2.1	팻 시스템 구현
	{
		enum 
		{
			FLAG_SHOVELING_SEARCH		= 1 << 18, 
			FLAG_SHOVELING_APPROACH		= 1 << 19, 
			FLAG_SHOVELING_DIG			= 1 << 20, 
		};
		AR_HANDLE	master_handle;
		ENC_INT		pet_code;
		char		szName[ 19 ];
	};

	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;
	};

	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,
		};

		unsigned char sex;

		ItemBase::ItemCode	faceId;
		int					faceTextureId;	// 2010.06.18 deco index이다, 변수명이 너무 헷깔린다. - prodongi
		ItemBase::ItemCode  hairId;

		int				hairColorIndex;
		unsigned long	hairColorRGB;
		// 2010.05.20 - prodongi
		unsigned int	hideEquipFlag;

		char	szName[19];

		unsigned short job_id;

		AR_HANDLE		ride_handle;
		int             guild_id;
		int				title_code;	// 2012. 5. 30 - marine
		int				back_board;
	};

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

struct SMSG_ATTACK_DOUBLE : public SGameMessage
{	
	SMSG_ATTACK_DOUBLE() : SGameMessage(MSG_ATTACK_DOUBLE) 
	{
		attacker_handle = 0;
		target_handle   = 0;
		right_hand_damage = 0;
		left_hand_damage  = 0;
		attack_speed      = 0; 
		hp_percentage     = 0;        

		pos_target    = K3DVector(0,0,0);

		flag = 0;    
		memset( right_hand_elemental_damage, 0, sizeof( right_hand_elemental_damage ) );
		memset( left_hand_elemental_damage,  0, sizeof( left_hand_elemental_damage  ) );
	}

	AR_HANDLE      attacker_handle;
	AR_HANDLE      target_handle;
	short          right_hand_damage;
	short          left_hand_damage;
	unsigned short attack_speed;                 ///< ms
	unsigned char  hp_percentage;                ///< HP %
	
	unsigned short flag;   
	unsigned char  right_hand_elemental_damage[ CreatureElemental::COUNT ];     ///< 추가데미지
	unsigned char  left_hand_elemental_damage[ CreatureElemental::COUNT ];      ///< 추가데미지

	K3DVector pos_target;  ///< 이동 할 위치
};

struct SMSG_ATTACK :  public SGameMessage
{
	SMSG_ATTACK() : SGameMessage(MSG_ATTACK) 
	{
		attacker_handle		= 0;
		target_handle		= 0;

//		pTarget				= NULL; 
		pos_target			= K3DVector(0,0,0);

		attack_speed		= 0;

		count				= 0;

		nTypeBow			= 0;
	}
	~SMSG_ATTACK()
	{
		m_vAttackInfoList.clear();
	}

	AR_HANDLE      attacker_handle;
	AR_HANDLE      target_handle;

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

	char			attack_action;

	char			attack_flag;

	unsigned char	count;

	int			    nTypeBow;      ///< 활 공격 종류 ItemClass 참조~

//	class SGameObject * pTarget; //공격 대상
	K3DVector pos_target;  ///< 이동 할 위치

	std::vector< ATTACK_INFO >	m_vAttackInfoList;
};

struct SMSG_CANT_ATTACK :  public SGameMessage
{
	SMSG_CANT_ATTACK() : SGameMessage(MSG_CANT_ATTACK) 
	{
		attacker_handle = 0;
		target_handle   = 0;
//		tx              = 0; 
//		ty              = 0;
//		attack_range    = 0;
	}
	AR_HANDLE				attacker_handle;
	AR_HANDLE				target_handle;
//	AR_UNIT					tx,ty;
//	AR_UNIT					attack_range;
	int						reason;
};

struct SMSG_DAMAGE : public SGameMessage
{
	enum
	{
		NORMAL_DAMAGE = 0,
		SKILL_DAMAGE,
		DOT_DAMAGE,
	};

	enum
	{
		FIRE_SKILL = 0,
		REGION_FIRE_SKILL,
	};

	SMSG_DAMAGE() : SGameMessage(MSG_DAMAGE)
	{
		nDamage					= 0;
		flag					= 0;
		nHittingAdd_FxID		= 0;
		attacker_handle			= 0;
		target_handle			= 0;
		memset( elemental_damage, 0 ,sizeof(elemental_damage) );
		skillresult.damage.type = SkillResult::NOT_USE;
		bSphereDamage			= false;
		bBowAttack				= false;
		nSkillID				= 0;
		nSkillLevel				= 0;	// TODO: Change later skill levels everywhere to short or char because it actually can't be higher than 255
		strTargetName.clear();

		attack_action			= 0;
		attack_flag				= 0;

		nDamage_Type            = NORMAL_DAMAGE;

		strCasterName			= "Somebody";
		strTargetName			= "Somebody";

		skill_type				= FIRE_SKILL;
		chainCaster				= 0;		/// 2011.03.25 - prodongi
	}

	AR_HANDLE		attacker_handle;
	AR_HANDLE		target_handle;

	bool			bSphereDamage;	///< 범위데미지
	bool			bBowAttack;	///< 활 공격이냐

	int				nHittingAdd_FxID;  ///<부가 FX ID

	int				nDamage; ///<데미지
	unsigned char	flag;                                 
	int				elemental_damage[ CreatureElemental::COUNT ]; ///< 추가데미지

	int nSkillID;
	int nSkillLevel;

	std::string strCasterName;
	std::string strTargetName;

	SkillResult		skillresult;

	char			attack_action;
	char			attack_flag;

	short			nDamage_Type;
	int				skill_type;
	AR_HANDLE		chainCaster;	/// 2011.03.25 - prodongi
};

struct SMSG_STAT_INFO : public SGameMessage
{
	SMSG_STAT_INFO() : SGameMessage(MSG_STAT_INFO)
	{
		handle       = 0;
		memset( &stat     , 0, sizeof(stat)      );
		memset( &attribute, 0, sizeof(attribute) );
		type = 0;
	}

	AR_HANDLE				handle;

	CreatureStat			stat;
	CreatureAttribute		attribute;

	unsigned char			type;
};

struct SMSG_GOLD_UPDATE : public SGameMessage
{
	SMSG_GOLD_UPDATE() : SGameMessage(MSG_GOLD_UPDATE), gold(0) { }
	money_t					gold;	///< [sonador][3.4.1]소지금 한도 증가 관련 서버 메시지 변경
	int						chaos;
};

struct SMSG_LEVEL_UPDATE : public SGameMessage
{
	SMSG_LEVEL_UPDATE() : SGameMessage(MSG_LEVEL_UPDATE), handle(0), level(0), job_level(0) { }
	AR_HANDLE               handle;
	int						level;
	int                     job_level;
};

struct SMSG_EXP_UPDATE : public SGameMessage
{
	SMSG_EXP_UPDATE() : SGameMessage(MSG_EXP_UPDATE), handle(0), exp(0), jp(0) { }
	AR_HANDLE               handle;
	__int64					exp;
	__int64					jp;	/// 2011.04.29 int -> __int64 - prodongi
};

struct SMSG_BONUS_EXP_JP : public SGameMessage
{
	SMSG_BONUS_EXP_JP() : SGameMessage(MSG_BONUS_EXP_JP)
	{
	}

	std::vector< TS_SC_BONUS_EXP_JP::BONUS_INFO > m_vBonusInfo;
};

struct SMSG_STATUS_CHANGE : public SGameMessage
{
	SMSG_STATUS_CHANGE() : SGameMessage(MSG_STATUS_CHANGE)
	{
		handle = 0;
		status = 0;
	}

	AR_HANDLE		handle;
	unsigned		status;
};

struct SMSG_WATCH_BOOTH : public SGameMessage
{
	SMSG_WATCH_BOOTH( AR_HANDLE h = NULL, bool bIsStart = false ) : SGameMessage( MSG_WATCH_BOOTH ), hTarget( h ), bIsStartWatch( bIsStart ) {}

	AR_HANDLE		hTarget;
	bool			bIsStartWatch;
};

struct SMSG_BOOTH_NAME_CHANGED : public SGameMessage
{
	SMSG_BOOTH_NAME_CHANGED( AR_HANDLE h, const std::string & name ) : SGameMessage( MSG_BOOTH_NAME_CHANGED ), hTarget( h ), strBoothName( name ) {}

	AR_HANDLE	hTarget;
	std::string strBoothName;
};

struct SMSG_BOOTH_CLOSED : public SGameMessage
{
	SMSG_BOOTH_CLOSED( AR_HANDLE h ) : SGameMessage( MSG_BOOTH_CLOSED ), hTarget( h ) {}

	AR_HANDLE	hTarget;
};

struct SMSG_BOOTH_INFO : public SGameMessage
{
	SMSG_BOOTH_INFO() : SGameMessage( MSG_BOOTH_INFO ) { bIsWatch = false;}

	bool			bIsWatch;
	bool			bIsSell;
	AR_HANDLE		hTarget;
	std::vector< TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO > vList;
};

struct SMSG_BOOTH_TRADE_INFO : public SGameMessage
{
	SMSG_BOOTH_TRADE_INFO() : SGameMessage( MSG_BOOTH_TRADE_INFO ) {}

	AR_HANDLE	hTarget;
	bool bIsSell;
	std::vector< TS_BOOTH_TRADE_ITEM_INFO > vList;
};

struct SMSG_BOOTH_NAME : public SGameMessage
{
	SMSG_BOOTH_NAME() : SGameMessage( MSG_BOOTH_NAME ) {}

	std::vector< TS_SC_GET_BOOTHS_NAME::TS_BOOTH_NAME > vBoothName;
};

struct SMSG_STATE : public SGameMessage
{
	enum
	{
		OWNER_NONE = 0,
		OWNER_LOCAL_PLAYER,
		OWNER_LOCAL_CREATURE,
		OWNER_LOCAL_PARTY,
		OWNER_LOCAL_GUILD,
	};

	SMSG_STATE() : SGameMessage(MSG_STATE)
	{
		handle       = 0;
		state_handle = 0;
		state_code   = 0;
		state_level  = 0;
		end_time     = 0;
		start_time	 = 0;
		state_value  = 0;
		data_owner   = OWNER_NONE;
		isToggle     = false;
		/// 2011.07.28 redmine #16797 - prodongi
		disguiseEnhance = 0;
		isNewState = false;
	}

	AR_HANDLE		handle;			///< 대상 크리쳐
	unsigned short	state_handle;	///< 상태이상 핸들
	unsigned int	state_code;		///< 상태이상 종류
	unsigned short	state_level;	///< 상태이상의 레벨 (0이면 풀리는 메세지임)
	AR_TIME			end_time;		///< 끝나는 시간 (0이면 영원히)
	AR_TIME			start_time;
	unsigned short  data_owner;
	int             state_value;    ///< 지속효과 관련 추가값
	std::string     state_string_value;
	/// 2011.07.28 redmine #16797 - prodongi
	int				disguiseEnhance; /// 변신할 크리처의 강화 정보

	bool			isToggle;       ///< 토글형 스킬?

	bool isNewState;			/// 2012.02.01 새로 걸리는 버프인지 아닌지(기존 버프가 존재하지 않거나 기존에 걸려 있는 버프와의 레벨이 틀리는 경우) - prodongi
};
/*
struct SMSG_HP : public SGameMessage
{
	SMSG_HP() : SGameMessage(MSG_HP)
	{
		handle = 0;
		hp     = 0;
		hp_percentage = 0;
	}

	AR_HANDLE	handle;
	int			hp;
	unsigned char hp_percentage;
};

struct SMSG_MP : public SGameMessage
{
	SMSG_MP() : SGameMessage(MSG_MP)
	{
		handle = 0;
		mp     = 0;
	}

	AR_HANDLE	handle;
	int			mp;
};
*/
struct SMSG_SP : public SGameMessage
{
	SMSG_SP() : SGameMessage(MSG_SP)
	{
		handle	=	0;
		sp		=	0;
		max_sp	=	0;
	}

	AR_HANDLE	handle;
	short		sp;
	short		max_sp;
};

struct SMSG_REGEN_HPMP : public SGameMessage
{
	SMSG_REGEN_HPMP() : SGameMessage( MSG_REGEN_HPMP )
	{
		handle    = 0;
		hp_regen  = 0;
		mp_regen  = 0;
		hp        = 0;
		mp        = 0;
	}
	
	AR_HANDLE    handle;
	int		hp_regen;
	int		mp_regen;
	int		hp;
	int		mp;
};

struct SMSG_PROPERTY : public SGameMessage
{
	enum
	{
		PROPERTY_HP,          			///< "hp"
		PROPERTY_MP,          			///< "mp"
		PROPERTY_MAX_HP,      			///< "max_hp"
		PROPERTY_MAX_MP,      			///< "max_mp"
		PROPERTY_LOGIN,       			///< "login"
		PROPERTY_ACCOUNT,     			///< "account"
		PROPERTY_NAME,        			///< "name"
		PROPERTY_GOLD,        			///< "gold"
		PROPERTY_EXP,         			///< "exp"
		PROPERTY_JP,          			///< "jp"
		PROPERTY_JOB_LEVEL,   			///< "job_level"
		PROPERTY_JOB,         			///< "job"
		PROPERTY_JOB_0,       			///< "job_0"
		PROPERTY_JLV_0,       			///< "jlv_0"
		PROPERTY_JOB_1,       			///< "job_1"
		PROPERTY_JLV_1,       			///< "jlv_1"
		PROPERTY_JOB_2,       			///< "job_2"
		PROPERTY_JLV_2,       			///< "jlv_2"
		PROPERTY_LEVEL,       			///< "level"
		PROPERTY_WEIGHT,      			///< "weight"
		PROPERTY_STR,         			///< "str"
		PROPERTY_AGI,         			///< "agi"
		PROPERTY_DEX,         			///< "dex"
		PROPERTY_INT,         			///< "int"
		PROPERTY_LUCK,        			///< "luck"
		PROPERTY_VITAL,       			///< "vital"
		PROPERTY_MENTAL,      			///< "mental"
		PROPERTY_PERMISSION,  			///< "permission"
		PROPERTY_PK_COUNT,    			///< "pk_count"
		PROPERTY_DK_COUNT,    			///< "dkc"
		PROPERTY_RACE,        			///< "race"
		PROPERTY_CHARISMA,    			///< "charisma"
		PROPERTY_MORAL,       			///< "moral"
		PROPERTY_LOGIN_TIME,  			///< "login_time"
		PROPERTY_SEX,         			///< "sex"
		PROPERTY_X,           			///< "x"
		PROPERTY_Y,           			///< "y"
		PROPERTY_SPEED,       			///< "speed"
		PROPERTY_SP,          			///< "sp" ( 소환수에게 온다. )			
		PROPERTY_STORAGE_GOLD,			///< "storage_gold" 창고에 저장된 금액	
		PROPERTY_STAMINA,     			///< "stamina"
		PROPERTY_CHAOS,		  			///< "chaos"
		PROPERTY_MAX_CHAOS,   			///< "max_chaos"
		PROPERTY_MAX_STAMINA, 			///< "max_stamina"
		PROPERTY_CHANNEL,     			///< "channel"
		PROPERTY_STAMINA_REGEN_RATE,	///< "stamina_regen"
		PROPERTY_PLAYTIME,				///< "playtime"
		PROPERTY_PLAYTIME_LIMIT1,       ///< "playtime_limit1"
		PROPERTY_PLAYTIME_LIMIT2,		///< "playtime_limit2"
		PROPERTY_HUNTAHOLIC_ENT,		///< "huntaholic_ent"

		PROPERTY_ETHEREAL_STONE_DURABILITY,		///< "ethereal_stone_durability"
		PROPERTY_HUNTAHOLICPOINT,		// "huntaholicpoint"
		PROPERTY_TP,					/// 2011.03.28 "tp" 특성 포인트 - prodongi		
		PROPERTY_AP,					/// 2012.06.08 "ap" 아레나 포인트 - prodongi

		PROPERTY_ALIAS,					/// 아레나 별칭
		PROPERTY_CLIENT_INFO, 			///< "client_info"
		PROPERTY_QUICK_SLOT, 			///< "quick_slot"
		PROPERTY_CURRENT_KEY,			///< "current_key_info"
		PROPERTY_SAVED_KEY,				///< "saved_key_info"
	};

	SMSG_PROPERTY( AR_HANDLE han, int nType, const char* szValue )
		: SGameMessage(MSG_PROPERTY), handle(han), nPropertyType( nType ), strValue( szValue ) { }

	AR_HANDLE	handle;
	int			nPropertyType; ///< 위의 프로퍼티 타입 참조
	std::string strValue;
};

struct SMSG_HPMP : public SGameMessage
{
	SMSG_HPMP() : SGameMessage(MSG_HPMP)
	{
		handle = 0;
		add_hp = 0;
		hp     = 0;
		max_hp = 0;
		add_mp = 0;
		mp     = 0;
		max_mp = 0;
	}

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

};

struct SMSG_TARGET : public SGameMessage
{
	SMSG_TARGET() : SGameMessage(MSG_TARGET)
	{
		target = 0;
	}

	AR_HANDLE target;
};

struct SMSG_SHOW_CREATE_GUILD : public SGameMessage
{
	SMSG_SHOW_CREATE_GUILD() : SGameMessage(MSG_SHOW_CREATE_GUILD)
	{

	}
};

struct SMSG_SHOW_CREATE_ALLIANCE : public SGameMessage
{
	SMSG_SHOW_CREATE_ALLIANCE()	:  SGameMessage(MSG_SHOW_CREATE_ALLIANCE) {}
};

struct SMSG_SEND_DATA : public SGameMessage
{
	SMSG_SEND_DATA( int n )
		: SGameMessage( MSG_SEND_DATA ), nNumber( n ) { }

	SMSG_SEND_DATA( const char *pszMessage )
		: SGameMessage( MSG_SEND_DATA ), strMessage( pszMessage  ) { }

	SMSG_SEND_DATA( const char *pszMessage, const char *pszData )
		: SGameMessage( MSG_SEND_DATA ), strMessage( pszMessage  ), strData( pszData  ){ }

	SMSG_SEND_DATA( int n, const char *pszMessage )
		: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage  ) { }

	SMSG_SEND_DATA( int n, const char *pszMessage, const char *pszData )
		: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage  ), strData( pszData ) { }

	SMSG_SEND_DATA( int n, const char *pszMessage, int n2, int n3, const char *pszData )
		: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage  ), nNumber2( n2 ), nNumber3( n3 ), strData( pszData ) { }

	SMSG_SEND_DATA( int n, const char *pszMessage, int n2, int n3, int n4, const char *pszData )
		: SGameMessage( MSG_SEND_DATA ), nNumber( n ), strMessage( pszMessage  ), nNumber2( n2 ), nNumber3( n3 ), nNumber4(n4), strData( pszData ) { }

	std::string			strMessage;
	std::string			strData;
	int					nNumber;
	int					nNumber2;
	int					nNumber3;
	int					nNumber4;
};

struct SMSG_ADD_SUMMON_INFO : public SGameMessage
{
	SMSG_ADD_SUMMON_INFO() : SGameMessage(MSG_ADD_SUMMON_INFO)
	{
		card_handle   = 0;
		summon_handle = 0;
		memset( name, 0, sizeof(name) );
		code          = 0;

		// 이하 정보 필요
		level = 0;
		sp    = 0; 

	};
	AR_HANDLE				card_handle;
	AR_HANDLE				summon_handle;

	char					name[19];
	int						code;   ///< 소환수 코드

	// 이하 정보 필요
	int						level;
	int						sp;
};

struct SMSG_REMOVE_SUMMON_INFO : public SGameMessage
{
	SMSG_REMOVE_SUMMON_INFO() : SGameMessage(MSG_REMOVE_SUMMON_INFO)
	{
		card_handle = 0;
	};

	AR_HANDLE				card_handle;
};

struct SMSG_EQUIP_SUMMON : public SGameMessage
{
	SMSG_EQUIP_SUMMON() : SGameMessage(MSG_EQUIP_SUMMON)
	{
		for( int i(0); 6>i; i++ ) card_handle[i] = 0;
	};

	bool				open_dialog;
	AR_HANDLE			card_handle[ 6 ];
};

struct SMSG_REQUEST_EQUIP_SUMMON : public SGameMessage
{
	SMSG_REQUEST_EQUIP_SUMMON() : SGameMessage(MSG_REQUEST_EQUIP_SUMMON)
	{
		card_handle = 0;
	};

	AR_HANDLE			card_handle;
};

struct SMSG_CHAT_COMMAND : public SGameMessage
{
	enum
	{	
		CHAT_NONE,
		CHAT_CASHSTORAGE_OPEN, ///< 캐쉬 창고 열기
		CHAT_CASHSHOP_OPEN,    ///< 캐쉬 샵 열기
	};

	SMSG_CHAT_COMMAND( int mode ) : SGameMessage(MSG_CHAT_COMMAND), nMode(mode)
	{
	}
	int nMode;
};

struct SMSG_AURA : public SGameMessage
{
	enum
	{
		OWNER_NONE = 0,
		OWNER_LOCAL_PLAYER,
		OWNER_LOCAL_CREATURE,
	};

	SMSG_AURA()  : SGameMessage(MSG_AURA)
	{
		caster   = 0;
		skill_id = 0;
		status   = false;

		data_owner  = OWNER_NONE;
	}

	AR_HANDLE                  caster;
	int			               skill_id;
	bool                       status;
	unsigned short             data_owner;
};

struct SMSG_REQ_GUILD_ICON : public SGameMessage
{
	SMSG_REQ_GUILD_ICON( int guild_id ) : SGameMessage(MSG_REQ_GUILD_ICON), nGuild_id(guild_id)
	{
	}
	int nGuild_id;
};

struct SMSG_CHANGE_NAME : public SGameMessage
{
	SMSG_CHANGE_NAME() : SGameMessage(MSG_CHANGE_NAME)
	{
		handle  = 0;
		IsLocal = false;
		status  = 0;
	}

	AR_HANDLE                  handle;
	std::string				   m_name;
	bool					   IsLocal;
	unsigned				   status;
};


struct SMSG_OPEN_URL : public SGameMessage
{
	SMSG_OPEN_URL() : SGameMessage(MSG_OPEN_URL)
					, width( 0 )
					, height( 0 )
	{

	}

    bool              wait_for_event_scene;
	std::string		  m_strURL;

	int      width;
	int      height;
};

struct SMSG_RQ_SUMMON		: public SGameMessage
{
	SMSG_RQ_SUMMON() : SGameMessage(MSG_RQ_SUMMON)
	{
		is_summon   = 0;	///< 1이면 소환, 0이면 역소환
		card_handle = 0;
	}

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

struct SMSG_UNSUMMON : public SGameMessage
{
	SMSG_UNSUMMON() : SGameMessage(MSG_UNSUMMON)
	{
		summon_handle = 0;
	}

	AR_HANDLE			summon_handle;
};

struct SMSG_UNSUMMON_NOTICE : public SGameMessage
{
	SMSG_UNSUMMON_NOTICE() : SGameMessage(MSG_UNSUMMON_NOTICE)
	{
		summon_handle     = 0;
		unsummon_duration = 0;
	}

	AR_HANDLE                     summon_handle;
	AR_TIME                       unsummon_duration;
};

struct SMSG_SUMMON_EVOLUTION : public SGameMessage
{
	SMSG_SUMMON_EVOLUTION() : SGameMessage( MSG_SUMMON_EVOLUTION )
	{
		card_handle			=	0;
		summon_handle		=	0;
		memset( name, 0, sizeof(name) );
		code				=	0;
	}

	AR_HANDLE                     card_handle;
	AR_HANDLE                     summon_handle;
	char                          name[19];
	int                           code;
};

struct SMSG_TAMING_INFO : public SGameMessage
{
	SMSG_TAMING_INFO() : SGameMessage(MSG_TAMING_INFO)
	{
		mode          = 0;
		tamer_handle  = 0;
		target_handle = 0;
	}

	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 SMSG_MOUNT_SUMMON : public SGameMessage
{
	SMSG_MOUNT_SUMMON()	:	SGameMessage(MSG_MOUNT_SUMMON)
	{
		handle			=	0;
		summon_handle	=	0;
		x				=	0;
		y				=	0;
		success			=	true;
	}

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

struct SMSG_UNMOUNT_SUMMON : public SGameMessage
{
	SMSG_UNMOUNT_SUMMON()	: SGameMessage(MSG_UNMOUNT_SUMMON)
	{
		handle			=	0;
		summon_handle	=	0;
		flag			=	NORMAL;
	}

	AR_HANDLE              handle;
	AR_HANDLE              summon_handle;

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

struct SMSG_SUMMON_NAME_CHANGE : public SGameMessage
{
	SMSG_SUMMON_NAME_CHANGE()	: SGameMessage(MSG_SUMMON_NAME_CHANGE)
	{
		summon_handle = 0;
	}

	AR_HANDLE	summon_handle;
};


struct SMSG_SUMMON_CARD : public SGameMessage
{
	SMSG_SUMMON_CARD()	: SGameMessage(MSG_SUMMON_CARD)
	{
		card_handle = 0;
	}

	AR_HANDLE card_handle;
};

// 2010.08.06 - prodongi
struct SMSG_BOSS_MONSTER_CARD : public SGameMessage
{
	SMSG_BOSS_MONSTER_CARD() : SGameMessage(MSG_BOSS_MONSTER_CARD)
	{
		card_handle = 0;
	}
	AR_HANDLE card_handle;
};

struct SMSG_SKILL_LIST : public SGameMessage
{
	SMSG_SKILL_LIST() : SGameMessage(MSG_SKILL_LIST)
	{
		dwTime     = 0;
		target     = 0;	///< 플레이어 혹은 크리쳐
		count      = 0;
		modification_type = 0;	/// 2011.07.04 - prodongi
		pSkillInfo = NULL;
	}

	virtual ~SMSG_SKILL_LIST()
	{
		SAFE_DELETE_ARRAY( pSkillInfo );
	}

	struct SkillInfo
	{
		int				skill_id;            ///< 스킬 ID
		unsigned char   base_skill_level;    ///< 기본 스킬 레벨
		unsigned char   current_skill_level; ///< 현재 스킬 레벨
		AR_TIME         total_cool_time;     //
		AR_TIME			remain_cool_time;    ///< 남은 쿨타임 시간  1/100 초
	};

	/// 2011.07.04 - prodongi
	// 이후 따라오는 스킬 리스트가 어떤 의미를 가지는가를 의미하는열거형
	enum ModificationType
	{              
		UPDATE		= 0,   // 스킬이 업데이트됨 (기존 reset = false)
		REFRESH     = 1,   // 스킬 리스트를 갱신 (기존 reset = true)
	};
	bool isUpdate() const	{	return modification_type == UPDATE;		}
	bool isRefresh() const	{	return modification_type == REFRESH;	}

	DWORD               dwTime; ///< 발생 현재 시간
	AR_HANDLE			target;	///< 플레이어 혹은 크리쳐
	unsigned short		count;
	/// 2011.07.04 - prodongi
	unsigned char       modification_type; // enum ModificationType
	SkillInfo *         pSkillInfo;
};
	
struct SMSG_SKILL_EVENT : public SGameMessage
{
	enum
	{
		OWNER_NONE = 0,
		OWNER_LOCAL_PLAYER,
		OWNER_LOCAL_CREATURE,
	};

	SMSG_SKILL_EVENT() : SGameMessage(MSG_SKILL_EVENT)
	{
		skill_id    = 0;
		skill_level = 0;
		caster      = 0;
		target      = 0;
		x           = 0;
		y           = 0;
		z           = 0;
		layer       = 0;
		status_type = 0;
		hp_cost     = 0;
		mp_cost     = 0;
		caster_hp   = 0;
		caster_mp   = 0;

		data_owner  = OWNER_NONE;
		//target_name.clear(); // Fraun performance tweak
	}

	int			            skill_id;
	char                    skill_level;
	AR_HANDLE               caster;
	AR_HANDLE               target;
	AR_UNIT                 x,y,z;
	unsigned char           layer;
	char					status_type;
	int						hp_cost;
	int						mp_cost;
	int						caster_hp;
	int						caster_mp;

	short					data_owner;
	//std::string				target_name; // Fraun performance tweak

	struct CancelType
	{
		// 내용 없음
	};

	struct CompleteType
	{
		// 내용 없음
	};

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

	/// Region Fire일 경우에도 얘가 날아감.
	struct FireType
	{
		bool              bMultiple;             ///< true 실시간 연타
		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 만큼 따라간다

	std::vector<SkillResult>	vSkillResult;
};

//struct SMSG_SKILL_EFFECT : public SGameMessage
//{
//	SMSG_SKILL_EFFECT() : SGameMessage(MSG_SKILL_EFFECT)
//	{
//		caster = 0;
//		target = 0;
//
//		skill_id    = 0;
//		skill_level = 0;
//
//		var = 0;
//		var2 = 0;
//	}
//
//	AR_HANDLE			caster;
//	AR_HANDLE			target;
//
//	int skill_id;
//	unsigned char skill_level;
//
//	int var;	
//	unsigned char var2;
//};

//struct SMSG_SKILL_CASTING_TIME : public SGameMessage
//{
//	SMSG_SKILL_CASTING_TIME() : SGameMessage(MSG_SKILL_CASTING_TIME)
//	{
//		caster = 0;
//		tm     = 0;
//	}
//
//	AR_HANDLE                             caster;
//	AR_TIME                               tm;
//};

//==========================================================================================

struct SMSG_UPDATE_ITEM_COUNT : public SGameMessage
{
	SMSG_UPDATE_ITEM_COUNT() :  SGameMessage(MSG_UPDATE_ITEM_COUNT)
	{
		item_handle = 0;
		count       = count_t( 0 );
	}
	AR_HANDLE				item_handle;
	count_t					count;
};

struct SMSG_TRADE : public SGameMessage
{
	SMSG_TRADE() : SGameMessage(MSG_TRADE) 
	{
		rq_mode       = false;
		target_player = 0;
		mode          = 0;
		memset( &item_info, 0, sizeof(item_info) );
		bLocalPlyaer = false;
		bIncoming	 = false;
	}

	int					rq_mode;
	AR_HANDLE			target_player;
	std::string	        target_Name;
	bool				bLocalPlyaer;
	bool				bIncoming;			///< TRADE::REQUEST의 애매함 때문에 추가 (내가 신청하는 메시지나 신청받는 메시지나 똑같이 REQUEST임) - true면 신청 받는 (서버에서 오는) 메시지
	char				mode;
	TS_ITEM_INFO		item_info;
};

struct SMSG_REQUEST_BOOTH_NAME  : public SGameMessage
{
	SMSG_REQUEST_BOOTH_NAME() : SGameMessage( MSG_REQUEST_BOOTH_NAME )
	{
	}

	std::vector< AR_HANDLE >	*pvBoothList;
};

struct SMSG_UI_BOOTH : public SGameMessage
{
	SMSG_UI_BOOTH() : SGameMessage( IMSG_UI_BOOTH )
	{
		nMode = 0;
	}

	enum BOOTH_TYPE
	{
		START_BOOTH		= 0,
		END_BOOTH		= 1,
	};
	int							nBoothType;
	
	std::string					strBoothName;	
	std::vector< money_t >		vPriceList;
	std::vector< count_t >		vCountList;
	std::vector< AR_HANDLE >	vItemList;
	
	int							nMode;	///< 0이면 판매, 1이면 구매
};

struct SMSG_USE_ITEM_RESULT : public SGameMessage
{
	SMSG_USE_ITEM_RESULT() : SGameMessage(MSG_USE_ITEM_RESULT)
	{
		item_handle   = 0;
		target_handle = 0;
	}

	AR_HANDLE       item_handle;
	AR_HANDLE       target_handle;
};

struct SMSG_TAKE_ITEM_RESULT : public SGameMessage
{
	SMSG_TAKE_ITEM_RESULT() : SGameMessage( MSG_TAKE_ITEM_RESULT )
	{
		item_handle		=	0;
		item_taker		=	0;
	}
	
	AR_HANDLE              item_handle;
	AR_HANDLE              item_taker;
};	

struct SMSG_SKILLCARD_INFO : public SGameMessage
{
	SMSG_SKILLCARD_INFO() : SGameMessage(MSG_SKILLCARD_INFO) 
	{
		item_handle   = 0;
		target_handle = 0;
	}

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

struct SMSG_OPEN_STORAGE : public SGameMessage
{	
	SMSG_OPEN_STORAGE() : SGameMessage(MSG_OPEN_STORAGE)
	{
		maxStorageItemCount = 0;
	}
	int maxStorageItemCount;
};

struct SMSG_OPEN_JEWEL_EQUIP : public SGameMessage
{	SMSG_OPEN_JEWEL_EQUIP() : SGameMessage(MSG_OPEN_JEWEL_EQUIP){}	};

struct SMSG_OPEN_SOUL_REPAIR : public SGameMessage
{	SMSG_OPEN_SOUL_REPAIR() : SGameMessage(MSG_OPEN_SOUL_REPAIR){}	};

struct SMSG_CHANGE_STORAGE : public SGameMessage
{
	SMSG_CHANGE_STORAGE() : SGameMessage(MSG_CHANGE_STORAGE)
	{
		hItem = 0;
		nCount = count_t( 1 );
		nMode = 0;
	}

    AR_HANDLE hItem;
	count_t nCount;
	int nMode;
};


struct SMSG_MIX_RESULT : public SGameMessage
{
	SMSG_MIX_RESULT() : SGameMessage(MSG_MIX_RESULT)
	{
		count     = 0;
		pArHandle = NULL;
	}
	~SMSG_MIX_RESULT()
	{
		SAFE_DELETE_ARRAY( pArHandle );
	}
	unsigned		count;		///< 이하 AR_HANDLE 이 count 만큼 붙게 됨. count 가 0 이면 조합 실패.
	unsigned char	type;

	AR_HANDLE   *   pArHandle;
};

struct SMSG_ITEM_DESTROY : public SGameMessage
{
	SMSG_ITEM_DESTROY() : SGameMessage(MSG_ITEM_DESTROY)
	{
		item_handle = 0;
	}

	AR_HANDLE			item_handle;
};


// 아이템파괴 응답.
struct SMSG_ERASE_ITEM : public SGameMessage
{
	struct EraseItemInfo
	{
		//ItemBase::ItemCode	code;
		AR_HANDLE			handle;
		__int64				count;
	};
	
	unsigned char	item_count;

	EraseItemInfo * pItemInfo;

	SMSG_ERASE_ITEM() : SGameMessage(MSG_ITEM_ERASE)
	{}

	~SMSG_ERASE_ITEM()
	{
		SAFE_DELETE_ARRAY( pItemInfo );
	}
};

struct SMSG_ITEM_INVEN :  public SGameMessage
{
	SMSG_ITEM_INVEN() :  SGameMessage(MSG_ITEM_INVEN)
	{
		nItemCnt  = 0;
		pItemInfo = NULL;
	}

	virtual ~SMSG_ITEM_INVEN()
	{
		SAFE_DELETE_ARRAY( pItemInfo );
	}

	int            nItemCnt;
	TS_ITEM_INFO * pItemInfo;

	AR_HANDLE handle;
};

struct SMSG_ITEM_WEAR :  public SGameMessage
{
	SMSG_ITEM_WEAR() : SGameMessage(MSG_ITEM_WEAR)
	{
		handle = 0;
		for( int i(0); ItemBase::MAX_ITEM_SPARE_WEAR>i; i++ )
		{
			nItemCode[i]	= -1;
			nItemEnhance[i]	= -1;
			nItemLevel[i]   = -1;
			nAppearanceItemCode[i] = -1;
		}
	}
	
	AR_HANDLE handle;
	ItemBase::ItemCode	nItemCode[ItemBase::MAX_ITEM_SPARE_WEAR];
	int					nItemEnhance[ItemBase::MAX_ITEM_SPARE_WEAR];
	int					nItemLevel[ItemBase::MAX_ITEM_SPARE_WEAR];
	unsigned char		elemental_effect_type[ItemBase::MAX_ITEM_SPARE_WEAR];
	ItemBase::ItemCode	nAppearanceItemCode[ItemBase::MAX_ITEM_SPARE_WEAR];	// 2012. 7. 24 - marine
};

struct SMSG_ITEM_WEAR_INFO :  public SGameMessage
{
	SMSG_ITEM_WEAR_INFO() : SGameMessage(MSG_ITEM_WEAR_INFO)
	{
		item_handle   = 0;
		wear_position = -1;
		target_handle = 0;
		enhance		  = -1;
		appearance_code = 0;
	}

	AR_HANDLE			item_handle;
	short				wear_position;         ///< -1이면 장착 안된 아이템, 소환수의 경우는 순서대로 +1000 * n (n은 슬롯 번호)
	AR_HANDLE			target_handle;		   ///< 크리처 핸들
	int                 enhance;
	unsigned char		elemental_effect_type;
	ItemBase::ItemCode			appearance_code;
};



struct SMSG_ITEM_DROP :  public SGameMessage
{
	SMSG_ITEM_DROP() : SGameMessage(MSG_ITEM_DROP_RESULT) 
	{
		item_handle = 0;
		isAccepted	= true;
	}
	AR_HANDLE	item_handle;
	bool		isAccepted;
};

struct SMSG_ITEM_DROP_INFO : public SGameMessage
{
	SMSG_ITEM_DROP_INFO() : SGameMessage(MSG_ITEM_DROP_INFO)
	{
		monster_handle = 0;
		item_handle    = 0;
	}

	AR_HANDLE                     monster_handle;
	AR_HANDLE                     item_handle;
};

struct SMSG_ITEM_TAKE :  public SGameMessage
{
	SMSG_ITEM_TAKE() :  SGameMessage(MSG_ITEM_TAKE_RESULT) {}

	TS_ITEM_INFO	item_info;
};

//==========================================================================================

//struct SMSG_SKILL_RESULT : public SGameMessage
//{
//	SMSG_SKILL_RESULT() : SGameMessage(MSG_SKILL_RESULT)
//	{
//		pSrc         = NULL;//Src
//		pDst         = NULL;//Dest
//		dwStartTime  = 0;	//Cur Time
//		fSpeed       = 1.f;	//Speed
//		nCount       = 0;	//Count
//	}
//
//	SGameObject * pSrc;			//Src
//	SGameObject * pDst;			//Dest
//	DWORD		  dwStartTime;	//Cur Time
//	float		  fSpeed;		//Speed
//	unsigned int  nCount;		//Count
//	std::string   strProjectile;//발사체
//	std::string   strAniName;	//Animation Type
//};
//
//struct SMSG_SPELL_RESULT : public SGameMessage
//{
//	SMSG_SPELL_RESULT() : SGameMessage(MSG_SPELL_RESULT)
//	{
//		pSrc         = NULL;//Src
//		pDst         = NULL;//Dest
//		dwStartTime  = 0;	//Cur Time
//		fSpeed       = 1.f;	//Speed
//		nCount       = 0;	//Count
//		nProcessType = 0;	//연출 Type
//	}
//
//	SGameObject * pSrc;			//Src
//	SGameObject * pDst;			//Dest
//	DWORD		  dwStartTime;	//Cur Time
//	float		  fSpeed;		//Speed
//	unsigned int  nCount;		//Count
//	std::string   strProjectile;//발사체
//	unsigned int  nProcessType;	//연출 Type
//};

struct SMSG_CMD_RESULT   : public SGameMessage
{
	SMSG_CMD_RESULT()  : SGameMessage(MSG_CMD_RESULT)
	{

	}

	std::string   strAniName;	///< Animation Type
};

//==========================================================================================

struct SMSG_CHATTING : public SGameMessage
{
	SMSG_CHATTING() : SGameMessage(MSG_CHATTING)
	{
		handle    = 0;
		len       = 0;
		nChatType = 0;		///< CHAT_NORMAL;
		nNoticeOnly = 0;
	}

	AR_HANDLE		handle;
	unsigned short	len;
	int             nChatType;
	std::string     szSender;
	std::string     strText;
	int nNoticeOnly;		///< 공지 채팅만 출력할 것인지 체크, kappamind.
};

struct SMSG_CHATTING_REQUEST : public SGameMessage
{	
	SMSG_CHATTING_REQUEST() : SGameMessage(MSG_CHATTING_REQUEST)
	{
		memset( szTarget, 0, sizeof(szTarget) );
		request_id = 0;
		type       = 0;		///< CHAT_NORMAL;
		nSize      = sizeof( *this );
	}

	char			szTarget[21];
	unsigned char	request_id;
	unsigned char	type;
	std::string     strText;
};

struct SMSG_MARKET : public SGameMessage
{
	SMSG_MARKET() : SGameMessage(MSG_MARKET)
	{
		item_count = 0;   ///< 수 만큼 ItemInfo이 뒤에 붙음.
		pItemInfo  = NULL;
	}
	
	~SMSG_MARKET()
	{
		SAFE_DELETE_ARRAY( pItemInfo );
	}

	struct ItemInfo
	{
		ItemBase::ItemCode	code;
		__int64				price;
		int					huntaholic_point; // #2.1.2.11.1
		int					arena_point;	/// 2012.07.20 아레나 포인트 - prodongi
	};

	AR_HANDLE               npc_handle;    ///< NULL 일수도 있음. ( NPC가 보내지 않은 특수한 경우 )
	unsigned short			item_count;
	ItemInfo           *    pItemInfo;
};


struct SMSG_NPC_DIALOG : public SGameMessage
{
	SMSG_NPC_DIALOG() : SGameMessage(MSG_NPC_DIALOG) 
	{ 
		npc_handle = 0;
		nQuestCode = 0;
		nQuestTextID = 0; 
	}

	enum
	{
		BUTTON_NORMAL			= 0,
		BUTTON_QUEST_STARTABLE,
		BUTTON_QUEST_INPROGRESS,
		BUTTON_QUEST_FINISHABLE,

		BUTTON_DUNGEON_STONE,
		BUTTON_DONATION_PROP,
	};

	struct DLGMENU
	{
		std::string strMenuName;
		std::string strTrigger;
		int			nButtonType;

		DLGMENU( const char* szMenuName, const char* szTrigger, int nType = BUTTON_NORMAL )
			: strMenuName( szMenuName ), strTrigger( szTrigger ), nButtonType( nType ) { }
	};

	int         nDialogType;
	AR_HANDLE   npc_handle;		///< NULL 일수도 있음. ( NPC가 보내지 않은 특수한 경우 )
	int			nQuestCode;		///< Quest code...
	int			nQuestTextID;	///< Quest text...
	std::string strTitle;
	STRING_VECTOR vtTexts;
	std::vector<DLGMENU> vtMenus;
};

struct SMSG_TOOFAR_AS_CONTACTEDNPC : public SGameMessage
{
	SMSG_TOOFAR_AS_CONTACTEDNPC() : SGameMessage( MSG_TOOFAR_AS_CONTACTEDNPC ) { }
};

struct SMSG_CAMERA_EFFECT :  public SGameMessage
{
	SMSG_CAMERA_EFFECT() : SGameMessage(MSG_CAMERA_EFFECT)
	{
		nEffect = 0;
		fDeltaX = fDeltaY = 0.f;
		dwKeepTime = 0;
	};

	int		nEffect;
	float	fDeltaX;
	float	fDeltaY;
	DWORD	dwKeepTime;
};

//===================================================================================================
/// 시스템 메시지
struct STMSG_TIMESYNC :  public SGameMessage
{
	STMSG_TIMESYNC() : SGameMessage(TMSG_TIMESYNC)
	{
		time = 0;
	}

	AR_TIME	time;
};

struct STMSG_CHANGEAVATAR : public SGameMessage
{
	STMSG_CHANGEAVATAR( AR_HANDLE hPlayer )
		: SGameMessage( TMSG_CHANGEAVATAR ), handle( hPlayer ) { }

	AR_HANDLE handle;
};

struct STMSG_REQ_CLOSE : public SGameMessage
{
	STMSG_REQ_CLOSE( bool bByWndMsg = true )
		: SGameMessage( TMSG_REQ_CLOSE ), m_bByWndMsg( bByWndMsg ) { }

	bool m_bByWndMsg;
};

struct STMSG_REQ_CLOSE_EX : public SGameMessage
{
	STMSG_REQ_CLOSE_EX()
		: SGameMessage( TMSG_REQ_CLOSE_EX )
	{ 
	}
};

struct STMSG_SYSTEM_OPTION : public SGameMessage
{
	enum _OPTION_TYPE
	{
		SYSOPTION_BLOOMEFFECT,
		SYSOPTION_TEXQUALITY,
		SYSOPTION_BACKGROUND,
		SYSOPTION_BGSOUND,
		SYSOPTION_EFFECTSOUND,
        
		// 차후 추가
		SYSOPTION_RESOLUTION,
		SYSOPTION_SCREENBIT,
		SYSOPTION_BRIGHT,
		SYSOPTION_MODELING,
		SYSOPTION_SHADOW,
		SYSOPTION_CHARACTER,
		SYSOPTION_PROP,

		SYSOPTION_MAINSOUND,
		SYSOPTION_SURROUNDSOUND,
		SYSOPTION_FACECUT,
		SYSOPTION_MINIMAP,
		SYSOPTION_ZOOM,
	};
	STMSG_SYSTEM_OPTION( _OPTION_TYPE Type, int nOption )
		: SGameMessage( TMSG_SYSTEM_OPTION ), m_Type( Type ), m_nOption( nOption ) { }

	_OPTION_TYPE m_Type;
	int m_nOption;
};

struct STMSG_REQ_SYSTEM_OPTION : public SGameMessage
{
	STMSG_REQ_SYSTEM_OPTION( STMSG_SYSTEM_OPTION::_OPTION_TYPE Type )
		: SGameMessage( TMSG_REQ_SYSTEM_OPTION ), m_Type( Type ), m_nGetOption( 0 ) { }

	STMSG_SYSTEM_OPTION::_OPTION_TYPE m_Type;
	int m_nGetOption;
};

//===================================================================================================
/// Cheating 메세지
struct SCMSG_WARP : public SGameMessage
{
	SCMSG_WARP() : SGameMessage(CMSG_WARP)
	{
		x = y = z = 0;
		layer	=	0;
	}
	AR_UNIT				x,y,z;
	unsigned char		layer;
};

struct SMSG_CONSOLE_BUILDER : public SGameMessage
{
	SMSG_CONSOLE_BUILDER() : SGameMessage(MSG_CONSOLE_BUILDER), m_nValueCount( 0 ), m_bOut( false ), m_nCommandType( 0 )
	{}
	~SMSG_CONSOLE_BUILDER()
	{
		m_vecValueList.clear();
	}

	enum KEY_TYPE
	{
		TYPE_GAME = 0,
		TYPE_OPTION,
		TYPE_DEBUG,
		TYPE_LUA,
		TYPE_DB,
	};

    bool m_bOut;
	int m_nCommandType;

	std::string m_strKey;
	int m_nValueCount;
	std::vector<std::string> m_vecValueList;
};

//////////////////////////////////////////////////////////////////////////
/// 지역 관련
struct SMSG_CHANGE_LOCATION : public SGameMessage
{
	SMSG_CHANGE_LOCATION()  : SGameMessage( MSG_CHANGE_LOCATION )
	{
		prev_location_id	=	0;
		cur_location_id		=	0;
	}

	int prev_location_id;
	int cur_location_id;
};

//////////////////////////////////////////////////////////////////////////
/// 날씨 관련
struct SMSG_GET_WEATHER_INFO : public SGameMessage
{
	SMSG_GET_WEATHER_INFO() : SGameMessage( MSG_GET_WEATHER_INFO )
	{
		region_id		=	0;
	}
	unsigned int region_id;
};

struct SMSG_WEATHER_INFO : public SGameMessage
{
	SMSG_WEATHER_INFO()   : SGameMessage( MSG_WEATHER_INFO )
	{
		region_id		=	0;
		weather_id		=	0;
	}
 
    enum
    {
       CLEAR = 0, CLOUDY = 1, FOGGY = 2, DRIZZLINGLY = 3, RAINY = 4, SNOWY = 5,
    };

	unsigned int	region_id;
    unsigned short weather_id;
};

struct SMSG_TURN_ON_PK_MODE : public SGameMessage
{
	SMSG_TURN_ON_PK_MODE()	:	SGameMessage( MSG_TURN_ON_PK_MODE )
	{}
};
struct SMSG_TURN_OFF_PK_MODE : public SGameMessage
{
	SMSG_TURN_OFF_PK_MODE() : SGameMessage( MSG_TURN_OFF_PK_MODE )
	{}
};
struct SMSG_EMOTION : public SGameMessage
{
	SMSG_EMOTION() : SGameMessage( MSG_EMOTION )
	{
		handle			=	0;
		emotion			=	0;
	}

	AR_HANDLE	handle;
	int			emotion;
};
struct SMSG_GAME_TIME : public SGameMessage
{
	SMSG_GAME_TIME() : SGameMessage( MSG_GAME_TIME )
	{
		t			=	0;
		game_time	=	0;
	}
	
	AR_TIME t;
	time_t game_time;
};

// sonador 3.10.2	PC 방 혜택 관련 라크 획득 시스템 메시지 변경
struct SMSG_GET_CHAOS : public SGameMessage
{
	SMSG_GET_CHAOS() : SGameMessage( MSG_GET_CHAOS )
	{
		hPlayer			=	0;
		hCorpse			=	0;
		nChaos			=	0;
		nBonusType		=	CHAOS_BONUS_NONE;
		nBonusPercent	=	0;
		nBonus			=	0;
	}

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

	AR_HANDLE		hPlayer;
	AR_HANDLE       hCorpse;
	int				nChaos;
	char			nBonusType;
	unsigned char	nBonusPercent;
	int             nBonus;
};

/// 기공
struct SMSG_ENERGY : public SGameMessage
{
	SMSG_ENERGY() : SGameMessage( MSG_ENERGY )
	{
		handle		=	0;
		energy		=	0;
	}

	AR_HANDLE			handle;
	short				energy;
};

struct SMSG_ITEM_COOL_TIME : public SGameMessage
{
	SMSG_ITEM_COOL_TIME() : SGameMessage( MSG_ITEM_COOL_TIME )
	{}

	AR_TIME cool_time[TS_SC_ITEM_COOL_TIME::MAX_ITEM_COOLTIME_GROUP];
};

struct SMSG_STATE_RESULT : public SGameMessage
{
	SMSG_STATE_RESULT()    : SGameMessage( MSG_STATE_RESULT )
	{}

	AR_HANDLE				caster_handle;
	AR_HANDLE				target_handle;

    int                     code;
	unsigned short			level;

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

    bool					final;
    int						total_amount;
	
/*	AR_HANDLE				caster_handle;
	AR_HANDLE				target_handle;
	int						target_hp;
    int                     code;
	unsigned short			level;
    int						damage;
    bool					final;
    int						total_damage;*/
};

struct SMSG_PARTY_COMMAND : public SGameMessage
{
	enum
	{	
		PARTY_NONE,
		PARTY_CREATE,	///< 파티 생성
		PARTY_INVITE,   ///< 파티 초대
		PARTY_KICK,     ///< 파티 추방
		PARTY_DESTROY,  ///< 파티 파괴
		PARTY_LEAVE,    ///< 파티 탈퇴
		PARTY_TRANSFER, ///< 파티 양도
		PARTY_OPTION,   ///< 파티 옵션
	};

	SMSG_PARTY_COMMAND() : SGameMessage( MSG_PARTY_COMMAND )
	{
		mode = PARTY_NONE;
	}
	
	SMSG_PARTY_COMMAND( int _mode, const char * pStrName ) : SGameMessage( MSG_PARTY_COMMAND ),
		mode( _mode ), strName( pStrName )
	{
	}

	int			mode;
	std::string strName;
};

struct SMSG_FRIEND_COMMAND : public SGameMessage
{
	enum
	{	
		FRIEND_NONE,
		FRIEND_ADD,		///< 친구 추가
		FRIEND_DELETE,	///< 친구 삭제
		CUT_ADD,		///< 차단 추가
		CUT_DELETE,		///< 차단 삭제
	};

	SMSG_FRIEND_COMMAND( int nmode, const char* lpName ) : SGameMessage( MSG_FRIEND_COMMAND ), strName(lpName), mode(nmode)
													     , target( 0 )
	{}
	
	int			mode;
	std::string strName;
	AR_HANDLE	target;
};

struct SMSG_ALLIANCE_COMMAND : public SGameMessage
{
	enum
	{	
		ALLIANCE_NONE,
		ALLIANCE_ADD,		///< 친구 추가
		ALLIANCE_DELETE,	///< 친구 삭제
	};

	SMSG_ALLIANCE_COMMAND( int nmode, const char* lpName ) : SGameMessage( MSG_ALLIANCE_COMMAND ), strName(lpName), mode(nmode){}
	
	int			mode;
	std::string strName;
};

struct SMSG_CHAT_RESULT : public SGameMessage
{
	SMSG_CHAT_RESULT() : SGameMessage( MSG_CHAT_RESULT )
	{}

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


struct SMSG_SCRIPT_SHOW_WINDOW : public SGameMessage
{
	SMSG_SCRIPT_SHOW_WINDOW() : SGameMessage( MSG_SCRIPT_SHOW_WINDOW )
	{

	}

	std::string strWindow;   ///< 윈도우 열어라
	std::string strTrigger;  ///< 트리거
	std::string strArgument; ///< 이름이나, 기타 등등
};


struct SMSG_TAKEOUT_COMMERCIAL_ITEM : public SGameMessage
{
	SMSG_TAKEOUT_COMMERCIAL_ITEM() : SGameMessage( MSG_TAKEOUT_COMMERCIAL_ITEM )
	{
		commercial_item_uid = 0;
		count               = 0;
	}

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

struct SMSG_BELT_SLOT_INFO : public SGameMessage
{
	SMSG_BELT_SLOT_INFO() : SGameMessage( MSG_BELT_SLOT_INFO ) { }

	AR_HANDLE              handle[8];
};


struct SMSG_COMMERCIAL_STORAGE_INFO : public SGameMessage
{
	SMSG_COMMERCIAL_STORAGE_INFO() : SGameMessage( MSG_COMMERCIAL_STORAGE_INFO )
	{
		total_item_count = 0;
		new_item_count   = 0;
	}

	unsigned       short total_item_count;
	unsigned       short new_item_count;
};

struct SMSG_COMMERCIAL_STORAGE_LIST : public SGameMessage
{
	SMSG_COMMERCIAL_STORAGE_LIST() : SGameMessage( MSG_COMMERCIAL_STORAGE_LIST )
	{
		
	}

	unsigned short count;

	std::vector<TS_SC_COMMERCIAL_STORAGE_LIST::CommercialItemInfo> vItemList;
};

struct SMSG_QUEST_UPDATA : public SGameMessage
{
	SMSG_QUEST_UPDATA() : SGameMessage( MSG_QUEST_UPDATA )
	{}

	int	nQuestID;
	int	nStatus[QuestInstance::MAX_STATUS];
	std::string strOldQuest;
	unsigned char nProgress;
};

// 2011.07.12 - servantes
struct SMSG_END_QUEST : public SGameMessage
{
	SMSG_END_QUEST( int _code, unsigned char _nOptionalReward ) 
		: SGameMessage( MSG_END_QUEST ), quest_code(_code), nOptionalReward(_nOptionalReward)
	{}
	int           quest_code;
    unsigned char nOptionalReward;
};

struct SMSG_RESURRECTION : public SGameMessage
{
	SMSG_RESURRECTION( AR_HANDLE owner, int useitem, bool compete, bool deathmatch = false ) : SGameMessage( IMSG_RESURRECTION )
													  , hOwner( owner )
													  , nUseItem( useitem )
													  , bCompete( compete )
													  , bDeathmatch( deathmatch )
	{
	}

	AR_HANDLE	hOwner;			// Normal resurrection
	int			nUseItem;		// Resurrection by an item
	bool		bCompete;		// After duel
	bool		bDeathmatch;	// When dead in deathmatch

};

/// 플레이어가 타 플레이어에게 대련 요청
struct SMSG_CS_COMPETE_REQUEST : public SGameMessage
{
	SMSG_CS_COMPETE_REQUEST() : SGameMessage( MSG_CS_COMPETE_REQUEST )
	{
	}

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

/// 대련 요청받은 플레이어에게 요청 전달
struct SMSG_SC_COMPETE_REQUEST : public SGameMessage
{
	SMSG_SC_COMPETE_REQUEST() : SGameMessage( MSG_SC_COMPETE_REQUEST )
	{
	}

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

/// 대련 요청받은 플레이어가 응답
struct SMSG_CS_COMPETE_ANSWER : public SGameMessage
{
	SMSG_CS_COMPETE_ANSWER() : SGameMessage( MSG_CS_COMPETE_ANSWER )
	{
	}

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

/// 최초 대련 요청에 대한 결과 전달(수락/거부/자동거부)
struct SMSG_SC_COMPETE_ANSWER : public SGameMessage
{
	SMSG_SC_COMPETE_ANSWER() : SGameMessage( MSG_SC_COMPETE_ANSWER )
	{
	}

	unsigned char compete_type;          ///< _COMPETE_TYPE 값이 사용됨
	unsigned char answer_type;           ///< _COMPETE_ANSWER_TYPE 값이 사용됨
	char          requestee[ 31 ];       ///< 도전 받은 플레이어 
};

/// 대련 시작 전 카운트 다운 개시
struct SMSG_SC_COMPETE_COUNTDOWN : public SGameMessage
{
	SMSG_SC_COMPETE_COUNTDOWN() : SGameMessage( MSG_SC_COMPETE_COUNTDOWN )
	{
	}

	unsigned char compete_type;          ///< _COMPETE_TYPE 값이 사용됨
	char          competitor[ 31 ];      ///< 도전 받은 플레이어 
	AR_HANDLE     handle_competitor;     ///< 상대방플레이어핸들(1:1 PVP에서만 사용됨)
};


/// 대련 시작
struct SMSG_SC_COMPETE_START : public SGameMessage
{
	SMSG_SC_COMPETE_START() : SGameMessage( MSG_SC_COMPETE_START )
	{
	}

	unsigned char compete_type;          ///< _COMPETE_TYPE 값이 사용됨
	char          competitor[ 31 ];      ///< 도전 받은 플레이어 
};

/// 대련 종료(결과  방송)
struct SMSG_SC_COMPETE_END : public SGameMessage
{
	SMSG_SC_COMPETE_END() : SGameMessage( MSG_SC_COMPETE_END )
	{
	}

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

struct SMSG_CS_RANKING_TOP_RECORD : public SGameMessage
{
	SMSG_CS_RANKING_TOP_RECORD() : SGameMessage( MSG_CS_RANKING_TOP_RECORD )
	{
	}

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

struct SMSG_SC_RANKING_TOP_RECORD : public SGameMessage
{
	SMSG_SC_RANKING_TOP_RECORD() : SGameMessage( MSG_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		ranking_record[10];
};

struct SMSG_SC_CREATE_SECURITY_NO : public SGameMessage	
{
	SMSG_SC_CREATE_SECURITY_NO() : SGameMessage( MSG_SC_CREATE_SECURITY_NO )
	{}
};

struct SMSG_REQUEST_SECURITY_NO	: public SGameMessage
{
	SMSG_REQUEST_SECURITY_NO() : SGameMessage( MSG_REQUEST_SECURITY_NO )
	{}

	enum { SC_NONE, SC_OPEN_STORAGE };

	int			mode; ///< 0 - None, 1 - Storage open
};

struct SMSG_SECURITY_NO	: public SGameMessage
{
	SMSG_SECURITY_NO() : SGameMessage( MSG_SECURITY_NO )
	{}

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

struct SMSG_CS_CREATE_SECURITY_NO : public SGameMessage
{
	SMSG_CS_CREATE_SECURITY_NO() : SGameMessage( MSG_CS_CREATE_SECURITY_NO )
	{}

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

struct SMSG_CHANGE_SECURITY_NO : public SGameMessage
{
	SMSG_CHANGE_SECURITY_NO() : SGameMessage( MSG_CHANGE_SECURITY_NO )
	{}

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

struct SMSG_CS_REQUEST_SECURITY_NO_CHANGE : public SGameMessage
{
	SMSG_CS_REQUEST_SECURITY_NO_CHANGE() : SGameMessage( MSG_CS_REQUEST_SECURITY_NO_CHANGE )
	{}
};

struct SMSG_CS_REQUEST_CLEAR_SECURITY_NO : public SGameMessage
{
	SMSG_CS_REQUEST_CLEAR_SECURITY_NO() : SGameMessage( MSG_CS_REQUEST_CLEAR_SECURITY_NO )
	{}
	
};

struct SMSG_SC_CLEAR_SECURITY_NO : public SGameMessage
{
	SMSG_SC_CLEAR_SECURITY_NO() : SGameMessage( MSG_SC_CLEAR_SECURITY_NO )
	{
	}

	bool	clearable;
};

struct SMSG_CS_CLEAR_SECURITY_NO : public SGameMessage
{
	SMSG_CS_CLEAR_SECURITY_NO() : SGameMessage( MSG_CS_CLEAR_SECURITY_NO )
	{
	}

	char	password[19];
	char	security_no[19];
};
/*
const int MSG_CS_REQUEST_CLEAR_SECURITY_NO	= 141;
const int MSG_SC_CLEAR_SECURITY_NO			= 142;
const int MSG_CS_CLEAR_SECURITY_NO			= 143;
*/

struct SMSG_SC_CHANGE_SECURITY_NO : public SGameMessage
{
	SMSG_SC_CHANGE_SECURITY_NO() : SGameMessage( MSG_SC_CHANGE_SECURITY_NO )
	{
	}
};

struct SMSG_NPC_TRADE_INFO : public SGameMessage
{
	SMSG_NPC_TRADE_INFO() : SGameMessage( MSG_NPC_TRADE_INFO )
	{
	}

	bool				is_sell;
	ItemBase::ItemCode	code;
	count_t				count;
	money_t				price;
	money_t				huntaholic_point; // #2.1.2.11.1
	money_t				arena_point;

	AR_HANDLE			target;

	void operator = ( const TS_SC_NPC_TRADE_INFO& rhs )
	{
		this->is_sell			= rhs.is_sell;
		this->code				= rhs.code;
		this->count				= count_t( rhs.count );
		this->price				= money_t( rhs.price );
		this->huntaholic_point	= money_t( rhs.huntaholic_point ); // #2.1.2.11.1
		this->arena_point       = money_t(rhs.arena_point);

		this->target			= rhs.target;
	}
};

//1:1 대련 관련 챗팅 메시지 수정
// 2009-01-30:hunee
// struct SMSG_WHISPER_ADDONWND : public SGameMessage
// {
// 	SMSG_WHISPER_ADDONWND() : SGameMessage( MSG_WHISPER_ADDONWND )
// 	{
// 	}
// 
// 	AR_HANDLE	target;
// 
// 	struct Challenge
// 	{
// 	};
// 
// 	struct Whisper
// 	{
// 	};
// };

// 2009.02.24 대련 수정
struct SMSG_COMMAND_BY_ADDONWND : public SGameMessage
{
	enum COMMAND_TYPE
	{
		COMMAND_CHALLENGE = 0,
		COMMAND_WHISPER,
		COMMAND_MAX,
	};

	COMMAND_TYPE command_type;

	SMSG_COMMAND_BY_ADDONWND( COMMAND_TYPE type ) : SGameMessage( MSG_COMMAND_BY_ADDONWND )
		, command_type( type )
	{
	}

	AR_HANDLE	target;

	struct Challenge
	{
	};

	struct Whisper
	{
	};
};

struct SMSG_GAME_OUT : public SGameMessage
{
	SMSG_GAME_OUT()
		: SGameMessage( MSG_GAME_OUT )
		, character_select( false )
	{}

	bool	character_select;	///< true캐릭 선택 화면 false면 게임 종료
};


/// sonador 1.8.5	자동 따라가기 구현
struct SMSG_AUTO_FOLLOW : public SGameMessage
{
	SMSG_AUTO_FOLLOW() : SGameMessage( MSG_AUTO_FOLLOW ) {}
};

// sonador 10.2.1	팻 시스템 구현
/**----------------------------------------------------------------------------------------
	@struct SMSG_UNSUMMON_PET
	@brief	unsummon pet
	@author	sonador
----------------------------------------------------------------------------------------*/
struct SMSG_UNSUMMON_PET : public SGameMessage
{
	SMSG_UNSUMMON_PET() : SGameMessage( MSG_UNSUMMON_PET )
	{
		pet_handle = 0;
	}
	AR_HANDLE	pet_handle;
};

/**----------------------------------------------------------------------------------------
	@struct SMSG_ADD_PET_INFO
	@brief	add a information about pet to game
	@author	sonador
-----------------------------------------------------------------------------------------*/
struct SMSG_ADD_PET_INFO : public SGameMessage
{
	SMSG_ADD_PET_INFO() : SGameMessage( MSG_ADD_PET_INFO )
	{
		pet_handle	= 0;
		code        = 0;
		memset( name, 0, sizeof(name) );
	};
	AR_HANDLE	pet_handle;		//!< pet handle
	AR_HANDLE	cage_handle;	//<! cage handle
	int			code;			//!< pet code
	char		name[19];		//!< name of pet
};

/**----------------------------------------------------------------------------------------
	@struct SMSG_REMOVE_PET_INFO
	@brief	remove a information about pet from game
	@author	sonador
-----------------------------------------------------------------------------------------*/
struct SMSG_REMOVE_PET_INFO : public SGameMessage
{
	SMSG_REMOVE_PET_INFO() : SGameMessage( MSG_REMOVE_PET_INFO )
	{
		pet_handle = 0;
	};
	AR_HANDLE	pet_handle;	//<! pet handle which must be removed from game
};

/**----------------------------------------------------------------------------------------
	@struct SMSG_REMOVE_PET_INFO
	@brief	message from server means need to show an ui for changing name of pet
	@author	sonador
-----------------------------------------------------------------------------------------*/
struct SMSG_SHOW_SET_PET_NAME : public SGameMessage
{
	SMSG_SHOW_SET_PET_NAME() : SGameMessage( MSG_SHOW_SET_PET_NAME ) 
	{
		pet_handle = 0;
	}
	AR_HANDLE	pet_handle;	//<! handle
};

// #2.1.2.11.1 {
// 헌터홀릭 인스턴스 던전 목록
struct SMSG_HUNTAHOLIC_INSTANCE_LIST : public SGameMessage
{
	SMSG_HUNTAHOLIC_INSTANCE_LIST() : SGameMessage( MSG_HUNTAHOLIC_INSTANCE_LIST ), instance_info( 0 ) {}
	~SMSG_HUNTAHOLIC_INSTANCE_LIST() 
	{ 
		SAFE_DELETE_ARRAY( instance_info ); 
	}

	int		huntaholic_id;	///< 헌터홀릭 ID
	int		page;			///< 현재 페이지 번호
	int		count;			///< 현재 페이지에 해당하는 인스턴스 던전 개수
	int		total_page;		///< 전체 인스턴스 던전 개수
	
	TS_HUNTAHOLIC_INSTANCE_INFO*	instance_info;	///< 이 뒤로 TS_HUNTAHOLIC_INSTANCE_INFO 가 count 개 만큼 이어 붙음
};

/// 헌터홀릭 인스턴스 던전 정보(현재 소속된 던전만)
struct SMSG_HUNTAHOLIC_INSTANCE_INFO : public SGameMessage
{
	SMSG_HUNTAHOLIC_INSTANCE_INFO() : SGameMessage( MSG_HUNTAHOLIC_INSTANCE_INFO ) {}

	TS_HUNTAHOLIC_INSTANCE_INFO	info;
};

/// 헌터홀릭 인스턴스 던전 사냥 결과
struct SMSG_HUNTAHOLIC_HUNTING_SCORE : public SGameMessage
{
	SMSG_HUNTAHOLIC_HUNTING_SCORE() : SGameMessage( MSG_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: 일반방, 1.0초과: 올림방)
	int		gain_point;			///< 최종 계산된 획득 포인트
	char	is_retired;			///< 0: 성공 / 1: 사망 / 2: 실패 // sonador #2.1.2.9.3	헌터홀릭 시스템 수정(사망/실패 구분)
};

/// 헌터홀릭 인스턴스 던전 사냥 중 점수 갱신
struct SMSG_HUNTAHOLIC_UPDATE_SCORE : public SGameMessage
{
	SMSG_HUNTAHOLIC_UPDATE_SCORE() : SGameMessage( MSG_HUNTAHOLIC_UPDATE_SCORE ) {}

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

/// 헌터홀릭 로비에서 던전으로 입장, 사냥 시작
struct SMSG_HUNTAHOLIC_BEGIN_HUNTING : public SGameMessage
{
	SMSG_HUNTAHOLIC_BEGIN_HUNTING() : SGameMessage( MSG_HUNTAHOLIC_BEGIN_HUNTING ) {}
	AR_TIME begin_time;
};

struct SMSG_HUNTAHOLIC_BEGIN_COUNTDOWN : public SGameMessage
{
	SMSG_HUNTAHOLIC_BEGIN_COUNTDOWN() : SGameMessage( MSG_HUNTAHOLIC_BEGIN_COUNTDOWN ) {}
};

// #2.1.2.11.1 }



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

struct SMSG_ENTER_EVENTAREA : public SGameMessage
{
	SMSG_ENTER_EVENTAREA( int _id, int _pNum ) 
		: SGameMessage( MSG_ENTER_EVENTAREA ), nID(_id), nPolyNum(_pNum)
	{}
	int		nID;
	int		nPolyNum;
};

struct SMSG_LEAVE_EVENTAREA : public SGameMessage
{
	SMSG_LEAVE_EVENTAREA( int _id, int _pNum )    // 2011.07.06 - servantes / nPolyNum 추가
		: SGameMessage( MSG_LEAVE_EVENTAREA ), nID(_id), nPolyNum(_pNum)   // 2011.07.06 - servantes / nPolyNum 추가
	{}
	int		nID;
	int		nPolyNum;  // 2011.07.06 - servantes / nPolyNum 추가
};


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

struct SMSG_INSTANCE_GAME_ENTER : public SGameMessage
{
	enum INSTANCE_TYPE
	{
        HUNTAHOLIC_BEAR_ROAD          = 0,
        RANKED_DEATHMATCH             = 1,
		FREED_DEATHMATCH              = 2,
	};

	SMSG_INSTANCE_GAME_ENTER ( int _type ) 
		: SGameMessage( IMSG_INSTANCE_GAME_ENTER )
		, instance_game_type(_type)
	{}
	
	int								instance_game_type;

};


struct SMSG_INSTANCE_GAME_EXIT : public SGameMessage
{	
	SMSG_INSTANCE_GAME_EXIT () 
		: SGameMessage( IMSG_INSTANCE_GAME_EXIT )		
	{}	

};

struct SMSG_INSTANCE_GAME_SCORE : public SGameMessage
{	
	SMSG_INSTANCE_GAME_SCORE (	unsigned int _holicpoint, 
								unsigned int _bearroad_ranking, 
								unsigned int _deathmatch_kill_count, 
								unsigned int _deathmatch_death_count
							)
		: SGameMessage( IMSG_INSTANCE_GAME_SCORE )		
			, holicpoint(_holicpoint)
			, bearroad_ranking(_bearroad_ranking)
			, deathmatch_kill_count(_deathmatch_kill_count)
			, deathmatch_death_count(_deathmatch_death_count)
	{}	
	
	unsigned int           holicpoint;
	unsigned int           bearroad_ranking;
    unsigned int           deathmatch_kill_count;
    unsigned int           deathmatch_death_count;

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

};
	
struct SMSG_INSTANCE_GAME_SCORE_REQUEST : public SGameMessage
{
	SMSG_INSTANCE_GAME_SCORE_REQUEST(bool _activeAddedWnd = false)
		: SGameMessage( MSG_INSTANCE_GAME_SCORE_REQUEST ), activeAddedWnd(_activeAddedWnd)	
	{}
	bool activeAddedWnd;	/// 2011.05.26 added window 활성화 여부
};

// 스킬레벨의변동이발생
// 2010.3.9 : hunee 
struct SMSG_ADDED_SKILL_LIST : public SGameMessage
{
	SMSG_ADDED_SKILL_LIST() : SGameMessage( MSG_ADDED_SKILL_LIST ), pAddedSkillInfo( 0 )
	{
		target     = 0;	///< 플레이어 혹은 크리쳐
		count      = 0;
	}
	~SMSG_ADDED_SKILL_LIST() 
	{ 
		SAFE_DELETE_ARRAY( pAddedSkillInfo ); 
	}

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

    AR_HANDLE              target;
    unsigned short         count;

	AddedSkillInfo * pAddedSkillInfo;
};

struct SMSG_HAIR_INFO        : public SGameMessage
{
	SMSG_HAIR_INFO() : SGameMessage( MSG_HAIR_INFO )
	{
		hPlayer = 0;
		nHairID = 0;
		nHairColorIndex = 0;
		nHairColorRGB = 0;
	}

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


// 2010.05.19 HIDE_EQUIP_INFO - prodongi
struct SMSG_HIDE_EQUIP_INFO : public SGameMessage
{
	SMSG_HIDE_EQUIP_INFO() : SGameMessage(MSG_HIDE_EQUIP_INFO)
	{
		hPlayer = 0;
		nHideEquipFlag = 0;
	}
	AR_HANDLE      hPlayer;
	unsigned int   nHideEquipFlag;
};


// 길드. Guild bintitle.
struct SMSG_GUILD_COMMAND : public SGameMessage
{
	enum
	{
		GUILD_NOTICE,				// 길드공지.
		GUILD_MEMBER_MEMO,			// 길드원 메모.
		GUILD_AUTHORITY,			// 길드원 권한.
		GUILD_AUTHORITY_SET,		// 길드권한등급 비트플래그(권한세트)
		GUILD_AUTHORITY_CLASS_NAME, // 길드 등급명.
		GUILD_INVITATION,			// 길드 초대.
		GUILD_DESTROY,				// 길드 해산.
		GUILD_PROMOTE,				// 길드장 인계.
		GUILD_RAID,					// 공격대정보.
		GUILD_BUFF,
		GUILD_DONATE,
		GUILD_UPGRADE,

};

	explicit SMSG_GUILD_COMMAND( int mode ) : SGameMessage(MSG_GUILD_COMMAND), nMode( mode )
	{}

	SMSG_GUILD_COMMAND( int mode, std::string & _strNotice ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strMemo( _strNotice )
	{} 

	SMSG_GUILD_COMMAND( int mode, std::string & _strName, std::string & _strMemo ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strName( _strName ), strMemo( _strMemo )
	{} // 길드 공지. // 길드원 메모.

	SMSG_GUILD_COMMAND( int mode, std::string & _strName, int _nClass ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), strName( _strName ), nClass( _nClass )
	{} // 길드원 권한등급.
	   // 길드 등급명.

	SMSG_GUILD_COMMAND( int mode, int _nClass, int _nClassBitSet ) : SGameMessage(MSG_GUILD_COMMAND), nMode(mode), nClass( _nClass ), nClassBitSet( _nClassBitSet )
	{} // 권한등급비트셋

	int nMode;
	int nClass;				// 권한등급.
	int nClassBitSet;		// 권한등급비트셋.
	std::string strName;	// 캐릭터명.
	std::string strMemo;	// 메모.	 
};

/// 2011.01.17 - prodongi
struct SMSG_MARK_STATUS_CHANGE : public SGameMessage
{
	enum	{	PVP = 1 << 0,	PK_NORMAL = 1 << 1, PK_DEMONIAC = 1 << 2	};
	SMSG_MARK_STATUS_CHANGE(AR_HANDLE handle, int status) : SGameMessage(IMSG_MARK_STATUS_CHANGE)
	{
		m_status = status;
		m_handle = handle;
	}
	int m_status;
	AR_HANDLE m_handle;
};

struct SMSG_TITLE_LIST : public SGameMessage
{
	SMSG_TITLE_LIST( ) : SGameMessage(MSG_TITLE_LIST), count(0), pListInfo(NULL){}
	virtual ~SMSG_TITLE_LIST(){	SAFE_DELETE_ARRAY(pListInfo);	}
	struct TS_TITLE_INFO
	{
		int     code;
		int     status;
	};

	enum{
	TITLE_STATUS_OPEN		= ( 1 << 0 ),
	TITLE_STATUS_ACHIEVE	= ( 1 << 1 ),
	TITLE_STATUS_BOOKMARK	= ( 1 << 2 )
	};

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

struct SMSG_TITLE_CONDITION_LIST : public SGameMessage
{
	SMSG_TITLE_CONDITION_LIST() : SGameMessage(MSG_TITLE_CONDITION_LIST), count(0), pListInfo(NULL){}
	virtual ~SMSG_TITLE_CONDITION_LIST(){	SAFE_DELETE_ARRAY(pListInfo);	}
	
	struct TS_TITLE_CONDITION_INFO
	{
		int type;
		__int64 count;
	};

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

struct SMSG_TITLE_REMAIN_TIME : public SGameMessage
{
	SMSG_TITLE_REMAIN_TIME() : SGameMessage(MSG_TITLE_REAMIN_TIME){}

	AR_TIME remain_title_time;
};

struct SMSG_TITLE_SET_MAIN_TITLE : public SGameMessage
{
	SMSG_TITLE_SET_MAIN_TITLE() : SGameMessage(MSG_TITLE_SET_MAIN_TITLE) {}

	int handle;
	int code;
};

struct SMSG_TITLE_SET_SUB_TITLE : public SGameMessage
{
	SMSG_TITLE_SET_SUB_TITLE() : SGameMessage(MSG_TITLE_SET_SUB_TITLE) {}

	int index;
	int code;
};

struct SMSG_TITLE_BOOKMARK_TITLE : public SGameMessage
{
	SMSG_TITLE_BOOKMARK_TITLE() : SGameMessage(MSG_TITLE_BOOKMARK){}

	int code;
	bool bookmarked;
};

struct SMSG_TITLE_ACHIEVE_TITLE : public SGameMessage
{
	SMSG_TITLE_ACHIEVE_TITLE() : SGameMessage(MSG_TITLE_ACHIEVE){}

	int code;
};

struct SMSG_TITLE_OPEN_TITLE : public SGameMessage
{
	SMSG_TITLE_OPEN_TITLE() : SGameMessage(MSG_TITILE_OPEN){}

	int code;
};

struct SMSG_TITLE_CHANGE_CONDITION : public SGameMessage
{
	SMSG_TITLE_CHANGE_CONDITION() : SGameMessage(MSG_TITLE_CHANGE_CONDITION){}

	int condition_id;
	__int64 count;
};


// 크리처 농장 정보  // servantes 2011.02.23
struct SMSG_CREATURE_FARM_INFO : public SGameMessage
{
    SMSG_CREATURE_FARM_INFO() : SGameMessage(MSG_CREATURE_FARM_INFO), pInfoList(NULL), creature_count(0) {}
	~SMSG_CREATURE_FARM_INFO()
	{
		SAFE_DELETE_ARRAY(pInfoList);
	}

    char                                         creature_count;

    struct SMSG_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 구조체가 따라옴.
	SMSG_SUMMON_INFO* pInfoList;
};

// 크리처 맡기기 결과
struct SMSG_RESULT_FOSTER : public SGameMessage
{
        SMSG_RESULT_FOSTER() : SGameMessage(MSG_RESULT_FOSTER), result(0) {}

        char                         result;
};

// 크리처 돌보기 결과
struct SMSG_RESULT_NURSE : public SGameMessage
{
        SMSG_RESULT_NURSE() : SGameMessage(MSG_RESULT_NURSE), result(0) {}

        char                         result;
};

// 크리처 꺼내기 결과
struct SMSG_RESULT_REGAIN : public SGameMessage
{
        SMSG_RESULT_REGAIN() : SGameMessage(MSG_RESULT_RETRIEVE), result(0) {}

        char                         result;
};

/// 2011.03.29 출력에 필요한 아이템 카드 인포가 들어 있다 - prodongi
struct SMSG_SUMMON_CARD_ITEM_INFO : public SGameMessage
{
	SMSG_SUMMON_CARD_ITEM_INFO()	: SGameMessage(MSG_SUMMON_CARD_ITEM_INFO)
	{
		level = 0;
	}

	int level;
	TS_ITEM_BASE_INFO item_info;
};

/// 2011.05.12 우클릭 유도 - prodongi
struct SMSG_SKILL_LEVEL_LIST : public SGameMessage
{
	SMSG_SKILL_LEVEL_LIST() : SGameMessage(MSG_SKILL_LEVEL_LIST), list(NULL), count(0) {}
	~SMSG_SKILL_LEVEL_LIST()
	{
		SAFE_DELETE_ARRAY(list);
	}
	struct SkillLevelInfo
	{
		int skill_id;
		unsigned char skill_level;
	};
	unsigned short count;
	SkillLevelInfo* list;
};

/// 2011.10.26 - prodongi
struct SMSG_GENERAL_MESSAGE_BOX : public SGameMessage
{
	SMSG_GENERAL_MESSAGE_BOX() : SGameMessage(MSG_GENERAL_MESSAGE_BOX) {}
	~SMSG_GENERAL_MESSAGE_BOX()	{	m_text.clear();	}

	std::string m_text;
};

/// 2012.06.05 아레나 관련 구조체 추가 - prodongi
struct SMSG_BATTLE_ARENA_JOIN_QUEUE : public SGameMessage
{
	SMSG_BATTLE_ARENA_JOIN_QUEUE() : SGameMessage(MSG_BATTLE_ARENA_JOIN_QUEUE) {}

	int arenaId;
	_BATTLE_GRADE grade;	/// 클라에서는 LocalPlayer의 레벨을 판단다면 되기 때문에 굳이 쓰이지는 않고 있다.
};

struct SMSG_BATTLE_ARENA_LEAVE : public SGameMessage
{
	SMSG_BATTLE_ARENA_LEAVE() : SGameMessage(MSG_BATTLE_ARENA_LEAVE) {}

	_ARENA_LEAVE_TYPE leaveType;
	char name[ 19 ];
};

struct SMSG_BATTLE_ARENA_BATTLE_INFO : public SGameMessage
{
	enum {	MAX_TEAM_NUM = 2 };	/// 연합군, 마녀군, sArenaSystemInfo::MAX_TEAM_NUM과 같다

	SMSG_BATTLE_ARENA_BATTLE_INFO() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_INFO)
	{
		for (int i = 0; i < MAX_TEAM_NUM; ++i)
			playerInfo[i] = NULL;
	}
	~SMSG_BATTLE_ARENA_BATTLE_INFO()
	{
		for (int i = 0; i < MAX_TEAM_NUM; ++i)
			SAFE_DELETE_ARRAY(playerInfo[i]);
	}

	int arenaId;
	// 패킷 수신자 개인 종속적인 내용
	AR_TIME forceEnterTime;
	// 경기 종속적인 내용(점수는 별도의 패킷이 있으므로 제외)
	AR_TIME				startTime;
	_BATTLE_GRADE	 grade;
	AR_TIME endTime;
	unsigned char playerCountPerTeam[MAX_TEAM_NUM];

	struct sPlayerInfo
	{
		AR_HANDLE handle;				// handle == 0 이면 오프라인 유저
		int jobID;
		char name[ 19 ];		// 기존에 AR_HANDLE과 묶인 이름 정보가 있더라도 가명에 의해 다른 이름이 지정될 수 있음
	};

	sPlayerInfo* playerInfo[MAX_TEAM_NUM];
};

struct SMSG_BATTLE_ARENA_EXERCISE_READY_STATUS : public SGameMessage
{
	SMSG_BATTLE_ARENA_EXERCISE_READY_STATUS() : SGameMessage(MSG_BATTLE_ARENA_EXERCISE_READY_STATUS) {}
	int readyState;
};

struct SMSG_BATTLE_ARENA_BATTLE_STATUS : public SGameMessage
{
	SMSG_BATTLE_ARENA_BATTLE_STATUS() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_STATUS) {}
	_PROP_STATE GetPropState( int nPropIndex ) const		{ assert( nPropIndex >= 0 && nPropIndex < 9 ); return static_cast< _PROP_STATE >( ( status >> ( nPropIndex * 2 ) ) & 0x3 ); }
	bool IsActivatedBingoLine( int nLineIndex )				{ assert( nLineIndex >= 0 && nLineIndex < 8 ); return ( ( status >> 24 ) & ( 1 << nLineIndex ) ) != 0; }

	int status;
};

struct SMSG_BATTLE_ARENA_BATTLE_SCORE : public SGameMessage
{
	SMSG_BATTLE_ARENA_BATTLE_SCORE() : SGameMessage(MSG_BATTLE_ARENA_BATTLE_SCORE)
	{
		playerScore = NULL;
	}
	~SMSG_BATTLE_ARENA_BATTLE_SCORE()
	{
		SAFE_DELETE_ARRAY(playerScore);
	}

	struct sTeamScore
	{
		short		totalKillCount;	// 각 팀별 킬 수 총합
		short		totalDeathCount;	// 각 팀별 데스 수 총합
		short		score;				// 각 팀별 현재 점수
	};
	struct sPlayerScore
	{
		char		name[ 19 ];
		short		killCount;
		short		deathCount;
		short		propActivateCount;
		int			totalGainAP;
	};

	sTeamScore		teamScore[ 2 /* GameRule::BATTLE_ARENA_MAX_TEAM_COUNT */ ];
	unsigned char	playerScoreCount;
	sPlayerScore* playerScore;
};

struct SMSG_BATTLE_ARENA_JOIN_BATTLE : public SGameMessage
{
	SMSG_BATTLE_ARENA_JOIN_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_JOIN_BATTLE) {}

	int				teamNo;
	AR_HANDLE	handle;
	int				jobID;
	char			name[ 19 ];
};

struct SMSG_BATTLE_ARENA_DISCONNECT_BATTLE : public SGameMessage
{
	SMSG_BATTLE_ARENA_DISCONNECT_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_DISCONNECT_BATTLE) {}

	AR_HANDLE handle;
};

struct SMSG_BATTLE_ARENA_RECONNECT_BATTLE : public SGameMessage
{
	SMSG_BATTLE_ARENA_RECONNECT_BATTLE() : SGameMessage(MSG_BATTLE_ARENA_RECONNECT_BATTLE) {}

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

struct SMSG_BATTLE_ARENA_RESULT : public SGameMessage
{
	SMSG_BATTLE_ARENA_RESULT() : SGameMessage(MSG_BATTLE_ARENA_RESULT), mvp(NULL) {}
	~SMSG_BATTLE_ARENA_RESULT()
	{
		SAFE_DELETE_ARRAY(mvp);
	}

	/*
	// 아레나 경기 종료 타입
	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	endType;
	_ARENA_REWARD_TYPE rewardType;
	int	winnerTeamNo;		// 0: 연합군, 1:마녀군

	struct sMvp
	{
		char name[19];
	};
	unsigned char		mvpCount;
	sMvp* mvp;
};

struct SMSG_BATTLE_ARENA_ABSENCE_CHECK : public SGameMessage
{
	SMSG_BATTLE_ARENA_ABSENCE_CHECK() : SGameMessage(MSG_BATTLE_ARENA_ABSENCE_CHECK) {}

	AR_TIME limitTime;
};

struct SMSG_BATTLE_ARENA_PENALTY_INFO : public SGameMessage
{
	SMSG_BATTLE_ARENA_PENALTY_INFO() : SGameMessage(MSG_BATTLE_ARENA_PENALTY_INFO) {}

	AR_TIME blockTime;
	int penaltyCount;
	AR_TIME penaltyCountTime;
};

struct SMSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT : public SGameMessage
{
	SMSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT() : SGameMessage(MSG_BATTLE_ARENA_UPDATE_WAIT_USER_COUNT) {}

	int waitUserCount;
};

struct SMSG_BATTLE_ARENA_PROMOTE : public SGameMessage
{
	SMSG_BATTLE_ARENA_PROMOTE() : SGameMessage(MSG_BATTLE_ARENA_PROMOTE) {}
};


struct SMSG_KMOVE : public SGameMessage
{
	SMSG_KMOVE() : SGameMessage(MSG_KMOVE)
	{ 
		handle     = 0;
		start_time = 0;
		bReqMove   = false;
		pos_target = K3DVector(0,0,0); 
		speed      = 0; 
	}
	~SMSG_KMOVE()
	{
		m_vecMoveInfo.clear();
	}

	AR_HANDLE    handle;
	AR_TIME		start_time;

	bool		bReqMove;

	K3DVector pos_target; ///< 이동 할 위치

	unsigned char speed;
	
	std::vector< ArPosition >	m_vecMoveInfo;
};


struct SMSG_DECOMPOSE_DO : public SGameMessage
{
	SMSG_DECOMPOSE_DO()
	: SGameMessage( IMSG_DECOMPOSE_DO )
	{
	}

	struct IN_DATA
	{
		IN_DATA() { _handle = 0; _count = 1; }
		AR_HANDLE _handle;
		unsigned int _count;
	};

	vector<IN_DATA>	m_vecItemData;
};


struct SMSG_DECOMPOSE_RESULT : public SGameMessage
{
	SMSG_DECOMPOSE_RESULT()
	: SGameMessage( IMSG_DECOMPOSE_RESULT )
	{
	}

	typedef struct stDecomposeInfo
	{
		AR_HANDLE	m_hItem;
		UINT		m_nItemCount;
		
		stDecomposeInfo()
		:	m_hItem( NULL )
		,	m_nItemCount( NULL )
		{
		}
	}DECOMPOSE_INFO, *PDECOMPOSE_INFO;

	vector<DECOMPOSE_INFO>	m_vecItemInfo;
};


struct SMSG_CHANGE_SKIN_COLOR : public SGameMessage
{
	SMSG_CHANGE_SKIN_COLOR()
	:	SGameMessage( MSG_CHANGE_SKIN_COLOR )
	,	hPlayer( NULL )
	,	dwSkinColor( NULL )
	{
	}

	AR_HANDLE	hPlayer;
	DWORD		dwSkinColor;
};




struct SMSG_PARTYMATCH_MEMBER : public SGameMessage
{
	SMSG_PARTYMATCH_MEMBER():	SGameMessage( MSG_PARTYMATCH_MEMBER )
	{
	}

	int				nRoom;
	AR_HANDLE		nMaster;		// master ID 아래에 pMeber중 하나가 이와 같은 값이다.
	STRUCT_PARTYMATCH_MEMBER pMember[PARTYMATCH_MEMBER_MAX];
};

struct SMSG_PARTYMATCH_LIST : public SGameMessage
{
	SMSG_PARTYMATCH_LIST()
	:	SGameMessage( MSG_PARTYMATCH_LIST )
	{
	}

	int	nPage;
	int nRoomTotal;
	STRUCT_PARTYMATCH_ROOM pRoom[PARTYMATCH_ROOM_PAGE];
};


struct SMSG_PARTYMATCH_ACTION : public SGameMessage
{
	SMSG_PARTYMATCH_ACTION()
	:	SGameMessage( MSG_PARTYMATCH_ACTION )
	{
	}

	int				nAction;
	int				nPage;	
	AR_HANDLE		nMaster;		// master ID 아래에 pMeber중 하나가 이와 같은 값이다.
	STRUCT_PARTYMATCH_ROOM stRoom;
};

#pragma pack()