#pragma once

#include "DNPacket.h"
#include "MemPool.h"

/*--------------------------------------------------------------------------
					Server쪽에서 쓰는 모든것들(?)
--------------------------------------------------------------------------*/

// const ----------------------------------------------------------------------------------------------

#if defined(_CH)
const WCHAR* const SQLPASSWORD = L"4795CEA6409d492";
const WCHAR* const SQLHOSTNAME = L"A2A375E23370f8a";
const WCHAR* const SQLAPPNAME = L"C98D23990E1119a";
#elif defined(_JP)
const WCHAR* const SQLPASSWORD = L"945C437D6632718";
//const WCHAR* const SQLPASSWORD = L"A443131C-2988-4C3E-9974-37033B2A0A33";
const WCHAR* const SQLHOSTNAME = L"E4C874F3D920ced";
const WCHAR* const SQLAPPNAME = L"2001C72210299d0";
#elif defined(_TW)
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
#elif defined(_US) 
const WCHAR* const SQLPASSWORD = L"BACF8969BB00b2d";
const WCHAR* const SQLHOSTNAME = L"04B3944622a7c5b";
const WCHAR* const SQLAPPNAME = L"33518A83865e269";
#elif defined(_SG)
const WCHAR* const SQLPASSWORD = L"4708A804794d233";
const WCHAR* const SQLHOSTNAME = L"D3B8367356e19d7";
const WCHAR* const SQLAPPNAME = L"3A222498E96c63f";
#elif defined(_TH)
const WCHAR* const SQLPASSWORD = L"gozjtoRldi!*";
const WCHAR* const SQLHOSTNAME = L"rjfflausenlwlsek@#@";
const WCHAR* const SQLAPPNAME = L"roshatlRl!#";
#elif defined(_ID)
const WCHAR* const SQLPASSWORD = L"skQmsgozj!*sha";
const WCHAR* const SQLHOSTNAME = L"rhdqntlzlsi)*^";
const WCHAR* const SQLAPPNAME = L"rotoRjwuqjfu!#";
#elif defined(_RU) 
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
#elif defined(_KAMO)  //[OK_Cash]  
const WCHAR* const SQLPASSWORD = L"3A6A7D31A8c6415";
const WCHAR* const SQLHOSTNAME = L"3B74FB5B269bf5d";
const WCHAR* const SQLAPPNAME = L"4A54A42ED0381e3";
#elif defined(_EU)
const WCHAR* const SQLPASSWORD = L"110C37F5B9fb934";
const WCHAR* const SQLHOSTNAME = L"D8FA71CD6Ee2479";
const WCHAR* const SQLAPPNAME = L"518BD8D722e2f6b";
#else
const WCHAR* const SQLPASSWORD = L"428A44DC4Eebd12";
const WCHAR* const SQLHOSTNAME = L"CF0EEDCEF386298";
const WCHAR* const SQLAPPNAME = L"D121240B6419392";
#endif // #if defined( _US )

const WCHAR* const SQLActozMembershipDBPassword = L"dnaccount$dnest7h.o.t.44_2";
const WCHAR* const SQLActozWorldDBPassword = L"dndb$dnest50h.o.t.44_2";
const WCHAR* const SQLActozCommonDBPassword_Test = L"devdb$game9mingi44_2";
const WCHAR* const SQLActozCommonDBPassword = L"dncomdb$game60mingi44_2";

#if defined( PRE_ADD_DWC )
const WCHAR* const DWCPREFIX = L"DWCGM_";
const int DWCPREFIXLEN			= 6;
#endif // #if defined( PRE_ADD_DWC )

const char DBSERVERMAX			= 16;
const char THREADMAX			= 8;	// DB THREAD
const char LOGINTIMELENMAX		= 20;	// last login time length max
const char TIMELENMAX = 20;				// 데이트타임 타입

const int LOGINCOUNTMAX				= 64;			// 총 로그인 서버 개수
const int LOGINCONCOUNTINFOTERM		= (1*30*1000);	// 로그인 서버 현재 동시접속자 정보 마스터 서버에 보고 제한간격 (단위:ms)
const int LOGINSERVERLISTSORTTERM	= (1*3*1000);	// 로그인 서버 세션 정렬 제한간격 (단위:ms)
const int MASTERCOUNTMAX			= 10;			// 총 마스터 서버 개수

const int  DELETECHAR_WAITTIME_MINUTE	= 7*24*60;	// 7일
const BYTE PROCESSCOUNT = 40;	// 초당 오브젝트 처리개수

const int INTERNALBUFFERLENMAX = 51200;

const UINT PROCESSBUFFERLENMAX = 1024 * 64;
const UINT WORKERBUFFERLENMAX = 1024 * 64;

const int QUESTSIZEINFO = 2775;

const int QUERYOVERTIME = 1000;

const int QUERYNAMESIZE = 200; // 쿼리 최대 크기
const int GAMEDELAYSIZE = 200; // 게임딜레이 로그 최대 크기

const int SERVERDETACHPACKETSIZE = 1024*40;	// 패킷전송시 버퍼사이즈크기
//const variable.
#ifdef _FINAL_BUILD
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_PARTY = 120 * 1000;								//최초 게임서버 컨넥트 대기 시간
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_SINGLE = 120 * 1000;
const unsigned long WAIT_FOR_ANOTHER_USER_TIME_LIMIT = 15 * 1000;						//최초인원이 컨넥을 하고 다른인원을 기다리는 시간
const unsigned long WAIT_FOR_LOAD_TIME_LIMIT = 60 * 1000;								//데이타베이스의 로딩을 기다리는 시간
const unsigned long GOGO_SING_TO_PLAY_FOR_WAIT_TIME_LIMIT = 2 * 60 * 1000;					//클라이언트 로딩과 싱크를 기다리는 시간
const unsigned long GOGO_SING_TO_FARMPLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000;			//농장로딩 시간은 초큼 별개로
#else
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_PARTY = 60 * 1000;								//최초 게임서버 컨넥트 대기 시간
const unsigned long RUDP_CONNECT_TIME_LIMIT_FOR_SINGLE = 120 * 1000;
const unsigned long WAIT_FOR_ANOTHER_USER_TIME_LIMIT = 60 * 1000;						//
const unsigned long WAIT_FOR_LOAD_TIME_LIMIT = 150 * 1000;								//
const unsigned long GOGO_SING_TO_PLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000;				//
const unsigned long GOGO_SING_TO_FARMPLAY_FOR_WAIT_TIME_LIMIT = 5 * 60 * 1000;			//농장로딩 시간은 초큼 별개로
#endif

const int EACH_GAMESERVER_MAX_ROOM_COUNT = 20;
const int EACH_GAMESERVER_MAX_USER_COUNT = 100;

const int INTERVALDELETE_TIMINGTICK = 1000 * 60;		//1분쯤??...-_-;
const int CHECK_ZOMBIE_DISCONNECT_TICK = 1000 * 60 * 5;
const int DISTRIBUTE_IDLE_TICK = 1000 * 5;

const int DELAYED_PRCESS_CHECKTICK = 1000 * 10;
const int DELAYED_PRCESS_LOG_COUNT = 10;
const int FRAMEDEADLINE = 17;

const int EVENTMAPSTRMAX = 50;

const int CHECKLIVETICK = 60000 * 2;//  * 5;	// 핵쉴드 5분 마다 체크 -> 1분으로 바꾸라고 해서 바꿈 -> 2분으로 늘림
const int CHECKRESPONSETICK = 60000 * 3;		// 핵쉴드 응답 시간 (3분정도?)

const int CHECKGPKFIRSTTICK = 1000 * 60 * 2;	// 최초 검사타이밍
const int CHECKGPKTICK = 60000;
const int MANAGEDMAX = 20;

#if !defined(_FINAL_BUILD)
const DWORD CHECK_TCP_PING_TICK	= 1000*30*1;	// 1분
const DWORD CHECK_UDP_PING_TICK = 1000*30*1;	// 1분
#else		//#if !defined(_FINAL_BUILD)
const DWORD CHECK_TCP_PING_TICK	= 1000*60*1;	// 1분
const DWORD CHECK_UDP_PING_TICK = 1000*60*1;	// 1분
#endif		//#if !defined(_FINAL_BUILD)

#if defined(_CH)
const int CHECKLOGINUSERKICKTICK = 30 * 60 * 1000;		// 로그인 서버에 30분 동안 머물면 강퇴!(중국만)
#else
const int CHECKLOGINUSERKICKTICK = 15 * 60 * 1000;		// 로그인 서버에 15분 동안 머물면 강퇴!
#endif //#if defined(_CH)
const int CHECKNOTAUTHLOGINUSERKICKTICK = 5 * 60 * 1000;  // 로그인 서버에 인증되지 않은체 5분 동안 머물면 강퇴!

const unsigned int DEFAULTUSERSESSIONID = 10000;

const unsigned int CASHDELUSERDELAY_LIMITTICK = (4*30*1000);

// DB 누적작업 관련 개수
const int DBQUERYSTREAMDATAMAX			= (36*1024);	// DB 누적작업 데이터 최대 크기			: DB 서버에 바로 송신되는 대신 큐에 누적 후 일괄처리가 필요한 데이터 구조체 중 가장 큰 것을 기준으로 설정 → 크기가 부족할 경우 지속적인 재조정 필요 예상
const unsigned int DBQUERYAUTOCHKSUM	= 0xE41C723F;	// DB 쿼리 직렬화 처리 시 체크값

const int QUESTINVENBLANKCHECKMIN	= 2;				// 퀘스트 인벤토리 체크 시 메시지 발송이 되는 최소 개수
const float MAX_ITEMPRICE_RATE = 0.5f;

#if defined(_FINAL_BUILD)
const int BEGINAUTHLIMITSEC			= (9*10);			// 최초 인증 제한시간 (단위:초, 0 이하는 무제한 대기 ?)
const int CHECKAUTHLIMITSEC			= (6*10);			// 일반 인증 제한시간 (단위:초)
const int BEGINAUTHLIMITTERM		= (BEGINAUTHLIMITSEC*1000);		// 최초 인증 제한간격 (단위:ms)
//const int CHECKAUTHLIMITTERM		= (CHECKAUTHLIMITSEC*1000);		// 일반 인증 제한간격 (단위:ms)
const int CHECKAUTHLIMITTERM		= (1*30*1000);		// 일반 인증 제한간격 (단위:ms)		// P.S.> 던전, PVP 등 컨텐츠 참여자들의 불편사항을 고려하여 기존 시간보다 짧게 정함
#else	// _FINAL_BUILD
const int BEGINAUTHLIMITSEC			= (6*10);			// 최초 인증 제한시간 (단위:초, 0 이하는 무제한 대기 ?)
const int CHECKAUTHLIMITSEC			= (4*10);			// 일반 인증 제한시간 (단위:초)
const int BEGINAUTHLIMITTERM		= (BEGINAUTHLIMITSEC*1000);		// 최초 인증 제한간격 (단위:ms)
//const int CHECKAUTHLIMITTERM		= (CHECKAUTHLIMITSEC*1000);		// 일반 인증 제한간격 (단위:ms)
const int CHECKAUTHLIMITTERM		= (1*20*1000);		// 일반 인증 제한간격 (단위:ms)		// P.S.> 던전, PVP 등 컨텐츠 참여자들의 불편사항을 고려하여 기존 시간보다 짧게 정함
#endif	// _FINAL_BUILD

const int RESETAUTHLISTMAX			= (1000);			// 인증정보 목록 초기화 크기 (주의!!! - 본 전역상수를 사용하는 패킷들이 송신/수신 패킷 크기를 넘지 않아야 함)
const int RESETAUTHLISTTERM			= (1*1000);			// 인증정보 목록 초기화 작업주기 (단위:ms)
const int RESETAUTHSERVERTERM		= (5*1000);			// 인증정보 서버 초기화 작업주기 (단위:ms)
const int RESETAUTHWORLDCHECKTERM	= (5*1000);			// 인증정보 월드 초기화 작업주기 (단위:ms)
const int RESETAUTHWORLDLIMITTERM	= (2*30*1000);		// 인증정보 월드 초기화 제한시간 (단위:ms)

const int GETAUTHUSERCOUNT = 1000 * 10;					// 인증월드유저 카운트 획득주기

const int GUILDMGRCHKTERM = (5*1000);					// 길드 관리자 체크 주기
const int GUILDMGRUPDTERM = (10*1000);					// 길드 관리자 갱신 주기
const int GUILDCHKMEMBTERM = (30*1000);					// 길드 멤버정보 체크 주기
const int GUILDCHKRESCTERM = (30*1000);					// 길드 자원반납 체크 주기
const int GUILDREQINFOTERM = (60*1000);					// 길드 정보요청 체크 주기
const int GUILDRFSVIEWTERM = (10*1000);					// 길드 시각정보 갱신 주기
const int GUILDAPLPOINTTERM = (10*1000);				// 길드 일반/래더 포인트 DB 적용 주기
const int GUILDCHKRESCLIMIT = (2*30*1000);				// 길드 자원반납 체크 제한

const int PERIODQUESTTERM = (60*1000);					// 기간제 퀘스트 갱신 주기

const int PERIODGUILDWARTERM = (60*1000);				// 길드전 갱신 주기
const int GUILDWARMISSION_MAXGROUP = 4;

const int SERVICEMANAGER_SERVERDEALY_SIZE = 1000;
const int SERVICEMANAGER_REPORT_SIZE = 4096;

#define SWAP16(x) (((((x) & 0xff) << 8) | (((x) >> 8) & 0xff)))
#define SWAP32(x) (((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)))
#define SWAP64(x) (((((x) & 0xFF00000000000000ULL) >> 56) | (((x) & 0x00FF000000000000ULL) >> 40) | (((x) & 0x0000FF0000000000ULL) >> 24) | (((x) & 0x000000FF00000000ULL) >>  8) | \
	(((x) & 0x00000000FF000000ULL) <<  8) | (((x) & 0x0000000000FF0000ULL) << 24) | (((x) & 0x000000000000FF00ULL) << 40) | (((x) & 0x00000000000000FFULL) << 56)))

struct DNProcessCheck
{
	enum eDNProcessCheck
	{
		Key					= 0x00000001,
		DisconnectInterval	= 60*1000*2,
		UpdateInterval		= 10*1000,
		HeartbeatKey		= 0x00000002,
		SQLHeartbeatInterval = 60*1000*10,
		SelectIPMagicInterval = 60*1000*60,
	};
};

// enum ----------------------------------------------------------------------------------------------
enum eServerType
{
	SERVERTYPE_LOGIN,		// 로그인 서버
	SERVERTYPE_DB,			// DB 서버
	SERVERTYPE_VILLAGE,		// 빌리지 서버
	SERVERTYPE_GAME,		// 게임 서버
	SERVERTYPE_MASTER,		// 마스터 서버
	SERVERTYPE_LOG,			// 로그 서버
	SERVERTYPE_MAX,
};

enum ePatchType
{
	PATCHTYPE_LOGIN,		// 로그인 서버
	PATCHTYPE_DB,			// DB 서버
	PATCHTYPE_VILLAGE,		// 빌리지 서버
	PATCHTYPE_GAME,			// 게임 서버
	PATCHTYPE_MASTER,		// 마스터 서버
	PATCHTYPE_LOG,			// 로그 서버
	PATCHTYPE_PATCHER,		// ESM
	PATCHTYPE_CASH,			// 캐쉬 서버
};

enum eConnectionKey
{
	CONNECTIONKEY_DEFAULT = 0,
	CONNECTIONKEY_USER,
	CONNECTIONKEY_LOGIN,
	CONNECTIONKEY_DB,
	CONNECTIONKEY_VILLAGE,
	CONNECTIONKEY_GAME,
	CONNECTIONKEY_MASTER,
	CONNECTIONKEY_LOG,
	CONNECTIONKEY_LAUNCHER,
	CONNECTIONKEY_SERVICEMANAGER,
	CONNECTIONKEY_AUTH,		// 인증섭(넥슨)
	CONNECTIONKEY_CASH,
	CONNECTIONKEY_BILLING,	// 빌링섭(퍼블리셔)
	CONNECTIONKEY_SERVICEPATCHER,
	CONNECTIONKEY_SERVERMONITOR,
	CONNECTIONKEY_TW_AUTHLOGIN,	// 인증섭(감마니아 1 - Authorization : 사용자 계정 인증 처리, 상태 (블록 여부, 캐쉬 잔여 포인트 ?) 체크)
	CONNECTIONKEY_TW_AUTHLOGOUT,	// 인증섭(감마니아 2 - Logout : 사용자 로그아웃 처리)
	CONNECTIONKEY_TW_QUERY,
	CONNECTIONKEY_TW_SHOPITEM,
	CONNECTIONKEY_TW_COUPON,	// 감마니아 쿠폰서버
	CONNECTIONKEY_TW_COUPON_ROLLBACK,	// 감마니아 쿠폰롤백..징그러운것들 서버를 포트별로 만들다니..ㅠ
	CONNECTIONKEY_TH_AUTH,
	CONNECTIONKEY_TH_OTP,
	CONNECTIONKEY_TH_QUERY,
	CONNECTIONKEY_TH_SHOPITEM,
	CONNECTIONKEY_DOORS,
};

enum eAcceptOpenVerifyType
{
	ACCEPTOPEN_VERIFY_TYPE_APPINITCOMPLETE = 0,
	ACCEPTOPEN_VERIFY_TYPE_MASTERCONNECTION,
	ACCEPTOPEN_VERIFY_TYPE_RESETAUTH,
	ACCEPTOPEN_VERIFY_TYPE_MAX,
};

enum eServerLogLevel
{
	ServerLogLevel_1 = 1,
	ServerLogLevel_2 = 2,
	ServerLogLevel_3 = 3,
};

