#include <stdexcept>
#include <ctime>

#include <network/IConnection.h>
#include <network/XIOCPConnection.h>
#include <mmo/ArRegion.h>
#include <toolkit/XEnv.h>
#include <toolkit/bits_scramble.h>
#include <toolkit/XConsole.h>
#include <mmo/ArcadiaServer.h>
#include <toolkit/XQuadScanner.h>
#include <toolkit/XStringUtil.h>
#include <toolkit/KHash.h>

#include "LogClient/LogClient.h"
#include "ErrorCode/ErrorCode.h"

#include "GameMessage.h"
#include "LUAVM.h"
#include "SendMessage.h"
#include "GameContent.h"
#include "StructPlayer.h"
#include "StructSkill.h"
#include "StructNPC.h"
#include "StructMonster.h"
#include "StructSummon.h"
#include "StructPet.h"
#include "StructFieldProp.h"
#include "DB_Commands.h"
#include "StructItem.h"
#include "PartyManager.h"
#include "GuildManager.h"
#include "DungeonManager.h"
#include "RankingManager.h"
#include "StructWorldLocation.h"
#include "StructSkillProp.h"
#include "ThreadPlayerHelper.h"


extern volatile LONG													g_nSendMessageCount;
extern volatile LONG													g_nSendMessageByte;
extern IStreamSocketConnection	*										g_pAuthConnection;
extern IStreamSocketConnection	*										g_pUploadConnection;
extern IStreamSocketConnection	*										g_pCoordinatorConnection;
extern bool																g_bUseMessageStatistics;

struct MessagingInfo
{
	unsigned short	msg_id;
	__int64			total_size;
	int				count;
};

struct MessageLogger : ArSchedulerObject
{
public:
	MessageLogger()
		: m_nLastLogTime( GetArTime() )
		, m_csLock( "MessageLogger::m_csLock" )
	{
	}

	void Init()
	{
		ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_LOW );
	}

	void DeInit()
	{
		ArcadiaServer::Instance().SetObjectPriority( this, ArSchedulerObject::UPDATE_PRIORITY_NULL );
	}

	void SetMessagingInfo( unsigned short msg_id, __int64 msg_size, bool bIsSendMessage )
	{
		if( !g_bUseMessageStatistics )
			return;

		THREAD_SYNCRONIZE( m_csLock );

		std::vector< MessagingInfo > * pvInfo = &m_vSendInfo;

		if( !bIsSendMessage )
		{
			pvInfo = &m_vRecvInfo;
		}

		for( std::vector< MessagingInfo >::iterator it = pvInfo->begin(); it != pvInfo->end(); ++it )
		{
			if( (*it).msg_id == msg_id )
			{
				++(*it).count;
				(*it).total_size += msg_size;

				return;
			}
		}

		MessagingInfo _info;

		_info.msg_id = msg_id;
		_info.total_size = msg_size;
		_info.count = 1;

		pvInfo->push_back( _info );
	}

	void LogMessagingInfo()
	{
		if( !g_bUseMessageStatistics )
			return;

		std::string strLog;
		char buf[256];

		THREAD_SYNCRONIZE( m_csLock );

		strLog = "\r\n::Send Messaging Info::\r\n";

		for( std::vector< MessagingInfo >::iterator it = m_vSendInfo.begin(); it != m_vSendInfo.end(); ++it )
		{
			s_sprintf( buf, _countof( buf ), "%5u\t%20I64d\t%10d\r\n", (*it).msg_id, (*it).total_size, (*it).count );
			strLog += buf;
		}

		strLog += "\r\n::Recv Messaging Info::\r\n";

		for( std::vector< MessagingInfo >::iterator it = m_vRecvInfo.begin(); it != m_vRecvInfo.end(); ++it )
		{
			s_sprintf( buf, _countof( buf ), "%5u\t%20I64d\t%10d\r\n", (*it).msg_id, (*it).total_size, (*it).count );
			strLog += buf;
		}

		strLog += "\r\n\r\n";

		FileLogHandler::GetFileLogHandler()->LogStringEx( NULL, "MessagingLog", strLog.c_str() );

		m_vSendInfo.clear();
		m_vRecvInfo.clear();
	};

	virtual void onProcess( int nThreadNum )
	{
		char buf[255];
		s_sprintf( buf, _countof( buf ), "thread.scheduler.%d.proc", nThreadNum );
		ENV().Set( buf, "MessageLogger" );

		if( !g_bUseMessageStatistics )
			return;

		AR_TIME t = GetArTime();

		if( m_nLastLogTime + LOG_PERIOD < t )
		{
			m_nLastLogTime = t;

			LogMessagingInfo();
		}
	}

private:
	static const AR_TIME			LOG_PERIOD		= 60000;
	XCriticalSection				m_csLock;
	std::vector< MessagingInfo >	m_vSendInfo;
	std::vector< MessagingInfo >	m_vRecvInfo;
	AR_TIME							m_nLastLogTime;
};

MessageLogger g_MessageLogger;

void InitMessageLogger()
{
	g_MessageLogger.Init();
}

void DeInitMessageLogger()
{
	g_MessageLogger.DeInit();
}

void SetMessagingInfo( unsigned short msg_id, __int64 msg_size, bool bIsSendMessage )
{
	g_MessageLogger.SetMessagingInfo( msg_id, msg_size, bIsSendMessage );
}

// 타임싱크
void SendTimeSync( StructPlayer * pPlayer )
{
	TS_TIMESYNC	msg;
	msg.time =  GetArTime();
	PendMessage( pPlayer, &msg );

#ifdef TIME_DEBUG
	_cprint( "SND : TM_TIMESYNC (%d)\n", msg.time );
#endif
}

void fillItemBaseInfo( TS_ITEM_BASE_INFO *pInfo, StructItem * pItem )
{
	pInfo->Code						= pItem->GetItemCode();
	pInfo->count					= pItem->GetCount();
	pInfo->Flag						= *pItem->GetInstanceFlag().GetRawData();
	pInfo->handle					= pItem->GetHandle();
	pInfo->ethereal_durability		= pItem->GetCurrentEtherealDurability();
	pInfo->endurance				= pItem->GetCurrentEndurance();
	pInfo->enhance					= pItem->GetItemEnhance();
	pInfo->level					= pItem->GetItemLevel();
	pInfo->uid						= pItem->GetItemUID();
	pInfo->enhance_chance			= pItem->GetItemEnhanceChance();
	pInfo->nAdditionalItemEffect	= pItem->GetItemAdditionalEffect();	// Fraun Sky Accessories 7/12/2025

	if( pItem->IsExpireItem() )
		pInfo->remain_time	= pItem->GetExpireTime() - time( NULL );
	else
		pInfo->remain_time	= 0;

	for( unsigned i = 0; i < ItemBase::MAX_SOCKET_NUMBER; ++i )
	{
		pInfo->socket[i]	= pItem->GetSocketCode( i );
	}

	time_t tCurrent = time( NULL );

	if( pItem->GetElementalEffectType() && ( !pItem->GetElementalEffectExpireTime() || pItem->GetElementalEffectExpireTime() > tCurrent ) )
	{
		pInfo->elemental_effect_remain_time = pItem->GetElementalEffectExpireTime() ? pItem->GetElementalEffectExpireTime() - tCurrent : -1;
		pInfo->elemental_effect_type = pItem->GetElementalEffectType();
		pInfo->elemental_effect_attack_point = pItem->GetElementalEffectAttackPoint();
		pInfo->elemental_effect_magic_point = pItem->GetElementalEffectMagicPoint();
	}
	else
	{
		pInfo->elemental_effect_remain_time = 0;
		pInfo->elemental_effect_type = Elemental::TYPE_NONE;
		pInfo->elemental_effect_attack_point = 0;
		pInfo->elemental_effect_magic_point = 0;
	}

	pInfo->appearance_code = pItem->GetAppearanceCode();

	for( int nCnt = 0 ; nCnt < ItemInstance::MAX_AWAKEN_NUMBER ; ++nCnt )
	{
		pInfo->awakenoption.nValue1[nCnt] = pItem->GetAwakenOptionValue1( nCnt );
		pInfo->awakenoption.nValue2[nCnt] = pItem->GetAwakenOptionValue2( nCnt );
	}

	for( int nCnt = 0 ; nCnt < ItemInstance::MAX_RANDOM_OPTION_NUMBER ; ++nCnt )
	{
		pInfo->random_option.nType[nCnt] = pItem->GetIdentifiedOptionType( nCnt );
		pInfo->random_option.fValue1[nCnt] = pItem->GetIdentifiedOptionValue1( nCnt );
		pInfo->random_option.fValue2[nCnt] = pItem->GetIdentifiedOptionValue2( nCnt );
	}

	if( pItem->IsSummonCard() )
	{
		StructSummon * pSummon = pItem->GetSummonStruct();

		if( pSummon )
		{
			int depth = pSummon->GetTransformLevel();
			int i;
			for( i = 0; i < depth - 1; ++i )
			{
				pInfo->socket[i + 1] = pSummon->GetPrevJobLevel( i );
			}
			pInfo->socket[i + 1] = pSummon->GetLevel();
		}
	}

	pInfo->summon_code = pItem->GetSummonCode();
}

void fillItemInfo( TS_ITEM_INFO *pInfo, StructItem *pItem )
{
	fillItemBaseInfo( pInfo, pItem );

	pInfo->wear_position = pItem->GetWearInfo();

	pInfo->own_summon_handle = 0;

	if( pItem->GetOwnSummonUID() > 0 )
	{
		pInfo->own_summon_handle = pItem->GetOwnSummonHandle();

	}

	if( pItem->IsInStorage() )
	{
		pInfo->wear_position = -2;
	}

	pInfo->index = pItem->GetIdx();
}

void SendDropResult( struct StructPlayer * pClient, AR_HANDLE ItemHandle, bool bIsSuccess )
{
	TS_SC_DROP_RESULT msg;
	msg.item_handle = ItemHandle;
	msg.isAccepted = bIsSuccess;
	PendMessage( pClient, &msg );
}

void SendTakeResult( struct StructPlayer * pClient, struct StructItem *pItem )
{
	/*
	TS_SC_TAKE_RESULT msg;
	fillItemInfo( &msg.item_info, pItem );
	PendMessage( pClient, &msg );
	*/
}


static void pendMessage( struct IStreamSocketConnection *pConn, const struct TS_MESSAGE * pMessage )
{
	if( !pConn ) return;

	TS_MESSAGE* temp = const_cast< TS_MESSAGE* >( pMessage );
	temp->set_check_sum();

	InterlockedIncrement( &g_nSendMessageCount );
	InterlockedExchangeAdd( &g_nSendMessageByte, pMessage->size );

	SetMessagingInfo( pMessage->id, pMessage->size, true );

	int nSize = pConn->Write( pMessage, pMessage->size );
	
	if( nSize != pMessage->size ) 
	{
		//assert( 0 );
		return;
	}
}

static void pendStream( struct IStreamSocketConnection *pConn, const void *pBuffer, unsigned size )
{
	if( !pConn ) return;

	InterlockedIncrement( &g_nSendMessageCount );
	InterlockedExchangeAdd( &g_nSendMessageByte, size );

	const struct TS_MESSAGE * pMessage = static_cast< const struct TS_MESSAGE * >( pBuffer );

	SetMessagingInfo( pMessage->id, pMessage->size, true );

	int nSize = pConn->Write( pBuffer, size );
	
	if( nSize != size ) 
	{
		//assert( 0 );
		return;
	}
}

static void pendString( struct IStreamSocketConnection *pConn, const char *szString, size_t nLength )
{
	if( !pConn ) return;
	int nSize = pConn->Write( szString, nLength );
}

void PendMessage( struct IStreamSocketConnection *pConn, const struct TS_MESSAGE * pMessage )
{
	//if( LockIOCPConnection( pConn ) )
	{
		pendMessage( pConn, pMessage );
		//UnLockIOCPConnection( pConn );
	}
}

void PendMessage( const struct ArObject *pObj, const struct TS_MESSAGE * pMessage )
{
	if( static_cast< const GameObject * >(pObj)->IsPlayer() && static_cast< const StructPlayer* >( pObj )->pConnection && static_cast< const StructPlayer* >( pObj )->pConnection->IsConnected() )
	{
		pendMessage( static_cast< const StructPlayer* >( pObj )->pConnection, pMessage );
	}
}

void PendStream( const struct ArObject *pObj, const void *pBuffer, unsigned size )
{
	if( static_cast< const GameObject * >(pObj)->IsPlayer() && static_cast< const StructPlayer* >( pObj )->pConnection && static_cast< const StructPlayer* >( pObj )->pConnection->IsConnected() )
	{
		pendStream(	static_cast< const StructPlayer* >( pObj )->pConnection, pBuffer, size );
	}
}

void PendString( struct IStreamSocketConnection *pConnection, const char *szStr )
{
	pendString( pConnection, szStr, strlen( szStr ) );
}

void SendResult( const struct ArObject *pObj, unsigned short msg, unsigned short result, int value )
{
	if( static_cast< const GameObject * >(pObj)->IsPlayer() && static_cast< const StructPlayer* >( pObj )->pConnection && static_cast< const StructPlayer* >( pObj )->pConnection->IsConnected() )
	{
		pendMessage( static_cast< const StructPlayer* >( pObj )->pConnection, &TS_SC_RESULT( msg, result, value ) );
	}
}

void SendResult( IStreamSocketConnection *pConnection, unsigned short msg, unsigned short result, int value )
{
	//if( LockIOCPConnection( pConnection ) )
	if( pConnection && pConnection->IsConnected() )
	{
		pendMessage( pConnection, &TS_SC_RESULT( msg, result, value ) );
		//UnLockIOCPConnection( pConnection );
	}
}

void PrintfChatMessage( bool bLock, int nChatType, const char *szSenderName, struct StructPlayer *pTarget, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendChatMessage( bLock, nChatType, szSenderName, pTarget, szBuf, (unsigned)strlen( szBuf ) );
}

void SendSelfChatMessage( int nChatType, const char *szSenderName, struct StructPlayer *pTarget, const char *szString, unsigned len )
{
	SendChatMessage( false, nChatType, szSenderName,pTarget->GetHandle(), szString, len );
}

/*
void PrintfChatMessage( const char *szSenderName, struct StructPlayer *pTarget, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendChatMessage( false, szSenderName, pTarget, szBuf );
}*/

void SendQuestMessage( int nChatType, struct StructPlayer *pTarget, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendChatMessage( true, nChatType, "@QUEST", pTarget, szBuf );
}

void PrintfGlobalChatMessage( int nChatType, const char *szSenderName, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendGlobalChatMessage( nChatType, szSenderName, szBuf );
}

void SendPartyChatMessage( int nChatType, const char *szSender, int nPartyID, const char *szString, unsigned len )
{
	struct myPartyFunctor : PartyManager::PartyFunctor
	{
		myPartyFunctor( const char *s, const char *p, int t ) : szSender( s ), pString( p ), nChatType( t ) {}

		virtual bool operator()( AR_HANDLE handle )
		{
			SendChatMessage( false, nChatType, szSender, handle, pString );

			return true;
		}
		int nChatType;
		const char *szSender;
		const char *pString;
	} _fo( szSender, szString, nChatType );

	PartyManager::GetInstance().DoEachMember( nPartyID, _fo );
}

void SendPartyChatMessage( const char *szSender, int nPartyID, const char *szString, unsigned len )
{
	SendPartyChatMessage( CHAT_PARTY, szSender, nPartyID, szString, len );
}

void PrintfPartyChatMessage( int nChatType, int nPartyID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendPartyChatMessage( nChatType, "@PARTY", nPartyID, szBuf );
}

void PrintfPartyChatMessage( int nPartyID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendPartyChatMessage( "@PARTY", nPartyID, szBuf );
}

void SendGuildChatMessage( int nChatType, const char *szSender, int nGuildID, const char *szString, unsigned len )
{
	struct myGuildFunctor : GuildManager::GuildFunctor
	{
		myGuildFunctor( const char *s, const char *p, int t ) : szSender( s ), pString( p ), nChatType( t ) {}

		virtual bool operator()( AR_HANDLE handle )
		{
			SendChatMessage( false, nChatType, szSender, handle, pString );

			return true;
		}
		int nChatType;
		const char *szSender;
		const char *pString;
	} _fo( szSender, szString, nChatType );

	GuildManager::GetInstance().DoEachMember( nGuildID, _fo );
}

void SendGuildChatMessage( const char *szSender, int nGuildID, const char *szString, unsigned len )
{
	SendGuildChatMessage( CHAT_GUILD, szSender, nGuildID, szString, len );
}

void PrintfGuildChatMessage( int nChatType, const char * szSender, int nGuildID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendGuildChatMessage( nChatType, szSender, nGuildID, szBuf );
}

void PrintfGuildChatMessage( int nChatType, int nGuildID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendGuildChatMessage( nChatType, "@GUILD", nGuildID, szBuf );
}

void PrintfGuildChatMessage( int nGuildID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendGuildChatMessage( "@GUILD", nGuildID, szBuf );
}

void PrintfAllianceChatMessage( int nChatType, int nAllianceID, const char * szSender, const char * szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	std::vector< int > vAllianceMember = GuildManager::GetInstance().GetAllianceMemberID( nAllianceID );

	for( std::vector< int >::iterator it = vAllianceMember.begin(); it != vAllianceMember.end(); ++it )
	{
		SendGuildChatMessage( nChatType, szSender, (*it), szBuf );
	}
}

void PrintfAllianceChatMessage( int nAllianceID, const char * szSender, const char * szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	PrintfAllianceChatMessage( CHAT_ALLIANCE_SYSTEM, nAllianceID, szSender, szBuf );
}

void PrintfAllianceChatMessage( int nAllianceID, const char * szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	PrintfAllianceChatMessage( nAllianceID, "@ALLIANCE", szBuf );
}

void SendLocalChatMessage( int nChatType, unsigned rx, unsigned ry, unsigned char layer, const char *szSenderName, const char *szString, unsigned len )
{
	ARCADIA_LOCK( ArcadiaServer::Instance().LockWithVisibleRange( rx, ry, layer ) );
	// 메세지 헤더
	TS_SC_CHAT msg;
	msg.type = nChatType;
	s_strcpy( msg.szSender, _countof( msg.szSender ), szSenderName );
	msg.len = (unsigned char)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendLocalChatMessage too big : %d", msg.size );
		_cprint( "SendLocalChatMessage too big : %d", msg.size );
		return;
	}
	// 메모리 할당
	char pBuffer[ SENDMSG_BUFFER_SIZE ];
// char * pBuffer = new char[ msg.size ];


	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer )-sizeof(msg), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	// 메세지 전송
	ArcadiaServer::Instance().Broadcast( rx, ry, layer, pBuffer );
	
}

void BroadcastChatMessage( int nChatType, unsigned rx, unsigned ry, unsigned char layer, const char *szSenderName, const char *szString, unsigned len )
{
	// 메세지 헤더
	TS_SC_CHAT msg;
	msg.type = nChatType;
	s_strcpy( msg.szSender, _countof( msg.szSender ), szSenderName );
	msg.len = (unsigned char)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "BroadcastChatMessage too big : %d", msg.size );
		_cprint( "BroadcastChatMessage too big : %d", msg.size );
		return;
	}

	// 메모리 할당
	char pBuffer[SENDMSG_BUFFER_SIZE];

	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer ) - sizeof(msg), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	// 메세지 전송
	ArcadiaServer::Instance().Broadcast( rx, ry, layer, pBuffer );
}

void PrintfLocalChatMessage( bool bLock, int ChatType, unsigned rx, unsigned ry, unsigned char layer, const char *szSenderName, const char * szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	int nResultLen = s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	if( nResultLen <= 0 )
		return;

	if( bLock )
		SendLocalChatMessage( ChatType, rx, ry, layer, szSenderName, szBuf, nResultLen );
	else
		BroadcastChatMessage( ChatType, rx, ry, layer, szSenderName, szBuf, nResultLen );
}

void SendGuildNotify( struct StructPlayer *pPlayer )
{
	char szBuf[256];

	s_sprintf( szBuf, _countof( szBuf ), "GCHANGE|%u|%d", pPlayer->GetHandle(), pPlayer->GetGuildID() );

	SendLocalChatMessage( CHAT_GUILD_SYSTEM, pPlayer->GetRX(), pPlayer->GetRY(), pPlayer->GetLayer(), "@GUILD", szBuf, static_cast<unsigned int>( strlen( szBuf ) ) + 1 );
}

