#include "stdafx.h"
#include "Handler_CG.h"

#include <Object/WiseUser.h>
#include <Object/WiseCharacter.h>
#include <Object/ObjectManager.h>

#include "SolarDateTime.h"


#define HANDLER_CG_RECV_IMPL(fnName)		\
	void Handler_CG::On##fnName(ServerSession* pSession, WiseUser* pUser, sSIG_NETMSG* pSIG_NETMSG)


sPACKET_HANDLER_INFO*	Handler_CG::GetHandlerInfo()
{
	static sPACKET_HANDLER_INFO s_pHandlerInfo[] =
	{
#undef ADD_HANDLER_RECV_INFO_EOR
#undef ADD_HANDLER_RECV_INFO
#define ADD_HANDLER_RECV_INFO_EOR()	{ MAKEWORD(0, 0), PHASE_NOACTION, (PH_fnHandler)NULL }
#define ADD_HANDLER_RECV_INFO(c, p, accptablePHASE)		\
		{ MAKEWORD(c, p), (ePHASE_SHIFT)(accptablePHASE), (PH_fnHandler)&Handler_CG::On##p },

#		include "Handler_CG.List.hxx"

		ADD_HANDLER_RECV_INFO_EOR(),

#undef ADD_HANDLER_RECV_INFO
#undef ADD_HANDLER_RECV_INFO_EOR
	};

	return s_pHandlerInfo;
};

void	Handler_CG::RegisterHandler_ALL(PACKET_HANDLER_DELEGATOR pInstance)
{
	pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo());
	//pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_CHARINFO());
	//pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_SYNC());

	//pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_ZONE());
	//pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_PARTY());
	//pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_GM());
	pInstance->RegisterHandler(AGENT_SESSION, GetHandlerInfo_SECURE());
}

//#define ADD_HANDLER_RECV_INFO(c, p, accptablePHASE)		\
//	void Handler_CG::On##p(ServerSession* pSession, WiseUser* pUser, sSIG_NETMSG* pSIG_NETMSG)

//
//
//

#include <PacketStruct_CG.h>

// (WAVERIX) (REMARK) <070318>
//   Client handler들은 살펴볼 시간이 없었다.

HANDLER_CG_RECV_IMPL(CG_CRYPTOGRAPHY_KEY)
{
	DEBUGGING_CODE_L3("");
	MSG_CG_CRYPTOGRAPHY_KEY& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_CRYPTOGRAPHY_KEY>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	ClientSecurePackNode4Session& rSECURE = pSession->SECURE_PACK();
	ClientCryptPack4Packet& rSENDCRYPT = rSECURE.SEND_CRYPT_PACKET_INFO();

	// 기존 코드... 좀더 생각해 보자.
	//ClientCryptPack4Packet& rRECVCRYPT = rSECURE.RECV_CRYPT_PACKET_INFO();
	//sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	//if(S_000540_WAIT_CG_CRYPTOGRAPHY_KEY_LF == rLOGIC.GetCurrentSTEP())
	//{
	//	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;
	//	sSIG_STEP_ARG& rARG = rSIGNAL.TypeOf<sSIG_STEP_ARG>();
	//	rARG.GROUP = LFG_CONNECTION;
	//	rARG.STEP = S_000920_CLOSURE_EXCEPTION_LF;
	//	rLOGIC.OnMsg(&rSIGNAL);
	//}
	//rSENDCRYPT.SetCryptographyInfo(pMsg);

	MSG_CG_CRYPTOGRAPHY_ACK& rMsgACK = pUser->SEND_MSG().InstanceOf<MSG_CG_CRYPTOGRAPHY_ACK>();
	rMGR.SendPacket(AGENT_SESSION, &rMsgACK, sizeof(rMsgACK));

	rSENDCRYPT.SetCryptographyInfo(&rRecvMsg);

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	if(S_000540_WAIT_CG_CRYPTOGRAPHY_KEY_LF == rLOGIC.GetCurrentSTEP())
	{
		rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

		sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
		rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
		rLOGIC.OnMsg(&rSIGNAL);
	}
}

HANDLER_CG_RECV_IMPL(CG_CRYPTOGRAPHY_CMD)
{
	DEBUGGING_CODE_L3("");
	MSG_CG_CRYPTOGRAPHY_CMD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_CRYPTOGRAPHY_CMD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	ClientSecurePackNode4Session& rSECURE = pSession->SECURE_PACK();
	ClientCryptPack4Packet& rRECVCRYPT = rSECURE.RECV_CRYPT_PACKET_INFO();
	ClientCryptPack4Packet& rSENDCRYPT = rSECURE.SEND_CRYPT_PACKET_INFO();

	// Duplicate Info
	rRECVCRYPT = ClientCryptPack4Packet(rSENDCRYPT);

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	if(S_000560_WAIT_CG_CRYPTOGRAPHY_CMD_LF == rLOGIC.GetCurrentSTEP())
	{
		DEBUGGING_CODE_L3("CMD!!!");
		rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

		sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
		rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
		rLOGIC.OnMsg(&rSIGNAL);
	}
}

