#include "stdafx.h"
#include "gamesrv.h"
#include "DeathMatchObject.h"
#include "PVPManager.h"
#include "Protocol.h"
#include "LevelScript.h"
#include "PvPScript.h"
#include "Totem.h"
#include "ObjectManager.h"
#include "SkillManager.h"
#include "StageScript.h"
#include "GatheringScript.h"
#include "Gathering.h"
#include "GridManager.h"
#include "MonsterScript.h"
#include "AIManager.h"
#include "Monster.h"


cDeathMatchObject::cDeathMatchObject() : cBaseDeathMatch( ePVPDM_OBJECTTYPE_1 )
{
	mLeaderTimePass = 0;
	mNextLogTime = 0;
}


cDeathMatchObject::~cDeathMatchObject()
{
	for( unsigned long i = 0 ; i < ePVPDM_TEAMTYPE_MAX ; ++i )
	{
		if( mStoneInfo[i].mStoneIdx != 0 )
		{
			cMonster* pMonObject = OBJECTMANAGER->GetMonster( mStoneInfo[i].mStoneIdx );
			if( pMonObject != NULL )
			{
				pMonObject->Release();
				GRIDMANAGER->RemoveMonster( pMonObject );
			}
			OBJECTMANAGER->RemoveMonster( mStoneInfo[i].mStoneIdx );	
		}
	}
}

void* cDeathMatchObject::operator new( size_t n )
{
	if( n != sizeof(cDeathMatchObject) ) 
	{
		NETWORK2->PostServerEvent("cDeathMatchObject::operator new %d != sizeof(cDeathMatchObject)", n );
		return NULL;
	}

	return PVPOBJECTPOOL->NewDMObject();
}


void cDeathMatchObject::operator delete( void* ptr, size_t n )
{
	/// NULL Æ÷ÀÎÅÍ °Ë»ç



	if( ptr == 0 )
	{
		NETWORK2->PostServerEvent("cDeathMatchObject::operator delete ptr == 0" );
		return;
	}

	if( n != sizeof(cDeathMatchObject) ) 
	{
		NETWORK2->PostServerEvent("cDeathMatchObject::operator delete n != sizeof(cDeathMatchObject", n );
		return;
	}

	//PVPOBJECTPOOL->FreeDMObject( static_cast<cDeathMatchObject*>(ptr) );

	return;
}

bool cDeathMatchObject::Init( unsigned short DMIdx, sLevelForceInfo* pLevelForceInfo )
{
	memset( mLeaderInfo, 0, sizeof( mLeaderInfo ) );
	memset( mStoneInfo, 0, sizeof( mStoneInfo ) ); 

	return cBaseDeathMatch::Init( DMIdx, pLevelForceInfo );
}


void cDeathMatchObject::Process( unsigned long elapsedTime, unsigned long accumTime )
{
	/// ¹æ¿¡ ¾Æ¹«µµ ¾øÀ¸¸é °´Ã¼ ¼Ò¸ê
	/// ¸¶Áö¸· À¯Àú°¡ ³ª°¡´Â ½ÃÁ¡¿¡ »èÁ¦ ºÒ°¡´É Çß´ø ÀÌÀ¯ üũÇغ¸ÀÚ!!
	if( mTeamInfo[ePVPDM_TEAMTYPE_A].mMemberCnt + mTeamInfo[ePVPDM_TEAMTYPE_B].mMemberCnt == 0 && ePVPDM_PROCESS_READY < mProcess )
		mProcess = ePVPDM_PROCESS_END;

	if( mScoreEnd == true )
	{
		mScoreEnd = false;
		Result();
	}

	switch( mProcess )
	{
	case ePVPDM_PROCESS_WAIT:		/// Ready() È£Ãâ ±â´Ù¸²
		{
			if( mWaitEndTime > accumTime )
				return;

			Ready();
		}
		break;
	case ePVPDM_PROCESS_READY:
		{
			/// PvP ´ë±â½Ã°£


			if( mProcessEndTime > accumTime )
				return;

			EndNpcTalk();

			unsigned long fightTime = 0;
			sDMInfo* pInfo = PVPMANAGER->GetDMInfo();
			if( pInfo != NULL )
			{
				/// ePVPDM_PROCESS_FIGHT_MINIMUM ¿¡¼­ ³ª¸ÓÁö ÀÜ¿©½Ã°£À» ´Ù½Ã ¼³Á¤
				fightTime = pInfo->mTotalDMTime * MINUTE;		/// ÃÑÀüÅõ½Ã°£

				/// ÃÑÀüÅõ½Ã°£º¸´Ù ÀοøºÎÁ·Ã¼Å© ¾ÈÇÔ ½Ã°£ÀÌ Å«°æ¿ì


				if( PVP_DM_TEAM_MINCNT_TIME > fightTime )	
					mProcessEndTime = accumTime + fightTime;	 /// ´ÙÀ½ÇÁ·Î¼¼½º ¼öÇà½Ã°£À» ½ºÅ©¸³Æ®½Ã°£À¸·Î
				else	/// ÃÑÀüÅõ½Ã°£º¸´Ù ÀοøºÎÁ· ½Ã°£ÀÌ ÀÛÀº°æ¿ì
					mProcessEndTime = accumTime + PVP_DM_TEAM_MINCNT_TIME;	/// ´ÙÀ½ÇÁ·Î¼¼½º ¼öÇà½Ã°£À» ÃÖ¼ÒÀοø üũ¾ÈÇԽð£À¸·Î
			}

			/// Ŭ¶óÀ̾ðÆ®¿¡´Â ÃÑÀüÅõ½Ã°£À» ¾Ë·ÁÁÜ


			SendFight( fightTime );

			/// pvp ÀüÅõ ½ÃÀÛ ÇÁ·Î¼¼½º·Î À̵¿
			mProcess = ePVPDM_PROCESS_FIGHT_MINIMUM;

			///
			cTotem* pTotem = NULL;
			NiPoint2 centerPos;
			for( unsigned char i=0;i<ePVPDM_TEAMTYPE_MAX; ++i )
			{
				unsigned long posIdx = PVPMANAGER->GetTeamGenPosIdx( (ePVPDM_TEAM_TYPE)i );
				if( posIdx != 0 )
				{
					sStageChangePos* pStagePos = STAGESCRIPT->GetPosScriptInfo( posIdx );
					if( pStagePos != 0 )
					{
						centerPos.x = pStagePos->mPosX;
						centerPos.y = pStagePos->mPosY;
						pTotem = OBJECTMANAGER->PvPAddTotem( i, PVP_DM_ADD_TOTEMIDX_BUFF, mDMIdx, centerPos, eAPPLYTYPE_BUDDY, eATTRIBUTETYPE_PHYSICAL );
						if( pTotem != NULL )
						{
							GRIDMANAGER->AddTotem( pTotem );
							mDMTotemArr.PushBack(pTotem->GetObjectID());
						}
						pTotem = OBJECTMANAGER->PvPAddTotem( i, PVP_DM_ADD_TOTEMIDX_DEBUFF, mDMIdx, centerPos, eAPPLYTYPE_ENEMY, eATTRIBUTETYPE_PHYSICAL );
						if( pTotem != NULL )
						{
							GRIDMANAGER->AddTotem( pTotem );
							mDMTotemArr.PushBack(pTotem->GetObjectID());
						}
					}
				}
			}

			AddTeleportPortal();
		}
		break;
	case ePVPDM_PROCESS_READY_OUT:
		{
			/// pvp out ¿äû ¹Þ´Â ½Ã°£
			if( mProcessEndTime > accumTime )
				return;

			/// ¿ÀºêÁ§Æ® Á¦°Å
			mProcess = ePVPDM_PROCESS_END;
		}
		break;
	case ePVPDM_PROCESS_FIGHT_MINIMUM:
		{
			LeaderProcess( elapsedTime, accumTime );
			StoneProcess( elapsedTime, accumTime );

			/// ÀÏÁ¤ ½Ã°£µ¿¾È ÀοøºÎÁ· °áÅõ Á¾·á üũ ¾ÈÇÔ
			if( mProcessEndTime <= accumTime )
			{
				mProcess = ePVPDM_PROCESS_FIGHT;

				mProcessEndTime = accumTime + 0;
				sDMInfo* pInfo = PVPMANAGER->GetDMInfo();
				if( pInfo != NULL )
				{
					/// Àοøüũ ¾ÈÇÔ ½Ã°£º¸´Ù ÃÑÀüÅõ½Ã°£ÀÌ Å«°æ¿ì ³ª¸ÓÁö ÀÜ¿©½Ã°£À» ¼³Á¤ÇØÁÜ
					if( PVP_DM_TEAM_MINCNT_TIME < pInfo->mTotalDMTime * MINUTE )
						mProcessEndTime = accumTime + ( pInfo->mTotalDMTime * MINUTE - PVP_DM_TEAM_MINCNT_TIME );

					for( int i = ePVPDM_TEAMTYPE_A ; i < ePVPDM_TEAMTYPE_MAX ; ++i )
					{
						if( mTeamInfo[i].mMemberCnt < pInfo->mTeamPlayerMin )
						{
							Result();
							return;
						}
					}
				}
			}
		}
		break;
	case ePVPDM_PROCESS_FIGHT:
		{
			LeaderProcess( elapsedTime, accumTime );
			StoneProcess( elapsedTime, accumTime );

			/// ½Ã°£ Á¾·á
			if( mProcessEndTime <= accumTime )
				Result();
		}
		break;
	case ePVPDM_PROCESS_FIGHTEND:
		{
			/// pvp out ¿äû ¹Þ´Â ½Ã°£
			if( mProcessEndTime <= accumTime )
				mProcess = ePVPDM_PROCESS_END;
		}
		break;
	case ePVPDM_PROCESS_END:
		{
			/// Àüü À¯Àú Ãß¹æ
			if( mAutoOutCheckTime < accumTime )
			{
				if( OrderEndDM() == true )
				{
					EndDM();
					PVPMANAGER->DelAryInsertPVP( mDMIdx );
				}
			}
		}
		break;
	}
}


