#include "StdAfx.h"
#include "CompetitionTeam.h"
#include "CompetitionFormula.h"
#include "PVPInfo.h"
#include "PacketStruct_AG.h"
#include "CHuntingRewardParser.h"
#include "GameZone.h"
#include "RewardManager.h"
#include "CompetitionInfo.h"
#include "CHuntingManager.h"
#include "MapInfoParser.h"
#include "GameCHuntingRoom.h"
#include "ServerOptionParser.h"
#include "StatusManager.h"
#include "ItemManager.h"
#include <ServerOptionParserEx.h>
#include <RewardInfoList.h>
#include <GameServerEx.h>


CompetitionTeam::CompetitionTeam()
{
}

CompetitionTeam::~CompetitionTeam()
{
}

VOID CompetitionTeam::Init( CHuntingManager *pMgr, WORD wTeamKey, eCOMPETITION_RULE_TYPE eRule, eCOMPETITION_MODE_TYPE eMode )
{
	m_pCHuntngMgr = pMgr;
	m_wTeamKey = wTeamKey;
	m_Rule = eRule;
	m_Mode = eMode;
	m_State = eTEAM_STATE_NONE;
	m_wKillPoint = 0;
	m_wWinPoint = 0;
	m_byInitMemberNum = 0;
	m_TotLevel = 0;
	m_eExpireState = eEXPIRE_STATE_NONE;
	m_bChampion = FALSE;

	m_PlayerHash.clear();
	m_wPartyKey = 0;
	m_setReadyUserKeys.clear();
	m_bResultTie = FALSE;

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	m_GuildGuid = 0;
#endif
}

VOID CompetitionTeam::Update()
{
	Player* pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;

		if( pPlayer->IsAlive() )	continue;

		if( pPlayer->GetCompetitionInfo().IsExpiredResurrection() )
			pPlayer->OnResurrection( 0, 1.f, 1.f );
	}

	switch( m_State )
	{
	case eTEAM_STATE_MATCH:
		{
			if( OnIsExpired() )
			{
				OnEnd();
			}
		}
		break;
	case eTEAM_STATE_END:
		{
			if( m_EndWaitTimer.IsExpiredManual( FALSE ) )
			{
#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
				OnExpels();
#else
				OnExpel();
#endif
			}
		}
		break;
	}
}

VOID CompetitionTeam::Start()
{
	m_State = eTEAM_STATE_MATCH;

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	// ¼Ò¸ê½ÃÄѾßÇÒ ÀÔÀå±Ç °³¼ö
	POSTYPE EntranceCount = 0;	SLOTCODE ItemCode = 0;
	if( m_pCHuntngMgr->IsGuildPVPMode() )
	{
		sMAPINFO* pInfo = (sMAPINFO*)MapInfoParser::Instance()->FindMapInfo( m_pCHuntngMgr->GetCHunting()->GetMapCode() );
		if( pInfo )
		{
			ItemCode = pInfo->EntranceItemCode;
			EntranceCount = pInfo->EntranceItemCount;
		}
	}
#endif

	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;

		// °æÀïÇåÆà Âü°¡È½¼ö¸¦ Áõ°¡½ÃŲ´Ù.
		pPlayer->GetCompetitionInfo().IncPlayTimes();

		if( !IsTimeAttackMode() )
		{
			// °¢ ÆÄƼ¸â¹öµéÀÌ PVP°¡ °¡´ÉÇϵµ·Ï »óŸ¦ º¯°æÇÑ´Ù.
			pPlayer->GetPVPInfo().Clear();
			pPlayer->GetPVPInfo().SetPVPState( ePVP_USER_MATCH );
		}

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
		// ÀÌÀü ÆÇÀÌ ¹«½ÂºÎ¿´À¸¸é ÀÔÀå±ÇÀ» ¼Ò¸ê½ÃÅ°Áö ¾Ê´Â´Ù.
		if( !m_pCHuntngMgr->IsGuildPVPMode() || m_bResultTie )	continue;


		// ÇÊ¿äÇÑ °³¼ö¸¸Å­ ÀÔÀå±ÇÀ» °¡Áö°í ÀÖÀ¸¸é ¼Ò¸ê½ÃÅ°°í ¾øÀ¸¸é ÅðÀå½ÃŲ´Ù.
		if( pPlayer->GetItemOwnFlag().GetItemNum( eITEMTYPE_GUILD_PVP_ENTRANCE ) >= EntranceCount )
		{
			MSG_CG_ITEM_LOSE_ACK msg;
			if( RC::RC_ITEM_SUCCESS == pPlayer->GetItemManager()->DeleteAllKindOfItem( 1, &ItemCode, &EntranceCount, &(msg.m_ItemInfo) ) )
			{
				if( msg.m_ItemInfo.m_Count != 0 )
					pPlayer->SendPacket( &msg, msg.GetSize() );
			}
			else
				OnExpel( pPlayer );
		}
		// ¾øÀ¸¸é ÅðÀå½ÃŲ´Ù.
		else
		{
			OnExpel( pPlayer );
		}
#endif
	}
}