enum eUserState		// login에서 쓰는 상태값
{
	STATE_NONE,

	// login
	STATE_CHECKVERSION,
	STATE_CHECKLOGIN,		// 아이디 패스워드 확인상태
	STATE_SERVERLIST,
	STATE_WAITUSER,			// 대기유저
	STATE_CHARLIST,			// 캐릭터 리스트 상태
	STATE_CHANNELLIST,
	STATE_CONNECTVILLAGE,	// 빌리지 서버에 접속가능상태
	STATE_CONNECTGAME,		// 겜 서버에 접속가능상태
	STATE_RECONNECTLOGIN,	// 리커넥트 상태

	// master
	STATE_CHECKVILLAGE,		//빌리지로 넘어가기전의 상태입니다. 유저가 끊길경우 고아가 되므로 이 스테이트를 통해서 관리됩니다.
	STATE_CHECKGAME,		//게임으로 넘어가기 전의 상태입니다. 상동
	STATE_CHECKRECONNECTLOGIN,	//캐릭터선택창으로 넘어가기 전의 상태입니다. 상동
	STATE_VILLAGE,			// village상태인가
	STATE_GAME,				// game상태인가
	STATE_LOGIN,			// login상태인가

	// village
	STATE_LOADUSERDATA,		// 유저데이터 DB에서 불러왔는지
	STATE_READY,			// 필드 나갈 준비 완료
	STATE_READYTOVILLAGE,	// village 딴 장비로 옮길때 (준비단계)
	STATE_READYTOGAME,		// game으로 넘어갈때 (준비단계)
	STATE_READYTOLOGIN,		// login으로 넘어갈때 (준비단계)
	STATE_MOVETOVILLAGE,	// village 딴 장비로 옮길때
	STATE_MOVETOGAME,		// game으로 넘어갈때
	STATE_MOVETOLOGIN,		// login으로 넘어갈때
	STATE_MOVESAMECHANNEL,	// 같은 채널 이동

#if defined(_HSHIELD)
	HSHIELD_NONE = 0,
	HSHIELD_RESPONSEVERSION = 1,	// checkversion 패킷 받은 상태
	HSHIELD_RECONNECTLOGIN,		// 재접속 패킷 받은 상태
	HSHIELD_LOADUSER,			// 디비 로드 끝낸상태
	HSHIELD_REQUEST,			// _AhnHS_MakeRequest 요청상태
	HSHIELD_RESPONSE,			// 응답온 상태
#endif	// _HSHIELD

};

//enumulation
//GameRoom
enum eGameRoomState
{
	_GAME_STATE_NONE,					//생성!
	_GAME_STATE_READY2CONNECT,			//초기화 완료 컨넥션 대기! 상태
	_GAME_STATE_CONNECT2CHECKAUTH,		//DB 를 이용한 인증정보 체크
	_GAME_STATE_CONNECT2LOAD,			//연결 및 검증 완료! 로드상태로 전이
	_GAME_STATE_LOAD2SYNC,				//클라이언트 연결완료 준비상태
	_GAME_STATE_SYNC2SYNC,
	_GAME_STATE_SYNC2PLAY,				//플레이대기중
	_GAME_STATE_PLAY,					//게임중!

	_GAME_STATE_CANCEL_LOADING,			//백그라운드 로더와 싱크
	_GAME_STATE_DESTROYED,				//방깨졌삼!
	_GAME_STATE_FARM_NONE,				//농장용 스테이트입니다. 생성 루틴이 달라 일반과 다르게 흘러갑니다 _GAME_STATE_PLAY부터는 동일
	_GAME_STATE_FARM_READY2LOAD,		//디비에 농장관련 데이타를 요청한 상태
	_GAME_STATE_FARM_LOAD2PLAY,			//디비에서 농장관련 데이타를 받았다. 세팅하고 마스터에 알리자
	_GAME_STATE_FARM_PAUSE,				//농장 포우즈~
	_GAME_STATE_PVP_SYNC2GAMEMODE,		//피빕피일경우 유저가 없는 상태에서 시작시점이 생김(길드전) 접속스테이트를 건너뛰고 모드받고 로드로 넘어가는 중간스테이트
};

//GameSession
enum eGameSessionState
{
	SESSION_STATE_NONE,
	SESSION_STATE_READY,				//객체생성만 되어 있음! 연결은 안되어 있음
	SESSION_STATE_RUDP_CONNECTED,	
	SESSION_STATE_CONNECTED,			//연결 되었음!
	SESSION_STATE_LOAD,					//연결 되면 디비에 요청합니다.
	SESSION_STATE_LOADED,				//게임로딩완료!
	SESSION_STATE_WAIT_TO_READY,		//Ready 상태 기다림
	SESSION_STATE_READY_TO_SYNC,		//Sync 준비 완료!
	SESSION_STATE_SYNC_READY_2_DELAY,	//서버가 메세지처리준비가 안되상태에서 메세지를 받았습니다.
	SESSION_STATE_READY_TO_PLAY,		//Sync 2 Play
	SESSION_STATE_GAME_PLAY,			//게임플레이중!
	SESSION_STATE_READY_TO_VILLAGE,		//game -> village (준비단계)
	SESSION_STATE_READY_TO_LOGIN,		//game -> login char select (준비단계)
	SESSION_STATE_RECONNECTLOGIN,		//game -> login char select
	SESSION_STATE_SERVER_CHANGE,		//서버이동중! 이동완료되면 끊김
	SESSION_STATE_DISCONNECTED,			//짤린상태! (tcp까지 전부 끊긴 상태)
	//SESSION_STATE_CRASH,				//크래쉬!
};

// GameServer Parse Type
enum eGameMsgType
{
	MSG_TYPE_MASTER,
	MSG_TYPE_DATABASE,
};

enum eFieldMessage
{
	FM_CREATE,
	FM_DESTROY,
	FM_SHOW,
	FM_HIDE,
	FM_MOVE,
	FM_ACTORMSG,
	FM_CHAT,
	FM_CHANGEEQUIP,
	FM_ADDEXP,
	FM_LEVELUP,
	FM_CHANGEAPPELLATION,
	FM_CHANGEHIDE,
	FM_CHANGECASHEQUIP,
	FM_CHANGEGUILDSELFVIEW,
	FM_CHANGEJOB,
	FM_EFFECT,
	FM_CHANGECOLOR,
	FM_CHANGEGLYPH,
	FM_CHATROOMVIEW,
	FM_CHATROOMUSER,
	FM_CHANGEVEHICLE,
	FM_CHANGEVEHICLECOLOR,
	FM_CHANGEPET,
	FM_CHANGEPETBODY,
	FM_RENAME_PET,
	FM_ENTERPARTY,
	FM_LEAVEPARTY,
	FM_CHARACTER_RENAME,
	FM_GUILDWARWINSKILL,
	FM_USE_SOURCE,
	FM_USE_EFFECTSKILL,
	FM_HAVE_NAMEDITEM,
	FM_CHANGE_TRANSFORM,
	FM_CHANGETALISMAN,
	FM_CHANGEDWCTEAM,
};

enum eClass
{
	CLASS_NONE = 0,
	CLASS_WARRIER = 1,
	CLASS_ARCHER,
	CLASS_SOCERESS,
	CLASS_CLERIC,
#if defined( PRE_ADD_ACADEMIC )
	CLASS_ACADEMIC,
#endif // #if defined( PRE_ADD_ACADEMIC )
#if defined( PRE_ADD_KALI )
	CLASS_KALI,
#endif // #if defined( PRE_ADD_KALI )
//	CLASS_ASSASSIN,
//	CLASS_LENCEA,
//	CLASS_MACHINA,
	CLASS_MAX,
};

enum eJob
{
	JOB_NONE,

	JOB_WARRIER = 1,
	JOB_ARCHER,
	JOB_SOCERESS,
	JOB_CLERIC,

	JOB_BLAZEWARRIER = 11,
	JOB_SWORDMAN,
	JOB_CHAINSOLDIER,

	JOB_RANGER = 21,
	JOB_HUNTER,
	JOB_KEEPER,

	JOB_WIZARD = 31,
	JOB_MAGICIAN,
	JOB_WITCH,

	JOB_PRIEST = 41,
	JOB_PALADIN,
	JOB_MONK,

	JOB_MAX = 47,
};

enum eAppendItemString
{
	Append_ItemSN,
	Append_Price,
	Append_Limit,
	Append_ItemID,
	Append_Option,
	Append_Refundable,
#ifdef PRE_ADD_LIMITED_CASHITEM
	Append_QuantityLimited,
#endif		//#ifdef PRE_ADD_LIMITED_CASHITEM

	Append_Max,
};

enum eModItemBitmap
{
	ModItem_Durability = 1,
	ModItem_Level = (1<<1),
	ModItem_Potential = (1<<2),
	ModItem_SoulBound = (1<<3),
	ModItem_SealCount = (1<<4),
	ModItem_Option = (1<<5),
	ModItemAll = ModItem_Durability|ModItem_Level|ModItem_Potential|ModItem_SoulBound|ModItem_SealCount|ModItem_Option,
};

enum eWeaponType
{
	WEAPON_SWORD,			// 대검
	WEAPON_GAUNTLET,		// 건틀렛
	WEAPON_AXE,				// 도끼
	WEAPON_HAMMER,			// 해머
	WEAPON_SMALLBOW,		// 소궁
	WEAPON_BIGBOW,			// 대궁
	WEAPON_CROSSBOW,		// 석궁
	WEAPON_STAFF,			// 스테프
	WEAPON_BOOK,			// 마법서
	WEAPON_ORB,				// 수정구
	WEAPON_PUPPET,			// 주술인형
	WEAPON_MACE,			// 메이스
	WEAPON_FLAIL,			// 프레일
	WEAPON_WAND,			// 완드
	WEAPON_SHIELD,			// 방패
	WEAPON_ARROW,			// 화살
	WEAPON_CANNON,			// 캐논
	WEAPON_BUBBLEGUN,		// 버블건
	WEAPON_GLOVE,			// 글러브
	WEAPON_FAN,             // 부채
	WEAPON_CHAKRAM,         // 차크람
	WEAPON_CHARM,           // 참
	WEAPON_SCIMITER,		// 시미터
	WEAPON_DAGGER,			// 대거
	WEAPON_CROOK,			// 크룩
	WEAPON_SPEAR,
	WEAPON_RESERVED1,
	WEAPON_BRACELET,
	WEAPON_KNUCKLE,
	WEAPON_RESERVED2,
	WEAPON_CLAW,
};

enum eParts
{
	PARTS_FACE,				// 
	PARTS_HAIR,
	PARTS_HELMET,			// 투구
	PARTS_BODY,				// 상체
	PARTS_LEG,				// 하체
	PARTS_HAND,				// 손
	PARTS_FOOT,				// 발
	PARTS_NECKLACE,
	PARTS_EARRING,
	PARTS_RING,
	PARTS_RING2,
	PARTS_CREST,
	PARTS_FULLSET,			// 풀세트
};

enum eQuestDataType
{
	QUESTDATA_STATE = 1,	// 퀘스트 상태
	QUESTDATA_STEP,			// 현재 퀘스트 스텝
	QUESTDATA_JOURNAL,		// 현재 퀘스트 저널
};

enum eEtcType	//  DNEtc table Type
{
	ETC_NONE,
	ETC_QUICKSLOT,			// TQuickSlot QuickSlot[QUICKSLOTMAX];		// 단축 슬롯창 (10개씩 2줄)
	ETC_JOB,				// USHORT wJobArray[JOBMAX];				// 직업 (0: 맨처음 직업, 나머지 쭉쭉~ 전직 포함)
	ETC_NOTIFIER,			// int Notifier[Notifier_MaxCount];	// 알리미 (quest, mission)
	ETC_DUNGEONCLEAR,		// TDungeonClearData DungeonClear[DUNGEONCLEARMAX];	// 던전 클리어 (120개)
	ETC_ETERNITYITEM,		// USHORT wEternityItem[ETERNITYITEMMAX];	// 영구아이템
	ETC_EQUIPDELAYTIME,		// int nEquipDelayTime[EQUIPMAX];			// equip index에 관련된 cooltime
	ETC_EQUIPREMAINTIME,	// int nEquipRemainTime[EQUIPMAX];
};

enum eAuthType
{
	AUTHTYPE_BEGINAUTH,		// 인증 시작
	AUTHTYPE_STOREAUTH,		// 인증 저장
	AUTHTYPE_CHECKAUTH,		// 인증 체크
	AUTHTYPE_RESETAUTH,		// 인증 리셋
	AUTHTYPE_CNT,
};

enum eAbuseCode
{
	ABUSE_NONE = 0,
	ABUSE_MOVE_SERVERS,		// 마을 <-> 던젼 워프
	ABUSE_MOVE_INSKY,		// 공중이동
	ABUSE_HACKSHIELD,		// 핵쉴드에서 부정이용자
	ABUSE_TWN_EXTENDLOG,	// 대만용 추가 로그값 #48714 관계 있음
#if defined( PRE_ADD_CHARACTERCHECKSUM )
	ABUSE_CHARACTER_CHECKSUM, // #80315 캐릭터 체크섬 이상 발견
#endif // #if defined( PRE_ADD_CHARACTERCHECKSUM )
};

struct WorldUserState
{
	enum eCode
	{
		Add = 0,
		Delete,
		Modify,
	};
};

namespace DBDNMembership
{
	struct OrderStatusCode
	{
		enum eOrderStatusCode
		{
			SuccessPayment = 1,		// 결제성공 & pickup 대기
			Success = 2,			// 구매완료
			FailPayment = 3,		// 결제실패
		};
	};
};

namespace DBDNWorldDef
{
	struct CharacterExpChangeCode
	{
		enum eCharacterExpChangeCode 
		{
			Quest = 1,			// : 퀘스트 보상	-> FKey = QuestID
			Dungeon = 2,		// : 던전 보상		-> FKey = PartyID or NULL
			Cheat = 3,			// : 치트			-> FKey = NULL
			Admin = 4,			// : 보정 변경
			Eternity = 5,		// 영구아이템		-> FKey = ItemSerial
			PvP	= 6,			// : PvP 피로도 보상 -> FKey = NULL
			DungeonMonster = 7,	// :던젼 몬스터 사냥 경험치 -> FKey = PartyID or NULL( 서버에서 구분자로 쓰임..DB에 넘어갈때는 Dungeon 으로 Convert 된다. )
			Item = 8,			// : 경험치증가 아이템 -> FKey = ItemID
		};
	};

	struct CharacterLevelChangeCode
	{
		enum eCharacterLevelChangeCode
		{
			Normal = 1,		// : 일반
			Cheat = 2,		// : 치트
			Admin = 3,		// : 관리자 변경
		};
	};

	struct CoinChangeCode
	{
		enum eCoinChangeCode	// 주의 : 던전 보상, 우편첨부, 창고 입출금, 아이템 되팔기, 교환 입출금, 교환 수수료, 강화 수수료, 스킬 언락, 상점 구입, 우편 수수료 인 경우 각각의 SP에 포함되어 있습니다.
		{
			DoNotDBSave = 0,
			QuestReward = 1,					// : 퀘스트 보상 (FKey: QuestID)
			PickUp = 2,							// : 픽업 (FKey: PartyID or NULL)
			Cheat = 3,							// : 치트 (FKey: NULL)
			Admin = 4,							// : 관리자 변경 (FKey: AuditLogID)
			Use = 5,							// : 사용 (FKey: NULL)
												// 6: 우편송신첨부 (FKey: MailID)
												// 7: 우편수신첨부 (FKey: MailID)
			InvenToWare = 8,					// : 창고 입금 (FKey: NULL)
			WareToInven = 9,					// : 창고 출금 (FKey: NULL)
												// 10: 아이템 되팔기 (FKey: NpcID)
												// 11: 교환 입금 (FKey: CharacterID)
												// 12: 교환 출금 (FKey: CharacterID)
			QuestSub = 13,						// 퀘스트 차감 (FKey: QuestID)
			RepairItem = 14,					// 아이템 수리 (FKey: ItemSerial)
												// 15: 교환 수수료 (FKey: NULL)
												// 16: 강화 수수료 (FKey: ItemEnchantLogID)
												// 17: 스킬 언락 (FKey: SkillID)
												// 18: 상점 구입 (FKey: ItemSerial)
			DisjointTax = 19,					// 분해수수료 (FKey: NULL)
												// 20: 우편 수수료 (FKey: MailID)
												// 21: 무인상점등록 수수료 (FKey: TradeID)
												// 22: 무인상점 아이템 구 (FKey: TradeID)입
												// 23: 무인상점 아이템 판매금 (FKey: TradeID)
												// 24: 무인상점 거래 성립 수수료 (FKey: TradeID)
			CompoundTax = 25,					// 조합수수료 (FKey: NULL)
												// 26: 캐릭터 삭제 (FKey: NULL)
			MaxLevelExperienceTransGold = 27,	// 만랩 경험치 골드 보상 (FKey: NULL)
			Present = 28,						// 선물 (FKey: NpcID)
												// 29: 길드 창설 (FKey: GuildID)
			GuildLevelup = 30,					// 30: 길드 레벨 업 (FKey: GuildID)
			InvenToGuildWare = 31,				// 31: 길드 창고 입금 (FKey: GuildID)
			GuildWareToInven = 32,				// 32: 길드 창고 출금 (FKey: GuildID)
			GuildRewardBuy = 33,				// 33: 길드 보상 구매 (FKey: GuildItemID)
			Donation = 34,						// 기부
												// 35: (DOORS) 등록수수료
												// 36: (DOORS) 입찰수수료
												// 37: (DOORS) 낙찰수수료
												// 38: (DOORS) 낙찰결제
												// 39: (DOORS) 낙찰정산
												// 40: (DOORS) 등록수수료취소
												// 41: (DOORS) 입찰수수료취소
												// 42: (DOORS) 낙찰수수료취소
												// 43: (DOORS) 낙찰결제취소
												// 44: (DOORS) 낙찰정산취소
			CharmItem = 45,						// 보물상자 (FKey: ItemID)
			ChaosItem = 46,						// 카오스 큐브 (FKey: ItemID)
			SpecialBox = 47,					// 특수보관함 (FKey: EventRewardID)
			// 48: 월드창고 사용 수수료
			// 49: C2C 보관
			// 50: C2C 회수
			// 51: C2C 거래
			TalismanSlotOpen = 52,				// 52: 탈리스만 슬롯 오픈(FKey: 슬롯 인덱스)
			TalismanSlotChange = 53,			// 53: 탈리스만 슬롯 장착 위치 이동