void SendGlobalChatMessage( int ChatType, const char *szSenderName, const char *szString, unsigned len )
{
	if( !len ) len = (unsigned)strlen( szString );

	// 메세지 헤더
	TS_SC_CHAT msg;
	msg.type = ChatType;
	s_strcpy( msg.szSender, _countof( msg.szSender ), szSenderName );
	msg.len = (unsigned short)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendGlobalChatMessage too big : %d", msg.size );
		_cprint( "SendGlobalChatMessage too big : %d", msg.size );
		return;
	}

	// 메모리 할당
	char pBuffer[SENDMSG_BUFFER_SIZE];

	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer ) - sizeof( msg ), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	// 메세지 전송
	struct _ChatSender : ArObjectFunctor
	{
		_ChatSender( const void *_msg ) { msg = _msg; }

		void operator()( ArObject *pObj ) const
		{
			PendMessage( pObj,
						 reinterpret_cast< const TS_MESSAGE* >( msg ) );
		}

		const void *msg;

	} _sender( pBuffer );

	StructPlayer::DoEachPlayer( _sender );

	StructPlayer::iterator pit( StructPlayer::get( StructPlayer::FindPlayer( szSenderName ) ) );
	StructPlayer *pSender = *pit;
	if( pSender )
	{
		SendResult( pSender, TM_CS_CHAT_REQUEST, RESULT_SUCCESS );
	}
}

void SendWarpMessage( const StructPlayer *pPlayer )
{
	TS_SC_WARP msg;
	msg.x = pPlayer->GetX();
	msg.y = pPlayer->GetY();
	msg.z = pPlayer->GetZ();
	msg.layer = pPlayer->GetLayer();

	PendMessage( pPlayer, &msg );
}

void SendChatMessageWithLock( AR_HANDLE hTarget, const void *pMsg, unsigned len )
{
	struct _MessageSender : ArObjectFunctor
	{
		_MessageSender( const void *_msg, unsigned int _size ) : msg( _msg ), size( _size )	{}

		void operator()( ArObject *pObj ) const
		{
			PendStream( pObj, msg, size );
		}
		
		unsigned int size;
		const void *msg;

	} _sender( pMsg, len );

	StructPlayer::DoPlayer( hTarget, _sender );	
}

void SendChatMessageWithoutLock( AR_HANDLE hTarget, void *pBuffer, unsigned len )
{
	StructPlayer::iterator pit( StructPlayer::get( hTarget ) );
	StructPlayer *pPlayer = *pit;

	TS_SC_CHAT *pMsg = reinterpret_cast< TS_SC_CHAT * >( pBuffer );

	if( pPlayer ) PendStream( pPlayer, pMsg, len );
}

void SendChatMessage( bool bLock, int nChatType, const char *szSenderName, StructPlayer *pTarget, const char *szString, unsigned len )
{
	SendChatMessage( bLock, nChatType, szSenderName, pTarget->GetHandle(), szString, len );
}

void SendChatMessage( bool bLock, int nChatType, const char *szSenderName, AR_HANDLE hTarget, const char *szString, unsigned len )
{
	if( !len ) len = (unsigned)strlen( szString );

	if( len > 30000 )
	{
		//assert( 0 );
		return;
	}

	// 메세지 헤더
	TS_SC_CHAT msg;
	msg.type = nChatType;
	s_strcpy( msg.szSender, _countof( msg.szSender ), szSenderName );
	msg.len = (unsigned short)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendChatMessage too big : %d", msg.size );
		_cprint( "SendChatMessage too big : %d", msg.size );
		return;
	}

	// 메모리 할당
	char pBuffer[SENDMSG_BUFFER_SIZE];

	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer ) - sizeof( msg ), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	if( bLock ) SendChatMessageWithLock( hTarget, pBuffer, msg.size );
	else		SendChatMessageWithoutLock( hTarget, pBuffer, msg.size );



}

void SendChatMessage( bool bLock, int nChatType, const char *szSenderName, const char *szTarget, const char *szString, unsigned len )
{
	if( !len ) len = (unsigned)strlen( szString );

	StructPlayer::iterator pit_sender( StructPlayer::get( StructPlayer::FindPlayer( szSenderName ) ) );
	StructPlayer *pSender = *pit_sender;
	StructPlayer::iterator pit_target( StructPlayer::get( StructPlayer::FindPlayer( szTarget ) ) );
	StructPlayer *pTarget = *pit_target;
	
	if( !pTarget )
	{
		if( pSender )
			SendResult( pSender, TM_CS_CHAT_REQUEST, RESULT_NOT_EXIST );

		return;
	}

	SendChatMessage( bLock, nChatType, szSenderName, pTarget->GetHandle(), szString, len );

	if( !pSender ) ENV().Set( "error_chat", 1 );

	if( pSender )
		SendResult( pSender, TM_CS_CHAT_REQUEST, RESULT_SUCCESS );
}

void SendYellChatMessage( int nChatType, AR_HANDLE handle, const char *szString, unsigned len )
{
	StructCreature::iterator cit = StructCreature::get( handle );
	if( !(*cit) )
	{
		FILELOG( "SendYellChatMessage invalid object : %I64d", handle );
		_cprint( "SendYellChatMessage invalid object : %I64d\n", handle );
		return;
	}

	ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithSpecificRange( cit.get(), GameRule::CHAT_YELL_RANGE ) );

	// 메세지 헤더
	TS_SC_CHAT_LOCAL msg;
	msg.type = nChatType;
	msg.handle = handle;
	msg.len = (unsigned char)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendYellChatMessage too big : %d", msg.size );
		_cprint( "SendYellChatMessage too big : %d", msg.size );
		return;
	}
	// 메모리 할당
	char pBuffer[SENDMSG_BUFFER_SIZE];

	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer ) - sizeof( msg ), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	// 메세지 전송
	ArcadiaServer::Instance().BroadcastToSpecificRegion( cit.get()->GetRX(), cit.get()->GetRY(), GameRule::CHAT_YELL_RANGE, cit.get()->GetLayer(), pBuffer );
	
	StructPlayer::iterator pit( StructPlayer::get( handle ) );
	StructPlayer *pPlayer = *pit;
	if( pPlayer )
	{
		SendResult( pPlayer, TM_CS_CHAT_REQUEST, RESULT_SUCCESS );
	}
}

void SendLocalChatMessage( int nChatType, AR_HANDLE handle, const char *szString, unsigned len )
{	
	StructCreature::iterator cit = StructCreature::get( handle );
	if( !(*cit) )
	{
		FILELOG( "SendLocalChatMessage invalid object : %I64d", handle );
		_cprint( "SendLocalChatMessage invalid object : %I64d\n", handle );
		return;
	}

	ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( cit.get() ) );

	// 메세지 헤더
	TS_SC_CHAT_LOCAL msg;
	msg.type = nChatType;
	msg.handle = handle;
	msg.len = (unsigned char)(len + 1);
	
	// 문자열 크기만큼 사이즈 늘림
	msg.size += static_cast< unsigned >( msg.len );

	if ( msg.size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendLocalChatMessage too big : %d", msg.size );
		_cprint( "SendLocalChatMessage too big : %d", msg.size );
		return;
	}
	// 메모리 할당

	char pBuffer[SENDMSG_BUFFER_SIZE];

	// 버퍼에 헤더 복사
	s_memcpy( pBuffer, sizeof( pBuffer ), &msg, sizeof(msg) );
	
	// 버퍼에 문자열 복사
	s_memcpy( pBuffer + sizeof(msg), sizeof( pBuffer ) - sizeof( msg ), szString, msg.len );

	// '\0' 추가
	pBuffer[ msg.size-1 ] = '\0';

	// 메세지 전송
	ArcadiaServer::Instance().Broadcast( cit.get()->GetRX(), cit.get()->GetRY(), cit.get()->GetLayer(), pBuffer );
	
	StructPlayer::iterator pit( StructPlayer::get( handle ) );
	StructPlayer *pPlayer = *pit;
	if( pPlayer && pPlayer->IsPlayer() )
	{
		SendResult( pPlayer, TM_CS_CHAT_REQUEST, RESULT_SUCCESS );
	}
}

void BroadcastTamingMessage( struct StructPlayer *pPlayer, struct StructMonster *pMonster, int mode )
{
	if( !pPlayer )
		return;

	TS_SC_TAMING_INFO info;
	info.tamer_handle	= pPlayer ? pPlayer->GetHandle() : 0;
	info.target_handle	= pMonster->GetHandle();
	info.mode			= mode;
	ArcadiaServer::Instance().Broadcast( pMonster->GetRX(), pMonster->GetRY(), pMonster->GetLayer(), &info );

	switch( mode )
	{
	case TS_SC_TAMING_INFO::START:
		if( pPlayer )
		{
			if( pPlayer->GetPartyID() )
				PrintfPartyChatMessage( CHAT_PARTY_SYSTEM, pPlayer->GetPartyID(), "TAMING_START|%d|", pMonster->GetMonsterBase()->name_id );
			else
				PrintfChatMessage( false, CHAT_PARTY_SYSTEM, "@SYSTEM", pPlayer, "TAMING_START|%d|", pMonster->GetMonsterBase()->name_id );
		}
		break;
	case TS_SC_TAMING_INFO::CLEAR:
	case TS_SC_TAMING_INFO::FAILED:
		if( pPlayer )
		{
			if( pPlayer->GetPartyID() )
				PrintfPartyChatMessage( CHAT_PARTY_SYSTEM, pPlayer->GetPartyID(), "TAMING_FAILED|%d|", pMonster->GetMonsterBase()->name_id );
			else
				PrintfChatMessage( false, CHAT_PARTY_SYSTEM, "@SYSTEM", pPlayer, "TAMING_FAILED|%d|", pMonster->GetMonsterBase()->name_id );
		}
		break;
	case TS_SC_TAMING_INFO::SUCCESS:
		if( pPlayer )
		{
			// Fraun executes a script on successful creature taming. Inside of it, we do usually have taming announce with checks
			int nSummonCode = (pMonster->IsMonsterCreatureTame()) ? pMonster->GetMonsterCreatureTameCode() : pMonster->GetTameCode();
			int nSummonRate = GameContent::GetSummonInfo(nSummonCode)->rate;
			int nPetNameId = GameContent::GetSummonInfo(nSummonCode)->name_id;

			std::string creatureTamingCode = std::to_string(static_cast<long long>(pMonster->GetTameItemCode()));

			std::string scriptText;

			XStringUtil::Format(scriptText, "on_creature_taming( '%s', '%s', '%i', '%i' )", pPlayer->GetName(), creatureTamingCode, nSummonRate, nPetNameId);

			LUA()->RunString(scriptText.c_str());


			if( pPlayer->GetPartyID() )
				PrintfPartyChatMessage( CHAT_PARTY_SYSTEM, pPlayer->GetPartyID(), "TAMING_SUCCESS|%d|", pMonster->GetMonsterBase()->name_id );
			else
				PrintfChatMessage( false, CHAT_PARTY_SYSTEM, "@SYSTEM", pPlayer, "TAMING_SUCCESS|%d|", pMonster->GetMonsterBase()->name_id );
		}
		break;
	}
}

template< int FACTOR >
const short RoundUp( const c_fixed< FACTOR > fixed )
{
	c_fixd< FACTOR > temp;
	temp.set( fixed.get() + FACTOR - 1 );

}

void SendStatInfo( struct StructPlayer * pClient, struct StructCreature * pCreature )
{
	{
		TS_SC_STAT_INFO	msg;

		// 기본 정보 전송
		msg.handle		= pCreature->GetHandle();

		const CreatureStatServer & stat = pCreature->GetStat();
		msg.stat.stat_id		= stat.stat_id;
		msg.stat.strength		= stat.strength;
		msg.stat.vital			= stat.vital;
		msg.stat.dexterity		= stat.dexterity;
		msg.stat.agility		= stat.agility;
		msg.stat.intelligence	= stat.intelligence;
		msg.stat.mentality		= stat.mentality;
		msg.stat.luck			= stat.luck;

		const CreatureAttributeServer & attr = pCreature->GetAttribute();
		msg.attribute.nCritical					= attr.fCritical;
		msg.attribute.nCriticalPower			= attr.fCriticalPower;
		msg.attribute.nAttackPointRight			= attr.fAttackPointRight;
		msg.attribute.nAttackPointLeft			= attr.fAttackPointLeft;
		msg.attribute.nDefence					= attr.fDefence;
		msg.attribute.nBlockDefence				= attr.fBlockDefence;
		msg.attribute.nMagicPoint				= attr.fMagicPoint;
		msg.attribute.nMagicDefence				= attr.fMagicDefence;
		msg.attribute.nAccuracyRight			= attr.fAccuracyRight;
		msg.attribute.nAccuracyLeft				= attr.fAccuracyLeft;
		msg.attribute.nMagicAccuracy			= attr.fMagicAccuracy;
		msg.attribute.nAvoid					= attr.fAvoid;
		msg.attribute.nMagicAvoid				= attr.fMagicAvoid;
		msg.attribute.nBlockChance				= attr.fBlockChance;
		msg.attribute.nMoveSpeed				= attr.fMoveSpeed;
		msg.attribute.nAttackSpeed				= attr.fAttackSpeed;
		msg.attribute.nAttackRange				= attr.fAttackRange;
		msg.attribute.nMaxWeight				= attr.fMaxWeight;
		msg.attribute.nCastingSpeed				= attr.fCastingSpeed;
		msg.attribute.nCoolTimeSpeed			= attr.fCoolTimeSpeed;
		msg.attribute.nItemChance				= attr.fItemChance;
		msg.attribute.nHPRegenPercentage		= attr.fHPRegenPercentage;
		msg.attribute.nHPRegenPoint				= attr.fHPRegenPoint;
		msg.attribute.nMPRegenPercentage		= attr.fMPRegenPercentage;
		msg.attribute.nMPRegenPoint				= attr.fMPRegenPoint;
		msg.attribute.nPerfectBlock				= attr.fPerfectBlock;
		msg.attribute.nMagicalDefIgnore			= attr.fMagicalDefIgnore;
		msg.attribute.nMagicalDefIgnoreRatio	= attr.fMagicalDefIgnoreRatio;
		msg.attribute.nPhysicalDefIgnore		= attr.fPhysicalDefIgnore;
		msg.attribute.nPhysicalDefIgnoreRatio	= attr.fPhysicalDefIgnoreRatio;
		msg.attribute.nMagicalPenetration		= attr.fMagicalPenetration;
		msg.attribute.nMagicalPenetrationRatio	= attr.fMagicalPenetrationRatio;
		msg.attribute.nPhysicalPenetration		= attr.fPhysicalPenetration;
		msg.attribute.nPhysicalPenetrationRatio	= attr.fPhysicalPenetrationRatio;

		msg.type		= TS_SC_STAT_INFO::TOTAL;
		PendMessage( pClient, &msg );

		// 아이템빨 정보 전송
		msg.handle		= pCreature->GetHandle();

		// 원본 스탯의 정수 값을 구한 뒤 이를 최종 스탯의 정수값에서 빼서 보너스 값을 구한다

		// 단순 대입하지 않고 아래와 같이 구현한 까닭은 소수점 이하 값이 절삭되면 원본 스탯이 가끔 왜곡되어 나오기 때문
		// 가장 좋은 방법은 애초에 원본 스탯+최종 스탯을 보내주는 것이지만 클라의 변경이 동반되므로 일단 보류
		// 보너스 스탯에 대해 올림을 하는 방법도 있으나 이 경우는 똑같은 결과임에도 분기문이 들어가야 해서 기각
		const CreatureStatServer & statByState = pCreature->GetStatByState();
		msg.stat.stat_id		= statByState.stat_id;
		msg.stat.strength		-= static_cast< int >( stat.strength - statByState.strength );
		msg.stat.vital			-= static_cast< int >( stat.vital - statByState.vital );
		msg.stat.dexterity		-= static_cast< int >( stat.dexterity - statByState.dexterity );
		msg.stat.agility		-= static_cast< int >( stat.agility - statByState.agility );
		msg.stat.intelligence	-= static_cast< int >( stat.intelligence - statByState.intelligence );
		msg.stat.mentality		-= static_cast< int >( stat.mentality - statByState.mentality );
		msg.stat.luck			-= static_cast< int >( stat.luck - statByState.luck );

		const CreatureAttributeServer & attrByState = pCreature->GetAttributeByState();
		msg.attribute.nCritical					-= static_cast< int >( attr.fCritical - attrByState.fCritical );
		msg.attribute.nCriticalPower			-= static_cast< int >( attr.fCriticalPower - attrByState.fCriticalPower );
		msg.attribute.nAttackPointRight			-= static_cast< int >( attr.fAttackPointRight - attrByState.fAttackPointRight );
		msg.attribute.nAttackPointLeft			-= static_cast< int >( attr.fAttackPointLeft - attrByState.fAttackPointLeft );
		msg.attribute.nDefence					-= static_cast< int >( attr.fDefence - attrByState.fDefence );
		msg.attribute.nBlockDefence				-= static_cast< int >( attr.fBlockDefence - attrByState.fBlockDefence );
		msg.attribute.nMagicPoint				-= static_cast< int >( attr.fMagicPoint - attrByState.fMagicPoint );
		msg.attribute.nMagicDefence				-= static_cast< int >( attr.fMagicDefence - attrByState.fMagicDefence );
		msg.attribute.nAccuracyRight			-= static_cast< int >( attr.fAccuracyRight - attrByState.fAccuracyRight );
		msg.attribute.nAccuracyLeft				-= static_cast< int >( attr.fAccuracyLeft - attrByState.fAccuracyLeft );
		msg.attribute.nMagicAccuracy			-= static_cast< int >( attr.fMagicAccuracy - attrByState.fMagicAccuracy );
		msg.attribute.nAvoid					-= static_cast< int >( attr.fAvoid - attrByState.fAvoid );
		msg.attribute.nMagicAvoid				-= static_cast< int >( attr.fMagicAvoid - attrByState.fMagicAvoid );
		msg.attribute.nBlockChance				-= static_cast< int >( attr.fBlockChance - attrByState.fBlockChance );
		msg.attribute.nMoveSpeed				-= static_cast< int >( attr.fMoveSpeed - attrByState.fMoveSpeed );
		msg.attribute.nAttackSpeed				-= static_cast< int >( attr.fAttackSpeed - attrByState.fAttackSpeed );
		msg.attribute.nAttackRange				-= static_cast< int >( attr.fAttackRange - attrByState.fAttackRange );
		msg.attribute.nMaxWeight				-= static_cast< int >( attr.fMaxWeight - attrByState.fMaxWeight );
		msg.attribute.nCastingSpeed				-= static_cast< int >( attr.fCastingSpeed - attrByState.fCastingSpeed );
		msg.attribute.nCoolTimeSpeed			-= static_cast< int >( attr.fCoolTimeSpeed - attrByState.fCoolTimeSpeed );
		msg.attribute.nItemChance				-= static_cast< int >( attr.fItemChance - attrByState.fItemChance );
		msg.attribute.nHPRegenPercentage		-= static_cast< int >( attr.fHPRegenPercentage - attrByState.fHPRegenPercentage );
		msg.attribute.nHPRegenPoint				-= static_cast< int >( attr.fHPRegenPoint - attrByState.fHPRegenPoint );
		msg.attribute.nMPRegenPercentage		-= static_cast< int >( attr.fMPRegenPercentage - attrByState.fMPRegenPercentage );
		msg.attribute.nMPRegenPoint				-= static_cast< int >( attr.fMPRegenPoint - attrByState.fMPRegenPoint );
		msg.attribute.nPerfectBlock				-= static_cast< int >( attr.fPerfectBlock - attrByState.fPerfectBlock );
		msg.attribute.nMagicalDefIgnore			-= static_cast< int >( attr.fMagicalDefIgnore - attrByState.fMagicalDefIgnore );
		msg.attribute.nMagicalDefIgnoreRatio	-= static_cast< int >( attr.fMagicalDefIgnoreRatio - attrByState.fMagicalDefIgnoreRatio );
		msg.attribute.nPhysicalDefIgnore		-= static_cast< int >( attr.fPhysicalDefIgnore - attrByState.fPhysicalDefIgnore );
		msg.attribute.nPhysicalDefIgnoreRatio	-= static_cast< int >( attr.fPhysicalDefIgnoreRatio - attrByState.fPhysicalDefIgnoreRatio );
		msg.attribute.nMagicalPenetration		-= static_cast< int >( attr.fMagicalPenetration - attrByState.fMagicalPenetration );
		msg.attribute.nMagicalPenetrationRatio	-= static_cast< int >( attr.fMagicalPenetrationRatio - attrByState.fMagicalPenetrationRatio );
		msg.attribute.nPhysicalPenetration		-= static_cast< int >( attr.fPhysicalPenetration - attrByState.fPhysicalPenetration );
		msg.attribute.nPhysicalPenetrationRatio	-= static_cast< int >( attr.fPhysicalPenetrationRatio - attrByState.fPhysicalPenetrationRatio );

		msg.type		= TS_SC_STAT_INFO::BY_ITEM;
		PendMessage( pClient, &msg );
	}
}

void BroadcastPropertyMessage( unsigned rx, unsigned ry, unsigned char layer, AR_HANDLE handle, const char *szPropertyName, const __int64 & value )
{
	TS_SC_PROPERTY msg;
	s_strcpy( msg.name, _countof( msg.name ), szPropertyName );
	// 모든 패킷은 ZeroMemory가 되므로 name의 마지막 바이트는 0이 되어야 한다.
	// 아니면 szPropertyName이 너무 길어서 버퍼 오버런의 위험이 있다는 이야기
	// 여기에서 걸리면 TS_SC_PROPERTY::name의 크기 조절할 것.	
	msg.handle = handle;
	msg.value = value;
	msg.is_number = true;

	ArcadiaServer::Instance().Broadcast( rx, ry, layer, &msg );
}