BOOL CompetitionTeam::OnIsExpired()
{
	// ¸â¹ö¼ö°¡ 0À̸é Á¾·á
	if( m_PlayerHash.size() == 0 )
	{
		m_eExpireState = eEXPIRE_STATE_ALL_LEAVE;
		return TRUE;
	}

	if( IsSurvivalMode() )
	{
		// ¸â¹öµéÀÌ ¸ðµÎ Á×À¸¸é Á¾·á
		if( IsAllDied() )
		{
			m_eExpireState = eEXPIRE_STATE_ALL_DEAD;
			return TRUE;
		}
	}
	
	return FALSE;
}

BOOL CompetitionTeam::IsAllDied()
{
	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;
		if( pPlayer->IsAlive() )	return FALSE;
	}

	return TRUE;
}

VOID CompetitionTeam::OnEnd()
{
	m_State = eTEAM_STATE_END;

	// ÀÏÁ¤½Ã°£ ±â´Ù¸° ÈÄ¿¡ Ãß¹æ½ÃŲ´Ù.
	m_EndWaitTimer.SetTimer( END_WAIT_TIME );
}

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
VOID CompetitionTeam::OnExpel( Player *pPlayer )
{
	MSG_AG_ZONE_CHUNTING_LEAVE_CMD msg;
	pPlayer->SendPacket( &msg, sizeof(msg) );
}
VOID CompetitionTeam::OnExpels()
{
	// °­Á¦·Î Ãß¹æ½ÃŲ´Ù.
	Player * pPlayer = NULL;
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != m_PlayerHash.end(); ++it )
	{
	#ifndef __TW_0_20080521_GUILD_PVP_BUG_FIX	//ÀڷᱸÁ¶ º¯°æµÇ¾úÀ½.
		pPlayer = *it;	
	#else
		pPlayer = it->second;
	#endif
		OnExpel( pPlayer );
	}

	m_State = eTEAM_STATE_NONE;
}
#else
VOID CompetitionTeam::OnExpel()
{
	MSG_AG_ZONE_CHUNTING_LEAVE_CMD msg;

	// °­Á¦·Î Ãß¹æ½ÃŲ´Ù.
	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;
		pPlayer->SendPacket( &msg, sizeof(msg) );
	}

	m_State = eTEAM_STATE_NONE;
}
#endif

VOID CompetitionTeam::ResultTie()
{
	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;
		// PVP ÇØÁ¦
		pPlayer->GetPVPInfo().SetPVPState( ePVP_USER_NONE );

		// Á×¾ú´ø Ç÷¹ÀÌ¾î ºÎÈ°
		if( pPlayer->IsDead() )
		{
			pPlayer->OnResurrection( 0, 1.f, 1.f );
		}

		// °æÀï Æ÷ÀÎÆ® ÃʱâÈ­
		pPlayer->GetCompetitionInfo().PointInit();

		// ¹«½ÂºÎ ¸Þ¼¼Áö¸¦ ³¯¸°´Ù.
		MSG_CG_CHUNTING_TIE_COMPETITION_BRD msg;
		pPlayer->SendPacket( &msg, sizeof(msg) );
	}

	m_State = eTEAM_STATE_NONE;
	m_wKillPoint = 0;

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	m_bResultTie = TRUE;
#endif
}