			GamblePrice=55,						// 55: 도박모드 참가비
			GambleFirstWinner=56,				// 56: 도박모드 1등 골드
			GambleSecondWinner=57,				// 56: 도박모드 2등 골드
			DWC = 58,							// 58: DWC 캐릭터 기본 소유 골드
		};
		enum ePetalChangeCode
		{
			GambleEnterPetal= 9,				// 9: 도박모드 페탈 입장료
			GambleFirstWinPetal= 12,			// 12: 도박모드 1등 페탈 상금
			GambleSecondWinPetal= 13,			// 13: 도박모드 2등 페탈 상금
		};
	};

	struct CoinTypeCode
	{
		enum eCoinTypeCode
		{
			Coin = 1,				// : 코인
			WarehouseCoin = 2,		// : 창고 코인
			RebirthCoin = 3,		// : 부활 코인
			PCBangRebirthCoin = 4,	// : PC방 부활 코인
		};
	};

	struct EquipmentAttributeCode
	{
		enum eEquipmentAttributeCode 
		{
			DelayTime = 1,	// : 딜레이 시간
			RemainTime = 2,	// : Remain 시간
		};
	};

	struct FatigueTypeCode
	{
		enum eFatigueTypeCode
		{
			PCBang = 1,		// : PC방 피로도
			Daily = 2,		// : 일일 피로도
			Weekly = 3,		// : 주간 피로도
			Event = 4,		// 이벤트 피로도
			VIP = 5,		// VIP피로도
		};
	};

	struct PublisherCode
	{
		enum ePublisherCode
		{
			Studio = 0,
			KR = 1,
			CH = 2,
			JP = 3,
			TW = 4,
			US = 5,
			SG = 6,
			TH = 7,
			ID = 8,
			RU = 9,
			EU = 10,
		};
	};

	struct QuestStatusCode
	{
		enum eQuestStatusCode
		{
			Gain = 0,		// : 퀘스트획득
			Progress = 1,	// : 퀘스트진행
		};
	};

	struct SkillPointCode
	{
		enum eSkillPointCode
		{
			LevelUp = 1,		// 스킬레벨업
			EternityItem = 2,	// 영구적용아이템
			Repair = 10,		// 걍 강제로 복구 세팅
		};
	};

	struct SkillChangeCode
	{
		enum eSkillChangeCode
		{
			Gain = 1,		// : 스킬포인트 획득
			Use = 2,		// : 스킬레벨업 & 스킬포인트 사용
			Reset = 3,		// : 스킬포인트 리셋
			GainByQuest = 4,	// : 스킬 획득 (퀘스트)
			GainByDungeon = 5,	// : 스킬 획득 (던전 보상)
			GainByBook = 6,		// : 스킬 획득 (스킬북)
			GainByEvent = 7,	// : 스킬 획득 (이벤트)
			GainByAdmin = 8,	// : 스킬 획득 (by 관리자)
			DelByDrop = 9,		// : 스킬 삭제 (드랍)
			DelByQuest = 10,	// : 스킬 삭제 (퀘스트)
			DelByEvent = 11,	// : 스킬 삭제 (이벤트 만료)
			DelByAdmin = 12,	// : 스킬 삭제 (by 관리자)
			ModSkillLevelByAdmin = 13,	// : 스킬레벨 조정 (by 관리자)
			GainByBuy = 14,		// 14스킬획득(구입)
		};
	};

	struct TradeStatusCode
	{
		enum eTradeStatusCode
		{
			Sell = 0,		// : 판매중
			CompleteSellByItem = 1,	// : 판매완료(아이템 수령)
			CompleteSellByCoin = 2,	// : 판매완료(판매금 수령)
			CancelSell = 3,	// : 판매취소
			Expire = 4,		// : 기간만료
		};
	};

	struct AddMaterializedItem
	{
		enum eCode
		{
			Pick			= 1,	// 1=줍기			-> FKey: PartyID or NULL
			Mission			= 2,	// 2=미션			-> FKey: MissionID
			QuestReward		= 3,	// 3=퀘스트보상		-> FKey: QuestID
			Present			= 4,	// 4=선물			-> FKey: PurchaseID
			PointBuy		= 5,	// 5=인게임포인트 구입	-> FKey: NPCID
			CashBuy			= 6,	// 6=캐쉬 구입		-> FKey: PurchaseID
			ReserveMoneyBuy	= 7,	// 7=페탈 구입	-> FKey: PurchaseID
			GetGachaResultCashItem_JP = 9,	// 9=일본 가챠 돌려서 나온 캐쉬 아이템.
			GMGive			= 10,	// 10=관리자 지급	-> FKey: AuditLogID
			ItemDecompose	= 11,	// 11=아이템 분해	-> FKey: NPCID
			// ItemEnchantFail = 12,	// 12=아이템 강화 실패	-> FKey: ItemEnchantID
			ItemCompound	= 13,	// 조합
			RandomItem		= 14,	// 랜덤아이템
			DungeonReward	= 15,	// 던젼보상
			PvPReward		= 16,	// pvp보상
			CharacterCreate = 17,	// 기본지급
			SystemMail = 18,		// 시스템메일 (미션보상)
			FixedItem = 19,			// 캐쉬템 (얼굴, 머리) - 기존얼굴/머리 지우고 덮어쓰기 -> FKey: 캐쉬템 사용아이템시리얼 (인벤에 있는애)
			CostumeMix = 21,		// 코스튬 합성
			FishingReward = 22,		// 낚시보상
			Harvest = 23,			// 수확
			Cheat = 24,				// 치트
			PvPLadderPoint = 25,	// 래더포인트
			UnionPoint = 26,		// 연합포인트
			Trigger = 27,			// 트리거
			GuildWarFestivalPoint = 28, // 길드 축제 포인트
			Repurchase = 29,
			GuildReversionItem = 30,
			CostumeRandomMixItem = 31,
			BestFriendItem = 34,
			COMEBACKREWARD = 35,	// 복귀유저보상
			SpecialBoxReward = 36,
			NewbieGameQuitReward = 37, //신규 유저 접속 종료할 때 보상
			NewbiewReConnectReward = 38, //신규 유저 재접속시 보상
			ComebackGameQuitReward = 39, //귀환자 접속 종료할 때 보상
			SeedPointBuy = 40, //시드로 구입
		};
	};

	struct MailTypeCode
	{
		enum eCode
		{
			Normal					= MailType::NormalMail,			// 일반 메일
			Mission					= MailType::MissionMail,		// 미션 보상
			Admin					= MailType::AdminMail,			// 관리자 메일
			EventMail				= MailType::EventMail,			// 이벤트 메일
			VIP						= MailType::VIPMail,			// VIP
			MasterSystem			= MailType::MasterSystemMail,	// 사제시스템
			NpcReputaion			= MailType::NpcReputationMail,	// NPC호감도시스템
			Quest					= MailType::Quest,				// 퀘스트
			GuildWarReward  		= MailType::GuildWarReward,		// 길드전 보상
			SpecialBox_Account		= MailType::SpecialBox_Account,	// 특수보관함_계정타겟 
			SpecialBox_Character	= MailType::SpecialBox_Character,	// 특수보관함_현캐릭터타겟
			Cadge					= MailType::Cadge,				// 조르기
			GuildMaxLevelReward		= MailType::GuildMaxLevelReward,// 최초길드가입 만랩 길드 보상
			AppellationBookReward	= MailType::AppellationBookReward, // 칭호 컬렉션북 완료 보상
		};
	};

	struct UseItem
	{
		enum eUseItemCode
		{
			DoNotDBSave = 0,
			Use = 1,		// 1=소모성 아이템 사용
			Destroy = 2,	// 2=버리기
			DeCompose = 4,	// 4=분해
			Present = 5,	// 5=선물
			GuildReversionItem = 6,	// 6=길드탈퇴나 추방으로 길드귀속아이템 삭제
		};
	};

	struct ItemLocation
	{
		enum eCode
		{
			Equip = 1,
			Inventory = 2,
			Warehouse = 3,
			QuestInventory = 4,
			CashInventory = 5,
			GiftRepository = 6,
			CashEquip = 7,
			Glyph = 8,
			VehicleInventory = 9,
			PetInventory = 10,
			HarvestDepot = 11,	// 수확창고
			ServerWare = 17,	// 서버 일반 아이템 창고
			ServerWareCash = 18,	// 서버 캐쉬 아이템 창고
			Talisman = 19,	// 탈리스만
			PeriodInventory = 20,
			PeriodWarehouse = 21,
		};
	};

	struct PetType
	{
		enum eCode
		{
			Vehicle = 1,
			Pet = 2,
			SATIETY_PET = 3,
		};
	};

	struct PayMethodCode
	{
		enum eCode
		{
			Coin = 1,				// 1: 코인
			Cash = 2,				// 2: 캐쉬
			Petal = 3,				// 3: 적립금
			Coupon = 4,				// 4: 쿠폰
			Admin = 5,				// 5: 관리자 지급
			Quest = 6,				// 6: 퀘스트보상
			Mission = 7,			// 7: 미션보상
			LevelupEvent = 8,		// 8=캐릭터 레벨 업 보상
			VIP = 9,				// 9 : VIP 선물
			PvP = 10,				// 10 : PVP 래더 포인트
			Union_Commerical = 11,	// 11 : 상인 연합 포인트
			Union_Royal = 12,		// 12 : 왕성 연합 포인트
			Union_Liberty = 13,		// 13 : 자유 연합 포인트
			Cash_NexonUSA = 14,		// 14 : 넥슨아메리카 캐쉬
			Event = 15,				// 15 : 이벤트
			GuildWar_Festival = 16,	// 16 : 길드전 축제 포인트
			GuildWar_Reward = 17,	// 17 : 길드전 보상
			Comeback = 19,			// 18 : 복귀유저보상
			BestFriend = 20,		// 20 : 절친
			BeginnerGuild = 21,		// 21 : 초보자길드 선물
			GuildSupport = 22,		// 22 : 길드지원보상
			ActiveMission = 23,		// 23 : 액티브미션 보상
#if defined( PRE_ADD_STAMPSYSTEM )
			Stamp = 24,				// 24 : 스탬프 보상
#endif // #if defined( PRE_ADD_STAMPSYSTEM )
#if defined( PRE_ADD_NEW_MONEY_SEED )
			SeedPoint = 25,			// 25 : 시드로 구입
#endif
		};
	};

	struct CashRebirthCode
	{
		enum eCode
		{
			Cash = 1,
			Petal = 2,
			Admin = 3,
			Item = 4,
			Seed = 5,
		};
	};

	struct EffectItemGetCode
	{
		enum eCode
		{
			Cash = 1,
			Petal = 2,
			Cooper = 3,
			Admin = 4,
			Union = 5,
			Item = 6,
			Guild = 7,
			BestFriend = 8,
			Seed = 9,
		};
	};

	struct EffectItemLifeSpanType
	{
		enum eCode
		{
			New = 0,
			Extend = 1,
			Update = 2,
		};
	};

	struct DifficultyCode
	{
		enum eCode
		{
			Easy = 1,
			Normal,
			Hard,
			Master,
			Abyss,
		};
	};

	struct ClearGradeCode
	{
		enum eCode
		{
			SSS = 10, 
			SS,
			S,
			A,
			B,
			C,
			D,
		};
	};

	struct RewardBoxCode
	{
		enum eCode
		{
			Wood = 1,
			Bronze,
			Silver,
			Gold,
		};
	};

	struct WhereToGoCode
	{
		enum eCode
		{
			StageEntrance = 1,
			Village,
		};
	};

	struct PvPModeCode
	{
		enum eCode
		{
			Round = 1,
			Respawn,
			Captain,
			IndividualRespawn,
			Zombie,
			Ladder1vs1,
			Ladder2vs2,
			Ladder3vs3,
			Ladder4vs4,
			GuildWar,
			Occupation,
			AllKill,
			Racing,
			Tournament,
#if defined( PRE_ADD_PVP_COMBOEXERCISE )
			ComboExercise,
#endif // #if defined( PRE_ADD_PVP_COMBOEXERCISE )
#if defined(PRE_ADD_DWC)
			DWCRegular,			
			DWCPractice,
#endif
		};
	};

	struct PvPTeamCode
	{
		enum eCode
		{
			A = 1,
			B,
		};
	};

	struct PvPResultCode
	{
		enum eCode
		{
			Win = 1,
			Lose,
			Draw,
			GiveUp,
		};
	};

	struct RestraintTargetCode
	{
		enum eCode
		{
			Account = 1,	// 계정
			Character,		// 캐릭터
		};
	};

	struct RestraintTypeCode
	{
		enum eCode
		{
			ConnectRestraint = 1,
			ChatRestraint,
			TradeRestraint,
		};
	};

	struct RestraintDolisReasonCode
	{
		enum eCode
		{
			DefaultCode = 110,
			AbuseRestraintCode = 111,
			AbuseTradeRestraintCode = 112,
		};
	};

	struct TransactorCode
	{
		enum eCode
		{
			Master = 1,
			Pupil,
		};
	};

	struct GetMasterCharacterCode
	{
		enum eCode
		{
			MyInfo = 1,				// 자신의 스승 정보
			MyMasterInfo,			// 내 스승 정보
			OptionalMasterInfo,		// 임의의 특정 스승 정보
		};
	};
#if defined( PRE_ADD_SECONDARY_SKILL )

	struct SecondarySkillTypeCode
	{
		enum eCode
		{
			ProductionSkill		= SecondarySkill::Type::ProductionSkill,		// 생산스킬
			ManufactureSkill	= SecondarySkill::Type::ManufactureSkill,		// 제작스킬
			CommonSkill			= SecondarySkill::Type::CommonSkill,			// 공용스킬
		};
	};
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )

	struct AppellationKind
	{
		enum eAppellationKind
		{
			Select = 1,
			Cover = 2
		};
	};

	struct EtcPointCode
	{
		enum eCode
		{
			None = 0,
			PvP = 1,
			Union_Commercial = 2,
			Union_Royal = 3,
			Union_Liberty = 4,
			GuildWar_Festival = 5,	// 길드전 축제 포인트			
			SeedPoint = 6,			// 시드 머니
			Max,
		};
	};
	struct GuildWarRewardType
	{
		enum eGuildWarRewardType
		{
			GuildWarFestivalWin = 1,	// 길드축제우승
			GuildWarFestivalLose,		// 길드축제패배
			GuildWarFinalUnder4,		// 본선 4강미만
			GuildWarFinal4,				// 본선 4강보상
			GuildWarFinal2,				// 본선 2위보상
			GuildWarFinalWin,			// 본선 우승보상
			GuildWarFinalAbnormalLose,	// 본선 비정상패배(동점때 예선점수?)
		};
	};

	struct EventRewardType
	{
		enum eEventRewardType
		{
			Admin = 1,
			System = 2,
		};
	};
};

//Exception Report
enum eExceptionRepert
{
	_EXCEPTIONTYPE_NONE = 0,

	//for game
	_EXCEPTIONTYPE_ROOMCRASH,
	_EXCEPTIONTYPE_SESSIONCRASH,
	_EXCEPTIONTYPE_ROOMDESTRUCTOR,
	_EXCEPTIONTYPE_GAME_DELAYED,

	//for db
	_EXCEPTIONTYPE_DBMW_DELAYED,
};

//GameServerAffinity Type
enum eGameServerAffinityType
{
	_GAMESERVER_AFFINITYTYPE_NORMAL = 0,		//그냥 일반 던전이미 머니 그런거
	_GAMESERVER_AFFINITYTYPE_HYBRYD,			//피비피도 받고 다 받아요
	_GAMESERVER_AFFINITYTYPE_PVP,				//피비피만 받아요
	_GAMESERVER_AFFINITYTYPE_FARM,				//게임서버 월드 통합처리용 농장 전용 겜섭!
};

// Cash
enum eCashEtc
{
	Reason_GameClient = 1,
	Reason_Web = 2,
	Reason_PCBangGameClient = 3,
	Reason_PCBangWeb = 4,

	Category_Main = 1,
	Category_Costume = 2,
	Category_Item = 3,
	Category_Package = 4,

	CashItemState_None = 1,
	CashItemState_Hot = 2,
	CashItemState_New = 3,
	CashItemState_Normal = 4,
	CashItemState_Discount = 5,
};

#if defined(_CH)
enum eChSndaAuthFlag
{
	eChSndaAuthFlag_UseEKey		= (1 << 0),		// EKey 기능 사용 여부
	eChSndaAuthFlag_UseECard	= (1 << 1),		// ECard 기능 사용 여부
};
#endif	// _CH

// structure -----------------------------------------------------------------------------------------------

