warsystem.cpp

天之炼狱1服务器端源文件游戏服务端不完整

#include "WarSystem.h"
#include "Assert.h"
#include "War.h"
#include "RaceWar.h"
#include "WarSchedule.h"
#include "WarScheduler.h"
#include "Player.h"
#include "GamePlayer.h"
#include "ZoneGroupManager.h"
#include "CastleInfoManager.h"
#include "StringStream.h"
#include "Gpackets/GCSystemMessage.h"
#include "Gpackets/GCWarList.h"
#include "Gpackets/GCWarScheduleList.h"
#include "VariableManager.h"
#include "GuildWar.h"
#include "RaceWarInfo.h"
#include "GuildWarInfo.h"
#include "EventRefreshHolyLandPlayer.h"
#include "ShrineInfoManager.h"
#include "ClientManager.h"
#include "HolyLandManager.h"
#include "StringPool.h"

#include <algorithm>
#include <stdio.h>

WarID_t WarSystem::s_WarIDSuccessor = 0;

WarSystem* g_pWarSystem = NULL;

WarSystem::WarSystem()
	throw(Error)
{
	__BEGIN_TRY

	m_Mutex.setName("WarSystem");
	m_MutexWarQueue.setName("WarSystemQueue");
	m_MutexActiveWars.setName("ActiveWars");
    m_MutexWarList.setName("WarList");

	m_bHasRaceWar = false;

	m_pRaceWarSchedule = NULL;

	__END_CATCH
}

WarSystem::~WarSystem()
	throw(Error)
{
	__BEGIN_TRY

	SAFE_DELETE(m_pRaceWarSchedule);

	__END_CATCH
}

void WarSystem::init()
	throw (Error)
{
	__BEGIN_TRY

	load();

	prepareRaceWar();

	__END_CATCH
}

void WarSystem::prepareRaceWar()
	throw (Error)
{
	__BEGIN_TRY

	SAFE_DELETE(m_pRaceWarSchedule);

	// 辆练 傈里阑 霖厚秦敌促.
	VSDateTime warStartTime = WarScheduler::getNextWarDateTime( WAR_RACE, VSDateTime::currentDateTime() );

	War* pRaceWar 		= new RaceWar( War::WAR_STATE_WAIT );
	pRaceWar->setWarStartTime( warStartTime );
	m_pRaceWarSchedule 	= new Schedule( pRaceWar, warStartTime );

	filelog("WarLog.txt", "[WarID=%d,Time=%s] 辆练 傈里阑 眠啊钦聪促.", (int)pRaceWar->getWarID(), warStartTime.toString().c_str());

	__END_CATCH
}


void WarSystem::load()
	throw (Error)
{
	__BEGIN_TRY

	// load且芭 绝促.

	// 柳青吝牢 傈里阑 load秦具 茄促.

	__END_CATCH
}

VSDateTime WarSystem::getWarEndTime(WarType_t warType) const
{
	int seconds = 0;
	switch (warType)
	{
		// 辨靛傈篮 1矫埃
		case WAR_GUILD :
			seconds = g_pVariableManager->getVariable( GUILD_WAR_TIME );
		break;

		// 辆练傈篮 2矫埃
		case WAR_RACE :
			seconds = g_pVariableManager->getVariable( RACE_WAR_TIME );
		break;
	}

	VSDateTime dt(VSDateTime::currentDateTime());

	return dt.addSecs( seconds );
}

bool WarSystem::addWarDelayed(War* pWar)
	throw (Error)
{
	__BEGIN_TRY

	Assert(pWar!=NULL);

	if (hasActiveRaceWar() && pWar->getWarType()==WAR_RACE)
	{
		throw Error("捞固 辆练 傈里捞 柳青吝涝聪促.");
	}

	__ENTER_CRITICAL_SECTION(m_MutexWarQueue);

	m_WarQueue.push_back( pWar );

	__LEAVE_CRITICAL_SECTION(m_MutexWarQueue);
	
	return true;

	__END_CATCH
}

bool WarSystem::addQueuedWar()
	throw (Error)
{
	__BEGIN_TRY

	__ENTER_CRITICAL_SECTION(m_MutexWarQueue);

	while (!m_WarQueue.empty())
	{
		War* pWar = m_WarQueue.front();
		Assert(pWar!=NULL);

		m_WarQueue.pop_front();

		addWar( pWar );
	}

	__LEAVE_CRITICAL_SECTION(m_MutexWarQueue);

	return true;
	
	__END_CATCH
}