VOID CompetitionTeam::ResultWin( CompetitionTeam *pLoseTeam, WORD wProcessTime )
{
	// °³ÀÎ µî¼ö ±¸Çϱâ
	OnCalcRanking();

	BOOL bGetItem = FALSE;

	int iPreVictoryNum = (int)(m_wWinPoint / 100);

    //_NA_0_20091118_GAMEROOM_BATTLE_RESULT
    if ( pLoseTeam )
        ++m_byTeamWinCount;

    WORD wPlusWinPoint = min( 100, 100 * wProcessTime / OnGetMaxPlayTimes() );
	m_wWinPoint += wPlusWinPoint;
	m_wWinPoint = min( MAX_WIN_POINT, m_wWinPoint );

	// m_wWinPoint °ªÀÌ 100´ÜÀ§ÀÇ º¯È­°¡ ÀÖ¾î¾ß ¾ÆÀÌÅÛÀ» ¹Þ´Â´Ù.
	int iVictoryNumDiff = m_wWinPoint / 100 - iPreVictoryNum;
	if( iVictoryNumDiff > 0 )
		bGetItem = TRUE;

	// º¸»ó ó¸®
	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;

		// PVP ÇØÁ¦
		pPlayer->GetPVPInfo().SetPVPState( ePVP_USER_NONE );

		// Á×¾ú´ø Ç÷¹ÀÌ¾î ºÎÈ°
		if( pPlayer->IsDead() )
		{
			pPlayer->OnResurrection( 0, 1.f, 1.f );
		}

		// º¸»ó ó¸®
		OnRewards( pPlayer, pLoseTeam->GetAvgLevel(), wProcessTime, bGetItem );

		// °æÀï Æ÷ÀÎÆ® ÃʱâÈ­
		pPlayer->GetCompetitionInfo().PointInit();

		// ½Â¸® ÀüÀû Ãß°¡
		pPlayer->GetCompetitionInfo().IncWinTimes();
	}

	// ¿¬½ÂȽ¼ö Áõ°¡ ¹× º¯¼ö ÃʱâÈ­
	m_State = eTEAM_STATE_NONE;
	m_wKillPoint = 0;
	SetChampion( TRUE );

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	m_bResultTie = FALSE;

	// ±æµåÀüÀº ÇÑ ÆÇÀÌ ³¡³ª¸é ´Ù½Ã ½ÃÀÛÇÑ´Ù.
	if( m_pCHuntngMgr->IsGuildPVPMode() )
	{
		OnEnd();
	}
#endif

	// 30¿¬½ÂÀ» ±â·ÏÇßÀ» ¶§ °­Á¦·Î Ãß¹æ½ÃŲ´Ù.
	if( m_wWinPoint == MAX_WIN_POINT )
		OnEnd();
}

VOID CompetitionTeam::OnRewards( Player *pPlayer, LEVELTYPE EnemyPartyAvgLV, WORD wProcessTime, BOOL bGetItem )
{
	MSG_CG_CHUNTING_WIN_COMPETITION_BRD msg;

	memset( &msg.m_ItemInfo, 0, sizeof(INVENTORY_TOTAL_INFO) );

	EXPTYPE OldExp = pPlayer->GetExp();

	// °æÇèÄ¡ ȹµæ
	BYTE byMemberNum = GetMemberNum();
	if( !byMemberNum )
	{
		byMemberNum = m_byInitMemberNum;
	}

#ifdef __NA_0_20070329_CHUNTING_FORMULA_BUG
	EXPTYPE RewardExp = (DWORD)CalcCompetitionExp( m_Mode, wProcessTime, byMemberNum, pPlayer->GetLevel(), GetTotLevel(), GetAvgLevel(), EnemyPartyAvgLV, m_wWinPoint );
#else
	WORD RewardExp = (WORD)CalcCompetitionExp( m_Mode, wProcessTime, byMemberNum, pPlayer->GetLevel(), GetTotLevel(), GetAvgLevel(), EnemyPartyAvgLV, m_wWinPoint );
#endif

	pPlayer->AddExp( RewardExp, 0, 0, FALSE );

	// ÇÏÀÓ È¹µæ
	MONEY RewardMoney = CalcCompetitionMoney( m_Mode, wProcessTime, byMemberNum, pPlayer->GetLevel(), GetAvgLevel(), EnemyPartyAvgLV, m_wWinPoint );
	pPlayer->PlusMoney( RewardMoney );

	GAMELOG->LogExp( EXP_COMPETITION, pPlayer, pPlayer->GetExp(), OldExp );
	GAMELOG->LogMoney( MONEY_REWARD_COMPETITION, pPlayer, RewardMoney );

	// PVP Æ÷ÀÎÆ® ȹµæ(ÆÀ½Â¸® Æ÷ÀÎÆ®)
	WORD wPVPPoint = GetMemberNum() * 3;

	// PVP Æ÷ÀÎÆ® ȹµæ(°³Àεî¼ö Æ÷ÀÎÆ®)
	switch( pPlayer->GetCompetitionInfo().GetRanking() )
	{
	case 1:		wPVPPoint += GetMemberNum() * 3;	break;
	case 2:		wPVPPoint += GetMemberNum() * 2;	break;
	case 3:		wPVPPoint += GetMemberNum() * 1;	break;
	}

	pPlayer->GetPVPInfo().PlusPVPPoint( wPVPPoint );

	// ¾ÆÀÌÅÛ È¹µæ
	DWORD dwRewardIndex = 0;
	GameZone *pZone = pPlayer->GetGameZonePtr();
	if( pZone && bGetItem )
	{
		BYTE VictoryNum = (BYTE)(m_wWinPoint / 100);

		MAPCODE FieldCode = 0;	
		if( pPlayer->GetField() )	FieldCode = pPlayer->GetField()->GetFieldCode();

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
		REWARD_INFO *pRewardInfo = CHuntingRewardParser::Instance()->GetRewardInfo( pZone->GetMapCode(), FieldCode, m_pCHuntngMgr->IsGuildPVPMode() , m_Rule, m_Mode, VictoryNum );
#else
		REWARD_INFO *pRewardInfo = CHuntingRewardParser::Instance()->GetRewardInfo( pZone->GetMapCode(), FieldCode, m_Rule, m_Mode, VictoryNum, 0 );
#endif
		if( pRewardInfo )
		{
			dwRewardIndex = CHuntingRewardParser::Instance()->GetRandomRewardIndex( pRewardInfo );
            uint index = RewardInfo::MAX_DROP_INDEX_NUM - 1;
            BYTE SelectItemBits = ( 1 << random(0,index) );
			g_RewardManager.RewardItem( RewardManager::eREWARD_COMPETITION, dwRewardIndex, SelectItemBits, pPlayer, msg.m_ItemInfo );
		}
	}

	// ½Â¸® ¸Þ¼¼Áö¸¦ ³¯¸°´Ù.
	msg.m_wWinPoint = m_wWinPoint;
	msg.m_i64Exp = pPlayer->GetExp();
	msg.m_CurMoney = pPlayer->GetMoney();
	msg.m_PlusPVPPoint = wPVPPoint;
	pPlayer->SendPacket( &msg, msg.GetSize() );
}