struct TChannelInfo
{
	USHORT nChannelID;			//할당된 채널(필드)아이디
	USHORT nChannelIdx;
	USHORT nMapIdx;				//담당하는 맵의 아이디
	USHORT nChannelMaxUser;
	USHORT nCurrentUser;
	int nAttribute;				//DirtyBit
	int nMeritBonusID;			//Merit bonus
	bool bVisibility;
	WCHAR wszMapName[MAPNAMELENMAX];
	int	nLimitLevel;
	bool bShow;
	USHORT nDependentMapID;
	int	nServerID;
	BYTE cThreadID;
#if defined(PRE_ADD_CHANNELNAME)
	WCHAR wszLanguageName[CHANNELLANGUAGEMAX];
#endif //#if defined(PRE_ADD_CHANNELNAME)
	int GetUserPercentage() const
	{
		if( nChannelMaxUser > 0 )
			return nCurrentUser*100/nChannelMaxUser;
		return -1;
	}
};

struct TVillageInfo
{
	BYTE cVillageID;
	int nManagedID;
	char szIP[IPLENMAX];
	USHORT nPort;

	std::vector <TChannelInfo> vOwnedChannelList;
	TVillageInfo()
	{
		cVillageID = 0;
		nManagedID = 0;
		memset(szIP, 0, sizeof(szIP));
		nPort = 0;
	}
};

struct TGameInfo
{
	int nServerID;
	int nServerAttribute;
	ULONG nIP;
	USHORT nPort;
	USHORT nTcpPort;

	int nRoomCnt;
	int nUserCnt;
	bool bHasMargin;
	UINT nFrame;

	bool bComplete;
	UINT uiLastDelayReportTick;
};

// Server Info
struct TServerInfo
{
	bool bMergedWorld;
	int nWorldSetID;							// 통합 월드 아이디
	char cWorldID;
	WCHAR wszWorldName[WORLDNAMELENMAX];
	UINT nWorldMaxUser;				//대기자용
	USHORT nDefaultMaxUser;
	bool bOnline;				// online, offline 상태표시용
	bool bOnTop;
	std::vector <TVillageInfo> vOwnedVillageList;

	TServerInfo() 
	{
		bMergedWorld = false;
		nWorldSetID = 0;
		cWorldID = 0;
		memset(wszWorldName, 0, sizeof(wszWorldName));
		nWorldMaxUser = 0;
		nDefaultMaxUser = 0;
		bOnline = false;
		bOnTop = false;
	}
};

// 
struct TChannelInfoEx
{
	TChannelInfo Channel;
	BYTE cVillageID;
	char szIP[IPLENMAX];
	USHORT nPort;
};
typedef std::map<int, TChannelInfoEx> TMapChannel;

// 서버에서는 float로 바로 쓰지않는다. 클라에서 받은 좌표에 *1000을 해서 사용함
struct TPosition
{
	int nX;
	int nY;
	int nZ;
};

struct TLocation
{
	UINT nMapIndex;
	TPosition Pos;
};

// npc, user object생성에 해당. 공통된 부분만 
struct TBaseData
{
	UINT nObjectID;
	WCHAR wszName[NAMELENMAX];
	int nChannelID;
	TPosition CurPos, TargetPos;
	TPosition MoveDir;
	float fRotate;
	bool bBattleMode;
};

struct TParamData
{
	eChatType eChatType;
	int nChatSize;
	WCHAR wszChatMsg[CHATLENMAX];
	char Buffer[128];
	int nBufSize;
	USHORT wActorProtocol;
	TItemInfo ItemInfo;
	TItemInfo CashItemInfo;
	BYTE cLevel;
	UINT nExp;
	int nJob;
	int nSelectAppellation;
	int nCoverAppellation;
	bool bHide;
	bool bEncrypt;
	DNEncryptPacketSeq	sEncrypt;
	char cType;
	char cState;
	DWORD dwColor;
	int nChatRoomParam;
	int nIndex;
	DWORD dwSendSessionID; // SendSessionID
	TItem Vehicle;
	TVehicleCompact PetInfo;
	char cPetPartsType;
};

struct TDefaultCreateData
{
	BYTE cClassID;										// 클래스 
	int cDarkClass;									// rlkt_dark dark class :)
	int cDarkClassJobID;									// rlkt_dark dark class :)
	int nCreateMapIndex;								// 처음 생성시 시작 맵 인덱스
	int nCreateMapStartPositionX[DEFAULTPOSITIONMAX];	// 처음 생성시 시작 위치 X
	int nCreateMapStartPositionY[DEFAULTPOSITIONMAX];	// 처음 생성시 시작 위치 Y
	int nCreateMapStartRadius[DEFAULTPOSITIONMAX];		// 반경

	int nCreateTutorialMapIndex;			// 처음 생성시 튜토리얼 맵 인덱스 (GameServer쪽)
	int nCreateTutorialGateNo;				// 처음 생성시 튜토리얼 게이트 (GameServer쪽)

	int nDefaultBody;						// 기본몸
	int nDefaultLeg;						// 기본다리
	int nDefaultHand;						// 기본손
	int nDefaultFoot;						// 기본발
	int nFace[DEFAULTPARTSMAX];				// 얼굴
	int nHair[DEFAULTPARTSMAX];				// 머리
	int nHelmet[DEFAULTPARTSMAX];			// 헬멧
	int nBody[DEFAULTPARTSMAX];				// 상의
	int nLeg[DEFAULTPARTSMAX];				// 하의
	int nHand[DEFAULTPARTSMAX];				// 손
	int nFoot[DEFAULTPARTSMAX];				// 발
	int nWeapon[WEAPONMAX];					// 무기

	DWORD dwHairColor[DEFAULTHAIRCOLORMAX];
	DWORD dwSkinColor[DEFAULTSKINCOLORMAX];
	DWORD dwEyeColor[DEFAULTEYECOLORMAX];

	int nDefaultItemID[DEFAULTITEMMAX];		// 소유아이템
	int nDefaultItemCount[DEFAULTITEMMAX];	// 소유아이템 개수

	int nDefaultSkillID[DEFAULTSKILLMAX];	// 소유스킬

	TQuickSlot DefaultQuickSlot[DEFAULTQUICKSLOTMAX];	// 퀵슬롯개수
	int nDefaultGestureID[DEFAULTGESTUREMAX];	// 소유 제스처
};

#if defined( PRE_ADD_DWC )
struct TDWCCreateData
{
	BYTE cClassID;										// 기본 클래스 ID
	BYTE cJobCode1;										// 1차 전직 클래스 ID
	BYTE cJobCode2;										// 2차 전직 클래스 ID
	BYTE cLevel;
	int nExp;
	int nCreateMapIndex;								// 처음 생성시 시작 맵 인덱스
	int nCreateMapStartPositionX[DEFAULTPOSITIONMAX];	// 처음 생성시 시작 위치 X
	int nCreateMapStartPositionY[DEFAULTPOSITIONMAX];	// 처음 생성시 시작 위치 Y
	int nCreateMapStartRadius[DEFAULTPOSITIONMAX];		// 반경

	int nDefaultBody;						// 기본몸
	int nDefaultLeg;						// 기본다리
	int nDefaultHand;						// 기본손
	int nDefaultFoot;						// 기본발
	int nEquipArray[EQUIPMAX]; // 장착 장비

	DWORD dwHairColor;
	DWORD dwSkinColor;
	DWORD dwEyeColor;

	int nDefaultItemID[DEFAULTITEMMAX];		// 소유아이템
	int nDefaultItemCount[DEFAULTITEMMAX];	// 소유아이템 개수

	int nDefaultSkillID[DEFAULTSKILLMAX];	// 소유스킬

	TQuickSlot DefaultQuickSlot[DEFAULTQUICKSLOTMAX];	// 퀵슬롯개수
	int nDefaultGestureID[DEFAULTGESTUREMAX];	// 소유 제스처
	short nSkillPoint; // 스킬 포인트
	int nGold; // 골드 - 필요 없다면 제거하자

};
#endif // #if defined( PRE_ADD_DWC )

struct TMapInfo
{
	int nMapID;
	char szMapName[10][256];
	BYTE GateMapCount[WORLDMAP_GATECOUNT];
	USHORT GateMapIndexs[WORLDMAP_GATECOUNT][WORLDMAP_GATECOUNT];
	BYTE GateStartIndexs[WORLDMAP_GATECOUNT][WORLDMAP_GATECOUNT];
	int nWorldLevel;
	GlobalEnum::eMapTypeEnum MapType;
	GlobalEnum::eMapSubTypeEnum MapSubType;
	int nMaxClearCount;
	int nAllowMapType;
	std::vector<int> vMapAreaIndex;
	bool bExpandable;
	bool bUserReturnSystem;	// 유저 복귀시스템
	bool bVehicleMode;
	bool bPetMode;
	bool bAllowFreePass;
#if defined( PRE_PARTY_DB )
	std::wstring wstrMapName;
	int iEnterConditionTable;
#endif // #if defined( PRE_PARTY_DB )
#if defined( PRE_NORMALSTAGE_REGULATION )
	char cRevisionNum;	//보정넘버
#endif
#if defined(PRE_ADD_VEHICLE_SPECIAL_ACTION)
	bool bVehicleSpecalActionMode;
#endif
};

struct TCoinCountData
{
	BYTE cLevel;
	int nRebirthCoin[WORLDCOUNTMAX];		// 부활코인
	int nCashRebirthCoin[WORLDCOUNTMAX];	// 부활캐쉬코인
	int nRebirthCoinLimit;					// 무료코인소지제한개수
	int nCashRebirthCoinLimit;				// 유료코인소지제한개수
	int nVIPRebirthCoin;					// VIP부활코인
};

struct TActorData
{
	int nActorID;
	BYTE cClass;					// 유닛 타입 종류
};

const int QUEST_MAX_CNT = 20;
struct TNpcData
{
	int nNpcID;
	int nParam[2];
	WCHAR wszName[EXTDATANAMELENMAX];
	char szTalkFile[256];				// 대사파일이름
	char szScriptFile[256];				// script 파일이름
	int QuestIndexArr[QUEST_MAX_CNT];	// 퀘스트인덱스
	TActorData ActorData;
};

struct TItemData
{
	int nItemID;
	WCHAR wszItemName[EXTDATANAMELENMAX];
	int nType;							// 타입
	int nTypeParam[3];					// 타입파라미터
	BYTE cLevelLimit;					// 레벨제한
	BYTE cRank;							// 등급
	BYTE cReversion;					// 귀속여부
	bool IsCash;						// 캐쉬템인가
	bool IsDestruction;					// 파괴여부
	bool IsAuthentication;				// 인증여부
	int nAmount;						// 금액
	int nSellAmount;					// 판매금액
	int nOverlapCount;					// 중첩개수
	std::vector<int> nNeedJobClassList;	// 직업제한

	int nSkillID;						// 스킬 인덱스
	char cSkillLevel;					// 스킬 레벨
	char cSkillUsingType;				// 스킬 사용 타입
	int nMaxCoolTime;					// 최대 쿨타임 (변하지 않는 값)
	int nEnchantID;						// 인챈트아이디
	int	nAllowMapType;					// 사용가능한 맵 타입
	char cSealCount;					// 밀봉 횟수
	int nSealID;						// SealCountTableID
	int nNeedBuyItemID;					// 상점에서 구입할 때 필요한 아이템ID
	int nNeedBuyItemCount;				// 상점에서 구입할 때 필요한 아이템개수
	int nNeedPvPRank;					// 장착할 때 필요한 PvP 랭크
	bool IsSealed;						// 획득 시 밀봉여부
	int nCashTradeCount;				// 캐시아이템 교환개수
	bool IsEnableCostumeMix;
	int nApplicableValue;
	bool IsCollectingEvent;			// 아이템 수집 API를 호출여부
	int nExchangeCode;				// 아이템 카테고리 ID
	int iNeedBuyLadderPoint;		
	int iUseLevelLimit;
	int iNeedBuyUnionPoint;
	int iNeedBuyGuildWarPoint;
	bool bRebuyable;
	int nPeriod;
#if defined(PRE_ADD_SERVER_WAREHOUSE)
	bool IsWStorage;					// 서버 창고에 넣을 수 있는 예외
#endif
	int DragonJewelType;

	void Reset() 
	{
		memset( wszItemName, 0, sizeof(wszItemName) );
		memset( nTypeParam, 0, sizeof(nTypeParam) );
		nNeedJobClassList.clear();
		std::vector<int>().swap(nNeedJobClassList);

		nItemID			= 0;
		nType			= 0;
		cLevelLimit		= 0;
		cRank			= 0;
		cReversion		= 0;
		IsCash			= 0;
		IsDestruction	= 0;
		IsAuthentication= 0;
		nAmount			= 0;
		nSellAmount		= 0;
		nOverlapCount	= 0;
		nSkillID		= 0;
		cSkillLevel		= 0;
		cSkillUsingType = 0;
		nMaxCoolTime	= 0;
		nAllowMapType	= 0;
		cSealCount		= 0;
		nNeedBuyItemID		= 0;
		nNeedBuyItemCount	= 0;
		nNeedPvPRank		= 0;
		IsSealed			= 0;
		nCashTradeCount = 0;
		IsEnableCostumeMix	= 0;
		nApplicableValue = 0;
		IsCollectingEvent = 0;
		nExchangeCode = 0;
		iNeedBuyUnionPoint = 0;
		iNeedBuyGuildWarPoint = 0;
		bRebuyable = false;
		nPeriod = 0;
		DragonJewelType = 0;
	}
};

struct TWeaponData
{
	int nWeaponIndex;
	char cEquipType;					// 장착타입
	int nLength;						// 무기 길이
	int nDurability;					// 내구도
	int nDurabilityRepairCoin;			// 수리비
	int nPermitJob[10];
	bool bOneType;
};

struct TPartData
{
	int nPartIndex;
	int nParts;							// 파츠
	int nDurability;					// 내구도
	int nDurabilityRepairCoin;			// 수리비
	int nPermitJob[10];
	std::vector<int> nSubPartsList;		// 서브파츠 (한벌옷)

	TPartData()
	{
		nPartIndex = 0;
		nParts = 0;
		nDurability = 0;
		nDurabilityRepairCoin = 0;
		memset(nPermitJob, 0, sizeof(nPermitJob));
	}
};

struct TVehiclePartsData
{
	int nItemID;
	int nVehicleClassID;
	int nVehiclePartsType;
	std::string strSkinName;
	std::string strAniName;
	std::string strActName;
	int nSkinColor;
	TVehiclePartsData()
	{
		nItemID = 0;
		nVehicleClassID = 0;
		nVehiclePartsType = 0;
		nSkinColor = 0;
	}
};

struct TVehicleData
{
	int nItemID;
	int nVehicleClassID;
	int nVehicleActorID;
	int nDefaultBody;
	int nDefaultParts1;
	int nDefaultParts2;
	int nVehicleSummonTime;
	int nVehicleDefaultSpeed;
	int nPetLevelTypeID;	// pet 등급(?)값 등급이 다른 펫을 참조하기위한 키값
	int nPetSkillID1;		// 
	int nPetSkillID2;
	int nRange;				// 스캔 범위값. 이를테면 줍기 같은거 
	int nFoodID;
};

const BYTE PetStateMax = 10;
struct TPetLevelDetail
{
	int nTableIndex;
	int nPetLevel;
	int nPetExp;
	int nState[PetStateMax];
	char *szStateMin[PetStateMax];
	char *szStateMax[PetStateMax];
	int nVipExp;
};

struct TPetLevelData
{
	int nPetLevelType;
	std::vector<TPetLevelDetail> VecPetLevel;
};

struct TPetFoodData
{
	int nItemID;
	int nTickTime; // 소모 시간(second)
	int nFullTic;  // 틱당 소모량
	BYTE cFullTimeLogOut; // 로그아웃시 기존 만복도 나누기값
	int nFullMaxCount;		// 만복도 최대 max수치
	int nUseExp[Pet::MAX_SATIETY_SELECTION];
	int nUseState[Pet::MAX_SATIETY_SELECTION];
};

struct TPotentialJewelData
{
	int nItemID;
	int nApplyApplicableValue;
	int nPotentialNo;
	bool bErasable;
	bool bCanApplySealedItem;

#if defined(PRE_ADD_REMOVE_PREFIX)
	bool bSuffix;
#endif // PRE_ADD_REMOVE_PREFIX
#if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
	int nRollbackAmount; // 잠재력 부여 롤백 수수료
#endif	// #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
};

struct TEnchantJewelData
{
	int nItemID;
	int nApplyApplicableValue;
	int nRequireMaxItemLevel;
	int nRequireEnchantLevel;
	int nEnchantLevel;
	bool bCanApplySealedItem;
};

struct TItemDropData
{
	int nItemDropID;
	bool bIsGroup[20];
	int nIndex[20];
	int nProb[20];
	int nInfo[20];
};

struct TGlobalWeightData
{
	int nID;
	float fValue;
};

struct TGlobalWeightIntData
{
	int nID;
	int nValue;
};

struct TLevelData
{
	int nIndex;
	short wStrength;					// 힘
	short wAgility;						// 민첩
	short wIntelligence;				// 지능
	short wStamina;						// 건강
	int nExperience;					// 경험치
	int nFatigue;						// 피로도
};

struct TStat
{
	USHORT wStr;
	USHORT wDex;
	USHORT wInt;
	USHORT wHealth;
	USHORT wLuck;
};

struct TSkillLevelData
{
	char cSkillLevel;					// 스킬 레벨
	char cLevelLimit;					// 제한 레벨
	//int nNeedJobClass;				// 직업제한 -> 스킬 테이블로 옮겨졌음.
	int nDelayTime;						// 스킬딜레이(ms)
	int nAddRange;						// 추가 사거리(cm)
	int nNeedItemID;					// 소모아이템
	int nNeedItemDecreaseCount;			// 소모 아이템 개수
	int nDecreaseHP;					// 소모HP
	int nDecreaseSP;					// 소모SP
	int nNeedSkillPoint;
	int nEffectClassValue1Duration;
	float nMagicDamage; //rlkt_damage
	float nPhyDamage; //rlkt_damage
};