HANDLER_CG_RECV_IMPL(CG_CONNECTION_ENTERSERVER_ACK)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_CONNECTION_ENTERSERVER_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_CONNECTION_ENTERSERVER_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	CLIENT_CHARACTER_PART rCHAR_INFO[MAX_CHARACTER_LIST_NUM];
	rRecvMsg.ConvertForRecv(rCHAR_INFO);

	for(DWORD dwIdx=0 ; dwIdx<MAX_CHARACTER_LIST_NUM ; ++dwIdx)
	{
		SLOTIDX idx = rCHAR_INFO[dwIdx].m_bySlot;
		pUser->AddChar(idx, rCHAR_INFO[dwIdx]);
	}

	ZoneControl& rZONE = pUser->ZoneController();
	rZONE.ZoneMoveCmd(ZoneControl::CMD_ZONE_MOV_END, NULL);

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	if(S_000570_WAIT_CG_CONNECTION_ENTERSERVER_ACK_LF == rLOGIC.GetCurrentSTEP())
	{
		rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

		sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
		rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
		rLOGIC.OnMsg(&rSIGNAL);
	}
}

HANDLER_CG_RECV_IMPL(CG_CONNECTION_ENTERSERVER_NAK)
{
	DEBUGGING_CODE_L3("");

	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;

	sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	rARG.SetInfo(LFG_CONNECTION, S_000920_CLOSURE_EXCEPTION_LF);
	rLOGIC.OnMsg(&rSIGNAL);
}

HANDLER_CG_RECV_IMPL(CG_PREPARE_WORLD_CONNECT_ACK)
{
	MSG_CG_PREPARE_WORLD_CONNECT_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_PREPARE_WORLD_CONNECT_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_PREPARE_WORLD_CONNECT_NAK)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_CONNECTION_ENTERVILLAGEREQ_ACK)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_CONNECTION_ENTERVILLAGEREQ_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_CONNECTION_ENTERVILLAGEREQ_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();
	// pUser->GetSelectedCharacter();
	// 이 값이 NULL이 안되도록 하자.
	WiseCharacter* pCHAR = pUser->GetSelectedCharacter();

	DWORD dwPlayerKey = rRecvMsg.m_dwPlayerKey;
	pCHAR->OBJECT_KEY() = dwPlayerKey;

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

	sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	rARG.SetInfo(LFG_ZONE, S_002950_CLOSURE_EXCEPTION_LF);
	rLOGIC.OnMsg(&rSIGNAL);
}

HANDLER_CG_RECV_IMPL(CG_CHARINFO_CHAR_ITEM_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_CHARINFO_SKILL_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_CHARINFO_QUICK_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_CHARINFO_STYLE_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_MISSION_STREAM_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_QUEST_STREAM_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_AREACONQUEST_STREAM_CMD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_SYNC_PLAYER_ENTER_ACK)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_SYNC_PLAYER_ENTER_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_SYNC_PLAYER_ENTER_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();
	ZoneControl& rZONE = pUser->ZoneController();

	rRecvMsg.Decode();

	rZONE.MapPosCmdBlockMode() = FALSE;

	//rRecvMsg.m_fPos;
	//rRecvMsg.m_TransSkillCode;
	sMAP_POS_ARG rPOS;
	rPOS.SUBCMD = 0;
	rPOS.ANGLE = 0;
	rZONE.MapPosCmd(ZoneControl::CMD_POS_GET_CUR_INFO, &rPOS);
	CopyMemory(rPOS.XYZ_CUR, rRecvMsg.m_fPos, sizeof(rPOS.XYZ_CUR));
	CopyMemory(rPOS.XYZ_DEST, rRecvMsg.m_fPos, sizeof(rPOS.XYZ_DEST));
	rZONE.MapPosCmd(ZoneControl::CMD_POS_SET_CUR_INFO, &rPOS);

#if CODE_BACKUP
	ScriptLogic* pSLOGIC = Manipulater::GetScriptLogicInterface()->SCRIPTLOGIC;
	if(pSLOGIC->IsAcceptPlay("[VILLAGE]"))
		printf("Accept\n");
	else
		printf("Can't Accept\n");

	// 위와 같은 샘플을 토대로 이후 플레이 이동에 관련한 플로우를 결정하자.
	// 그 후의 액션은 UsrLogic.dll로 위임하자.