void SendPropertyMessage( const struct StructPlayer *pPlayer, AR_HANDLE handle, const char *szPropertyName, const __int64 & value )
{
	TS_SC_PROPERTY msg;
	s_strcpy( msg.name, _countof( msg.name ), szPropertyName );
	// 모든 패킷은 ZeroMemory가 되므로 name의 마지막 바이트는 0이 되어야 한다.
	// 아니면 szPropertyName이 너무 길어서 버퍼 오버런의 위험이 있다는 이야기
	// 여기에서 걸리면 TS_SC_PROPERTY::name의 크기 조절할 것.	
	msg.handle = handle;
	msg.value = value;
	msg.is_number = true;
	PendMessage( pPlayer, &msg );
}

void SendPropertyMessage( const struct StructPlayer *pPlayer, AR_HANDLE handle, const char *szPropertyName, const char *szValue )
{
	TS_SC_PROPERTY msg;
	msg.size += static_cast< unsigned >( strlen(szValue)+1 );
	s_strcpy( msg.name, _countof( msg.name ), szPropertyName );
	// 모든 패킷은 ZeroMemory가 되므로 name의 마지막 바이트는 0이 되어야 한다.
	// 아니면 szPropertyName이 너무 길어서 버퍼 오버런의 위험이 있다는 이야기
	// 여기에서 걸리면 TS_SC_PROPERTY::name의 크기 조절할 것.	
	msg.handle = handle;
	msg.is_number = false;
	char szTmp[4096 + sizeof(msg)];
	s_memcpy( szTmp, sizeof( szTmp ), &msg, sizeof(msg) );
	s_memcpy( szTmp+sizeof(msg), sizeof( szTmp ) - sizeof( msg ), szValue, static_cast< unsigned >( strlen(szValue)+1 ) );
	PendStream( pPlayer, szTmp, msg.size );
}

void SendSPMsg( const StructPlayer *pPlayer, struct StructSummon *pSummon )
{
	TS_SC_SP msg;
	msg.sp = pSummon->GetSP();
	msg.max_sp = pSummon->GetMaxSP();
	msg.handle = pSummon->GetHandle();
	PendMessage( pPlayer, &msg );
}


void SendExpMsg( const StructPlayer *pPlayer, const StructCreature *pCreature )
{
	TS_SC_EXP_UPDATE msg;
	msg.handle = pCreature->GetHandle();
	msg.jp  = pCreature->GetJobPoint();
	msg.exp = pCreature->GetEXP();
	PendMessage( pPlayer, &msg );
}

void BroadcastLevelMsg( const struct StructCreature *pCreature )
{
	TS_SC_LEVEL_UPDATE msg;
	msg.handle = pCreature->GetHandle();
	msg.job_level = pCreature->GetJobLevel();
	msg.level = pCreature->GetLevel();

	ArcadiaServer::Instance().Broadcast( pCreature->GetRX(), pCreature->GetRY(), pCreature->GetLayer(), &msg );
}

void SendLevelMsg( const struct StructPlayer *pPlayer, const StructCreature *pCreature )
{
	TS_SC_LEVEL_UPDATE msg;
	msg.handle = pCreature->GetHandle();
	msg.job_level = pCreature->GetJobLevel();
	msg.level = pCreature->GetLevel();
	PendMessage( pPlayer, &msg );
}

void SendGoldChaosUpdateMsg( const StructPlayer *pPlayer )
{
	TS_SC_GOLD_UPDATE msg;
	msg.gold = pPlayer->GetGold().GetRawData();
	msg.chaos = pPlayer->GetChaos();
	PendMessage( pPlayer, &msg );
}

void SendMixResult( struct StructPlayer * pClient, AR_HANDLE *pHandle, unsigned count, unsigned int type )
{
	TS_SC_MIX_RESULT msg;
	msg.count = count;
	msg.size += static_cast< unsigned int >( sizeof(AR_HANDLE)*count );
	msg.type = type;		// 특수 조합 결과 (각성, 랜덤화 등)

	char szTmp[4096];
	s_memcpy( szTmp, sizeof( szTmp ), &msg, sizeof(msg) );
	if( pHandle && count )
		s_memcpy( szTmp+sizeof(msg), sizeof( szTmp ) - sizeof( msg ), pHandle, sizeof(AR_HANDLE)*count );
	PendStream( pClient, szTmp, msg.size );
}

void SendDecomposeResult( struct StructPlayer * pClient, TS_SC_DECOMPOSE_RESULT::DECOMPOSE_INFO * pItemResults, unsigned int count )
{
	TS_SC_DECOMPOSE_RESULT msg;

	msg.total_count = count;
	msg.size += sizeof( TS_SC_DECOMPOSE_RESULT::DECOMPOSE_INFO ) * count;
	
	char szTmp[4096];
	s_memcpy( szTmp, sizeof( szTmp ), &msg, sizeof( msg ) );
	s_memcpy( szTmp+sizeof( msg ), sizeof( szTmp ) - sizeof( msg ), pItemResults, sizeof( TS_SC_DECOMPOSE_RESULT::DECOMPOSE_INFO ) * count );
	PendStream( pClient, szTmp, msg.size );
}

void SendItemList( struct StructPlayer * pClient, bool bIsStorage )
{
	if( !pClient->GetItemCount() ) return;

	size_t cnt = 0;
	
	if( bIsStorage )	cnt = pClient->GetStorageItemCount();
	else				cnt = pClient->GetItemCount();

	TS_SC_INVENTORY msg;

	const static size_t MAX_ITEM_COUNT_PER_MSG = ( SENDMSG_BUFFER_SIZE - sizeof( msg ) ) / sizeof( TS_ITEM_INFO );
	// TS_SC_INVENTORY::count가 unsigned short 이므로 한 번에 0xFFFF 개까지만 송신 가능. 버퍼가 부족한 경우 체크
	assert( MAX_ITEM_COUNT_PER_MSG <= 0xFFFF );

	for( size_t idx = 0 ; idx < cnt ; idx += MAX_ITEM_COUNT_PER_MSG )
	{
		// 한 번에 MAX_ITEM_COUNT_PER_MSG 개수만큼씩만 묶어서 보냄
		msg.count = static_cast< unsigned short >( ( ( cnt - idx ) > MAX_ITEM_COUNT_PER_MSG ) ? MAX_ITEM_COUNT_PER_MSG : ( cnt - idx ) );
		// 아이템 정보만큼 크기를 늘림
		msg.size = static_cast< unsigned int >( sizeof( TS_SC_INVENTORY ) + sizeof( TS_ITEM_INFO ) * msg.count );

		char szBuffer[ SENDMSG_BUFFER_SIZE ] = "";

		// 버퍼에 헤더 복사
		s_memcpy( szBuffer, sizeof( szBuffer ), &msg, sizeof(msg) );
		
		// 버퍼에 개개의 아이템 정보 복사
		TS_ITEM_INFO * pInfo = reinterpret_cast< TS_ITEM_INFO * >( szBuffer + sizeof( msg ) );
		size_t nMaxItemIndex = idx + msg.count;
		for( size_t i = idx ; i < nMaxItemIndex ; ++i )
		{
			StructItem * pItem = bIsStorage ? pClient->GetStorageItem( static_cast< unsigned int >( i ) ) : pClient->GetItem( static_cast< unsigned int >( i ) );
			fillItemInfo( pInfo, pItem );				
			++pInfo;
		}

		// 메세지 전송
		PendStream( pClient, szBuffer, msg.size );
	}
}

void BroadcastSummonEvolutionMessage( struct StructPlayer * pClient, struct StructSummon *pSummon )
{
}


void SendAddSummonMessage( struct StructPlayer * pClient, struct StructSummon *pSummon )
{
	TS_SC_ADD_SUMMON_INFO msg;
	
	msg.summon_handle = pSummon->GetHandle();			// 소환수 핸들
	msg.card_handle = pSummon->GetParentCard()->GetHandle();
	msg.level = pSummon->GetLevel();
	s_strcpy( msg.name, _countof( msg.name ), pSummon->GetName() );	// 소환수 이름
	msg.code = pSummon->GetSummonCode();
	PendMessage( pClient, &msg );

	SendStatInfo( pClient, pSummon );	// 소환수 스탯정보 얻어서
										// 보내주자

	SendHPMPMsg( pClient, pSummon, pSummon->GetHP(), pSummon->GetMP() );	// HP/MP
	SendLevelMsg( pClient, pSummon );	// 레벨
	SendExpMsg( pClient, pSummon );		// 경치

	SendSPMsg( pClient, pSummon );
}

void SendRemoveSummonMessage( struct StructPlayer * pClient, struct StructSummon *pSummon )
{
	TS_SC_REMOVE_SUMMON_INFO msg;
	msg.card_handle = pSummon->GetParentCard()->GetHandle();

	PendMessage( pClient, &msg );
}

void SendAddPetMessage( struct StructPlayer * pClient, struct StructPet *pPet )
{
	TS_SC_ADD_PET_INFO msg;
	msg.cage_handle = ( pPet->GetParentCage() ) ? pPet->GetParentCage()->GetHandle() : 0;
	msg.pet_handle = pPet->GetHandle();
	s_strcpy( msg.name, _countof( msg.name ), pPet->GetName() );
	msg.code = pPet->GetPetCode();

	PendMessage( pClient, &msg );
}

void SendRemovePetMessage( struct StructPlayer * pClient, struct StructPet *pPet )
{
	TS_SC_REMOVE_PET_INFO msg;

	msg.handle = pPet->GetHandle();

	PendMessage( pClient, &msg );
}

void GetWearMsg( struct StructCreature *pCreature, TS_WEAR_INFO & itemInfoMsg )
{
	memset( &(itemInfoMsg.itemCode), 0, sizeof( itemInfoMsg.itemCode ) );
	memset( &(itemInfoMsg.itemEnhance), 0, sizeof( itemInfoMsg.itemEnhance ) );

	StructItem * pItem;
	itemInfoMsg.handle = pCreature->GetHandle();
	for( int i = 0; i < ItemBase::MAX_ITEM_WEAR; ++i )
	{
		pItem = pCreature->GetWearedItem( (ItemBase::ItemWearType) i );
		if( !pItem ) continue;
		itemInfoMsg.itemCode[i] = pItem->GetItemCode();
		itemInfoMsg.itemEnhance[i] = pItem->GetItemEnhance();
		itemInfoMsg.itemLevel[i] = pItem->GetItemLevel();
		itemInfoMsg.elemental_effect_type[i] = pItem->GetElementalEffectType();
		itemInfoMsg.appearance_code[i] = pItem->GetAppearanceCode();
	}

	if( pCreature->IsPlayer() )
	{
		StructPlayer * pPlayer = static_cast< StructPlayer * >(pCreature);
		// 매직 넘버 -_-
		// if( !itemInfoMsg.itemCode[ ItemBase::WEAR_HELM ] ) itemInfoMsg.itemCode[ ItemBase::WEAR_HELM ] = pPlayer->GetBaseModelId( 0 );
		if( !itemInfoMsg.itemCode[ ItemBase::WEAR_ARMOR ] ) itemInfoMsg.itemCode[ ItemBase::WEAR_ARMOR ] = pPlayer->GetBaseModelId( 2 );
		if( !itemInfoMsg.itemCode[ ItemBase::WEAR_GLOVE ] ) itemInfoMsg.itemCode[ ItemBase::WEAR_GLOVE ] = pPlayer->GetBaseModelId( 3 );
		if( !itemInfoMsg.itemCode[ ItemBase::WEAR_BOOTS ] ) itemInfoMsg.itemCode[ ItemBase::WEAR_BOOTS ] = pPlayer->GetBaseModelId( 4 );
	}
}

void SendWearMessage( StructPlayer *pPlayer )
{
	SendWearMessage( pPlayer, pPlayer );
}

void SendWearMessage( struct StructPlayer *pPlayer, struct StructCreature *pCreature )
{
	TS_WEAR_INFO msg;
	GetWearMsg( pCreature, msg );
	PendMessage( pPlayer, &msg );
}

void SendTotalItemWearInfoMessage( StructPlayer *pPlayer, StructCreature *pTarget )
{
	if( !pPlayer || !pTarget )
		return;

	for( int i = 0; i < ItemBase::MAX_ITEM_WEAR; ++i )
	{
		StructItem * pItem = pTarget->GetWearedItem( (ItemBase::ItemWearType) i );
		if( !pItem ) continue;

		SendItemWearInfoMessage( pPlayer, pTarget, pItem );
	}
}


void SendItemWearInfoMessage( StructPlayer *pPlayer, StructCreature *pTarget, StructItem *pItem )
{
	TS_SC_ITEM_WEAR_INFO msg;

	msg.target_handle = pTarget ? pTarget->GetHandle() : NULL;
	msg.item_handle = pItem->GetHandle();
	msg.wear_position = pItem->GetWearInfo();
	msg.enhance = pItem->GetItemEnhance();
	msg.elemental_effect_type = pItem->GetElementalEffectType();
	msg.appearance_code = pItem->GetAppearanceCode();

	PendMessage( pPlayer, &msg );
}

void SendCharacterList( struct IStreamSocketConnection * pConn, struct LOBBY_CHARACTER_INFO *pInfo, unsigned short nCount, unsigned short nLastLoginIndex )
{
	if( nCount > 10 )
	{
		FILELOG( "SendCharacterList() : a lot of count : %d", nCount );
		_cprint( "SendCharacterList() : a lot of count : %d\n", nCount );
		return;
	}

	// 메세지 버퍼 할당
	char pBuf[SENDMSG_BUFFER_SIZE];
	// char *pBuf = new char[ sizeof( TS_SC_CHARACTER_LIST ) + sizeof( LOBBY_CHARACTER_INFO ) * nCount ];

	// 메세지 포인터 설정
	TS_SC_CHARACTER_LIST *pMsg = new (pBuf) TS_SC_CHARACTER_LIST;
	LOBBY_CHARACTER_INFO *pMsgInfo = reinterpret_cast< LOBBY_CHARACTER_INFO* >( pMsg+1 );
	int msg_buf_len = sizeof( pBuf ) - sizeof( TS_SC_CHARACTER_LIST );

	// 메인 메세지 초기화
	pMsg->size += static_cast< unsigned int >( sizeof( LOBBY_CHARACTER_INFO ) * nCount );

	if ( pMsg->size > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendCharacterList too big : %d", pMsg->size );
		_cprint( "SendCharacterList too big : %d", pMsg->size );
		return;
	}
	// pMsg->current_server_time = time( NULL );

	{
		extern XCriticalSection g_ConnectionTagLock;
		THREAD_SYNCHRONIZE( g_ConnectionTagLock );

		_CONNECTION_TAG * pTag = static_cast< _CONNECTION_TAG * >( pConn->GetTag() );

		pTag->vCharacterNameList.clear();
		// 캐릭터 정보 추가
		for( unsigned short i = 0; i < nCount ; ++i )
		{
			pTag->vCharacterNameList.push_back( pInfo->name );

			s_memcpy( pMsgInfo, msg_buf_len, pInfo, sizeof(LOBBY_CHARACTER_INFO) );
			msg_buf_len -= sizeof( LOBBY_CHARACTER_INFO );
			++pMsgInfo;
			++pInfo;
		}
	}

	pMsg->count = nCount;

	// 최근 선택 캐릭터 번호 추가
	pMsg->last_login_index = nLastLoginIndex;

	// 메세지 보내고
	PendMessage( pConn, pMsg );
}

void SendItemMessage( struct StructPlayer * pPlayer, struct StructItem *pItem )
{
	// 메세지 헤더
	char buf[ sizeof(TS_SC_INVENTORY)+sizeof(TS_ITEM_INFO) ];
	TS_SC_INVENTORY *pInvenMsg = new (buf) TS_SC_INVENTORY();

	// 아이템 정보만큼 크기를 늘린다
	pInvenMsg->size += sizeof(TS_ITEM_INFO);

	pInvenMsg->count = 1;
	
	// 버퍼에 개개의 아이템 정보 복사
	TS_ITEM_INFO * pIt = reinterpret_cast< TS_ITEM_INFO * >( buf + sizeof(TS_SC_INVENTORY) );
	fillItemInfo( pIt, pItem );

	// 메세지 전송
	PendMessage( pPlayer, pInvenMsg );
}


void SendCreatureEquipMessage( const StructPlayer *pPlayer, bool bShowDialog )
{
	TS_EQUIP_SUMMON msg;	

	for( int i = 0; i < 6; ++i )
	{
		StructItem *pCard = pPlayer->GetSummonCardAt( i );

		if( pCard ) msg.card_handle[i] = pCard->GetHandle();
		else msg.card_handle[i] = 0;
	}

	msg.open_dialog = bShowDialog;

	PendMessage( pPlayer, &msg );
}

void SendAccountResultWithAuth( struct IStreamSocketConnection * pConn, const char *szAccount, int nError )
{
	SendResult( pConn, TM_CS_ACCOUNT_WITH_AUTH, nError );
}

void SendDisconnectDesc( struct IStreamSocketConnection * pConn, const TS_SC_DISCONNECT_DESC::_DISCONNECT_TYPE eDisconnectionDesc )
{
	TS_SC_DISCONNECT_DESC msg;

	msg.desc_id = eDisconnectionDesc;

	PendMessage( pConn, &msg );
}