VOID CompetitionTeam::ResultLose( CompetitionTeam *pWinnerTeam )
{
    // _NA_0_20091118_GAMEROOM_BATTLE_RESULT
    if ( pWinnerTeam )
        m_byTeamWinCount = 0;

	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;

		// PVP ÇØÁ¦
		pPlayer->GetPVPInfo().Clear();
		pPlayer->GetPVPInfo().SetPVPState( ePVP_USER_NONE );

		// PVP Æ÷ÀÎÆ® ȹµæ(ÆÀ½Â¸® Æ÷ÀÎÆ®)
		WORD wPVPPoint = GetMemberNum();
		pPlayer->GetPVPInfo().PlusPVPPoint( wPVPPoint );

		// Æйè ÀüÀû Ãß°¡
		pPlayer->GetCompetitionInfo().IncLoseTimes();

		// ÆÐ¹è ¸Þ¼¼Áö¸¦ ³¯¸°´Ù.
		MSG_CG_CHUNTING_LOSE_COMPETITION_BRD msg;
		pPlayer->SendPacket( &msg, sizeof(msg) );
	}

	m_wKillPoint = 0;

#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	m_bResultTie = FALSE;
#endif

	OnEnd();
}

VOID CompetitionTeam::IncNPCKillPoint( Player *pKiller, NPC *pNPC )
{
	if( IsTimeAttackMode() )
	{
		WORD wBonusKillPoint = CalcNPCKillPoint( (eNPC_GRADE)pNPC->GetGrade() );
		m_wKillPoint += wBonusKillPoint;

		// °³ÀΠųÆ÷ÀÎÆ® Áõ°¡
		pKiller->GetCompetitionInfo().IncKill( wBonusKillPoint );

		// ųÆ÷ÀÎÆ® °»½ÅÀ» ¾Ë¸°´Ù.
		MSG_CG_CHUNTING_UPDATE_KILLPOINT_BRD brdMsg;
		brdMsg.m_wTeamKey = m_wTeamKey;
		brdMsg.m_wKillPoint = m_wKillPoint;
		m_pCHuntngMgr->SendPacketToAll( &brdMsg, sizeof(brdMsg) );
	}
}

