#include "stdafx.h"
#include "gamesrv.h"
#include "PartyManager.h"
#include "Player.h"
#include "ObjectManager.h"
#include "InfluenceObject.h"
#include "SkillManager.h"
#include "GridManager.h"

cPartyManager* cPartyManager::mpSingleton = NULL;

// cPartyManager Constructor
cPartyManager::cPartyManager( )
{
	mpSingleton = this;
	mpPartyJoinPool = NULL;
}

// ~cPartyManager Destructor
cPartyManager::~cPartyManager( )
{
	Release( );
	mpSingleton = 0;
}

// Init Method
bool cPartyManager::Init()
{
	mPartyPool.Reserve( 100, 10 );
	mpPartyJoinPool = new cPartyJoinPool( );
	return true;
}

// Release Method
void cPartyManager::Release( )
{
	// Memory Pool - cPartyJoinPool class.
	SAFE_DELETE( mpPartyJoinPool );
}

// Process Method
void cPartyManager::Process(unsigned long /*elapsedTime*/, unsigned long accumTime)
{
	cPartyMap::cIterator begin = mPartyMap.Begin( );
	cPartyMap::cIterator end   = mPartyMap.End( );
	unsigned long lostPlayer;

	while ( begin != end )
	{
		cParty* party = (*begin++).mSecond;
		if ( party != NULL )
		{
			// ÆÄƼ(¿ø)Á¤º¸ ¾÷µ¥ÀÌÆ®
			if ( accumTime > party->GetLastAccumTime( )  )
			{
				party->SendUpdate( );
				party->SetLastAccumTime( accumTime+PARTY_UPDATETIME );
			}

			// ÁÖ»çÀ§ ±¼¸®±â
			if ( party->GetDiceEndTime( ) > 0 )
			{
				if ( party->IsDiceRollEnd( ) || party->GetDiceEndTime( ) <= accumTime )
					SendDiceResult( party );
			}

			// ÆÄƼ(¿ø)°ü¸®
			lostPlayer = party->GetLostPlayer( GetTickCount( )-PARTY_DELETETIME );
			if ( lostPlayer > 0 )
			{
				PartyDelPlayer( party, lostPlayer );
			}
		}
	}


	/*-- ÆÄƼÃÊ´ë ÀÀ´ä ´ë±âÀÚ Ã³¸® --*/

	PartyJoinRoot* root = mpPartyJoinPool->GetRoot( );
	PartyJoin*     join = (PartyJoin*)root->pool;
	PartyJoin*     next = join;
	DWORD          tick = GetTickCount( );

	cPlayer*           player;
	ePLAYER_PARTYSTATE state;

	while ( join != NULL )
	{
		next = (PartyJoin*)join->next;
		if ( tick > join->delay )
		{
			player = OBJECTMANAGER->GetPlayer( join->playerDat.userIndex );
			if ( player != NULL )
			{
				if ( player->GetPartyState( ) == ePARTY_SENDJOIN )
				{
					state = (player->GetPartyIndex( ) > 0) ? ePARTY_COMPLETE : ePARTY_NONE;
					player->SetPartyState( state );

					NETWORK2->SendMsgError( player->GetConnectionIdx( ), NM_PARTY, NM_PARTY_ADD_RES, ERROR_PARTY_ADD_USER );
				}
			}
			mpPartyJoinPool->Release( join );
		}
		join = next;
	}
}

// ResPartyList Method
bool cPartyManager::ResPartyList(cPlayer* player, cParty* party)
{
	HANDLE              handle  = NULL;
	MSG_SYN_PARTY_LIST* sendMsg = (MSG_SYN_PARTY_LIST*)NETWORK2->GetMsgRoot( &handle, player->GetConnectionIdx( ), NM_PARTY, NM_PARTY_LIST_SYN );

	if ( sendMsg != NULL )
	{
		unsigned long   length     = sizeof(MSG_SYN_PARTY_LIST) - sizeof(sendMsg->mTable);
		unsigned long*  userArr    = party->GetUserArr( );
		unsigned int    partyCount = party->GetCount( );

		unsigned char&  rowCount   = sendMsg->RowCount;
		sPartyUserData* data       = sendMsg->mTable;

		sendMsg->mIndex       = party->GetIndex( );
		sendMsg->mLeaderIndex = party->GetLeader( );
		sendMsg->mDivideType  = (char)party->GetDivideType( );
		sendMsg->RowCount     = 0;

		for ( unsigned int i = 0; i < partyCount; ++i, ++userArr )
		{
			// ÀÚ±âÀڽŠÁ¦¿Ü
			cPlayer* user = OBJECTMANAGER->GetPlayer( (*userArr) );

			if ( user != NULL )
				user->GetPartyUserData( data );
			else
				(*data) = party->GetUserData( )[ i ];

			data++;
			rowCount++;
		}

		if( partyCount == 0 )
		{
			NETWORK2->PostServerEvent( "Error cPartyManager::ResPartyList : partycount == 0" );
		}

		length += (sendMsg->RowCount * sizeof(sendMsg->mTable));
		return NETWORK2->SendMsgRoot( handle, length );
	}
	return true;
}	