struct TSkillData
{
	int nSkillID;						// 스킬id
	char cNeedWeaponType[ 2 ];			// 필요무기
	int nMaxLevel;						// 최대레벨
	char cSkillType;					// 스킬타입
	char cDurationType;					// 지속타입
	char cTargetType;					// 타겟타입
	char cDissolvable;					// 해제 가능 여부
	int nNeedJobID;						// 직업 제한
	bool bDefaultLocked;				// 디폴트로 락이 된 건지 여부
	int nUnlockSkillBookItemID;			// 언락하는 스킬북의 아이템 ID
	int nUnlockPrice;					// 돈으로 언락할 때 비용.
	int nExclusiveID;					// 이 아이디가 같은 값인 스킬은 같이 배울 수 없다.
	int nGlobalCoolTime;				// 글로벌 스킬 쿨타임 (#36858)
	int nGlobalSkillGroup;				// 글로벌 스킬 그룹 (#36858)
	std::vector<TSkillLevelData> vLevelDataList;

	TSkillData()
	{
		nSkillID =0;
		memset(cNeedWeaponType, 0, sizeof(cNeedWeaponType));		
		nMaxLevel = 0;
		cSkillType = 0;
		cDurationType = 0;
		cTargetType = 0;
		cDissolvable = 0;
		nNeedJobID = 0;
		bDefaultLocked = false;
		nUnlockSkillBookItemID = 0;
		nUnlockPrice = 0;
		nExclusiveID = 0;
		nGlobalCoolTime = 0;
		nGlobalSkillGroup = 0;
	}
};

struct TSkillTreeData
{
	int nSkillID;
	int nTreeSlotIndex;
	int nParentSkillID[ 3 ];
	int nNeedParentSkillLevel[ 3 ];
#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
	int nNeedBasicSP;
	int nNeedFirstSP;
	int nNeedSecondSP;
#endif	//	#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
#if defined( PRE_ADD_ONLY_SKILLBOOK )
	bool bNeedSkillBook;
#endif	// #if defined( PRE_ADD_ONLY_SKILLBOOK )
};

// npc 대화 관련 구조체 
struct TALK_QUESTION
{
	std::wstring szQuestion;
};

struct TALK_ANSWER 
{
	std::wstring szLinkTarget;
	std::wstring szLinkIndex;
	std::wstring szAnswer;
	bool bOtherTargetLink;	// 다른 토크파일로 링크 하는 경우 true
};

struct TALK_PARAGRAPH
{
	std::wstring				szIndex;
	TALK_QUESTION				Question;
	std::vector<TALK_ANSWER>	Answers;
};

// key - 문단스트링인덱스, second - 문단
typedef std::map<std::wstring, TALK_PARAGRAPH> TALK_PARAGRAPH_MAP;
typedef TALK_PARAGRAPH_MAP::iterator TALK_PARAGRAPH_MAP_IT;

// key - 대사xml 파일 이름, second - 대사전체
typedef std::map<std::wstring, TALK_PARAGRAPH_MAP> TALK_MAP;
typedef TALK_MAP::iterator TALK_MAP_IT;

#include <set>

// key - 문단응답스트링인덱스 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도)
typedef std::set<std::wstring> TALK_ANSWER_SET;
typedef TALK_ANSWER_SET::iterator TALK_ANSWER_SET_IT;

// key - 대사xml 파일 이름, second - 문단응답스트링집합 (단지 클라이언트 대사요청 무결성 체크 오류메시지를 막는 용도)
typedef std::map<std::wstring, TALK_ANSWER_SET>	TALK_ANSWER_MAP;
typedef TALK_ANSWER_MAP::iterator TALK_ANSWER_MAP_IT;

// 퀘스트 보상 아이템 테이블 정보
// 돈과 아이템 6종류 까지 세팅할 수 있다. nItemID 과 nItemCount는 세트이다.

struct TQuestRewardBase
{
	struct _ITEMSET
	{
		int	nItemID;
		int	nItemCount;
		int	nItemOptionTableID;
	};
};

struct TQuestReward : public TQuestRewardBase
{
	UINT nIndex;			// 보상테이블 인덱스
	UINT nStringIndex;	// 보상테이블 스트링
	char cType;			// 보상타입 1이면 전체보상 / 2면 선택보상
	char cSelectMax;		// 선택보상일경우 몇개까지 선택할것인지.
	UINT nCoin;			// 보상금액
	int	nExp;			// 보상 경험치
	int	nQuestID;		// 퀘스트 ID
	int	nQuestStep;		// 퀘스트 완료 시 스텝
	BYTE nClass;			// 보상 클래스
	_ITEMSET ItemArray[QUESTREWARD_INVENTORYITEMMAX];
	_ITEMSET LevelCapItemArray[MAX_QUEST_LEVEL_CAP_REWARD];
	int nMailID;
	int nFatigue;
};

struct TQuestLevelCapReward : public TQuestRewardBase
{
	UINT uIndex;
	char cType;
	char cClassID;
	_ITEMSET Items[MAX_QUEST_LEVEL_CAP_REWARD];
};

struct TCompleteEventQuest
{
	short wCompleteCount;
	int nScheduleID;
};

// Shop
struct TShopItem
{
	int nItemID;		// 상점 아이템 아이디
	int nCount;			// 상점 아이템 수량
	int nMaxCount;		// 아이템 최대수량
	int nPrice;			// 아이템 가격
	int buyLimitCount;
#if defined (PRE_ADD_COMBINEDSHOP_PERIOD)
	int nPeriod;
#endif
#if defined( PRE_ADD_LIMITED_SHOP )
	int nShopLimitReset;
#endif
};

struct TShopTabData
{
	int nTabID;
	std::vector<TShopItem> vShopItem;	// SHOPTABMAX
	TShopTabData()
	{
		Clear();
	}
	void Clear()
	{
		nTabID = 0;
		vShopItem.clear();
	}
};

struct TShopData
{
	int nShopID;		// 샵 아이디 (npc가 가지고 있는 아이디와 비교해서 연결)
	std::vector<TShopTabData> vShopTabData;	// SHOPITEMMAX
	TShopData()
	{
		nShopID = 0;
	}
};

// Skill Shop
struct TSkillShopItem
{
	int nSkillID;		// 스킬아이디
	int nPrice;			// 스킬 가격
};

struct TSkillShopData
{
	int nShopID;		// 샵 아이디 (npc가 가지고 있는 아이디와 비교해서 연결)
	TSkillShopItem SkillShopItem[SKILLSHOPITEMMAX];	// 최대 10개밖에 안된다
};

// Enchant
const int ENCHANTITEMMAX = 5;
struct TEnchantLevelData
{
	int nItemID;
	char cLevel;
#ifdef PRE_FIX_MEMOPT_ENCHANT
	int nNeedItemTableID;
	int nStateTableID;
	int nNeedCoin;
#else
	char cEnchantProb;
	char cBreakRatio;
	char cMinDownLevel;
	char cMaxDownLevel;
	int nNeedItemID[ENCHANTITEMMAX];
	int nNeedItemCount[ENCHANTITEMMAX];
	int nNeedCoin;
	int nFailResultItemID;
	int nPotentialID;
	char cPotentialProb;
	int nProtectItemCount;
#if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM)
	int nShieldItemCount;	// 상위강화보호젤리용(다운그레이드x)
#endif
#endif // PRE_FIX_MEMOPT_ENCHANT
};

struct TEnchantData
{
	int nEnchantID;
	char cCount;
	std::map<char, TEnchantLevelData*> pMapLevelData;
};

#ifdef PRE_FIX_MEMOPT_ENCHANT
struct TEnchantNeedItemData
{
	char cEnchantProb;
	char cBreakRatio;
	char cMinDownLevel;
	char cMaxDownLevel;
	int nNeedItemID[ENCHANTITEMMAX];
	int nNeedItemCount[ENCHANTITEMMAX];
	float fUpStateRatio;
	int nFailResultItemID;
	int nProtectItemCount;
#if defined(PRE_ADD_ENCHANTSHIELD_CASHITEM)
	int nShieldItemCount;	// 상위강화보호젤리용(다운그레이드x)
#endif
};
#endif // PRE_FIX_MEMOPT_ENCHANT

struct TPotentialDataItem
{
	int nItemID;
	int nPotentailOffset;
	int nPotentialNo;
	int nProb;

	int nSkillID;
	int nSkillLevel;
	int nSkillUsingType;
};

struct TPotentialData
{
	int nPotentialID;
	int nTotalProb;
	std::vector<TPotentialDataItem*> pVecItemData;
};

// Exchange
struct TExchangeData
{
	int nInvenIndex;	// 인벤 인덱스
	short wCount;		// 몇개 넣었는지
	INT64 biSerial;
};

#ifdef PRE_ADD_GACHA_JAPAN
// gachapon japan
struct TGachaponShopInfoByJob_JP
{
	int nGachaponTableID;		// 가챠폰 테이블 ID
	int nGachaponIndex;			// 가챠폰 샵 인덱스.
	int nJobClassID;			// 이 가챠폰에서 드랍해주는 아이템들의 직업
	int nPartsLinkDropTableID[ CASHEQUIPMAX ];
};

struct TGachaponData_JP
{
	int nGachaponIndex;			// 가챠폰 샵 인덱스. npc 테이블에 쓰인 인덱스를 이걸로 찾음. 테이블 인덱스 아님.
	TGachaponShopInfoByJob_JP GachaponShopInfo[ CLASSKINDMAX ];
};
#endif // PRE_ADD_GACHA_JAPAN

struct TCostumeMix
{
	int nMinScore;
	int nDropID;
};

//community
//getsimple characterdata patialy enum type
enum eReqCharacterPartialy
{
	_REQCHARACTERPARTIALY_FRIEND, 
};

//Friend
struct TFriendGroup:public TBoostMemoryPool<TFriendGroup>
{
	UINT nGroupDBID;
	WCHAR wszGroupName[FRIEND_GROUP_NAMELENMAX];
};

struct TFriend:public TBoostMemoryPool<TFriend>
{
	UINT nFriendAccountDBID;
	INT64 biFriendCharacterDBID;
	UINT nGroupDBID;

	TCommunityLocation Location;
	
	WCHAR wszCharacterName[NAMELENMAX];
	WCHAR wszGroupName[FRIEND_GROUP_NAMELENMAX];
	WCHAR wszFriendMemo[FRIEND_MEMO_LEN_MAX];
#ifdef PRE_ADD_DOORS
	bool bMobileAuthentication;
#endif		//#ifdef PRE_ADD_DOORS
};

//UserState
enum eCummunityState		//초대 받는다 안받는다 쪽지 받겠다 안받겠다 등등
{
	_COMMUNITY_NONE = 0,
	_COMMUNITY_MSG_PERMIT,		//모든 메세지 받아효~
	_COMMUNITY_MSG_NOTPERMIT,//메세지 안받아효~ 나좀 내버려 두삼!
};

struct sWorldUserState
{
	WCHAR wszCharacterName[NAMELENMAX];
	INT64 biCharacterDBID;			//일단은 혹쉬나 해서 훗훗
	int	nChannelID;				//
	int	nMapIdx;
	int	nLocationState;			//eLocationState
	int	nCummunityState;		//eCummunityState
};

//ServiceManager NoticeType
enum eSMNoticeType
{
	_NOTICETYPE_ALL = 0,
	_NOTICETYPE_WORLD,
	_NOTICETYPE_EACHSERVER,
	_NOTICETYPE_CHANNEL,
	_NOTICETYPE_ZONE,
};

//VoiceChannelReqType
enum eVoiceChannelReqType
{
	_VOICECHANNEL_REQTYPE_PARTY,
	_VOICECHANNEL_REQTYPE_PVP,
	//머 이런식으로 생기지 않을까나..
	//_VOICECHANNELTYPE_GUILD,
	//_VOICECHANNELTYPE_PRIVATE,
};

//Invite PartyInfo
struct TInvitePartyInfo
{
	TPARTYID PartyID;
	int nMapIdx;
	BYTE cLimitLevelMin;
#if defined( PRE_PARTY_DB )
#else
	BYTE cLimitLevelMax;
#endif // #if defined( PRE_PARTY_DB )
	BYTE cPartyMemberMax;
	BYTE cPartyMemberCount;
	BYTE cPartyAvrLevel;
	WCHAR wszPartyName[PARTYNAMELENMAX];
};

// PvP
struct TPvPMapTable
{
	UINT uiGameType;				// PvPCommon::GameType
	std::vector<UINT> vGameModeTableID;		// PvPGameModeTableID
	std::vector<UINT> vNumOfPlayerOption;		// 인원수 옵션
	bool bIsBreakInto;			// 난입가능Flag
	UINT uiItemUsageType;		// PvPCommon::ItemUsageType
	bool bIsAllowItemDrop;		// 아이템드롭 Flag
	bool bIsGuildBattleGround;	// 길드전에서 사용할수 있는지 Flag
	bool bIsReleaseShow;			// 릴리즈버전에서노출
	LadderSystem::MatchType::eCode	MatchType;

	// Function
	bool CheckMaxUser( const BYTE cMaxUser ) const
	{
		for( UINT i=0 ; i<vNumOfPlayerOption.size() ; ++i )
		{
			if( vNumOfPlayerOption[i] == cMaxUser )
				return true;
		}
		return false;
	}

	bool CheckGameModeTableID( const UINT uiTableID ) const
	{
		for( UINT i=0 ; i<vGameModeTableID.size() ; ++i )
		{
			if( vGameModeTableID[i] == uiTableID )
				return true;
		}
		return false;
	}

	bool CheckBreakIntoOption( const BYTE cBreakIntoFlag ) const
	{
		if( cBreakIntoFlag )
		{
			if( !bIsBreakInto )
				return false;
		}
		return true;
	}
};

struct TPvPGameModeTable
{
	int	nItemID;
	UINT uiGameMode;		// PvPCommon::GameMode
	std::vector<UINT> vWinCondition;
	std::vector<UINT> vPlayTimeSec;
	UINT uiRespawnTimeSec;
	UINT uiRespawnNoDamageTimeSec;
	UINT uiRespawnHPPercent;
	UINT uiRespawnMPPercent;
	UINT uiWinXPPerRound;
	UINT uiLoseXPPerRound;
	UINT uiItemDropTableID;
	bool bIsLevelRegulation;
	bool bIsReleaseShow;			// 릴리즈버전에서노출
	UINT uiMedalExp;
	UINT uiNumOfPlayersMin;
	UINT uiNumOfPlayersMax;
	std::vector<UINT> vVictoryExp;
	std::vector<UINT> vVictoryBonusRate;
	std::vector<UINT> vDefeatExp;
	std::vector<UINT> vDefeatBonusRate;
	LadderSystem::MatchType::eCode	LadderMatchType;
	int	iRewardItemID;
	int	nFatigueConTime;
	int	nFatigueConValue;
	int	nFatigueConExp;
	int	nFatigueConMedal;
	int	iNeedInven;
	int	iSkillSetting;
	bool bIsSelectableRegulation;
	bool bIsDefaultRegulation;
	int nBattleGroundTableID;
	bool bAllowedUserCreateMode;
#if defined( PRE_ADD_RACING_MODE ) || defined( PRE_ADD_PVP_TOURNAMENT )
	int nDefaultRewardItem;
	int nDefaultRewardValue;
	std::vector<int> vRankRewardItem;
	std::vector<int> vRankRewardValue;
#endif // #if defined( PRE_ADD_RACING_MODE ) || defined( PRE_ADD_PVP_TOURNAMENT )

	// Function
	bool CheckWinCondition( const UINT uiWinCondition ) const
	{
		if( vWinCondition.empty() )
			return true;

		for( UINT i=0 ; i<vWinCondition.size() ; ++i )
		{
			if( vWinCondition[i] == uiWinCondition )
				return true;
		}
		return false;
	}

	bool CheckPlayTimeSec( const UINT uiPlayTime ) const
	{
		if( vPlayTimeSec.empty() )
			return true;

		for( UINT i=0 ; i<vPlayTimeSec.size() ; ++i )
		{
			if( vPlayTimeSec[i] == uiPlayTime )
				return true;
		}
		return false;
	}

	// 실패시 -1 리턴
	int GetWinconditionIndex( const UINT uiWinCondition ) const
	{
		for( UINT i=0 ; i<vWinCondition.size() ; ++i )
		{
			if( vWinCondition[i] == uiWinCondition )
				return i;
		}
		return -1;
	}

	bool CheckMaxUser( const UINT uiMaxUser ) const 
	{
		return (uiMaxUser >= uiNumOfPlayersMin && uiMaxUser <= uiNumOfPlayersMax);
	}
};

struct TPvPGameStartConditionTable
{
	UINT uiMinTeamPlayerNum;		// 최소 시작 팀 인원
	UINT uiMaxTeamPlayerDiff;	// 최대 양팀 인원 허용 수

	short Check( const UINT uiATeam, const UINT uiBTeam, const bool bRandomTeam ) const
	{
		// 최소 시작 팀 인원 검사
		if( uiATeam < uiMinTeamPlayerNum || uiBTeam < uiMinTeamPlayerNum )
			return ERROR_PVP_CANTSTART_LESS_MINTEAMPLAYER;

		if (!bRandomTeam)	// 랜덤팀이 아닌 경우 처리한다.
		{
			// 최대  양팀 인원 허용 수 검사
			UINT uiDiff = ::abs( static_cast<int>(uiATeam-uiBTeam) );
			if( uiDiff > uiMaxTeamPlayerDiff )
				return ERROR_PVP_CANTSTART_MORE_MAXDIFFTEAMPLAYER;
		}
		

		return ERROR_NONE;
	}
};

struct TPvPRankTable
{
	UINT uiXP;
#ifdef PRE_MOD_PVPRANK
	BYTE cType;			//PvPCommon::RankTable 참조
	BYTE cMinRange;		//rate or rank
	BYTE cMaxRange;		//rate or rank

