DragonNest/Server/DNVillageServer/DNPvPRoomManager.cpp

#include "StdAfx.h"
#include "DNPvPRoomManager.h"
#include "DNPvPRoom.h"
#include "DNUserSession.h"
#include "DnPvPRoomSortObject.h"
#include "DNField.h"
#include "DNEvent.h"
#include "DNMasterConnection.h"
#include "DNGameDataManager.h"
#include "EtUIXML.h"
#include "DNGameDataManager.h"

#if defined( PRE_WORLDCOMBINE_PVP )
#include "DNDBConnection.h"
#include "DNDBConnectionManager.h"
#endif

extern TVillageConfig g_Config;

CDNPvPRoomManager::CDNPvPRoomManager()
{
	m_dwUpdateTick = timeGetTime();
#if defined( PRE_WORLDCOMBINE_PVP )
	m_dwGetWorldPvPRoomTick = 0;
	m_nWorldPvPChannelID = 0;
	m_nGMWorldPvPRoomIndex = WorldPvPMissionRoom::Common::GMWorldPvPRoomStartIndex;
	m_mapWorldPvPRoom.clear();
	m_listWorldPvpReqRoom.clear();
	m_pDBCon = NULL;
	m_bApplyWorldPvPRoom = false;
#endif
	m_nMasterDisconnected = false;
#if defined( PRE_PVP_GAMBLEROOM )
	m_bCreateGambleRoomFromDolis = false;
	memset( &m_GambleRoomData, 0, sizeof(m_GambleRoomData) );
	m_nPvPLobbyChannelID = 0;
#endif
}

CDNPvPRoomManager::~CDNPvPRoomManager()
{
	for( std::map<std::pair<USHORT,UINT>,CDNPvPRoom*>::iterator itor=m_mPvPRoom.begin() ; itor!=m_mPvPRoom.end() ; ++itor )
		SAFE_DELETE( (*itor).second );
}

bool CDNPvPRoomManager::bIsExist( const USHORT unVillageChannelID, const UINT uiPvPIndex )
{
	return (GetPvPRoom( unVillageChannelID, uiPvPIndex )) ? true : false;
}

CDNPvPRoom*	CDNPvPRoomManager::GetPvPRoom( const USHORT unVillageChannelID, const UINT uiPvPIndex )
{
	std::map<std::pair<USHORT,UINT>,CDNPvPRoom*>::iterator itor = m_mPvPRoom.find( std::make_pair(unVillageChannelID,uiPvPIndex) );
	if( itor == m_mPvPRoom.end() )
		return NULL;

	return (*itor).second;
}

short CDNPvPRoomManager::CreatePvPRoom( CDNUserSession* pUserObj, const MAVIPVP_CREATEROOM* pPacket )
{
	if( bIsExist( pPacket->unVillageChannelID, pPacket->uiPvPIndex ) )
		return ERROR_NONE;

	CDNPvPRoom* pRoom = new (std::nothrow) CDNPvPRoom;
	if( !pRoom )
		return ERROR_NONE;

	short nRet = pRoom->Create( pPacket );
	if( nRet == ERROR_NONE )
	{
		m_mPvPRoom.insert( std::make_pair( std::make_pair(pPacket->unVillageChannelID,pPacket->uiPvPIndex), pRoom ) );
#if defined( PRE_WORLDCOMBINE_PVP )
		if( pRoom->GetWorldPvPRoomType() )
		{
			pRoom->SetWorldPvPRoomMemberInfo( pPacket->cWorldPvPRoomCurMemberCount );
		}
#endif
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		std::map<USHORT,std::vector<std::list<CDNPvPRoom*>>>::iterator itor = m_listPvPRoom.find( pPacket->unVillageChannelID );
		if( itor == m_listPvPRoom.end() )
		{
			std::vector<std::list<CDNPvPRoom*>> pushvec;
			for (int i = 0; i < PvPCommon::RoomType::max; i++)
			{
				std::list<CDNPvPRoom*> list;
				if (i == pPacket->sCSPVP_CREATEROOM.cRoomType)
					list.push_back( pRoom );

				pushvec.push_back(list);
			}
			m_listPvPRoom.insert( std::make_pair( pPacket->unVillageChannelID, pushvec) );
		}
		else
		{
			if (pPacket->sCSPVP_CREATEROOM.cRoomType < PvPCommon::RoomType::max)
			{
				(*itor).second[pPacket->sCSPVP_CREATEROOM.cRoomType].push_back( pRoom );
			}
		}
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		std::map<USHORT,std::list<CDNPvPRoom*>>::iterator itor = m_listPvPRoom.find( pPacket->unVillageChannelID );
		if( itor == m_listPvPRoom.end() )
		{
			std::list<CDNPvPRoom*> list;
			list.push_back( pRoom );
			m_listPvPRoom.insert( std::make_pair( pPacket->unVillageChannelID, list) );
		}
		else
		{
			(*itor).second.push_back( pRoom );
		}
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		if( pRoom->GetEventRoomIndex() > 0 )		
		{
			std::map<USHORT,std::list<CDNPvPRoom*>>::iterator EventItor = m_listPvPEventRoom.find( pRoom->GetEventPtr()->nEventID );
			if( EventItor == m_listPvPEventRoom.end() )
			{
				std::list<CDNPvPRoom*> list;
				list.push_back( pRoom );
				m_listPvPEventRoom.insert( std::make_pair(pRoom->GetEventPtr()->nEventID, list ) );
			}
			else
			{
				(*EventItor).second.push_back( pRoom );
			}

			g_Log.Log(LogType::_NORMAL, L"[Type:%d Group:%d ID:%d] PvPEventRoom Success!! \r\n", pRoom->GetEventPtr()->nEventType1, pRoom->GetEventPtr()->nEventType2, pRoom->GetEventPtr()->nEventID);
		}
		if( pUserObj )
		{
			pUserObj->SendPvPCreateRoom( ERROR_NONE, pPacket->uiPvPIndex, &pPacket->sCSPVP_CREATEROOM );
		}
		return ERROR_NONE;
	}

	delete pRoom;
	return nRet;
}