void SendLoginResult( struct IStreamSocketConnection * pConn, struct StructPlayer * pClient, const char nPCBangMode, const unsigned short nResult )
{
	// 접속이 더이상 유효하지 않다면
	/*
	if( !LockIOCPConnection( pConn ) )
	{	
		ArcadiaServer::Instance().DeleteObject( pClient );
		return;
	}*/

	TS_LOGIN_RESULT msg;

	msg.result = nResult;

	if( nResult == RESULT_SUCCESS )
	{
		// time sync
		SendTimeSync( pClient );

		msg.handle = pClient->GetHandle();
		msg.region_size = g_nRegionSize;
		msg.cell_size = CELL_SIZE;

		// 종족
		msg.race = pClient->GetRace();

		// 성별
		msg.sex = pClient->GetSex();

		// 외형 정보
		msg.skin_color = pClient->GetSkinColor();
		msg.hairId = pClient->GetBaseModelId( 0 );
		msg.faceId = pClient->GetBaseModelId( 1 );

		// 이름
		s_strcpy( msg.szName, _countof( msg.szName ), pClient->GetName() );

		msg.guild_id = pClient->GetGuildID();

		// 로그인 핸들러 호출
		ThreadPlayerHelper TPHelper( pClient );

		std::string strFirstLoginHandler;
		strFirstLoginHandler = "on_login( '";
		strFirstLoginHandler += pClient->GetName();
		strFirstLoginHandler += "' )";

		// on_login 에서 SCRIPT_SetValue 가 호출되며 프로퍼티 방송이 발생함
		{
			ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pClient ) );
			LUA()->RunString( strFirstLoginHandler.c_str() );
		}

		// HP
		msg.hp = pClient->GetHP();
		msg.mp = pClient->GetMP();
		msg.max_hp = pClient->GetMaxHP();
		msg.max_mp = pClient->GetMaxMP();

		pClient->SetCurrentXY( pClient->GetX(), pClient->GetY() );

		// 위치 세팅
		msg.x = pClient->GetX();
		msg.y = pClient->GetY();
		msg.z = pClient->GetZ();
		msg.layer = pClient->GetLayer();
		msg.face_direction = pClient->GetFace();
		StructItem * pItem = pClient->GetWearedItem( ItemBase::WEAR_BACKBOARD );

		msg.back_board = pItem ? pItem->GetItemBase().nCode : 0;

	}

	pendMessage( pConn, &msg );

	// 로그인 성공이라면
	if( nResult == RESULT_SUCCESS )
	{
		pClient->SendCharacterInfo();

		// 퀵슬롯 정보는 캐쉬 아이템 서버에서는 프리패스 귀환권 지급 이후에 송신해야 함(DB_ReadCommercialStorageList)
		if( !GameRule::bIsCashUsableServer )
		{
			// Client Info (클라 인포, 퀵 슬롯, 저장 키 정보 등) 전송
			// !! 클라이언트 세팅 정보를 보낼 때에는 client_info를 항상 먼저 보내야 한다.
			SendPropertyMessage( pClient, pClient->GetHandle(), "client_info", pClient->GetClientInfo() );
			SendPropertyMessage( pClient, pClient->GetHandle(), "quick_slot", pClient->GetQuickSlot() );
			SendPropertyMessage( pClient, pClient->GetHandle(), "current_key", pClient->GetCurrentKey() );
			SendPropertyMessage( pClient, pClient->GetHandle(), "saved_key", pClient->GetSavedKey() );
		}

		if( pClient->GetPartyID() != 0 ) 
		{
			int nPartyID = pClient->GetPartyID();
			if( PartyManager::GetInstance().onLogin( pClient->GetPartyID(), pClient ) )
			{
				if( PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
				{
					PrintfLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", pClient->GetPartyID(), "LOGIN|%s|%s|", PartyManager::GetInstance().GetPartyName( pClient->GetPartyID() ).c_str(), pClient->GetAlias() );

					BroadcastPartyMemberInfo( nPartyID, pClient );
					BroadcastLinkedPartyMemberInfo( nPartyID, pClient );

					SendPartyInfo( pClient );
					SendLinkedPartyInfo( pClient );
				}
				else
				{
					PrintfPartyChatMessage( CHAT_PARTY_SYSTEM, pClient->GetPartyID(), "LOGIN|%s|%s|", PartyManager::GetInstance().GetPartyName( pClient->GetPartyID() ).c_str(), pClient->GetName() );

					BroadcastPartyMemberInfo( nPartyID, pClient );

					SendPartyInfo( pClient );
				}

				BroadcastSummonInfo( nPartyID, pClient );
				SendSummonInfo( pClient );
			}
		}

		if( pClient->GetGuildID() != 0 )
		{
			PrintfGuildChatMessage( CHAT_GUILD_SYSTEM, pClient->GetGuildID(), "LOGIN|%s|%s|", GuildManager::GetInstance().GetGuildName( pClient->GetGuildID() ).c_str(), pClient->GetName() );
			BroadcastGuildMemberInfo( pClient->GetGuildID(), pClient );

			SendGuildStaticInfo( pClient );
			GuildManager::GetInstance().onLogin( pClient->GetGuildID(), pClient );
			SendGuildMemberInfo( pClient );
 		}

		SendQuestList( pClient );

		// 호칭 관련 처리
		SendTitleList( pClient );
		SendTitleConditionList( pClient );
		SendRemainTitleTime( pClient );
		SendMainTitle( pClient );
		SendSubTitle( pClient );

		// 피씨방 유저 세팅 및 지속효과 부여
		if( ENV().GetInt( "game.pcbang_bonus_server" ) )
		{
			ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pClient ) );
			pClient->SetPCBangMode( nPCBangMode );
		}

		// 친구들처리
		{
			SendFriendsList( pClient );
			SendDenialsList( pClient );

			SendStatusMessageToFriendOfPlayer( pClient, true );
		}

		// 아이템 쿨타임 처리
		{
			// 클라 로딩과 쿨타임 처리 싱크 문제 발생으로 임시로 제거
			//SendItemCoolTimeInfo( pClient );
		}

		// 게임 중독 방지 시스템 관련 프로퍼티 송신
		{
			// SetContinuousPlayTime에서 스테미너 세이버 관련 지속효과 변화가 있을 경우 지역 방송 발생 함
			ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pClient ) );

			AR_TIME nContinuousPlayTime = pClient->GetContinuousPlayTime();
			pClient->SetContinuousPlayTime( nContinuousPlayTime );	// 메시지 방송 및 스테미너 세이버 시간 정지 처리 수행
			SendPropertyMessage( pClient, pClient->GetHandle(), "playtime_limit1", GameRule::nMaxHealthyGameTime );
			SendPropertyMessage( pClient, pClient->GetHandle(), "playtime_limit2", GameRule::nMaxTiredGameTime );
		}

		// 기부 랭킹 보상 대상자일 경우 메시지 출력
		if( RankingManager::Instance().IsValidRankingScore( RankingManager::RANKING_TYPE_DONATION_REWARD, pClient->GetPlayerUID() ) )
		{
			SendChatMessage( false, CHAT_NOTICE, "@NOTICE", pClient, "@6748" );
		}
	}

	//UnLockIOCPConnection( pConn );

	if( GameRule::bUseLoginLogoutDebug )
	{
		_ctprint( "SendLoginResult (%s, %s, %hu)\n", pClient->GetAccountName(), pClient->GetName(), msg.result );
		FileLogHandler::GetFileLogHandler()->LogStringEx( NULL, "LoginLogout_Debug", "SendLoginResult (%s, %s, %hu)", pClient->GetAccountName(), pClient->GetName(), msg.result );
	}

	// nResult != RESULT_SUCCESS 일 때에는 SendLoginResult 함수 호출 측에서 LogoutNow 호출 해 줌.
	// 로그인 처리는 다 성공했는데 그 사이에 접속이 끊겨서 컨넥션이 없어진 경우에만 별도로 로그아웃 처리 해 줌
	if( nResult == RESULT_SUCCESS && pClient && !pClient->pConnection )
		pClient->LogoutNow( 3 );
}

void SendFriendsList( struct StructPlayer *pClient )
{
	std::string strResult = "FLIST|";

	struct FriendListEnumerator : public StructPlayer::FriendDenialFunctor
	{
		FriendListEnumerator( std::string & strFriendList, const char * pszName )
			: m_strFriendList( strFriendList )
			, m_pszName( pszName )
		{}

		virtual const bool operator()( std::string & strName )
		{
			m_strFriendList += strName;
			AR_HANDLE hTarget = StructPlayer::FindPlayer( strName.c_str() );
			StructPlayer::iterator itFriend = StructPlayer::get( hTarget );
			StructPlayer * pFriend = (*itFriend);

			if( pFriend )
			{
				std::vector< std::string >::const_iterator it = std::find( pFriend->m_vDenial.begin(), pFriend->m_vDenial.end(), m_pszName );

				if( it != pFriend->m_vDenial.end() )
				{	// 차단 됨(오프라인으로 보임)
					m_strFriendList += "|2|";
				}
				else
				{	// 온라인
					m_strFriendList += "|1|";
				}
			}
			else
			{	// 오프라인
				m_strFriendList += "|0|";
			}

			return true;
		}

	private:
		std::string &	m_strFriendList;
		const char *	m_pszName;
	} _FriendListEnumerator( strResult, pClient->GetName() );

	pClient->DoEachFriend( _FriendListEnumerator );

	SendChatMessage( false, CHAT_FRIEND_SYSTEM, "@FRIEND", pClient, strResult.c_str() );
}

void SendDenialsList( struct StructPlayer *pClient )
{
	std::string strResult = "DLIST|";

	struct DenialListEnumerator : public StructPlayer::FriendDenialFunctor
	{
		DenialListEnumerator( std::string & strDenialList )
			: m_strDenialList( strDenialList )
		{}

		virtual const bool operator()( std::string & strName )
		{
			m_strDenialList += strName;
			m_strDenialList += "|";

			return true;
		}

	private:
		std::string & m_strDenialList;
	} _DenialListEnumerator( strResult );

	pClient->DoEachDenial( _DenialListEnumerator );

	SendChatMessage( false, CHAT_FRIEND_SYSTEM, "@FRIEND", pClient, strResult.c_str() );
}

void SendStatusMessageToFriendOfPlayer( struct StructPlayer *pClient, struct StructPlayer *pTarget, bool bIsLogin )
{
	std::string strResult = "FSTATUS|";
	strResult += pClient->GetName();
	
	if( bIsLogin )
	{
		strResult += "|1|";
	}
	else
	{
		strResult += "|0|";
	}

	SendChatMessage( false, CHAT_FRIEND_SYSTEM, "@FRIEND", pTarget, strResult.c_str() );
}

void SendStatusMessageToFriendOfPlayer( struct StructPlayer *pClient, bool bIsLogin )
{
	std::string strResult = "FSTATUS|";
	strResult += pClient->GetName();
	
	if( bIsLogin )
	{
		strResult += "|1|";
	}
	else
	{
		strResult += "|0|";
	}

	struct FriendLoginNoticeFunctor : public StructPlayer::FriendDenialFunctor
	{
		FriendLoginNoticeFunctor( const StructPlayer * pClient, const std::string & strLoginNotice )
			: m_pClient( pClient )
			, m_strLoginNotice( strLoginNotice )
		{}

		virtual const bool operator()( std::string & strName )
		{
			AR_HANDLE hTarget = StructPlayer::FindPlayer( strName.c_str() );
			StructPlayer::iterator itFriend = StructPlayer::get( hTarget );
			StructPlayer * pFriend = (*itFriend);

			if( pFriend )
			{
				std::vector< std::string >::const_iterator it = std::find( m_pClient->m_vDenial.begin(), m_pClient->m_vDenial.end(), strName );
				if( it == m_pClient->m_vDenial.end() )
				{
					SendChatMessage( false, CHAT_FRIEND_SYSTEM, "@FRIEND", pFriend, m_strLoginNotice.c_str() );
				}
			}

			return true;
		}

	private:
		const StructPlayer *	m_pClient;
		const std::string &		m_strLoginNotice;
	} _FriendLoginNoticeFunctor( pClient, strResult );

	pClient->DoEachFriendOf( _FriendLoginNoticeFunctor );
}

void SendItemCoolTimeInfo( struct StructPlayer *pPlayer )
{
	TS_SC_ITEM_COOL_TIME msg;

	AR_TIME t = GetArTime();

	for( int i = 0; i < TS_SC_ITEM_COOL_TIME::MAX_ITEM_COOLTIME_GROUP; ++i )
	{
		msg.cool_time[i] = std::max( (int) pPlayer->GetItemCoolTime( i + 1 ) - (int) t, (int) 0 );
	}

	PendMessage( pPlayer, &msg );
}

void SendWindowMessage( struct StructPlayer *pPlayer, const char *szWindow, const char *szArgument, const char *szTrigger )
{
	TS_SC_SHOW_WINDOW msg;
	msg.window_length = static_cast<unsigned short>( strlen( szWindow ) );
	msg.argument_length = static_cast<unsigned short>( strlen( szArgument ) );
	msg.trigger_length = static_cast<unsigned short>( strlen( szTrigger ) );
	msg.size += ( msg.window_length + msg.argument_length + msg.trigger_length );

	if( msg.size > 1024 )
		return;

	char szTmp[ 1024 ];
	char *p = szTmp;
	int temp_size = sizeof( szTmp );

	s_memcpy( p, temp_size, &msg, sizeof(msg) );				p += sizeof(msg); temp_size -= sizeof(msg);
	s_memcpy( p, temp_size, szWindow, msg.window_length );		p += msg.window_length; temp_size -= msg.window_length;
	s_memcpy( p, temp_size, szArgument, msg.argument_length );	p += msg.argument_length; temp_size -= msg.argument_length;
	s_memcpy( p, temp_size, szTrigger, msg.trigger_length );	p += msg.trigger_length; temp_size -= msg.trigger_length;

	PendStream( pPlayer, szTmp, msg.size );
}

void SendDialogMessage( struct StructPlayer *pPlayer, AR_HANDLE npc_handle, int type, const char *szTitle, const char *szText, const char *szMenu )
{	
	TS_SC_DIALOG msg;
	msg.npc_handle = npc_handle;
	msg.type = type;
	msg.title_length = static_cast< unsigned short >( strlen(szTitle) );
	msg.text_length = static_cast< unsigned short >( strlen(szText) );
	msg.menu_length = static_cast< unsigned short >( strlen(szMenu) );
	msg.size += ( msg.title_length + msg.text_length + msg.menu_length );
	
	char szTmp[ 10*1024 ];
	char* pBuff = szTmp;
	int temp_size = sizeof( szTmp );
	if( msg.size > sizeof( szTmp ) )
	{
		pBuff = new char[msg.size];
		temp_size = msg.size;
	}

	char *p = pBuff;

	s_memcpy( p, temp_size, &msg, sizeof(msg) );			p += sizeof(msg); temp_size -= sizeof(msg);
	s_memcpy( p, temp_size, szTitle, msg.title_length );	p += msg.title_length; temp_size -= msg.title_length;
	s_memcpy( p, temp_size, szText, msg.text_length );		p += msg.text_length; temp_size -= msg.text_length;
	s_memcpy( p, temp_size, szMenu, msg.menu_length );

	PendStream( pPlayer, pBuff, msg.size );

	if( pBuff != szTmp )
	{
		delete [] pBuff;
	}
}

void SendShowCreateGuild( struct StructPlayer *pPlayer )
{
	if( !pPlayer )
		return;

	ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pPlayer ) );

	TS_SC_SHOW_CREATE_GUILD msg;

	pPlayer->SetLastContact( "guild", 1 );

	PendMessage( pPlayer, &msg );
}

void SendShowCreateAlliance( struct StructPlayer *pPlayer )
{
	if( !pPlayer )
		return;

	ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pPlayer ) );

	TS_SC_SHOW_CREATE_ALLIANCE msg;

	pPlayer->SetLastContact( "alliance", 1 );

	PendMessage( pPlayer, &msg );
}

void SendMarketInfo( struct StructPlayer *pPlayer, AR_HANDLE npc_handle, struct _MARKET_INFO *pInfo )
{
	// 마지막 접선한 상점 이름 저장
	pPlayer->SetLastContactMarket( pInfo->strMarketName.c_str() );

	// 헤더
	TS_SC_MARKET msg;
	msg.npc_handle = npc_handle;
	msg.item_count = static_cast< unsigned short >( pInfo->vItemList.size() );
	msg.size += sizeof(_MARKET_INFO::_MARKET_TAG)*msg.item_count;

	char szTmp[10240];

	s_memcpy( szTmp, sizeof( szTmp ), &msg, sizeof(msg) );

	TS_SC_MARKET::ItemInfo * pItemInfo = reinterpret_cast< TS_SC_MARKET::ItemInfo * >( szTmp+sizeof(msg) );

	for( int i = 0; i < msg.item_count; ++i )
	{
		pItemInfo->code = pInfo->vItemList[i].code;
		pItemInfo->price = pInfo->vItemList[i].price.GetRawData();
		pItemInfo->huntaholic_point = pInfo->vItemList[i].huntaholic_point;
		pItemInfo->arena_point = pInfo->vItemList[i].arena_point;

		++pItemInfo;
	}

	PendStream( pPlayer, szTmp, msg.size );
}

void SendGeneralMessageBox( struct StructPlayer *pPlayer, const char *szText )
{
	TS_SC_GENERAL_MESSAGE_BOX msg;
	
	msg.text_length = static_cast<unsigned short>( strlen( szText ) );
	msg.size += msg.text_length;

	if( msg.size > 1024 )
		return;

	char szTmp[ 1024 ];
	char *p = szTmp;
	int temp_size = sizeof( szTmp );

	s_memcpy( p, temp_size, &msg, sizeof(msg) );		p += sizeof(msg); temp_size -= sizeof(msg);
	s_memcpy( p, temp_size, szText, msg.text_length );	p += msg.text_length; temp_size -= msg.text_length;

	PendStream( pPlayer, szTmp, msg.size );
}

void SendItemDestroyMessage( struct StructPlayer * pPlayer, struct StructItem *pItem )
{
	TS_SC_DESTROY_ITEM msg;
	msg.item_handle = pItem->GetHandle();
	PendMessage( pPlayer, &msg );
}

void SendItemCountMessage( struct StructPlayer * pPlayer, struct StructItem *pItem )
{
	TS_SC_UPDATE_ITEM_COUNT msg;
	msg.item_handle = pItem->GetHandle();
	msg.count = pItem->GetCount();
	PendMessage( pPlayer, &msg );
}

void SendSkillCardInfo( struct StructItem *pItem )
{
	GameObject *pPtr = GameObject::raw_get( pItem->GetOwnerHandle() );
	if( !pPtr ) return;
	StructPlayer *pPlayer = static_cast< StructPlayer * >( pPtr );

	TS_SC_SKILLCARD_INFO msg;
	msg.item_handle = pItem->GetHandle();
	msg.target_handle = pItem->GetBindedCreatureHandle();

	PendMessage( pPlayer, &msg );
}

void SendShowSoulStoneCraftWindow( struct StructPlayer * pPlayer )
{
	TS_SC_SHOW_SOULSTONE_CRAFT_WINDOW msg;

	pPlayer->SetLastContact( "SoulStoneCraft", 1 );

	PendMessage( pPlayer, &msg );
}

void SendShowSoulStoneRepairWindow( struct StructPlayer * pPlayer )
{
	TS_SC_SHOW_SOULSTONE_REPAIR_WINDOW msg;
	
	pPlayer->SetLastContact( "RepairSoulStone", 1 );

	PendMessage( pPlayer, &msg );
}

void GenerateStateMessage( TS_SC_STATE& msg, AR_HANDLE target_handle, const struct StructState * pState, bool bIsCancel )
{
	msg.handle = target_handle;
	msg.state_handle = pState->GetUID();
	msg.state_code = pState->GetCode();

	msg.state_value = pState->GetStateValue();

	s_strcpy( msg.state_string_value, _countof( msg.state_string_value ), pState->GetStateStringValue() );

	if( !bIsCancel )
	{
		msg.state_level	= pState->GetLevel();

		if( pState->IsAura() )
		{
			msg.end_time	= (AR_TIME)(-1);
		}
		else
		{
			msg.end_time	= pState->GetEndTime();
		}

		msg.start_time	= pState->GetStartTime();
	
		if( msg.start_time && msg.end_time > 0 && msg.start_time > msg.end_time )
		{
			FILELOG( "start time or end time error!! %d", msg.state_code);
			_cprint( "start time or end time error!! %d   \n", msg.state_code);
			assert( 0 );
		}
	}
	else
	{
		msg.state_level	= 0;
		msg.end_time	= 0;
		msg.start_time	= 0;
	}
}

void BroadcastStateMessage( struct StructCreature *pCreature, struct StructState *p, bool bIsCancel )
{
	TS_SC_STATE msg;

	GenerateStateMessage( msg, pCreature->GetHandle(), p, bIsCancel );		
	ArcadiaServer::Instance().Broadcast( pCreature->GetRX(), pCreature->GetRY(), pCreature->GetLayer(), &msg );
}

void SendStateMessage( const struct StructPlayer *pPlayer, AR_HANDLE target_handle, const struct StructState *p, bool bIsCancel )
{
	TS_SC_STATE msg;

	GenerateStateMessage( msg, target_handle, p, bIsCancel );
	PendMessage( pPlayer, &msg );
}

void SendSkillResetMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature )
{
	TS_SC_SKILL_LIST msg;		

	msg.count = 0;
	msg.modification_type = TS_SC_SKILL_LIST::REFRESH;
	msg.target = pCreature->GetHandle();

	PendMessage( pPlayer, &msg );
}

void SendSkillMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature, int skill_id, bool refresh )
{
	char buf[4096];

	TS_SC_SKILL_LIST msg;		

	msg.count = 0;
	msg.modification_type = refresh ? TS_SC_SKILL_LIST::REFRESH : TS_SC_SKILL_LIST::UPDATE;
	msg.target = pCreature->GetHandle();

	if( skill_id < 0 )
	{
		struct mySkillFunctor : StructCreature::SKILL_FUNCTOR
		{
			mySkillFunctor( const StructPlayer *p, char *q, int size ) : pPlayer( p ), pBuf( q ), nBufSize( size ), cnt(0)  {}

			virtual void onSkill( int sid, int skill_id, int base_skill_level, int current_skill_level, AR_TIME total_cool_time, AR_TIME remain_cool_time )
			{
				TS_SC_SKILL_LIST::SkillInfo info;
				info.skill_id = skill_id;
				info.base_skill_level = base_skill_level;
				info.current_skill_level = current_skill_level;
				info.total_cool_time = total_cool_time;
				info.remain_cool_time = remain_cool_time;

				assert( nBufSize >= sizeof(info) );
				if( nBufSize >= sizeof(info) )
				{
					s_memcpy( pBuf, nBufSize, &info, sizeof(info) );
					pBuf += sizeof(info);
					nBufSize -= sizeof(info);
					++cnt;
				}
				else
				{
					_cprint( "SendSkillMessage(skill_id) Creature INSUFFICIENT_BUFFER count: %d", cnt );
					FILELOG( "SendSkillMessage(skill_id) Creature INSUFFICIENT_BUFFER count: %d", cnt );
				}
			}
			unsigned cnt;
			char * pBuf;
			int nBufSize;
			const StructPlayer *pPlayer;
		} mySkillFunctorInst( pPlayer, buf + sizeof( msg ), sizeof(buf)-sizeof(msg) );

		pCreature->EnumSkill( mySkillFunctorInst );	
		msg.count = mySkillFunctorInst.cnt;
	}
	else if( pCreature->GetSkill( skill_id )->GetSkillUID() > 0 )
	{
		TS_SC_SKILL_LIST::SkillInfo info;
		info.skill_id = skill_id;
		info.base_skill_level = pCreature->GetBaseSkillLevel( skill_id );
		info.current_skill_level = pCreature->GetCurrentSkillLevel( skill_id );
		info.total_cool_time = pCreature->GetTotalCoolTime( skill_id );
		info.remain_cool_time = pCreature->GetRemainCoolTime( skill_id );

		msg.count = 1;
		s_memcpy( buf + sizeof(msg), sizeof( buf ) - sizeof( msg ), &info, sizeof(info) );
	}

	msg.size += msg.count * sizeof( TS_SC_SKILL_LIST::SkillInfo );

	s_memcpy( buf, sizeof( buf ), &msg, sizeof( msg ) );
	if( msg.count || msg.modification_type == TS_SC_SKILL_LIST::REFRESH )	PendStream( pPlayer, buf, msg.size );
}

void SendSkillMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature, std::vector< int > vSkill )
{
	char buf[4096];

	TS_SC_SKILL_LIST msg;		

	msg.count = 0;
	msg.modification_type = TS_SC_SKILL_LIST::UPDATE;
	msg.target = pCreature->GetHandle();

	struct mySkillFunctor : StructCreature::SKILL_FUNCTOR
	{
		mySkillFunctor( std::vector< int > & s, char *q, int size ) : vSkill( s ), pBuf( q ), nBuffSize( size ), cnt(0)  {}

		virtual void onSkill( int sid, int skill_id, int base_skill_level, int current_skill_level, AR_TIME total_cool_time, AR_TIME remain_cool_time )
		{
			std::vector< int >::iterator it = std::find( vSkill.begin(), vSkill.end(), skill_id );
			if( it != vSkill.end() )
			{
				TS_SC_SKILL_LIST::SkillInfo info;
				info.skill_id = skill_id;
				info.base_skill_level = base_skill_level;
				info.current_skill_level = current_skill_level;
				info.total_cool_time = total_cool_time;
				info.remain_cool_time = remain_cool_time;

				assert( nBuffSize >= sizeof(info) );
				if( nBuffSize >= sizeof(info) )
				{
					s_memcpy( pBuf, nBuffSize, &info, sizeof(info) );
					pBuf += sizeof(info);
					nBuffSize -= sizeof(info);
					++cnt;
				}
				else
				{
					_cprint( "SendSkillMessage(vSkill) Creature INSUFFICIENT_BUFFER count: %d", cnt );
					FILELOG( "SendSkillMessage(vSkill) Creature INSUFFICIENT_BUFFER count: %d", cnt );
				}

				vSkill.erase( it );
			}
		}

		std::vector< int > & vSkill;
		char * pBuf;
		int nBuffSize;
		unsigned cnt;
	} mySkillFunctorInst( vSkill, buf + sizeof( msg ), sizeof(buf)-sizeof(msg) );

	pCreature->EnumSkill( mySkillFunctorInst );

	msg.count = mySkillFunctorInst.cnt;
	msg.size += msg.count * sizeof( TS_SC_SKILL_LIST::SkillInfo );

	s_memcpy( buf, sizeof( buf ), &msg, sizeof( msg ) );
	if( msg.count )	PendStream( pPlayer, buf, msg.size );
}

void SendAddedSkillMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature )
{
	char buf[4096];

	TS_SC_ADDED_SKILL_LIST msg;

	msg.count = 0;
	msg.target = pCreature->GetHandle();

	struct mySkillFunctor : StructCreature::ADDED_SKILL_FUNCTOR
	{
		mySkillFunctor( const StructPlayer *p, char *q, int size ) : pPlayer( p ), pBuf( q ), nBuffSize( size ), cnt( 0 ) { }

		virtual void onSkill( int skill_id, bool restricted_to_type, char added_skill_level )
		{
			TS_SC_ADDED_SKILL_LIST::AddedSkillInfo info;
			info.skill_id = skill_id;
			info.restricted_to_type = restricted_to_type;
			info.added_skill_level = added_skill_level;
			
			assert( nBuffSize >= sizeof(info) );
			if( nBuffSize >= sizeof( info ) )
			{
				s_memcpy( pBuf, nBuffSize, &info, sizeof( info ) );
				pBuf += sizeof( info );
				nBuffSize -= sizeof( info );
				cnt++;
			}
			else
			{
				_cprint( "SendAddedSkillMessage() Creature INSUFFICIENT_BUFFER count: %d", cnt );
				FILELOG( "SendAddedSkillMessage() Creature INSUFFICIENT_BUFFER count: %d", cnt );
			}
		}

		unsigned cnt;
		char * pBuf;
		int nBuffSize;
		const StructPlayer *pPlayer;
	} mySkillFunctorInst( pPlayer, buf + sizeof( msg ), sizeof( buf ) - sizeof( msg ) );

	pCreature->EnumAddedSkill( mySkillFunctorInst );
	msg.count = mySkillFunctorInst.cnt;

	msg.size += msg.count * sizeof( TS_SC_ADDED_SKILL_LIST::AddedSkillInfo );

	s_memcpy( buf, sizeof( buf ), &msg, sizeof( msg ) );
	PendStream( pPlayer, buf, msg.size );
}

void SendSkillLevelMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature )
{
	char buf[4096];

	TS_SC_SKILL_LEVEL_LIST msg;		

	msg.count = 0;
	
	struct mySkillFunctor : StructCreature::SKILL_FUNCTOR
	{
		mySkillFunctor( const StructPlayer *p, char *q, int size ) : pPlayer( p ), pBuf( q ), nBuffSize( size ), cnt(0)  {}

		virtual void onSkill( int sid, int skill_id, int base_skill_level, int current_skill_level, AR_TIME total_cool_time, AR_TIME remain_cool_time )
		{
			TS_SC_SKILL_LEVEL_LIST::SkillLevelInfo info;
			info.skill_id = skill_id;
			info.skill_level = base_skill_level;
			
			assert( nBuffSize >= sizeof(info) );
			if( nBuffSize >= sizeof(info) )
			{
				s_memcpy( pBuf, nBuffSize, &info, sizeof(info) );
				pBuf += sizeof(info);
				nBuffSize -= sizeof(info);
				++cnt;
			}
			else
			{
				_cprint( "SendSkillLevelMessage() Creature INSUFFICIENT_BUFFER count: %d", cnt );
				FILELOG( "SendSkillLevelMessage() Creature INSUFFICIENT_BUFFER count: %d", cnt );
			}
		}
		unsigned cnt;
		char * pBuf;
		int nBuffSize;
		const StructPlayer *pPlayer;
	} mySkillFunctorInst( pPlayer, buf + sizeof( msg ), sizeof( buf ) - sizeof( msg ) );

	pCreature->EnumSkill( mySkillFunctorInst );	
	msg.count = mySkillFunctorInst.cnt;
	msg.size += msg.count * sizeof( TS_SC_SKILL_LEVEL_LIST::SkillLevelInfo );

	s_memcpy( buf, sizeof( buf ), &msg, sizeof( msg ) );
	PendStream( pPlayer, buf, msg.size );
}

void BroadcastSkillEffectMessage( const struct StructCreature *pCaster, const struct StructCreature *pTarget, int skill_level, int skill_id, int var1, unsigned char var2, char var3 )
{
	TS_SC_SKILL_EFFECT msg;
	msg.target = pTarget->GetHandle();
	msg.caster = pCaster->GetHandle();
	msg.var1 = var1;
	msg.var2 = var2;
	msg.var3 = var3;
	msg.skill_level = skill_level;
	msg.skill_id = skill_id;

	ArcadiaServer::Instance().Broadcast( pCaster->GetRX(), pCaster->GetRY(), pCaster->GetLayer(), &msg );
}

void SendDetectRangeMessage( const struct StructPlayer *pPlayer, const struct StructCreature *pCreature )
{
	TS_SC_DETECT_RANGE_UPDATE msg;
	msg.handle = pCreature->GetHandle();
	msg.detect_range = pCreature->GetDetectHideRange();
	PendMessage( pPlayer, &msg );
}

void SendTradeCancelMessage( struct StructPlayer * pClient )
{
	TS_TRADE msg;
	msg.mode = TS_TRADE::CANCEL_TRADE;
	msg.target_player = pClient->GetTradeTarget();
	PendMessage( pClient, &msg );
}

void SendCantAttackMsg( const struct StructPlayer *pPlayer, AR_HANDLE attacker_handle, AR_HANDLE target_handle, int reason )
{
	TS_SC_CANT_ATTACK msg;
	msg.attacker_handle = attacker_handle;
	msg.target_handle = target_handle;
	msg.reason = reason;
	PendMessage( pPlayer, &msg );
}

void SendAuraMsessage( const struct StructPlayer *pPlayer, const int skillId, const bool status )
{
	TS_SC_AURA msg;

	msg.caster = pPlayer->GetHandle();
	msg.skill_id = skillId;

	msg.status = status;

	PendMessage( pPlayer, &msg );
}

void SendAuraMsessage( const struct StructCreature *pCreature, const int skillId, const bool status )
{
	if( pCreature->IsPlayer() )
	{
		SendAuraMsessage( static_cast< const StructPlayer * >( pCreature ), skillId, status );
	}
	else if( pCreature->IsSummon() && static_cast< const StructSummon * >( pCreature )->GetMaster() )
	{
		SendAuraMsessage( static_cast< const StructSummon * >( pCreature )->GetMaster(), skillId, status);
	}
}

// 아래 구현이 더 효율적이지 않을까 싶음
/*
const	unsigned short TM_SC_PARTY_MEMBER_INFO		= 518;

struct TS_SC_PARTY_MEMBER_INFO : TS_MESSAGE
{
	TS_SC_PARTY_MEMBER_INFO()		_INIT( TM_SC_PARTY_MEMBER_INFO )

	AR_HANDLE		handle;
	int				level;
	int				job_id;
	unsigned char	hp_percentage;
	unsigned char	mp_percentage;
	int				x;
	int				y;

	unsigned char	name_length;
	char			name[];
};

void SendPartyMemberInfo( struct StructPlayer* pPlayer, struct StructPlayer* pTarget )
{
	char buf[256];
	TS_SC_PARTY_MEMBER_INFO* msg = reinterpret_cast< char* >( buf );

	msg->handle = pPlayer->GetHandle();
	msg->level = pPlayer->GetLevel();
	msg->job_id = pPlayer->GetJobId();
	msg->hp_percentage = pPlayer->GetHPPercentage();
	msg->mp_percentage = pPlayer->GetMPPercentage();
	msg->x = pPlayer->GetX();
	msg->y = pPlayer->GetY();
	msg->name_length = strlen( pPlayer->GetName() );	
	s_memcpy( msg+1, sizeof( buf ) - sizeof( msg ), pPlayer->GetName(), msg->name_length );
	msg->size += msg->size + msg->name_length;

	PendMessage( pTarget, msg );
}

void BroadcastPartyMemberInfo( int nPartyID, struct StructPlayer *pPlayer )
{
	struct myAttackTeamFunctor : PartyManager::PartyFunctor
	{
		myAttackTeamFunctor( StructPlayer *pPlayer ) : pPlayer( pPlayer ) {}

		virtual bool operator()( AR_HANDLE handle )
		{
			StructPlayer *pMember = static_cast< StructPlayer * >( GameObject::raw_get( *it ) );

			if( !pMember && IsVisibleRegion( pPlayer->GetRX(),  pPlayer->GetRY(), pMember->GetRX(), pMember->GetRX() )
			{
				SendPartyMemberInfo( pPlayer, pMember );
				return true;
			}
			else
			{
				return false
			}			
		}
		StructPlayer *pPlayer;
	} _fo( pPlayer, szString, nChatType );

	PartyManager::GetInstance().DoEachLinkedPartyMember( nPartyID, _fo );
}
*/

void BroadcastPartyMemberInfo( int nPartyID, struct StructPlayer *pPlayer )
{
	char buf[256];

	s_sprintf( buf, _countof( buf ), "MINFO|%u|%s|%d|%d|%d|%d|%d|%d|%d|", pPlayer->GetHandle(), pPlayer->GetAlias(), pPlayer->GetLevel(), pPlayer->GetJobId(), pPlayer->GetHPPercentage(), pPlayer->GetMPPercentage(), (int)pPlayer->GetX(), (int)pPlayer->GetY(), 2 );

	SendPartyChatMessage( CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, buf, (unsigned)strlen(buf) );
}

void BroadcastLinkedPartyMemberInfo( int nPartyID, struct StructPlayer *pPlayer )
{
	char buf[256];

	if( !PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
		return;

	s_sprintf( buf, _countof( buf ), "RMINFO|%u|%s|%d|%d|", pPlayer->GetHandle(), pPlayer->GetAlias(), pPlayer->GetJobId(), pPlayer->GetHPPercentage() != 0 );

	SendLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, buf );
}

void SendLinkedPartyChatMessage( bool bLock, int nChatType, const char *szSender, int nPartyID, const char *szString )
{
	struct myPartyFunctor : PartyManager::PartyFunctor
	{
		myPartyFunctor( const char *s, const char *p, int t ) : szSender( s ), pString( p ), nChatType( t ) {}

		virtual bool operator()( AR_HANDLE handle )
		{
			SendChatMessage( false, nChatType, szSender, handle, pString );

			return true;
		}
		int nChatType;
		const char *szSender;
		const char *pString;
	} _fo( szSender, szString, nChatType );

	if( PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
		PartyManager::GetInstance().DoEachLinkedPartyMember( nPartyID, _fo );
	else
		PartyManager::GetInstance().DoEachMember( nPartyID, _fo );
}

/*	TODO: Get player ID to check if he is in a guild and check if the guild has an alliance.
*	This should make it easier to collaborate on this shit
*/

void SendAttackTeamChatMessageByGuildID( bool bLock, int nChatType, const char *szSender, int nGuildID, const char *szString )
{
	int nPartyID = PartyManager::GetInstance().GetAttackTeamLeadPartyIDByGuildID( nGuildID );
	

	if (PartyManager::GetInstance().GetPartyType( nPartyID ) == PartyManager::TYPE_RAID_ATTACKTEAM) {
		if( !nPartyID )
			return;

		SendLinkedPartyChatMessage( bLock, nChatType, szSender, nPartyID, szString );
	}
}

void PrintfLinkedPartyChatMessage( bool bLock, int nChatType, const char *szSender, int nPartyID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendLinkedPartyChatMessage( bLock, nChatType, szSender, nPartyID, szBuf );
}

/*
*	This might be a clue since it takes the name of the sender as a parameter, the method that calls it should have info about the client.
*/
void PrintfAttackTeamChatMessageByGuildID( bool bLock, int nChatType, const char *szSender, int nGuildID, const char *szString, ... )
{
	char szBuf[2048];
	va_list va;
	va_start( va, szString );
	s_vsprintf( szBuf, _countof(szBuf), szString, va );
	va_end( va );

	SendAttackTeamChatMessageByGuildID( bLock, nChatType, szSender, nGuildID, szBuf);
}

void BroadcastLinkedPartyInfo( int nPartyID )
{
	std::string strLinkedPartyInfo = PartyManager::GetInstance().GetLinkedPartyInfo( nPartyID );

	if( !strLinkedPartyInfo.empty() )
		SendLinkedPartyChatMessage( false, CHAT_RAID_SYSTEM, "@RAID", nPartyID, strLinkedPartyInfo.c_str() );

}

void SendLinkedPartyInfo( struct StructPlayer *pPlayer )
{
	int nPartyID = pPlayer->GetPartyID();
	if( !nPartyID )
		return;

	if( !PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
		return;

	std::string strRaidPartyInfo = PartyManager::GetInstance().GetLinkedPartyInfo( nPartyID );

	SendChatMessage( false, CHAT_RAID_SYSTEM, "@RAID", pPlayer, strRaidPartyInfo.c_str() );
}

void BroadcastPartyLeave( struct StructPlayer *pPlayer, bool bByBattleArena )
{
	BroadcastPartyLeave( pPlayer->GetPartyID(), pPlayer->GetName(), bByBattleArena );
}

void BroadcastPartyLeave( int nPartyID, const char * pszName, bool bByBattleArena )
{
	PrintfLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, "LEAVE|%s|%d|", pszName, ( bByBattleArena ) ? 1 : 0 );
}

void BroadcastPartyDestroy( int nPartyID, bool bByBattleArena )
{
	// 시즈/레이드 공대 파티의 마스터 파티가 해산되는 경우에는 링크된 모든 파티의 파티원들에게 각각 자신의 파티가 해산되는 것을 방송
	if( PartyManager::GetInstance().IsAttackTeamParty( nPartyID ) && nPartyID == PartyManager::GetInstance().GetLinkedPartyLeadPartyID( nPartyID ) )
	{
		struct myPartyDestroyFunctor : PartyManager::PartyFunctor
		{
			myPartyDestroyFunctor( bool _bByBattleArena )
				: bByBattleArena( _bByBattleArena )
			{}

			virtual bool operator()( AR_HANDLE handle )
			{
				StructPlayer *pPlayer = static_cast< StructPlayer * >( GameObject::raw_get( handle ) );
				if( !pPlayer ) return true;

				PrintfChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", pPlayer, "DESTROY|%s|%d|", PartyManager::GetInstance().GetPartyName( pPlayer->GetPartyID() ).c_str(), ( bByBattleArena ) ? 1 : 0 );

				return true;
			}

			bool bByBattleArena;
		} _fo( bByBattleArena );

		PartyManager::GetInstance().DoEachLinkedPartyMember( nPartyID, _fo );
	}
	// 그 외에는 링크된 파티원 전원(링크된 파티가 없는 단일 파티라면 자기네 파티원 전원)이 해산된 파티에 대한 해산 메시지만 받으면 됨
	else
	{
		PrintfLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, "DESTROY|%s|%d|", PartyManager::GetInstance().GetPartyName( nPartyID ).c_str(), ( bByBattleArena ) ? 1 : 0 );
	}
}

void SendPartyInfoByID( struct StructPlayer *pPlayer, const int nPartyID )
{
	std::string strPartyInfo;

	// 배틀 아레나 연습 경기용 파티의 경우 경기 시작과 함께 실제 경기용 파티로 변경되므로 클라에는 무조건 실제 경기용 파티 타입으로 방송
	PartyManager::_PARTY_TYPE ePartyType = PartyManager::GetInstance().GetPartyType( nPartyID );
	XStringUtil::Format( strPartyInfo, "PINFO|%d|%s|%s|%d|%d|%d|%d|", nPartyID, PartyManager::GetInstance().GetPartyName( nPartyID ).c_str(),
		PartyManager::GetInstance().GetLeaderDisplayName( nPartyID ).c_str(), PartyManager::GetInstance().GetShareMode( nPartyID ),
		PartyManager::GetInstance().GetMaxLevel( nPartyID ), PartyManager::GetInstance().GetMinLevel( nPartyID ),
		( ePartyType != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM ) ? ePartyType : PartyManager::TYPE_BATTLE_ARENA_TEAM );

	struct myPartyMemberTagFunctor : public PartyManager::PartyMemberTagFunctor
	{
		myPartyMemberTagFunctor( std::string & _strPartyInfo )
			: strPartyInfo( _strPartyInfo )
		{}

		virtual bool operator()( PartyManager::PartyMemberTag * pMemberTag )
		{
			bool bIsProc = false;

			do
			{
				if( !pMemberTag->bIsOnline )
					break;

				StructPlayer::iterator pit = StructPlayer::get( StructPlayer::FindPlayer( pMemberTag->strName.c_str() ) );
				StructPlayer * pPlayer = *pit;
				if( !pPlayer )
					break;

				char buf[512];
				s_sprintf( buf, _countof( buf ), "%u|%s|%d|%d|%d|%d|%d|%d|%d|", pPlayer->GetHandle(), pMemberTag->strDisplayName.c_str(), pMemberTag->nLevel, pMemberTag->nJobId, pPlayer->GetHPPercentage(), pPlayer->GetMPPercentage(), (int)pPlayer->GetX(), (int)pPlayer->GetY(), 2 );
				strPartyInfo += buf;

				bIsProc = true;

			} while( false );

			if( !bIsProc )
			{
				char buf[512];
				s_sprintf( buf, _countof( buf ), "0|%s|%d|%d|0|0|0|0|0|", pMemberTag->strDisplayName.c_str(), pMemberTag->nLevel, pMemberTag->nJobId );
				strPartyInfo += buf;
			}

			return true;
		}

		std::string & strPartyInfo;
	} _fo( strPartyInfo );

	PartyManager::GetInstance().DoEachMemberTag( nPartyID, _fo );

	SendChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", pPlayer, strPartyInfo.c_str() );
}

void SendPartyInfo( struct StructPlayer *pPlayer )
{
	int nPartyID = pPlayer->GetPartyID();
	if( !nPartyID )
		return;

	SendPartyInfoByID( pPlayer, nPartyID );
}

void SendPartyPosition( struct StructPlayer *pPlayer )
{
	int nPartyID = pPlayer->GetPartyID();
	if( !nPartyID )
		return;

	struct myPartyFunctor : PartyManager::PartyFunctor
	{
		virtual bool operator()( AR_HANDLE handle )
		{
			StructPlayer *pPlayer = static_cast< StructPlayer * >( GameObject::raw_get( handle ) );
			if( !pPlayer ) return true;

			char buf[512];
			s_sprintf( buf, _countof( buf ), "%u|%d|%d|", pPlayer->GetHandle(), (int)pPlayer->GetX(), (int)pPlayer->GetY() );
			strList += buf;

			return true;
		}
		std::string					strList;
	} _fo;

	if( PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
	{
		PartyManager::GetInstance().DoEachLinkedPartyMember( nPartyID, _fo );

		PrintfLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, "PPOS|%s", _fo.strList.c_str() );
	}
	else
	{
		PartyManager::GetInstance().DoEachMember( nPartyID, _fo );

		PrintfChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", pPlayer, "PPOS|%s", _fo.strList.c_str() );
	}
}