void cDeathMatchObject::LeaderProcess( unsigned long /*elapsedTime*/, unsigned long accumTime )
{
	if( mLeaderTimePass < accumTime )
		mLeaderTimePass = accumTime + 200;

	/// ¸®´õ ¼±Á¤
	for( int teamType = ePVPDM_TEAMTYPE_A ; teamType < ePVPDM_TEAMTYPE_MAX ; ++teamType )
	{
		/// ½Ã°£ üũ
		if( mLeaderInfo[teamType].mLeaderChangeTime >= accumTime )
			continue;

		unsigned long memberIdx[PVP_DM_TEAM_CNT];
		unsigned long cnt = 0;
		tPointerHashMap<unsigned long, void*>::cIterator b = mTeamInfo[teamType].mMemberMap.Begin();
		tPointerHashMap<unsigned long, void*>::cIterator end = mTeamInfo[teamType].mMemberMap.End();
		for( ; b!=end; ++b )
		{
			cPvPDMMemberInfo* pInfo = (cPvPDMMemberInfo*)(*b).mSecond;
			if( pInfo )
			{
				cPlayer* player = OBJECTMANAGER->GetPlayer( pInfo->mPlayerIdx );
				if( player == 0 || player->GetStateDie() == true )
					continue;

				memberIdx[cnt] = pInfo->mPlayerIdx;
				++cnt;
			}
		}
		if( cnt == 0 )
			continue;

		/// ±âÁ¸ ¼öÀå ±ÇÇÑ ¹Ý³³
		sObject leader = { eOBJECTTYPE_PLAYER, mLeaderInfo[teamType].mLeaderIdx };
		SKILLMANAGER->DeleteInfluenceClassIdx( leader, PVP_DM_LEADER_INFLUENCE );
		SKILLMANAGER->DeleteInfluenceClassIdx( leader, PVP_DM_LEADER_INFLUENCE2 );

		/// ¼±Á¤µÈ ¸ñ·ÏÁß ·£´ý ¼±ÅÃ
		unsigned long selectCnt = rand() % cnt;

		sObject object = { eOBJECTTYPE_PLAYER, memberIdx[selectCnt] };
		if( SKILLMANAGER->AddInfSwitch( object, object, PVP_DM_LEADER_INFLUENCE, PVP_DM_LEADER_SKILL, true ) == 0 )
			return;
		SKILLMANAGER->AddInfSwitch( object, object, PVP_DM_LEADER_INFLUENCE2, 0, true );

		mLeaderInfo[teamType].mLeaderIdx = memberIdx[selectCnt];
		/// ´ÙÀ½ º¯°æ ½Ã°£ ¼³Á¤
		mLeaderInfo[teamType].mLeaderChangeTime = accumTime + PVP_DM_LEADER_CHANGETIME;

		/// ¼öÀå ¼³Á¤ ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_PVP_DM_LEADERCHANGE synMsg;
		synMsg.Category = NM_PVP;
		synMsg.Protocol = NM_PVP_DM_LEADERSELECT_SYN;
		synMsg.mCharacterIdx = mLeaderInfo[teamType].mLeaderIdx;
		TeamQuickSend( (ePVPDM_TEAM_TYPE)teamType, (char*)&synMsg, sizeof(synMsg) );
	}
}


void cDeathMatchObject::StoneProcess( unsigned long /*elapsedTime*/, unsigned long accumTime )
{
	if( mpDMBlockInfo == NULL )
	{
		assert(NULL);
		if( mNextLogTime < accumTime )
		{
			mNextLogTime = accumTime + 1 * MINUTE;
			NETWORK2->PostServerEvent("cDeathMatchObject::StoneProcess mpDMBlockInfo == NULL");
		}
		return;
	}

	/// ¸®´õ ¼±Á¤
	for( int teamType = ePVPDM_TEAMTYPE_A ; teamType < ePVPDM_TEAMTYPE_MAX ; ++teamType )
	{
		if( mStoneInfo[teamType].mStoneIdx != 0 )
			continue;

		if( mStoneInfo[teamType].mStoneRegenTime != 0 )
		{
			/// ½Ã°£ üũ
			if( mStoneInfo[teamType].mStoneRegenTime >= accumTime )
				continue;
		}

		mStoneInfo[teamType].mStoneRegenTime = ULONG_MAX;
		
		//unsigned long posIdx = PVPMANAGER->GetTeamGenPosIdx( (ePVPDM_TEAM_TYPE)teamType );
		//if( posIdx == 0 )
		//{
		//	if( mNextLogTime < accumTime )
		//	{
		//		mNextLogTime = accumTime + 1 * MINUTE;
		//		NETWORK2->PostServerEvent("cDeathMatchObject::StoneProcess posIdx[%d] == 0", posIdx);
		//	}

		//	assert(NULL);
		//	continue;
		//}
		//else
		//{
		//	sStageChangePos* pStagePos = STAGESCRIPT->GetPosScriptInfo( posIdx );
		//	if( pStagePos != 0 )
		//	{
		//		x = pStagePos->mPosX;
		//		y = pStagePos->mPosY;
		//	}
		//	else
		//	{
		//		if( mNextLogTime < accumTime )
		//		{
		//			mNextLogTime = accumTime + 1 * MINUTE;
		//			NETWORK2->PostServerEvent("cDeathMatchObject::StoneProcess pStagePos[%d] != 0", posIdx);
		//		}

		//		assert(NULL);
		//		continue;
		//	}
		//}

		/// ´ÙÀ½ º¯°æ ½Ã°£ ¼³Á¤
		//mStoneInfo[teamType].mStoneRegenTime = accumTime + PVP_DM_STONE_REGEN_TIME;

		sDMInfo* pDMInfo = PVPMANAGER->GetDMInfo();
		if( pDMInfo == NULL )
		{
			if( mNextLogTime < accumTime )
			{
				mNextLogTime = accumTime + 1 * MINUTE;
				NETWORK2->PostServerEvent("cDeathMatchObject::StoneProcess pDMInfo == NULL");
			}
			continue;
		}

		if( pDMInfo->mStone == false )
			continue;

		NiPoint2 pos;
		if( teamType == ePVPDM_TEAMTYPE_A )
			pos = pDMInfo->mStoneAPos;
		else if( teamType == ePVPDM_TEAMTYPE_B )
			pos = pDMInfo->mStoneBPos;
		else
			assert(NULL);

		unsigned long stoneIdx = mpDMBlockInfo->mStoneAIdx;
		if( teamType == ePVPDM_TEAMTYPE_B )
			stoneIdx = mpDMBlockInfo->mStoneBIdx;

		cMonster* pMonster = AIMANAGER->StoneSummonMonRegen( mDMIdx, pos.x, pos.y, stoneIdx, (ePVPDM_TEAM_TYPE)teamType );
		if( pMonster == NULL )
		{
			if( mNextLogTime < accumTime )
			{
				mNextLogTime = accumTime + 1 * MINUTE;
				NETWORK2->PostServerEvent("cDeathMatchObject::StoneProcess pMonster == NULL[%d,%f,%f,%d,%f]", 
					mDMIdx, pos.x, pos.y, stoneIdx, (ePVPDM_TEAM_TYPE)teamType);
			}

			assert(NULL);
			continue;
		}

		/// °íÀ¯¹øÈ£
		mStoneInfo[teamType].mStoneIdx = pMonster->GetObjectID();

		/// ¼®»ó»ý¼º
		MSG_SYN_PVP_DM_STONE_CREATE synMsg;
		synMsg.Category = NM_PVP;
		synMsg.Protocol = NM_PVP_DM_STONE_CREATE_SYN;
		synMsg.mTeamType = (unsigned char)teamType;
		synMsg.mMaxHP = pMonster->GetMaxHP();
		synMsg.mPos = pMonster->GetPos();
		DMQuickSend( (char*)&synMsg, sizeof(synMsg) );
	}
}