	TPvPRankTable()
	{
		uiXP = 0;
		cType = PvPCommon::RankTable::InitValue;
		cMinRange = 0;
		cMaxRange = 0;
	}
#endif		//#ifdef PRE_MOD_PVPRANK
};

struct TAppellationData
{
	int nAppellationID;
	int nArrayIndex;
	int nColor;
	int nLevelLimit;
	int nType;
#if defined( PRE_ADD_NEWCOMEBACK )
	int nSkillItemID;	
#endif
#if defined( PRE_MOD_APPELLATIONBOOK_RENEWAL)
	std::vector<int> nUseCollectionBookIndex;
#endif	// #if defined( PRE_MOD_APPELLATIONBOOK_RENEWAL)
};

// 미션 시스템 관련
struct TEventCondition
{
	char cEvent;
	char cType[5];
	int  nParam[5];
	char cOperator[5];
	bool bCheckType;
};

struct TMissionData
{
	bool bActivate;
	int nType;			// 미션타입(eMissionType)
	int nMailID;
	int nRewardAppellation;
	int nRewardPoint;
	bool bIsAchieveNotice;
	TEventCondition GainCondition;
	TEventCondition AchieveCondition;
};

struct TDailyMissionData
{
	int nMailID;
	int nRewardAppellation;
	int nRewardPoint;
	TEventCondition AchieveCondition;
	int nCounterParam;
	char cCounterOperator;
	int nItemID;
	int nType;
	int nTypeParam;
	__time64_t tStartDate;
#if defined(PRE_ADD_WEEKLYEVENT_MISSION_ENDTIME)
	__time64_t tEndDate;
#endif	// #if defined(PRE_ADD_WEEKLYEVENT_MISSION_ENDTIME)
};

#if defined(PRE_ADD_REMOTE_QUEST)
struct TRemoteQuestData
{
	bool bActivate;
	int nIndex;
	int nQuestID;
	bool bPreQuestCheckType;
	std::vector<int> nVecPreQuestCondition;
	TEventCondition GainCondition;
};
#endif

#if defined(PRE_ADD_ACTIVEMISSION)
struct TActiveMissionData
{
	int nIndex;
	bool bActivate;
	int nMailID;
	TEventCondition AchieveCondition;
};
#endif

// Collection
const char CollectionAppellationMax = 10;
struct TCollectionBookData
{
	int nID;
	std::vector<int> nVecAppellationArrayIndex;
	int nRewardAppellationArrayIndex;
#if defined(PRE_MOD_APPELLATIONBOOK_RENEWAL)
	int nMailID[2];			// 0 - 50% 넘겼을 때 보내줄 메일 ID, 1- 칭호 컬렉션 완성시 보상 MailID 
#endif  //#if defined(PRE_MOD_APPELLATIONBOOK_RENEWAL)
};

// TaxTable
struct TTaxData
{
	char cTaxType;			// 세금종류 (TaxType_PostTax)
	int nLevelStart;		// 시작 레벨
	int nLevelEnd;			// 끝 레벨
	int nAmountStart;		// 시작금액 (골드단위)
	int nAmountEnd;			// 끝금액
	float fRate;			// 세율
	int nTaxAmount;			// 세액
};

// Seal
const BYTE SEALENCHANTMAX = 16;	// 노강화부터 15강까지.
struct TSealCountData
{
	int nType1;
	int nType2;
	int nLevel[SEALENCHANTMAX];
	char cSuccessRate[SEALENCHANTMAX];
};

// PCBang
const BYTE PCParamMax = 2;
struct TPCBangParam
{
	int nParam[PCParamMax];
};

struct TPCBangData
{
	char cType;		// PCBang 혜택 종류 (ePCBangType)
	std::vector<TPCBangParam> VecPCBangParam;
	std::vector<TPCBangParam> VecPremiumPCBangParam;
	std::vector<TPCBangParam> VecGoldPCBangParam;
	std::vector<TPCBangParam> VecSilverPCBangParam;
	std::vector<TPCBangParam> VecRedPCBangParam;
};

// CashShop
const BYTE COMMODITYITEMMAX = 5;
const BYTE COMMODITYLINKMAX = 5;
struct TCashCommodityData
{
	int nSN;
#if defined(_JP)
	std::string strJPSN;
#endif	// #if defined(_JP)
	BYTE cCategory;
	int nSubCategory;
	int nItemID[COMMODITYITEMMAX];	// ItemTable 아이템 ID
	int nLinkSN[COMMODITYLINKMAX];	// 연계상품
	std::string strName;
	short wPeriod;					// 기간
	int nPrice;						// 가격
	int nCount;						// 구매시 주어지는 개수
	int nPriority;					// 캐시샵에 표시되는 우선순위
	bool bOnSale;					// 판매상태
	bool bOnSaleReal;				// 진짜(?)판매상태
	char cState;					// HOT, NEW등 상태 표시용
	bool bLimit;					// 한정 판매
	bool bReserveGive;				// 적립금 제공 여부
	int nReserve;					// 구매시 주어지는 적립금
	int nValidity;					// 유효기간
	bool bReserveAble;				// 적립금으로 살수 있는지 여부
	bool bPresentAble;				// 선물 가능 여부
	char cItemSort;					// 아이템종류
	int nPriceFix;					// 정가
	bool bCartAble;					// 장바구니에 담을 수 있는지
	bool bVIPSell;					// VIP 전용 판매 여부
	int nVIPLevel;					// VIP 등급
	bool bAutomaticPay;				// 자동결제 여부
	int nAutomaticPaySale;			// 자동결제 후 할인적용
	int nVIPPoint;					// 구매시 지급하는 VIPPoint
	int nOverlapBuy;				// 중복구매방지
#if defined(PRE_ADD_CASH_REFUND)
	bool bNoRefund;					// 청약 철회 불가능여부(true : 불가능)
#endif
#if defined(PRE_ADD_CASHSHOP_CREDIT)
	bool bCreditAble;				// 미쿡빌링
	int nCreditAbleLevel;			// 미쿡빌링 크레딧레벨
#endif	// #if defined(PRE_ADD_CASHSHOP_CREDIT)
#if defined(PRE_ADD_SALE_COUPON)
	bool bUseCoupon;
#endif //#if defined(PRE_ADD_SALE_COUPON)
#if defined( PRE_ADD_NEW_MONEY_SEED )
	bool bSeedAble;
	int nSeed;
	bool bSeedGive;
#endif

	TCashCommodityData()
	{
		nSN=0; cCategory=0; nSubCategory =0; 
		memset(nItemID, 0, sizeof(nItemID));
		memset(nLinkSN, 0, sizeof(nLinkSN));
		wPeriod=0; nPrice=0; nCount=0; nPriority=0;
		bOnSale=false; bOnSaleReal=false; cState=0;
		bLimit=false; bReserveGive=false; nReserve=0;
		nValidity=0; bReserveAble=false; bPresentAble=false;
		cItemSort=0; nPriceFix=0; bCartAble=false;
		bVIPSell=false; nVIPLevel=0; bAutomaticPay=false;
		nAutomaticPaySale=0; nVIPPoint=0;
		nOverlapBuy =0;

#if defined(PRE_ADD_CASH_REFUND)
		bNoRefund = true;		// 기본 불가능
#endif
#if defined(PRE_ADD_CASHSHOP_CREDIT)
		bCreditAble = false;
		nCreditAbleLevel = 0;
#endif	// #if defined(PRE_ADD_CASHSHOP_CREDIT)
#if defined(PRE_ADD_SALE_COUPON)
		bUseCoupon = false;
#endif // #if defined(PRE_ADD_SALE_COUPON)
#if defined( PRE_ADD_NEW_MONEY_SEED )
		bSeedAble = false;
		nSeed = 0;
		bSeedGive = false;
#endif
	}
};

struct TCashPackageData
{
	int nSN;		// 패키지판매SN
	std::vector<int> nVecCommoditySN;

	TCashPackageData()
	{
		nSN = 0;
		nVecCommoditySN.clear();
	}
};

struct TCashLimitData
{
	int nSN;			// 한정판매할 상품 SN
	time_t tStartDate;  // _StartDate	시작일
	time_t tEndDate;	// _EndDate	종료일	
	int nBuyAbleCount;	// 캐릭터당 구매가능횟수
#if defined(PRE_ADD_LIMITED_CASHITEM)
	int nLimitedSellCount;		//갯수한정아이템!
#endif		//#if defined(PRE_ADD_LIMITED_CASHITEM)
};

struct TVIPData
{
	int nVipID;				// VIPTable에서의 ID
	int nMonthItemSN;		// 캐시 아이템 상품 넘버 (30일 결제시 한번 주기)
	int nMailID[4];			// 0:서비스만료 7일전, 1:서비스만료 1일전, 2:서비스만료시, 3:자동결제시 캐시 부족할때
	int nAutoPayItemSN;		// 자동결제할때 결제할 아이템SN	
};

// DL Table
struct TDLMapData
{
	int nTotalRound;
	int nFloor;

#if defined( PRE_ADD_CHALLENGE_DARKLAIR )
	bool bChallengeDarkLair;
#endif	// #if defined( PRE_ADD_CHALLENGE_DARKLAIR )
};

struct TDLClearDataItem
{
	int nLevelMin;
	int nLevelMax;
	int nRoundMin;
	int nRoundMax;
	int nRewardExperience;
	int nShowBoxCount;
	int nSelectBoxCount;
	char cTreasureBoxRatio[4];
	int nRewardItemID[4];
	int nReturnWorldSetID;
	int nReturnWorldGateID;
	int nRewardGP;
};

struct TDLClearData
{
	std::vector<TDLClearDataItem*> pVecClearItem;
};

// Levelup Event 
struct TLevelupEvent
{
	enum eEventType
	{
		Levelup = 1,			// 일반 레벨업이벤트
		ShandaPromotion = 2,	// 샨다 프로모션이벤트
		CombackUser = 3,		// 복귀유저이벤트
		LevelupNew = 4,			// 레벨업이벤트 새거 (한번 받으면 더이상 못받는 버젼)
		ComeBackUserInven = 5,		// 귀환자에게 바로 넣어주는 아이템 타입
		NewbieQuitReward = 6, //신규 유저 접속 종료 보상
		NewbieReconnectReward = 7, //신규 유저 재접속 보상
		ComeBackUserQuitReward = 8, //귀환자 접속 종료 보상
	};

	int nLevel;			// Player 캐릭터의 레벨
	char cClassID;		// 클래스
	BYTE cJob;
	int nMailID;
	int nCashMailID;
	int nEventType;		// eEventType

	TLevelupEvent()
	{
		nLevel = 0;
		cClassID = 0;
		nMailID = 0;
		nCashMailID = 0;
		cJob = 0;
	}
};

struct TItemOptionTableData
{
	int iEnchant;
	int iOption;
	int iPotential;
	TItemOptionTableData()
	{
		iEnchant = 0;
		iOption = 0;
		iPotential = 0;
	}
};

#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )

struct TReputeTableData
{
#if defined( PRE_ADD_REPUTATION_EXPOSURE )
	int iMissionID;
	int iNpcPresentRepute1; // 선물1 지급 호감도 달성 조건
	int iNpcPresentRepute2; // 선물2 지급 호감도 달성 조건
	int iNpcPresentID1; // NpcPresentRepute1 달성 시 NPC가 주는 선물 1 ItemID
	int iNpcPresentID2; // NpcPresentRepute1 달성 시 NPC가 주는 선물 2 ItemID
#else
	std::vector<int>	iQuestIDs;
#endif // #if defined( PRE_ADD_REPUTATION_EXPOSURE )
	
	int	iMaxFavor;			// 호의 최대치
	int	iTakeFavorPerDay;	// 1일당 깎이는 호의 수치
	int	iMaxMalice;			// 악의 최대치
	int	iAddMalicePerDay;	// 1일당 올라가는 악의 수치
	int	iPresentIDArr[6];	// 받을 수 있는 선물 리스트
	std::vector<int> vFavorNpcID;		// 호의 NPC 리스트
	std::vector<int> vMaliceNpcID;		// 악의 NPC 리스트
	int	iFavorGroupBomb;
	int	iMaliceGroupBomb;
	int	iMailID[NpcReputation::Common::MaxMailCount];
	int	iMailRand[NpcReputation::Common::MaxMailCount];
	int	iPlusItemID;
	int	iPlusProb;
	int	iUnionID;
	int	iPresentPointArr[6]; // 선물마다 받을수 있는 연합포인트

	TReputeTableData()
	{
#if defined( PRE_ADD_REPUTATION_EXPOSURE )
		iMissionID			= 0;
		iNpcPresentRepute1	= 0;
		iNpcPresentRepute2	= 0;
		iNpcPresentID1		= 0;
		iNpcPresentID2		= 0;
#else
#endif // #if defined( PRE_ADD_REPUTATION_EXPOSURE )
		iMaxFavor			= 0;
		iTakeFavorPerDay	= 0;
		iMaxMalice			= 0;
		iAddMalicePerDay	= 0;
		iFavorGroupBomb		= 0;
		iMaliceGroupBomb	= 0;
		for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
			iPresentIDArr[i] = 0;
		for( UINT i=0 ; i<NpcReputation::Common::MaxMailCount ; ++i )
		{
			iMailID[i]		= 0;
			iMailRand[i]	= 0;
		}
		vFavorNpcID.clear();
		vMaliceNpcID.clear();

		iPlusItemID			= 0;
		iPlusProb			= 0;
		iUnionID			= 0;
		for( UINT i=0 ; i<_countof(iPresentPointArr) ; ++i )
			iPresentPointArr[i] = 0;
	}

	int GetUnionPointByPresent (const int iPresentID)
	{
		for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
		{
			if( iPresentIDArr[i] == iPresentID )
			{
				// 혹시 몰라서 사이즈 검사 한번더!
				if (0 <= i && i < _countof(iPresentPointArr))
					return iPresentPointArr[i];
			}
		}
		return 0;
	}

	bool CheckPresentID( const int iPresentID )
	{
		for( UINT i=0 ; i<_countof(iPresentIDArr) ; ++i )
		{
			if( iPresentIDArr[i] == iPresentID )
				return true;
		}
		return false;
	}

	bool bIsFavorNpc( const int iNpcID )
	{
		for( UINT i=0 ; i<vFavorNpcID.size() ; ++i )
		{
			if( vFavorNpcID[i] == iNpcID )
				return true;
		}
		return false;
	}

	bool bIsMaliceNpc( const int iNpcID )
	{
		for( UINT i=0 ; i<vMaliceNpcID.size() ; ++i )
		{
			if( vMaliceNpcID[i] == iNpcID )
				return true;
		}
		return false;
	}
};

struct TPresentTableData
{
	enum eType
	{
		Normal	= 0,
		Cash	= 1,
		Coin	= 2,
		Max,
	};

	eType Type;
	int	iTypeID;
	int	iCount;
	int	iAddFavorPoint;
	int	iTakeMalicePoint;
	int	iFavorGroupPoint;
	int	iMaliceGroupPoint;

	TPresentTableData()
	{
		Type = Max;
		iTypeID = 0;
		iCount = 0;
		iAddFavorPoint = 0;
		iTakeMalicePoint = 0;
		iFavorGroupPoint = 0;
		iMaliceGroupPoint = 0;
	}
};

struct TMailTableData
{
	DBDNWorldDef::MailTypeCode::eCode	Code;
	bool IsCash;
	int	nSenderUIStringIndex;
	int	nTitleUIStringIndex;
	int	nTextUIStringIndex;
	int	ItemIDArr[MAILATTACHITEMMAX];
	int	ItemCountArr[MAILATTACHITEMMAX];
	int	ItemSNArr[MAILATTACHITEMMAX];
	int	nPresentMoney;
#if defined(PRE_SPECIALBOX)
	int nKeepBoxReceive;
	int nKeepBoxType;
	int nKeepBoxLevelMin;
	int nKeepBoxLevelMax;
	int nKeepBoxClass;
#endif	// #if defined(PRE_SPECIALBOX)
	
	TMailTableData()
	{
		Code = static_cast<DBDNWorldDef::MailTypeCode::eCode>(0);
		IsCash = false;
		nSenderUIStringIndex = 0;
		nTitleUIStringIndex = 0;
		nTextUIStringIndex = 0;
		nPresentMoney = 0;
		memset( ItemIDArr, 0, sizeof(ItemIDArr) );
		memset( ItemCountArr, 0, sizeof(ItemCountArr) );
		memset( ItemSNArr, 0, sizeof(ItemSNArr) );
#if defined(PRE_SPECIALBOX)
		nKeepBoxReceive = 0;
		nKeepBoxType = 0;
		nKeepBoxLevelMin = 0;
		nKeepBoxLevelMax = 0;
		nKeepBoxClass = 0;
#endif	// #if defined(PRE_SPECIALBOX)
	}
};

struct TStoreBenefitData
{
	// 아래의 순서는 StoreBenefit 테이블의 정의와 맞춘 것이기 때문에 절대로 순서가 바뀌면 안됨.
	enum eType
	{
		EnchantFeeDiscount = NpcReputation::StoreBenefit::EnchantFeeDiscount,
		RepairFeeDiscount = NpcReputation::StoreBenefit::RepairFeeDiscount,
		SellingPriceUp = NpcReputation::StoreBenefit::SellingPriceUp,
		BuyingPriceDiscount = NpcReputation::StoreBenefit::BuyingPriceDiscount,
		FishProficiencyUp = NpcReputation::StoreBenefit::FishProficiencyUp,
		CookProficiencyUp = NpcReputation::StoreBenefit::CookProficiencyUp,
		CultivateProficiencyUp = NpcReputation::StoreBenefit::CultivateProficiencyUp,
		Max = NpcReputation::StoreBenefit::Max, 
	};