VOID CompetitionTeam::IncPlayerKillPoint( Player *pKiller, Player *pDeadPlayer )
{
	// PVP ų¼ö Áõ°¡
	pKiller->GetPVPInfo().IncKill();

	// die¼ö Áõ°¡
	pDeadPlayer->GetPVPInfo().IncDie();
	pDeadPlayer->GetCompetitionInfo().IncDie();

	if( IsSurvivalMode() || IsDeathMatchMode() )
	{
		int iLevelDiff = pDeadPlayer->GetLevel() - pKiller->GetLevel();

		WORD wBonusKillPoint = CalcPlayerKillPoint( iLevelDiff );
		m_wKillPoint += wBonusKillPoint;

		// °³ÀΠųÆ÷ÀÎÆ® Áõ°¡
		pKiller->GetCompetitionInfo().IncKill( wBonusKillPoint );

		// ųÆ÷ÀÎÆ® °»½ÅÀ» ¾Ë¸°´Ù.
		MSG_CG_CHUNTING_UPDATE_KILLPOINT_BRD brdMsg;
		brdMsg.m_wTeamKey = m_wTeamKey;
		brdMsg.m_wKillPoint = m_wKillPoint;
		m_pCHuntngMgr->SendPacketToAll( &brdMsg, sizeof(brdMsg) );
	}
	else if( IsTimeAttackMode() )
	{
		// ¿¬½Â ÄÞÆ÷ Áõ°¡
		pKiller->GetCompetitionInfo().IncKill( 0 );
	}
}

VOID CompetitionTeam::UsePotion()
{
}

VOID CompetitionTeam::AddMember( Player *pPlayer )
{
	if( !(m_PlayerHash.size() < CHUNTING_MAX_MEMBER_NUM) )
	{
		SUNLOG( eMIDDLE_LOG, "[CompetitionTeam::AddMember] Player Num Access!" );
		return;
	}

	DWORD dwObjectKey = pPlayer->GetObjectKey();
	Player *pMember = FindMember( dwObjectKey );
	if( pMember )
	{
		SUNLOG( eMIDDLE_LOG, "[CompetitionTeam::AddMember] Player already exists" );
		return;
	}

	m_PlayerHash.insert( std::make_pair( dwObjectKey, pPlayer ) );

	// Ç÷¹À̾îÀÇ °æÀïÀÎÆ÷ ÃʱâÈ­ ¹× Å° ¼ÂÆÃ
	pPlayer->GetCompetitionInfo().Init();
	pPlayer->GetCompetitionInfo().SetTeamKey( m_wTeamKey );

	// Ãʱ⠸â¹öÀÇ ·¹º§, ¼ö
	m_TotLevel += pPlayer->GetLevel();
	m_byInitMemberNum = (BYTE)m_PlayerHash.size();

	// ÆÀÁ¤º¸ Send
	MSG_CG_CHUNTING_TEAM_INFO_CMD cmdMsg;
	cmdMsg.m_wTeamKey = m_wTeamKey;
	pPlayer->SendPacket( &cmdMsg, sizeof(cmdMsg) );

	m_setReadyUserKeys.erase( pPlayer->GetUserKey() );
}

VOID CompetitionTeam::RemoveMember( DWORD dwObjKey )
{
	Player *pMember = FindMember( dwObjKey );
	if( !pMember )
	{
		SUNLOG( eMIDDLE_LOG, "[CompetitionTeam::RemoveMember] Player doesn't exist" );
		return;
	}

	m_PlayerHash.erase( dwObjKey );
	// Ç÷¹À̾îÀÇ °æÀïÀÎÆ÷ ÃʱâÈ­
	pMember->GetCompetitionInfo().Init();

	m_setReadyUserKeys.erase( pMember->GetUserKey() );
}

Player*		CompetitionTeam::FindMember( DWORD dwObjKey )
{
	PLAYER_HASH_ITR itFIND = m_PlayerHash.find(dwObjKey);
	Player* pPlayer = itFIND != m_PlayerHash.end() ? itFIND->second : NULL;
	return pPlayer;
}

BYTE		CompetitionTeam::GetMemberNum()
{
	return (BYTE)m_PlayerHash.size();
}

BYTE CompetitionTeam::GetAliveMemberNum()
{
	BYTE byAliveNum = 0;

	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;
		if( pPlayer->IsAlive() )
			++byAliveNum;
	}

	return byAliveNum;
}