// ResPartyAddOne Method - ÆÄƼ¿ø Ãß°¡ Á¤º¸ º¸³»±â
bool cPartyManager::ResPartyAddOne(cPlayer* player, cParty* party)
{
	unsigned long* userArr    = party->GetUserArr( );
	unsigned int   partyCount = party->GetCount( );

	// Ãß°¡µÈ À¯Àú¸¦ Á¦¿ÜÇÑ ³ª¸ÓÁö ÆÄƼ¿ø¿¡°Ô º¸³»±â
	for ( unsigned int i = 0; i < partyCount; ++i, ++userArr )
	{
		cPlayer* user = OBJECTMANAGER->GetPlayer( (*userArr) );
		if ( user != NULL )
		{
			if ( player != user )
			{
				HANDLE                handle  = NULL;
				MSG_SYN_PARTY_ADDONE* sendMsg = (MSG_SYN_PARTY_ADDONE*)NETWORK2->GetMsgRoot( &handle, user->GetConnectionIdx(), NM_PARTY, NM_PARTY_ADDONE_SYN );
				if ( sendMsg != NULL )
				{
					player->GetPartyUserData( &sendMsg->mTable );
					NETWORK2->SendMsgRoot( handle, sizeof(MSG_SYN_PARTY_ADDONE) );
				}
			}
		}
	}

	return true;
}

// PartyDelPlayer Method - ÆÄƼÀ¯Àú Å»Åð
void cPartyManager::PartyDelPlayer(cParty* party, unsigned long playerIdx)
{
	unsigned long partyIdx = party->GetIndex( );

	/*-- ÆÄƼ ¸®´õó¸® --*/
	unsigned long leaderIdx = party->GetLeader( );

	if ( party->IsLeader( playerIdx ) && party->GetCount( ) > 2 )
	{
		leaderIdx = party->NextLeader( );				// ´ÙÀ½ ÆÄƼÀå °Ë»ö
		party->SetLeader( leaderIdx );					// ÆÄƼÀå ¼¼ÆÃ
		party->SendPartyLeaderSyn( leaderIdx );			// ÆÄƼÀå À§ÀÓ ¾Ë¸² 
	}

	/*-- ÆÄƼ Å»Åðó¸® --*/
	if ( party->GetCount( ) > 2 )
	{
		party->SendPartyOutSyn( playerIdx );			// Å»Åð ¾Ë¸²
		party->DeleteUser( playerIdx );					// Å»Åð-ÆÄƼ¿ø
		PostDelUser( partyIdx, leaderIdx, playerIdx );	// ä³Î µ¿±âÈ­
	}
	else
	{
		party->SendPartyDeleteSyn( );					// »èÁ¦ ¾Ë¸²
		DelParty( &party );								// »èÁ¦-ÆÄƼ
		PostDelParty( partyIdx );						// ä³Î µ¿±âÈ­
	}
}

// PartyOutPlayer Method - ÆÄƼÀ¯Àú Å»Åð
void cPartyManager::PartyOutPlayer(cPlayer* player)
{
	/*-- Å»ÅðÀÎÁõ --*/
	unsigned long partyIdx  = player->GetPartyIndex( );
	unsigned long playerIdx = player->GetObjectID( );

	if ( partyIdx == 0 )
		throw ERROR_PARTY_OUT_FAIL;

	cParty* party = GetParty( partyIdx );
	if ( party == NULL )
	{
		player->SetPartyIndex( 0 );
		player->SetPartyState( ePARTY_NONE );
		throw ERROR_PARTY_OUT_FAIL;
	}

	if ( party->IsUser( playerIdx ) == false )
		throw ERROR_PARTY_OUT_FAIL;

	/*-- ÆÄƼ¿ø Å»Åðó¸® --*/
	player->SetPartyIndex( 0 );
	player->SetPartyState( ePARTY_NONE );

	/*-- ÆÄƼ ¸®´õó¸® --*/
	unsigned long leaderIdx = party->GetLeader( );

	if ( party->IsLeader( playerIdx ) && party->GetCount( ) > 2 )
	{
		leaderIdx = party->NextLeader( );				// ´ÙÀ½ ÆÄƼÀå °Ë»ö
		party->SetLeader( leaderIdx );					// ÆÄƼÀå ¼¼ÆÃ
		party->SendPartyLeaderSyn( leaderIdx );			// ÆÄƼÀå À§ÀÓ ¾Ë¸² 
	}

	/*-- ÆÄƼ Å»Åðó¸® --*/
	if ( party->GetCount( ) > 2 )
	{
		party->DeleteUser( playerIdx );					// Å»Åð-ÆÄƼ¿ø
		party->SendPartyOutSyn( playerIdx );			// Å»Åð ¾Ë¸²
		PostDelUser( partyIdx, leaderIdx, playerIdx );	// ä³Î µ¿±âÈ­
	}
	else
	{
		party->DeleteUser( playerIdx );					// »èÁ¦-ÆÄƼ¿ø
		party->SendPartyDeleteSyn( );					// »èÁ¦ ¾Ë¸²
		DelParty( &party );								// »èÁ¦-ÆÄƼ
		PostDelParty( partyIdx );						// ä³Î µ¿±âÈ­
	}
}