void BroadcastGuildMemberInfo( int nGuildID, StructPlayer *pPlayer )
{
	char buf[256];

	s_sprintf( buf, _countof( buf ), "MINFO|%u|%s|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|", pPlayer->GetHandle(), pPlayer->GetName(), pPlayer->GetLevel(), pPlayer->GetJobId(), pPlayer->GetGuildPermission(), pPlayer->GetHPPercentage(), pPlayer->GetMPPercentage(), (int)pPlayer->GetX(), (int)pPlayer->GetY(), 2, pPlayer->GetGuildPoint(), pPlayer->GetGuildTotalPoint() );  //AziaMafia Fix guild
	SendGuildChatMessage( CHAT_GUILD_SYSTEM, "@GUILD", nGuildID, buf, (unsigned)strlen(buf) );

	s_sprintf( buf, _countof( buf ), "MEMO|%s|%s|", pPlayer->GetName(), GuildManager::GetInstance().GetMemberMemo( nGuildID, pPlayer->GetSID() ).c_str() );
	SendGuildChatMessage( CHAT_GUILD_SYSTEM, "@GUILD", nGuildID, buf, (unsigned)strlen(buf) );
}

void SendGuildStaticInfo( struct StructPlayer * pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	// 소유 중인 던전 ID 얻기(연합 관련 체크 적용)
	int nOwnDungeonID = 0;
	{
		int nAllianceID = GuildManager::GetInstance().GetAllianceID( nGuildID );
		int nRaidGuildID = nGuildID;
		if( nAllianceID )
			nRaidGuildID = GuildManager::GetInstance().GetAllianceLeaderGuildID( nAllianceID );

		nOwnDungeonID = GuildManager::GetInstance().GetRaidDungeonID( nRaidGuildID );

		// 레이드/시즈 진행 중이지만 주인은 아닌 경우에는 제외
		if( DungeonManager::Instance().GetOwnGuildID( nOwnDungeonID ) != nRaidGuildID )
			nOwnDungeonID = 0;
	}

	char buf[512];
	s_sprintf( buf, _countof( buf ), "GINFO|%d|%s|%s|%d|%s|%d|%d|%s|%d|%d|",
				nGuildID,
				GuildManager::GetInstance().GetGuildName( nGuildID ).c_str(),
				StructPlayer::GetPlayerName( GuildManager::GetInstance().GetLeaderSID( nGuildID ) ),
				GuildManager::GetInstance().GetMemberCount( nGuildID ),
				GuildManager::GetInstance().GetGuildNotice( nGuildID ).c_str(),
				GuildManager::GetInstance().IsRecruitingGuild( nGuildID ),
				nOwnDungeonID,
				GuildManager::GetInstance().GetGuildURL( nGuildID ).c_str(),
				GuildManager::GetInstance().GetGuildGrade( nGuildID ),
				GuildManager::GetInstance().GetGuildPoint( nGuildID ) );

	SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );

	SendGuildPermissionInfo( pPlayer );
	SendAllianceInfo( pPlayer );
	SendGuildAdvertiseInfo( pPlayer );

	// 길드의 던전 레이드/시즈 팁은 해당 UI를 열었을 때 클라이언트가 채팅 명령어를 서버로 전달하므로 그 때만 보내면 됨
	//SendGuildDungeonRaidSiegeTip( pPlayer );
}

void SendGuildMemberInfo( struct StructPlayer * pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	struct myGuildFunctor : GuildManager::GuildFunctor
	{
		myGuildFunctor( StructPlayer * pPlayer )
			: m_pPlayer( pPlayer )
		{}

		virtual bool operator()( AR_HANDLE handle )
		{
			StructPlayer * pPlayer = static_cast< StructPlayer * >( GameObject::raw_get( handle ) );
			if( !pPlayer ) return true;

			char buf[512];
			s_sprintf( buf, _countof( buf ), "GMEMBER|%u|%s|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|", pPlayer->GetHandle(), pPlayer->GetName(), pPlayer->GetLevel(), pPlayer->GetJobId(), pPlayer->GetGuildPermission(), pPlayer->GetHPPercentage(), pPlayer->GetMPPercentage(), (int)pPlayer->GetX(), (int)pPlayer->GetY(), 2, pPlayer->GetGuildPoint(), pPlayer->GetGuildTotalPoint() );
			SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", m_pPlayer, buf );

			return true;
		}

		StructPlayer * m_pPlayer;
	} _fo( pPlayer );

	GuildManager::GetInstance().DoEachMember( nGuildID, _fo );

	std::vector< GuildManager::GuildMemberTag > vList;
	GuildManager::GetInstance().GetOfflineMember( nGuildID, vList );

	char buf[512];
	for( std::vector< GuildManager::GuildMemberTag >::iterator it = vList.begin(); it != vList.end(); ++it )
	{
		s_sprintf( buf, _countof( buf ), "GMEMBER|0|%s|%d|%d|%d|0|0|0|0|0|%d|%d", StructPlayer::GetPlayerName( (*it).sid ), (*it).nLevel, (*it).nJobId, (*it).nPermission, (*it).nPoint, (*it).nTotalPoint );
		SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );
	}

	struct myGuildMemoFunctor : GuildManager::GuildMemberTagFunctor
	{
		myGuildMemoFunctor( StructPlayer * pPlayer )
			: m_pPlayer( pPlayer )
		{}

		virtual bool operator()( GuildManager::GuildMemberTag * pMemberTag )
		{
			char szBuffer[256];
			s_sprintf( szBuffer, _countof( szBuffer ), "MEMO|%s|%s|", StructPlayer::GetPlayerName( pMemberTag->sid ), pMemberTag->strMemo.c_str() );
			SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", m_pPlayer, szBuffer );

			return true;
		}

	private:
		StructPlayer *	m_pPlayer;
	} _foMemo( pPlayer );

	GuildManager::GetInstance().DoEachMemberTag( nGuildID, _foMemo );
}

void SendGuildInfo( StructPlayer *pPlayer )
{
	SendGuildStaticInfo( pPlayer );
	SendGuildMemberInfo( pPlayer );
}

void SendGuildPermissionInfo( struct StructPlayer *pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	char buf[512];

	s_sprintf( buf, _countof( buf ), "GPERMISSION|%s|%d|%s|%d|%s|%d|%s|%d|%s|%d|%s|%d|",
				// PERMISSION_MEMBER_LEAST = 1
				GuildManager::GetInstance().GetPermissionName( nGuildID, 1 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 1 ),
				GuildManager::GetInstance().GetPermissionName( nGuildID, 2 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 2 ),
				GuildManager::GetInstance().GetPermissionName( nGuildID, 3 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 3 ),
				GuildManager::GetInstance().GetPermissionName( nGuildID, 4 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 4 ),
				GuildManager::GetInstance().GetPermissionName( nGuildID, 5 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 5 ),
				GuildManager::GetInstance().GetPermissionName( nGuildID, 6 ).c_str(), GuildManager::GetInstance().GetPermissionSet( nGuildID, 6 ) );
				// PERMISSION_MEMBER_MAX = 6

	SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );
}

void getAllianceInfo( const int nAllianceID, char * pszBuf, size_t buf_len )
{
	int nLength = s_sprintf( pszBuf, buf_len, "AINFO|%d|%s|%d|%d|", nAllianceID, GuildManager::GetInstance().GetAllianceName( nAllianceID ).c_str(),
		GuildManager::GetInstance().GetAllianceMemberGuildCount( nAllianceID ), GuildManager::GetInstance().GetAllianceLeaderGuildID( nAllianceID ) );

	if( nLength < 0 )
	{
		return;
	}

	struct _myAllianceMemberFunctor : GuildManager::GuildListFunctor
	{
		_myAllianceMemberFunctor( char * pszBuffer, size_t len ) : m_pszBuffer( pszBuffer ), m_bufLen( len ) {}

		virtual bool operator()( int nGuildID, const char * szGuildName, const char * szGuildLeaderName, int nGuildLeaderLevel, int nGuildMemberCount, int nRaidDungeonID )
		{
			int nLength = s_sprintf( m_pszBuffer, m_bufLen, "%d|%s|%s|%d|", nGuildID, szGuildName, szGuildLeaderName, nGuildMemberCount );
			assert( nLength > 0 );
			if( nLength > 0 && m_bufLen >= nLength )
			{
				m_pszBuffer += nLength;
				m_bufLen -= nLength;
			}

			return true;
		}

		char * m_pszBuffer;
		size_t m_bufLen;
	} _fo( pszBuf + nLength, buf_len - nLength );

	GuildManager::GetInstance().DoEachAllianceGuild( nAllianceID, _fo );
}

void SendAllianceInfo( struct StructPlayer *pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	int nAllianceID = GuildManager::GetInstance().GetAllianceID( nGuildID );
	if( !nAllianceID )
		return;

	char buf[ 1024 ];
	getAllianceInfo( nAllianceID, buf, _countof( buf ) );

	SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );
}

void BroadcastAllianceInfo( const int nAllianceID )
{
	char buf[ 1024 ];
	getAllianceInfo( nAllianceID, buf, _countof( buf ) );

	std::vector< int > & vGuildList = GuildManager::GetInstance().GetAllianceMemberID( nAllianceID );
	for( std::vector< int >::const_iterator it = vGuildList.begin() ; it != vGuildList.end() ; ++it )
	{
		SendGuildChatMessage( CHAT_GUILD_SYSTEM, "@GUILD", (*it), buf );
	}
}

void SendGuildAdvertiseInfo( struct StructPlayer *pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	char buf[512];

	s_sprintf( buf, _countof( buf ), "GADV|%d|%d|%s|", GuildManager::GetInstance().GetGuildAdvertiseType( nGuildID ),
		static_cast< int >( GuildManager::GetInstance().GetGuildAdvertiseEndTime( nGuildID ) - time( NULL ) ),
		GuildManager::GetInstance().GetGuildAdvertiseComment( nGuildID ).c_str() );

	SendChatMessage( false, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );
}

void SendGuildDungeonRaidSiegeTip( struct StructPlayer *pPlayer )
{
	int nGuildID = pPlayer->GetGuildID();
	if( !nGuildID )
		return;

	int nAllianceID = GuildManager::GetInstance().GetAllianceID( nGuildID );
	int nRaidGuildID = nGuildID;
	if( nAllianceID )
		nRaidGuildID = GuildManager::GetInstance().GetAllianceLeaderGuildID( nAllianceID );

	int nDungeonID = GuildManager::GetInstance().GetRaidDungeonID( nRaidGuildID );

	char buf[512];

	// 레이드 신청 전에는 자신의 길드에 대한 정보만 송신
	if( !nDungeonID )
	{
		s_sprintf( buf, _countof( buf ), "GRAIDSIEGETIP|0|0| | |0|0|" );
	}
	else
	{
		int nType = 0;
		int nTipGuildID = 0;
		AR_TIME nTipRecord = 0;

		// 레이드 기간이면 레이드 1위 길드 정보 확인
		if( DungeonManager::Instance().IsDungeonRaidTime( nDungeonID ) )
		{
			nType = 1;
			DungeonManager::Instance().GetTopDungeonRaidRecord( nDungeonID, nTipGuildID, nTipRecord );
		}
		// 시즈 기간이면
		else
		{
			// 주인 길드면 공격자 길드 정보 확인
			int nOwnerGuildID = DungeonManager::Instance().GetOwnGuildID( nDungeonID );
			if( nGuildID == nOwnerGuildID )
			{
				nType = 2;
				nTipGuildID = DungeonManager::Instance().GetRaidGuildID( nDungeonID );
				nTipRecord = DungeonManager::Instance().GetDungeonRaidRecord( nDungeonID, nTipGuildID );
			}
			// 공격자 길드면 주인 길드 정보 확인
			else
			{
				nType = 3;
				nTipGuildID = nOwnerGuildID;
			}
		}

		// 팁에 해당하는 길드에 대한 추가 정보 획득 및 방송 내용 생성
		if( nTipGuildID )
		{
			int nTipAllianceID = GuildManager::GetInstance().GetAllianceID( nTipGuildID );

			// 팁 길드가 연합 소속인 경우
			if( nTipAllianceID )
			{
				s_sprintf( buf, _countof( buf ), "GRAIDSIEGETIP|%d|%d|%s(%s)|%s|%d|%d|",
					nType, nTipRecord, GuildManager::GetInstance().GetAllianceName( nTipAllianceID ).c_str(),
					GuildManager::GetInstance().GetGuildName( nTipGuildID ).c_str(),
					StructPlayer::GetPlayerName( GuildManager::GetInstance().GetLeaderSID( nTipGuildID ) ),
					GuildManager::GetInstance().GetAllianceMemberPlayerCount( nTipAllianceID ), nDungeonID );
			}
			else
			{
				s_sprintf( buf, _countof( buf ), "GRAIDSIEGETIP|%d|%d|%s|%s|%d|%d|",
					nType, nTipRecord, GuildManager::GetInstance().GetGuildName( nTipGuildID ).c_str(),
					StructPlayer::GetPlayerName( GuildManager::GetInstance().GetLeaderSID( nTipGuildID ) ),
					GuildManager::GetInstance().GetMemberCount( nTipGuildID ), nDungeonID );
			}
		}
		else
		{
			s_sprintf( buf, _countof( buf ), "GRAIDSIEGETIP|%d|%d| | |0|%d|", nType, nTipRecord, nDungeonID );
		}
	}

	SendChatMessage( FALSE, CHAT_GUILD_SYSTEM, "@GUILD", pPlayer, buf );
}

void SendSummonInfo( struct StructPlayer *pPlayer )
{
	int nPartyID = pPlayer->GetPartyID();
	if( !nPartyID )
		return;

	std::string strSummonInfo;

	if( PartyManager::GetInstance().IsLinkedParty( nPartyID ) )
	{
		strSummonInfo = PartyManager::GetInstance().GetLinkedPartySummonInfo( nPartyID );
	}
	else
	{
		strSummonInfo = PartyManager::GetInstance().GetSummonInfo( nPartyID );
	}	
	
	SendChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", pPlayer, strSummonInfo.c_str() );
}

void BroadcastSummonInfo( int nPartyID, struct StructPlayer *pPlayer, bool bForce )
{
	if( !nPartyID )
		return;

	int nMainSummonHandle = pPlayer->GetMainSummon() ? pPlayer->GetMainSummon()->GetHandle() : 0;
	int nSubSummonHandle = pPlayer->GetSubSummon() ? pPlayer->GetSubSummon()->GetHandle() : 0;

	if( !bForce && !nMainSummonHandle && !nSubSummonHandle )
		return;

	PrintfLinkedPartyChatMessage( false, CHAT_PARTY_SYSTEM, "@PARTY", nPartyID, "MSINFO|%d|%d|%d|%d|", nPartyID, pPlayer->GetHandle(), nMainSummonHandle, nSubSummonHandle );
}

void SendBeltSlotInfo( struct StructPlayer *pPlayer )
{
	TS_SC_BELT_SLOT_INFO msg;
	
	for( int i = 0; i < 8; ++i )
	{
		StructItem * pItem = pPlayer->GetBeltSlotCardAt( i );
		msg.handle[i] = pItem ? pItem->GetHandle() : 0;
	}

	PendMessage( pPlayer, &msg );
}

void SendOpenStorageMessage( struct StructPlayer *pPlayer )
{
	TS_SC_OPEN_STORAGE msg;
	msg.maxStorageItemCount = GameRule::nMaxStorageItemCount;
	PendMessage( pPlayer, &msg );
}

void SendJobInfo( struct StructPlayer *pPlayer, struct StructCreature *pCreature )
{
	SendPropertyMessage( pPlayer, pCreature->GetHandle(), "job", pCreature->GetJobId() );
	SendPropertyMessage( pPlayer, pCreature->GetHandle(), "job_level", pCreature->GetJobLevel() );
	for( int i = 0; i < GameRule::MAX_JOB_DEPTH - 1; ++i )
	{
		char buf[56];
		s_sprintf( buf, _countof( buf ), "job_%d", i );
		SendPropertyMessage( pPlayer, pCreature->GetHandle(), buf, pCreature->GetPrevJobId( i ) );
		s_sprintf( buf, _countof( buf ), "jlv_%d", i );
		SendPropertyMessage( pPlayer, pCreature->GetHandle(), buf, pCreature->GetPrevJobLevel( i ) );
	}
}

void SendTargetMsg( const struct StructPlayer *pPlayer, AR_HANDLE target )
{
	TS_SC_TARGET msg;
	msg.target = target;
	PendMessage( pPlayer, &msg );
}

void SendLeaveMsg( const ArObject * pClient, const ArObject * pObj )
{
	GameObject *pPtr = GameObject::raw_get( pObj->GetHandle() );
	if( !pPtr )
	{
		return;
	}

	//if( pClient != pObj && pPtr->IsPlayer() && static_cast< StructPlayer * >(pPtr)->IsInvisible() )
	//{
	//	return;
	//}

	TS_LEAVE msg;
	msg.handle = pObj->GetHandle();

/*	GameObject *pPtr = GameObject::raw_get( pObj->GetHandle() );

	if( pPtr )
	{

		if( pPtr->IsSummon() )
		{
			const StructSummon * pSummon = static_cast< const StructSummon * >( pObj );

			if( pSummon->GetSummonFlag() && !pSummon->IsWarping() && pSummon->GetMaster() == static_cast< const StructPlayer * >( pClient ) )
				return;
		}
	}
*/
	PendMessage( pClient, &msg );
}