#endif

	//////////////////////////////////////////////////////////////////////////
	// 임시 위치 보정용
	if(1)
	{
		// 벨트헨, 특정 위치
		static float s_rVecSrc[3] =
		{
			-79.f, 78.f, -25.f
			//-37.32f, 59.3f, -25.14f
		};
		rZONE.MapPosCmdBlockMode() = TRUE;
		//CopyMemory(rPOS.XYZ_DEST, s_rVecSrc, sizeof(rPOS.XYZ_DEST));
		SEND_MESSAGE_BLOCK& rSENDMSG = pUser->SEND_MSG();

		if(1)
		{
			MSG_CG_MAP_TELEPORT_SYN& rMsgSYN = rSENDMSG.InstanceOf<MSG_CG_MAP_TELEPORT_SYN>();
			CopyMemory(&rMsgSYN.vPos, &s_rVecSrc, sizeof(s_rVecSrc));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN, sizeof(rMsgSYN));
		}
		if(1)
		{
			MSG_CG_GM_STRING_CMD_SYN& rMsgSYN_T = rSENDMSG.InstanceOf<MSG_CG_GM_STRING_CMD_SYN>();
			strncpy(rMsgSYN_T.m_szStringCmd, "부활" ,sizeof(rMsgSYN_T.m_szStringCmd));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN_T, sizeof(rMsgSYN_T));
		}
		if(0)
		{
			MSG_CG_GM_STRING_CMD_SYN& rMsgSYN_T = rSENDMSG.InstanceOf<MSG_CG_GM_STRING_CMD_SYN>();
			strncpy(rMsgSYN_T.m_szStringCmd, "투명 켬" ,sizeof(rMsgSYN_T.m_szStringCmd));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN_T, sizeof(rMsgSYN_T));
		}
		if(1)
		{
			MSG_CG_GM_STRING_CMD_SYN& rMsgSYN_T2 = rSENDMSG.InstanceOf<MSG_CG_GM_STRING_CMD_SYN>();
			strncpy(rMsgSYN_T2.m_szStringCmd, "무적 켬" ,sizeof(rMsgSYN_T2.m_szStringCmd));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN_T2, sizeof(rMsgSYN_T2));
		}
		if(0)
		{
			MSG_CG_GM_STRING_CMD_SYN& rMsgSYN_T3 = rSENDMSG.InstanceOf<MSG_CG_GM_STRING_CMD_SYN>();
			strncpy(rMsgSYN_T3.m_szStringCmd, "몬스터소환 2211 1" ,sizeof(rMsgSYN_T3.m_szStringCmd));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN_T3, sizeof(rMsgSYN_T3));
		}

		if(0)
		{
			MSG_CG_GM_STRING_CMD_SYN& rMsgSYN_T4 = rSENDMSG.InstanceOf<MSG_CG_GM_STRING_CMD_SYN>();
			strncpy(rMsgSYN_T4.m_szStringCmd, "몬스터제거" ,sizeof(rMsgSYN_T4.m_szStringCmd));
			rMGR.SendPacket(AGENT_SESSION, &rMsgSYN_T4, sizeof(rMsgSYN_T4));
		}
	}
	//
	//////////////////////////////////////////////////////////////////////////

	//////////////////////////////////////////////////////////////////////////
	// 임시 위치 보정용
	//BOOL bPROC = FALSE;
	//if(bPROC)
	//{
	//	// 벨트헨, 특정 위치
	//	static float s_rVecSrc[3] =
	//	{
	//		-469.f,
	//		343.f,
	//		6.f
	//	};
	//	rZONE.MapPosCmdBlockMode() = TRUE;
	//	//CopyMemory(rPOS.XYZ_DEST, s_rVecSrc, sizeof(rPOS.XYZ_DEST));
	//	SEND_MESSAGE_BLOCK& rSENDMSG = pUser->SEND_MSG();
	//	MSG_CG_MAP_TELEPORT_SYN& rMsgSYN = rSENDMSG.InstanceOf<MSG_CG_MAP_TELEPORT_SYN>();
	//	CopyMemory(&rMsgSYN.vPos, &s_rVecSrc, sizeof(s_rVecSrc));
	//	rMGR.SendPacket(AGENT_SESSION, &rMsgSYN, sizeof(rMsgSYN));
	//}
	//
	//////////////////////////////////////////////////////////////////////////

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

	sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	rARG.SetInfo(LFG_MAX, S_000090_CLOSURE_EXCEPTION_LF);
	rLOGIC.OnMsg(&rSIGNAL);
	rARG.SetInfo(LFG_ZONE, S_002950_CLOSURE_EXCEPTION_LF);
	rLOGIC.OnMsg(&rSIGNAL);
}