// PartyThrowPlayer Method
void cPartyManager::PartyThrowPlayer(cPlayer* leader, unsigned long playerIdx)
{
	/*-- Ãß¹æÀÎÁõ --*/
	unsigned long partyIdx  = leader->GetPartyIndex( );
	unsigned long leaderIdx = leader->GetObjectID( );

	if ( partyIdx == 0 )
		throw ERROR_PARTY_THROW_FAIL;

	cParty* party = PARTYMAN->GetParty( partyIdx );
	if ( party == NULL )
	{
		leader->SetPartyIndex( 0 );
		leader->SetPartyState( ePARTY_NONE );
		throw ERROR_PARTY_THROW_FAIL;
	}

	if ( party->IsLeader( leaderIdx ) == false )
		throw ERROR_PARTY_THROW_LEADER;

	if ( party->IsUser( playerIdx ) == false )
		throw ERROR_PARTY_THROW_FAIL;

	/*-- ÆÄƼ¿ø Ãß¹æ¾Ë¸² --*/
	cPlayer* player = OBJECTMANAGER->GetPlayer( playerIdx );
	if ( player != NULL )
	{
		NETWORK2->SendMsgRoot( player->GetConnectionIdx( ), NM_PARTY, NM_PARTY_CUT_SYN );
		player->SetPartyIndex( 0 );
		player->SetPartyState( ePARTY_NONE );
	}

	/*-- ÆÄƼ Ãß¹æó¸® --*/
	if ( party->GetCount( ) > 2 )
	{
		party->DeleteUser( playerIdx );					// »èÁ¦-ÆÄƼ¿ø
		party->SendPartyThrowSyn( playerIdx );			// Å»Åð ¾Ë¸²
		PostOutUser( partyIdx, leaderIdx, playerIdx );	// ä³Î µ¿±âÈ­
	}
	else
	{
		party->DeleteUser( playerIdx );					// »èÁ¦-ÆÄƼ¿ø
		party->SendPartyDeleteSyn( );					// »èÁ¦ ¾Ë¸²
		DelParty( &party );								// »èÁ¦-ÆÄƼ
		PostDelParty( partyIdx );						// ä³Î µ¿±âÈ­
	}
}

// PartyChangeLeader Method - ÆÄƼÀå º¯°æ 
void cPartyManager::PartyChangeLeader(cPlayer* leader, unsigned long playerIdx)
{
	/*-- ÆÄƼÀå º¯°æ ÀÎÁõ --*/
	unsigned long partyIdx = leader->GetPartyIndex( );

	if ( partyIdx == 0 )
		throw ERROR_PARTY_CHANGELEADER_FAIL;

	cParty* party = GetParty( partyIdx );
	if ( party == NULL )
	{
		leader->SetPartyIndex( 0 );
		leader->SetPartyState( ePARTY_NONE );
		throw ERROR_PARTY_CHANGELEADER_FAIL;
	}

	if ( party->IsLeader( leader->GetObjectID( ) ) == false )
		throw ERROR_PARTY_CHANGELEADER_LEADER;

	if ( party->IsUser( playerIdx ) == false )
		throw ERROR_PARTY_CHANGELEADER_FAIL;

	/*-- ÆÄƼÀå º¯°æó¸® --*/
	party->SetLeader( playerIdx );				// ÆÄƼÀå Á¤º¸ Àç¼¼ÆÃ
	party->SendPartyLeaderSyn( playerIdx );		// ÆÄƼÀå À§ÀÓ ¾Ë¸² 
	PostSynLeader( party );						// ä³Î µ¿±âÈ­
}