bool CDNPvPRoomManager::bDestroyPvPRoom( const USHORT unVillageChannelID, const UINT unPvPIndex )
{
	std::map<std::pair<USHORT,UINT>,CDNPvPRoom*>::iterator itor = m_mPvPRoom.find( std::make_pair(unVillageChannelID,unPvPIndex) );
	if( itor == m_mPvPRoom.end() )
	{
		_DANGER_POINT();
		return false;
	}

	CDNPvPRoom* pPvPRoom = (*itor).second;
	if( !pPvPRoom->bIsEmpty() )
	{
		_DANGER_POINT();
		return false;
	}

#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	std::map<USHORT,std::vector<std::list<CDNPvPRoom*>>>::iterator itor2 = m_listPvPRoom.find( unVillageChannelID );
	if( itor2 != m_listPvPRoom.end() )
	{
		for (int i = 0; i < PvPCommon::RoomType::max; i++)
			(*itor2).second[i].remove(pPvPRoom);
	}
	m_mPvPRoom.erase( itor );
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	std::map<USHORT,std::list<CDNPvPRoom*>>::iterator itor2 = m_listPvPRoom.find( unVillageChannelID );
	if( itor2 != m_listPvPRoom.end() )
		(*itor2).second.remove( pPvPRoom );
	m_mPvPRoom.erase( itor );
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	if( pPvPRoom->GetEventRoomIndex() > 0 )
	{
		std::map<USHORT,std::list<CDNPvPRoom*>>::iterator EventItor = m_listPvPEventRoom.find( pPvPRoom->GetEventPtr()->nEventID );
		if( EventItor != m_listPvPEventRoom.end() )
			(*EventItor).second.remove( pPvPRoom );
	}
	delete pPvPRoom;

	return true;
}