void CompetitionTeam::SendPacketToAll(MSG_BASE_FORWARD* msg, WORD msg_size, DWORD sender_object_key)
{
    MSG_AG_CONNECTION_PACKET_BROADCASTER_ONEtoN_SYN& msg_brd =
        MSG_ONEtoN_BROADCASTER::InstanceOfBase();
    msg_brd.Init(msg, msg_size);
    uint16_t* const user_begin = msg_brd.GetUsersStartPtr();

    const BOOLEAN check_skip_object = !sender_object_key;
    FOREACH_CONTAINER(const PLAYER_HASH::value_type& node, m_PlayerHash, PLAYER_HASH)
    {
        Player* const player = node.second;
        const DWORD object_key = player->GetObjectKey();
        if (!(check_skip_object || (object_key != sender_object_key))) {
            continue;
        };

        DWORD bound_check = msg_brd.AddUser(user_begin, object_key);
        __TOUCHED(bound_check); //assert(bound_check != 0);
    };

    if (msg_brd.number_of_users) {
        g_pGameServer->SendToServer(AGENT_SERVER, &msg_brd, msg_brd.GetSendingSize());
    };
}

BYTE CompetitionTeam::GetAllPointInfo( CompetitionPoint * OUT pPointInfo )
{
	BYTE byCount = 0;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		Player* pPlayer = it->second;
		pPointInfo[byCount].m_dwObjKey = pPlayer->GetObjectKey();
		pPointInfo[byCount].m_wKillPoint = pPlayer->GetCompetitionInfo().GetKillPoint();
		pPointInfo[byCount].m_byDieNum = pPlayer->GetCompetitionInfo().GetDieNum();
		pPointInfo[byCount].m_byCombo = pPlayer->GetCompetitionInfo().GetMaxSeries();

		byCount++;
	}

	return byCount;
}


class KillPointGreater
{
public:
	bool operator () ( Player *pLeft, Player *pRight ) const
	{
		return pLeft->GetCompetitionInfo().GetKillPoint() > pRight->GetCompetitionInfo().GetKillPoint();
	}
};

VOID CompetitionTeam::OnCalcRanking()
{
	static PLAYER_SORT_VECTOR m_vecSortPlayer;
	Player * pPlayer = NULL;
	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		pPlayer = it->second;
		m_vecSortPlayer.push_back( pPlayer );
	}

	BYTE bySortCount = min( 3, (BYTE)m_PlayerHash.size() );
	partial_sort( m_vecSortPlayer.begin(), m_vecSortPlayer.begin()+bySortCount, m_vecSortPlayer.end(), KillPointGreater() );

	int iRanking = -1;		WORD wPreKillPoint = 0;		
	PLAYER_SORT_VECTOR_ITR endit = m_vecSortPlayer.begin()+bySortCount;

	for( PLAYER_SORT_VECTOR_ITR vit = m_vecSortPlayer.begin(); vit != endit; ++vit )
	{
		pPlayer = *vit;

		// ÀÌÀü ųÆ÷ÀÎÆ® º¸´Ù ³·À¸¸é ·©Å·ÀÌ ³»·Á°£´Ù.(µ¿·üÀÏ °æ¿ì¸¦ À§ÇÑ ÄÚµå)
		if( wPreKillPoint > pPlayer->GetCompetitionInfo().GetKillPoint() )
		{
			++iRanking;
			wPreKillPoint = pPlayer->GetCompetitionInfo().GetKillPoint();
		}

		pPlayer->GetCompetitionInfo().SetRanking( max(0, iRanking) );
	}
}

VOID CompetitionTeam::AllResurrectionAtSafezone()
{
	const sMAPINFO *psMAPINFO = MapInfoParser::Instance()->FindMapInfo( m_pCHuntngMgr->GetCHunting()->GetMapCode() );
	if( !psMAPINFO )
	{
		SUNLOG( eCRITICAL_LOG, "[AllResurrection] psMAPINFO is NULL" );
		return;
	}

	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		Player* pPlayer = it->second;
		ResurrectionAtSafezone( pPlayer, FALSE );
	}
}