// PartyChangeDivide Method - ÆÄƼºÐ¹è¹æ½Ä º¯°æ
void cPartyManager::PartyChangeDivide(cPlayer* leader, PARTY_DIVIDE_TYPE type)
{
	/*-- ºÐ¹è¹æ½Ä ÀÎÁõ --*/
	unsigned long partyIdx = leader->GetPartyIndex( );

	if ( partyIdx == 0 )
		throw ERROR_PARTY_CHANGEDIVIDE_FAIL;

	cParty* party = GetParty( partyIdx );

	if ( party == NULL )
	{
		leader->SetPartyIndex( 0 );
		leader->SetPartyState( ePARTY_NONE );
		throw ERROR_PARTY_CHANGEDIVIDE_FAIL;
	}

	// °ËÁõ
	if( type == PARTY_DIVIDE_NONE || type == PARTY_DEVIDE_MAX )
		throw ERROR_PARTY_CHANGEDIVIDE_FAIL;

	if ( party->IsLeader( leader->GetObjectID( ) ) == false )
		throw ERROR_PARTY_CHANGEDIVIDE_LEADER;
	
	if ( party->GetDivideType( ) == type )
		throw ERROR_PARTY_CHANGEDIVIDE_LEADER;

	/*-- ºÐ¹è¹æ½Ä ó¸® --*/
	party->SetDivideType( type );					// ºÐ¹è¹æ½Ä º¯°æ
	party->SendPartyDivideType( (char)type );		// ºÐ¹è¹æ½Ä º¯°æ ¾Ë¸²
	PostSynDivideType( party );							// ä³Î µ¿±âÈ­
}

// PartyMapIn Method - ÆÄƼ¿ø ¸ÊüÀÎÁö
void cPartyManager::PartyMapIn(cPlayer* player)
{
	ePLAYER_PARTYSTATE state = player->GetPartyState( );

	// ÆÄƼÁßÀ̶ó¸é
	if ( state == ePARTY_COMPLETE )
	{
		cParty* party = GetParty( player->GetPartyIndex( ) );
		if ( party )
		{
			// ´Ù¸¥À¯Àúµé¿¡°Ô ¸Ê üÀÎÁö ¾Ë¸®±â
			cPlayer*       partyUser  = 0;
			unsigned long* userArr    = party->GetUserArr( );
			unsigned int   partyCount = party->GetCount( );

			// ¸Ê üÀÎÁö ¾Ë¸®±â - üÀÎÁöÇÑ À¯Àú¸¸ ¾È º¸³¿.
			for ( unsigned int i = 0; i < partyCount; ++i, ++userArr )
			{
				partyUser = OBJECTMANAGER->GetPlayer( (*userArr) );
				if ( partyUser != NULL )
				{
					if ( partyUser != player )
					{
						player->SendPartyMapchangeSyn( partyUser->GetConnectionIdx( ) );
					}
				}
			}

			// ä³Îµ¿±âÈ­ - ¸Ê üÀÎÁö ¾Ë¸®±â.
			PostSynMapData( party->GetIndex( ), player );

			// À̵¿ÇÑÀ¯Àúµé¿¡°Õ ÆÄƼ Á¤º¸ »õ·Î º¸³»±â
			ResPartyList( player, party );

			// ÁÖ»çÀ§ ±¼¸®±â Æ÷±â ¼³Á¤
			if ( party->GetDiceEndTime() > 0 )
			{
				sDiceMember* pMember = party->GetDiceMember( player->GetObjectID( ) );
				if ( pMember && pMember->mRoll == false )
				{
					HANDLE                          handle  = NULL;
					MSG_SYN_PARTY_DICE_REMAIN_TIME* sendMsg = (MSG_SYN_PARTY_DICE_REMAIN_TIME*)NETWORK2->GetMsgRoot( &handle
																													,player->GetConnectionIdx( )
																													,NM_PARTY
																													,NM_PARTY_DICE_REMAIN_TIME_SYN );
					if ( sendMsg != NULL )
					{
						sendMsg->mTime = party->GetDiceEndTime( ) - NETWORK2->GetAccumTime( );
						NETWORK2->SendMsgRoot( handle, sizeof(MSG_SYN_PARTY_DICE_REMAIN_TIME) );
					}
				}
			}
		}
		else
			NETWORK2->PostServerEvent( "Error cPartyManager::PartyMapIn : not exist party" );
	}
}