	int iNpcID;
	eType Type;
	int aiFavorThreshold[ STORE_BENEFIT_MAX ];
	int aiAdjustPercent[ STORE_BENEFIT_MAX ];

	TStoreBenefitData( void ) : iNpcID( 0 ), Type( Max )
	{
		memset( aiFavorThreshold, 0, sizeof(aiFavorThreshold) );
		memset( aiAdjustPercent, 0, sizeof(aiAdjustPercent) );
	}
};

#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )

struct TShopPurchaseType
{
	Shop::PurchaseType::eCode PurchaseType;
	int iPurchaseItemID;
	int iPurchaseItemValue;
};

struct TCombinedShopTableData
{
	TShopItem ShopItem;
	TShopPurchaseType PurchaseType[Shop::Max::PurchaseType];
	Shop::PurchaseLimitType::eCode PurchaseLimitType;
	int iPurchaseLimitValue;
#if defined(PRE_SAMPLEITEMNPC)
	int nSampleVersion;	// 샘플아이템 회차
#endif	//#if defined(PRE_SAMPLEITEMNPC)
};

struct TMasterSystemDecreaseTableData
{
	int iPupilLevel;
	int iPupilFavor;
	int iFavorUpDecreaseRespectPoint;
	int iFavorDownDecreaseRespectPoint;
	int iMasterSuccessMailID;
	int iMasterFailureMailID;
	int iPupilSuccessMailID;
	int iPupilFailureMailID;

	int GetDecreaseRespectPoint( int iFavorPoint )
	{
		if( iFavorPoint >= iPupilFavor)
			return iFavorUpDecreaseRespectPoint;
		return iFavorDownDecreaseRespectPoint;
	}
};

struct TMasterSystemGainTableData
{
	int	iFavorPoint;
	int	iRepectPoint;
};

#if defined( PRE_ADD_SECONDARY_SKILL )

struct TSecondarySkillTableData
{
	int	iSkillID;
	SecondarySkill::Type::eType Type;
	SecondarySkill::SubType::eType SubType;
	SecondarySkill::ExecuteType::eType ExecuteType;
};

struct TSecondarySkillLevelTableData
{
	int	iSkillID;
	SecondarySkill::Grade::eType Grade;
	int	iLevel;
	int	iExp;
	int	iNextID;
	int	iParam;
};