void cDeathMatchObject::ScoreUpdate( unsigned long killIdx, ePVPDM_TEAM_TYPE killerTeam, 
									unsigned long deadIdx, ePVPDM_TEAM_TYPE deadTeam )
{
	if( mProcess < ePVPDM_PROCESS_FIGHT_MINIMUM || ePVPDM_PROCESS_FIGHT < mProcess )
		return;

	if( killerTeam >= ePVPDM_TEAMTYPE_MAX || deadTeam >= ePVPDM_TEAMTYPE_MAX )
	{
		assert(0);
		return;
	}

	/// ÃÖÃÊ Å³Æ÷ÀÎÆ® ȹµæÆÀ ¼ÂÆÃ
	if( mFirstKillTeam == ePVPDM_TEAMTYPE_MAX )
		mFirstKillTeam = killerTeam;

	/// ¼öÀå Á×À½ üũ
	bool isLeader = false;

	unsigned long plusPoint = PVP_DM_MEMBER_DIE_POINT;
	/// Á×Àº ¼öÀå ó¸®
	if( mLeaderInfo[deadTeam].mLeaderIdx == deadIdx )
	{
		isLeader = true;

		/// ¼öÀå ¾øÀ½ ¼³Á¤
		++mLeaderInfo[deadTeam].mLeaderDieCnt;
		mLeaderInfo[deadTeam].mLeaderIdx = 0;
		mLeaderInfo[deadTeam].mLeaderChangeTime = NETWORK2->GetAccumTime() + PVP_DM_LEADER_DIECHANGETIME;

		/// ¼öÀå Á×À½ ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_DM_LEADERDIE synMsg;
		synMsg.Category = NM_PVP;
		synMsg.Protocol = NM_PVP_DM_LEADERDIE_SYN;
		synMsg.mPlayerIdx = deadIdx;
		TeamQuickSend( deadTeam, (char*)&synMsg, sizeof( synMsg ) );

		MSG_SYN_DM_ENEMYLEADERDIE synMsgEnemy;
		synMsgEnemy.Category = NM_PVP;
		synMsgEnemy.Protocol = NM_PVP_DM_ENEMYLEADERDIE_SYN;
		synMsgEnemy.mPlayerIdx = killIdx;
		TeamQuickSend( killerTeam, (char*)&synMsgEnemy, sizeof( synMsgEnemy ) );

		/// Á×Àº ÀÚ°¡ ¼öÀåÀ̸é 5Æ÷ÀÎÆ®¸¦ ÁÜ

		plusPoint = PVP_DM_LEADER_DIE_POINT;
	}

	/// Á×ÀÎÀÚ ÆÀ¿¡ Á¡¼ö Áõ°¡
	mTeamInfo[killerTeam].mPoint += plusPoint;

	/// Á×ÀÎÀÚ kill Áõ°¡
	cPvPDMMemberInfo* pInfo = (cPvPDMMemberInfo*)mTeamInfo[killerTeam].mMemberMap.GetAt( killIdx );
	if( pInfo )
	{
		if( isLeader == true )
			pInfo->mLeaderKillCnt++;
		else
			pInfo->mKillCnt++;

		/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_PVP_DM_SCORE msg;
		msg.Category = NM_PVP;
		msg.Protocol = NM_PVP_DM_SCORE_SYN;
		msg.mTeamType = (unsigned char)killerTeam;
		msg.mPlusScore = plusPoint;
		msg.mTotalScore = mTeamInfo[killerTeam].mPoint;
		msg.mPlayerIdx = killIdx;
		msg.mPlayerScore = pInfo->mKillCnt + pInfo->mLeaderKillCnt;
		TeamQuickSend( killerTeam, (char*)&msg, sizeof( MSG_SYN_PVP_DM_SCORE ) );
	}
	else
	{
		assert(0);
	}

	pInfo = (cPvPDMMemberInfo*)mTeamInfo[deadTeam].mMemberMap.GetAt( deadIdx );
	if( pInfo )
	{
		pInfo->mDeathCnt++;

		/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_PVP_DM_SCORE msg;
		msg.Category = NM_PVP;
		msg.Protocol = NM_PVP_DM_SCORE_SYN;
		msg.mTeamType = (unsigned char)killerTeam;
		msg.mPlusScore = plusPoint;
		msg.mTotalScore = mTeamInfo[killerTeam].mPoint;
		msg.mPlayerIdx = deadIdx;
		msg.mPlayerScore = pInfo->mDeathCnt;
		TeamQuickSend( deadTeam, (char*)&msg, sizeof( MSG_SYN_PVP_DM_SCORE ) );
	}
	else
	{
		assert(0);
	}

	/// Á¡¼ö ½Â¸®Á¶°Ç üũ
	if( mTeamInfo[killerTeam].mPoint >= mpDMBlockInfo->mGoalPoint )
		mScoreEnd = true; 
}

void cDeathMatchObject::StoneScoreUpdate( ePVPDM_TEAM_TYPE killerTeam, unsigned long killerIdx )
{
	if( mProcess < ePVPDM_PROCESS_FIGHT_MINIMUM || ePVPDM_PROCESS_FIGHT < mProcess )
		return;

	if( killerTeam >= ePVPDM_TEAMTYPE_MAX )
	{
		assert(0);
		return;
	}

	/// ÃÖÃÊ Å³Æ÷ÀÎÆ® ȹµæÆÀ ¼ÂÆÃ
	if( mFirstKillTeam == ePVPDM_TEAMTYPE_MAX )
		mFirstKillTeam = killerTeam;

	/// Á×ÀÎÀÚ ÆÀ¿¡ Á¡¼ö Áõ°¡
	mTeamInfo[killerTeam].mPoint += PVP_DM_STONE_DIE_POINT;

	/// Á×ÀÎÀÚ kill Áõ°¡
	unsigned long killerScore = 0;
	cPvPDMMemberInfo* pInfo = (cPvPDMMemberInfo*)mTeamInfo[killerTeam].mMemberMap.GetAt( killerIdx );
	if( pInfo )
		killerScore = pInfo->mKillCnt + pInfo->mLeaderKillCnt;

	/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
	MSG_SYN_PVP_DM_STONE_DIE msg;
	msg.Category = NM_PVP;
	msg.Protocol = NM_PVP_DM_STONE_DIE_SYN;
	msg.mTeamType = (unsigned char)killerTeam;
	msg.mKillerIndex = killerIdx;
	msg.mTotalScore = mTeamInfo[killerTeam].mPoint;

	DMQuickSend( (char*)&msg, sizeof(MSG_SYN_PVP_DM_STONE_DIE) );

	//MSG_SYN_PVP_DM_STONE_ENEMYDIE msgEnemyDie;
	//msgEnemyDie.Category = NM_PVP;
	//msgEnemyDie.Protocol = NM_PVP_DM_STONE_ENEMYDIE_SYN;

	//msgEnemyDie.mTeamType = (unsigned char)killerTeam;
	//msgEnemyDie.mTotalScore = mTeamInfo[killerTeam].mPoint;
	//msgEnemyDie.mPlayerIdx = killerIdx;

	////msgEnemyDie.mPlusScore = PVP_DM_STONE_DIE_POINT;
	////msgEnemyDie.mPlayerScore = killerScore;
	////msgEnemyDie.mPlayerIdx = killerIdx;
	//TeamQuickSend( killerTeam, (char*)&msgEnemyDie, sizeof( MSG_SYN_PVP_DM_STONE_ENEMYDIE ) );

	///// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
	//MSG_SYN_PVP_DM_STONE_DIE msg;
	//msg.Category = NM_PVP;
	//msg.Protocol = NM_PVP_DM_STONE_DIE_SYN;

	//msg.mTeamType = (unsigned char)killerTeam;
	//msg.mTotalScore = mTeamInfo[killerTeam].mPoint;
	//msg.mPlayerIdx = 0;

	//msg.mPlusScore = PVP_DM_STONE_DIE_POINT;
	//msg.mPlayerScore = 0;
	//TeamQuickSend( deadTeam, (char*)&msg, sizeof( MSG_SYN_PVP_DM_STONE_DIE ) );

	/// Á¡¼ö ½Â¸®Á¶°Ç üũ
	if( mTeamInfo[killerTeam].mPoint >= mpDMBlockInfo->mGoalPoint )
		mScoreEnd = true; 
}

void cDeathMatchObject::Result()
{
	mProcess = ePVPDM_PROCESS_FIGHTEND;
	mProcessEndTime = NETWORK2->GetAccumTime() + PVP_DM_OUTWAIT_TIME;

	if( mpDMBlockInfo )
	{
		///Æ÷ÀÎÆ® ´Þ¼º üũ
		if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint >= mpDMBlockInfo->mGoalPoint )
		{
			SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_POINT );
			return;
		}
		if( mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint >= mpDMBlockInfo->mGoalPoint )
		{
			SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_POINT );
			return;
		}
	}
	else
	{
		assert(0);
	}

	/// Æ÷ÀÎÆ® ¿ìÀ§ üũ
	if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint > mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint )
	{
		SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_TIME );
		return;
	}
	else if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint < mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint )
	{
		SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_TIME );
		return;
	}

	/// ¼öÀå »ç¸Á Ƚ¼ö üũ
	if( mLeaderInfo[ePVPDM_TEAMTYPE_A].mLeaderDieCnt > mLeaderInfo[ePVPDM_TEAMTYPE_B].mLeaderDieCnt )
	{
		SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_LEADERDIE );
		return;
	}
	if( mLeaderInfo[ePVPDM_TEAMTYPE_A].mLeaderDieCnt < mLeaderInfo[ePVPDM_TEAMTYPE_B].mLeaderDieCnt )
	{
		SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_LEADERDIE );
		return;
	}

	cBaseDeathMatch::Result();
}

void cDeathMatchObject::OutMember( unsigned long playerIdx, ePVPDM_TEAM_TYPE teamType )
{
	cBaseDeathMatch::OutMember( playerIdx, teamType );

	if( mLeaderInfo[teamType].mLeaderIdx == playerIdx )
	{
		mLeaderInfo[teamType].mLeaderIdx = 0;
		mLeaderInfo[teamType].mLeaderChangeTime = NETWORK2->GetAccumTime() + PVP_DM_LEADER_DIECHANGETIME;
	}

	///
	sDMInfo* pDMInfo = PVPMANAGER->GetDMInfo();
	if( pDMInfo )
	{
		if( ( ePVPDM_PROCESS_FIGHT_MINIMUM == mProcess && mTeamInfo[teamType].mMemberCnt == 0 ) ||
			( ePVPDM_PROCESS_FIGHT == mProcess && mTeamInfo[teamType].mMemberCnt < pDMInfo->mTeamPlayerMin ) )
		{
			mProcess = ePVPDM_PROCESS_FIGHTEND;
			mProcessEndTime = NETWORK2->GetAccumTime() + PVP_DM_OUTWAIT_TIME;

			if( teamType == ePVPDM_TEAMTYPE_A )
				SendResult( ePVPDM_TEAMTYPE_B,ePVPDM_ENDTYPE_MEMBER );
			if( teamType == ePVPDM_TEAMTYPE_B )
				SendResult( ePVPDM_TEAMTYPE_A,ePVPDM_ENDTYPE_MEMBER );
		}
	}
	else
	{
		assert(0);
	}
}