// SendToJobChange Method - ÀüÁ÷ Á¤º¸ º¸³»±â
void cPartyManager::SendToJobChange(cPlayer* player)
{
	cParty* party = GetParty( player->GetPartyIndex( ) );
	if ( party != NULL )
	{
		cPlayer*       partyUser  = 0;
		unsigned long* userArr    = party->GetUserArr( );
		unsigned int   partyCount = party->GetCount( );

		for ( unsigned int i = 0; i < partyCount; ++i, ++userArr )
		{
			if ( (*userArr) != player->GetObjectID( ) )
			{
				partyUser = OBJECTMANAGER->GetPlayer( (*userArr) );
				if ( partyUser )
				{
					HANDLE					 handle  = NULL;
					MSG_SYN_PARTY_CHANGEJOB* sendMsg = (MSG_SYN_PARTY_CHANGEJOB*)NETWORK2->GetMsgRoot( &handle
																									  ,partyUser->GetConnectionIdx( )
																									  ,NM_PARTY
																									  ,NM_PARTY_JOBCHANGE_SYN );
					if ( sendMsg != NULL )
					{
						sendMsg->userIndex = player->GetObjectID();
						sendMsg->job       = (unsigned short)player->GetJob();
						NETWORK2->SendMsgRoot( handle, sizeof(MSG_SYN_PARTY_CHANGEJOB) );
					}
				}
			}
		}
	}
}

// SendToPartyHunt Method - ÆÄƼ¿øÀÌ ¸ó½ºÅÍ »ç³ÉÇÑ Á¤º¸¸¦ º¸³½´Ù (Äù½ºÆ® ¾÷µ¥ÀÌÆ®¿ë)
void cPartyManager::SendToPartyHunt(cMonster* monster, cPlayer* player, unsigned int racegender)
{
	cParty* party = GetParty( player->GetPartyIndex( ) );
	if ( party != NULL )
	{
		cPlayer*       partyUser  = 0;
		unsigned long* userArr    = party->GetUserArr( );
		unsigned int   partyCount = party->GetCount( );

		for ( unsigned int i = 0; i < partyCount; ++i, ++userArr )
		{
			partyUser = OBJECTMANAGER->GetPlayer( (*userArr) );
			if ( partyUser != NULL )
			{
				// °Å¸® üũ
				if ( monster->GetMapNumber( ) == partyUser->GetMapNumber( ) )
				{
					NiPoint2 monPos  = monster->GetPos( );
					NiPoint2 userPos = partyUser->GetPos( );

					// ÀÏÁ¤ ¹üÀ§¾È¿¡ ÀÖÀ¸¸é Äù½ºÆ® Á¤º¸ °»½Å
					cRangeCheck range( PARTY_RANGE );
					if ( range.IsRange( monPos, userPos ) == true )
					{
						// ÆÄƼ¿ø Äù½ºÆ® Á¤º¸ °»½Å
						partyUser->UpdateDutyHunt( racegender, player->GetObjectID() );
					}
				}
			}
		}
	}
}

// PartyDiceStart Method
void cPartyManager::PartyDiceStart(cPlayer* player)
{
	unsigned long partyIdx = player->GetPartyIndex( );
	cParty*       party;

	if ( partyIdx == 0 )
		throw ERROR_DICE_START_PARTY_STATE;

	party = PARTYMAN->GetParty( partyIdx );

	if ( party == NULL )
		throw ERROR_DICE_START_PARTY_STATE;

	if ( party->IsLeader( player->GetObjectID( ) ) == false )
        throw ERROR_DICE_START_PARTY_LEADER;

	if ( party->DiceStart( ) == false )
        throw ERROR_DICE_START_FAIL;

	PostSynDiceStart( partyIdx );
}

// PartyDiceResult Method
void cPartyManager::PartyDiceResult(cPlayer* player, unsigned short value)
{
	unsigned long partyIdx  = player->GetPartyIndex( );
	unsigned long playerIdx = player->GetObjectID( );

	cParty*       party;
	int           retvalue;

	if ( partyIdx == 0 )
		throw ERROR_DICE_ROLL_PARTY_STATE;

	party = PARTYMAN->GetParty( partyIdx );
	if ( party == NULL )
		throw ERROR_DICE_ROLL_PARTY_STATE;

	retvalue = party->DiceRollReq( playerIdx, value );
	if ( retvalue == ERROR_DICE_ROLL_SUCCESS )
	{
		PostSynDiceResult( partyIdx, playerIdx, value );
	}
	else
		throw retvalue;
}