#if defined(PRE_ADD_PVP_VILLAGE_ACCESS)
void CDNPvPRoomManager::SendPvPRoomList( CDNUserSession* pUserObj, const MAVIPVP_ROOMLIST* pPacket, BYTE cVillageID, UINT uiAccountDBID )
#else
void CDNPvPRoomManager::SendPvPRoomList( CDNUserSession* pUserObj, const MAVIPVP_ROOMLIST* pPacket )
#endif
{
	std::vector<CDNPvPRoom*> vPvPRoom;
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	std::map<USHORT,std::vector<std::list<CDNPvPRoom*>>>::iterator itor = m_listPvPRoom.find( pPacket->unVillageChannelID );
	if(itor == m_listPvPRoom.end() || pPacket->sCSPVP_ROOMLIST.uiPage*PvPCommon::Common::RoomPerPage >= (*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].size())
	{
		if( pUserObj )
			pUserObj->SendPvPRoomList( ERROR_NONE, vPvPRoom, pPacket->sCSPVP_ROOMLIST.uiPage );
#if defined(PRE_ADD_PVP_VILLAGE_ACCESS)
		else if( cVillageID > 0 && uiAccountDBID )
			g_pMasterConnection->SendPvPRoomListRelay(cVillageID, uiAccountDBID, ERROR_NONE, vPvPRoom, pPacket->sCSPVP_ROOMLIST.uiPage);
#endif
		return;
	}
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	std::map<USHORT,std::list<CDNPvPRoom*>>::iterator itor = m_listPvPRoom.find( pPacket->unVillageChannelID );	
	if( itor == m_listPvPRoom.end() || pPacket->sCSPVP_ROOMLIST.uiPage*PvPCommon::Common::RoomPerPage >= (*itor).second.size() )
	{
		if( pUserObj )
			pUserObj->SendPvPRoomList( ERROR_NONE, vPvPRoom, pPacket->sCSPVP_ROOMLIST.uiPage );
#if defined(PRE_ADD_PVP_VILLAGE_ACCESS)
		else if( cVillageID > 0 && uiAccountDBID )
			g_pMasterConnection->SendPvPRoomListRelay(cVillageID, uiAccountDBID, ERROR_NONE, vPvPRoom, pPacket->sCSPVP_ROOMLIST.uiPage);
#endif
		return;
	}
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER

	// Sort
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	switch( pPacket->sCSPVP_ROOMLIST.cRoomSortType )
	{
	case PvPCommon::RoomSortType::Index:
		{
			if( pPacket->sCSPVP_ROOMLIST.cIsAscend != 0)	
				(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::RoomIndexOrderByAsc() );
			else
				(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::RoomIndexOrderByDesc() );
			break;
		}
	case PvPCommon::RoomSortType::GameMode:
		{
			(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::GameModeOrder(pPacket->sCSPVP_ROOMLIST.uiSortData) );
			break;
		}
	case PvPCommon::RoomSortType::MapIndex:
		{
			(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::MapOrder(pPacket->sCSPVP_ROOMLIST.uiSortData) );
			break;
		}
	case PvPCommon::RoomSortType::NumOfPlayer:
		{
			if( pPacket->sCSPVP_ROOMLIST.cIsAscend != 0)	
				(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::NumOfPlayerOrderByAsc() );
			else
				(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].sort( PvPRoomSort::NumOfPlayerOrderByDesc() );
			break;
		}
	default:
		{
			if( pUserObj )
				pUserObj->SendPvPRoomList( ERROR_GENERIC_INVALIDREQUEST );
			return;
		}
	}
	//



	std::list<CDNPvPRoom*>::iterator itor2 = (*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].begin();
	std::advance( itor2, pPacket->sCSPVP_ROOMLIST.uiPage*PvPCommon::Common::RoomPerPage );


	for( ; itor2!=(*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].end() ; ++itor2 )
	{
		vPvPRoom.push_back( *itor2 );
		if( vPvPRoom.size() >= PvPCommon::Common::RoomPerPage )
			break;
	}
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	switch( pPacket->sCSPVP_ROOMLIST.cRoomSortType )
	{
		case PvPCommon::RoomSortType::Index:
		{
			if( pPacket->sCSPVP_ROOMLIST.cIsAscend != 0)	
				(*itor).second.sort( PvPRoomSort::RoomIndexOrderByAsc() );
			else
				(*itor).second.sort( PvPRoomSort::RoomIndexOrderByDesc() );
			break;
		}
		case PvPCommon::RoomSortType::GameMode:
		{
			(*itor).second.sort( PvPRoomSort::GameModeOrder(pPacket->sCSPVP_ROOMLIST.uiSortData) );
			break;
		}
		case PvPCommon::RoomSortType::MapIndex:
		{
			(*itor).second.sort( PvPRoomSort::MapOrder(pPacket->sCSPVP_ROOMLIST.uiSortData) );
			break;
		}
		case PvPCommon::RoomSortType::NumOfPlayer:
		{
			if( pPacket->sCSPVP_ROOMLIST.cIsAscend != 0)	
				(*itor).second.sort( PvPRoomSort::NumOfPlayerOrderByAsc() );
			else
				(*itor).second.sort( PvPRoomSort::NumOfPlayerOrderByDesc() );
			break;
		}
		default:
		{
			if( pUserObj )
				pUserObj->SendPvPRoomList( ERROR_GENERIC_INVALIDREQUEST );
			return;
		}
	}
	//

	std::list<CDNPvPRoom*>::iterator itor2 = (*itor).second.begin();
	std::advance( itor2, pPacket->sCSPVP_ROOMLIST.uiPage*PvPCommon::Common::RoomPerPage );

	for( ; itor2!=(*itor).second.end() ; ++itor2 )
	{
		vPvPRoom.push_back( *itor2 );
		if( vPvPRoom.size() >= PvPCommon::Common::RoomPerPage )
			break;
	}
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER

	// <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	UINT uiRoomCount	= static_cast<UINT>((*itor).second[pPacket->sCSPVP_ROOMLIST.cChannelType].size());
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	UINT uiRoomCount	= static_cast<UINT>((*itor).second.size());
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	UINT uiMaxPage		= uiRoomCount/PvPCommon::Common::RoomPerPage;
	if( uiMaxPage > 0 && uiRoomCount%PvPCommon::Common::RoomPerPage == 0 )
		--uiMaxPage;

	if( pUserObj )
		pUserObj->SendPvPRoomList( ERROR_NONE, vPvPRoom, uiMaxPage );
#if defined(PRE_ADD_PVP_VILLAGE_ACCESS)
	else if( cVillageID > 0 && uiAccountDBID )
		g_pMasterConnection->SendPvPRoomListRelay(cVillageID, uiAccountDBID, ERROR_NONE, vPvPRoom, uiMaxPage);
#endif
}