void cDeathMatchObject::SyncStoneHP( unsigned long teamType, unsigned long hp )
{
	if( teamType >= ePVPDM_TEAMTYPE_MAX )
		return;

	MSG_SYN_PVP_DM_STONE_HP syncHP;
	syncHP.Category = NM_PVP;
	syncHP.Protocol = NM_PVP_DM_STONE_HP_SYN;
	syncHP.mHP = hp;
	TeamQuickSend( (ePVPDM_TEAM_TYPE)teamType, (char*)&syncHP, sizeof( syncHP ) );
}

void cDeathMatchObject::DeleteStone( unsigned long teamType, unsigned long lastAttacker )
{
	if( teamType >= ePVPDM_TEAMTYPE_MAX )
		return;

	if( mProcess != ePVPDM_PROCESS_FIGHT_MINIMUM && mProcess != ePVPDM_PROCESS_FIGHT )
		return;

	mStoneInfo[teamType].mStoneIdx = 0;
	mStoneInfo[teamType].mStoneRegenTime = NETWORK2->GetAccumTime() + PVP_DM_STONE_REGEN_TIME;

	if( teamType == ePVPDM_TEAMTYPE_A )
		StoneScoreUpdate( ePVPDM_TEAMTYPE_B, lastAttacker );
	else
		StoneScoreUpdate( ePVPDM_TEAMTYPE_A, lastAttacker );
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

cDeathMatch2Object::cDeathMatch2Object() : cBaseDeathMatch( ePVPDM_OBJECTTYPE_2 )
{
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
			continue;

		pF->mFlagIndex = 0;
		pF->mFlagPointIndex = 0;

		pF->mFlagOwnerIndex = 0;
		pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;

		pF->mNewFlagGen = false;
		pF->mNewFlagWaitTime = 0;
		pF->mSendFlagPosTime = ULONG_MAX;
	}

	mFirstFlagTeam = ePVPDM_TEAMTYPE_MAX;
}