HANDLER_CG_RECV_IMPL(CG_SYNC_KBMOVE_BRD)
{
	DEBUGGING_CODE_L3("");
}

HANDLER_CG_RECV_IMPL(CG_MAP_TELEPORT_BRD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_MAP_TELEPORT_BRD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_MAP_TELEPORT_BRD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();
	ZoneControl& rZONE = pUser->ZoneController();

	// 명령 타입... 이것도 처리해야 할 것이다.
	//rRecvMsg.m_bForcedCommand

	WiseCharacter* pCHAR = pUser->GetSelectedCharacter();
	if(pCHAR->OBJECT_KEY() == rRecvMsg.m_dwObjectKey)
	{
		rZONE.MapPosCmdBlockMode() = FALSE;

		sMAP_POS_ARG rPOS;
		//rPOS.SUBCMD = 0;
		//rPOS.ANGLE = 0;
		rZONE.MapPosCmd(ZoneControl::CMD_POS_GET_CUR_INFO, &rPOS);
		CopyMemory(rPOS.XYZ_CUR, &rRecvMsg.vPos, sizeof(rPOS.XYZ_CUR));
		CopyMemory(rPOS.XYZ_DEST, &rRecvMsg.vPos, sizeof(rPOS.XYZ_DEST));
		rZONE.MapPosCmd(ZoneControl::CMD_POS_SET_CUR_INFO, &rPOS);
	}
}

HANDLER_CG_RECV_IMPL(CG_SYNC_MONSTER_LEAVE_BRD)
{
	DEBUGGING_CODE_L3("");
}


//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
// MONSTER_RENDER_INFO

HANDLER_CG_RECV_IMPL(CG_SYNC_MONSTER_ENTER_BRD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_SYNC_MONSTER_ENTER_BRD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_SYNC_MONSTER_ENTER_BRD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_OBJCTRL& rOBJCTRL = sSIGNAL_BUFFER::InstanceOf<sSIG_OBJCTRL>();
	rOBJCTRL.OBJTYPE() = OBJTYPE_MONSTER;// GAME_OBJECT::GOBJ_MONSTER;
	rOBJCTRL.SUBTYPE() = sSIG_OBJCTRL::ST_ENTER;
	rOBJCTRL.OBJECT_KEY() = 0;
	rOBJCTRL.MSG_HDR() = (BYTE*)&rRecvMsg;
	rOBJCTRL.MSG_LEN() = pSIG_NETMSG->MSG_LEN();
	//rOBJCTRL.MsgTypeOf<MSG_CG_SYNC_MONSTER_ENTER_BRD*>() = &rRecvMsg;

	ObjectManager::OnMsg(&rOBJCTRL);
}

HANDLER_CG_RECV_IMPL(CG_SYNC_MONSTER_DIR_ENTER_BRD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_SYNC_MONSTER_DIR_ENTER_BRD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_SYNC_MONSTER_DIR_ENTER_BRD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_OBJCTRL& rOBJCTRL = sSIGNAL_BUFFER::InstanceOf<sSIG_OBJCTRL>();
	rOBJCTRL.OBJTYPE() = OBJTYPE_MONSTER;// GAME_OBJECT::GOBJ_MONSTER;
	rOBJCTRL.SUBTYPE() = sSIG_OBJCTRL::ST_ENTER;
	rOBJCTRL.OBJECT_KEY() = 0;
	rOBJCTRL.MSG_HDR() = (BYTE*)&rRecvMsg;
	rOBJCTRL.MSG_LEN() = pSIG_NETMSG->MSG_LEN();
	//rOBJCTRL.MsgTypeOf<MSG_CG_SYNC_MONSTER_ENTER_BRD*>() = &rRecvMsg;

	ObjectManager::OnMsg(&rOBJCTRL);
}

HANDLER_CG_RECV_IMPL(CG_SYNC_ALLMONSTERS_CMD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_SYNC_ALLMONSTERS_CMD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_SYNC_ALLMONSTERS_CMD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_OBJCTRL& rOBJCTRL = sSIGNAL_BUFFER::InstanceOf<sSIG_OBJCTRL>();
	rOBJCTRL.OBJTYPE() = OBJTYPE_MONSTER;// GAME_OBJECT::GOBJ_MONSTER;
	rOBJCTRL.SUBTYPE() = sSIG_OBJCTRL::ST_ENTER;
	rOBJCTRL.OBJECT_KEY() = 0;
	rOBJCTRL.MSG_HDR() = (BYTE*)&rRecvMsg;
	rOBJCTRL.MSG_LEN() = pSIG_NETMSG->MSG_LEN();
	//rOBJCTRL.MsgTypeOf<MSG_CG_SYNC_MONSTER_ENTER_BRD*>() = &rRecvMsg;

	ObjectManager::OnMsg(&rOBJCTRL);
}

