///////////////////////////////////////////////////////////////////////////////////////////////
//
// ClientSocket Class
//
///////////////////////////////////////////////////////////////////////////////////////////////
#include "ClientSocket.h"
#include <mmsystem.h>

#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/PacketStruct/ServerPacket.h>
#include <Network/Packet/PacketStruct/PartyPacket.h>
#include <Network/Packet/PacketStruct/CharMovePacket.h>
#include <Network/Packet/PacketStruct/CharLoginOutPacket.h>
#include <Network/Packet/PacketStruct/CharAdminPacket.h>
#include <Network/Packet/PacketStruct/ClientToAuthServer.h>
#include <Network/Packet/PacketStruct/ClientToLoginServer.h>

#define SAFE_DELETE(p)			{ if (p) { delete (p);     (p) = NULL; } }

ClientSocket::ClientSocket(HWND hWnd_In) :
m_hMainWnd(hWnd_In), m_UpdateCount(0), m_ConnectServer(0)
{
	m_ClientList = new UDPList();
	m_ClientList->SetGarbageStackLength(100);

	m_PartyList = new UDPList();
	m_PartyList->SetGarbageStackLength(10);

	m_InstanceClientList = new UDPList();
	m_InstanceClientList->SetGarbageStackLength(40);

	memset(&m_PubUDPAddress, 0, sizeof(SOCKADDR_IN));
	memset(&m_PriUDPAddress, 0, sizeof(SOCKADDR_IN));
	memset(&m_GSSUDPAddress, 0, sizeof(SOCKADDR_IN));

	m_RegAddress.S_un.S_addr	= 0;
}

ClientSocket::~ClientSocket(void)
{
	Disconnect();
	
	SAFE_DELETE(m_InstanceClientList);
	SAFE_DELETE(m_ClientList);
	SAFE_DELETE(m_PartyList);
}

DWORD ClientSocket::InsertIntoAddressList(unsigned short List_In, DWORD CharID_In, SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In)
{
	if(List_In == ListType_Client)
		return m_ClientList->InsertIntoAddressList(CharID_In, PubAddress_In, PriAddress_In, GetPeerType(PubAddress_In, PriAddress_In));
	else if(List_In == ListType_Party)
		return m_PartyList->InsertIntoAddressList(CharID_In, PubAddress_In, PriAddress_In, GetPeerType(PubAddress_In, PriAddress_In));

	return 0;
}

bool ClientSocket::DeleteFromAddressList(unsigned short List_In, DWORD CharID_In)
{
	if(List_In == ListType_Client)
		return m_ClientList->DeleteFromAddressList(CharID_In);
	else if(List_In == ListType_Party)
		return m_PartyList->DeleteFromAddressList(CharID_In);

	return false;
}

bool ClientSocket::DeleteFromAddressList(unsigned short List_In, SOCKADDR_IN Address_In)
{
	if(List_In == ListType_Client)
		return m_ClientList->DeleteFromAddressList(Address_In);
	else if(List_In == ListType_Party)
		return m_PartyList->DeleteFromAddressList(Address_In);

	return false;
}

bool ClientSocket::IsExistToList(unsigned short List_In, DWORD CharID_In)
{
	if(List_In == ListType_Client)
	{
		if(NULL != m_ClientList->SearchFromAddressList(CharID_In))
			return true;
	}
	else if(List_In == ListType_Party)
	{
		if(NULL != m_PartyList->SearchFromAddressList(CharID_In))
			return true;
	}

	return false;
}

DWORD ClientSocket::GetListCount(unsigned short List_In)
{
	if(List_In == ListType_Client)
	{
		return m_ClientList->GetListCount();
	}
	else if(List_In == ListType_Party)
	{
		return m_PartyList->GetListCount();
	}

	return 0;
}

bool ClientSocket::RegistInstanceUDPList(DWORD CharID_In)
{
	LPUDP_LIST lpUDPList = m_ClientList->SearchFromAddressList(CharID_In);
	if(!lpUDPList) lpUDPList = m_PartyList->SearchFromAddressList(CharID_In);

	if(lpUDPList)
	{
		UDP_LIST *pAddNode=new UDP_LIST;
		memset(pAddNode,0,sizeof(UDP_LIST));

		pAddNode->CharID=lpUDPList->CharID;		
		pAddNode->PeerType=lpUDPList->PeerType;
		pAddNode->PublicAddress=lpUDPList->PublicAddress;
		pAddNode->PrivateAddress=lpUDPList->PrivateAddress;

		m_InstanceClientList->InsertToList(pAddNode);	

		return true;
	} else
		return false;
}

void ClientSocket::DeleteInstanceUDPList()
{
	m_InstanceClientList->DeleteAllFromList();	
}

bool ClientSocket::IsRealIP(void)
{
	if(m_PubUDPAddress.sin_addr.S_un.S_addr == m_PriUDPAddress.sin_addr.S_un.S_addr)
		return true;

	return false;
}

PEERTYPE ClientSocket::GetPeerType(SOCKADDR_IN PubAddress_In, SOCKADDR_IN PriAddress_In)
{
	if(PubAddress_In.sin_addr.S_un.S_addr == PriAddress_In.sin_addr.S_un.S_addr)
		return REAL_IP;
	else
	{
		if(!IsRealIP() && PubAddress_In.sin_addr.S_un.S_addr == m_PubUDPAddress.sin_addr.S_un.S_addr)
			return NAT_Friendly;
		else
			return NAT_Different;
	}

	return Not_Defined;
}

bool ClientSocket::UDPSendList(WSABUF &SendBuf_In, UDPList* lpList_In)
{
	int send_byte = 0;

	LPUDP_LIST lpDelete = NULL;
	LPUDP_LIST lpList = lpList_In->m_pListHead;
	if(lpList == NULL)
		return false;

	while(lpList)
	{
		if(!IsRealIP() && lpList->PeerType == NAT_Friendly)						
		{
			// »ó´ë°¡ °¡»ó, °°Àº NAT
			if(!SendTo(m_UDPSocket, lpList->PrivateAddress, SendBuf_In))
			{
				lpDelete = lpList;
				lpList = lpList->pNext;

				lpList_In->DeleteFromList(lpDelete);
				continue;
			}
		}
		else
		{
			// º»ÀÎÀÌ ¸®¾ó¶Ç´Â °°Àº NATÀÏ °æ¿ì
			if(!SendTo(m_UDPSocket, lpList->PublicAddress, SendBuf_In))
			{
				lpDelete = lpList;
				lpList = lpList->pNext;

				lpList_In->DeleteFromList(lpDelete);
				continue;
			}		
		}

		lpList = lpList->pNext;
	}

	return true;
}

bool ClientSocket::UDPSendList(WSABUF &SendBuf_In, UDPList* lpList_In, DWORD CharID_In)
{
	int send_byte = 0;

	LPUDP_LIST lpList = lpList_In->SearchFromAddressList(CharID_In);
	if(lpList == NULL)
		return false;

	if(lpList->PeerType == NAT_Friendly)						
	{
		// »ó´ë°¡ °°Àº NAT
		if(!SendTo(m_UDPSocket, lpList->PrivateAddress, SendBuf_In))
		{
			lpList_In->DeleteFromList(lpList);
			return false;
		}
	}
	else
	{
		// º»ÀÎÀÌ ¸®¾óÀ̰ųª »ó´ë°¡ ¸®¾ó/´Ù¸¥ NATÀÏ °æ¿ì
		if(!SendTo(m_UDPSocket, lpList->PublicAddress, SendBuf_In))
		{
			lpList_In->DeleteFromList(lpList);
			return false;
		}		
	}

	return true;
}

bool ClientSocket::UDPRecv(void)
{
	SOCKADDR_IN Address = {0,};

	if(NetBase::UDPRecv(&Address) == false)
	{
/*		if(GetLastError() == 10054)
			if(DeleteFromAddressList(ClientSocket::ListType_Client, Address))
				return true;		
*/	
		return false;
	}

	return true;
}

bool ClientSocket::ConnectToAuthServer(char *Address_In)
{
	Disconnect();

	if(!Socket::CreateTCPSocket(&m_TCPSocket, m_hMainWnd, WM_CLIENT_SOCKET))
		return false;

	m_ConnectServer = CO_SRV::CO_AUTH;
	return Socket::Connect(m_TCPSocket, Socket::MakeSockAddr(Address_In, DemonAuthTCPPort), &m_pRecvDataBuffer);
}

bool ClientSocket::ConnectToGameServer(char *Address_In)
{
	Disconnect();

	if(!Socket::CreateTCPSocket(&m_TCPSocket, m_hMainWnd, WM_CLIENT_SOCKET))
		return false;

	bool NullBind = false;
	IN_ADDR Addr = {0,};
	if(Socket::GetHostIP(Addr, false))
//	if(Socket::GetHostIP(Addr, true))
	{
		if(Socket::IsWrongIP(Addr))
		{
			// »çÀÌ°ÔÀÌÆ® »ç¿ëÀÚ Àϼöµµ ÀÖÀ½
			NullBind = true;
		}
	}
	else
	{
		NullBind = true;
	}

	if(true == NullBind)
	{
		m_PriUDPAddress = Socket::MakeSockAddr(NULL, DemonClientUDPPort);
		if(!Socket::CreateUDPSocket(&m_UDPSocket, m_PriUDPAddress, m_hMainWnd, WM_UDP_SOCKET))
			return false;

		Socket::GetNATAddress(m_UDPSocket, &m_PriUDPAddress, true);
	}
	else
	{
		m_PriUDPAddress = Socket::MakeSockAddr(Addr, DemonClientUDPPort);
		if(!Socket::CreateUDPSocket(&m_UDPSocket, m_PriUDPAddress, m_hMainWnd, WM_UDP_SOCKET))
			return false;
	}

	m_ConnectServer = CO_SRV::CO_GAME;
	return Socket::Connect(m_TCPSocket, Socket::MakeSockAddr(Address_In, DemonGameTCPPort), &m_pRecvDataBuffer);
}

bool ClientSocket::Disconnect(void)
{	
	if(m_TCPSocket)
		Socket::DeleteSocket(&m_TCPSocket, m_hMainWnd);

	if(m_UDPSocket)
		Socket::DeleteSocket(&m_UDPSocket, m_hMainWnd);

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ÇÎ ÆÐŶ [ public ]
//
// Parameter :
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::SendSysPing(void)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktSyP), CmdSysPing, 0);
	LPPktSyP lpSyPAckPt = reinterpret_cast<LPPktSyP>(lpBuffer->GetBuf());

	lpSyPAckPt->m_dwTickTime = GetTickCount();

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼­¹ö Á¸ À̵¿ [ public ]
//
// Parameter :
//	1st : Á¸[In]
//	2st : À§Ä¡[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharMoveZone(char Zone_In, POS& NewPos_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktSZMv), CmdCharMoveZone, 0, 0);
	LPPktSZMv lpSZMvPt = reinterpret_cast<LPPktSZMv>(lpBuffer->GetBuf());
	
	lpSZMvPt->m_cZone	= Zone_In;	
	lpSZMvPt->m_NewPos	= NewPos_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