// SendDiceResult Method
void cPartyManager::SendDiceResult(cParty* party)
{
	PerIoContext*           ioContext = NETWORK2->GetIoContext( IOCP_REQUEST_WRITE );
	MSG_SYN_PARTY_DICE_END* sendMsg   = (MSG_SYN_PARTY_DICE_END*)ioContext->buffer;

	sendMsg->Category = NM_PARTY;
	sendMsg->Protocol = NM_PARTY_DICE_END_SYN;

	// ±¼¸®±â ¼±ÅÃÇÑ ¸â¹ö¸¸..
	short rollCnt  = 0;
	short totalCnt = 0;
	for ( unsigned int i = 0; i < party->GetDiceCount(); i++ )
	{
		sDiceMember* pMember = party->GetDiceMember( i );
		if ( pMember )
		{
			if( pMember->mRandom > 0 )
			{
				sendMsg->mResult[rollCnt].mRandom = pMember->mRandom;
				wcscpy( sendMsg->mResult[rollCnt].mCharName, pMember->mCharName );
				++rollCnt;
			}
			++totalCnt;
		}
	}

	sendMsg->mNotRollCnt = totalCnt - rollCnt;
	sendMsg->mTotalCnt   = totalCnt;
	sendMsg->mRowCount   = rollCnt;

	// ÁÖ»çÀ§ Âü¿© ¸â¹ö Áß ÆÄƼ¿ø¿¡¸¸ Àü¼Û
	for ( unsigned int i = 0; i < party->GetDiceCount( ); i++ )
	{
		sDiceMember* pMember = party->GetDiceMember( i );
		if ( pMember != NULL )
		{
			cPlayer* partyUser = OBJECTMANAGER->GetPlayer( pMember->mUserIdx );
			if ( partyUser && party->GetIndex( ) == partyUser->GetPartyIndex( ) )
			{
				NETWORK2->SendToUser( partyUser->GetConnectionIdx( ), (char*)sendMsg, sendMsg->GetMsgLength( ) );
			}
		}
	}

	ioContext->offset = sendMsg->GetMsgLength( );
	NETWORK2->ReleaseIoContext( ioContext );

	party->DiceRelease( );
}

// SendToPartyAll Method
void cPartyManager::SendToPartyAll(cParty* party, char* msg, unsigned long length)
{
	unsigned long* pUserArr = party->GetUserArr( );
	for ( int i = 0; i < (int)party->GetCount( ); i++ )
	{
		if ( pUserArr[ i ] )
		{
			cPlayer* partyUser = OBJECTMANAGER->GetPlayer( pUserArr[ i ] );
			if ( partyUser != NULL )
			{
				NETWORK2->SendToUser( partyUser->GetConnectionIdx(), msg, length );
			}
		}
	}
}

// CheckPlayer Method
int cPartyManager::CheckPlayer(cPlayer* player)
{
	sGameOption*       gameOption = player->GetOptionData( );
	ePLAYER_PARTYSTATE partyState = player->GetPartyState( );

	if ( player->GetPartyUnionIndex( ) > 0 )			// ÆÄƼ¿¬ÇÕ »óÅ °Ë»ç
		return ERROR_PARTY_ADD_PARTYUNION;

	if ( player->IsRequestRejection( ) == true )		// ÀÀ´ä°¡´É »óÅ °Ë»ç
		return ERROR_PARTY_ADD_STATUS;

	if ( player->GetGameIn( ) == false )				// ¸Ê À̵¿ °Ë»ç
		return ERROR_PARTY_ADD_MAP;

	if ( gameOption->option1.rejectionParty )		// ¿É¼Ç - ÆÄƼ°ÅºÎ °Ë»ç
		return ERROR_PARTY_ADD_OPTIONREFUSE;

	// ÃÊ´ë¹ÞÀº À¯Àú »óÅ °Ë»ç
	switch ( partyState )
	{
	case ePARTY_COMPLETE:
		return ERROR_PARTY_ADD_COMPLETE;
	case ePARTY_RECVJOIN:
	case ePARTY_SENDJOIN:
		return ERROR_PARTY_ADD_STATUS;
	}

	return ERROR_PARTY_ADD_SUCCESS;
}

// AddParty Method
cParty*	cPartyManager::AddParty(unsigned long partyIndex, unsigned long leaderIdx, unsigned long playerIdx)
{
	// ÆÄƼ »ý¼º
	cParty* pParty = new cParty;
	if ( pParty != NULL )
	{
		// ÆÄƼ ±âº»Á¤º¸ ¼¼ÆÃ
		pParty->Init( partyIndex, leaderIdx, PARTY_DIVIDE_TURN, NETWORK2->GetAccumTime( ) + PARTY_UPDATETIME );

		// ÆÄƼ¿ø ¼¼ÆÃ
		pParty->AddUser( leaderIdx );
		pParty->AddUser( playerIdx );

		// ÆÄƼ »ðÀÔ 
		if ( mPartyMap.Insert( partyIndex, pParty ) == false )
		{
			SAFE_DELETE( pParty );
			NETWORK2->PostServerEvent( "Error cPartyManager::AddParty : failed to insert party map" );
		}
	}
	else
		NETWORK2->PostServerEvent( "Error cPartyManager::AddParty : failed to create party" );

	return pParty;
}