void CDNPvPRoomManager::SendPvPWaitUserList( CDNUserSession* pUserSession, const MAVIPVP_WAITUSERLIST* pPacket )
{
	if( !pUserSession )
		return;

	CDNField* pField = pUserSession->GetField();
	if( !pField || !pField->bIsPvPLobby() )
		return;

	std::vector<CDNUserSession*>	SendList;
	std::list<CDNUserSession*>		UserList;

	int iLimitLevel = -1;
#if defined(PRE_ADD_DWC)	//<2F>ʿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD>
	if( pUserSession->bIsLadderUser() && pUserSession->GetPvPChannelType() != PvPCommon::RoomType::dwc )
#else
	if( pUserSession->bIsLadderUser() )
#endif
		iLimitLevel = static_cast<int>(CGlobalWeightTable::GetInstance().GetValue( CGlobalWeightTable::PvPLadder_LimitLevel ));
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	pField->GetWaitUserList( UserList, iLimitLevel, pUserSession->bIsLadderUser() ? static_cast<BYTE>(PvPCommon::RoomType::max) : pUserSession->GetPvPChannelType() );
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
	pField->GetWaitUserList( UserList, iLimitLevel );
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER

	if( UserList.empty() || static_cast<size_t>(pPacket->sCSPVP_WAITUSERLIST.unPage*PvPCommon::WaitUserList::Common::MaxPerPage) >= UserList.size() )
	{
		pUserSession->SendPvPWaitUserList( ERROR_NONE, SendList, pPacket->sCSPVP_WAITUSERLIST.unPage );
		return;
	}

	SendList.reserve( PvPCommon::WaitUserList::Common::MaxPerPage );

	switch( pPacket->sCSPVP_WAITUSERLIST.SortType )
	{
		case PvPCommon::WaitUserList::SortType::PvPLevel:
		{
			if( pPacket->sCSPVP_WAITUSERLIST.bIsAscend )
				UserList.sort( PvPUserSort::OrderByPvPLevelAsc() );
			else
				UserList.sort( PvPUserSort::OrderByPvPLevelDesc() );
			break;
		}
		case PvPCommon::WaitUserList::SortType::Job:
		{
			if( pPacket->sCSPVP_WAITUSERLIST.bIsAscend )
				UserList.sort( PvPUserSort::OrderByJobAsc() );
			else
				UserList.sort( PvPUserSort::OrderByJobDesc() );
			break;
		}
		case PvPCommon::WaitUserList::SortType::Level:
		{
			if( pPacket->sCSPVP_WAITUSERLIST.bIsAscend )
				UserList.sort( PvPUserSort::OrderByLevelAsc() );
			else
				UserList.sort( PvPUserSort::OrderByLevelDesc() );
			break;
		}
		case PvPCommon::WaitUserList::SortType::Name:
		{
			if( pPacket->sCSPVP_WAITUSERLIST.bIsAscend )
				UserList.sort( PvPUserSort::OrderByCharNameAsc() );
			else
				UserList.sort( PvPUserSort::OrderByCharNameDesc() );
			break;
		}
	}

	std::list<CDNUserSession*>::iterator itor = UserList.begin();
	std::advance( itor, pPacket->sCSPVP_WAITUSERLIST.unPage*PvPCommon::WaitUserList::Common::MaxPerPage );

	for( ; itor!=UserList.end() ; ++itor )
	{
		SendList.push_back( *itor );
		if( SendList.size() >= PvPCommon::WaitUserList::Common::MaxPerPage )
			break;
	}


	// <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
	UINT uiUserCount	= static_cast<UINT>(UserList.size());
	UINT uiMaxPage		= uiUserCount/PvPCommon::WaitUserList::Common::MaxPerPage;
	if( uiMaxPage > 0 && uiUserCount%PvPCommon::WaitUserList::Common::MaxPerPage == 0 )
		--uiMaxPage;

	if( pUserSession )
		pUserSession->SendPvPWaitUserList( ERROR_NONE, SendList, uiMaxPage );
}

void CDNPvPRoomManager::OnDisconnected( const UINT uiConnectionKey )
{
	switch( uiConnectionKey )
	{
		case CONNECTIONKEY_MASTER:
		{
			InterlockedExchange(&m_nMasterDisconnected, 1);
		}
	}
}