void SendEnterMsg( const ArObject * pClient, const ArObject * pObj )
{
	char buf[1024];
	assert( sizeof(TS_ENTER) < sizeof(buf) );
 	TS_ENTER *pMsg = new (buf) TS_ENTER();
	ArPosition pos = pObj->GetCurrentPosition( GetArTime() );
	pMsg->x = pos.x;
	pMsg->y = pos.y;
	pMsg->z = pos.z;
	//pMsg->x = pObj->GetX();
	//pMsg->y = pObj->GetY();
	//pMsg->z = pObj->GetZ();
	pMsg->layer = pObj->GetLayer();
	pMsg->handle = pObj->GetHandle();

	GameObject *pPtr = GameObject::raw_get( pObj->GetHandle() );
	if( !pPtr )
	{
		//assert( 0 );
		return;
	}
	StructCreature *pCreature = NULL;
	bool bIsNeedStateNotify = false;

	switch( pObj->GetObjectType() )
	{
		case ArObject::STATIC_OBJECT:	
		{
			pMsg->type = TS_ENTER::STATIC_OBJECT;
			if( pPtr->IsItem() ) 
			{
				StructItem *pItem = static_cast< StructItem * >( pPtr );
				pMsg->ObjType = TS_ENTER::GAME_ITEM;

				TS_ENTER::ItemInfo *pItemInfo = (TS_ENTER::ItemInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::ItemInfo);

				pItemInfo->code = pItem->GetItemCode();
				pItemInfo->cnt = pItem->GetCount();
				pItemInfo->pick_up_order.drop_time = pItem->GetDropTime();

				const StructItem::ITEM_PICKUP_ORDER & ItemPickupOrder = pItem->GetPickupOrder();

				for( int i = 0; i < 3; i++ )
				{
					pItemInfo->pick_up_order.hPlayer[i] = ItemPickupOrder.hPlayer[i];
					pItemInfo->pick_up_order.nPartyID[i] = ItemPickupOrder.nPartyID[i];
				}

			}
			else if( pPtr->IsSkillProp() )
			{
				StructSkillProp *pSkillProp = static_cast< StructSkillProp * >( pPtr );
				pMsg->ObjType = TS_ENTER::GAME_SKILL_PROP;

				TS_ENTER::SkillInfo *pSkillInfo = (TS_ENTER::SkillInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::SkillInfo);

				pSkillInfo->caster = pSkillProp->GetCasterHandle();
				pSkillInfo->skill_num = pSkillProp->GetSkillId();
				pSkillInfo->start_time = pSkillProp->GetStartTime();
			}
			else if( pPtr->IsFieldProp() )
			{
				StructFieldProp *pFieldProp = static_cast< StructFieldProp * >( pPtr );
				pMsg->ObjType = TS_ENTER::GAME_FIELD_PROP;

				TS_ENTER::FieldPropInfo *pPropInfo = (TS_ENTER::FieldPropInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::FieldPropInfo);

				pPropInfo->prop_id = pFieldProp->GetPropId();
				pPropInfo->fZOffset = pFieldProp->GetZOffset();
				pPropInfo->fRotateX = pFieldProp->GetRotateX();
				pPropInfo->fRotateY = pFieldProp->GetRotateY();
				pPropInfo->fRotateZ = pFieldProp->GetRotateZ();
				pPropInfo->fScaleX = pFieldProp->GetScaleX();
				pPropInfo->fScaleY = pFieldProp->GetScaleY();
				pPropInfo->fScaleZ = pFieldProp->GetScaleZ();
				pPropInfo->bLockHeight = pFieldProp->IsHeightLocked();
				pPropInfo->fLockHeight = pFieldProp->GetLockHeight();
			}
			break;
		}
		case ArObject::MOVABLE_OBJECT:
		{
			pMsg->type = TS_ENTER::NPC;

			if( pPtr->IsNPC() )
			{
				pMsg->ObjType = TS_ENTER::GAME_NPC;

				TS_ENTER::NPCInfo *pNPCInfo = (TS_ENTER::NPCInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::NPCInfo);

				pNPCInfo->face_direction = static_cast<StructNPC*>( pPtr )->GetFace();
				pNPCInfo->npc_id = static_cast<StructNPC*>( pPtr )->GetNPCID();
				pNPCInfo->hp = 100;
				pNPCInfo->max_hp = 100;
				pNPCInfo->mp = 0;
				pNPCInfo->max_mp = 0;
				pNPCInfo->level = static_cast<StructNPC*>( pPtr )->GetLevel();
				pNPCInfo->skin_color = static_cast<StructNPC*>( pPtr )->GetSkinColor();
				pNPCInfo->is_first_enter = false;
				pNPCInfo->energy = static_cast<StructNPC*>( pPtr )->GetEnergyCount();
				pNPCInfo->status = GetStatusCode( static_cast<StructPlayer*>( pPtr ), static_cast< const StructPlayer* >( pClient ) );

				// _cprint( "NPC ENTER : %s <- %s\n", static_cast< const StructPlayer*>( pClient )->GetName(), static_cast<const StructNPC*>( pPtr )->GetName() );
			}
			if( pPtr->IsMonster() )
			{
				pMsg->ObjType = TS_ENTER::GAME_MOB;

				TS_ENTER::MonsterInfo *pMonsterInfo = (TS_ENTER::MonsterInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::MonsterInfo);

				pMonsterInfo->face_direction = static_cast<StructMonster*>( pPtr )->GetFace();
				pMonsterInfo->monster_id = bits_scramble< int, 3 >( static_cast<StructMonster*>( pPtr )->GetMonsterId() );
				pMonsterInfo->race = static_cast<StructCreature*>( pPtr )->GetCreatureGroup();
				pMonsterInfo->hp = static_cast<StructCreature*>( pPtr )->GetHP();
				pMonsterInfo->max_hp = static_cast<StructCreature*>( pPtr )->GetMaxHP();
				pMonsterInfo->mp = static_cast<StructCreature*>( pPtr )->GetMP();
				pMonsterInfo->max_mp = static_cast<StructCreature*>( pPtr )->GetMaxMP();
				pMonsterInfo->level = static_cast<StructCreature*>( pPtr )->GetLevel();
				pMonsterInfo->skin_color = static_cast<StructCreature*>( pPtr )->GetSkinColor();
				pMonsterInfo->is_first_enter = static_cast<StructCreature*>( pPtr )->IsFirstEnter();
				pMonsterInfo->energy = static_cast<StructCreature*>( pPtr )->GetEnergyCount();
				pMonsterInfo->is_tamed = !!static_cast<StructMonster*>( pPtr )->GetTamer();
				pMonsterInfo->status = GetStatusCode( static_cast<StructPlayer*>( pPtr ), static_cast< const StructPlayer* >( pClient ) );

				if( static_cast<StructCreature*>( pPtr )->IsNeedStateNotify() )
				{
					pCreature = static_cast<StructCreature*>( pPtr );
					bIsNeedStateNotify = true;
				}
			}
			else if( pPtr->IsSummon() )
			{
				pMsg->ObjType = TS_ENTER::GAME_SUMMON;

				TS_ENTER::SummonInfo *pSummonInfo = (TS_ENTER::SummonInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::SummonInfo);

				StructSummon *pSummon = static_cast< StructSummon * >( pPtr );
				if( !pSummon ) break;

				pSummonInfo->face_direction = pSummon->GetFace();
				pSummonInfo->summon_code = pSummon->GetSummonCode();
				pSummonInfo->master_handle = pSummon->GetMaster()->GetHandle();
				s_strcpy( pSummonInfo->szName, _countof( pSummonInfo->szName ), pSummon->GetName() );
				pSummonInfo->race = pSummon->GetCreatureGroup();
				pSummonInfo->hp = pSummon->GetHP();
				pSummonInfo->max_hp = pSummon->GetMaxHP();
				pSummonInfo->mp = pSummon->GetMP();
				pSummonInfo->max_mp = pSummon->GetMaxMP();
				pSummonInfo->level = pSummon->GetLevel();
				pSummonInfo->skin_color = pSummon->GetSkinColor();
				pSummonInfo->is_first_enter = pSummon->IsFirstEnter();
				pSummonInfo->energy = pSummon->GetEnergyCount();
				pSummonInfo->enhance = 0;
				if( pSummon->GetParentCard() )
					pSummonInfo->enhance = pSummon->GetParentCard()->GetItemEnhance();
				if( pSummon->IsNeedStateNotify() )
				{
					pCreature = static_cast<StructCreature*>( pSummon );
					bIsNeedStateNotify = true;
				}
			}
			else if( pPtr->IsPet() )
			{
				pMsg->ObjType = TS_ENTER::GAME_PET;

				TS_ENTER::PetInfo *pPetInfo = (TS_ENTER::PetInfo*)(pMsg+1);
				pMsg->size += sizeof(TS_ENTER::PetInfo);

				StructPet *pPet = static_cast< StructPet * >( pPtr );
				pPetInfo->face_direction = pPet->GetFace();
				pPetInfo->pet_code = pPet->GetPetCode();
				pPetInfo->master_handle = pPet->GetMaster()->GetHandle();
				s_strcpy( pPetInfo->szName, _countof( pPetInfo->szName ), pPet->GetName() );
				pPetInfo->race = pPet->GetCreatureGroup();
				pPetInfo->hp = 100;			// 사용 안 함
				pPetInfo->max_hp = 100;		// 사용 안 함
				pPetInfo->mp = 100;			// 사용 안 함
				pPetInfo->max_mp = 100;		// 사용 안 함
				pPetInfo->level = 1;		// 사용 안 함
				pPetInfo->skin_color = 0;	// 사용 안 함
				pPetInfo->is_first_enter = pPet->IsFirstEnter();
				pPetInfo->energy = 0;		// 사용 안 함

				if( pPet->IsNeedStateNotify() )
				{
					pCreature = static_cast<StructCreature*>( pPet );
					bIsNeedStateNotify = true;
				}
			}
			else if( pPtr->IsRoamer() )
			{
				// StructRoamer 객체에 대한 엔터 메시지는 유저한테 보내지 않음 -_ -;
				return;
			}
			else
			{
				pMsg->ObjType = TS_ENTER::GAME_NPC;
			}
			
			break;
		}
		case ArObject::CLIENT_OBJECT:
		{
			pMsg->type = TS_ENTER::PLAYER;
			pMsg->ObjType = TS_ENTER::GAME_PLAYER;

			TS_ENTER::PlayerInfo * pPlayerInfo = (TS_ENTER::PlayerInfo*)(pMsg+1);
			pMsg->size += sizeof(TS_ENTER::PlayerInfo);

			StructPlayer * pPlayer = static_cast< StructPlayer * >( pPtr );
			
			pPlayerInfo->hp = pPlayer->GetHP();
			pPlayerInfo->max_hp = pPlayer->GetMaxHP();

			pPlayerInfo->mp = pPlayer->GetMP();
			pPlayerInfo->max_mp = pPlayer->GetMaxMP();
			pPlayerInfo->level = pPlayer->GetLevel();

			pPlayerInfo->race = pPlayer->GetRace();
			pPlayerInfo->skin_color = pPlayer->GetSkinColor();

			// 캐릭터의 이름 세팅(가명 기능에 따른 추가 처리 포함)
			{
				// 가명 사용 여부 세팅과는 별개로 아레나 경기장 내부에서만 엔터 메시지를 가명으로 보내야 함
				// * 보통 Enter 메시지 방송 후에 pPlayer->ChangeLocation 함수가 호출되기 때문에
				//   m_pWorldLocation 이나 m_nWorldLocationId 에 의존해서 아레나 경기장 내부인지 판별하면 안 됨
				//   이 지점에서 유효한 정보는 좌표밖에 없음...;;;

				bool bUseAlias = false;
				// 가장 부담되는 GetLocationId, GetLocationType의 호출을 가능한 피하기 위해
				// 가명 기능이 활성화돼있고 경기에 참여 중인 유저만 위치 체크 진행
				if( pPlayer->IsUsingAlias() && pPlayer->GetBattleArenaInstanceNo() )
				{
					int nLocationID = GameContent::GetLocationId( pos.x, pos.y );
					if( nLocationID && WorldLocationManager::Instance().GetLocationType( nLocationID ) == StructWorldLocation::LOCATION_BATTLE_ARENA )
					{
						s_strcpy( pPlayerInfo->szName, _countof( pPlayerInfo->szName ), pPlayer->GetAlias() );
						bUseAlias = true;
					}
				}
				if( !bUseAlias )
				{
					s_strcpy( pPlayerInfo->szName, _countof( pPlayerInfo->szName ), pPlayer->GetName() );
				}
			}

			pPlayerInfo->sex = pPlayer->GetSex();

			// 오토들 덕분에 생긴 찌꺼기 정보가 ObjType 0에 성별, 종족이 0으로 날아간다.
			// 이런 경우는 그냥 무시해주자. 실제로 플레이어라면 둘 중 어떤 것도 0은 될 수 없다.
			if( !pPlayerInfo->race || !pPlayerInfo->sex )
			{
				FILELOG("TS_ENTER: Invalid object info - Postion: (%d, %d, %d) / Handle: %d", pMsg->x, pMsg->y, pMsg->layer, pMsg->handle );
				return;
			}

			// 투명인 케릭터는 엔터 메시지를 안보내기
			//if( pObj != pClient && static_cast< StructCreature * >(pPtr)->IsInvisible() )
			//{
			//	return;
			//}

			pPlayerInfo->face_direction = pPlayer->GetFace();
			pPlayerInfo->is_first_enter = pPlayer->IsFirstEnter();
			pPlayerInfo->energy = pPlayer->GetEnergyCount();
			pPlayerInfo->faceId = pPlayer->GetBaseModelId( 1 );
			pPlayerInfo->faceTextureId = pPlayer->GetFaceTextureId();
			pPlayerInfo->hairId = pPlayer->GetBaseModelId( 0 );
			pPlayerInfo->hairColorIndex = pPlayer->GetHairColorIndex();
			pPlayerInfo->hairColorRGB = pPlayer->GetHairColorRGB();

			pPlayerInfo->hideEquipFlag = pPlayer->GetHideEquipFlag();

			pPlayerInfo->job_id	= pPlayer->GetJobId();
			pPlayerInfo->status = GetStatusCode( pPlayer, static_cast< const StructPlayer* >( pClient ) );
			pPlayerInfo->ride_handle = pPlayer->GetRideHandle();

			if( pPlayerInfo->ride_handle )
			{
				SendEnterMsg( pClient, pPlayer->GetRideObject() );
			}

			if( pPlayer->IsNeedStateNotify() )
			{
				pCreature = pPlayer;
				bIsNeedStateNotify = true;
			}

			pPlayerInfo->guild_id = pPlayer->GetGuildID();
			pPlayerInfo->title_code = pPlayer->GetMainTitle() ? pPlayer->GetMainTitle()->nID : 0;

			StructItem * pItem = pPlayer->GetWearedItem( ItemBase::WEAR_BACKBOARD );

			pPlayerInfo->back_board = pItem ? pItem->GetItemBase().nCode : 0;

			break;
		}
	}

	// 엔터 메세지 전송
	PendMessage( pClient, pMsg );
	
	// 이동중인 녀석이라면 이동정보 보내주자
	if( pObj->GetObjectType() != ArObject::STATIC_OBJECT && pObj->IsMoving() )
	{
		SendMoveMsg( pClient, static_cast< const ArObject* >( pObj ) );
	}

	// 플레이어라면 아이템 정보 보내주자
	if( pMsg->type == TS_ENTER::PLAYER )
	{
		TS_WEAR_INFO wearInfo;
		GetWearMsg( static_cast<StructPlayer*>( pPtr ), wearInfo );
		PendMessage( pClient, &wearInfo );
	}

	// 상태이상
	if( bIsNeedStateNotify && pCreature )
	{
		const std::vector< StructState > & vStateList = pCreature->GetStateList();

		for( std::vector< StructState >::const_iterator it = vStateList.begin(); it != vStateList.end(); ++it )
		{
			//if( (*it).IsNeedDisplay() )
			//{
				SendStateMessage( static_cast< const StructPlayer* >( pClient ), pCreature->GetHandle(), &(*it) );
			//}
		}
	}
}

void SendMoveMsg( const ArObject * pClient, const ArObject * pObj )
{
	size_t nSize = sizeof( TS_MOVE ) + sizeof( TS_MOVE::MOVE_INFO ) * pObj->GetTargetPosList().size();
	if ( nSize > SENDMSG_BUFFER_SIZE )
	{
		FILELOG( "SendMoveMsg too big : %d", nSize );
		_cprint( "SendMoveMsg too big : %d", nSize );
		return;
	}
	char buf[SENDMSG_BUFFER_SIZE];

	// char * buf = new char[ sizeof( TS_MOVE ) + sizeof( TS_MOVE::MOVE_INFO ) * pObj->GetTargetPosList().size() ];

	TS_MOVE * pMsg = new (buf) TS_MOVE();

	pMsg->handle = pObj->GetHandle();
	pMsg->start_time = pObj->lastStepTime;
	pMsg->speed = pObj->GetSpeed();
	pMsg->count = static_cast<unsigned short>( pObj->GetTargetPosList().size() );
	pMsg->size += sizeof( TS_MOVE::MOVE_INFO ) * pMsg->count;
	pMsg->tlayer = pObj->GetLayer();

	TS_MOVE::MOVE_INFO * pMoveInfo = reinterpret_cast< TS_MOVE::MOVE_INFO * >( pMsg + 1 );
	std::vector< ArMoveVector::MOVE_INFO >::const_iterator it;

	for( it = pObj->GetTargetPosList().begin(); it != pObj->GetTargetPosList().end(); ++it, ++pMoveInfo )
	{
		pMoveInfo->tx = (*it).end.x;
		pMoveInfo->ty = (*it).end.y;
	}

	PendStream( pClient, buf, pMsg->size );

	// delete [] buf;
}

void SendForceMoveMsg( const ArObject * pClient, const ArObject * pObj )
{
	TS_FORCE_MOVE msg;
	msg.handle = pObj->GetHandle();
	msg.x = pObj->GetX();
	msg.y = pObj->GetY();
	msg.z = pObj->GetZ();
	msg.layer = pObj->GetLayer();
	msg.face = pObj->GetFace();

	PendMessage( pClient, &msg );
}

void SendQuestList( struct StructPlayer *pPlayer )
{
	// 패킷 버퍼(TS_SC_QUEST_LIST 패킷의 예측 가능한 최대 크기 만큼 할당, TS_QUEST_INFO가 TS_PENDING_QUEST_INFO 보다 크다고 가정함)
	char szBuf[ SENDMSG_BUFFER_SIZE ];
	memset( szBuf, 0, sizeof( szBuf ) );

	TS_SC_QUEST_LIST * pMsg = new (szBuf) TS_SC_QUEST_LIST;

	// 시작되었던 퀘스트 정보 버퍼에 복사
	struct myActiveQuestFunctor : public StructQuestManager::QuestFunctor
	{
		myActiveQuestFunctor( TS_SC_QUEST_LIST::TS_QUEST_INFO * pQuestInfoBuffer ) : m_pQuestInfoBuffer( pQuestInfoBuffer ) {}

		virtual bool operator()( StructQuest * pQuest )
		{
			m_pQuestInfoBuffer->code = pQuest->GetQuestCode();
			m_pQuestInfoBuffer->nStartID = pQuest->GetQuestInstance().nStartID;
			m_pQuestInfoBuffer->nProgress = ( pQuest->IsFinishable() ) ? QuestInstance::FINISHABLE : pQuest->GetProgress();
			m_pQuestInfoBuffer->nTimeLimit = ( pQuest->GetTimeLimitType() != QuestBase::TIME_LIMIT_TYPE_PERMANENT ) ? pQuest->GetTimeLimit() : 0;

			s_memcpy( m_pQuestInfoBuffer->nStatus, sizeof( m_pQuestInfoBuffer->nStatus ), pQuest->GetQuestInstance().nStatus, sizeof( m_pQuestInfoBuffer->nStatus ) );

			if( pQuest->IsRandomQuest() )
			{
				m_pQuestInfoBuffer->nValue[0] = pQuest->GetRandomKey( 0 );
				m_pQuestInfoBuffer->nValue[2] = pQuest->GetRandomKey( 1 );
				m_pQuestInfoBuffer->nValue[4] = pQuest->GetRandomKey( 2 );
				m_pQuestInfoBuffer->nValue[1] = pQuest->GetRandomValue( 0 );
				m_pQuestInfoBuffer->nValue[3] = pQuest->GetRandomValue( 1 );
				m_pQuestInfoBuffer->nValue[5] = pQuest->GetRandomValue( 2 );
			}

			++m_pQuestInfoBuffer;

			return true;
		}

		TS_SC_QUEST_LIST::TS_QUEST_INFO * m_pQuestInfoBuffer;
	} _aqfo( reinterpret_cast< TS_SC_QUEST_LIST::TS_QUEST_INFO * >( pMsg + 1 ) );

	pMsg->count_active = static_cast< unsigned short >( pPlayer->DoEachActiveQuest( _aqfo ) );
	// 퀘스트 정보만큼 크기를 늘린다
	pMsg->size += static_cast< unsigned int >( sizeof( TS_SC_QUEST_LIST::TS_QUEST_INFO ) * pMsg->count_active );

	// 시작 대기 중인 퀘스트 정보 버퍼에 복사
	struct myPendingQuestFunctor : public StructQuestManager::QuestFunctor
	{
		myPendingQuestFunctor( TS_SC_QUEST_LIST::TS_PENDING_QUEST_INFO * pQuestInfoBuffer ) : m_pQuestInfoBuffer( pQuestInfoBuffer ) {}

		virtual bool operator()( struct StructQuest * pQuest )
		{
			m_pQuestInfoBuffer->code = pQuest->GetQuestCode();
			m_pQuestInfoBuffer->nStartID = pQuest->GetQuestInstance().nStartID;

			++m_pQuestInfoBuffer;

			return true;
		}

		TS_SC_QUEST_LIST::TS_PENDING_QUEST_INFO * m_pQuestInfoBuffer;
	} _pqfo( reinterpret_cast< TS_SC_QUEST_LIST::TS_PENDING_QUEST_INFO * >( _aqfo.m_pQuestInfoBuffer ) );

	pMsg->count_pending = static_cast< unsigned short >( pPlayer->DoEachPendingQuest( _pqfo ) );
	// 퀘스트 정보만큼 크기를 늘린다
	pMsg->size += static_cast< unsigned int >( sizeof( TS_SC_QUEST_LIST::TS_PENDING_QUEST_INFO ) * pMsg->count_pending );

	// 메세지 전송
	PendStream( pPlayer, pMsg, pMsg->size );
}

void SendQuestStatus( struct StructPlayer *pPlayer, struct StructQuest* pQuest )
{
	if( !pQuest )
		return;

	TS_SC_QUEST_STATUS msg;
	msg.code = pQuest->GetQuestCode();

	for( int i = 0; i < QuestInstance::MAX_STATUS; ++i )
	{
		msg.nStatus[i] = pQuest->GetStatus( i );
	}

	msg.nProgress = ( pQuest->IsFinishable() ) ? QuestInstance::FINISHABLE : pQuest->GetProgress();
	msg.nTimeLimit = ( pQuest->GetTimeLimitType() != QuestBase::TIME_LIMIT_TYPE_PERMANENT ) ? pQuest->GetTimeLimit() : 0;;

	PendMessage( pPlayer, &msg );
}