// DelParty Method
void cPartyManager::DelParty(cParty** party)
{
	mPartyMap.Erase( (*party)->GetIndex( ) );
	SAFE_DELETE( (*party) );
}

// AddRestore Method
void cPartyManager::AddRestore(unsigned long playerIdx, unsigned int partyIdx)
{
	cJoinMap::cIterator i = mRestore.Find( playerIdx );
	if ( i == mRestore.End( ) )
	{
		mRestore.Insert( playerIdx, partyIdx );
	}
}

// SetRestore Method
void cPartyManager::SetRestore(cPlayer* player)
{
	cJoinMap::cIterator i = mRestore.Find( player->GetObjectID( ) );
	if ( i != mRestore.End( ) )
	{
		unsigned long partyIdx = (unsigned long)(*i).mSecond;
		cParty*       party    = GetParty( partyIdx );
		if ( party != NULL )
		{
			if ( party->IsUser( player->GetObjectID( ) ) == true )
			{
				party->SetUserData( player, 0 );
				player->SetPartyIndex( partyIdx );
				player->SetPartyState( ePARTY_COMPLETE );
			}
		}
		DelRestore( player->GetObjectID( ) );
	}
}

// DelRestore Method
void cPartyManager::DelRestore(unsigned long playerIdx)
{
	mRestore.Erase( playerIdx );
}

// GetParty Method
cParty*	cPartyManager::GetParty(unsigned int partyIdx)
{
	return ( partyIdx > 0 ) ? (cParty*)mPartyMap.GetAt( partyIdx ) : NULL;
}

// SearchJoin Method
PartyJoin* cPartyManager::SearchJoin(wchar_t* name)
{
	return mpPartyJoinPool->Search( name );
}

// GetJoin Method
PartyJoin* cPartyManager::GetJoin(wchar_t* name)
{
	PartyJoin* join = mpPartyJoinPool->Search( name );
	if ( join != NULL )
	{
		mpPartyJoinPool->Release( join );
	}
	join = mpPartyJoinPool->Get( name );
	return join;
}

// ReleaseJoin Method
void cPartyManager::ReleaseJoin(PartyJoin* join)
{
	mpPartyJoinPool->Release( join );
}

// ClearRequest Method - ¸Ê¾Æ¿ô(½Åû¹Þ´ÂÀ¯Àú) ÀÚµ¿ °ÅÀý ó¸®ÇÑ´Ù
void cPartyManager::ClearRequest(cPlayer* player)
{
	ePLAYER_PARTYSTATE state = player->GetPartyState( );

	// ÆÄƼÃʴ븦 ¹Þ´ÂÁßÀ̾ú´Ù¸é
	if ( state == ePARTY_RECVJOIN )
	{
		// ½ÅûÇÑ À¯Àú¿¡°Ô °ÅÀý¸Þ¼¼Áö º¸³»±â
		PartyJoin* join = mpPartyJoinPool->Search( player->GetName( ) );
		if ( join != NULL )
		{
			cPlayer* requester = OBJECTMANAGER->GetPlayer( join->playerDat.userIndex );
			if ( requester != NULL )
			{
				ePLAYER_PARTYSTATE state = (requester->GetPartyIndex( ) > 0) ? ePARTY_COMPLETE : ePARTY_NONE;
				requester->SetPartyState( state );

				NETWORK2->SendMsgError( requester->GetConnectionIdx( ), NM_PARTY, NM_PARTY_ADD_RES, ERROR_PARTY_ADD_REFUSE );
			}
			else
			{
				PostRepParty( join->playerDat.userIndex, join->name, ERROR_PARTY_ADD_REFUSE, 0 );
			}

			// ¸ÊüÀÎÁöÇÑ À¯ÀúÀÇ »óÅ º¯°æ
			player->SetPartyState( ePARTY_NONE );
			player->EndRequestRejection( eREQREJCT_PARTY );

			mpPartyJoinPool->Release( join );	// ¸®Äù½ºÆ® »èÁ¦
		}
	} 
}

void cPartyManager::PostSynParty(cParty* party)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_PARTY;
	sync.synParty.partyIdx  = party->GetIndex( );
	sync.synParty.leaderIdx = party->GetLeader( );

	unsigned long*  userArr = party->GetUserArr( );
	sPartyUserData* userDat = party->GetUserData( );
	cPlayer*        player;

	for ( unsigned long i = 0; i < party->GetCount( ); ++i, ++userArr, ++userDat )
	{
		player = OBJECTMANAGER->GetPlayer( (*userArr) );
		(player != NULL) ? player->GetPartyUserData( &sync.synParty.player[ i ] ) : sync.synParty.player[ i ] = (*userDat);
	}

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNPARTY( )  );
}