void CDNPvPRoomManager::DoUpdate( DWORD dwCurTick )
{
	if (InterlockedCompareExchange(&m_nMasterDisconnected, 0, 1) == 1)
	{
		MasterDisconnectProcess();
		return;
	}

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20>ֱ<EFBFBD> üũ
	if( timeGetTime()-m_dwUpdateTick < 5000 )
		return;
	m_dwUpdateTick = dwCurTick;	

#if defined( PRE_WORLDCOMBINE_PVP )	
	CDNDBConnection* pDBCon = GetDBConnection();
	if( g_Config.nCombinePartyWorld > 0 )
	{
		if( timeGetTime()-m_dwGetWorldPvPRoomTick < WorldPvPMissionRoom::Common::GetWorldPvPRoomTick )
			return;
		m_dwGetWorldPvPRoomTick = dwCurTick;

		if( pDBCon && pDBCon->GetActive() )
			pDBCon->QueryGetListWorldPvPRoom();
	}	
#endif

	// PvPLobby ä<><C3A4> <20>˻<EFBFBD>
	if( !g_pMasterConnection )
		return;

	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
	if( !pChannelInfo )
		return;
	if( pChannelInfo->cVillageID != g_Config.nVillageID )
		return;
	
	if (!g_pDataManager) 
		return;

	if (!g_pMasterConnection || !g_pMasterConnection->GetActive())
		return;

	TVecPvPMissionRoom& vPvPMissionRoom = g_pDataManager->GetVecPvPMissionRoom();

	// <20><><EFBFBD>纻<EFBFBD><E7BABB> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
	srand((UINT)time(NULL));
	
	TVecPvPMissionRoom vRandomPvPMissionRoom;
	std::copy (vPvPMissionRoom.begin(), vPvPMissionRoom.end(), std::back_inserter(vRandomPvPMissionRoom));
	random_shuffle(vRandomPvPMissionRoom.begin(), vRandomPvPMissionRoom.end());	

	for( TVecPvPMissionRoom::iterator iter = vRandomPvPMissionRoom.begin(); iter != vRandomPvPMissionRoom.end(); iter++ )
	{
		TPvPMissionRoom* pMissonRoom = &(*iter);
		if (!pMissonRoom)
			continue;
	
		bool bDuplicatedGroup = false;
		std::map<USHORT,std::list<CDNPvPRoom*>>::iterator itor = m_listPvPEventRoom.begin();
		while (itor != m_listPvPEventRoom.end())
		{
			std::list<CDNPvPRoom*>& list_rooms = itor->second;

			std::list<CDNPvPRoom*>::iterator itor2 = list_rooms.begin();
			while (itor2 != list_rooms.end())
			{
				CDNPvPRoom* pRoom = *itor2;
				
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
				if (pRoom->GetEventPtr()->nEventType1 == pMissonRoom->nChannelType && pRoom->GetEventPtr()->nEventType2 == pMissonRoom->nGroupID)
				{
					bDuplicatedGroup = true;
					break;
				}
#else // #ifdef PRE_ADD_COLOSSEUM_BEGINNER
				if (pRoom->GetEventPtr()->nEventType2 == pMissonRoom->nGroupID)
				{
					bDuplicatedGroup = true;
					break;
				}
#endif
				itor2++;
			}

			itor++;
		}

		if (bDuplicatedGroup) 
			continue;

		// pMissonRoom -> TEvent <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȯ
		TEvent PvPEvent;
		memset( &PvPEvent, 0, sizeof(PvPEvent) );
		PvPEvent._tEndTime = -1; // <20>̺<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
		PvPEvent.nEventID = pMissonRoom->nItemID;
		PvPEvent.nAtt1	= pMissonRoom->nMapID;
		PvPEvent.nAtt2	= pMissonRoom->nModeID;
		PvPEvent.nAtt3	= pMissonRoom->nWinCondition;
		PvPEvent.nAtt4	= pMissonRoom->nPlayTime;
		PvPEvent.nAtt5	= pMissonRoom->nMaxPlayers;
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		PvPEvent.nEventType1 = pMissonRoom->nChannelType;
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		PvPEvent.nEventType2 = pMissonRoom->nGroupID;
		
		CSPVP_CREATEROOM CreateRoom;
		memset( &CreateRoom, 0, sizeof(CreateRoom) );

		CreateRoom.uiEventItemID		= pMissonRoom->nItemID;
		CreateRoom.uiMapIndex			= PvPEvent.nAtt1;
		CreateRoom.uiGameModeTableID	= PvPEvent.nAtt2;
		CreateRoom.uiSelectWinCondition	= PvPEvent.nAtt3;
		CreateRoom.uiSelectPlayTimeSec	= PvPEvent.nAtt4;
		CreateRoom.cMaxUser				= PvPEvent.nAtt5;
		CreateRoom.cMinUser				= pMissonRoom->nStartPlayers;
		CreateRoom.cMinLevel			= 1;
		CreateRoom.cMaxLevel			= CHARLEVELMAX;
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		CreateRoom.cRoomType = PvPEvent.nEventType1;
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		CreateRoom.unRoomOptionBit		= (PvPCommon::RoomOption::BreakInto);
		if (pMissonRoom->bDropItem)
			CreateRoom.unRoomOptionBit	|= PvPCommon::RoomOption::DropItem;
#ifdef PRE_MOD_PVPOBSERVER
		CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::AllowObserver;
#endif		//#ifdef PRE_MOD_PVPOBSERVER
	
#if defined(PRE_ADD_MULTILANGUAGE)
		std::wstring wszName = GetEtUIXML().GetUIString( CEtUIXML::idCategory1, pMissonRoom->nRoomNameIndex, MultiLanguage::eDefaultLanguage );
#else		//#if defined(PRE_ADD_MULTILANGUAGE)
		std::wstring wszName = GetEtUIXML().GetUIString( CEtUIXML::idCategory1, pMissonRoom->nRoomNameIndex );
#endif		//#if defined(PRE_ADD_MULTILANGUAGE)
		_wcscpy( CreateRoom.wszBuf, PvPCommon::TxtMax::RoomName, wszName.c_str(), static_cast<int>(wszName.size()) );
		CreateRoom.cRoomNameLen			= static_cast<BYTE>(wcslen( CreateRoom.wszBuf ));

		UINT uiPvPGameMode;
		if( CDNUserSession::bIsCheckPvPCreateRoom( NULL, &CreateRoom, CreateRoom.uiMapIndex, uiPvPGameMode ) == false )
		{
			g_Log.Log(LogType::_ERROR, L"[Type:%d Group:%d ID:%d] PvPEventRoom Fail!! \r\n", PvPEvent.nEventType1, PvPEvent.nEventType2, PvPEvent.nEventID);
			continue;
		}
#if defined(PRE_ADD_PVP_TOURNAMENT)
		if( uiPvPGameMode == PvPCommon::GameMode::PvP_Tournament )
			CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::RandomTeam;
#endif // #if defined(PRE_ADD_PVP_TOURNAMENT)
		g_pMasterConnection->SendPvPCreateRoom( 0, static_cast<BYTE>(uiPvPGameMode), pChannelInfo->nChannelID, pChannelInfo->nMapIdx, &CreateRoom, &PvPEvent );

	}
}

#if defined( PRE_WORLDCOMBINE_PVP )

CDNDBConnection* CDNPvPRoomManager::GetDBConnection()
{
	if( m_pDBCon == NULL )
	{
		BYTE cThreadID;
		m_pDBCon = g_pDBConnectionManager->GetDBConnection( g_Config.nWorldSetID, cThreadID );
	}

	return m_pDBCon;
}