// WarSystem 救俊辑父 龋免登绰 窃荐捞骨肺 LOCK鞘夸绝促.
bool WarSystem::addWar(War* pWar)
	throw (Error)
{
	__BEGIN_TRY

	Assert(pWar!=NULL);
	Assert(pWar->getState()==War::WAR_STATE_CURRENT);

	WarType_t 	warType 	= pWar->getWarType();
	VSDateTime 	warEndTime 	= getWarEndTime( warType );

	Schedule::ScheduleType scheduleType;
	
	scheduleType = Schedule::SCHEDULE_TYPE_ONCE;
		
	WarSchedule* pWarSchedule = new WarSchedule( pWar, warEndTime, scheduleType);

	addSchedule( pWarSchedule );

	// 老窜 葛电 粮俊 谎赴促.
	if (makeGCWarList_LOCKED())
	{
		GCWarList gcWarList;

	    __ENTER_CRITICAL_SECTION(m_MutexWarList)

		gcWarList = m_GCWarList;

   	 	__LEAVE_CRITICAL_SECTION(m_MutexWarList)

		g_pZoneGroupManager->broadcast( &gcWarList );
	}

	// 捞固 父甸绢脸促. WarScheduler狼 execute俊辑 tinysave沁扁 锭皋 Status官曹 鞘夸档 绝促.
	//pWarSchedule->create();

	// 柳青 吝牢 傈里 府胶飘俊 眠啊矫难霖促.
	// heartbeat()俊辑 力芭矫难霖促.
	if (pWar->getWarType()==WAR_GUILD)
	{
		GuildWar* pGuildWar = dynamic_cast<GuildWar*>(pWar);
		Assert(pGuildWar!=NULL);

		// 己瘤俊 乐绰 蜡历狼 惑怕甫 Refresh 秦霖促.
		EventRefreshHolyLandPlayer* pEvent = new EventRefreshHolyLandPlayer( NULL );
		pEvent->setDeadline( 0 );
		g_pClientManager->addEvent( pEvent );

		__ENTER_CRITICAL_SECTION(m_MutexActiveWars)

		m_ActiveWars.push_back( ActiveWarInfo(pGuildWar->getCastleZoneID(), pGuildWar->getChallangerGuildID() ) );

		__LEAVE_CRITICAL_SECTION(m_MutexActiveWars)
	}
	else if (pWar->getWarType()==WAR_RACE)
	{
		m_bHasRaceWar = true;

		// 己瘤俊 乐绰 蜡历狼 惑怕甫 Refresh 秦霖促.
		EventRefreshHolyLandPlayer* pEvent = new EventRefreshHolyLandPlayer( NULL );
		pEvent->setDeadline( 0 );
		g_pClientManager->addEvent( pEvent );

		// 酒淬狼 己瘤 傈开俊 乔狼 己辑 困摹甫 焊郴霖促.
		g_pShrineInfoManager->broadcastBloodBibleStatus();

		// 辆练 傈里俊 曼啊窍瘤 臼绰 荤恩甸阑 郴焊辰促.
		g_pHolyLandManager->remainRaceWarPlayers();
	}

	return true;

	__END_CATCH
}


bool WarSystem::makeGCWarList_LOCKED()
	throw (Error)
{
	__BEGIN_TRY

    __ENTER_CRITICAL_SECTION(m_MutexWarList)

	m_GCWarList.clear();

	if (isEmpty())
	{
		m_MutexWarList.unlock();
		return false;
	}

	const RecentSchedules::container_type& Schedules = m_RecentSchedules.getSchedules();
	RecentSchedules::const_iterator itr = Schedules.begin();

	for (; itr!=Schedules.end(); itr++)
	{
		Schedule* pSchedule = *itr;

		WarSchedule* pWarSchedule = dynamic_cast<WarSchedule*>(pSchedule);
		Assert(pWarSchedule!=NULL);

		War* pWar = pWarSchedule->getWar();
		Assert(pWar!=NULL);

		WarInfo* pWarInfo = NULL;
		
		switch (pWar->getWarType())
		{
			case WAR_GUILD : pWarInfo = new GuildWarInfo; break;
			case WAR_RACE  : pWarInfo = new RaceWarInfo; break;
			default : throw Error("WarType捞 肋给灯促.");
		}

		pWarSchedule->makeWarInfo( pWarInfo );

		m_GCWarList.addWarInfo( pWarInfo );
	}

    __LEAVE_CRITICAL_SECTION(m_MutexWarList)

	return true;

	__END_CATCH
}