RC::eSTATUS_RESULT CompetitionTeam::ResurrectionAtSafezone( Player *pPlayer, BOOL bModeCheck )
{
	GameField *pField = pPlayer->GetField();
	if( !pField )
		return RC::RC_STATUS_FIELD_IS_NULL;

	// Mode üũ( °æÀï¸ðµå¿¡ µû¶ó¼­ ºÎÈ°ÀÌ °¡´ÉÇÒ ¶§µµ ÀÖ°í, ºÒ°¡´ÉÇÒ ¶§µµ ÀÖ´Ù. )
	if( bModeCheck )
	{
		if( IsCompetition() )
		{
			// °æÀïÁßÀÏ ¶§´Â ŸÀÓ¾îÅÿ¡¼­¸¸ ºÎÈ°À§Ä¡¿¡¼­ ºÎÈ°ÇÒ ¼ö ÀÖ´Ù.
			if( !IsTimeAttackMode() )
				return RC::RC_STATUS_RESURRECTION_FAIL;
		}
	}

	// SafeZoneÀ¸·Î À̵¿ÇÑ´Ù.
	RC::eSTATUS_RESULT rcResult = OnMoveToSafezone( pPlayer );
	if( rcResult != RC::RC_STATUS_SUCCESS )
		return rcResult;

	//Á×Àº»óÅÂÀÏ ¶§¸¸ ºÎÈ°ÇÑ´Ù.
	if( pPlayer->IsDead() )
	{
		if( !pPlayer->OnResurrection( 0, 0.15f, 0.15f ) )
		{
			return RC::RC_STATUS_RESURRECTION_FAIL;
		}
	}

	return RC::RC_STATUS_SUCCESS;
}

RC::eSTATUS_RESULT CompetitionTeam::OnMoveToSafezone( Player *pPlayer )
{
	GameField *pField = pPlayer->GetField();
	if( !pField )
		return RC::RC_STATUS_FIELD_IS_NULL;

	const sMAPINFO *psMAPINFO = MapInfoParser::Instance()->FindMapInfo( m_pCHuntngMgr->GetCHunting()->GetMapCode() );
	if( !psMAPINFO )
	{
		SUNLOG( eCRITICAL_LOG, "[CompetitionTeam::MoveToSafezone] psMAPINFO is NULL" );
		return RC::RC_STATUS_MAPINFO_IS_NULL;
	}

	DWORD dwAreaID = 0;
	if( m_bChampion )	dwAreaID = psMAPINFO->wStartAreaID;
	else				dwAreaID = psMAPINFO->wStartAreaID2;

	WzVector vDestPos;
	if( !pField->GetAreaRandomStartingVector( dwAreaID, vDestPos ) )
		return RC::RC_STATUS_IS_NOT_SAFEZONE;

	// ½ÃÀÛÀ§Ä¡·Î ÅÚ·¹Æ÷Æ® ½ÃŲ´Ù.
	if( !pField->TeleportObject( pPlayer, &vDestPos, TRUE ) )
		return RC::RC_STATUS_TELEPORT_FAIL;

	// °­Á¦¿öÇÁ½Ã Àá½Ã ´Ù¸¥ À̵¿À» ¸·´Â´Ù.
	SERVER_COMMON_OPTION& stServerOptionInfo = ServerOptionParserEx::Instance()->GetServerOption();

	pPlayer->GetStatusManager()->AllocStatus( eCHAR_STATE_ETC_FORCED_WARP, stServerOptionInfo.m_wFORCED_WARP_MOVE_DELAY );

	return RC::RC_STATUS_SUCCESS;
}

LEVELTYPE CompetitionTeam::GetAvgLevel()
{
	BYTE byMemberNum = GetMemberNum();
	if( !byMemberNum )
	{
		byMemberNum = m_byInitMemberNum;
	}

	LEVELTYPE AvgLevel = 0;
	if( byMemberNum )
		AvgLevel = GetTotLevel() / byMemberNum;
	else
		AvgLevel = 1;

	AvgLevel = max( 1, AvgLevel );

	return AvgLevel;
}

LEVELTYPE CompetitionTeam::GetTotLevel()
{
	// ÆÀ¿øÀÌ ¸ðµÎ ³ª°¬À» °æ¿ì TotLevelÀº Ãʱ⠷¹º§°ªÀ» ÂüÁ¶ÇÑ´Ù.
	if( !GetMemberNum() )
	{
		return m_TotLevel;
	}

	LEVELTYPE TotLevel = 0;

	PLAYER_HASH_ITR itend = m_PlayerHash.end();
	for( PLAYER_HASH_ITR it = m_PlayerHash.begin(); it != itend ; ++it )
	{
		Player* pPlayer = it->second;
		TotLevel += pPlayer->GetLevel();
	}

	return TotLevel;
}