DWORD ClientSocket::HandleCharMoveZone(char *pBuffer_In, unsigned char *Zone_Out, unsigned short *lpChannelNum_Out)
{
	LPPktSZMvAck lpSZMvAckPt = (LPPktSZMvAck)pBuffer_In;

	if(lpSZMvAckPt == NULL || lpChannelNum_Out == NULL)
		return WrongParameter;

	if(lpSZMvAckPt->Error() != NoError)
		return lpSZMvAckPt->Error();

	*Zone_Out = lpSZMvAckPt->m_cZone;
    memcpy(lpChannelNum_Out, lpSZMvAckPt->m_wChannelNum, sizeof(unsigned short) * PktSZMvAck::MAX_CHANNEL_NUM);

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼­¹ö Á¸ [ public ]
//
// Parameter :
//	1st : Á¸[In]
//	2st : ä³Î[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::ServerZone(char Zone_In, char Channel_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktSZ), CmdServerZone, 0, 0);
	LPPktSZ lpSZPt = reinterpret_cast<LPPktSZ>(lpBuffer->GetBuf());
	
	lpSZPt->m_cZone		= Zone_In;	
	lpSZPt->m_cChannel	= Channel_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

DWORD ClientSocket::HandleServerZone(char *pBuffer_In, DWORD *ServerID_Out)
{
	LPPktSZAck lpSZAckPt = (LPPktSZAck)pBuffer_In;

	if(lpSZAckPt == NULL || ServerID_Out == NULL)
		return WrongParameter;

	if(lpSZAckPt->Error() != NoError)
		return lpSZAckPt->Error();

	*ServerID_Out	= lpSZAckPt->m_dwServerID;
	m_RegAddress	= lpSZAckPt->m_GameAddress;

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// À¯Àú ·Î±×ÀÎ [ public ]
//
// Parameter :
//	1st : À¯Àú ¾ÆÀ̵ð[In]
//	2st : ¼­¹ö ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::UserLogin(DWORD SessionID_In, DWORD UserID_In, DWORD ServerID_In, DWORD CheckSum_In)
{
	CrearRegAddress();	// ÁÖ¼Ò ÃʱâÈ­

	if(m_TCPSocket == NULL || UserID_In == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktULi), CmdUserLogin, 0);
	LPPktULi lpULiPt = reinterpret_cast<LPPktULi>(lpBuffer->GetBuf());

	lpULiPt->m_dwSessionID	= SessionID_In;
	lpULiPt->m_dwUserID		= UserID_In;
	lpULiPt->m_dwServerID	= ServerID_In;
	lpULiPt->m_dwCheckSum	= CheckSum_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// À¯Àý ·Î±×ÀÎ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]
//	2st : À¯Àú °íÀ¯ ¾ÆÀ̵ð Æ÷ÀÎÅÍ[Out]
//	3st : ·Î±×ÀΠij¸¯ÅÍ Á¤º¸ ±¸Á¶Ã¼[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleUserLogin(char *pBuffer_In, DWORD *UserID_Out, LPCHAR_VIEW CharRecode_Out)
{
	LPPktULiAck lpULiAckPt = (LPPktULiAck)pBuffer_In;

	if(lpULiAckPt == NULL || UserID_Out == NULL || CharRecode_Out == NULL)
		return WrongParameter;

	if(lpULiAckPt->Error() != NoError)
		return lpULiAckPt->Error();

	*UserID_Out		= lpULiAckPt->m_dwUserID;

	CopyMemory(CharRecode_Out, lpULiAckPt->m_CharView, sizeof(CHAR_VIEW) * 3); 

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ »ý¼º [ public ]
//
// Parameter :
//	1st : À¯Àú °íÀ¯ ¾ÆÀ̵ð[In]						ex) 1 or 3 ....
//	2st : ¼±ÅÃµÈ ½½·Ô ¼ýÀÚ[In]						ex) 1 or 2 or 3
//	3st : »ý¼º ±¸Á¶Ã¼[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharCreate(DWORD UserID_In, DWORD SlotNum_In, CHAR_CREATE &Create_In)
{
	if(m_TCPSocket == NULL || UserID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCC), CmdCharCreate, 0, 0);
	LPPktCC lpCCPt = reinterpret_cast<LPPktCC>(lpBuffer->GetBuf());
	
	lpCCPt->m_dwUserID		= UserID_In;
	lpCCPt->m_dwSlotNum	= SlotNum_In;
	lpCCPt->m_CreateChar	= Create_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ »ý¼º [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð Æ÷ÀÎÅÍ[Out]
//	3st : ½½·Ô Æ÷ÀÎÅÍ[Out]
//	4st : ij¸¯ÅÍ ºä Æ÷ÀÎÅÍ[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharCreate(char *pBuffer_In, DWORD *CharID_Out, DWORD *SlotNum_Out, LPCHAR_VIEW lpCharView_Out)
{
	LPPktCCAck lpCCAckPt = (LPPktCCAck)pBuffer_In;

	if(lpCCAckPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	if(lpCCAckPt->Error() != NoError)
		return lpCCAckPt->Error();

	*CharID_Out			= lpCCAckPt->m_dwCharID;
	*SlotNum_Out		= lpCCAckPt->m_dwSlotNum;
	CopyMemory(lpCharView_Out, &(lpCCAckPt->m_CharView), sizeof(CHAR_VIEW)); 

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¼±Åà [ public ]
//
// Parameter :
//	1st : À¯Àú °íÀ¯ ¾ÆÀ̵ð[In]				
//	2st : ¼±ÅÃµÈ Ä³¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]	
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSelect(DWORD UserID_In, DWORD CharID_In)
{

	if(m_TCPSocket == NULL || UserID_In == 0 || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCS), CmdCharSelect, 0, 0);
	LPPktCS lpCSPt = reinterpret_cast<LPPktCS>(lpBuffer->GetBuf());
	
	lpCSPt->m_dwUserID		= UserID_In;
	lpCSPt->m_dwCharID		= CharID_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
//	ij¸¯ÅÍ ¼±Åà [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]
//	2st : ä³Î ¼ýÀÚ[In]	
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSelect(char *pBuffer_In, unsigned char *Zone_Out, unsigned short *lpChannelNum_Out)
{
	LPPktCSAck lpCSAckPt = (LPPktCSAck)pBuffer_In;

	if(lpCSAckPt == NULL || lpChannelNum_Out == NULL)
		return WrongParameter;

	if(lpCSAckPt->Error() != NoError)
		return lpCSAckPt->Error();

	*Zone_Out = lpCSAckPt->m_cZone;
	memcpy(lpChannelNum_Out, lpCSAckPt->m_wChannelNum, sizeof(unsigned short) * PktCSAck::MAX_CHANNEL_NUM);

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ »èÁ¦ [ public ]
//
// Parameter :
//	1st : À¯Àú °íÀ¯ ¾ÆÀ̵ð[In]		
//	2st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]
//	3st : ½½·Ô ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharDelete(DWORD UserID_In, DWORD CharID_In, DWORD SlotNum_In)
{
	if(m_TCPSocket == NULL || UserID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCD), CmdCharDelete, 0, 0);
	LPPktCD lpCDPt = reinterpret_cast<LPPktCD>(lpBuffer->GetBuf());
	
	lpCDPt->m_dwUserID		= UserID_In;
	lpCDPt->m_dwCharID		= CharID_In;
	lpCDPt->m_dwSlotNum		= SlotNum_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ »èÁ¦ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]
//	2st : À¯Àú °íÀ¯ ¾ÆÀ̵ð Æ÷ÀÎÅÍ[Out]
//	3st : ½½·Ô ¼ýÀÚ[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharDelete(char *pBuffer_In, DWORD *UserID_Out, DWORD *SlotNum_Out)
{
	LPPktCDAck lpCDAckPt = (LPPktCDAck)pBuffer_In;

	if(lpCDAckPt == NULL || UserID_Out == NULL || SlotNum_Out == NULL)
		return WrongParameter;

	if(lpCDAckPt->Error() != NoError)
		return lpCDAckPt->Error();

	*UserID_Out			= lpCDAckPt->m_dwUserID;
	*SlotNum_Out		= lpCDAckPt->m_dwSlotNum;

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·Î±×ÀÎ [ public ]
//
// Parameter :
//	1st : À¯Àú °íÀ¯ ¾ÆÀ̵ð[In]					
//	2st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]
//	3st : ¼¼¼Ç ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharLogin(DWORD UserID_In, DWORD CharID_In, DWORD SessionID_In)
{
	CrearRegAddress();		// ÁÖ¼Ò ÃʱâÈ­

	if(m_TCPSocket == NULL || UserID_In == 0 || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCLi), CmdCharLogin, 0, 0);
	LPPktCLi lpCLiPt = reinterpret_cast<LPPktCLi>(lpBuffer->GetBuf());
	
	lpCLiPt->m_dwSessionID	= SessionID_In;
	lpCLiPt->m_dwUserID		= UserID_In;
	lpCLiPt->m_dwCharID		= CharID_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·Î±×ÀÎ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	3st : ij¸¯ÅÍ À§Ä¡[Out]
//	4st : ¼­¹ö ½Ã°£[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharLogin(char *pBuffer_In, char *Admin_Out, LPCHAR_INFOST lpCharInfo_Out, 
									LPSKILL lpSkill_Out, LPQUICK lpQuick_Out, LPCHAR_POS lpPos_Out, DWORD *ServerTime_Out, 
									unsigned short *EquipSize_Out, char **lppEquipBuff_Out, 
									unsigned short *InvenSize_Out, char **lppInvenBuff_Out, 
									unsigned short *ExtraSize_Out, char **lppExtraBuff_Out, 
									unsigned short *ExchangeSize_Out, char **lppExchangeBuff_Out)
{
	LPPktCLiAck lpCLiAckPt = (LPPktCLiAck)pBuffer_In;
	
	if (lpCLiAckPt == NULL) {
		return WrongParameter;
	}

	m_GSSUDPAddress		= lpCLiAckPt->m_GSSUDPAddr;
	*ServerTime_Out		= lpCLiAckPt->m_dwServerTime;
	*Admin_Out			= lpCLiAckPt->m_cAdmin;

	unsigned short *usUpdateLen	= lpCLiAckPt->m_usUpdate;

	*lppEquipBuff_Out = NULL;
	*lppInvenBuff_Out = NULL;
	*lppExtraBuff_Out = NULL;
	*lppExchangeBuff_Out = NULL;
	*EquipSize_Out = 0;
	*InvenSize_Out = 0;
	*ExtraSize_Out = 0;
	*ExchangeSize_Out = 0;

	char* OffSet		= pBuffer_In + sizeof(PktCLiAck);
	for (int nCount = 0; nCount < DBUpdateData::MAX_UPDATE_DB; ++nCount) 
	{			
		if (0 == usUpdateLen[nCount]) { 
			continue; 
		}

		switch (nCount) 
		{
			case DBUpdateData::STATUS_UPDATE:		    *lpCharInfo_Out			= *(LPCHAR_INFOST)OffSet;	break;
			case DBUpdateData::POSITION_UPDATE:		    *lpPos_Out				= *(LPCHAR_POS)OffSet;		break;
			case DBUpdateData::SKILL_UPDATE:			*lpSkill_Out			= *(LPSKILL)OffSet;			break;
			case DBUpdateData::QUICKSLOT_UPDATE:		*lpQuick_Out			= *(LPQUICK)OffSet;			break;;
			case DBUpdateData::ITEM_EQUIP_UPDATE:	    *lppEquipBuff_Out		= OffSet;		*EquipSize_Out = usUpdateLen[nCount];		break;
			case DBUpdateData::ITEM_INVEN_UPDATE:	    *lppInvenBuff_Out		= OffSet;		*InvenSize_Out = usUpdateLen[nCount];		break;
			case DBUpdateData::ITEM_EXTRA_UPDATE:	    *lppExtraBuff_Out		= OffSet;		*ExtraSize_Out = usUpdateLen[nCount];		break;
			case DBUpdateData::ITEM_EXCHANGE_UPDATE:	*lppExchangeBuff_Out	= OffSet;		*ExchangeSize_Out = usUpdateLen[nCount];	break;
		};

		OffSet += usUpdateLen[nCount];
	}

	if(lpCLiAckPt->Error() != NoError) {
		return lpCLiAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·Î±×¾Æ¿ô [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharLogout(DWORD CharID_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCLo), CmdCharLogout, 0, 0);
	LPPktCLo lpCLoPt = reinterpret_cast<LPPktCLo>(lpBuffer->GetBuf());
	
	lpCLoPt->m_dwCharID		= CharID_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·Î±×¾Æ¿ô [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharLogout(char *pBuffer_In, DWORD *CharID_Out)
{
	LPPktCLoAck lpCLoAckPt = (LPPktCLoAck)pBuffer_In;
	
	if(lpCLoAckPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	*CharID_Out			= lpCLoAckPt->m_dwCharID;

	if(lpCLoAckPt->Error() != NoError)
		return lpCLoAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·Î±×¾Æ¿ô [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : Ç÷¡±×[Out]
//	3st : ÇØ´ç ÅÇ[Out]
//	4st : ¿Ï¼º[Out]
//	5st : â°í »çÀÌÁî[Out]
//	6st : â°í µ¥ÀÌÅÍ[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleDepositUpdate(char *pBuffer_In, DWORD *Flag_Out, unsigned char *TabNum_Out, bool *Complete_Out, unsigned short *StoreSize_Out, char **lppStoreBuff_Out)  
{
	PktDepositUpdateDB* lpDepositUpdateDB = (PktDepositUpdateDB*)pBuffer_In;

	if (lpDepositUpdateDB == NULL) {
		return WrongParameter;
	}

	*Flag_Out		= lpDepositUpdateDB->m_dwTabFlag;
	*TabNum_Out		= lpDepositUpdateDB->m_cTabNum;
	*Complete_Out	= lpDepositUpdateDB->m_bUpdateComplete;

	*StoreSize_Out		= lpDepositUpdateDB->m_usDataSize;
	*lppStoreBuff_Out	= pBuffer_In + sizeof(PktDepositUpdateDB);

	if(lpDepositUpdateDB->Error() != NoError) {
		return lpDepositUpdateDB->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// UDP ÁÖ¼Ò ¾÷µ¥ÀÌÆ® [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharUpdateAddress(DWORD CharID_In)
{
	if(m_UDPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktUA), CmdCharUpdateAddress, 0, 0);
	LPPktUA lpUAPt = reinterpret_cast<LPPktUA>(lpBuffer->GetBuf());
	
	lpUAPt->m_dwCharID			= CharID_In;
	lpUAPt->m_PrivateAddress	= m_PriUDPAddress;

	lpBuffer->WrapPacket(true);
	if(!SendTo(m_UDPSocket, m_GSSUDPAddress, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// UDP ÁÖ¼Ò ¾÷µ¥ÀÌÆ® [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharUpdateAddress(char *pBuffer_In)
{
	LPPktUAAck lpUAAckPt = (LPPktUAAck)pBuffer_In;
	
	if(lpUAAckPt == NULL)
		return WrongParameter;

	m_PriUDPAddress		= lpUAAckPt->m_PrivateAddress;
	m_PubUDPAddress		= lpUAAckPt->m_PublicAddress;

	if(lpUAAckPt->Error() != NoError)
		return lpUAAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// Á¤º¸ ¿äû [ public ]
//
// Parameter :
//	: ¿ä±¸ÀÚ ¾ÆÀ̵ð[In]
//	: ÇØ´ç ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	: Ä¿¸Çµå
//		0 : HP, MP Á¤º¸,	1 : UDP ÁÖ¼Ò,	2 : ¸ð¾ç
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharRequireInfo(DWORD SenderID_In, DWORD TargetID_In, unsigned char Cmd_In)
{
	if(m_TCPSocket == NULL || SenderID_In == 0 || TargetID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktRI), CmdCharRequireInfo, 0, 0);
	LPPktRI lpRIPt = reinterpret_cast<LPPktRI>(lpBuffer->GetBuf());
	
	lpRIPt->m_dwCharID			= SenderID_In;
	lpRIPt->m_cCmd				= Cmd_In;
	lpRIPt->m_PublicAddress		= m_PubUDPAddress;
	lpRIPt->m_PrivateAddress	= m_PriUDPAddress;

	lpBuffer->WrapPacket(true);
	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList, TargetID_In);
	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÁÖ¼Ò Á¤º¸ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	3st : UDP ÁÖ¼Ò Public[Out]	
//	4st : UDP ÁÖ¼Ò Private[Out]	
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharRequireInfo(char *pBuffer_In, DWORD *CharID_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out, unsigned char *Cmd_Out)
{
	LPPktRI lpRIPt = (LPPktRI)pBuffer_In;

	if(lpRIPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	*CharID_Out			= lpRIPt->m_dwCharID;
	*Cmd_Out			= lpRIPt->m_cCmd;
	*PubAddress_Out		= lpRIPt->m_PublicAddress;
	*PriAddress_Out		= lpRIPt->m_PrivateAddress;

	if(lpRIPt->Error() != NoError)
		return lpRIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÁÖ¼Ò Á¤º¸ [ public ]
//
//	: ƯÁ¤ Ŭ¶óÀ̾ðÆ®¿¡°Ô ¸®½ºÆ® º¸³»±â
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharAddressInfo(DWORD CharID_In, DWORD TargetID_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktAI), CmdCharAddressInfo, 0, 0);
	LPPktAI lpAIPt = reinterpret_cast<LPPktAI>(lpBuffer->GetBuf());
	
	lpAIPt->m_AddressInfo.m_dwCharID		= CharID_In;
	lpAIPt->m_AddressInfo.m_PublicAddress	= m_PubUDPAddress;
	lpAIPt->m_AddressInfo.m_PrivateAddress	= m_PriUDPAddress;

	lpBuffer->WrapPacket(true);
	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList, TargetID_In);
	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÁÖ¼Ò Á¤º¸ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	3st : UDP ÁÖ¼Ò Public[Out]	
//	4st : UDP ÁÖ¼Ò Private[Out]	
//
// Return :
//	¿¡·¯ ÄÚµå
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharAddressInfo(char *pBuffer_In, DWORD *CharID_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out)
{
	LPPktAI lpAIPt = (LPPktAI)pBuffer_In;

	if(lpAIPt == NULL || CharID_Out == NULL ||  PubAddress_Out == NULL || PriAddress_Out == NULL)
		return WrongParameter;

	*CharID_Out			= lpAIPt->m_AddressInfo.m_dwCharID;

	*PubAddress_Out		= lpAIPt->m_AddressInfo.m_PublicAddress;
	*PriAddress_Out		= lpAIPt->m_AddressInfo.m_PrivateAddress;

	if(lpAIPt->Error() != NoError)
		return lpAIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ À̵¿ [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]
//	2st : ÇöÀç À§Ä¡[In]
//	3st : ¹æÇâ[In]
//	4st : »óÀ§ ¾×¼Ç ³Ñ¹ö[In]
//	5st : ÇÏÀ§ ¾×¼Ç ³Ñ¹ö[In]
//	6st : ·¹º§[In]
//	7st : æƮ ÀÌÆåÆ® Ç¥½Ã[In]
//	8st : ¾ØæƮ ÀÌÆåÆ® Ç¥½Ã[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharMove(DWORD CharID_In, LPPOS Pos_In, float Dir_In, unsigned short UAct_In, unsigned short LAct_In, char Level_In, DWORD ChantEf_In, DWORD EnchantEf_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktMV), CmdCharMove, 0, 0);
	LPPktMV lpMVPt = reinterpret_cast<LPPktMV>(lpBuffer->GetBuf());
	
	lpMVPt->m_dwCharID		= CharID_In;
	lpMVPt->m_Position		= *Pos_In;
	lpMVPt->m_fDir			= Dir_In;
	lpMVPt->m_wUAct			= UAct_In;
	lpMVPt->m_wLAct			= LAct_In;

	lpMVPt->m_wLevel		= Level_In;
	lpMVPt->m_dwChantEf		= ChantEf_In;
	lpMVPt->m_dwEnchantEf	= EnchantEf_In;

	lpBuffer->WrapPacket(true);
//	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList);
	UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList);
	lpBuffer->Release();
	
	DeleteInstanceUDPList();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ À̵¿ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	1st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[Out]
//	2st : ÇöÀç À§Ä¡[Out]
//	3st : ÃÖÁ¾ À§Ä¡[Out]
//	4st : ¾×¼Ç ³Ñ¹ö[Out]
//	5st : ·¹º§[Out]
//	6st : æƮ ÀÌÆåÆ® Ç¥½Ã[Out]
//	7st : ¾ØæƮ ÀÌÆåÆ® Ç¥½Ã[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharMove(char *pBuffer_In, DWORD *CharID_Out, LPPOS Pos_Out, float *Dir_Out, unsigned short *UAct_Out, unsigned short *LAct_Out, char *Level_Out, DWORD *ChantEf_Out, DWORD *EnchantEf_Out, DWORD *PtCount_Out)
{
	LPPktMV lpMVPt = (LPPktMV)pBuffer_In;

	if(lpMVPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	*CharID_Out		= lpMVPt->m_dwCharID;
	*Pos_Out		= lpMVPt->m_Position;
	*Dir_Out		= lpMVPt->m_fDir;
	*UAct_Out		= lpMVPt->m_wUAct;
	*LAct_Out		= lpMVPt->m_wLAct;

	*Level_Out		= lpMVPt->m_wLevel;
	*ChantEf_Out	= lpMVPt->m_dwChantEf;
	*EnchantEf_Out	= lpMVPt->m_dwEnchantEf;

	*PtCount_Out	= lpMVPt->GetStartBit();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ À̵¿ [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ °íÀ¯ ¾ÆÀ̵ð[In]
//	2st : ÇöÀç À§Ä¡[In]
//	3st : ¹æÇâ[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharMoveUpdate(DWORD CharID_In, bool SitMode_In, LPPOS Pos_In, float Dir_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket( sizeof(PktMU), CmdCharMoveUpdate, 0, 0);
	LPPktMU lpMUPt = reinterpret_cast<LPPktMU>(lpBuffer->GetBuf());
	
	lpMUPt->m_dwTick		= GetTickCount();	// ½ºÇÙ ¹æÁö ·çƾ 
	lpMUPt->m_bSitMode		= SitMode_In;
	lpMUPt->m_Position		= *Pos_In;	
	lpMUPt->m_fDir			= Dir_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();

	// 1ºÐ¸¶´Ù Çѹø¾¿ ¼­¹ö¿¡ UDP ÆÐŶ ¾÷µ¥ÀÌÆ® ÇÑ´Ù.
	if(60 == m_UpdateCount)
	{
		m_UpdateCount = 0;

		CharUpdateAddress(CharID_In);
	}
	else
	{
		++m_UpdateCount; 
	}

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Ã¤Æà [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	2st : Ä¿¸Çµå[In]
//		0 : º¸Åë, 1 : ÆÄƼ, 2 : ÇÁ·»µå, 3 : ±æµå, 4 : °øÁö, 5 : ·Î±×
//	3st : äÆà ¹®ÀÚ¿­[In]
//	4st : äÆà ¹®ÀÚ¿­ Å©±â[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharChat(DWORD CharID_In, unsigned short Cmd_In, char* Message_In, int MessageSize_In)
{
	if (m_UDPSocket == NULL || Message_In == NULL || MessageSize_In == 0) {
		return false;
	}

	CPacket* lpBuffer = new CPacket(
        static_cast<unsigned short>(sizeof(PktCt) + MessageSize_In + 1), CmdCharChat, 0, 0);

	LPPktCt lpCtPt = reinterpret_cast<LPPktCt>(lpBuffer->GetBuf());
	
	lpCtPt->m_dwCharID		= CharID_In;
	lpCtPt->m_sCmd			= Cmd_In;

	*(Message_In + MessageSize_In) = NULL;
	CopyMemory(lpBuffer->GetBuf() + sizeof(PktCt), Message_In, MessageSize_In + 1);

	lpBuffer->WrapPacket(true);
	switch (Cmd_In)
	{
//		case PktCt::NORMAL: UDPSendList(lpBuffer->GetWSABuf(), m_ClientList);			break;	// º¸Åë
		case PktCt::NORMAL: UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList);	break;	// º¸Åë
		case PktCt::PARTY:	UDPSendList(lpBuffer->GetWSABuf(), m_PartyList);			break;	// ÆÄƼ
		case PktCt::FRIEND:	break;	// ÇÁ·£µå
		case PktCt::GUILD:	break;	// ±æµå

		case PktCt::NOTICE:	break;	// °øÁö (¼­¹ö¿¡¼­¸¸ º¸³½´Ù)

		case PktCt::CLIENT_LOG:		// ·Î±×
		case PktCt::STALL:			// ³ëÁ¡»ó ´ëÈ­¹æ
		{
			if (m_TCPSocket == NULL || CharID_In == 0) {
				return false;
			}

			if (false == Send(m_TCPSocket, lpBuffer->GetWSABuf()))
			{
				lpBuffer->Release();
				return false;
			}
		}
	}

	lpBuffer->Release();
	DeleteInstanceUDPList();

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Ã¤Æà [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]
//	2st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	2st : Ä¿¸Çµå[Out]
//	3st : ¸Þ½ÃÁö[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharChat(char *pBuffer_In, DWORD *CharID_Out, unsigned short *Cmd_Out, char *Message_Out)
{
	LPPktCt lpCtPt = (LPPktCt)pBuffer_In;
	
	if(lpCtPt == NULL || Message_Out == NULL)
		return WrongParameter;

	char *pBuffer	= (char *)lpCtPt + sizeof(PktCt);
	int nLen		= lpCtPt->GetLen();

	*CharID_Out		= lpCtPt->m_dwCharID;
	*Cmd_Out		= lpCtPt->m_sCmd;

	CopyMemory(Message_Out, pBuffer, nLen - sizeof(PktCt));
	Message_Out[nLen - sizeof(PktCt) - 1] = NULL; 

	if(lpCtPt->Error() != NoError)
		return lpCtPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ±Ó¼Ó¸» [ public ]
//
// Parameter :
//	1st : º¸³»´Â ij¸¯ÅÍ À̸§[In]
//	2nd : ¹Þ´Â ij¸¯ÅÍ À̸§[In]
//	3rd : äÆà ¹®ÀÚ¿­[In]
//	4th : äÆà ¹®ÀÚ¿­ Å©±â[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharWhisper(char* SenderName_In, char *RecverName_In, char* Message_In, int MessageSize_In)
{
	if(m_TCPSocket == NULL || SenderName_In == NULL || Message_In == NULL)
		return false;

	LPPktWh lpWhPt = reinterpret_cast<LPPktWh>(GetSendBuffer());
	lpWhPt->InitPtHead(static_cast<unsigned short>(sizeof(PktWh) + MessageSize_In + 1), CmdCharWhisper, 0, 0);	

	strncpy(lpWhPt->m_SenderName, SenderName_In, 16);
	strncpy(lpWhPt->m_RecverName, RecverName_In, 16);

	*(Message_In + MessageSize_In) = NULL;
	CopyMemory(GetSendBuffer() + sizeof(PktWh), Message_In, MessageSize_In + 1);

	PutSendBuffer(true);

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ±Ó¼Ó¸» [ public ]
//
// Parameter :
//	1st : º¸³»´Â ij¸¯ÅÍ À̸§[In]
//	2nd : ¹Þ´Â ij¸¯ÅÍ À̸§[In]
//	3rd : äÆà ¹®ÀÚ¿­[In]
//	4th : äÆà ¹®ÀÚ¿­ Å©±â[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharWhisper(char *pBuffer_In, char *SenderName_Out, char *RecverName_Out, char *Message_Out)
{
	LPPktWh lpWhPt = (LPPktWh)pBuffer_In;
	
	if(lpWhPt == NULL || SenderName_Out == NULL || RecverName_Out == NULL || Message_Out == NULL)
		return WrongParameter;

	char *pBuffer	= (char *)lpWhPt + sizeof(PktWh);
	int nLen		= lpWhPt->GetLen();

	strncpy(SenderName_Out, lpWhPt->m_SenderName, 16);
	strncpy(RecverName_Out, lpWhPt->m_RecverName, 16);

	CopyMemory(Message_Out, pBuffer, nLen - sizeof(PktWh));
	Message_Out[nLen - sizeof(PktWh) - 1] = NULL; 

	if(lpWhPt->Error() != NoError)
		return lpWhPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¼¿ ·Î±×ÀÎ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	2st : Ä¿¸Çµå[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharCellLogin(char *pBuffer_In, DWORD *CharID_Out, LPPOS Pos_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out, unsigned char *Cmd_Out)
{
	LPPktCCLi lpCCLiPt = (LPPktCCLi)pBuffer_In;

	if(lpCCLiPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	*CharID_Out		= lpCCLiPt->m_dwCharID;
	*Cmd_Out		= lpCCLiPt->m_cCmd;
	*Pos_Out		= lpCCLiPt->m_Pos;
	*PubAddress_Out	= lpCCLiPt->m_PublicAddress;
	*PriAddress_Out = lpCCLiPt->m_PrivateAddress;

	if(lpCCLiPt->Error() != NoError)
		return lpCCLiPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¼¿ ·Î±×¾Æ¿ô [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	2st : Ä¿¸Çµå[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharCellLogout(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Cmd_Out)
{
	LPPktCCLo lpCCLoPt = (LPPktCCLo)pBuffer_In;

	if(lpCCLoPt == NULL || CharID_Out == NULL)
		return WrongParameter;

	*CharID_Out		= lpCCLoPt->m_dwCharID;
	*Cmd_Out		= lpCCLoPt->m_cCmd;

	if(lpCCLoPt->Error() != NoError)
		return lpCCLoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¸ó½ºÅÍ ¿òÁ÷ÀÓ [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	2st : À§Ä¡[Out]
//	3st : ¹æÇâ[Out]
//	4st : ¼Óµµ[Out]
//	5st : ¾×¼Ç[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleMonMove(char *pBuffer_In, DWORD *MonID_Out, LPPOS lpPos_Out, float *Dir_Out, float *Vec_Out, unsigned short *Act_Out, unsigned short *AniNum_Out)
{
	LPPktMM lpMMPt = (LPPktMM)pBuffer_In;

	if(lpMMPt == NULL)
		return WrongParameter;

	*MonID_Out		= lpMMPt->m_dwMonID;
	*lpPos_Out		= lpMMPt->m_Position;
	*Dir_Out		= lpMMPt->m_fDir;
	*Vec_Out		= lpMMPt->m_fVec;
	*Act_Out		= lpMMPt->m_wAct;
	*AniNum_Out		= lpMMPt->m_wAniNum;

	if(lpMMPt->Error() != NoError)
		return lpMMPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ °ø°Ý ¿òÁ÷ÀÓ [ public ]
//
// Parameter :
//	2st : À§Ä¡[Out]
//	3st : ¹æÇâ[Out]
//	4st : ¼Óµµ[Out]
//	5st : ¾×¼Ç[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharAttack(DWORD CharID_In, LPPOS lpPos_In, float Dir_In, AtType &AtType_In, AtNode &AtNode_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktAt lpAtPt = reinterpret_cast<LPPktAt>(GetSendBuffer());
	lpAtPt->InitPtHead(sizeof(PktAt), CmdCharAttack, 0, 0);	

	lpAtPt->m_dwCharID		= CharID_In;
	lpAtPt->m_Postion		= *lpPos_In;
	lpAtPt->m_fDir			= Dir_In;
	lpAtPt->m_AtType		= AtType_In;
	lpAtPt->m_AtNode		= AtNode_In;

	// ÆÐŶ ¹Ýº¹ º¸³»±â ´ëºñ
	InsertPtCount(GetSendBuffer());
	
	PutSendBuffer(true);

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ °ø°Ý [ public ]
//
// Parameter :
//	1st : ÆÐŶ ¹öÆÛ[In]								
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	2st : °æÇèÄ¡[Out]
//	3st : HP[Out]
//	4st : MP[Out]
//	5st : À妽º[Out]
//	6st : °ª[Out]
//	7st : µðÆæ´õ ¼ö[Out]
//	8st : µðÆæ´õ ³ëµå Æ÷ÀÎÅÍ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharAttack(char *pBuffer_In, DWORD *CharID_Out, LPAtType lpAtType_Out, unsigned short *HP_Out, unsigned short *MP_Out, 
									 DWORD *RightIndex_Out, DWORD *RightValue_Out, DWORD *LeftIndex_Out, DWORD *LeftValue_Out, 
									 char *Judge_Out, unsigned char *DefenserNum_Out, LPDefenserNode *lppNode_Out)
{
	LPPktAtAck lpAtAckPt = (LPPktAtAck)pBuffer_In;

	if(lpAtAckPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out			= lpAtAckPt->m_dwCharID;
	*lpAtType_Out		= lpAtAckPt->m_AtType;
	*HP_Out				= lpAtAckPt->m_wHP;
	*MP_Out				= lpAtAckPt->m_wMP;
	*RightIndex_Out		= lpAtAckPt->m_cRightHandIndex;
	*RightValue_Out		= lpAtAckPt->m_cRightHandValue;
	*LeftIndex_Out		= lpAtAckPt->m_cLeftHandIndex;
	*LeftValue_Out		= lpAtAckPt->m_cLeftHandValue;
	*Judge_Out			= lpAtAckPt->m_cJudge;
	*DefenserNum_Out	= lpAtAckPt->m_cDefenserNum;

	*lppNode_Out		= (LPDefenserNode)(pBuffer_In + sizeof(PktAtAck));

	if(lpAtAckPt->Error() != NoError) {
		return lpAtAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ °ø°Ý Á¤º¸ [ public ]
//
// Parameter :
//	1st : ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	2st : ¹æ¾îÀÚ ¼ö[In]
//	3st : ¹æ¾îÀÚ ³ëµå[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharAttackInfo(DWORD CharID_In, AtType &AtType_In, unsigned char DefenserNum_In, LPDefenserNode lpNode_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktAtInfo) + sizeof(DefenserNode) * DefenserNum_In, CmdCharAttackInfo, 0, 0);
	LPPktAtInfo lpAtInfoPt = reinterpret_cast<LPPktAtInfo>(lpBuffer->GetBuf());
	
	lpAtInfoPt->m_dwCharID			= CharID_In;
	lpAtInfoPt->m_AtType			= AtType_In;
	lpAtInfoPt->m_cDefenserNum		= DefenserNum_In;

	CopyMemory(lpBuffer->GetBuf() + sizeof(PktAtInfo), lpNode_In, sizeof(DefenserNode) * DefenserNum_In);

	lpBuffer->WrapPacket(true);
//	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList);
	UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList);
	lpBuffer->Release();
	
	DeleteInstanceUDPList();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ °ø°Ý [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	µðÆæ´õ ¼ö[Out]
//	µðÆæ´õ ³ëµå Æ÷ÀÎÅÍ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharAttackInfo(char *pBuffer_In, DWORD *CharID_Out, LPAtType lpAtType_Out, unsigned char *DefenserNum_Out, LPDefenserNode *lppNode_Out)
{
	LPPktAtInfo lpAtInfoPt = (LPPktAtInfo)pBuffer_In;

	if(lpAtInfoPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpAtInfoPt->m_dwCharID;
	*lpAtType_Out		= lpAtInfoPt->m_AtType;
	*DefenserNum_Out	= lpAtInfoPt->m_cDefenserNum;
	*lppNode_Out		= (LPDefenserNode)(pBuffer_In + sizeof(PktAtInfo));

	if(lpAtInfoPt->Error() != NoError)
		return lpAtInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸®½ºÆù [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharRespawn(DWORD CharID_In, unsigned char cCmd_In, POS& Pos_In)
{
	if (m_TCPSocket == NULL || CharID_In == 0) {
		return false;
	}

	LPPktRs lpRsPt = reinterpret_cast<LPPktRs>(GetSendBuffer());
	lpRsPt->InitPtHead(sizeof(PktRs), CmdCharRespawn, 0, 0);	

	lpRsPt->m_dwCharID		= CharID_In;
	lpRsPt->m_cCmd			= cCmd_In;
	lpRsPt->m_Position		= Pos_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸®½ºÆù [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	HP[Out]
//	MP[Out]
//	À§Ä¡[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharRespawn(char *pBuffer_In, DWORD *CharID_Out, unsigned short *HP_Out, unsigned short *MP_Out, LPPOS lpPos_Out, __int64 *Exp_Out)
{
	LPPktRsAck lpRsAckPt = (LPPktRsAck)pBuffer_In;

	if(lpRsAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpRsAckPt->m_dwCharID;
	*HP_Out				= lpRsAckPt->m_wHP;
	*MP_Out				= lpRsAckPt->m_wMP;
	*lpPos_Out			= lpRsAckPt->m_Position;
	*Exp_Out			= lpRsAckPt->m_dlExp;

	if(lpRsAckPt->Error() != NoError)
		return lpRsAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ °ø°Ý ¹ÞÀ½ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	°ø°ÝÀÚ ¾ÆÀ̵ð[Out]
//	°ø°Ý ŸÀÔ[Out]
//	°ø°ÝÀÚ À§Ä¡[Out]
//	°ø°ÝÀÚ ¹æÇâ[Out]
//	³» HP[Out]
//	³» MP[Out]
//	³» ¹«±â À妽º[Out]
//	³» ¹«±â ¼Õ»ó °ª[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharAttacked(char *pBuffer_In, DWORD *AtCharID_Out, AtType *AtType_Out, LPPOS lpAtPos_Out, float *AtDir_Out, unsigned short *Judge_Out, unsigned short *MyHP_Out, unsigned short *MyMP_Out, unsigned char *MyIndex_Out, unsigned char *MyValue_Out)
{
	LPPktAted lpAtedPt = (LPPktAted)pBuffer_In;

	if(lpAtedPt == NULL)
		return WrongParameter;

	*AtCharID_Out		= lpAtedPt->m_dwCharID;
	*AtType_Out			= lpAtedPt->m_AtType;
	*lpAtPos_Out		= lpAtedPt->m_Postion;
	*AtDir_Out			= lpAtedPt->m_fDir;

	*Judge_Out			= lpAtedPt->m_cJudge;

	*MyHP_Out			= lpAtedPt->m_wMyHP;
	*MyMP_Out			= lpAtedPt->m_wMyMP;
	*MyIndex_Out		= lpAtedPt->m_cMyWeaponIndex;
	*MyValue_Out		= lpAtedPt->m_cMyWeaponValue;

	if(lpAtedPt->Error() != NoError)
		return lpAtedPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¾î¿öµå [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	°æÇèÄ¡[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharAward(char *pBuffer_In, DWORD *CharID_Out, DWORD *Exp_Out)
{
	LPPktAw lpAwPt = (LPPktAw)pBuffer_In;

	if(lpAwPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpAwPt->m_dwCharID;
	*Exp_Out			= lpAwPt->m_dwExp;

	if(lpAwPt->Error() != NoError)
		return lpAwPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸ð¾ç [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¸ð¾ç[In]
//	»ç¿ëÇÏ´Â ¼Õ[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharShapeInfo(LPCHAR_VIEW lpCharView_In, unsigned char cSelectedHands_In, unsigned long dwStatusFlag_In, char *StallName_In)
{
	if(m_UDPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktSI), CmdCharShapeInfo, 0, 0);
	LPPktSI lpSIPt = reinterpret_cast<LPPktSI>(lpBuffer->GetBuf());
	
	lpSIPt->m_CharView			= *lpCharView_In;
	lpSIPt->m_cSelectedHands	= cSelectedHands_In;
	lpSIPt->m_dwStatusFlag		= dwStatusFlag_In;

	strncpy(lpSIPt->m_StallName, StallName_In, PktSI::MAX_STALL_NAME_LEN);

	lpBuffer->WrapPacket(true);
//	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList);
	UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList);
	lpBuffer->Release();

	DeleteInstanceUDPList();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸ð¾ç [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	ij¸¯ÅÍ ¸ð¾ç[In]
//	»ç¿ëÇÏ´Â ¼Õ[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharShapeInfo(DWORD CharID_In, LPCHAR_VIEW lpCharView_In, 
								 unsigned char cSelectedHands_In, unsigned long dwStatusFlag_In, char *StallName_In)
{
	if(m_UDPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktSI), CmdCharShapeInfo, 0, 0);
	LPPktSI lpSIPt = reinterpret_cast<LPPktSI>(lpBuffer->GetBuf());
	
	lpSIPt->m_CharView			= *lpCharView_In;
	lpSIPt->m_cSelectedHands	= cSelectedHands_In;
	lpSIPt->m_dwStatusFlag		= dwStatusFlag_In;

	strncpy(lpSIPt->m_StallName, StallName_In, PktSI::MAX_STALL_NAME_LEN);

	lpBuffer->WrapPacket(true);
	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList, CharID_In);
	lpBuffer->Release();

	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸ð¾ç Á¤º¸ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ºä ±¸Á¶Ã¼[Out]
//	»ç¿ëÇÏ´Â ¼Õ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharShapeInfo(char *pBuffer_In, LPCHAR_VIEW lpCharView_Out, 
										unsigned char *cSelectedHands_Out, unsigned long *dwStatusFlag_Out, char *StallName_Out)
{
	LPPktSI lpSIPt = (LPPktSI)pBuffer_In;

	if (lpSIPt == NULL) {
		return WrongParameter;
	}

	*lpCharView_Out		= lpSIPt->m_CharView;
	*cSelectedHands_Out	= lpSIPt->m_cSelectedHands;
	*dwStatusFlag_Out	= lpSIPt->m_dwStatusFlag;

	strncpy(StallName_Out, lpSIPt->m_StallName, PktSI::MAX_STALL_NAME_LEN);

	if (lpSIPt->Error() != NoError) {
		return lpSIPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// Áý±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	¿ÀºêÁ§Æ® ¾ÆÀ̵ð[In]
//	¾ÆÀÌÅÛ À§Ä¡[In]
//	À妽º[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPickUp(DWORD CharID_In, DWORD ObjectID_In, Item::ItemPos Index_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktPU lpPUPt = reinterpret_cast<LPPktPU>(GetSendBuffer());
	lpPUPt->InitPtHead(sizeof(PktPU), CmdCharPickUp, 0, 0);	

	lpPUPt->m_dwCharID		= CharID_In;
	lpPUPt->m_dwObjectID	= ObjectID_In;
	lpPUPt->m_itemPos       = Index_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ Áý±â [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	¿ÀºêÁ§Æ® ¾ÆÀ̵ð[Out]
//	¾ÆÀÌÅÛ À§Ä¡[Out]
//	À妽º[Out]
//	µ·[Out]		 # ¸¸¾à ÁýÀº°ÍÀÌ µ·À̶ó¸é »çÀÌÁî´Â 0ÀÌ¸ç ¹öÆÛ´Â NULL
//	»çÀÌÁî[Out]
//	¹öÆÛ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPickUp(char *pBuffer_In, DWORD *CharID_Out, DWORD *ObjectID_Out, 
                                     Item::ItemPos* lpIndex_Out, DWORD *Gold_Out, DWORD *Size_Out,
                                     unsigned char* cNum_Out, char **lppBuffer_Out)
{
	LPPktPUAck lpPUAckPt = (LPPktPUAck)pBuffer_In;

	if(lpPUAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpPUAckPt->m_dwCharID;
	*ObjectID_Out		= lpPUAckPt->m_dwObjectID;
	
	*lpIndex_Out		= lpPUAckPt->m_itemPos;
    *cNum_Out           = lpPUAckPt->m_cNum;

    switch(lpPUAckPt->m_cType)
    {
    case PktPUAck::Item:

    	*Gold_Out		= 0;
		*Size_Out		= lpPUAckPt->m_dwSize;
		*lppBuffer_Out	= (char *)(pBuffer_In + sizeof(PktPUAck));
        break;
	
    case PktPUAck::Gold:

        *Gold_Out		= lpPUAckPt->m_dwSize;
		*Size_Out		= 0;
		*lppBuffer_Out	= NULL;
        break;
    };

	if(lpPUAckPt->Error() != NoError)
		return lpPUAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ Áý±â Á¤º¸ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	¿ÀºêÁ§Æ® ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPickUpInfo(char *pBuffer_In, DWORD *CharID_Out, DWORD *ObjectID_Out)
{
	LPPktPUInfo lpPUInfoPt = (LPPktPUInfo)pBuffer_In;

	if(lpPUInfoPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpPUInfoPt->m_dwCharID;
	*ObjectID_Out		= lpPUInfoPt->m_dwObjectID;
	
	if(lpPUInfoPt->Error() != NoError)
		return lpPUInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¶³¾î¶ß¸®±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	¾ÆÀÌÅÛ À§Ä¡[In]
//	À妽º[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPullDown(DWORD CharID_In, Item::ItemPos Index_In, unsigned char cNum)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktPD lpPDPt = reinterpret_cast<LPPktPD>(GetSendBuffer());
	lpPDPt->InitPtHead(sizeof(PktPD), CmdCharPullDown, 0, 0);	

	lpPDPt->m_dwCharID		= CharID_In;	
	lpPDPt->m_itemPos		= Index_In;
    lpPDPt->m_cNum          = cNum;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¶³¾î¶ß¸®±â [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	¾ÆÀÌÅÛ À§Ä¡[Out]
//	À妽º[Out]
//	ÇÊµå ¾ÆÀÌÅÛ Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPullDown(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpIndex_Out, LPFieldObject lpFieldObject_Out)
{
	LPPktPDAck lpPDAckPt = (LPPktPDAck)pBuffer_In;

	if(lpPDAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpPDAckPt->m_dwCharID;
    *lpFieldObject_Out	= lpPDAckPt->m_FieldObject;
	*lpIndex_Out		= lpPDAckPt->m_itemPos;	
	
	if(lpPDAckPt->Error() != NoError)
		return lpPDAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¶³¾î¶ß¸®±â Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ÇÊµå ¾ÆÀÌÅÛ Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPullDownInfo(char *pBuffer_In, DWORD *CharID_Out, LPFieldObject lpFieldObject_Out)
{
	LPPktPDInfo lpPDInfoPt = (LPPktPDInfo)pBuffer_In;

	if(lpPDInfoPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpPDInfoPt->m_dwCharID;
	*lpFieldObject_Out	= lpPDInfoPt->m_FieldObject;
	
	if(lpPDInfoPt->Error() != NoError)
		return lpPDInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// °ÔÀÓ ¼¿ Á¤º¸ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	¿ÀºêÁ§Æ® °³¼ö[Out]
//	ÇÊµå ¿ÀºêÁ§Æ® Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleGameCellInfo(char *pBuffer_In, unsigned char *ObjectNum_Out, LPFieldObject *lppFieldObject_Out)
{
	LPPktCeInfo lpCeInfoPt = (LPPktCeInfo)pBuffer_In;

	if(lpCeInfoPt == NULL)
		return WrongParameter;

	*ObjectNum_Out			= lpCeInfoPt->m_cObjectNum;
	*lppFieldObject_Out		= (LPFieldObject)(pBuffer_In + sizeof(PktCeInfo));

	if(lpCeInfoPt->Error() != NoError)
		return lpCeInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ Ã³¸® [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	ó¸® Á¤º¸[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharTakeItem(DWORD CharID_In, TakeType TakeType_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktTI lpTIPt = reinterpret_cast<LPPktTI>(GetSendBuffer());
	lpTIPt->InitPtHead(sizeof(PktTI), CmdCharTakeItem, 0, 0);	

	lpTIPt->m_dwCharID		= CharID_In;
	lpTIPt->m_TakeType		= TakeType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ Ã³¸® [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ó¸® Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharTakeItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpTakeType_Out)
{
	LPPktTI lpTIPt = (LPPktTI)pBuffer_In;

	if(lpTIPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpTIPt->m_dwCharID;
	*lpTakeType_Out		= lpTIPt->m_TakeType;

	if(lpTIPt->Error() != NoError)
		return lpTIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ½º¿Ò [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	ó¸® ¼Ò½º Á¤º¸[In]
//	ó¸® ¸ñÀû Á¤º¸[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSwapItem(DWORD CharID_In, TakeType SrcType_In, TakeType DstType_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSwI lpSwIPt = reinterpret_cast<LPPktSwI>(GetSendBuffer());
	lpSwIPt->InitPtHead(sizeof(PktSwI), CmdCharSwapItem, 0, 0);	

	lpSwIPt->m_dwCharID		= CharID_In;
	lpSwIPt->m_SwapSrc		= SrcType_In;
	lpSwIPt->m_SwapDst		= DstType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ½º¿Ò [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ó¸® ¼Ò½º Á¤º¸[Out]
//	ó¸® ¸ñÀû Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSwapItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpSrcType_Out, LPTakeType lpDstType_Out)
{
	LPPktSwI lpSwIPt = (LPPktSwI)pBuffer_In;

	if(lpSwIPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSwIPt->m_dwCharID;
	*lpSrcType_Out		= lpSwIPt->m_SwapSrc;
	*lpDstType_Out		= lpSwIPt->m_SwapDst;
	
	if(lpSwIPt->Error() != NoError)
		return lpSwIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ °Å·¡ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	NPC ¾ÆÀ̵ð[In]
//	°Å·¡ ¾ÆÀÌÅÛ Á¾·ù ¾ÆÀ̵ð[In]
//	°Å·¡ ¾ÆÀÌÅÛ À§Ä¡
//	°Å·¡ ¾ÆÀÌÅÛ À妽º
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharTradeItem(DWORD CharID_In, DWORD NPCID_In, unsigned short ItemID_In, TakeType TakeType_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktTr lpTrPt = reinterpret_cast<LPPktTr>(GetSendBuffer());
	lpTrPt->InitPtHead(sizeof(PktTr), CmdCharTradeItem, 0, 0);	

	lpTrPt->m_dwCustomerID	= CharID_In;
	lpTrPt->m_dwOwnerID		= NPCID_In;

	lpTrPt->m_wBuyItemID	= ItemID_In;
	lpTrPt->m_TakeType		= TakeType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ °Å·¡ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	NPC ¾ÆÀ̵ð[In]
//	°Å·¡ ¾ÆÀÌÅÛ Á¾·ù ¾ÆÀ̵ð[In]
//	°Å·¡ ¾ÆÀÌÅÛ À§Ä¡
//	°Å·¡ ¾ÆÀÌÅÛ À妽º
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharTradeItem(char *pBuffer_In, DWORD *CharID_Out, DWORD *NPCID_Out, unsigned char *Pos_Out, Item::ItemPos* lpIndex_Out, 
										unsigned char *Num_Out, DWORD *Gold_Out, unsigned short *Size_Out, char **lppBuffer_Out)
{
	LPPktTrAck lpTrAckPt = (LPPktTrAck)pBuffer_In;

	if(lpTrAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpTrAckPt->m_dwCharID;
	*NPCID_Out			= lpTrAckPt->m_dwNPCID;		
	*lpIndex_Out		= lpTrAckPt->m_itemPos;
	*Num_Out			= lpTrAckPt->m_cNum;

	*Gold_Out			= lpTrAckPt->m_dwGold;

	if(0 == lpTrAckPt->m_wSize)
	{
		*Size_Out		= 0;
		*lppBuffer_Out	= NULL;
	}
	else
	{
		*Size_Out		= lpTrAckPt->m_wSize;
		*lppBuffer_Out	= pBuffer_In + sizeof(PktTrAck);
	}

	if(lpTrAckPt->Error() != NoError)
		return lpTrAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ¼ö¸® [ public ]
//
// Parameter :
//	NPC ¾ÆÀ̵ð[In]
//	¾ÆÀÌÅÛ À§Ä¡[In]
//	¾ÆÀÌÅÛ À妽º[In]
//	¼ö¸® ºñ¿ë[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharRepairItem(DWORD NPCID_In, Item::ItemPos* lpIndex_In, DWORD Gold_In)
{
	if(m_TCPSocket == NULL || NPCID_In == 0)
		return false;

	LPPktRpI lpRpIPt = reinterpret_cast<LPPktRpI>(GetSendBuffer());
	lpRpIPt->InitPtHead(sizeof(PktRpI), CmdCharRepairItem, 0, 0);	

	lpRpIPt->m_dwCharID		= NPCID_In;
	lpRpIPt->m_dwGold		= Gold_In;
    lpRpIPt->m_itemPos      = *lpIndex_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ¼ö¸® [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	¾ÆÀÌÅÛ À§Ä¡[Out]
//	¾ÆÀÌÅÛ À妽º[Out]
//	¼ö¸® ºñ¿ë[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharRepairItem(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpIndex_Out, DWORD *Gold_Out)
{
	LPPktRpI lpRpIPt = (LPPktRpI)pBuffer_In;

	if(lpRpIPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpRpIPt->m_dwCharID;
	*Gold_Out			= lpRpIPt->m_dwGold;
	*lpIndex_Out		= lpRpIPt->m_itemPos;
	
	if(lpRpIPt->Error() != NoError)
		return lpRpIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ »ç¿ë [ public ]
//
// Parameter :
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	¾ÆÀÌÅÛ À妽º[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharUseItem(DWORD SenderID_In, DWORD RecverID_In, Item::ItemPos* lpIndex_In)
{
	if(m_TCPSocket == NULL || SenderID_In == 0 || RecverID_In == 0)
		return false;

	LPPktUI lpUIPt = reinterpret_cast<LPPktUI>(GetSendBuffer());
	lpUIPt->InitPtHead(sizeof(PktUI), CmdCharUseItem, 0, 0);	

	lpUIPt->m_dwSender		= SenderID_In;
	lpUIPt->m_dwRecver		= RecverID_In;

	lpUIPt->m_itemPos		= *lpIndex_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ »ç¿ë [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	¾ÆÀÌÅÛ À妽º[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharUseItem(char *pBuffer_In, DWORD *SenderID_Out, DWORD *Recver_Out, Item::ItemPos* lpIndex_Out)
{
	LPPktUI lpUIPt = (LPPktUI)pBuffer_In;

	if(lpUIPt == NULL)
		return WrongParameter;

	*SenderID_Out		= lpUIPt->m_dwSender;
	*Recver_Out			= lpUIPt->m_dwRecver;
	*lpIndex_Out		= lpUIPt->m_itemPos;
	
	if(lpUIPt->Error() != NoError)
		return lpUIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿ÀºêÁ§Æ® ´øÁö±â [ public ]
//
// Parameter :
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	ij½ºÆ® ¿ÀºêÁ§Æ®[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharCastObject(DWORD SenderID_In, DWORD RecverID_In, CastObject &CastObject_In)
{
	if(m_TCPSocket == NULL || SenderID_In == 0 || RecverID_In == 0)
		return false;

	LPPktCO lpCOPt = reinterpret_cast<LPPktCO>(GetSendBuffer());
	lpCOPt->InitPtHead(sizeof(PktCO), CmdCharCastObject, 0, 0);	

	lpCOPt->m_dwSenderID		= SenderID_In;
	lpCOPt->m_dwReceiverID		= RecverID_In;

	lpCOPt->m_sCastObject		= CastObject_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿ÀºêÁ§Æ® ´øÁö±â [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	ij¸£Æ® ¿ÀºêÁ§Æ®[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharCastObject(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, LPCastObject lpCastObject)
{
	LPPktCO lpCOPt = (LPPktCO)pBuffer_In;

	if(lpCOPt == NULL)
		return WrongParameter;

	*SenderID_Out		= lpCOPt->m_dwSenderID;
	*RecverID_Out		= lpCOPt->m_dwReceiverID;
	*lpCastObject		= lpCOPt->m_sCastObject;
	
	if(lpCOPt->Error() != NoError)
		return lpCOPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿ÀºêÁ§Æ® ´øÁö±â Á¤º¸ [ public ]
//
// Parameter :
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[In]
//	ij½ºÆ® ¿ÀºêÁ§Æ®[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharCastObjectInfo(DWORD SenderID_In, DWORD RecverID_In, CastObject &CastObject_In)
{
	if(m_TCPSocket == NULL || SenderID_In == 0 || RecverID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktCOInfo), CmdCharCastObjectInfo, 0, 0);
	LPPktCOInfo lpCOInfoPt = reinterpret_cast<LPPktCOInfo>(lpBuffer->GetBuf());
	
	lpCOInfoPt->m_dwSenderID	= SenderID_In;
	lpCOInfoPt->m_dwReceiverID	= RecverID_In;

	lpCOInfoPt->m_sCastObject	= CastObject_In;

	lpBuffer->WrapPacket(true);
//	UDPSendList(lpBuffer->GetWSABuf(), m_ClientList);
	UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList);
	lpBuffer->Release();
	
	DeleteInstanceUDPList();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿ÀºêÁ§Æ® ´øÁö±â Á¤º¸ [ public ]
//
// Parameter :
//	ÆÐŶ ¹öÆÛ[In]								
//	ÁÖ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	¹Þ´Â »ç¶÷ ¾ÆÀ̵ð[Out]
//	ij¸£Æ® ¿ÀºêÁ§Æ®[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharCastObjectInfo(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, LPCastObject lpCastObject)
{
	LPPktCOInfo lpCOInfoPt = (LPPktCOInfo)pBuffer_In;

	if(lpCOInfoPt == NULL)
		return WrongParameter;

	*SenderID_Out		= lpCOInfoPt->m_dwSenderID;
	*RecverID_Out		= lpCOInfoPt->m_dwReceiverID;
	*lpCastObject		= lpCOInfoPt->m_sCastObject;
	
	if(lpCOInfoPt->Error() != NoError)
		return lpCOInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼ÒÄÏ ¼³Ä¡ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Àåºñ ¾ÆÀÌÅÛ À§Ä¡[In]
//	Àåºñ ¾ÆÀÌÅÛ À妽º[In]
//	º¸¼® À§Ä¡[In]
//	º¸¼® À妽º[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharInstallSocket(DWORD CharID_In, Item::ItemPos* lpEquipIndex_In, Item::ItemPos* lpSocket_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktIS lpISPt = reinterpret_cast<LPPktIS>(GetSendBuffer());
	lpISPt->InitPtHead(sizeof(PktIS), CmdCharInstallSocket, 0, 0);	

	lpISPt->m_dwCharID		= CharID_In;
	lpISPt->m_equipPos		= *lpEquipIndex_In;
	lpISPt->m_gemPos		= *lpSocket_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼ÒÄÏ ¼³Ä¡ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Àåºñ ¾ÆÀÌÅÛ À§Ä¡[Out]
//	Àåºñ ¾ÆÀÌÅÛ À妽º[Out]
//	º¸¼® À§Ä¡[Out]
//	º¸¼® À妽º[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharInstallSocket(char *pBuffer_In, DWORD *CharID_Out, Item::ItemPos* lpEquipIndex_Out, 
											Item::ItemPos* lpSocket_Out, unsigned short *Size_Out, char **lppBuffer_Out)
{
	LPPktISAck lpISAckPt = (LPPktISAck)pBuffer_In;

	if (lpISAckPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out			= lpISAckPt->m_dwCharID;	
	*lpEquipIndex_Out	= lpISAckPt->m_equipPos;	
	*lpSocket_Out		= lpISAckPt->m_gemPos;
	
	*Size_Out			= lpISAckPt->m_wSize;

	if (lpISAckPt->m_wSize > 0) {
		*lppBuffer_Out	= (char *)(pBuffer_In + sizeof(PktISAck));
	}

	if(lpISAckPt->Error() != NoError) {
		return lpISAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÀÚ»ì [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSuicide(DWORD CharID_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSC lpSCPt = reinterpret_cast<LPPktSC>(GetSendBuffer());
	lpSCPt->InitPtHead(sizeof(PktSC), CmdCharSuicide, 0, 0);	

	lpSCPt->m_dwCharID			= CharID_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÀÚ»ì [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ij¸¯ÅÍ À§Ä¡[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSuicide(char *pBuffer_In, DWORD *CharID_Out, LPPOS lpPos_Out)
{
	LPPktSCAck lpSCAckPt = (LPPktSCAck)pBuffer_In;

	if(lpSCAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSCAckPt->m_dwCharID;
	*lpPos_Out			= lpSCAckPt->m_Pos;

	if(lpSCAckPt->Error() != NoError)
		return lpSCAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ À§Ä¡ ¹ÙÀεå [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Ä¿¸Çµå[In]
//	À§Ä¡[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharBindPos(DWORD NPCID_In, unsigned char Cmd_In, LPPOS lpPos_In, char Zone_In)
{
	if(m_TCPSocket == NULL || NPCID_In == 0)
		return false;

	LPPktBP lpBPPt = reinterpret_cast<LPPktBP>(GetSendBuffer());
	lpBPPt->InitPtHead(sizeof(PktBP), CmdCharBindPosition, 0, 0);	

    lpBPPt->m_Pos			= *lpPos_In;
	lpBPPt->m_dwNPCID		= NPCID_In;
	lpBPPt->m_cCmd			= Cmd_In;	
	lpBPPt->m_cZone			= Zone_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ À§Ä¡ ¹ÙÀεå [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Ä¿¸Çµå[Out]
//	À§Ä¡[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharBindPos(char *pBuffer_In, DWORD *NPCID_Out, unsigned char *Cmd_Out, LPPOS lpPos_Out, char *Zone_Out)
{
	LPPktBP lpBPPt = (LPPktBP)pBuffer_In;

	if(lpBPPt == NULL)
		return WrongParameter;

    *lpPos_Out			= lpBPPt->m_Pos;
	*NPCID_Out			= lpBPPt->m_dwNPCID;
    *Cmd_Out			= lpBPPt->m_cCmd;
	*Zone_Out			= lpBPPt->m_cZone;

	if(lpBPPt->Error() != NoError)
		return lpBPPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·¹º§ ¾÷ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	·¹º§[Out]
//	ij¸¯ÅÍ ´É·ÂÄ¡[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharLevelUp(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Level_Out, LPChState lpChState_Out)
{
	LPPktLU lpLUPt = (LPPktLU)pBuffer_In;

	if(lpLUPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpLUPt->m_dwCharID;
	*Level_Out			= lpLUPt->m_cLevel;
	*lpChState_Out		= lpLUPt->m_State;

	if(lpLUPt->Error() != NoError)
		return lpLUPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Æ÷ÀÎÆ® Áõ°¡ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Æ÷ÀÎÆ®[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharIncreasePoint(DWORD CharID_In, unsigned char StateType_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktIP lpIPPt = reinterpret_cast<LPPktIP>(GetSendBuffer());
	lpIPPt->InitPtHead(sizeof(PktIP), CmdCharIncreasePoint, 0, 0);	

	lpIPPt->m_dwCharID		= CharID_In;
	lpIPPt->m_cStateType	= StateType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Æ÷ÀÎÆ® Áõ°¡ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	»óÅÂ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharIncreasePoint(char *pBuffer_In, DWORD *CharID_Out, LPChState lpChState_Out)
{
	LPPktIPAck lpIPAckPt = (LPPktIPAck)pBuffer_In;

	if(lpIPAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpIPAckPt->m_dwCharID;
	*lpChState_Out		= lpIPAckPt->m_State;

	if(lpIPAckPt->Error() != NoError)
		return lpIPAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Å¬·¡½º ¾÷±×·¹À̵å [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Ŭ·¡½º ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharClassUpgrade(DWORD CharID_In, unsigned char ClassID_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktCU lpCUPt = reinterpret_cast<LPPktCU>(GetSendBuffer());
	lpCUPt->InitPtHead(sizeof(PktCU), CmdCharClassUpgrade, 0, 0);	

	lpCUPt->m_dwCharID		= CharID_In;
	lpCUPt->m_cClass		= ClassID_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Å¬·¡½º ¾÷±×·¹À̵å [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Ŭ·¡½º ¾ÆÀ̵ð[Out]
//	½ºÅ³ À妽º[Out]
//	½ºÅ³ ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharClassUpgrade(char *pBuffer_In, DWORD *CharID_Out, unsigned short *ClassID_Out, LPChState lpState_Out, char *Index_Out, unsigned short *Skill_Out)
{
	LPPktCUAck lpCUAckPt = (LPPktCUAck)pBuffer_In;

	if(lpCUAckPt == NULL)
		return WrongParameter;

   	*lpState_Out		= lpCUAckPt->m_State;
	*CharID_Out			= lpCUAckPt->m_dwCharID;
	*Skill_Out			= lpCUAckPt->m_wSkill;
   	*ClassID_Out		= lpCUAckPt->m_cClass;
    *Index_Out			= lpCUAckPt->m_cIndex;

	if(lpCUAckPt->Error() != NoError)
		return lpCUAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ ¶ô [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	½ºÅ³ À妽º[In]
//	½ºÅ³ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSkillLock(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSk lpSkPt = reinterpret_cast<LPPktSk>(GetSendBuffer());
	lpSkPt->InitPtHead(sizeof(PktSk), CmdCharSkillLock, 0, 0);	

	lpSkPt->m_dwCharID		= CharID_In;
	lpSkPt->m_wSkill		= SkillID_In;
	lpSkPt->m_cIndex		= Index_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ ¶ô [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	½ºÅ³ À妽º[Out]
//	½ºÅ³ ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSkillLock(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out)
{
	LPPktSk lpSkPt = (LPPktSk)pBuffer_In;

	if(lpSkPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSkPt->m_dwCharID;

	*SkillID_Out		= lpSkPt->m_wSkill;
	*Index_Out			= lpSkPt->m_cIndex;

	if(lpSkPt->Error() != NoError)
		return lpSkPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ ¶ô ÇØÁ¦ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	½ºÅ³ À妽º[In]
//	½ºÅ³ ¾ÆÀ̵ð[In]
//	¾ÆÀÌÅÛ À妽º[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSkillUnLock(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In, Item::ItemPos* lpIndex_In)
{
	if (m_TCPSocket == NULL || CharID_In == 0) {
		return false;
	}

	LPPktSkUL lpSkULPt = reinterpret_cast<LPPktSkUL>(GetSendBuffer());
	lpSkULPt->InitPtHead(sizeof(PktSkUL), CmdCharSkillUnLock, 0, 0);	

	lpSkULPt->m_dwCharID	= CharID_In;
	lpSkULPt->m_wSkill		= SkillID_In;
    lpSkULPt->m_cIndex      = Index_In;
	lpSkULPt->m_itemPos     = *lpIndex_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ ¶ô ÇØÁ¦ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	½ºÅ³ À妽º[Out]
//	½ºÅ³ ¾ÆÀ̵ð[Out]
//	¾ÆÀÌÅÛ À妽º[Out]
//	¼Ò¸ðµÇ´Â µ·[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSkillUnLock(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out, 
										  Item::ItemPos* lpIndex_Out, unsigned long *Gold_Out)
{
	LPPktSkULAck lpSkULAckPt = (LPPktSkULAck)pBuffer_In;

	if(lpSkULAckPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out			= lpSkULAckPt->m_dwCharID;

	*SkillID_Out		= lpSkULAckPt->m_wSkill;
	*Index_Out			= lpSkULAckPt->m_cIndex;

    *Gold_Out			= lpSkULAckPt->m_dwGold;
	*lpIndex_Out		= lpSkULAckPt->m_itemPos;
	

	if (lpSkULAckPt->Error() != NoError) {
		return lpSkULAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ »ý¼º [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	½ºÅ³ À妽º[In]
//	½ºÅ³ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSkillCreate(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSk lpSkPt = reinterpret_cast<LPPktSk>(GetSendBuffer());
	lpSkPt->InitPtHead(sizeof(PktSk), CmdCharSkillCreate, 0, 0);	

	lpSkPt->m_dwCharID		= CharID_In;
	lpSkPt->m_wSkill		= SkillID_In;
	lpSkPt->m_cIndex		= Index_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ »ý¼º [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	½ºÅ³ À妽º[Out]
//	½ºÅ³ ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSkillCreate(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out)
{
	LPPktSk lpSkPt = (LPPktSk)pBuffer_In;

	if(lpSkPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSkPt->m_dwCharID;

	*SkillID_Out		= lpSkPt->m_wSkill;
	*Index_Out			= lpSkPt->m_cIndex;

	if(lpSkPt->Error() != NoError)
		return lpSkPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ Áö¿ì±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	½ºÅ³ À妽º[In]
//	½ºÅ³ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSkillErase(DWORD CharID_In, unsigned short SkillID_In, unsigned char Index_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSk lpSkPt = reinterpret_cast<LPPktSk>(GetSendBuffer());
	lpSkPt->InitPtHead(sizeof(PktSk), CmdCharSkillErase, 0, 0);	

	lpSkPt->m_dwCharID		= CharID_In;
	lpSkPt->m_wSkill		= SkillID_In;
	lpSkPt->m_cIndex		= Index_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅ³ Áö¿ì±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	½ºÅ³ À妽º[Out]
//	½ºÅ³ ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSkillErase(char *pBuffer_In, DWORD *CharID_Out, unsigned short *SkillID_Out, unsigned char *Index_Out)
{
	LPPktSk lpSkPt = (LPPktSk)pBuffer_In;

	if(lpSkPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSkPt->m_dwCharID;

	*SkillID_Out		= lpSkPt->m_wSkill;
	*Index_Out			= lpSkPt->m_cIndex;

	if(lpSkPt->Error() != NoError)
		return lpSkPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ Á¤º¸ [ public ]
//
// Parameter :
//	ÆÄƼ ¾ÆÀ̵ð[Out]
//	ÆÄƼ Á¤º¸[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPartyInfo(char *pBuffer_In, LPPARTY lpParty_Out)
{
	LPPktPI lpPIPt = (LPPktPI)pBuffer_In;

	if(lpPIPt == NULL)
		return WrongParameter;

	*lpParty_Out		= lpPIPt->m_Party;

	if(lpPIPt->Error() != NoError)
		return lpPIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ Ä¿¸Çµå [ public ]
//
// Parameter :
//	º¸³»´Â ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	¹Þ´Â ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	ÆÄƼ ¾ÆÀ̵ð[In]
//	Ä¿¸Çµå[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPartyCmd(DWORD SenderID_In, DWORD ReferenceID_In, DWORD PartyID_In, unsigned short Cmd_In)
{
	if(m_TCPSocket == NULL || SenderID_In == 0)
		return false;

	LPPktPC lpPCPt = reinterpret_cast<LPPktPC>(GetSendBuffer());
	lpPCPt->InitPtHead(sizeof(PktPC), CmdCharPartyCmd, 0, 0);	

	lpPCPt->m_wCmd					= Cmd_In;
	lpPCPt->m_dwPartyID				= PartyID_In;
	lpPCPt->m_dwSenderID			= SenderID_In;
	lpPCPt->m_dwReferenceID			= ReferenceID_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ Á¤º¸ [ public ]
//
// Parameter :
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPartyCmd(char *pBuffer_In, LPAddressInfo SenderAddress_Out, char *SenderName_Out, DWORD *SenderID_Out, DWORD *ReferenceID_Out, DWORD *PartyID_Out, unsigned short *Cmd_Out)
{
	LPPktPCAck lpPCAckPt = (LPPktPCAck)pBuffer_In;

	if(lpPCAckPt == NULL)
		return WrongParameter;

	*SenderAddress_Out	= lpPCAckPt->m_SenderAddressInfo;
	strncpy(SenderName_Out, lpPCAckPt->m_strSenderName, 16);
	*SenderID_Out		= lpPCAckPt->m_dwSenderID;
	*ReferenceID_Out	= lpPCAckPt->m_dwReferenceID;
	
	*PartyID_Out		= lpPCAckPt->m_dwPartyID;
	*Cmd_Out			= lpPCAckPt->m_cCmd;

	if(lpPCAckPt->Error() != NoError)
		return lpPCAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ Á¤º¸ [ public ]
//
// Parameter :
//	º¸³»´Â ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	¹Þ´Â ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ÆÄƼ ¾ÆÀ̵ð[Out]
//	Ä¿¸Çµå[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPartyCmdInfo(char *pBuffer_In, DWORD *MemberID_Out, DWORD *PartyID_Out, unsigned short *Cmd_Out)
{
	LPPktPCInfo lpPCInfoPt = (LPPktPCInfo)pBuffer_In;

	if(lpPCInfoPt == NULL)
		return WrongParameter;

	*MemberID_Out		= lpPCInfoPt->m_dwMemberID;
	*PartyID_Out		= lpPCInfoPt->m_dwPartyID;
	*Cmd_Out			= lpPCInfoPt->m_cCmd;
		
	if(lpPCInfoPt->Error() != NoError)
		return lpPCInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ ¸â¹ö Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	ÆÄƼ ¾ÆÀ̵ð[In]
//	ÃÖ´ë HP[In]
//	ÇöÁ¦ HP[In]
//	ÃÖ´ë MP[In]
//	ÇöÁ¦ MP[In]
//	æƮ[In]
//	¾ØæƮ[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPartyMemInfo(DWORD CharID_In, DWORD PartyID_In, unsigned char Class_In, char Level_In, unsigned short MaxHP_In, short CurHP_In, unsigned short MaxMP_In, short CurMP_In, DWORD Chant_In, DWORD Enchant_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktPM), CmdCharPartyMemInfo, 0, 0);
	LPPktPM lpPMPt = reinterpret_cast<LPPktPM>(lpBuffer->GetBuf());
	
	lpPMPt->m_dwCharID			= CharID_In;
	lpPMPt->m_dwPartyID			= PartyID_In;

	lpPMPt->m_cClass			= Class_In;
	lpPMPt->m_cLevel			= Level_In;

	lpPMPt->m_wMaxHP			= MaxHP_In;
	lpPMPt->m_sCurrHP			= CurHP_In;
	lpPMPt->m_wMaxMP			= MaxMP_In;
	lpPMPt->m_sCurrMP			= CurMP_In;

	lpPMPt->m_dwChant			= Chant_In;
	lpPMPt->m_dwEnchant			= Enchant_In;

	lpPMPt->m_PublicAddress		= m_PubUDPAddress;
	lpPMPt->m_PrivateAddress	= m_PriUDPAddress;

	lpBuffer->WrapPacket(true);
	UDPSendList(lpBuffer->GetWSABuf(), m_PartyList);
	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ ¸â¹ö Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ÆÄƼ ¾ÆÀ̵ð[Out]
//	ÃÖ´ë HP[Out]
//	ÇöÁ¦ HP[Out]
//	ÃÖ´ë MP[Out]
//	ÇöÁ¦ MP[Out]
//	æƮ[Out]
//	¾ØæƮ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPartyMemInfo(char *pBuffer_In, DWORD *CharID_Out, DWORD *PartyID_Out, unsigned char *Class_Out, char *Level_Out, unsigned short *MaxHP_Out, unsigned short *CurHP_Out, unsigned short *MaxMP_Out, unsigned short *CurMP_Out, DWORD *Chant_Out, DWORD *Enchant_Out, SOCKADDR_IN* PubAddress_Out, SOCKADDR_IN* PriAddress_Out)
{
	LPPktPM lpPMPt = (LPPktPM)pBuffer_In;

	if(lpPMPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpPMPt->m_dwCharID;
	*PartyID_Out		= lpPMPt->m_dwPartyID;
	
	*Class_Out			= lpPMPt->m_cClass;
	*Level_Out			= lpPMPt->m_cLevel;

	*MaxHP_Out			= lpPMPt->m_wMaxHP;
	*CurHP_Out			= lpPMPt->m_sCurrHP;
	*MaxMP_Out			= lpPMPt->m_wMaxMP;
	*CurMP_Out			= lpPMPt->m_sCurrMP;

	*Chant_Out			= lpPMPt->m_dwChant;
	*Enchant_Out		= lpPMPt->m_dwEnchant;

	*PubAddress_Out		= lpPMPt->m_PublicAddress;
	*PriAddress_Out		= lpPMPt->m_PrivateAddress;

	if(lpPMPt->Error() != NoError)
		return lpPMPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ ã±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPartyFind(DWORD CharID_In)
{
	if (m_TCPSocket == NULL || CharID_In == 0) {
		return false;
	}

	LPPktPF lpPFPt = reinterpret_cast<LPPktPF>(GetSendBuffer());
	lpPFPt->InitPtHead(sizeof(PktPF), CmdCharPartyFind, 0, 0);	

	lpPFPt->m_dwCharID			= CharID_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ÆÄƼ ã±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	ÆÄƼ¸¦ ã´Â ij¸¯ÅÍÀÇ ¼ö[Out]
//	ÆÄƼ¿øÀ» ã´Â ÆÄƼÀÇ ¼ö[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharPartyFind(char *pBuffer_In, DWORD *CharID_Out, unsigned char *MemberFindPartyNum_Out, unsigned char *PartyFindMemberNum_Out, 
										LPMemberFindParty *lppMemberFindParty_Out, LPPartyFindMember *lppPartyFindMember_Out)
{
	LPPktPFAck lpPFAckPt = (LPPktPFAck)pBuffer_In;

	if (lpPFAckPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out					= lpPFAckPt->m_dwCharID;
	*MemberFindPartyNum_Out		= lpPFAckPt->m_cMemberFindPartyNum;
	*PartyFindMemberNum_Out		= lpPFAckPt->m_cPartyFindMemberNum;

	*lppMemberFindParty_Out		= (LPMemberFindParty)(pBuffer_In + sizeof(PktPFAck));
	*lppPartyFindMember_Out		= (LPPartyFindMember)(pBuffer_In + sizeof(PktPFAck) + (*MemberFindPartyNum_Out * sizeof(MemberFindParty)));

	if (lpPFAckPt->Error() != NoError) {
		return lpPFAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ¾÷±×·¹À̵å [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Àåºñ À§Ä¡[In]
//	Àåºñ À͵¦½º[In]
//	±¤¹° À妽º[In]
//	±¤¹° ¼ö[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharUpgradeItem(DWORD CharID_In, unsigned char MineralNum_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktUgI lpUgIPt = reinterpret_cast<LPPktUgI>(GetSendBuffer());
	lpUgIPt->InitPtHead(sizeof(PktUgI), CmdCharUpgradeItem, 0, 0);	

	lpUgIPt->m_dwCharID			= CharID_In;
	lpUgIPt->m_cMineralNum		= MineralNum_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ¾÷±×·¹À̵å [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Àåºñ À§Ä¡[Out]
//	Àåºñ À͵¦½º[Out]
//	±¤¹° À妽º[Out]
//	±¤¹° ¼ö[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharUpgradeItem(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Size_Out, char **lppBuffer_Out)
{
	LPPktUgIAck lpUgIAckPt = (LPPktUgIAck)pBuffer_In;

	if(lpUgIAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpUgIAckPt->m_dwCharID;
	
	*Size_Out			= lpUgIAckPt->m_cSize;
	if(lpUgIAckPt->m_cSize > 0)
	{
		*lppBuffer_Out	= (char *)(pBuffer_In + sizeof(PktUgIAck));
	}

	if(lpUgIAckPt->Error() != NoError)
		return lpUgIAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ HP ¸®Á¨ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	HP Áõ°¡·®[Out]
//	MP Áõ°¡·®[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharHPRegen(char *pBuffer_In, DWORD *CharID_Out, unsigned short *HP_Out, unsigned short *MP_Out)
{
	LPPktHP lpHPPt = (LPPktHP)pBuffer_In;

	if(lpHPPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpHPPt->m_dwCharID;
	
	*HP_Out				= lpHPPt->m_sHP;
	*MP_Out				= lpHPPt->m_sMP;
		
	if(lpHPPt->Error() != NoError)
		return lpHPPt->Error();

	return NoError;
}


//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·¹º§¾÷ Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	·¹º§[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharLevelUpInfo(DWORD CharID_In, unsigned char Level_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktLUInfo), CmdCharLevelUpInfo, 0, 0);
	LPPktLUInfo lpLUInfoPt = reinterpret_cast<LPPktLUInfo>(lpBuffer->GetBuf());
	
	lpLUInfoPt->m_dwCharID	= CharID_In;
	lpLUInfoPt->m_cLevel	= Level_In;

	lpBuffer->WrapPacket(true);

//	if(!UDPSendList(lpBuffer->GetWSABuf(), m_ClientList))
	if(!UDPSendList(lpBuffer->GetWSABuf(), m_InstanceClientList))
	{
		lpBuffer->Release();
		DeleteInstanceUDPList();
		return false;
	}
	DeleteInstanceUDPList();

	if(!UDPSendList(lpBuffer->GetWSABuf(), m_PartyList))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ·¹º§¾÷ Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	·¹º§[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharLevelUpInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Level_Out)
{
	LPPktLUInfo lpLUInfoPt = (LPPktLUInfo)pBuffer_In;

	if(lpLUInfoPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpLUInfoPt->m_dwCharID;
	*Level_Out			= lpLUInfoPt->m_cLevel;
		
	if(lpLUInfoPt->Error() != NoError)
		return lpLUInfoPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸í¼º(°øÇåµµ) Á¤º¸ ¿äû [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Á¤º¸ Á¾·ù[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharFameInfo(DWORD CharID_In, unsigned char Cmd_In)
{
	if (m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktFI lpFIPt = reinterpret_cast<LPPktFI>(GetSendBuffer());
	lpFIPt->InitPtHead(sizeof(PktFI), CmdCharFameInfo, 0, 0);	

	lpFIPt->m_dwCharID		= CharID_In;
	lpFIPt->m_cInfoKind     = Cmd_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¸í¼º(°øÇåµµ) Á¤º¸ ¿äû [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Á¤º¸ Á¾·ù[Out]
//	ÇöÀç ¸í¼º[Out]
//	Á¾Á·º° ¼øÀ§[Out]
//	Ŭ·¡½ºº° ¼øÀ§[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharFameInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *Cmd_Out, 
									   unsigned long *FameOrMerits_Out, unsigned char *RankingByRace_Out, unsigned char *RankingByClass_Out)
{
	LPPktFIAck lpFIAckPt = (LPPktFIAck)pBuffer_In;

	if (lpFIAckPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out				= lpFIAckPt->m_dwCharID;
	*Cmd_Out				= lpFIAckPt->m_cInfoKind;
	*FameOrMerits_Out		= lpFIAckPt->m_dwFameOrMerits;
	*RankingByRace_Out		= lpFIAckPt->m_cRankingByRace;
	*RankingByClass_Out		= lpFIAckPt->m_cRankingByClass;

	if (lpFIAckPt->Error() != NoError) {
		return lpFIAckPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó °³¼³ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	³ëÁ¡»ó À̸§[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharStallOpen(DWORD CharID_In, char* StallName_In)
{
	if (NULL == m_TCPSocket) {
		return false;
	}

	LPPktStO lpStOPt = reinterpret_cast<LPPktStO>(GetSendBuffer());
	lpStOPt->InitPtHead(sizeof(PktStO), CmdCharStallOpen, 0, 0);	

	lpStOPt->m_dwCharID = CharID_In;
	strncpy(lpStOPt->m_StallName, StallName_In, PktStO::MAX_STALL_NAME_LEN);

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó °³¼³ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	³ëÁ¡»ó À̸§[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharStallOpen(char *pBuffer_In, DWORD *CharID_Out, char* StallName_Out)
{
	LPPktStO lpStOPt = (LPPktStO)pBuffer_In;

	if (NULL == lpStOPt) {
		return WrongParameter;
	}

	*CharID_Out = lpStOPt->m_dwCharID;
	strncpy(StallName_Out, lpStOPt->m_StallName, PktStO::MAX_STALL_NAME_LEN);

	if (lpStOPt->Error() != NoError) {
		return lpStOPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó ¾ÆÀÌÅÛ µî·Ï [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Å×ÀÌÅ© ±¸Á¶Ã¼[In]
//	°¡°Ý[In]
//	¸í·É[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharStallRegisterItem(DWORD CharID_In, TakeType TakeType_In, unsigned long Price_In, unsigned char Cmd_In)
{
	if (NULL == m_TCPSocket || 0 == CharID_In) {
		return false;
	}

	LPPktStRI lpStRIPt = reinterpret_cast<LPPktStRI>(GetSendBuffer());
	lpStRIPt->InitPtHead(sizeof(PktStRI), CmdCharStallRegisterItem, 0, 0);	

	lpStRIPt->m_dwCharID	= CharID_In;
	lpStRIPt->m_TakeType	= TakeType_In;
	lpStRIPt->m_dwPrice		= Price_In;
	lpStRIPt->m_cCmd		= Cmd_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó ¾ÆÀÌÅÛ µî·Ï [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Å×ÀÌÅ© ±¸Á¶Ã¼[Out]
//	°¡°Ý[Out]
//	¸í·É[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharStallRegisterItem(char *pBuffer_In, DWORD *CharID_Out, 
												TakeType *TakeType_Out, unsigned long *Price_Out, unsigned char *Cmd_Out)
{
	LPPktStRI lpStRIPt = (LPPktStRI)pBuffer_In;

	if (NULL == lpStRIPt) {
		return WrongParameter;
	}

	*CharID_Out		= lpStRIPt->m_dwCharID;
	*TakeType_Out	= lpStRIPt->m_TakeType;
	*Price_Out		= lpStRIPt->m_dwPrice;
	*Cmd_Out		= lpStRIPt->m_cCmd;

	if (lpStRIPt->Error() != NoError) {
		return lpStRIPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó ÀÔÀå [ public ]
//
// Parameter :
//	¼Õ´Ô ¾ÆÀ̵ð[In]
//	ÁÖÀÎ ¾ÆÀ̵ð[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharStallEnter(DWORD CustomerID_In, DWORD Owner_In)
{
	if (NULL == m_TCPSocket || 0 == CustomerID_In) {
		return false;
	}

	LPPktStE lpStEPt = reinterpret_cast<LPPktStE>(GetSendBuffer());
	lpStEPt->InitPtHead(sizeof(PktStE), CmdCharStallEnter, 0, 0);	

	lpStEPt->m_dwCustomerID	= CustomerID_In;
	lpStEPt->m_dwOwnerID	= Owner_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó ÀÔÀå [ public ]
//
// Parameter :
//	¼Õ´Ô ¾ÆÀ̵ð[Out]
//	ÁÖÀÎ ¾ÆÀ̵ð[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharStallEnter(char *pBuffer_In, DWORD *CustomerID_Out, DWORD *Owner_Out)
{
	LPPktStE lpStEPt = (LPPktStE)pBuffer_In;

	if (NULL == lpStEPt) {
		return WrongParameter;
	}

	*CustomerID_Out	= lpStEPt->m_dwCustomerID;
	*Owner_Out		= lpStEPt->m_dwOwnerID;

	if (lpStEPt->Error() != NoError) {
		return lpStEPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ³ëÁ¡»ó ¾ÆÀÌÅÛ Á¤º¸ [ public ]
//
// Parameter :
//	³ëÁ¡»ó ¾ÆÀÌÅÛ »çÀÌÁî[Out]
//	³ëÁ¡»ó ¾ÆÀÌÅÛ ¹öÆÛ[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharStallItemInfo(char *pBuffer_In, unsigned long *StallSize_Out, char **lppStallBuff_Out, 
											unsigned short *ItemNum_Out, unsigned long **StallPrice_Out)
{
	LPPktStIInfo lpPktStIInfo = (LPPktStIInfo)pBuffer_In;
	
	if (lpPktStIInfo == NULL) {
		return WrongParameter;
	}

	*StallSize_Out = lpPktStIInfo->m_dwItemSize;
	*lppStallBuff_Out = pBuffer_In + sizeof(PktStIInfo);
	*ItemNum_Out = lpPktStIInfo->m_wItemNum;
	*StallPrice_Out = reinterpret_cast<unsigned long*>(pBuffer_In + sizeof(PktStIInfo) + lpPktStIInfo->m_dwItemSize);

	if (lpPktStIInfo->Error() != NoError) {
		return lpPktStIInfo->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅà ¾ÆÀÌÅÛ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[In]
//	Å×ÀÌÅ© ±¸Á¶Ã¼[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSplitItem(DWORD CharID_In, TakeType &TakeType_In)
{
	if(m_TCPSocket == NULL || CharID_In == 0)
		return false;

	LPPktSplt lpSpltPt = reinterpret_cast<LPPktSplt>(GetSendBuffer());
	lpSpltPt->InitPtHead(sizeof(PktSplt), CmdCharSplitItem, 0, 0);	

	lpSpltPt->m_dwCharID			= CharID_In;
	lpSpltPt->m_TakeType			= TakeType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ½ºÅØ ¾ÆÀÌÅÛ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð[Out]
//	Å×ÀÌÅ© ±¸Á¶Ã¼[Out]
//	¾ÆÀÌÅÛ ±¸Á¶Ã¼ »çÀÌÁî[Out]
//	¾ÆÀÌÅÛ ±¸Á¶Ã¼[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSplitItem(char *pBuffer_In, DWORD *CharID_Out, LPTakeType lpTakeType_Out, unsigned char *Size_Out, char **lppBuffer_Out)
{
	LPPktSpItAck lpSpltAckPt = (LPPktSpItAck)pBuffer_In;

	if(lpSpltAckPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpSpltAckPt->m_dwCharID;
	*lpTakeType_Out		= lpSpltAckPt->m_TakeType;

	*Size_Out			= lpSpltAckPt->m_cSize;
	if(lpSpltAckPt->m_cSize > 0)
	{
		*lppBuffer_Out	= (char *)(pBuffer_In + sizeof(PktSpItAck));
	}

	if(lpSpltAckPt->Error() != NoError)
		return lpSpltAckPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Äü ½½·Ô À̵¿ [ public ]
//
// Parameter :
//	À̵¿[In]
//	½ºÅ³ ·¹º§[In]
//	½ºÅ³ ¶ô Ä«¿îÆ®[In]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharQuickSlotMove(TakeType &TakeType_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktQSM lpQSMPt = reinterpret_cast<LPPktQSM>(GetSendBuffer());
	lpQSMPt->InitPtHead(sizeof(PktQSM), CmdCharQuickSlotMove, 0, 0);	

    lpQSMPt->m_TakeType	= TakeType_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ Äü ½½·Ô À̵¿ [ public ]
//
// Parameter :
//	À̵¿[Out]
//	½ºÅ³ ·¹º§[Out]
//	½ºÅ³ ¶ô Ä«¿îÆ®[Out]
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharQuickSlotMove(char *pBuffer_In, LPTakeType lpTakeType_Out)
{
	LPPktQSM lpQSMPt = (LPPktQSM)pBuffer_In;

	if(lpQSMPt == NULL)
		return WrongParameter;

	*lpTakeType_Out		= lpQSMPt->m_TakeType;

	if(lpQSMPt->Error() != NoError)
		return lpQSMPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼Õ ¹Ù²Ù±â [ public ]
//
// Parameter :
//	¼±Åà ¼Õ[In]		( 1 = ¹«±â1 & ¹æÆÐ1,	2 = ¹«±â2 & ¹æÆÐ2 ) 
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharSwitchHand(unsigned char SelectHand_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktSwH lpSwHPt = reinterpret_cast<LPPktSwH>(GetSendBuffer());
	lpSwHPt->InitPtHead(sizeof(PktSwH), CmdCharSwitchHand, 0, 0);	

	lpSwHPt->m_cSelect	= SelectHand_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼Õ ¹Ù²Ù±â [ public ]
//
// Parameter :
//	¼±Åà ¼Õ[Out]	( 1 = ¹«±â1 & ¹æÆÐ1,	2 = ¹«±â2 & ¹æÆÐ2 ) 
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSwitchHand(char *pBuffer_In, unsigned char *SelectHand_Out)
{
	LPPktSwH lpSwHPt = (LPPktSwH)pBuffer_In;

	if(lpSwHPt == NULL)
		return WrongParameter;

	*SelectHand_Out		= lpSwHPt->m_cSelect;

	if(lpSwHPt->Error() != NoError)
		return lpSwHPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ´Ù·ç±â(º¹¼ö) [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	Áý±â ¼ýÀÚ
//	Áý±â Æ÷ÀÎÅÍ
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharTakeItems(unsigned long CharID_In, unsigned char TakeNum_In, LPTakeType lpTakeTypes_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktTIs lpTIsPt = reinterpret_cast<LPPktTIs>(GetSendBuffer());
	lpTIsPt->InitPtHead(sizeof(PktTIs) + sizeof(TakeType) * TakeNum_In, CmdCharTakeItems, 0, 0);	

	lpTIsPt->m_dwCharID	= CharID_In;
	lpTIsPt->m_TakeNum	= TakeNum_In;
	CopyMemory(GetSendBuffer() + sizeof(PktTIs), lpTakeTypes_In, sizeof(TakeType) * TakeNum_In);

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ´Ù·ç±â(º¹¼ö) [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	Áý±â ¼ýÀÚ
//	Áý±â Æ÷ÀÎÅÍ
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharTakeItems(char *pBuffer_In, unsigned long *CharID_Out, unsigned char *TakeNum_Out, LPTakeType *lppTakeTypes_Out)
{
	LPPktTIs lpTIsPt = (LPPktTIs)pBuffer_In;

	if(lpTIsPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpTIsPt->m_dwCharID;
	*TakeNum_Out		= lpTIsPt->m_TakeNum;
	*lppTakeTypes_Out	= (LPTakeType)(pBuffer_In + sizeof(PktTIs));

	if(lpTIsPt->Error() != NoError)
		return lpTIsPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// µ· ´Ù·ç±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	¼Ò½º À§Ä¡
//	¸ñÀû À§Ä¡
//	µ·
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharTakeGold(DWORD CharID_In, unsigned char SrcPos_In, unsigned char DstPos_In, DWORD Gold_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktTG lpTGPt = reinterpret_cast<LPPktTG>(GetSendBuffer());
	lpTGPt->InitPtHead(sizeof(PktTG), CmdCharTakeGold, 0, 0);	

	lpTGPt->m_dwCharID	= CharID_In;
	lpTGPt->m_cSrcPos	= SrcPos_In;
	lpTGPt->m_cDstPos	= DstPos_In;
	lpTGPt->m_dwGold	= Gold_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// µ· ´Ù·ç±â [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	¼Ò½º À§Ä¡
//	¸ñÀû À§Ä¡
//	µ·
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharTakeGold(char *pBuffer_In, unsigned long *CharID_Out, unsigned char *SrcPos_Out, unsigned char *DstPos_Out, DWORD *Gold_Out)
{
	LPPktTG lpTGPt = (LPPktTG)pBuffer_In;

	if(lpTGPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpTGPt->m_dwCharID;
	*SrcPos_Out			= lpTGPt->m_cSrcPos;
	*DstPos_Out			= lpTGPt->m_cDstPos;
	*Gold_Out			= lpTGPt->m_dwGold;

	if(lpTGPt->Error() != NoError)
		return lpTGPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ±³È¯ ¸í·É [ public ]
//
// Parameter :
//	º¸³»´ÂÀÌ ¾ÆÀ̵ð
//	¹Þ´ÂÀÌ ¾ÆÀ̵ð
//	¸í·É
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharExchangeCmd(DWORD SenderID_In, DWORD RecverID_In, unsigned char Cmd_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktExC lpExCPt = reinterpret_cast<LPPktExC>(GetSendBuffer());
	lpExCPt->InitPtHead(sizeof(PktExC), CmdCharExchangeCmd, 0, 0);	

	lpExCPt->m_dwSenderID	= SenderID_In;
	lpExCPt->m_dwRecverID	= RecverID_In;
	lpExCPt->m_cCmd			= Cmd_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ±³È¯ ¸í·É [ public ]
//
// Parameter :
//	º¸³»´ÂÀÌ ¾ÆÀ̵ð
//	¹Þ´ÂÀÌ ¾ÆÀ̵ð
//	¸í·É
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharExchangeCmd(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, unsigned char *Cmd_Out)
{
	LPPktExC lpExCPt = (LPPktExC)pBuffer_In;

	if(lpExCPt == NULL)
		return WrongParameter;

	*SenderID_Out		= lpExCPt->m_dwSenderID;
	*RecverID_Out		= lpExCPt->m_dwRecverID;
	*Cmd_Out			= lpExCPt->m_cCmd;

	if(lpExCPt->Error() != NoError)
		return lpExCPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¾ÆÀÌÅÛ ±³È¯ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	À妽º
//	¾ÆÀÌÅÛ »çÀÌÁî
//	¾ÆÀÌÅÛ ¹öÆÛ
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharExchangeItem(char *pBuffer_In, DWORD *CharID_Out, DWORD *Size_Out, Item::ItemPos* lpIndex_Out, unsigned char *Type_Out, unsigned char *Num_Out, char **lppBuffer_Out)
{
	LPPktExI lpExIPt = (LPPktExI)pBuffer_In;

	if(lpExIPt == NULL)
		return WrongParameter;

	*CharID_Out			= lpExIPt->m_dwCharID;
	*Size_Out			= lpExIPt->m_dwSize;
	*lpIndex_Out		= lpExIPt->m_itemPos;
	*Type_Out			= lpExIPt->m_cType;
    *Num_Out            = lpExIPt->m_cNum;

	if(0 == *Size_Out)
	{
		*lppBuffer_Out	= NULL;
	}
	else
	{
		*lppBuffer_Out	= (char *)(pBuffer_In + sizeof(PktExI));
	}

	if(lpExIPt->Error() != NoError)
		return lpExIPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¼¿ ºê·Îµå ij½ºÆà [ public ]
//
// Parameter :
//	¹öÆÛ
//	ij¸¯ÅÍ ¼ýÀÚ
//	ÁÖ¼Ò Á¤º¸
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCellBroadCasting(char *pBuffer_In, unsigned short *CharNum_Out, LPAddressInfo *lppAddress_Out)
{
	LPPktCB lpCBPt = (LPPktCB)pBuffer_In;

	if(lpCBPt == NULL)
		return WrongParameter;

	*CharNum_Out		= lpCBPt->m_sCharNum;

	if(0 == *CharNum_Out)
	{
		*lppAddress_Out	= NULL;
	}
	else
	{
		*lppAddress_Out	= reinterpret_cast<LPAddressInfo>(pBuffer_In + sizeof(PktCB));
	}

	if(lpCBPt->Error() != NoError)
		return lpCBPt->Error();

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ÆÄƼ µ¥ÀÌÅÍ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	¼­ºê ¸í·É
//	µ¥ÀÌÅÍ ±æÀÌ
//	µ¥ÀÌÅÍ
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharPartyData(DWORD CharID_In, unsigned short Cmd_In, unsigned short Len_In, void *Data_In)
{
	if(m_UDPSocket == NULL || CharID_In == 0)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktPMD) + Len_In, CmdCharPartyMemData, 0, 0);
	LPPktMD lpMDPt = reinterpret_cast<LPPktMD>(lpBuffer->GetBuf());
	
	lpMDPt->m_dwCharID	= CharID_In;
	lpMDPt->m_wCmd		= Cmd_In;
	lpMDPt->m_wLen		= Len_In;

	CopyMemory(lpBuffer->GetBuf() + sizeof(PktMD), Data_In, Len_In);

	lpBuffer->WrapPacket(true);
	UDPSendList(lpBuffer->GetWSABuf(), m_PartyList);
	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿É¼Ç Á¶Á¤ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	°ÅºÎ ¿É¼Ç
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharControlOption(DWORD CharID_In, RejectOption &Reject_In)
{
	if (NULL == m_TCPSocket || 0 == CharID_In) {
		return false;
	}

	LPPktCOp lpCOpPt = reinterpret_cast<LPPktCOp>(GetSendBuffer());
	lpCOpPt->InitPtHead(sizeof(PktCOp), CmdCharControlOption, 0, 0);	

	lpCOpPt->m_dwCharID		= CharID_In;
	lpCOpPt->m_RejectOption	= Reject_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿É¼Ç Á¶Á¤ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	°ÅºÎ ¿É¼Ç
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleControlOption(char *pBuffer_In, DWORD *CharID_Out, LPRejectOption Reject_Out)
{
	LPPktCOp lpCOpPt = (LPPktCOp)pBuffer_In;

	if (NULL == lpCOpPt) {
		return WrongParameter;
	}

	*CharID_Out		= lpCOpPt->m_dwCharID;
	*Reject_Out		= lpCOpPt->m_RejectOption;

	if (lpCOpPt->Error() != NoError) {
		return lpCOpPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// µà¾ó ¸í·É [ public ]
//
// Parameter :
//	º¸³»´ÂÀÌ ¾ÆÀ̵ð
//	¹Þ´ÂÀÌ ¾ÆÀ̵ð
//	¸í·É
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharDuelCmd(DWORD SenderID_In, DWORD RecverID_In, unsigned char Cmd_In)
{
	if(m_TCPSocket == NULL)
		return false;

	LPPktDuC lpDuCPt = reinterpret_cast<LPPktDuC>(GetSendBuffer());
	lpDuCPt->InitPtHead(sizeof(PktDuC), CmdCharDuelCmd, 0, 0);	

	lpDuCPt->m_dwSenderID	= SenderID_In;
	lpDuCPt->m_dwRecverID	= RecverID_In;
	lpDuCPt->m_cCmd			= Cmd_In;

	PutSendBuffer(true);
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// µà¾ó ¸í·É [ public ]
//
// Parameter :
//	º¸³»´ÂÀÌ ¾ÆÀ̵ð
//	¹Þ´ÂÀÌ ¾ÆÀ̵ð
//	¸í·É
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharDuelCmd(char *pBuffer_In, DWORD *SenderID_Out, DWORD *RecverID_Out, unsigned char *Cmd_Out)
{
	LPPktDuC lpDuCPt = (LPPktDuC)pBuffer_In;

	if (lpDuCPt == NULL) {
		return WrongParameter;
	}

	*SenderID_Out		= lpDuCPt->m_dwSenderID;
	*RecverID_Out		= lpDuCPt->m_dwRecverID;
	*Cmd_Out			= lpDuCPt->m_cCmd;

	if (lpDuCPt->Error() != NoError) {
		return lpDuCPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ÆÀ¹èƲ Á¤º¸ ¿äû [ public ]
//
// Parameter :
//	»ó´ë¹æ À̸§
//	»ó´ë ÆÄƼ¿ø ¼ýÀÚ
//	»ó´ë ÆÄƼ¿ø ¾ÆÀ̵ð
//	»ó´ë ÆÄƼ¿ø ·¹º§
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharTeamBattleInfo(char *pBuffer_In, unsigned long *CharID_Out, char *ChallengerName_Out, unsigned char *Cmd_Out, 
											 unsigned char *MemberNum_Out, unsigned long *MemberID_Out, unsigned char *MemberLevel_Out)
{
	LPPktTBInfo lpPktTBInfo = (LPPktTBInfo)pBuffer_In;

	if (lpPktTBInfo == NULL) {
		return WrongParameter;
	}

	*CharID_Out = lpPktTBInfo->m_dwCharID;
	::strncpy(ChallengerName_Out, lpPktTBInfo->m_strChallengerName, CHAR_INFOST::MAX_NAME_LEN);
	*Cmd_Out = lpPktTBInfo->m_cCmd;
	*MemberNum_Out = lpPktTBInfo->m_cMemberNum;

	for (int nIndex = 0; nIndex < *MemberNum_Out; nIndex++)
	{
		MemberID_Out[nIndex] = *(reinterpret_cast<unsigned long *>(pBuffer_In + sizeof(PktTBInfo) + 
			nIndex * (sizeof(unsigned long) + sizeof(unsigned char))));
		MemberLevel_Out[nIndex] = *(reinterpret_cast<unsigned char *>(pBuffer_In + sizeof(PktTBInfo) + 
			nIndex * (sizeof(unsigned long) + sizeof(unsigned char)) + sizeof(unsigned long)));
	}

	if (lpPktTBInfo->Error() != NoError) {
		return lpPktTBInfo->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ÁÖ¹® Á¤º¸ [ public ]
//
// Parameter :
//	ij¸¯ÅÍ ¾ÆÀ̵ð
//	ÁÖ¹® ŸÀÔ
//	ÁÖ¹® ·¹º§
//	On/Off
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharSpellInfo(char *pBuffer_In, DWORD *CharID_Out, unsigned char *SpellType_Out, unsigned short *EnchantLevel_Out, bool *OnOff_Out)
{
	LPPktSpInfo lpSpInfoPt = (LPPktSpInfo)pBuffer_In;

	if (lpSpInfoPt == NULL) {
		return WrongParameter;
	}

	*CharID_Out			= lpSpInfoPt->m_dwCharID;

	*SpellType_Out		= lpSpInfoPt->m_cSpellType;
	*EnchantLevel_Out	= lpSpInfoPt->m_nEnchantLevel;
	*OnOff_Out			= lpSpInfoPt->m_bOnOff;

	if (lpSpInfoPt->Error() != NoError) {
		return lpSpInfoPt->Error();
	}

	return NoError;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// â°í ·Î±×ÀÎ [ public ]
//
// Parameter :
//	Æнº¿öµå
//	Æнº ÀúÀå
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::StoreLogin(char *Password_In, char PassSave_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktDeposit), CmdDeposit, 0);
	PktDeposit* lpDeposit = reinterpret_cast<PktDeposit*>(lpBuffer->GetBuf());

	lpDeposit->m_cCmd = PktDeposit::CMD::LOGIN;
	memcpy(&lpDeposit->m_szData[0], Password_In, Deposit::PASSWORD_LENGTH);
	lpDeposit->m_szData[4] = PassSave_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// â°í ·Î±×¾Æ¿ô [ public ]
//
// Parameter :
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::StoreLogout(void)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktDeposit), CmdDeposit, 0);
	PktDeposit* lpDeposit = reinterpret_cast<PktDeposit*>(lpBuffer->GetBuf());

	lpDeposit->m_cCmd = PktDeposit::CMD::LOGOUT;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ÅÇ ±¸ÀÔ [ public ]
//
// Parameter :
//	»ç¿ë ÅÇ ¹øÈ£
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::StoreBuyTab(char TabNum_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktDeposit), CmdDeposit, 0);
	PktDeposit* lpDeposit = reinterpret_cast<PktDeposit*>(lpBuffer->GetBuf());

	lpDeposit->m_cCmd = PktDeposit::CMD::BUY_TAB;
	lpDeposit->m_szData[0] = TabNum_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// Æнº º¯°æ [ public ]
//
// Parameter :
//	Æнº
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::StoreChangePass(char *Password_In, char *NewPassword_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktDeposit), CmdDeposit, 0);
	PktDeposit* lpDeposit = reinterpret_cast<PktDeposit*>(lpBuffer->GetBuf());

	lpDeposit->m_cCmd = PktDeposit::CMD::CHANGE_PASS;
	memcpy(&lpDeposit->m_szData[0], Password_In, Deposit::PASSWORD_LENGTH);
	memcpy(&lpDeposit->m_szData[4], NewPassword_In, Deposit::PASSWORD_LENGTH);

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ij¸¯ÅÍ ¾îµå¹Î [ public ]
//
// Parameter :
//	Æнº
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
bool ClientSocket::CharAdmin(unsigned short Cmd_In, char* Name_In, char Zone_In, char Channel_In, unsigned short ProtoTypeID, POS& Pos_In)
{
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktAdmin), CmdCharAdminCmd, 0);
	PktAdmin* lpAdmin = reinterpret_cast<PktAdmin*>(lpBuffer->GetBuf());

	lpAdmin->m_usCmd	= Cmd_In;

	memcpy(lpAdmin->m_stName, Name_In, PktAdmin::MAX_NAME_LEN);
	
	if(0 != ProtoTypeID)
	{
		lpAdmin->m_usProtoTypeID		= ProtoTypeID;
	}
	else
	{
		lpAdmin->m_ZoneInfo.m_cZone		= Zone_In;
		lpAdmin->m_ZoneInfo.m_cChannel	= Channel_In;
	}

	lpAdmin->m_Position	= Pos_In;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;

}

DWORD ClientSocket::HandleDeposit(char *pBuffer_In, unsigned char *Cmd_Out, DWORD *Gold_Out, char *PassSave_Out)
{
	PktDeposit* lpDepositPt = (PktDeposit*)pBuffer_In;

	if (lpDepositPt == NULL) {
		return WrongParameter;
	}

	*Cmd_Out = lpDepositPt->m_cCmd;
	
	memcpy(Gold_Out, &lpDepositPt->m_szData[0],  sizeof(DWORD));
	*PassSave_Out = lpDepositPt->m_szData[4];

	if (lpDepositPt->Error() != NoError) {
		return lpDepositPt->Error();
	}

	return NoError;
}


// Ä£±¸ °ü·Ã
bool ClientSocket::CharFriendAddRequest(char* szName_In, PktFriendAddReq::CMD addType)
{
    // Ä£±¸ ¶Ç´Â °ÅºÎ ¸®½ºÆ®¿¡ Ãß°¡ÇÑ´Ù.
	if(m_TCPSocket == NULL)
		return false;

    switch(addType)
    {
    case PktFriendAddReq::ADD_FRIEND_REQ:
    case PktFriendAddReq::BAN_FRIEND_REQ:
        break;

    default:
        return false;
    };

	CPacket* lpBuffer = new CPacket(sizeof(PktFriendAddReq), CmdFriendAddRequest, 0);
	PktFriendAddReq* lpPktFriendAddRequest = reinterpret_cast<PktFriendAddReq*>(lpBuffer->GetBuf());

    memcpy(lpPktFriendAddRequest->m_szName, szName_In, PktFriendAddReq::MAX_NAME);
    lpPktFriendAddRequest->m_cCmd = addType;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

bool ClientSocket::CharFriendRemoveRequest(unsigned long dwCID, PktFriendRemoveReq::CMD removeType)
{
    // Ä£±¸ ¶Ç´Â °ÅºÎ ¸®½ºÆ®¿¡¼­ Á¦°ÅÇÑ´Ù.
	if(m_TCPSocket == NULL)
		return false;

	CPacket* lpBuffer = new CPacket(sizeof(PktFriendRemoveReq), CmdFriendRemoveRequest, 0);
	PktFriendRemoveReq* lpPktFriendRemoveRequest = reinterpret_cast<PktFriendRemoveReq*>(lpBuffer->GetBuf());

    lpPktFriendRemoveRequest->m_cCmd    = removeType;
    lpPktFriendRemoveRequest->m_dwCID   = dwCID;
    
	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
	return true;
}

bool ClientSocket::CharFriendEtcRequest(unsigned long dwCID, unsigned long dwData, PktFriendEtc::CMD etcType)
{
    if(m_TCPSocket == NULL)
        return false;

    switch(etcType)
    {
    case PktFriendEtc::SETGROUP:
        break;

    default:
        return false;
    };

    CPacket* lpBuffer = new CPacket(sizeof(PktFriendEtc), CmdFriendEtcRequest, 0);
    PktFriendEtc* lpPktFriendEtc = reinterpret_cast<PktFriendEtc*>(lpBuffer->GetBuf());

    lpPktFriendEtc->m_dwCID     = dwCID;
    lpPktFriendEtc->m_dwData    = dwData;
    lpPktFriendEtc->m_cCmd      = etcType;

	lpBuffer->WrapPacket(true);
	if(!Send(m_TCPSocket, lpBuffer->GetWSABuf()))
	{
		lpBuffer->Release();
		return false;
	}

	lpBuffer->Release();
    return true;
}

// Ä£±¸ ¸®½ºÆ®, °ÅºÎ ¸®½ºÆ®°¡ ¿Â´Ù.
DWORD ClientSocket::HandleCharFriendDB(char *pBuffer_In, unsigned char* cDataType_Out, char **ppFriendListData_Out, DWORD *dwDataSize_Out)
{
    PktFriendDB* lpPktFriendDB = reinterpret_cast<PktFriendDB*>(pBuffer_In);
    
    switch(lpPktFriendDB->m_cCmd)
    {
    case PktFriendDB::FRIEND_LIST:
    case PktFriendDB::BAN_LIST:

        *cDataType_Out        = lpPktFriendDB->m_cCmd;
        *dwDataSize_Out       = lpPktFriendDB->m_dwData;
        *ppFriendListData_Out = pBuffer_In + sizeof(PktFriendDB);
        break;

    default:
        return 1;
    };

    return lpPktFriendDB->GetError();
}

// °¢ÁÕ Ack°¡ ¿Â´Ù. (Ä£±¸, °ÅºÎÀÇ µî·Ï ¹× Á¦°Å Ack, Ä£±¸ÀÇ ·Î±×ÀÎ, ·Î±×¾Æ¿ô ¿©ºÎ Å뺸)
DWORD ClientSocket::HandleCharFriendAck(char *pBuffer_In, unsigned char* cCmd_Out, DWORD *dwCID_Out)
{
    PktFriendAck* lpPktFriendAck = reinterpret_cast<PktFriendAck*>(pBuffer_In);

    *cCmd_Out   = lpPktFriendAck->m_cCmd;
    *dwCID_Out  = lpPktFriendAck->m_dwCID;

    return lpPktFriendAck->GetError();
}

// ³ª¸¦ Ä£±¸·Î µî·ÏÇÑ »ç¶÷ÀÇ À̸§ÀÌ ¿Â´Ù.
DWORD ClientSocket::HandleCharFriendRegistered(char *pBuffer_In, char* szName_Out)
{
    PktFriendAddReq* lpPktFriendAddRequest = reinterpret_cast<PktFriendAddReq*>(pBuffer_In);    
    memcpy(szName_Out, lpPktFriendAddRequest->m_szName, PktFriendAddReq::MAX_NAME);
    return lpPktFriendAddRequest->GetError();
}

//Interface/////////////////////////////////////////////////////////////////////////////////////
//
// ¿¤¸®Æ® º¸³Ê½º [ public ]
//
// Parameter :
//	±¹°¡
//	º¸³Ê½º ·¹º§
//
// Return :
//	ÆÐŶ »ý¼º ÈÄ º¸³»±â ¼º°ø½Ã true, ½ÇÆнà false
//
///////////////////////////////////////////////////////////////////////////////////////////////
DWORD ClientSocket::HandleCharEliteBonus(char *pBuffer_In, char *Nation_Out, unsigned char *Level_Out)
{
	LPPktEB lpEBPt = (LPPktEB)pBuffer_In;

	if (lpEBPt == NULL) {
		return WrongParameter;
	}

	*Nation_Out		= lpEBPt->m_EliteBonus.m_cNation;
	*Level_Out		= lpEBPt->m_EliteBonus.m_cLevel;

	if (lpEBPt->Error() != NoError) {
		return lpEBPt->Error();
	}

	return NoError;
}