cDeathMatch2Object::~cDeathMatch2Object()
{
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
			continue;

		if( pF->mFlagIndex != 0 )
		{
			cGathering* p = OBJECTMANAGER->GetGathering( pF->mFlagIndex );
			if( p )
			{
				if( GRIDMANAGER->RemoveGathering( p ) == false )
					NETWORK2->PostServerEvent("~cDeathMatch2Object() GRIDMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, i );

				if( OBJECTMANAGER->RemoveGathering( pF->mFlagIndex ) == false )
					NETWORK2->PostServerEvent("~cDeathMatch2Object() OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, i );
			}

			pF->mFlagIndex = 0;
		}

		if( pF->mFlagPointIndex != 0 )
		{
			cGathering* p = OBJECTMANAGER->GetGathering( pF->mFlagPointIndex );
			if( p )
			{
				if( GRIDMANAGER->RemoveGathering( p ) == false )
					NETWORK2->PostServerEvent("~cDeathMatch2Object() GRIDMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagPointIndex, i );

				if( OBJECTMANAGER->RemoveGathering( pF->mFlagIndex ) == false )
					NETWORK2->PostServerEvent("~cDeathMatch2Object() OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagPointIndex, i );
			}
			pF->mFlagPointIndex = 0;
		}
	}

	for( unsigned char i = 0 ; i < mAHoistCnt ; ++i )
	{
		sHoistInfo* pH = &mAteamHoist[i];
		if( pH == NULL )
			continue;

		cGathering* p = OBJECTMANAGER->GetGathering( pH->mObjectIdx );
		if( p )
		{
			if( GRIDMANAGER->RemoveGathering( p ) == false )
				NETWORK2->PostServerEvent("~cDeathMatch2Object() mAteamHoist GRIDMANAGER->RemoveGathering( %d, %d ) == false", pH->mObjectIdx, i );

			if( OBJECTMANAGER->RemoveGathering( pH->mObjectIdx ) == false )
				NETWORK2->PostServerEvent("~cDeathMatch2Object() mAteamHoist OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pH->mObjectIdx, i );
		}
	}

	for( unsigned char i = 0 ; i < mBHoistCnt ; ++i )
	{
		sHoistInfo* pH = &mBteamHoist[i];
		if( pH == NULL )
			continue;

		cGathering* p = OBJECTMANAGER->GetGathering( pH->mObjectIdx );
		if( p )
		{
			if( GRIDMANAGER->RemoveGathering( p ) == false )
				NETWORK2->PostServerEvent("~cDeathMatch2Object() mBteamHoist GRIDMANAGER->RemoveGathering( %d, %d ) == false", pH->mObjectIdx, i );

			if( OBJECTMANAGER->RemoveGathering( pH->mObjectIdx ) == false )
				NETWORK2->PostServerEvent("~cDeathMatch2Object() mBteamHoist OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pH->mObjectIdx, i );
		}
	}
}

void* cDeathMatch2Object::operator new( size_t n )
{
	if( n != sizeof(cDeathMatch2Object) ) 
	{
		NETWORK2->PostServerEvent("cDeathMatchObject::operator new %d != sizeof(cDeathMatch2Object)", n );
		return NULL;
	}

	return PVPOBJECTPOOL->NewDM2Object();
}


void cDeathMatch2Object::operator delete( void* ptr, size_t n )
{
	/// NULL Æ÷ÀÎÅÍ °Ë»ç



	if( ptr == 0 )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::operator delete ptr == 0" );
		return;
	}

	if( n != sizeof(cDeathMatch2Object) ) 
	{
		NETWORK2->PostServerEvent("cDeathMatchObject::operator delete n != sizeof(cDeathMatch2Object", n );
		return;
	}

	//PVPOBJECTPOOL->FreeDMObject( static_cast<cDeathMatch2Object*>(ptr) );

	return;
}

bool cDeathMatch2Object::Init( unsigned short DMIdx, sLevelForceInfo* pLevelForceInfo )
{
	if( pLevelForceInfo == NULL )
		return false;

	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
			continue;

		pF->mFlagIndex = 0;
		pF->mFlagPointIndex = 0;

		pF->mFlagOwnerIndex = 0;
		pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;

		pF->mNewFlagGen = false;
		pF->mNewFlagWaitTime = 0;
		pF->mSendFlagPosTime = ULONG_MAX;
	}

	mFlagCnt = 0;

	mAHoistCnt = 0;
	memset( mAteamHoist, 0, sizeof(mAteamHoist) );
	mBHoistCnt = 0;
	memset( mBteamHoist, 0, sizeof(mBteamHoist) );

	mFirstFlagTeam = ePVPDM_TEAMTYPE_MAX;

	return cBaseDeathMatch::Init( DMIdx, pLevelForceInfo );
}


void cDeathMatch2Object::Process( unsigned long /*elapsedTime*/, unsigned long accumTime )
{
	/// ¹æ¿¡ ¾Æ¹«µµ ¾øÀ¸¸é °´Ã¼ ¼Ò¸ê
	/// ¸¶Áö¸· À¯Àú°¡ ³ª°¡´Â ½ÃÁ¡¿¡ »èÁ¦ ºÒ°¡´É Çß´ø ÀÌÀ¯ üũÇغ¸ÀÚ!!
	if( mTeamInfo[ePVPDM_TEAMTYPE_A].mMemberCnt + mTeamInfo[ePVPDM_TEAMTYPE_B].mMemberCnt == 0 && ePVPDM_PROCESS_READY < mProcess )
		mProcess = ePVPDM_PROCESS_END;

	if( mScoreEnd == true )
	{
		mScoreEnd = false;
		Result();
	}

	switch( mProcess )
	{
	case ePVPDM_PROCESS_WAIT:
		{
			if( mWaitEndTime > accumTime )
				return;

			Ready();
		}
		break;
	case ePVPDM_PROCESS_READY:
		{
			/// PvP ´ë±â½Ã°£

			if( mProcessEndTime > accumTime )
				return;

			EndNpcTalk();

			unsigned long fightTime = 0;
			sDMInfo* pInfo = PVPMANAGER->GetDMInfo();
			if( pInfo != NULL )
			{
				/// ePVPDM_PROCESS_FIGHT_MINIMUM ¿¡¼­ ³ª¸ÓÁö ÀÜ¿©½Ã°£À» ´Ù½Ã ¼³Á¤
				fightTime = pInfo->mTotalDMTime * MINUTE;		/// ÃÑÀüÅõ½Ã°£

				/// ÃÑÀüÅõ½Ã°£º¸´Ù ÀοøºÎÁ·Ã¼Å© ¾ÈÇÔ ½Ã°£ÀÌ Å«°æ¿ì


				if( PVP_DM_TEAM_MINCNT_TIME > fightTime )	
					mProcessEndTime = accumTime + fightTime;	 /// ´ÙÀ½ÇÁ·Î¼¼½º ¼öÇà½Ã°£À» ½ºÅ©¸³Æ®½Ã°£À¸·Î
				else	/// ÃÑÀüÅõ½Ã°£º¸´Ù ÀοøºÎÁ· ½Ã°£ÀÌ ÀÛÀº°æ¿ì
					mProcessEndTime = accumTime + PVP_DM_TEAM_MINCNT_TIME;	/// ´ÙÀ½ÇÁ·Î¼¼½º ¼öÇà½Ã°£À» ÃÖ¼ÒÀοø üũ¾ÈÇԽð£À¸·Î
			}

			/// Ŭ¶óÀ̾ðÆ®¿¡´Â ÃÑÀüÅõ½Ã°£À» ¾Ë·ÁÁÜ


			SendFight( fightTime );

			/// pvp ÀüÅõ ½ÃÀÛ ÇÁ·Î¼¼½º·Î À̵¿
			mProcess = ePVPDM_PROCESS_FIGHT_MINIMUM;

			///
			cTotem* pTotem = NULL;
			NiPoint2 centerPos;
			for( unsigned char i=0;i<ePVPDM_TEAMTYPE_MAX; ++i )
			{
				unsigned long posIdx = PVPMANAGER->GetTeamGenPosIdx( (ePVPDM_TEAM_TYPE)i );
				if( posIdx != 0 )
				{
					sStageChangePos* pStagePos = STAGESCRIPT->GetPosScriptInfo( posIdx );
					if( pStagePos != 0 )
					{
						centerPos.x = pStagePos->mPosX;
						centerPos.y = pStagePos->mPosY;
						pTotem = OBJECTMANAGER->PvPAddTotem( i, PVP_DM_ADD_TOTEMIDX_BUFF, mDMIdx, centerPos, eAPPLYTYPE_BUDDY, eATTRIBUTETYPE_PHYSICAL );
						if( pTotem != NULL )
						{
							GRIDMANAGER->AddTotem( pTotem );
							mDMTotemArr.PushBack(pTotem->GetObjectID());
						}
						pTotem = OBJECTMANAGER->PvPAddTotem( i, PVP_DM_ADD_TOTEMIDX_DEBUFF, mDMIdx, centerPos, eAPPLYTYPE_ENEMY, eATTRIBUTETYPE_PHYSICAL );
						if( pTotem != NULL )
						{
							GRIDMANAGER->AddTotem( pTotem );
							mDMTotemArr.PushBack(pTotem->GetObjectID());
						}
					}
				}
			}

			AddTeleportPortal();

			RegenHoist( true );
			EnableNewGen();
		}
		break;
	case ePVPDM_PROCESS_READY_OUT:
		{
			/// pvp out ¿äû ¹Þ´Â ½Ã°£
			if( mProcessEndTime > accumTime )
				return;

			/// ¿ÀºêÁ§Æ® Á¦°Å
			mProcess = ePVPDM_PROCESS_END;
		}
		break;
	case ePVPDM_PROCESS_FIGHT_MINIMUM:
		{
			/// ÀÏÁ¤ ½Ã°£µ¿¾È ÀοøºÎÁ· °áÅõ Á¾·á üũ ¾ÈÇÔ
			if( mProcessEndTime <= accumTime )
			{
				mProcess = ePVPDM_PROCESS_FIGHT;

				mProcessEndTime = accumTime + 0;
				sDMInfo* pInfo = PVPMANAGER->GetDMInfo();
				if( pInfo != NULL )
				{
					/// Àοøüũ ¾ÈÇÔ ½Ã°£º¸´Ù ÃÑÀüÅõ½Ã°£ÀÌ Å«°æ¿ì ³ª¸ÓÁö ÀÜ¿©½Ã°£À» ¼³Á¤ÇØÁÜ
					if( PVP_DM_TEAM_MINCNT_TIME < pInfo->mTotalDMTime * MINUTE )
						mProcessEndTime = accumTime + ( pInfo->mTotalDMTime * MINUTE - PVP_DM_TEAM_MINCNT_TIME );

					for( int i = ePVPDM_TEAMTYPE_A ; i < ePVPDM_TEAMTYPE_MAX ; ++i )
					{
						if( mTeamInfo[i].mMemberCnt < pInfo->mTeamPlayerMin )
						{
							Result();
							return;
						}
					}
				}
			}

			FlagProcess( accumTime );
		}
		break;
	case ePVPDM_PROCESS_FIGHT:
		{
			/// ½Ã°£ Á¾·á
			if( mProcessEndTime <= accumTime )
				Result();
			else
				FlagProcess( accumTime );
		}
		break;
	case ePVPDM_PROCESS_FIGHTEND:
		{
			/// pvp out ¿äû ¹Þ´Â ½Ã°£
			if( mProcessEndTime <= accumTime )
				mProcess = ePVPDM_PROCESS_END;
		}
		break;
	case ePVPDM_PROCESS_END:
		{
			/// Àüü À¯Àú Ãß¹æ
			if( mAutoOutCheckTime < accumTime )
			{
				if( OrderEndDM() == true )
				{
					EndDM();
					PVPMANAGER->DelAryInsertPVP( mDMIdx );
				}
			}
		}
		break;
	}
}

void cDeathMatch2Object::FlagProcess( unsigned long accumTime )
{
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
			continue;

		if( pF->mNewFlagGen && pF->mNewFlagWaitTime <= accumTime )
		{
			RegenNewFlag( i );

			pF->mNewFlagGen = false;
			pF->mNewFlagWaitTime = 0;
		}

		if( pF->mSendFlagPosTime <= accumTime )
			SendFlagPos( i );
	}

	RegenHoist( false );
}


void cDeathMatch2Object::SendFight( unsigned long fightTime )
{
	/// ÀüÅõ ½ÃÀÛ ¹ß¼Û
	cBaseDeathMatch::SendFight( fightTime );
}

void cDeathMatch2Object::RegenNewFlag( unsigned char aryPos )
{
	if( mFlagCnt <= aryPos )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::RegenNewFlag mFlagCnt <= aryPos[%d,%d]", mFlagCnt, aryPos );
		return;
	}

	sFlagInfo* pF = &mFlagInfo[aryPos];
	if( pF == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::RegenNewFlag pF == NULL[%d]", aryPos );
		return;
	}

	/// ±âÁ¸ ¸®Á¨ Á¦°Å
	if( pF->mFlagIndex != 0 )
	{
		cGathering* p = OBJECTMANAGER->GetGathering( pF->mFlagIndex );
		if( p )
		{
			if( GRIDMANAGER->RemoveGathering( p ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() GRIDMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, aryPos );

			if( OBJECTMANAGER->RemoveGathering( pF->mFlagIndex ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, aryPos );
		}
		pF->mFlagIndex = 0;
	}
	if( pF->mFlagPointIndex != 0 )
	{
		cGathering* p = OBJECTMANAGER->GetGathering( pF->mFlagPointIndex );
		if( p )
		{
			if( GRIDMANAGER->RemoveGathering( p ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() GRIDMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagPointIndex, aryPos );

			if( OBJECTMANAGER->RemoveGathering( pF->mFlagIndex ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagPointIndex, aryPos );
		}
		pF->mFlagPointIndex = 0;
	}

	/// ±ê¹ß º¸À¯ ¹öÇÁ º¯°æ



	if( pF->mFlagOwnerIndex != 0 )
	{
		pF->mFlagOwnerIndex = 0;
		pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;

		/// ¹öÇÁ Á¦°Å
		sObject object = { eOBJECTTYPE_PLAYER, pF->mFlagOwnerIndex };
		SKILLMANAGER->DeleteInfluenceClassIdx( object, PVP_DM2_FLAG_INFLUENCE );
	}

	unsigned long mapNum = PVPMANAGER->GetMapIndex();

	/// ±ê¹ß »ý¼º
	{
		unsigned long flagIdx = mapNum*MAPNUMBER_UNIT + 3;
		const sGatheringRegenHeader* header = GATHERINGSCRIPT->GetGatheringRegen( 0, flagIdx );
		if( header )
		{
			unsigned int posCnt = header->mRegenDetail.GetSize();
			if( posCnt )
			{
				sGatheringRegen* flagInfo = (sGatheringRegen*)header->mRegenDetail[aryPos];

				pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;
				cGathering* pFlag = OBJECTMANAGER->AddGathering( flagIdx, flagInfo->mGatheringIdx, mDMIdx, 
					flagInfo->mPosX, flagInfo->mPosY, flagInfo->mDirection, flagInfo->mHeight );
				if( pFlag )
				{
					pFlag->SetDMIndex( mDMIdx );

					if( GRIDMANAGER->AddGathering( pFlag ) == false )
					{
						assert(0);
						OBJECTMANAGER->RemoveGathering( pFlag->GetObjectID() );
						pF->mFlagIndex = 0;
						pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;
					}
					else
					{
						pFlag->SendRegenSync();
						pF->mFlagIndex = pFlag->GetObjectID();
					}
				}
				else
				{
					assert(0);
					NETWORK2->PostServerEvent( "RegenNewFlag() : flag create fail" );
				}
			}
			else
			{
				assert(0);
				NETWORK2->PostServerEvent( "RegenNewFlag() : flag regen pos count 0" );
			}
		}
		else
		{
			assert(0);
			NETWORK2->PostServerEvent( "RegenNewFlag() : flag info NULL" );
		}
	}

	///// °è¾ç Æ÷ÀÎÆ® »ý¼º
	//{
	//	unsigned long flagPointIdx = mapNum*MAPNUMBER_UNIT + 2;
	//	const sGatheringRegenHeader* header = GATHERINGSCRIPT->GetGatheringRegen( 0, flagPointIdx );
	//	if( header )
	//	{
	//		unsigned int posCnt = header->mRegenDetail.GetSize();
	//		if( posCnt )
	//		{
	//			unsigned int i = rand() % posCnt;
	//			sGatheringRegen* flagPointInfo = (sGatheringRegen*)header->mRegenDetail[i];

	//			cGathering* pFlagPoint = OBJECTMANAGER->AddGathering( flagPointIdx, flagPointInfo->mGatheringIdx, mDMIdx, 
	//				flagPointInfo->mPosX, flagPointInfo->mPosY, flagPointInfo->mDirection, flagPointInfo->mHeight );
	//			if( pFlagPoint )
	//			{
	//				pFlagPoint->SetDMIndex( mDMIdx );

	//				if( GRIDMANAGER->AddGathering( pFlagPoint ) == false )
	//				{
	//					assert(0);
	//					OBJECTMANAGER->RemoveGathering( pFlagPoint->GetObjectID() );
	//					mFlagPointIndex = 0;
	//				}
	//				else
	//				{
	//					pFlagPoint->SendRegenSync();
	//					mFlagPointIndex = pFlagPoint->GetObjectID();
	//				}
	//			}
	//			else
	//			{
	//				assert(0);
	//				NETWORK2->PostServerEvent( "RegenNewFlag() : flag point create fail" );
	//			}
	//		}
	//		else
	//		{
	//			assert(0);
	//			NETWORK2->PostServerEvent( "RegenNewFlag() : flag point regen pos count 0" );
	//		}

	//	}
	//	else
	//	{
	//		assert(0);
	//		NETWORK2->PostServerEvent( "RegenNewFlag() : flag point info NULL" );
	//	}
	//}

	/// Á¤º¸ °»½Å
	SendFlagInfo( aryPos, true );
}

void cDeathMatch2Object::RegenHoist( bool first )
{
	for( int ii = 1 ; ii <= 2 ; ++ii )
	{
		sHoistInfo* pTeamHoist = NULL;
		unsigned char* pHoistCnt = NULL;
		unsigned long basePos = 0;
		unsigned char teamType = ePVPDM_TEAMTYPE_MAX;
		if( ii == 1 )
		{
			pHoistCnt = &mAHoistCnt;
			pTeamHoist = mAteamHoist;
			basePos = 0;
			teamType = ePVPDM_TEAMTYPE_A;
		}
		else if( ii == 2 )
		{
			pHoistCnt = &mBHoistCnt;
			pTeamHoist = mBteamHoist;
			basePos = FLAG_MAX;
			teamType = ePVPDM_TEAMTYPE_B;
		}

		if( pTeamHoist == NULL )
			return;

		/// °è¾ç Æ÷ÀÎÆ® »ý¼º
		unsigned long flagPointIdx = PVPMANAGER->GetMapIndex() * MAPNUMBER_UNIT + ii;
		const sGatheringRegenHeader* header = GATHERINGSCRIPT->GetGatheringRegen( 0, flagPointIdx );
		if( header )
		{
			unsigned int posCnt = header->mRegenDetail.GetSize();
			if( first == true )
				*pHoistCnt = (unsigned char)posCnt;

			if( posCnt )
			{
				for( unsigned char i = 0 ; i < *pHoistCnt ; ++i )
				{
					if( ( pTeamHoist[i].mObjectIdx == 0 && pTeamHoist[i].mNextRegenTime <= NETWORK2->GetAccumTime() ) || first == true  )
					{
						sGatheringRegen* flagPointInfo = (sGatheringRegen*)header->mRegenDetail[i];

						if( first == true )
							pTeamHoist->mRegenIdx = flagPointInfo->mGatheringIdx;

						cGathering* pFlagPoint = OBJECTMANAGER->AddGathering( flagPointIdx, flagPointInfo->mGatheringIdx, mDMIdx, 
							flagPointInfo->mPosX, flagPointInfo->mPosY, flagPointInfo->mDirection, flagPointInfo->mHeight );
						if( pFlagPoint )
						{
							pFlagPoint->SetDMIndex( mDMIdx );

							if( GRIDMANAGER->AddGathering( pFlagPoint ) == false )
							{
								assert(0);
								OBJECTMANAGER->RemoveGathering( pFlagPoint->GetObjectID() );
								pTeamHoist[i].mObjectIdx = 0;
							}
							else
							{
								pFlagPoint->SetFlagTeamType( teamType );
								pFlagPoint->SendRegenSync( teamType );
								pTeamHoist[i].mObjectIdx = pFlagPoint->GetObjectID();

								unsigned long hoistPos = basePos + i + 1;
								/// ¸Þ¼¼Áö ¹ß¼Û
								MSG_SYN_PVP_DM2_HOIST msg;
								msg.Category = NM_PVP;
								msg.Protocol = NM_PVP_DM2_HOIST_SYN;
								msg.mGatherIdx = hoistPos;
								msg.mPos.x = flagPointInfo->mPosX;
								msg.mPos.y = flagPointInfo->mPosY;
								DMQuickSend( (char*)&msg, sizeof(msg) );
							}
						}
						else
						{
							assert(0);
							NETWORK2->PostServerEvent( "cDeathMatch2Object::UseHoist() A flag point create fail" );
						}
					}
				}
			}
			else
			{
				assert(0);
				NETWORK2->PostServerEvent( "cDeathMatch2Object::UseHoist() A flag point regen pos count 0" );
			}
		}
		else
		{
			assert(0);
			NETWORK2->PostServerEvent( "cDeathMatch2Object::UseHoist() A flag point info NULL" );
		}
	}
}

void cDeathMatch2Object::RegenFlag( unsigned char aryPos, float x, float y )
{
	if( mFlagCnt <= aryPos )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::RegenFlag mFlagCnt <= aryPos[%d,%d]", mFlagCnt, aryPos );
		return;
	}

	sFlagInfo* pF = &mFlagInfo[aryPos];
	if( pF == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::RegenFlag pF == NULL[%d]", aryPos );
		return;
	}

	if( pF->mFlagOwnerTeam < ePVPDM_TEAMTYPE_MAX )
	{
		MSG_SYN_PVP_DM2_FLAGDROP msg;
		msg.Category = NM_PVP;
		msg.Protocol = NM_PVP_DM2_FLAGDROP_SYN;
		msg.mPlayerIdx = pF->mFlagOwnerIndex;
		TeamQuickSend( pF->mFlagOwnerTeam, (char*)&msg, sizeof(msg) );
	}

	if( pF->mFlagIndex != 0 )
	{
		assert(0);
		cGathering* p = OBJECTMANAGER->GetGathering( pF->mFlagIndex );
		if( p )
		{
			if( GRIDMANAGER->RemoveGathering( p ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() GRIDMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, aryPos );

			if( OBJECTMANAGER->RemoveGathering( pF->mFlagIndex ) == false )
				NETWORK2->PostServerEvent("RegenNewFlag() OBJECTMANAGER->RemoveGathering( %d, %d ) == false", pF->mFlagIndex, aryPos );
		}
		pF->mFlagIndex = 0;
		pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;
	}

	/// ±ê¹ß º¸À¯ ¹öÇÁ º¯°æ

	if( pF->mFlagOwnerIndex != 0 )
	{
		/// ¹öÇÁ Á¦°Å
		sObject object = { eOBJECTTYPE_PLAYER, pF->mFlagOwnerIndex };
		SKILLMANAGER->DeleteInfluenceClassIdx( object, PVP_DM2_FLAG_INFLUENCE );

		pF->mFlagOwnerIndex = 0;
	}

	unsigned long mapNum = PVPMANAGER->GetMapIndex();

	/// ¿î¹ÝÀÚ »ç¸Á½Ã ±ê¹ß ¸®Á¨
	unsigned long flagIdx = mapNum*MAPNUMBER_UNIT + 3;
	const sGatheringRegenHeader* header = GATHERINGSCRIPT->GetGatheringRegen( 0, flagIdx );
	if( header )
	{
		unsigned int posCnt = header->mRegenDetail.GetSize();
		if( posCnt )
		{
			sGatheringRegen* flagInfo = (sGatheringRegen*)header->mRegenDetail[aryPos];

			pF->mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;
			cGathering* pFlag = OBJECTMANAGER->AddGathering( flagIdx, flagInfo->mGatheringIdx, mDMIdx, 
				x, y, flagInfo->mDirection, flagInfo->mHeight );
			if( pFlag )
			{
				pFlag->SetDMIndex( mDMIdx );

				if( GRIDMANAGER->AddGathering( pFlag ) == false )
				{
					assert(0);
					OBJECTMANAGER->RemoveGathering( pFlag->GetObjectID() );
					pF->mFlagIndex = 0;
				}
				else
				{
					pFlag->SendRegenSync();
					pF->mFlagIndex = pFlag->GetObjectID();
				}
			}
			else
			{
				assert(0);
				NETWORK2->PostServerEvent( "RegenFlag() : flag create fail" );
			}
		}
		else
		{
			assert(0);
			NETWORK2->PostServerEvent( "RegenFlag() : flag regen pos count 0" );
		}
	}
	else
	{
		NETWORK2->PostServerEvent( "RegenFlag() : flag info NULL" );
	}

	/// Á¤º¸ °»½Å
	SendFlagInfo( aryPos, false );
}

bool cDeathMatch2Object::DelInfRegenFlag( unsigned long playerIdx, float x, float y )
{ 
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
		{
			NETWORK2->PostServerEvent("cDeathMatch2Object::GetFlagOwnerIndex pF == NULL[%d,%d]", i, playerIdx );
			continue;
		}

		if( pF->mFlagOwnerIndex == playerIdx )
			RegenFlag( i, x, y );
	}

	return false;
}

bool cDeathMatch2Object::IsGathering( unsigned long playerIdx, unsigned long gatheringIdx )
{
	cPlayer* pPlayer = OBJECTMANAGER->GetPlayer( playerIdx );
	if( pPlayer == NULL )
		return false;

	bool haveFlag = pPlayer->IsInfluenceHave( PVP_DM2_FLAG_INFLUENCE );
	if( haveFlag == true )
	{
		if( pPlayer->GetPvPDMTeam() == ePVPDM_TEAMTYPE_A )
		{
			for( int i = 0 ; i < mAHoistCnt ; ++i )
			{
				if( mAteamHoist[i].mObjectIdx == gatheringIdx )
					return true;
			}
		}
		else if( pPlayer->GetPvPDMTeam() == ePVPDM_TEAMTYPE_B )
		{
			for( int i = 0 ; i < mBHoistCnt ; ++i )
			{
				if( mBteamHoist[i].mObjectIdx == gatheringIdx )
					return true;
			}
		}
		else
			return false;
	}
	else
	{
		for( int i = 0 ; i < mFlagCnt ; ++i )
		{
			if( mFlagInfo[i].mFlagIndex == gatheringIdx )
				return true;
		}
	}

	return false;
}

void cDeathMatch2Object::ScoreUpdate( unsigned long killIdx, ePVPDM_TEAM_TYPE killerTeam, 
									 unsigned long deadIdx, ePVPDM_TEAM_TYPE deadTeam )
{
	if( mProcess < ePVPDM_PROCESS_FIGHT_MINIMUM || ePVPDM_PROCESS_FIGHT < mProcess )
		return;

	if( killerTeam >= ePVPDM_TEAMTYPE_MAX || deadTeam >= ePVPDM_TEAMTYPE_MAX )
	{
		assert(0);
		return;
	}

	/// ÃÖÃÊ Å³Æ÷ÀÎÆ® ȹµæÆÀ ¼ÂÆÃ
	if( mFirstKillTeam == ePVPDM_TEAMTYPE_MAX )
		mFirstKillTeam = killerTeam;

	/// ±ê¹ß º¸À¯ÀÚ »ç¸Á½Ã ó¸®
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		if( mFlagInfo[i].mFlagOwnerIndex == deadIdx )
		{
			cPlayer* player = OBJECTMANAGER->GetPlayer( mFlagInfo[i].mFlagOwnerIndex );
			if( player )
			{
				RegenFlag( i, player->GetXPos(), player->GetYPos() );
			}
			else
			{
				assert(0);
				EnableNewGen( i );
			}
			mFlagInfo[i].mFlagOwnerIndex = 0;
			mFlagInfo[i].mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;

			break;
		}
	}

	/// Á×ÀÎÀÚ kill Áõ°¡
	cPvPDMMemberInfo* pInfo = (cPvPDMMemberInfo*)mTeamInfo[killerTeam].mMemberMap.GetAt( killIdx );
	if( pInfo )
	{
		pInfo->mKillCnt++;

		/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_PVP_DM2_PLAYER_SCORE msg;
		msg.Category = NM_PVP;
		msg.Protocol = NM_PVP_DM2_PLAYER_SCORE_SYN;
		msg.mTeamType = (unsigned char)killerTeam;
		msg.mPlayerIdx = killIdx;
		msg.mPlayerScore = pInfo->mKillCnt;
		TeamQuickSend( killerTeam, (char*)&msg, sizeof( MSG_SYN_PVP_DM2_PLAYER_SCORE ) );
	}
	else
	{
		assert(0);
	}

	/// Á×ÀºÀÚ death Áõ°¡
	pInfo = (cPvPDMMemberInfo*)mTeamInfo[deadTeam].mMemberMap.GetAt( deadIdx );
	if( pInfo )
	{
		pInfo->mDeathCnt++;

		/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
		MSG_SYN_PVP_DM2_PLAYER_SCORE msg;
		msg.Category = NM_PVP;
		msg.Protocol = NM_PVP_DM2_PLAYER_SCORE_SYN;
		msg.mTeamType = (unsigned char)killerTeam;
		msg.mPlayerIdx = deadIdx;
		msg.mPlayerScore = pInfo->mDeathCnt;
		TeamQuickSend( deadTeam, (char*)&msg, sizeof( MSG_SYN_PVP_DM2_PLAYER_SCORE ) );
	}
	else
	{
		assert(0);
	}
}

void cDeathMatch2Object::Result()
{
	mProcess = ePVPDM_PROCESS_FIGHTEND;
	mProcessEndTime = NETWORK2->GetAccumTime() + PVP_DM_OUTWAIT_TIME;

	///Æ÷ÀÎÆ® ´Þ¼º üũ
	if( mpDMBlockInfo )
	{
		if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint >= mpDMBlockInfo->mGoalPoint )
		{
			SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_POINT );
			return;
		}
		if( mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint >= mpDMBlockInfo->mGoalPoint )
		{
			SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_POINT );
			return;
		}
	}
	else
	{
		assert(0);
	}

	/// Æ÷ÀÎÆ® ¿ìÀ§ üũ
	if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint > mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint )
	{
		SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_TIME );
		return;
	}
	else if( mTeamInfo[ePVPDM_TEAMTYPE_A].mPoint < mTeamInfo[ePVPDM_TEAMTYPE_B].mPoint )
	{
		SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_TIME );
		return;
	}

	/// ÃÖÃÊ °Ô¾çÆÀ
	if( mFirstFlagTeam == ePVPDM_TEAMTYPE_A )
	{
		SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_FIRSTFLAG );
		return;
	}
	if( mFirstFlagTeam == ePVPDM_TEAMTYPE_B )
	{
		SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_FIRSTFLAG );
		return;
	}

	///// ¸¶Áö¸· ±ê¹ß º¸À¯
	//if( mFlagOwnerTeam == ePVPDM_TEAMTYPE_A )
	//{
	//	SendResult( ePVPDM_TEAMTYPE_A, ePVPDM_ENDTYPE_LASTFLAG );
	//	return;
	//}
	//if( mFlagOwnerTeam == ePVPDM_TEAMTYPE_B )
	//{
	//	SendResult( ePVPDM_TEAMTYPE_B, ePVPDM_ENDTYPE_LASTFLAG );
	//	return;
	//}

	cBaseDeathMatch::Result();
}