// GM ¸í·É¾î ¿ëµµ
VOID CompetitionTeam::IncWinCount( Player * pPlayer, int iIncVCount )
{
	// iIncVCount°¡ 0 ÀÌ»ó MAX_VICTORY_NUM °ªÀ» ³ÑÁö ¾Êµµ·Ï ¼öÄ¡¸¦ º¸Á¤ÇÑ´Ù.
	iIncVCount = max( 0, iIncVCount );
	WORD wWinPoint = m_wWinPoint + iIncVCount*100;
	wWinPoint = min( MAX_WIN_POINT, wWinPoint );
	iIncVCount = (wWinPoint - m_wWinPoint) / 100;

	m_wWinPoint += iIncVCount * 100;

	// ½Â¸® ÀüÀû Ãß°¡
	for( int i = 0; i < iIncVCount; ++i )
	{
		pPlayer->GetCompetitionInfo().IncPlayTimes();
		pPlayer->GetCompetitionInfo().IncWinTimes();
	}

	MSG_CG_CHUNTING_WIN_COMPETITION_BRD msg;

	memset( &msg.m_ItemInfo, 0, sizeof(INVENTORY_TOTAL_INFO) );

	// ¾ÆÀÌÅÛ È¹µæ, »ç¿ë°¡´ÉÇÑ ¹°¾à°³¼ö Áõ°¡
	DWORD dwRewardIndex = 0;
	GameZone *pZone = pPlayer->GetGameZonePtr();
	if( pZone )
	{
		BYTE VictoryNum = (BYTE)(m_wWinPoint / 100);

		MAPCODE FieldCode = 0;	
		if( pPlayer->GetField() )	FieldCode = pPlayer->GetField()->GetFieldCode();
		
#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
		REWARD_INFO *pRewardInfo = CHuntingRewardParser::Instance()->GetRewardInfo( pZone->GetMapCode(), FieldCode, m_pCHuntngMgr->IsGuildPVPMode() , m_Rule, m_Mode, VictoryNum );
#else
		REWARD_INFO *pRewardInfo = CHuntingRewardParser::Instance()->GetRewardInfo( pZone->GetMapCode(), FieldCode, m_Rule, m_Mode, VictoryNum, 0 );
#endif
		if( pRewardInfo )
		{
			dwRewardIndex = CHuntingRewardParser::Instance()->GetRandomRewardIndex( pRewardInfo );

			BYTE SelectItemBits = ( 1 << random(0,3) );

			g_RewardManager.RewardItem( RewardManager::eREWARD_COMPETITION, dwRewardIndex, SelectItemBits, pPlayer, msg.m_ItemInfo );
		}
	}

	msg.m_wWinPoint = m_wWinPoint;
	msg.m_i64Exp = pPlayer->GetExp();
	msg.m_CurMoney = pPlayer->GetMoney();
	msg.m_PlusPVPPoint = 0;
	pPlayer->SendPacket( &msg, msg.GetSize() );
}

WORD CompetitionTeam::OnGetMaxPlayTimes()
{
#ifdef __NA_000000_20070528_TAIWAN_GUILD_PVP
	return m_pCHuntngMgr->OnGetMaxPlayTimes();
#else

	SERVER_COMMON_OPTION& stServerOptionInfo = ServerOptionParserEx::Instance()->GetServerOption();

	if( IsTimeAttackMode() )
		return (WORD)(stServerOptionInfo.m_dwTIMEATTACK_PLAY_TIME/1000);
	else
		return (WORD)(stServerOptionInfo.m_dwSURVIVAL_PLAY_TIME/1000);
#endif
}

VOID CompetitionTeam::SetReadyPlayer( BYTE byReadyPlayerNum, DWORD * IN pUserKeyList )
{
    // _NA_0_20091118_GAMEROOM_BATTLE_RESULT
    m_byTeamWinCount = 0;            // ¿¬½Â Ƚ¼ö

	m_byReadyPlayerNum = byReadyPlayerNum;
	m_setReadyUserKeys.clear();

	for( int i = 0; i < byReadyPlayerNum; ++i )
	{
		m_setReadyUserKeys.insert( pUserKeyList[i] );
	}
}

BOOL CompetitionTeam::IsAllPlayerEntered()
{
	if( m_setReadyUserKeys.size() == 0 )
		return TRUE;
	else
		return FALSE;
}

BOOL CompetitionTeam::IsReadyPlayer( DWORD UserKey )
{
	STLX_SET<DWORD>::iterator it = m_setReadyUserKeys.find( UserKey );
	if( it != m_setReadyUserKeys.end() )
		return TRUE;

	return FALSE;
}