void CDNPvPRoomManager::OnRecvWorldPvPRoomList( const TAGetListWorldPvPRoom *pPacket )
{
	if( m_nWorldPvPChannelID == 0 )
	{
		const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
		if( !pChannelInfo )
			return;
		m_nWorldPvPChannelID = pChannelInfo->nChannelID;
	}
	

	TVecWorldPvPMissionRoom& vWorldPvPMissionRoom = g_pDataManager->GetWorldVecPvPMissionRoom();

	std::list<int> listDestroyWorldPvPRoomIndex;
	listDestroyWorldPvPRoomIndex.clear();

	for( std::map<int, TWorldPvPRoomDBData>::iterator ii = m_mapWorldPvPRoom.begin();ii != m_mapWorldPvPRoom.end();ii++ )
	{
		listDestroyWorldPvPRoomIndex.push_back(ii->first);
	}

	m_mapWorldPvPRoom.clear();
	
	for( int i=0;i<pPacket->nCount;i++ )
	{
		int nRoomIndex = WorldPvPMissionRoom::Common::WorldPvPRoomStartIndex;
		int nWinCondition = 0;
		int nPlaytime = 0;
		int nWorldPvPRoomType = WorldPvPMissionRoom::Common::MissionRoom;
		TVecWorldPvPMissionRoom::iterator iter;
		for( iter = vWorldPvPMissionRoom.begin(); iter != vWorldPvPMissionRoom.end(); iter++ )
		{
			if( pPacket->WorldPvPRoomData[i].cModeID == iter->cModeID && pPacket->WorldPvPRoomData[i].cChannelType == iter->nChannelType )
			{
				nRoomIndex += iter->nItemID;				
				break;
			}
		}

		if( iter == vWorldPvPMissionRoom.end() )
		{
			// <20><EFBFBD>ڰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>			
			nRoomIndex = ( pPacket->WorldPvPRoomData[i].nDBRoomID%100) + WorldPvPMissionRoom::Common::GMWorldPvPRoomStartIndex;
			nWorldPvPRoomType = WorldPvPMissionRoom::Common::GMRoom;
		}

		bool bCreatePvPRoom = false;

		CDNPvPRoom* pPvPRoom = GetPvPRoom( m_nWorldPvPChannelID, static_cast<UINT>(nRoomIndex) );

		if( pPvPRoom )
		{
			if( pPvPRoom->GetWorldPvPRoomDBIndex() != pPacket->WorldPvPRoomData[i].nDBRoomID )
			{
				bCreatePvPRoom = true;
				bDestroyPvPRoom(m_nWorldPvPChannelID, nRoomIndex);
			}
			else
			{
				pPvPRoom->SetWorldPvPRoomMemberInfo(pPacket->WorldPvPRoomData[i].nRoomMemberCount);
			}
		}
		else
			bCreatePvPRoom = true;
		
		m_mapWorldPvPRoom.insert( std::make_pair(nRoomIndex, pPacket->WorldPvPRoomData[i]) );

		if(bCreatePvPRoom)
		{				
			MAVIPVP_CREATEROOM Data;
			memset( &Data, 0, sizeof(Data));
			Data.cGameMode = pPacket->WorldPvPRoomData[i].cModeID;
			Data.sCSPVP_CREATEROOM.uiGameModeTableID = pPacket->WorldPvPRoomData[i].cModeID;
			Data.uiPvPIndex = nRoomIndex;
			Data.unVillageChannelID = m_nWorldPvPChannelID;
			Data.sCSPVP_CREATEROOM.uiSelectWinCondition = pPacket->WorldPvPRoomData[i].nWinCondition;
			Data.sCSPVP_CREATEROOM.uiSelectPlayTimeSec = pPacket->WorldPvPRoomData[i].nPlayTimeSec;		
			Data.sCSPVP_CREATEROOM.cMinLevel = pPacket->WorldPvPRoomData[i].cMinLevel;
			Data.sCSPVP_CREATEROOM.cMaxLevel = pPacket->WorldPvPRoomData[i].cMaxLevel;
			Data.sCSPVP_CREATEROOM.cMaxUser = pPacket->WorldPvPRoomData[i].cMaxPlayers;
			Data.sCSPVP_CREATEROOM.cRoomNameLen = (BYTE)wcslen(pPacket->WorldPvPRoomData[i].wszRoomName);
			Data.sCSPVP_CREATEROOM.uiMapIndex = pPacket->WorldPvPRoomData[i].nMapID;
#if defined( PRE_ADD_COLOSSEUM_BEGINNER )
			Data.sCSPVP_CREATEROOM.cRoomType = pPacket->WorldPvPRoomData[i].cChannelType;
#endif
			Data.sCSPVP_CREATEROOM.nWorldPvPRoomType = nWorldPvPRoomType;
			Data.cWorldPvPRoomCurMemberCount = (BYTE)(pPacket->WorldPvPRoomData[i].nRoomMemberCount);
			_wcscpy( Data.sCSPVP_CREATEROOM.wszBuf, _countof(Data.sCSPVP_CREATEROOM.wszBuf), pPacket->WorldPvPRoomData[i].wszRoomName, Data.sCSPVP_CREATEROOM.cRoomNameLen );
			
			if( CreatePvPRoom(NULL, &Data) == ERROR_NONE )
			{
				CDNPvPRoom* pPvPRoom = GetPvPRoom( m_nWorldPvPChannelID, static_cast<UINT>(nRoomIndex) );
				if( pPvPRoom )
				{	
					pPvPRoom->SetWorldPvPRoomDBIndex( pPacket->WorldPvPRoomData[i].nDBRoomID );

					if( pPacket->WorldPvPRoomData[i].nPassWord > 0 )
					{
						pPvPRoom->SetWorldPvPRoomPw(pPacket->WorldPvPRoomData[i].nPassWord);					
						UINT uiRoomState = pPvPRoom->GetRoomState();
						uiRoomState |= PvPCommon::RoomState::Password;
						pPvPRoom->SetRoomState(uiRoomState);
					}					
				}
			}
		}		
	}

	for( std::list<int>::iterator Delitor = listDestroyWorldPvPRoomIndex.begin();Delitor != listDestroyWorldPvPRoomIndex.end();Delitor++ )
	{
		if( m_mapWorldPvPRoom.end() == m_mapWorldPvPRoom.find(*Delitor) )
		{
			bDestroyPvPRoom(m_nWorldPvPChannelID, *Delitor);
		}
	}

	if( g_Config.nWorldSetID == g_Config.nCombinePartyWorld )
		CreateWorldPvPRoom();
}