void cPartyManager::PostAskParty(unsigned long partyIdx, cPlayer* player, wchar_t* playerName)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_ASK_PARTY;
	sync.askParty.partyIdx = partyIdx;
	player->GetPartyUserData( &sync.askParty.leader );
	wcscpy( sync.askParty.playerName, playerName );

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.ASKPARTY( )  );
}

void cPartyManager::PostRepParty(unsigned long leaderIdx, wchar_t* playerName, unsigned long error, unsigned char replay)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_REP_PARTY;
	sync.repParty.leaderIdx = leaderIdx;
	wcscpy( sync.repParty.playerName, playerName );
	sync.repParty.error     = error;
	sync.repParty.replay    = replay;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.REPPARTY( )  );
}

void cPartyManager::PostAddParty(unsigned long partyIdx, sPartyUserData* leader, sPartyUserData* player)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_ADD_PARTY;
	sync.addParty.partyIdx  = partyIdx;
	sync.addParty.leader = (*leader);
	sync.addParty.player = (*player);

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.ADDPARTY( )  );
}

void cPartyManager::PostDelParty(unsigned long partyIdx)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_DEL_PARTY;
	sync.delParty.partyIdx = partyIdx;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.DELPARTY( )  );
}

void cPartyManager::PostAddUser(unsigned long partyIdx, cPlayer* player)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_ADD_USER;
	sync.addUser.partyIdx  = partyIdx;
	player->GetPartyUserData( &sync.addUser.player );

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.ADDUSER( )  );
}

void cPartyManager::PostDelUser(unsigned long partyIdx, unsigned long leaderIdx, unsigned long playerIdx)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_DEL_USER;
	sync.delUser.partyIdx  = partyIdx;
	sync.delUser.leaderIdx = leaderIdx;
	sync.delUser.playerIdx = playerIdx;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.DELUSER( )  );
}

void cPartyManager::PostOutUser(unsigned long partyIdx, unsigned long leaderIdx, unsigned long playerIdx)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_OUT_USER;
	sync.outUser.partyIdx  = partyIdx;
	sync.outUser.leaderIdx = leaderIdx;
	sync.outUser.playerIdx = playerIdx;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.OUTUSER( )  );
}

void cPartyManager::PostSynLeader(cParty* party)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_LEADER;
	sync.synLeader.partyIdx  = party->GetIndex( );
	sync.synLeader.leaderIdx = party->GetLeader( );

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNLEADER( )  );
}

void cPartyManager::PostSynDivideType(cParty* party)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_DIVIDE_TYPE;
	sync.synDivideType.partyIdx   = party->GetIndex( );
	sync.synDivideType.divideType = (unsigned char)party->GetDivideType( );

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNDIVIDETYPE( )  );
}

//void cPartyManager::PostSynLevelData(unsigned long partyIdx, cPlayer* player)
//{
//	cSender* sender = g_gameSrv->GetSender( );
//
//	PARTY_DATA_SYNC sync;
//	memset( &sync, 0, sizeof(sync) );
//
//	sync.protocol = PSP_SYN_LEVEL_DATA;
//	sync.synLevelData.partyIdx = partyIdx;
//	player->GetPartyUserData( &sync.synLevelData.player );
//
//	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNLEVELDATA( )  );
//}

void cPartyManager::PostSynMapData(unsigned long partyIdx, cPlayer* player)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_MAP_DATA;
	sync.synMapData.partyIdx = partyIdx;
	player->GetPartyUserData( &sync.synMapData.player );

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNMAPDATA( )  );
}

// PostSynUser Method
void cPartyManager::PostSynUser(unsigned long partyIdx, unsigned long playerIdx, long gotoCID)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_USER;
	sync.synUser.gotoCID   = gotoCID;
	sync.synUser.partyIdx  = partyIdx;
	sync.synUser.playerIdx = playerIdx;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNUSER( )  );
}

// PostSynDiceStart Method
void cPartyManager::PostSynDiceStart(unsigned long partyIdx)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_DICE_START;
	sync.synDiceStart.partyIdx = partyIdx;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNDICESTART( ) );
}

void cPartyManager::PostSynDiceResult(unsigned long partyIdx, unsigned long playerIdx, unsigned short value)
{
	cSender* sender = g_gameSrv->GetSender( );

	PARTY_DATA_SYNC sync;
	memset( &sync, 0, sizeof(sync) );

	sync.protocol = PSP_SYN_DICE_RESULT;
	sync.synDiceResult.partyIdx  = partyIdx;
	sync.synDiceResult.playerIdx = playerIdx;
	sync.synDiceResult.value     = value;

	sender->PostPartySync( NETWORK2->GetCID( ), (char*)&sync, sync.SYNDICERESULT( ) );
}