void SendTitleList( struct StructPlayer *pPlayer )
{
	char szBuf[ SENDMSG_BUFFER_SIZE ] = "";
	char *pBuf = szBuf;
	
	size_t nCount = pPlayer->GetTitleCount();
	if( SENDMSG_BUFFER_SIZE <= sizeof( TS_SC_TITLE_LIST ) + sizeof( TS_SC_TITLE_LIST::TS_TITLE_INFO ) * nCount )
		pBuf = new char[ sizeof( TS_SC_TITLE_LIST ) + sizeof( TS_SC_TITLE_LIST::TS_TITLE_INFO ) * nCount ];

	TS_SC_TITLE_LIST * pMsg = new (pBuf) TS_SC_TITLE_LIST;

	nCount = 0;
	struct myTitleFunctor : public StructTitleManager::TitleFunctor
	{
		myTitleFunctor( TS_SC_TITLE_LIST::TS_TITLE_INFO * pTitleInfoBuffer, size_t & nCount )
			: m_pTitleInfoBuffer( pTitleInfoBuffer )
			, m_nCount( nCount )
		{}

		virtual bool operator()( StructTitle * pTitle )
		{
			m_pTitleInfoBuffer->code = pTitle->GetCode();
			m_pTitleInfoBuffer->status = pTitle->GetStatus();

			++m_pTitleInfoBuffer;
			++m_nCount;

			return true;
		}

		TS_SC_TITLE_LIST::TS_TITLE_INFO * m_pTitleInfoBuffer;
		size_t & m_nCount;
	} _atfo( reinterpret_cast< TS_SC_TITLE_LIST::TS_TITLE_INFO * >( pMsg + 1 ), nCount );

	pPlayer->DoEachTitle( _atfo );
	pMsg->count = static_cast< unsigned short >( nCount );
	pMsg->size += static_cast< unsigned int >( sizeof( TS_SC_TITLE_LIST::TS_TITLE_INFO ) * pMsg->count );

	// 메세지 전송
	PendStream( pPlayer, pMsg, pMsg->size );

	if( szBuf != pBuf )
		delete[] pBuf;
}

void SendTitleConditionList( struct StructPlayer *pPlayer )
{
	char szBuf[ SENDMSG_BUFFER_SIZE ] = "";
	char *pBuf = szBuf;

	const size_t nCount = pPlayer->GetTitleConditionCount();
	if( SENDMSG_BUFFER_SIZE <= sizeof( TS_SC_TITLE_CONDITION_LIST ) + sizeof( TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO ) * nCount )
		pBuf = new char[ sizeof( TS_SC_TITLE_CONDITION_LIST ) + sizeof( TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO ) * nCount ];

	TS_SC_TITLE_CONDITION_LIST * pMsg = new (pBuf) TS_SC_TITLE_CONDITION_LIST;

	struct myTitleConditionFunctor : public StructTitleManager::TitleConditionFunctor
	{
		myTitleConditionFunctor( TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO * pTitleConditionInfoBuffer ) : m_pTitleConditionInfoBuffer( pTitleConditionInfoBuffer ) {}

		virtual bool operator()( StructTitleCondition * pTitleCondition )
		{
			m_pTitleConditionInfoBuffer->type = pTitleCondition->GetType();
			m_pTitleConditionInfoBuffer->count = pTitleCondition->GetCount();

			++m_pTitleConditionInfoBuffer;

			return true;
		}

		TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO * m_pTitleConditionInfoBuffer;
	} _atcfo( reinterpret_cast< TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO * >( pMsg + 1 ) );

	pMsg->count = static_cast< unsigned short >( pPlayer->DoEachTitleCondition( _atcfo ) );
	pMsg->size += static_cast< unsigned int >( sizeof( TS_SC_TITLE_CONDITION_LIST::TS_TITLE_CONDITION_INFO ) * pMsg->count );

	// 메세지 전송
	PendStream( pPlayer, pMsg, pMsg->size );

	if( szBuf != pBuf )
		delete[] pBuf;
}

void SendRemainTitleTime( struct StructPlayer *pPlayer )
{
	AR_TIME t = GetArTime();

	TS_SC_REMAIN_TITLE_TIME msg;
	msg.remain_title_time = pPlayer->GetRemainTitleTime() > t ? pPlayer->GetRemainTitleTime() - t : 0;

	PendMessage( pPlayer, &msg );
}

void SendMainTitle( struct StructPlayer *pPlayer )
{
	TS_SC_SET_MAIN_TITLE msg;
	msg.handle = pPlayer->GetHandle();
	msg.code = pPlayer->GetMainTitle() ? pPlayer->GetMainTitle()->nID : 0;
	PendMessage( pPlayer, &msg );
}

void SendSubTitle( struct StructPlayer *pPlayer )
{
	for( int i = 0; i < GameRule::SUB_TITLE_COUNT; ++i )
	{
		TS_SC_SET_SUB_TITLE msg;
		msg.index = i;
		msg.code = pPlayer->GetSubTitle( i ) ? pPlayer->GetSubTitle( i )->nID : 0;
		PendMessage( pPlayer, &msg );
	}
}

void SendBoothClosedMessage( struct StructPlayer* pPlayer, AR_HANDLE target )
{
	TS_SC_BOOTH_CLOSED msg;
	msg.target = target;

	PendMessage( pPlayer, &msg );
}

void SendBoothInfo( struct StructPlayer* pPlayer, StructPlayer* pTarget )
{
	char szBuf[ sizeof( TS_SC_WATCH_BOOTH ) + ( sizeof( TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO ) * GameRule::MAX_BOOTH_ITEM_COUNT ) ];
	TS_SC_WATCH_BOOTH * pMsg = new (szBuf) TS_SC_WATCH_BOOTH;

	pMsg->target = pTarget->GetHandle();
	pMsg->type = pTarget->GetBoothStatus();

	const std::vector< StructPlayer::BOOTH_ITEM_INFO > & rvItemList = pTarget->GetBoothItemList();
	
	pMsg->cnt = static_cast<unsigned short>( rvItemList.size() );
	pMsg->size += sizeof( TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO ) * pMsg->cnt;

	TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO * pBoothItemInfo = reinterpret_cast< TS_SC_WATCH_BOOTH::TS_BOOTH_ITEM_INFO * >( pMsg + 1 );

	for( std::vector< StructPlayer::BOOTH_ITEM_INFO >::const_iterator it = rvItemList.begin(); it != rvItemList.end(); ++it )
	{
		fillItemBaseInfo( pBoothItemInfo, (*it).pItem );
		pBoothItemInfo->count = (*it).cnt;
		pBoothItemInfo->gold = (*it).gold;

		++pBoothItemInfo;
	}

	PendStream( pPlayer, pMsg, pMsg->size );
}

void SendNPCStatusInVisibleRange( struct StructPlayer* pPlayer )
{
	struct _ArObjectFunctor : ArObjectFunctor
	{
		_ArObjectFunctor( StructPlayer *_pPlayer, ArcadiaIntf *_pIntf ) { pPlayer = _pPlayer; pIntf = _pIntf; }

		void operator()( ArObject *pObj ) const
		{
			GameObject::iterator it = GameObject::get( pObj->GetHandle() );

			if( !(*it) || !(*it)->IsNPC() )
			{
				return;
			}

			StructNPC * pNPC = static_cast< StructNPC * >( (*it) );
			
			TS_SC_STATUS_CHANGE msg;

			msg.handle = pNPC->GetHandle();
			msg.status = GetStatusCode( pNPC, pPlayer );

			pIntf->SendGameMessage( pPlayer, &msg );
		}

		ArcadiaIntf * pIntf;
		StructPlayer* pPlayer;

	} _sender( pPlayer, ArcadiaServer::GetIntf() );

	struct Sender : ArRegionFunctor
	{
		Sender( ArObjectFunctor *_pFo ) { pFo = _pFo; }

		void operator()( const struct ArRegion * pRegion )
		{
			pRegion->DoEachMovableObject( *pFo );
		}

		ArObjectFunctor * pFo;

	} _fo( &_sender );

	ArcadiaServer::Instance().DoEachVisibleRegion( pPlayer->GetRX(), pPlayer->GetRY(), pPlayer->GetLayer(), _fo );
}

void SendStatusMessage( struct StructPlayer * pClient, struct StructCreature* pCreature )
{
	TS_SC_STATUS_CHANGE msg;

	msg.handle = pCreature->GetHandle();
	msg.status = GetStatusCode( pCreature, pClient );

	PendMessage( pClient, &msg );
}

void BroadcastStatusMessage( struct StructCreature* pCreature )
{
	struct _ArObjectFunctor : ArObjectFunctor
	{
		_ArObjectFunctor( StructCreature *_pCreature, ArcadiaIntf *_pIntf ) { pCreature = _pCreature; pIntf = _pIntf; }

		void operator()( ArObject *pObj ) const
		{
			TS_SC_STATUS_CHANGE msg;

			StructPlayer * pClient = static_cast< StructPlayer* >( pObj );

			msg.handle = pCreature->GetHandle();
			msg.status = GetStatusCode( pCreature, pClient );

			pIntf->SendGameMessage( pObj, &msg );
		}

		ArcadiaIntf * pIntf;
		StructCreature* pCreature;

	} _sender( pCreature, ArcadiaServer::GetIntf() );

	struct Sender : ArRegionFunctor
	{
		Sender( ArObjectFunctor *_pFo ) { pFo = _pFo; }

		void operator()( const struct ArRegion * pRegion )
		{
			pRegion->DoEachClient( *pFo );
		}

		ArObjectFunctor * pFo;

	} _fo( &_sender );

	ArcadiaServer::Instance().DoEachVisibleRegion( pCreature->GetRX(), pCreature->GetRY(), pCreature->GetLayer(), _fo );
}

void BroadcastHairInfo( struct StructPlayer * pPlayer )
{
	TS_SC_HAIR_INFO msg;

	msg.hPlayer = pPlayer->GetHandle();
	msg.nHairID = pPlayer->GetBaseModelId( 0 );
	msg.nHairColorIndex = pPlayer->GetHairColorIndex();
	msg.nHairColorRGB = pPlayer->GetHairColorRGB();

	ArcadiaServer::Instance().Broadcast( pPlayer->GetRX(), pPlayer->GetRY(), pPlayer->GetLayer(), &msg );
}

void BroadcastSkinInfo( struct StructPlayer * pPlayer )
{
	TS_SC_SKIN_INFO msg;

	msg.hPlayer = pPlayer->GetHandle();
	msg.nSkinColor = pPlayer->GetSkinColor();

	ArcadiaServer::Instance().Broadcast( pPlayer->GetRX(), pPlayer->GetRY(), pPlayer->GetLayer(), &msg );
}

// 이하 인증 관련 메시지
void SendGameServerLoginToAuth( const char * szServerName, const char * szServerScreenshotUrl, unsigned short nServerIdx, const char * szServerIP, int nServerPort )
{
	TS_GA_LOGIN msg;
	s_strcpy( msg.server_name, _countof( msg.server_name ), szServerName );
	s_strcpy( msg.server_screenshot_url, _countof( msg.server_screenshot_url ), szServerScreenshotUrl );
	s_strcpy( msg.server_ip, _countof( msg.server_ip ), szServerIP );

	msg.server_port = nServerPort;
	msg.is_adult_server = GameRule::bIsAdultServer;

	msg.server_idx = nServerIdx;

	if( g_pAuthConnection && g_pAuthConnection->IsConnected() )
	{
		PendMessage( g_pAuthConnection, &msg );
	}
}

// 이하 업로드 관련 메시지
void SendGameServerLoginToUpload( const char *szServerName )
{
	TS_SU_LOGIN msg;
	s_strcpy( msg.server_name, _countof( msg.server_name ), szServerName );

	if( g_pUploadConnection && g_pUploadConnection->IsConnected() )
	{
		PendMessage( g_pUploadConnection, &msg );
	}
}

void fillAuctionMessageBuffer( struct TS_AUCTION_INFO *pBuffer, const class AuctionInfo *pAuctionInfo )
{
	pBuffer->auction_uid = pAuctionInfo->nAuctionID;
	pBuffer->bidded_price = pAuctionInfo->nHighestBiddingPrice.GetRawData();

	time_t tLeftDuration = pAuctionInfo->tAuctionEnd - time( NULL );
	if( tLeftDuration > GameRule::AUCTION_DURATION_MIDTERM )
		pBuffer->duration_type = TS_AUCTION_INFO::DURATION_LONGTERM;
	else if( tLeftDuration > GameRule::AUCTION_DURATION_SHORTTERM )
		pBuffer->duration_type = TS_AUCTION_INFO::DURATION_MIDTERM;
	else
		pBuffer->duration_type = TS_AUCTION_INFO::DURATION_SHORTTERM;


	pBuffer->instant_purchase_price = pAuctionInfo->nInstantPurchasePrice.GetRawData();
	fillItemBaseInfo( &pBuffer->item_info, pAuctionInfo->pItem );
}

bool SendLoginToAuth( const char * szAccount, __int64 one_time_key )
{
	if( GameRule::bUseLoginLogoutDebug )
	{
		_ctprint( "SendLoginToAuth (%s)\n", szAccount );
		FileLogHandler::GetFileLogHandler()->LogStringEx( NULL, "LoginLogout_Debug", "SendLoginToAuth (%s)", szAccount );
	}

	TS_GA_CLIENT_LOGIN msg;

	s_strcpy( msg.account, _countof( msg.account ), szAccount );
	msg.one_time_key = one_time_key;

	if( g_pAuthConnection && g_pAuthConnection->IsConnected() )
	{
		PendMessage( g_pAuthConnection, &msg );
		return true;
	}

	_cprint( "authserver is not connected: %s\n", szAccount );
	FILELOG( "authserver is not connected: %s", szAccount );
	return false;
}

void SendLogoutToAuth( const char * szAccount, AR_TIME nContinuousPlayTime, const int nCallerIdx )
{
	if( GameRule::bUseLoginLogoutDebug )
	{
		_ctprint( "SendLogoutToAuth (%s, %d)\n", szAccount, nCallerIdx );
		FileLogHandler::GetFileLogHandler()->LogStringEx( NULL, "LoginLogout_Debug", "SendLogoutToAuth (%s, %d)", szAccount, nCallerIdx );
	}

	TS_GA_CLIENT_LOGOUT msg;

	s_strcpy( msg.account, _countof( msg.account ), szAccount );
	msg.nContinuousPlayTime = nContinuousPlayTime;

	if( g_pAuthConnection && g_pAuthConnection->IsConnected() )
	{
		PendMessage( g_pAuthConnection, &msg );
	}
}

void SendGameTime( const ArObject * pClient )
{
	TS_SC_GAME_TIME msg;

	msg.t = GetArTime();
	msg.game_time = time( NULL );

	PendMessage( pClient, &msg );
}

void SendHPMPMsg( const struct StructPlayer * pPlayer, const struct StructCreature * pCreature, int add_hp, short add_mp, bool need_to_display )
{
	TS_SC_HPMP msg;

	msg.handle = pCreature->GetHandle();

	msg.add_hp = add_hp;
	msg.add_mp = add_mp;
	msg.hp = pCreature->GetHP();
	msg.mp = pCreature->GetMP();
	msg.max_hp = pCreature->GetMaxHP();
	msg.max_mp = pCreature->GetMaxMP();
	msg.need_to_display = need_to_display;

	PendMessage( pPlayer, &msg );
}

void BroadcastHPMPMsg( const struct StructCreature *pCreature, int add_hp, short add_mp, bool need_to_display )
{
	TS_SC_HPMP msg;

	msg.handle = pCreature->GetHandle();

	msg.add_hp = add_hp;
	msg.add_mp = add_mp;
	msg.hp = pCreature->GetHP();
	msg.mp = pCreature->GetMP();
	msg.max_hp = pCreature->GetMaxHP();
	msg.max_mp = pCreature->GetMaxMP();
	msg.need_to_display = need_to_display;

	ArcadiaServer::Instance().Broadcast( pCreature->GetRX(), pCreature->GetRY(), pCreature->GetLayer(), &msg );
}

void SendOpenUrl( struct StructPlayer * pPlayer, const char *szUrl, const bool bWaitForEventScene, const int width, const int height )
{
	TS_SC_OPEN_URL msg;

	msg.wait_for_event_scene = bWaitForEventScene;
	msg.width = width;
	msg.height = height;
	msg.url_len = static_cast<unsigned short>( strlen( szUrl ) );
	msg.size += msg.url_len;

	if( msg.size > 1024 )
		return;

	char szTmp[ 1024 ];
	char *p = szTmp + sizeof(msg);
	int temp_size = sizeof(szTmp) - sizeof(msg);
	
	s_memcpy( p, temp_size, szUrl, msg.url_len );
	p += msg.url_len;
	temp_size -= msg.url_len;

	s_memcpy( szTmp, sizeof( szTmp ), &msg, sizeof(msg) );

	PendStream( pPlayer, szTmp, msg.size );
}

void SendUrlList( struct StructPlayer * pPlayer )
{
	TS_SC_URL_LIST msg;

	if( !ENV().IsExist( "game.url_list" ) )
		return;

	std::string szUrlList = ENV().GetString( "game.url_list" ) + "|guild_icon_upload.url|" + ENV().GetString( "game.guild_icon_base_url" ) + "/iconupload.aspx";

	msg.url_list_len = static_cast<unsigned short>( szUrlList.length() );
	msg.size += msg.url_list_len;

	if( msg.size > 1024 )
		return;

	char szTmp[ 1024 ];
	char *p = szTmp;
	int temp_size = sizeof( szTmp );
	
	s_memcpy( p, temp_size, &msg, sizeof(msg) );					p += sizeof(msg); temp_size -= sizeof(msg);
	s_memcpy( p, temp_size, szUrlList.c_str(), msg.url_list_len );	p += msg.url_list_len; temp_size -= msg.url_list_len;

	PendStream( pPlayer, szTmp, msg.size );
}

void SendShowCreatureNameChangeBox( struct StructPlayer *pPlayer, AR_HANDLE hSummon )
{
	if( !pPlayer )
		return;

	ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pPlayer ) );

	pPlayer->SetLastContact( "creature_name_change", 1 );

	TS_SC_SHOW_SUMMON_NAME_CHANGE msg;

	msg.handle = hSummon;

	PendMessage( pPlayer, &msg );
}

void SendHuntaholicInstanceInfo( const struct StructPlayer * pPlayer, const TS_HUNTAHOLIC_INSTANCE_INFO & info )
{
	if( !pPlayer )
		return;

	TS_SC_HUNTAHOLIC_INSTANCE_INFO msg;

	s_memcpy( &msg.info, sizeof( msg.info ), &info, sizeof( msg.info ) );

	PendMessage( pPlayer, &msg );
}

void SendHuntaholicHuntingScore( const struct StructPlayer * pPlayer, const int nHuntaholicID, const int nPersonalKillCount, const int nPersonalScore, const int nKillCount, const int nScore, const double & fPointAdvantage, const int nGainPoint, const char nResultType )
{
	if( !pPlayer )
		return;

	TS_SC_HUNTAHOLIC_HUNTING_SCORE msg;

	msg.huntaholic_id = nHuntaholicID;
	msg.personal_kill_count = nPersonalKillCount;
	msg.personal_score = nPersonalScore;
	msg.kill_count = nKillCount;
	msg.score = nScore;
	msg.point_advantage = fPointAdvantage;
	msg.point_rate = 1.0;
	msg.gain_point = nGainPoint;
	msg.result_type = nResultType;

	PendMessage( pPlayer, &msg );
}

void SendCompeteRequest( const struct StructPlayer * pPlayer, const unsigned char nCompeteType, const char * szRequester )
{
	if( !pPlayer )
		return;

	TS_SC_COMPETE_REQUEST msg;
	msg.compete_type = nCompeteType;
	s_strcpy( msg.requester, _countof( msg.requester ), szRequester );

	PendMessage( pPlayer, &msg );
}

void SendCompeteAnswer( const struct StructPlayer * pPlayer, const unsigned char nCompeteType, const unsigned char nAnswerType, const char * szRequestee )
{
	if( !pPlayer )
		return;

	TS_SC_COMPETE_ANSWER msg;
	msg.compete_type = nCompeteType;
	msg.answer_type = nAnswerType;
	s_strcpy( msg.requestee, _countof( msg.requestee ), szRequestee );

	PendMessage( pPlayer, &msg );
}

void SendCompeteCountdown( const struct StructPlayer * pPlayer, const unsigned char nCompeteType, const char * szCompetitor, const AR_HANDLE hCompetitor )
{
	if( !pPlayer )
		return;

	TS_SC_COMPETE_COUNTDOWN msg;
	msg.compete_type = nCompeteType;
	s_strcpy( msg.competitor, _countof( msg.competitor ), szCompetitor );
	msg.handle_competitor = hCompetitor;

	PendMessage( pPlayer, &msg );
}

void SendCompeteStart( const struct StructPlayer * pPlayer, const unsigned char nCompeteType, const char * szCompetitor )
{
	if( !pPlayer )
		return;

	TS_SC_COMPETE_START msg;
	msg.compete_type = nCompeteType;
	s_strcpy( msg.competitor, _countof( msg.competitor ), szCompetitor );

	PendMessage( pPlayer, &msg );
}

void SendCompeteEnd( const struct StructPlayer * pPlayer, const unsigned char nCompeteType, const unsigned char nEndType, const char * szWinner, const char * szLoser )
{
	if( !pPlayer )
		return;

	TS_SC_COMPETE_END msg;
	msg.compete_type = nCompeteType;
	msg.end_type = nEndType;
	s_strcpy( msg.winner, _countof( msg.winner ), szWinner );
	s_strcpy( msg.loser, _countof( msg.loser ), szLoser );

	PendMessage( pPlayer, &msg );
}