HANDLER_CG_RECV_IMPL(CG_SYNC_MAPNPC_ENTER_BRD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_SYNC_MAPNPC_ENTER_BRD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_SYNC_MAPNPC_ENTER_BRD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_OBJCTRL& rOBJCTRL = sSIGNAL_BUFFER::InstanceOf<sSIG_OBJCTRL>();
	rOBJCTRL.OBJTYPE() = OBJTYPE_MONSTER;// GAME_OBJECT::GOBJ_MONSTER;
	rOBJCTRL.SUBTYPE() = sSIG_OBJCTRL::ST_ENTER;
	rOBJCTRL.OBJECT_KEY() = 0;
	rOBJCTRL.MSG_HDR() = (BYTE*)&rRecvMsg;
	rOBJCTRL.MSG_LEN() = pSIG_NETMSG->MSG_LEN();
	//rOBJCTRL.MsgTypeOf<MSG_CG_SYNC_MONSTER_ENTER_BRD*>() = &rRecvMsg;

	ObjectManager::OnMsg(&rOBJCTRL);
}

/*
HANDLER_CG_RECV_IMPL(CG_MISSION_TUTORIAL_WINDOW_CMD)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_MISSION_TUTORIAL_WINDOW_CMD& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_MISSION_TUTORIAL_WINDOW_CMD>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	ScriptLogic* pSCRIPT = Manipulater::GetScriptLogicInterface()->SCRIPTLOGIC;
#if CODE_BACKUP

	CHAR* prValue;
	if(!pSCRIPT->GetData("[TUTORIAL]", "ACCEPT", prValue))
		return;

	DWORD bAccept = Converter::String::ToDWORD(prValue);

	if(!bAccept)
		return;
#endif

#if	CODE_RENEWAL
	BOOL bAccept = pSCRIPT->IsAcceptPlay("[TUTORIAL]");
	if(!bAccept)
		return;
#endif 

	//// 튜토리얼 필드로의 이동 처리 시작
	ZoneControl& rZONE = pUser->ZoneController();
	sZONE_CTRL_INFO& rCTRL = rZONE.ZONE_CTRL_INFO();
	rCTRL.Enabled(sZONE_CTRL_INFO::BIT_TUTORIAL_PROCESS);


	//sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	//rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_JUMP_STEP;

	//sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	//rARG.SetInfo(LFG_ZONE, S_001700_START_MARK_TUTORIAL_FIELD_LF);
	//rLOGIC.OnMsg(&rSIGNAL);

}

HANDLER_CG_RECV_IMPL(CG_MISSION_TUTORIAL_WINDOW_RET_ACCEPT_ACK)
{
	DEBUGGING_CODE_L3("");

	MSG_CG_MISSION_TUTORIAL_WINDOW_RET_ACCEPT_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_MISSION_TUTORIAL_WINDOW_RET_ACCEPT_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

	sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	rARG.SetInfo(LFG_ZONE, S_001760_EOL_FLOW_CONTROL_LF);
	rLOGIC.OnMsg(&rSIGNAL);
}
*/

HANDLER_CG_RECV_IMPL(CG_ZONE_PORTAL_FIELD_MOVE_ACK)
{
	MSG_CG_ZONE_PORTAL_FIELD_MOVE_ACK& rRecvMsg = pSIG_NETMSG->MsgTypeOf<MSG_CG_ZONE_PORTAL_FIELD_MOVE_ACK>();
	LogicFlowDelegator&	rLOGIC = pUser->GetLogicFlow();
	UserSessionMgr& rMGR = pUser->GetSessionMgr();

	sSIG_STEP& rSIGNAL = sSIGNAL_BUFFER::InstanceOf<sSIG_STEP>();
	rSIGNAL.SUBTYPE() = sSIG_STEP::ACTIVATE_NEXT_STEP;

	sSIG_STEP_ARG& rARG = rSIGNAL.InstanceOf<sSIG_STEP_ARG>();
	rARG.SetInfo(LFG_ZONE, S_001760_EOL_FLOW_CONTROL_LF);
	rLOGIC.OnMsg(&rSIGNAL);
}