struct TSecondarySkillRecipeTableData
{
public:
	int iManufactureItemID[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
	int	iMinExp[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
	int	iMaxExp[SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount];
	SecondarySkill::Grade::eType	RequireGrade;
	int	iRequireSkillLevel;
	int	iToolItemID[SecondarySkill::ManufactureSkill::MaxToolItemCount];
	int	iMasterExp;
	int	iStartExp;
	int	iMaxTime;	// 단위(ms)
	int	iSuccessProbability;
	int	iSuccessUpExp;
	int	iRecipeUpExp;
	int	iMaterialItemID[SecondarySkill::ManufactureSkill::MaxMaterialItemCount];
	int	iMaterialItemCount[SecondarySkill::ManufactureSkill::MaxMaterialItemCount];
	int	iSuccessCount;

	// 경험치로 생산될 ItemID 얻기
	int GetManufactureItemID( int iExp, int iMaxValue )
	{
		int iExpRate = static_cast<int>(iExp/static_cast<float>(iMaxValue)*100);

		for( int i=0 ; i<SecondarySkill::ManufactureSkill::MaxManufactureItemTypeCount ; ++i )
		{
			if( iExpRate >= iMinExp[i] && iExpRate <= iMaxExp[i] )
				return iManufactureItemID[i];
		}

		_ASSERT_EXPR(0, L"[GetManufactureItemID] can not find ItemID");
		return -1;
	}
};

#endif // #if defined( PRE_ADD_SECONDARY_SKILL )


#ifdef PRE_ADD_CASHFISHINGITEM
struct TFishingMeritInfo
{
	int nRodItemID;

	bool bUseCashBait;
	INT64 biBaitSerial;
	int nBaitIndex;

	int nMeritReduceFishingTime;
	int nMeritSuccessRate;
};
#endif		//#ifdef PRE_ADD_CASHFISHINGITEM

struct TFarmCultivateTableData
{
	int	iCultivateMaxTimeSec;
	int	iMaxWater;
	int iConsumeWater;
	int iHarvestNeedItemID;
	int iHarvestDropRate[Farm::Max::HARVESTITEM_COUNT];
	int iHarvestDropTableID;
	int iSkillPointPlant;			// 씨앗심기 시 경험치
	int iSkillPointWater;			// 물주기 시 경험치
	int iCatalystCount;				// 필요 성장촉진제 개수
	SecondarySkill::Grade::eType	RequiredSkillGrade;
	int								iRequiredSkillLevel;
	int	iOverlap;
};

struct TFishingTableData
{
	int nMaxTime;
#ifdef PRE_ADD_CASHFISHINGITEM
	int nAutoMaxTime;
#endif		//#ifdef PRE_ADD_CASHFISHINGITEM
	int nPullingTargetMin;
	int nPullingTargetMax;
	int nPullingTargetSpeed;
	int nPullingTargetUpTime;
	int nSkillPointSuccess;
	int nSkillPointFailure;
	int nSuccessProbability;
	int nSuccessDropTableID;
};

struct TFishingPattern
{
	int nPatternID;
	int nProbabillity;
};

struct TFishingPointTableData
{
	int nSecondarySkillClass;			//낚시보조스킬등급
	int nSecondarySkillLevel;			//낚시보조스킬레벨
	int nRequireItemType1;
	int nRequireItemType2;
	TFishingPattern Pattern[Fishing::Max::FISHINGPATTERNMAX];
};

struct TFishingAreaTableData
{
	int nMatchedMapID;
	int nMatchedFishingAreaID;
	int nFishingPointID;
};



struct TJobTableData
{
	char	cJobNumber;
	char	cBaseClass;
	char	cParentJob;
	float	afMaxUsingSP[ 5 ];
	char	cClass;
};

struct TGlyphSkillData
{
	int nGlyphID;
	int nGlyphType;
	int nSkillID;
	int nSkillLevelID;
};

struct TGlyphSlotData
{
	int nID;
	char cSlotID;
	char cLevelLimit;
	char cSlotType;
	bool IsCash;
};

struct TGlyphChargeData
{
	char cGlyphType;		// 1: 강화문장 2: 스킬문장  3: 특수스킬문장	(eGlyphType)
	char cGlyphRank;		// 1: 매직 2: 레어 3: 에픽 4: 유니크 (eItemRank)
	int nCharge;
};

struct TCharmItem
{
#if defined(PRE_FIX_68828)
	int nCharmID;	// 참테이블 ID
#endif
	int nItemID;	// 아이템
	int nCount;		// 유저가 획득할 개수
	int nProb;		// 확률
	int nPeriod;	// 기간
	int nAccumulationProb;
	int nGold;
	bool bMsg;
};

struct TCharmItemData
{
	int nCharmNo;	// 매력아이템 번호
	std::vector<TCharmItem> CharmItemList;
};

const BYTE CharmItemKeyMax = 5;
struct TCharmItemKeyData
{
	int nCharmItemID;	// 상자 아이템 아이디
	std::vector<int> nKeyList;
};

struct TCharmCountData
{
	int nID;
	int nMin;
	int nMax;
};

#if defined (PRE_ADD_CHAOSCUBE)
struct TChaosStuffItem
{
	int nItemID;
	int nCount;
	int nChaosNo;
};

struct TChaosResultItem
{
	int nItemID;	// 아이템
	int nCount;		// 유저가 획득할 개수
	int nProb;		// 확률
	int nPeriod;	// 기간
	int nAccumulationProb;
	int nGold;
	bool bMsg;
};

struct TChaosItemData
{
	int nChaosNo;
	std::vector<TChaosResultItem> ChaosItemList;

};
#endif // #if defined (PRE_ADD_CHAOSCUBE)

//ServerMonitor
enum eServerMonitorLevel
{
	SERVERMONITOR_LEVEL_NONE = 0,
	SERVERMONITOR_LEVEL_MONITOR,				//동접정보와 서버의상태
	SERVERMONITOR_LEVEL_ADMIN,					//동접정보와 서버상태 및 프로세스 시작만 가능
	SERVERMONITOR_LEVEL_SUPERADMIN,				//동접정보와 서버상태 및 모든컨트롤 가능
};

enum eServerMonitorNotice
{
	SERVERMONITOR_UPDATENOTICE_CHANNELINFO,
	SERVERMONITOR_UPDATENOTICE_SERVERINFO,
	SERVERMONITOR_UPDATENOTICE_MERITINFO,
	SERVERMONITOR_UPDATENOTICE_WOLRDINFO,
};

enum eSIDConnectionType
{
	SID_CONNECTION_TYPE_LOG = 1,
	SID_CONNECTION_TYPE_DB,
};

struct TPromotionData
{
	int nID;
	int nConditionType;				//ePromotionConditionType
	int nConditionValue;
	int nPromotionType;				//ePromotionType
	int nRewardValue;				//Percent
};

struct TUserPromotionData
{
	int nType;		//ePromotionType
	int nValue;		//Percent
};

struct TSchedule
{
	char cHour;
	char cMinute;
	int nCycle;
};


struct TGuildLevel
{
	int nLevel;
	int nReqGold;
	int nReqGuildPoint;
	int nDailyGuildPointLimit;
	int nDailyMissionPointLimit;
	bool bApplicable;
};

struct TGuildWarPoint
{
	int nRank;
	int nRewardGuildPoint;
};

struct TGuildWarMapInfo
{
	UINT uiMapTableID;
	char cGuildWarUseMonth;
};

struct TGuildWarEventInfo
{
	//char cEventStep;
	__time64_t tBeginTime;
	__time64_t tEndTime;
};
// 길드전 보상 메일관련
struct TGuildWarRewardData
{
	char cType;			// 보상 타입..eGuildWarRewardType
	char cClass;		// 클래스(워리어,아처, 소서리스, 클래릭)
	int nMailID;		// 우편 아이디
	int nPresentID;		// 선물함 아이디
	int nGuildFestivalPoint;	// 본선에서 지급할 길드축제포인트
	int nGuildPoint;			// 본선에서 지급할 길드포인트
};


struct TPeriodQuestDate
{
	int nPeriodType;
	__time64_t tAssignDate;
};

struct TExchangeTrade
{
	int nItemID;
	int nCategoryType;
	int nGroupID;
	int ExchangeType;
};

struct TPvPMissionRoom
{
	int nItemID;
	int nGroupID;
	int nMapID;
	int nModeID;
	int nWinCondition;
	int nPlayTime;
	int nMaxPlayers;
	int nStartPlayers;
	int nRoomNameIndex;
	bool bDropItem;
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	int nChannelType;
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
};

typedef std::vector<TPvPMissionRoom> TVecPvPMissionRoom;

struct TGhoulConditionData
{
	int nItemID;
	int nItemIdx;
	int nPlayerMaxNum[PvPCommon::Common::GhouConditionColCount];
	int nGhoulCount[PvPCommon::Common::GhouConditionColCount];
	int nMatchingMutationGroupID[PvPCommon::Common::GhouConditionColCount];
};

struct TMonsterMutationGroup
{
	int nGroupID;
	int nGourpIdx;
	int nMonsterID[PvPCommon::Common::MonsterMutationColCount];
	int nProbability[PvPCommon::Common::MonsterMutationColCount];
};

struct TMonsterMutationData
{
	int nMutationID;
	int nMutationIdx;
	int nMutationActorID;

	int nMutationHP;
	int nMutationStrPMax;
	int nMutationStrMMax;
	int nMutationDefP;
	int nMutationDefM;
	int nMutationStiff;

	int nMutationStiffResis;
	int nMutationCriticalResis;
	int nMutationStunResis;

	int nMutationWeaponIdx1;
	int nMutationWeaponIdx2;
	int nMutationSkillTableID;
	int nMutationSuperArmor;

	int nSizeMin;
	int nSizeMax;
	int nMoveSpeed;
};

struct TMonsterMutationSkill
{
	int nMonsterID;
	int nMonsterIdx;
	int nMonsterSkillIndex[PvPCommon::Common::MonsterMutationSkillColCount];
	int nMonsterSkillLevel[PvPCommon::Common::MonsterMutationSkillColCount];
};

struct TOccupationModeInfo
{
	int nVictoryCondition[PvPCommon::Common::MaximumVitoryCondition];		//PvPCommon::BattleGroundVictoryState
	int nVictoryParam[PvPCommon::Common::MaximumVitoryCondition];		//PvPCommon::BattleGroundVictoryState
	int nBossID[PvPCommon::TeamIndex::Max];									//생성보스아이디
	int nBossSpawnAreaID[PvPCommon::TeamIndex::Max];						//보스생성시 스폰위치
};

struct TBattleGourndModeInfo
{
	int nID;
	int nWaitingMin;
	int nFinishingMin;
	int nPvPSkillPoint;	
	int nMaximumResourceLimit;
	int nAllOcuupationBonusGain;
	int nOccupationBonusGain[PvPCommon::Common::MaximumCapturePosition];

	int nCaptureScore;
	int nStealScore;
	int nKillScore;
	int nClimaxTime;
	int nClimaxRespawnTime;

	TOccupationModeInfo ModeInfo;
};

struct TPositionAreaInfo
{
	int nID;
	int nMapID;
	int nPvPModeID;
	int nAreaID;
	int nGainResourceTermTick;			//점령시 획득텀
	int nGainResource;					//획특텀시 획득량
	int nRequireTryTick;				//획득시도시 클릭상태지속 유지필요시간
	int nCompleteOccupationTick;		//클릭완료후 점령권 넘어가기 전의 대기시간
	int nBonusBuffID;
	//클라이막스~
	int nClimaxGainTermTick;
	int nClimaxGainVal;
	int nClimaxTryTick;
	int nClimaxCompleteOccupationTick;
};

struct TBattleGroundEffectValue
{
	int nSkillID;
	int nSkillLevel;
	int nNeedSkillPoint;			//획득시필요포인트
	int nUseResPoint;			//스킬사용시 소모 점령전 포인트
	std::string strEffectValue[PvPCommon::Common::MaximumEffectCount];
	int nEffectValueDuration[PvPCommon::Common::MaximumEffectCount];
	//int nMonsterID;
	//int nSummonDist;
	std::string strActionName;
	int nCoolTime;

	void Reset()
	{
		nSkillID = 0;
		nSkillLevel = 0;
		nNeedSkillPoint = 0;			//획득시필요포인트
		nUseResPoint = 0;			//스킬사용시 소모 점령전 포인트		
		for (int i = 0; i < PvPCommon::Common::MaximumEffectCount; i++)
		{
			strEffectValue[i].clear();;
			nEffectValueDuration[i] = 0;
		}

		//nMonsterID = 0;
		//nSummonDist = 0;
		strActionName.clear();
		nCoolTime = 0;
	}
};

struct TBattleGroundSkillInfo
{
	int nSkillID;
	int nSkillMaxLevel;
	int nSkillType;				//CDnSkill::SkillTypeEnum		//점령전 스킬은 스킬타입에 그닥 영향을 받지 않지만 추가확장시 필요할까 해서 읽어둠
	int nSkillDurationType;		//CDnSkill::DurationTypeEnum
	int nSkillTargetType;		//CDnSkill::TargetTypeEnum
	int nEffectType[PvPCommon::Common::MaximumEffectCount];
	int nEffectApplyType[PvPCommon::Common::MaximumEffectCount];
	int nProcess;				//프로세스타입은 하나만 사용
	int nCanDuplicate;			//중첩가능?
};

struct TBattleGroundSkill
{
};

struct TUnionReputeBenefitData
{
	int nItemID;
	int nPeriod;
	int nBenefitType[NpcReputation::Common::MaxBenefitCount];
	int nBenefitNum[NpcReputation::Common::MaxBenefitCount];
};

struct TGuildMarkData
{
	int nItemID;
	int nType;
	bool bCash;
	bool bMarkOnly;
	bool bMarkView;
};

struct TPlayerCommonLevelTableInfo
{
	int iFatigue10000Ratio;	// 10000배율
	float fMasterGainExp;
	//int nMasterGainItemID;
	//int nMasterGainItemCount;
	float fAddGainExp;
	float fDefense;
	float fCritical;
	float fFinalDamage;
#if defined(PRE_ADD_TALISMAN_SYSTEM)
	int iTalismanCost;	// 탈리스만 장착 해제, 위치교환 비용
#endif
};

struct TMasterSysFeelTableInfo
{
	int nMinFeel;
	int nMaxFeel;
	int nAddExp; //(%값임)
};

struct TGlobalEventData
{
	int nItemID;
	int nCollectItemID;
	int nScheduleID;
	int nCollectTotalCount;
	int nNoticeCount[MAX_NOTICE_WORLDEVENT];
	bool bCheckNotice[MAX_NOTICE_WORLDEVENT];

	time_t tCollectStartDate;
	time_t tCollectEndDate;
	time_t tRewardDate;
};

struct TEveryDayEventData
{
	int nEventID;
	int nEventOnOff;
	int nSquenceDateCount;
	int nMailID;
	int nCashMailID;
	int nNumber;
	time_t tStartDate;
	time_t tEndDate;
};

enum eDBJobSystem  //g_szDBJobSystem
{
	DBJOB_GUILDWAR_INIT = 0,		// 길드전 초기화
	DBJOB_GUILDWAR_STATS,		// 길드전 통계
	DBJOB_SYSTEM_MAX,
};

enum eDBJobSystemStatus
{
	JOB_STATUS_RESERVE,		// 예약
	JOB_STATUS_COMPLETED,	// 완료
	JOB_STATUS_DOING,		// 실행중
	JOB_STATUS_FAIL,		// 실패
};

struct TGuildRewardItemData
{
	int		nItemID;			// 길드보상테이블에 있는 아이디
	short	nNeedGuildLevel;	// 구입하기위한 길드레벨
	int		nNeedGold;			// 구입하기위한 골드
	int		nItemType;			// 길드보상아이템 타입
	int		nTypeParam1;
	int		nTypeParam2;
	bool	bCheckInven;		// 이미 구입한건지 체크
	bool	bEternity;			// 0:기간제 1:영구
	int		nPeriod;			// 기간
	bool	bCheckMaster;		// 마스터체크 여부
	int		nCheckType;			// 필요 조건 체크(0:NONE 1:ITEMID 2:길드마크
	int		nCheckID;			// 필요한 이전 아이템아이디
};
struct TExpData 
{
	int nExperience;
	int nEventExperience;
	int nPcBangExperience;
	int nVIPExperience;
	int nPromotionExperience;
	int nItemExperience;
	int nGuildExp;
	TExpData()
	{
		nExperience = 0;
		nEventExperience = 0;
		nPcBangExperience = 0;
		nVIPExperience = 0;
		nPromotionExperience = 0;
		nItemExperience = 0;
		nGuildExp = 0;
	}
	void set(float Exp, float EventBonusExp = 0, float PcBangExp = 0, float VIPExp = 0, float PromotionBonusExp = 0, float ItemExp = 0, float GuildExp = 0)
	{
		nExperience = (int)Exp;
		nEventExperience = (int)EventBonusExp;
		nPcBangExperience = (int)PcBangExp;
		nVIPExperience = (int)VIPExp;
		nPromotionExperience = (int)PromotionBonusExp;
		nItemExperience = (int)ItemExp;
		nGuildExp = (int)GuildExp;
	}
};
#if defined(PRE_ADD_SALE_COUPON)
struct TSaleCouponData
{
	int nItemID;							// 쿠폰 ID
	int nUseItemSN[MAX_SALE_USEITEM];		// 쿠폰이 적용될 아이템 SN
};
#endif

#if defined( PRE_PARTY_DB )

namespace Party
{
	struct QueryOutPartyType
	{
		enum eCode
		{
			Normal = 0,
			Disconnect,
			Kick,
			EternityKick,
		};
	};

	struct AddPartyAndMemberGame
	{
		Party::Data PartyData;		
		UINT nKickedMemberList[PARTYKICKMAX];
		INT64 biCharacterDBID[PARTYMAX];
		UINT nSessionID[PARTYMAX];	
#if defined( PRE_ADD_NEWCOMEBACK )
		bool bCheckComebackAppellation[PARTYMAX];
#endif
	};

	struct PartyMemberVillageData
	{
		UINT nAccountDBID;
		INT64 biCharacterDBID;
		BYTE cMemberIndex;
		BYTE cVoiceAvailable;
#if defined( PRE_ADD_NEWCOMEBACK )
		bool bCheckComebackAppellation;
#endif
		UINT nMutedList[PARTYCOUNTMAX];
	};
	struct AddPartyAndMemberVillage
	{
		Party::Data PartyData;
		UINT nVoiceChannelID;
		WCHAR wszPartyName[PARTYNAMELENMAX];
		UINT nKickedMemberList[PARTYKICKMAX];
		PartyMemberVillageData MemberData[PARTYMAX];
	};
};

#endif // #if defined( PRE_PARTY_DB )

#if defined( PRE_ADD_NAMEDITEM_SYSTEM )
struct TNamedItemData
{
	int nItemID;		// 네임드아이템아이디
	int nMaxCount;		// 최대 갯수
	int nSwapItemID;	// 대체할 아이템아이디
};
namespace EffectSkillNameSpace
{
	struct SearchType
	{
		enum eType
		{
			ItemType = 0,
			ItemID,
			SkillID,			
		};
	};	
	struct BuffType
	{
		enum eType
		{
			Partybuff = 0,
			SelfBuff,
		};
	};
	struct ShowEffectType
	{
		enum eType
		{
			NONEEFFECT = 0,
			BUFFEFFECT,
			SPELLEFFECT,
		};
	};
};
#endif

#ifdef PRE_ADD_EXCHANGE_POTENTIAL
struct TPotentialTransferData
{
	int nItemID;
	int nExtractItemLevel;
	int nExtractItemRank;
	int nInjectItemLevel;
	int nInjectItemRank;
	int nConsumptionCount;
	int nMainType;
	int nSubType;
};
#endif		//#ifdef PRE_ADD_EXCHANGE_POTENTIAL

#if defined(PRE_ADD_INSTANT_CASH_BUY)
const int CashBuyShortcutMax = 10;
struct TCashBuyShortcutData
{
	int nType;
	int nAllowMapTypes;
	int nShow;
	std::vector<int> nSNList;
};
#endif	// #if defined(PRE_ADD_INSTANT_CASH_BUY)

#if defined(PRE_ADD_EXCHANGE_ENCHANT)
struct TExchangeEnchantData
{
	BYTE cRank;	// 아이템 등급
	BYTE cLevelLimit;	// 제한 레벨
	BYTE cEnchantLevel;	// 강화 레벨
	int nNeedCoin;	// 수수료
	int nNeedItemID1;	// 필요아이템1
	short wNeedItemCount1;	// 필요아이템 카운트1
	int nNeedItemID2;	// 필요아이템2
	short wNeedItemCount2;	// 필요아이템 카운트2
};
#endif //#if defined(PRE_ADD_EXCHANGE_ENCHANT)

#if defined( PRE_WORLDCOMBINE_PARTY )
namespace WorldCombineParty
{
	enum eType
	{
		MAXSKILLCOUNT = 2,
	};

	struct WrldCombinePartyData
	{
		BYTE cIndex;				// 인덱스
		BYTE cGroupIndex;			// 그룹인덱스
		WCHAR wszPartyName[PARTYNAMELENMAX];
		int nWorldMap;			// 월드존
		int nTargetMap;			// 타겟맵(기준값)
		ePartyType PartyType;	// 파티타입
		BYTE cPartyMemberMax;
		int nItemID;			// 입장권아이템
		TDUNGEONDIFFICULTY Difficulty;
		TPARTYITEMLOOTRULE ItemLootRule;			//ePartyItemLootRule 참조
		TITEMRANK ItemRank;				//아이템랭크(루트룰기획참조)
		BYTE cUserLvLimitMin;		//민맥스값이 있단다.
		int iBitFlag;
		int nSkillID[MAXSKILLCOUNT];				// 스킬아이디		
	};		
}
#endif

#if defined(PRE_ADD_PCBANG_RENTAL_ITEM)
struct TPcBangRentItem
{
	int nItemID;
	BYTE cLevelStart;
	BYTE cLevelEnd;
	BYTE cClassID;
	BYTE cJob;
	BYTE cGrade;
	int nItemOption;
};
#endif

#if defined( PRE_PRIVATECHAT_CHANNEL )
struct TPrivateChatChannelInfo
{	
	INT64 nPrivateChatChannelID;
	WCHAR wszName[PrivateChatChannel::Common::MaxNameLen];
	INT64 biMasterCharacterDBID;
	int nMemberCount;
	int nPassWord;	
};

struct TPrivateChatChannelMember
{
	time_t tJoinDate;
	UINT nAccountDBID;
	INT64 biCharacterDBID;	
	bool bMaster;
	WCHAR wszCharacterName[NAMELENMAX];
};

struct TPrivateMemberDelServer
{
	INT64 nPrivateChatChannelID;	
	INT64 biCharacterDBID;
	WCHAR wszCharacterName[NAMELENMAX];
};
#endif

#if defined(PRE_ADD_WEEKLYEVENT)
namespace WeeklyEvent
{
	struct TWeeklyEventData
	{
		int nStartTime;
		int nEndTime;
		BYTE cRaceType;		// eRaceType
		BYTE cClassType;	// eClass
		int nEventType;
		int nValue;			// %값
	};

	struct TWeeklyEvent
	{
		int nDayOfWeek;		// eDayType
		std::vector<TWeeklyEventData> VecEventData;
	};

	enum eDayType
	{
		Monday = 1,
		Tuesday = 2,
		Wednesday = 3,
		Thursday = 4,
		Friday = 5,
		Saturday = 6,
		Sunday = 7,
	};

	enum eRaceType
	{
		Player = 1,
		Monster = 2,
	};

	enum eEventType
	{
		Event_1 = 1,			// 1. hp상승 및 하락
		Event_2 = 2,			// 2. 공격력 강화 및 약화
		Event_3 = 3,			// 3. 방어력 강화 및 약화
		Event_4 = 4,			// 4. 강화 확률 증가
		Event_5 = 5,			// 5. 경험치 증가
		Event_6 = 6,			// 6. 파티유지 경험치 증가
		Event_7 = 7,			// 7. 친구 경험치 증가 (절친아님, 서로친구)
		Event_8 = 8,			// 8. 호감도 증가
		Event_9 = 9,			// 9. 연합 포인트획득량 증가
		Event_10 = 10,			// 10. 아이템 드랍률 증가
	};
}
#endif	// #if defined(PRE_ADD_WEEKLYEVENT)

#if defined( PRE_ADD_TOTAL_LEVEL_SKILL )
namespace TotalLevelSkill
{
	struct TTotalSkillLevelTable
	{
		int nSkillID;
		int nTotalLevelLimit;
		int nUseLevelLimit;
		int nSkillType;		
	};
	struct TTotalSkillBlowTable
	{
		int nSkillID;
		int nBlowID;
		float fBlowValue;
		int nBlowValue;		// 농장 아이템 아이디‹š문에 사용
	};
	struct TTotalSkillSlotTable
	{
		int nSlotIndex;
		int nLevelLimit;
		bool bCash;
	};
}
#endif

#if defined(PRE_SPECIALBOX)
struct TProvideItemData
{
	int nCashSN;
	int nItemID;
	int nCount;
	int nSealCount;
	int nOption;
};

struct TKeepBoxProvideItemData
{
	int nType;
	std::vector<TProvideItemData> VecProvideItem;
};
#endif	// #if defined(PRE_SPECIALBOX)

#ifdef PRE_ADD_JOINGUILD_SUPPORT
struct TGuildSupportData
{
	int nID;
	int nJoinMinLevel;			//최초길드가입시 최소레벨
	int nJoinMaxLevel;			//최초길드가입시 최대레벨
	int nFirstJoinMailID;		//최초가입시 보상메일아이디
	int nMaxLevelGuildSupportMailID;	//최초가입한 길드에서 만랩시 보상아이디
};
#endif		//#ifdef PRE_ADD_JOINGUILD_SUPPORT

#if defined( PRE_FIX_67546 )

struct TChannelDBInfo
{
	int nDBConnectionID;
	BYTE cThreadID;
};

struct TDBConnectionInfo
{	
	int nThreadCount[THREADMAX];
};

#endif
#if defined( PRE_WORLDCOMBINE_PVP )

struct TWorldPvPMissionRoom
{
	int nItemID;	
	int nMapID;
	BYTE cModeID;
	int nWinCondition;
	int nPlayTime;
	BYTE cMaxPlayers;
	int nStartPlayers;
	int nRoomNameIndex;
	bool bDropItem;
	USHORT unRoomOptionBit;
	WorldPvPMissionRoom::Common::eReqType eWorldReqType;
	int nMinLevel;
	int nMaxLevel;
	int nChannelType;
	WCHAR wszRoomName[PARTYNAMELENMAX];
	int nRoomPW;
};

struct TWorldPvPRoomDBData
{
	int nDBRoomID;
	int nWorldID;
	int nServerID;
	int nRoomID;
	BYTE cModeID;
	WCHAR wszRoomName[PARTYNAMELENMAX];
	BYTE cMaxPlayers;
	int nMapID;
	int nWinCondition;
	UINT nPlayTimeSec;
	bool bBreakIntoFlag;
	bool bDropItem;
	bool bRegulationFlag;
	bool bObserverFlag;
	bool bRandomFlag;
	BYTE cMinLevel;
	BYTE cMaxLevel;
	int nPassWord;
	int nRoomMemberCount;
	BYTE cChannelType;
};

typedef std::vector<TWorldPvPMissionRoom> TVecWorldPvPMissionRoom;

#endif

#if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD)
struct TBonusDropTable
{
	int nIndex;
	int nMapID; //맵ID
	int nDropType;
	int nNeedItemID[3]; //필요한 열쇠 아이템 ID
	int nDropItemGroupID[3]; //드랍될 드랍아이템그룹ID
};
#endif	// #if defined(PRE_ADD_STAGE_CLEAR_ADD_REWARD)

namespace ActozCommon
{
	struct CharacterStatus
	{
		enum eCharacterStatus
		{
			Revive = 0,
			Create = 0,
			Delete = 1,
		};
	};

	struct UpdateType
	{
		enum eUpdateType
		{
			Login = 1,
			Logout = 2,
			Levelup = 3,
			Sync = 4,
		};
	};
};

#if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD)
struct TItemDropEnchantData
{
	int nIndex; //IDX
	int nDropID; // ItemDropTable의 ID와 매칭되는 값
	int nEnchantCount; //인챈트가 몇개인지 카운트
	int nEnchantOption[20]; //인챈트 정보
	int nEnchantProb[20]; //인챈트가 선택될 확률
};
#endif	// #if defined(PRE_ADD_STAGE_CLEAR_ENCHANT_REWARD)

#if defined( PRE_ALTEIAWORLD_EXPLORE )
struct TAlteiaWorldMapInfo
{
	int nIndex;
	int nMapID;
	TDUNGEONDIFFICULTY Difficulty;
};
#endif // #if defined( PRE_ALTEIAWORLD_EXPLORE )

#if defined( PRE_ADD_STAMPSYSTEM )
namespace StampSystem
{
	struct ChallengeType
	{
		enum eType
		{
			DailyQuest	 = 1,
			DailyMission = 2,
		};
	};

	struct RewardCount
	{
		enum eCount
		{
			Day3 = 3,
			Day5 = 5,
		};
	};

	struct TStampChallenge // 스탬프 도전과제
	{
		BYTE cType;
		std::set<int> setAssignmentID; // 도전과제 목록
		int nMailID4; // 3일 보상
		int nMailID7; // 5일 보상
	};

	struct TStampTableData // 스탬프 테이블
	{
		INT64 biStartTime;
		std::vector<TStampChallenge> vChallengeList;
	};
}
#endif // #if defined( PRE_ADD_STAMPSYSTEM )

#if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)
struct TPrevPotentialData
{
	int nItemID; //아이템 ID
	INT64 nSerial; //시리얼
	char cPotential; //이전 잠재력데이터
	char cOption; //이전 잠재력데이터
	char cNowPotential; //새로 부여된 잠재력
	char cPotentialMoveCount; //(이전)잠재 이전 카운트
	INT64 nPotentialItemSerial; //잠재력 부여에 사용한 코드 시리얼
	int nPotentialItemID; //잠재력 부여에 사용한 아이템 ID
};
#endif	// #if defined(PRE_MOD_POTENTIAL_JEWEL_RENEWAL)

struct TEffectItemData
{
	int nItemSN;
	int nItemID;
	int nCount;
	bool bFail;
	INT64 nGiftDBID;
};

#if defined(PRE_ADD_TALISMAN_SYSTEM)
struct TTalismanData
{
	int nTalismanID;
	int nType;
	int nPeriod;
};

struct TTalismanSlotData
{
	bool bService;
	int nLevel;
	int nAmount;
	int nItem;
	int nNeedItemCount;
	float fEfficiency;
	int nType;
};
#endif

#if defined( PRE_PVP_GAMBLEROOM )

struct TPvPGambleRoomData
{
	int nRoomIndex;	
	bool bRegulation;
	BYTE cGambleType;
	int nPrice;	
};

struct TPvPGambleRoomWinData
{
	INT64 biCharacterDBID;
	int nPrice;
};

#endif // #if defined( PRE_PVP_GAMBLEROOM )

#if defined(PRE_ADD_EQUIPLOCK)
struct TDBLockItemInfo
{
	BYTE cItemCode;
	BYTE cItemSlotIndex;
	INT64 biItemSerial;
	EquipItemLock::TLockItem ItemData;
};
#endif	// #if defined(PRE_ADD_EQUIPLOCK)

#if defined( PRE_ADD_STAGE_WEIGHT )
struct TStageWeightData
{
	float fHPRate;
	float fAttackRate;
	float fSuperArmorRate;
	float fItemDropRate;
};
#endif // #if defined( PRE_ADD_STAGE_WEIGHT )

#if defined( PRE_ADD_CHARACTERCHECKSUM )
struct CheckSumReason
{
	enum eReason
	{
		LogoutCharacter			= 1,
		C2C_KeepGameMoney		= 2,
		C2C_TransferGameMoney	= 3,
	};
};
#endif // #if defined( PRE_ADD_CHARACTERCHECKSUM )

#if defined(PRE_ADD_STAGECLEAR_TIMECHECK)
namespace StageClearCheckTime
{
	enum eCheckMinTime	// 최소 클리어 타임
	{
		CheckMinTime = 60 * 1000, // 1분
	};
	enum eAbuseCount // 증가할 AbuseCount값
	{
		AbuseCount = 10,
	};
	// CheckTime을 사용하지 않을 맵(보스맵ID를 기준으로 판별한다
	struct IgnoreMapIndex
	{
		enum eIgnoreMapIndex
		{
			MAP_CHAOSE_FIELD_BossA = 15157,	//혼돈의 틈 파르마
			MAP_CHAOSE_FIELD_32Lv_BossA = 15167,	//혼돈의 틈 바이라
			MAP_CHAOSE_FIELD_24Lv_BossA = 15174,	// 혼돈의 틈 카말라
		};
	};
};
#endif	// #if defined(PRE_ADD_STAGECLEAR_TIMECHECK)