void cDeathMatch2Object::OutMember( unsigned long playerIdx, ePVPDM_TEAM_TYPE teamType )
{
	cBaseDeathMatch::OutMember( playerIdx, teamType );

	/// ±ê¹ß º¸À¯ÀÚÀ̸é


	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		if( mFlagInfo[i].mFlagOwnerIndex == playerIdx )
		{
			cPlayer* player = OBJECTMANAGER->GetPlayer( mFlagInfo[i].mFlagOwnerIndex );
			if( player )
			{
				RegenFlag( i, player->GetXPos(), player->GetYPos() );
			}
			else
			{
				assert(0);
				EnableNewGen( i );

				mFlagInfo[i].mFlagOwnerIndex = 0;
				mFlagInfo[i].mFlagOwnerTeam = ePVPDM_TEAMTYPE_MAX;

				SendFlagInfo( i, false );
			}
		}
	}

	/// Àοø Æйè Á¶°Ç¿¡ ÇØ´çÇÏ´ÂÁö È®ÀÎ
	sDMInfo* pDMInfo = PVPMANAGER->GetDMInfo();
	if( pDMInfo )
	{
		if( ( ePVPDM_PROCESS_FIGHT_MINIMUM == mProcess && mTeamInfo[teamType].mMemberCnt == 0 ) ||
			( ePVPDM_PROCESS_FIGHT == mProcess && mTeamInfo[teamType].mMemberCnt < pDMInfo->mTeamPlayerMin ) )
		{
			mProcess = ePVPDM_PROCESS_FIGHTEND;
			mProcessEndTime = NETWORK2->GetAccumTime() + PVP_DM_OUTWAIT_TIME;

			if( teamType == ePVPDM_TEAMTYPE_A )
				SendResult( ePVPDM_TEAMTYPE_B,ePVPDM_ENDTYPE_MEMBER );
			if( teamType == ePVPDM_TEAMTYPE_B )
				SendResult( ePVPDM_TEAMTYPE_A,ePVPDM_ENDTYPE_MEMBER );
		}
	}
	else
	{
		assert(0);
	}
}