bool WarSystem::makeGCWarList()
    throw (Error)
{
    __BEGIN_TRY

	bool ret = false;

    __ENTER_CRITICAL_SECTION(m_Mutex)

    ret = makeGCWarList_LOCKED();

    __LEAVE_CRITICAL_SECTION(m_Mutex)

	return ret;

    __END_CATCH

    return false;
}

void WarSystem::sendGCWarList(Player* pPlayer)
    throw (Error)
{
    __BEGIN_TRY

    __ENTER_CRITICAL_SECTION(m_MutexWarList)

	if (!m_GCWarList.isEmpty())
	{
		pPlayer->sendPacket( &m_GCWarList );
		//cout << m_GCWarList.toString().c_str() << endl;
	}

    __LEAVE_CRITICAL_SECTION(m_MutexWarList)

	__END_CATCH
}

Work* WarSystem::heartbeat() 
	throw(Error)
{
    __BEGIN_TRY

	Work* pWork = NULL;

    __ENTER_CRITICAL_SECTION(m_Mutex)

	addQueuedWar();

	pWork = Scheduler::heartbeat();

	if (pWork!=NULL)
	{
		// 矫埃捞 促 蹬辑 场抄 傈里俊 措茄 贸府
		War* pWar = dynamic_cast<War*>(pWork);
		Assert(pWar!=NULL);

		// 措眉肺绰 War::executeEnd()俊辑 且 巴捞促.
		if (pWar->getWarType()==WAR_GUILD)
		{
			GuildWar* pGuildWar = dynamic_cast<GuildWar*>(pWar);
			Assert(pGuildWar!=NULL);

			// 柳青 吝牢 傈里 府胶飘俊辑 力芭矫难霖促.
			__ENTER_CRITICAL_SECTION(m_MutexActiveWars)

			list<ActiveWarInfo>::iterator itr = find( m_ActiveWars.begin(), 
													m_ActiveWars.end(), 
													ActiveWarInfo( pGuildWar->getCastleZoneID() ) );
			Assert (itr!=m_ActiveWars.end());

			m_ActiveWars.erase( itr );

			__LEAVE_CRITICAL_SECTION(m_MutexActiveWars)
		}
		else if (pWar->getWarType()==WAR_RACE)
		{
			m_bHasRaceWar = false;

			// 己瘤俊 乐绰 蜡历狼 惑怕甫 Refresh 秦霖促.
			EventRefreshHolyLandPlayer* pEvent = new EventRefreshHolyLandPlayer( NULL );
			pEvent->setDeadline( 0 );
			g_pClientManager->addEvent( pEvent );
		}

		SAFE_DELETE(pWork);
	}

   	// 辆练 傈里阑 磊悼栏肺 矫累 矫挪促.
	if (m_pRaceWarSchedule!=NULL
		&& !m_bHasRaceWar
		&& g_pVariableManager->isAutoStartRaceWar())
	{
		checkStartRaceWar();
	}

	// WarList甫 盎脚秦霖促.
	static Timeval nextTime = {0,0};
	Timeval currentTime;
	getCurrentTime( currentTime );

	if (currentTime > nextTime)
	{
		makeGCWarList_LOCKED();
		nextTime.tv_sec = currentTime.tv_sec + 10;
	}

	__LEAVE_CRITICAL_SECTION(m_Mutex)

	return pWork;

	__END_CATCH
}

bool
WarSystem::checkStartRaceWar()
	throw (Error)
{
	__BEGIN_TRY

	if (m_pRaceWarSchedule->heartbeat())
	{
		Work* pWork = m_pRaceWarSchedule->popWork();
		Assert(pWork!=NULL);

		War* pRaceWar = dynamic_cast<War*>(pWork);
		addWarDelayed( pRaceWar );

		prepareRaceWar();

		return true;
	}

	return false;

	__END_CATCH
}

bool WarSystem::getAttackGuildID( ZoneID_t zoneID, GuildID_t& guildID ) const 
	throw(Error)
{
	__BEGIN_TRY
	
	bool bHasCastleActiveWar = false;

    __ENTER_CRITICAL_SECTION(m_MutexActiveWars)