void CDNPvPRoomManager::CreateWorldPvPRoom()
{
	if( !m_bApplyWorldPvPRoom )
		return;

	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
	
	if( !pChannelInfo )
		return;

	if( pChannelInfo->cVillageID != g_Config.nVillageID )
		return;

	TVecWorldPvPMissionRoom& vWorldPvPMissionRoom = g_pDataManager->GetWorldVecPvPMissionRoom();
	
	for( TVecWorldPvPMissionRoom::iterator iter = vWorldPvPMissionRoom.begin(); iter != vWorldPvPMissionRoom.end(); iter++ )
	{
		TWorldPvPMissionRoom* pMissonRoom = &(*iter);
		if (!pMissonRoom)
			continue;

		bool bDuplicatedGroup = false;		

		int nRoomIndex = PvPCommon::Common::MaxRoomCount+pMissonRoom->nItemID;
		bool bDuplicated = false;

		for(std::list<int>::iterator itor1 = m_listWorldPvpReqRoom.begin(); itor1!=m_listWorldPvpReqRoom.end();itor1++)
		{
			if(*itor1 == nRoomIndex)
			{
				bDuplicated = true;
				break;
			}				
		}

		for(std::map<int, TWorldPvPRoomDBData>::iterator itor2 = m_mapWorldPvPRoom.begin(); itor2!=m_mapWorldPvPRoom.end();itor2++)
		{
			if(itor2->first < WorldPvPMissionRoom::Common::GMWorldPvPRoomStartIndex && itor2->second.cModeID == pMissonRoom->cModeID && itor2->second.cChannelType == pMissonRoom->nChannelType)
			{
				bDuplicated = true;
				break;
			}
		}

		if(bDuplicated)
			continue;		

		g_pMasterConnection->SendWorldPvPCreateRoom( nRoomIndex, *pMissonRoom );
		m_listWorldPvpReqRoom.push_back( nRoomIndex );
	}
}

void CDNPvPRoomManager::DelWorldPvPRoom( int nRoomIndex )
{	
	for(std::list<int>::iterator itor = m_listWorldPvpReqRoom.begin(); itor!=m_listWorldPvpReqRoom.end();itor++)
	{
		if(*itor == nRoomIndex)
		{
			m_listWorldPvpReqRoom.erase(itor);
			return;
		}				
	}	
}

TWorldPvPRoomDBData* CDNPvPRoomManager::GetWorldPvPRoom( UINT uiPvPIndex )
{
	std::map<int, TWorldPvPRoomDBData>::iterator itor = m_mapWorldPvPRoom.find( uiPvPIndex );
	if( itor == m_mapWorldPvPRoom.end() )
		return NULL;

	return &((*itor).second);
}

#endif

void CDNPvPRoomManager::MasterDisconnectProcess()
{
	for( std::map<std::pair<USHORT,UINT>,CDNPvPRoom*>::iterator itor=m_mPvPRoom.begin() ; itor!=m_mPvPRoom.end() ; )
	{
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD><C3B3>
		(*itor).second->OnMasterServerDisconnected();
		// <20><>ü<EFBFBD>ı<EFBFBD>
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		std::map<USHORT,std::vector<std::list<CDNPvPRoom*>>>::iterator itor2 = m_listPvPRoom.find( (*itor).first.first );
		if( itor2 != m_listPvPRoom.end() )
		{
			for (int i = 0; i < PvPCommon::RoomType::max; i++)
				(*itor2).second[i].remove( (*itor).second );
		}
#else		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		std::map<USHORT,std::list<CDNPvPRoom*>>::iterator itor2 = m_listPvPRoom.find( (*itor).first.first );
		if( itor2 != m_listPvPRoom.end() )
			(*itor2).second.remove( (*itor).second );
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		delete (*itor).second;
		itor = m_mPvPRoom.erase( itor );
	}
	m_listPvPEventRoom.clear();
}