void cDeathMatch2Object::ChangeGatheringState( unsigned long gIdx, unsigned long playerIdx )
{
	if( mProcess > ePVPDM_PROCESS_FIGHT )
		return;

	cPlayer* pPlayer = OBJECTMANAGER->GetPlayer( playerIdx );
	if( pPlayer == 0 )
	{
		assert(0);
		return;
	}

	/// ±ê¹ßÀ» »ÌÀº°ÍÀÎÁö üũ
	sFlagInfo* pF = NULL;
	sFlagInfo* pOwn = NULL;
	unsigned char aryPos = 0;
	unsigned char ownPos = 0;
	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		/// »ÌÇûÀ¸¸é Á¤º¸¸¦ ¸¸µç´Ù.
		if( mFlagInfo[i].mFlagIndex == gIdx )
		{
			pF = &mFlagInfo[i];
			aryPos = i;
		}

		/// ²Å´Â °æ¿ì¿¡ ÇÊ¿äÇÑ Á¤º¸ ±â·Ï
		if( mFlagInfo[i].mFlagOwnerIndex == playerIdx )
		{
			pOwn = &mFlagInfo[i];
			ownPos = i;
		}
	}

	if( pF != NULL )
	{
		/// ±ê¹ßÀÌ »ÌÇû´Ù.
		pF->mFlagIndex = 0;
		pF->mFlagOwnerIndex = playerIdx;
		pF->mFlagOwnerTeam = (ePVPDM_TEAM_TYPE)pPlayer->GetPvPDMTeam();

		/// ¹öÇÁ ºÎ¿©



		if( pF->mFlagOwnerIndex != 0 )
		{
			/// ¹öÇÁ ºÎ¿©



			sObject object = { eOBJECTTYPE_PLAYER, pF->mFlagOwnerIndex };
			SKILLMANAGER->AddInfSwitch( object, object, PVP_DM2_FLAG_INFLUENCE, 0, true );
		}

		SendFlagInfo( aryPos, false );

		return;
	}

	if( pOwn == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::ChangeGatheringState pOwn == NULL");
		return;
	}

	unsigned long hoistPos = 0;
	for( unsigned char i = 0 ; i < mAHoistCnt ; ++i )
	{
		if( mAteamHoist[i].mObjectIdx == gIdx )
		{
			hoistPos = i + 1;
			mAteamHoist[i].mNextRegenTime = NETWORK2->GetAccumTime() + 10 * SECOND;
			mAteamHoist[i].mObjectIdx = 0;
		}
	}

	for( unsigned char i = 0 ; i < mBHoistCnt ; ++i )
	{
		if( mBteamHoist[i].mObjectIdx == gIdx )
		{
			hoistPos = FLAG_MAX + i + 1;
			mBteamHoist[i].mNextRegenTime = NETWORK2->GetAccumTime() + 10 * SECOND;
			mBteamHoist[i].mObjectIdx = 0;
		}
	}

	unsigned long curOwnerIdx = pOwn->mFlagOwnerIndex;
	if( pOwn->mFlagOwnerIndex != 0 )
	{
		/// ¹öÇÁ Á¦°Å
		sObject object = { eOBJECTTYPE_PLAYER, pOwn->mFlagOwnerIndex };
		SKILLMANAGER->DeleteInfluenceClassIdx( object, PVP_DM2_FLAG_INFLUENCE );

		pOwn->mFlagOwnerIndex = 0;
	}

	/// Error½Ã Àç½ÃÀÛ!!
	if( curOwnerIdx != playerIdx )
	{
		assert(0);
		EnableNewGen( ownPos );
		return;
	}
	if( pOwn->mFlagOwnerTeam != (ePVPDM_TEAM_TYPE)pPlayer->GetPvPDMTeam() )
	{
		assert(0);
		EnableNewGen( ownPos );
		return;
	}
	if( pOwn->mFlagOwnerTeam >= ePVPDM_TEAMTYPE_MAX )
	{
		assert(0);
		EnableNewGen( ownPos );
		return;
	}

	/// Á¡¼ö °»½Å
	mTeamInfo[pOwn->mFlagOwnerTeam].mPoint++;
	if( mFirstFlagTeam == ePVPDM_TEAMTYPE_MAX )
		mFirstFlagTeam = pOwn->mFlagOwnerTeam;


	ePVPDM_TEAM_TYPE ownerTeam = pOwn->mFlagOwnerTeam;
	ePVPDM_TEAM_TYPE viewTeam = pOwn->mFlagOwnerTeam;
	if( ownerTeam == ePVPDM_TEAMTYPE_A )
		viewTeam = ePVPDM_TEAMTYPE_B;
	else
		viewTeam = ePVPDM_TEAMTYPE_A;

	/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
	MSG_SYN_PVP_DM2_SCORE msg;
	msg.Category = NM_PVP;
	msg.Protocol = NM_PVP_DM2_SCORE_SYN;
	msg.mTeamType = (unsigned char)pOwn->mFlagOwnerTeam;
	msg.mTotalScore = mTeamInfo[pOwn->mFlagOwnerTeam].mPoint;
	msg.mDelFlagIdx = ownPos;
	msg.mDelHoistIdx = hoistPos;
	TeamQuickSend( viewTeam, (char*)&msg, sizeof( msg ) );

	/// Á¡¼ö ¸Þ¼¼Áö ¹ß¼Û
	MSG_SYN_PVP_FLAGCOMPLETE_SCORE msgComplete;
	msgComplete.Category = NM_PVP;
	msgComplete.Protocol = NM_PVP_DM2_FLAGCOMPLETE_SYN;
	msgComplete.mTeamType = (unsigned char)pOwn->mFlagOwnerTeam;
	msgComplete.mTotalScore = mTeamInfo[pOwn->mFlagOwnerTeam].mPoint;
	msgComplete.mDelFlagIdx = ownPos;
	msgComplete.mDelHoistIdx = hoistPos;
	msgComplete.mPlayerIdx = playerIdx;
	TeamQuickSend( ownerTeam, (char*)&msgComplete, sizeof( msgComplete ) );

	/// °ÔÀÓ Á¾·á üũ

	/// Á¡¼ö ½Â¸®Á¶°Ç üũ
	if( mTeamInfo[pOwn->mFlagOwnerTeam].mPoint >= mpDMBlockInfo->mGoalPoint )
		mScoreEnd = true; 
	else
		EnableNewGen( ownPos );

	return;
}

void cDeathMatch2Object::EnableNewGen()
{
	unsigned long flagIdx = PVPMANAGER->GetMapIndex() * MAPNUMBER_UNIT + 3;
	const sGatheringRegenHeader* header = GATHERINGSCRIPT->GetGatheringRegen( 0, flagIdx );
	if( header )
		mFlagCnt = (unsigned char)header->mRegenDetail.GetSize();

	for( unsigned char i = 0 ; i < mFlagCnt ; ++i )
	{
		sFlagInfo* pF = &mFlagInfo[i];
		if( pF == NULL )
			continue;

		pF->mNewFlagGen = true;
		pF->mNewFlagWaitTime = NETWORK2->GetAccumTime() + ( ( 60 * SECOND ) * ( i ) );
	}
}

void cDeathMatch2Object::EnableNewGen( unsigned char aryPos )
{
	if( mFlagCnt <= aryPos )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::EnableNewGen mFlagCnt <= aryPos[%d,%d]", mFlagCnt, aryPos );
		return;
	}

	sFlagInfo* pF = &mFlagInfo[aryPos];
	if( pF == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::EnableNewGen pF == NULL[%d]", aryPos );
		return;
	}

	pF->mNewFlagGen = true;
	pF->mNewFlagWaitTime = NETWORK2->GetAccumTime() + ( 10 * SECOND );
}

void cDeathMatch2Object::SendFlagInfo( unsigned char aryPos, bool newGen )
{
	if( mFlagCnt <= aryPos )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::SendFlagInfo mFlagCnt <= aryPos[%d,%d]", mFlagCnt, aryPos );
		return;
	}

	sFlagInfo* pF = &mFlagInfo[aryPos];
	if( pF == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::SendFlagInf pF == NULL[%d,%d]", aryPos, newGen );
		return;
	}

	MSG_SYN_PVP_DM2_INFO msg;
	msg.Category = NM_PVP;
	msg.Protocol = NM_PVP_DM2_INFO_SYN;
	msg.mFlagOwnerIdx = pF->mFlagOwnerIndex;
	msg.mGatherIdx = aryPos;

	cGathering* pGather = OBJECTMANAGER->GetGathering( pF->mFlagPointIndex );
	if( pGather == 0 )
		msg.mFlagPointPos = NiPoint2::ZERO;
	else
		msg.mFlagPointPos = pGather->GetPos();

	msg.mPrintNewGenMsg = newGen;
	DMQuickSend( (char*)&msg, sizeof(MSG_SYN_PVP_DM2_INFO) );

	SendFlagPos( aryPos );
}

void cDeathMatch2Object::SendFlagPos( unsigned char aryPos )
{
	if( mFlagCnt <= aryPos )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::SendFlagPos mFlagCnt <= aryPos[%d,%d]", mFlagCnt, aryPos );
		return;
	}

	sFlagInfo* pF = &mFlagInfo[aryPos];
	if( pF == NULL )
	{
		NETWORK2->PostServerEvent("cDeathMatch2Object::SendFlagPos pF == NULL[%d]", aryPos );
		return;
	}

	pF->mSendFlagPosTime = NETWORK2->GetAccumTime() + 1000;

	MSG_SYN_PVP_DM2_FLAGPOS msg;
	msg.Category = NM_PVP;
	msg.Protocol = NM_PVP_DM2_FLAGPOS_SYN;
	msg.mGatherIdx = aryPos;

	msg.mFlagPos = NiPoint2::ZERO;
	if( pF->mFlagOwnerIndex != 0 )
	{
		cPlayer* pPlayer = OBJECTMANAGER->GetPlayer( pF->mFlagOwnerIndex );
		if( pPlayer )
			msg.mFlagPos = pPlayer->GetPos();
	}
	else if( pF->mFlagIndex != 0 )
	{
		cGathering* pGather = OBJECTMANAGER->GetGathering( pF->mFlagIndex );
		if( pGather )
			msg.mFlagPos = pGather->GetPos();
	}
	else
	{
		return;
	}

	if( pF->mFlagOwnerTeam != ePVPDM_TEAMTYPE_A )
		TeamQuickSend( ePVPDM_TEAMTYPE_A, (char*)&msg, sizeof(MSG_SYN_PVP_DM2_FLAGPOS) );

	if( pF->mFlagOwnerTeam != ePVPDM_TEAMTYPE_B )
		TeamQuickSend( ePVPDM_TEAMTYPE_B, (char*)&msg, sizeof(MSG_SYN_PVP_DM2_FLAGPOS) );
}