#if defined( PRE_PVP_GAMBLEROOM )
void CDNPvPRoomManager::SetGambleRoomData( int nRoomIndex, bool bRegulation, BYTE cGambleType, int nPrice, bool bFlag )
{
	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
	if( !pChannelInfo )
		return;

	if( pChannelInfo->cVillageID != g_Config.nVillageID )
		return;

	if (!g_pMasterConnection || !g_pMasterConnection->GetActive())
		return;

	g_Log.Log(LogType::_NORMAL, L"SetGambleRoomData!! \r\n");

	m_GambleRoomData.nRoomIndex = nRoomIndex;
	m_GambleRoomData.bRegulation = bRegulation;
	m_GambleRoomData.cGambleType = cGambleType;
	m_GambleRoomData.nPrice = nPrice;

	g_pMasterConnection->SendCreateGambleRoomFlag( bFlag );
}

void CDNPvPRoomManager::CreateGambleRoom( int nTotalGambleRoomCount )
{	

	if( nTotalGambleRoomCount > (int)CGlobalWeightTable::GetInstance().GetValue(CGlobalWeightTable::PvPGambleRoomMaxCount) )
		return;

	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
	if( !pChannelInfo )
		return;

	if( pChannelInfo->cVillageID != g_Config.nVillageID )
		return;

	if (!g_pDataManager) 
		return;

	if (!g_pMasterConnection || !g_pMasterConnection->GetActive())
		return;
	

		TPvPMissionRoom* pGambleRoom = g_pDataManager->GetPvPGambleRoom(m_GambleRoomData.nRoomIndex);
		if (!pGambleRoom)
		{
			g_Log.Log(LogType::_ERROR, L"[RoomIndex:%d]GambleRoom Data Fail!! \r\n", m_GambleRoomData.nRoomIndex);
			return;
		}
		
		CSPVP_CREATEROOM CreateRoom;
		memset( &CreateRoom, 0, sizeof(CreateRoom) );
		
		CreateRoom.uiMapIndex			= pGambleRoom->nMapID;
		CreateRoom.uiGameModeTableID	= pGambleRoom->nModeID;
		CreateRoom.uiSelectWinCondition	= pGambleRoom->nWinCondition;
		CreateRoom.uiSelectPlayTimeSec	= pGambleRoom->nPlayTime;
		CreateRoom.cMaxUser				= pGambleRoom->nMaxPlayers;
		CreateRoom.cMinUser				= pGambleRoom->nStartPlayers;
		CreateRoom.cMinLevel			= 1;
		CreateRoom.cMaxLevel			= CHARLEVELMAX;
#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		CreateRoom.cRoomType = pGambleRoom->nChannelType;
#endif		//#ifdef PRE_ADD_COLOSSEUM_BEGINNER
		if( !m_GambleRoomData.bRegulation )
			CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::NoRegulation;		
		CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::RandomTeam;
		CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::AllKill_RandomOrder;

#if defined(PRE_ADD_MULTILANGUAGE)
		std::wstring wszName = GetEtUIXML().GetUIString( CEtUIXML::idCategory1, pGambleRoom->nRoomNameIndex, MultiLanguage::eDefaultLanguage );
#else		//#if defined(PRE_ADD_MULTILANGUAGE)
		std::wstring wszName = GetEtUIXML().GetUIString( CEtUIXML::idCategory1, pGambleRoom->nRoomNameIndex );
#endif		//#if defined(PRE_ADD_MULTILANGUAGE)
		_wcscpy( CreateRoom.wszBuf, PvPCommon::TxtMax::RoomName, wszName.c_str(), static_cast<int>(wszName.size()) );
		CreateRoom.cRoomNameLen			= static_cast<BYTE>(wcslen( CreateRoom.wszBuf ));

		UINT uiPvPGameMode;
		if( CDNUserSession::bIsCheckPvPCreateRoom( NULL, &CreateRoom, CreateRoom.uiMapIndex, uiPvPGameMode ) == false )
		{
			g_Log.Log(LogType::_ERROR, L"[RoomIndex:%d]PvPGambleRoom Create Fail!! \r\n", m_GambleRoomData.nRoomIndex);
			return;
		}
#if defined(PRE_ADD_PVP_TOURNAMENT)
		if( uiPvPGameMode == PvPCommon::GameMode::PvP_Tournament )
			CreateRoom.unRoomOptionBit |= PvPCommon::RoomOption::RandomTeam;
#endif // #if defined(PRE_ADD_PVP_TOURNAMENT)
		g_pMasterConnection->SendPvPCreateRoom( 0, static_cast<BYTE>(uiPvPGameMode), pChannelInfo->nChannelID, pChannelInfo->nMapIdx, &CreateRoom, NULL, 0, &m_GambleRoomData );
}

int CDNPvPRoomManager::GetPvPLobbyChannelID()
{
	if( m_nPvPLobbyChannelID == 0 )
	{
		const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
		if( !pChannelInfo )
			return 0;
		m_nPvPLobbyChannelID = pChannelInfo->nChannelID;
	}
	return m_nPvPLobbyChannelID;
}

void CDNPvPRoomManager::DelGambleRoom()
{
	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( GlobalEnum::CHANNEL_ATT_PVPLOBBY );
	if( !pChannelInfo )
		return;

	if( pChannelInfo->cVillageID != g_Config.nVillageID )
		return;

	if (!g_pMasterConnection || !g_pMasterConnection->GetActive())
		return;
	
	g_pMasterConnection->SendDelGambleRoom();
}

#endif