source-engine/game/server/dod/dod_control_point_master.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"
#include "dod_control_point_master.h"

BEGIN_DATADESC( CControlPointMaster )
	DEFINE_KEYFIELD( m_bDisabled,		FIELD_BOOLEAN,	"StartDisabled" ),

	DEFINE_KEYFIELD( m_iTimerLength,	FIELD_INTEGER, "cpm_timer_length" ),

	DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
	DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),

	DEFINE_INPUTFUNC( FIELD_VOID, "RoundInit", InputRoundInit ),

	DEFINE_FUNCTION( CPMThink ),

	DEFINE_OUTPUT( m_AlliesWinOutput,	"OnAlliesWin" ),
	DEFINE_OUTPUT( m_AxisWinOutput,		"OnAxisWin" ),

	DEFINE_INPUTFUNC( FIELD_INTEGER, "AddTimerSeconds", InputAddTimerSeconds ),

END_DATADESC()

LINK_ENTITY_TO_CLASS( dod_control_point_master, CControlPointMaster );

CControlPointMaster::CControlPointMaster()
{
	m_bUseTimer = false;
	m_iTimerTeam = TEAM_UNASSIGNED;

	SetDefLessFunc( m_ControlPoints );
}

void CControlPointMaster::Spawn( void )
{
	SetTouch( NULL );
	m_bFoundPoints = false;
	BaseClass::Spawn();
}

ConVar mp_tickpointinterval( "mp_tickpointinterval", "30", FCVAR_GAMEDLL, "Delay between point gives.", true, 1, false, 0 );

void CControlPointMaster::RoundRespawn( void )
{
	m_fGivePointsTime = gpGlobals->curtime + mp_tickpointinterval.GetInt();
}


// KeyValue
// ========
// this function interfaces with the keyvalues set by the mapper
//
// Values
// point_give_delay_time - how often to give time based points ( seconds )
// allies_capture_target - target to fire on allies complete capture
// axis_capture_target - target to fire on axis complete capture

bool CControlPointMaster::KeyValue( const char *szKeyName, const char *szValue )
{
	if (FStrEq(szKeyName, "cpm_use_timer"))
	{
		m_bUseTimer = ( atoi(szValue) > 0 );
	}
	else if (FStrEq(szKeyName, "cpm_timer_team"))
	{
		m_iTimerTeam = atoi(szValue);
	}
	else
	{
		return CBaseEntity::KeyValue( szKeyName, szValue );
	}	

	return true;
}

void CControlPointMaster::Reset( void )
{

}

bool CControlPointMaster::FindControlPoints( void )
{
	//go through all the points
	CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "dod_control_point" );

	int numFound = 0;
	
	while( pEnt )
	{
		CControlPoint *pPoint = (CControlPoint *)pEnt;

		if( pPoint->IsActive() )
		{
			int index = pPoint->GetPointIndex();

			Assert( index >= 0 );

			if( m_ControlPoints.Find( index ) == m_ControlPoints.InvalidIndex())
			{
				DevMsg( 2, "Adding control point %s with index %d\n", pPoint->GetName(), index );
				m_ControlPoints.Insert( index, pPoint );
				numFound++;
			}
			else
			{
				Warning( "!!!!\nMultiple control points with the same index, duplicates ignored\n!!!!\n" );
				UTIL_Remove( pPoint );
			}
		}

		pEnt = gEntList.FindEntityByClassname( pEnt, "dod_control_point" );
	}

	if( numFound > MAX_CONTROL_POINTS )
	{
		Warning( "Too many control points! Max is %d\n", MAX_CONTROL_POINTS );
	}

	//Remap the indeces of the control points so they are 0-based
	//======================
	unsigned int j;

	bool bHandled[MAX_CONTROL_POINTS];
	memset( bHandled, 0, sizeof(bHandled) );

	unsigned int numPoints = m_ControlPoints.Count();
	unsigned int newIndex = 0;

	while( newIndex < numPoints )
	{
		//Find the lowest numbered, unhandled point
		int lowestIndex = -1;
		int lowestValue = 999;

		//find the lowest unhandled index
		for( j=0; j<numPoints; j++ )
		{
			if( !bHandled[j] && m_ControlPoints[j]->GetPointIndex() < lowestValue )
			{
				lowestIndex = j;
				lowestValue = m_ControlPoints[j]->GetPointIndex();
			}
		}

		//Don't examine this point again
		Assert( lowestIndex >= 0 );
		bHandled[lowestIndex] = true;

		//Give it its new index
		m_ControlPoints[lowestIndex]->SetPointIndex( newIndex );
		newIndex++;
	}
	
	if( m_ControlPoints.Count() == 0 ) 
	{
		Warning( "Error! No control points found in map!\n");
		return false;	
	}

	g_pObjectiveResource->SetNumControlPoints( m_ControlPoints.Count() );

	unsigned int i;
	for( i=0;i<m_ControlPoints.Count();i++ )
	{
		CControlPoint *pPoint = m_ControlPoints[i];

		int iPointIndex = m_ControlPoints[i]->GetPointIndex();

		g_pObjectiveResource->SetOwningTeam( iPointIndex, pPoint->GetOwner() );
		g_pObjectiveResource->SetCPVisible( iPointIndex, pPoint->PointIsVisible() );
		g_pObjectiveResource->SetCPPosition( iPointIndex, pPoint->GetAbsOrigin() );
	
		g_pObjectiveResource->SetBombsRequired( iPointIndex, pPoint->GetBombsRequired() );
		g_pObjectiveResource->SetBombsRemaining( iPointIndex, pPoint->GetBombsRemaining() );

		g_pObjectiveResource->SetCPIcons( iPointIndex,
			pPoint->GetHudIconIndexForTeam(TEAM_ALLIES),
			pPoint->GetHudIconIndexForTeam(TEAM_AXIS),
			pPoint->GetHudIconIndexForTeam(TEAM_UNASSIGNED),
			pPoint->GetTimerCapHudIcon(),
			pPoint->GetBombedHudIcon() );
	}
	
	return true;
}

// Think
// =====
// Think is called every 0.1 seconds and checks the status of all the control points
// if one team owns them all, it gives points and resets
// Think also gives the time based points at the specified time intervals
//
// I moved the search for spawn points to the initial think - sometimes the points spawned 
// after the master and it wasnt finding them.

void CControlPointMaster::CPMThink( void )
{
	// search for all "dod_control_point" entities in the map
	// and put them in the array
	// only done the first Think

	//try to establish if any dod_area_capture ents are linked to our flags
	//via dod_point_relay

	//if there exists a point relay that has this as the target,
	//AND there exists a capture area that has that relay as a target
	//then we have our area!

	//every think

	//go through all the control points and make sure theyre the same as the last think
	//check masters

	//if they are, do nothing
	//else
	//

	//Note! Only one cpm should ever be active at the same time
	//funny things may happen if there are two of em!
	//if we are recently mastered on or off, touch the cps
					
	//---------------------------------------------------------------------------
	//below here we shouldn't execute unless we are an active control point master 
	
	//if the round has been decided, don't do any more thinking
	//if this cpm is not active, dont' do any thinking

	int iRoundState = DODGameRules()->State_Get();

	// No points or triggering new wins if we are not active 
	if( m_bDisabled || iRoundState != STATE_RND_RUNNING )
	{
		SetContextThink( &CControlPointMaster::CPMThink, gpGlobals->curtime + 0.2, FLAGS_CONTEXT );
		return;
	}

	// is it time to give time-based points yet?
	if( gpGlobals->curtime > m_fGivePointsTime )
	{
		int AlliesPoints = 0;
		int AxisPoints = 0;

		//give points based on who owns what
		unsigned int i;	
		for( i=0;i<m_ControlPoints.Count();i++ )
		{
			switch( m_ControlPoints[i]->GetOwner() )
			{
			case TEAM_ALLIES:
				AlliesPoints += m_ControlPoints[i]->PointValue();
				break;
			case TEAM_AXIS:
				AxisPoints += m_ControlPoints[i]->PointValue();
				break;
			default:
				break;
			}
		}

		//================
		//give team points
		//================
		// See if there are players active on these teams

		bool bFoundAllies = ( GetGlobalTeam(TEAM_ALLIES)->GetNumPlayers() > 0 );
		bool bFoundAxis = ( GetGlobalTeam(TEAM_AXIS)->GetNumPlayers() > 0 );

		bool bReportScore = true;
		
		// don't give team points to a team with no-one on it!
		if( AlliesPoints > 0 && bFoundAllies && DODGameRules()->State_Get() == STATE_RND_RUNNING  ) 
		{
			if( bReportScore )
			{
				if (AlliesPoints == 1)
					UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_score_allie_point" );
				else
				{
					char buf[8];
					Q_snprintf( buf, sizeof(buf), "%d", AlliesPoints );
					UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_score_allie_points", buf );
				}

			}
			GetGlobalTeam(TEAM_ALLIES)->AddScore( AlliesPoints );

			IGameEvent *event = gameeventmanager->CreateEvent( "dod_tick_points" );

			if ( event )
			{
				event->SetInt( "team", TEAM_ALLIES );
				event->SetInt( "score", AlliesPoints );
				event->SetInt( "totalscore", GetGlobalTeam(TEAM_ALLIES)->GetScore() );

				gameeventmanager->FireEvent( event );
			}
		}

		if( AxisPoints > 0 && bFoundAxis && DODGameRules()->State_Get() == STATE_RND_RUNNING ) 
		{
			if( bReportScore )
			{
				if (AxisPoints == 1)
					UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_score_axis_point" );
				else
				{
					char buf[8];
					Q_snprintf( buf, sizeof(buf), "%d", AxisPoints );
					UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_score_axis_points", buf );
				}
			}
			GetGlobalTeam(TEAM_AXIS)->AddScore( AxisPoints );

			IGameEvent *event = gameeventmanager->CreateEvent( "dod_tick_points" );

			if ( event )
			{
                event->SetInt( "team", TEAM_AXIS );
				event->SetInt( "score", AxisPoints );
				event->SetInt( "totalscore", GetGlobalTeam(TEAM_AXIS)->GetScore() );
				gameeventmanager->FireEvent( event );
			}
		}

		// the next time we'll give points
		m_fGivePointsTime = gpGlobals->curtime + mp_tickpointinterval.GetInt();
	}

	// If we call this from dod_control_point, this function should never 
	// trigger a win. but we'll leave it here just incase.
	CheckWinConditions();

	// the next time we 'think'
	SetContextThink( &CControlPointMaster::CPMThink, gpGlobals->curtime + 0.2, FLAGS_CONTEXT );
}

void CControlPointMaster::CheckWinConditions( void )
{
	// ============
	// Check that the points aren't all held by one team
	// if they are this will reset the round
	// and will reset all the points
	// ============
	switch( TeamOwnsAllPoints() )
	{
	case TEAM_ALLIES:	//allies own all		
		{
			TeamWins( TEAM_ALLIES );
		}			
		break;
	case TEAM_AXIS:	//axis owns all
		{
			TeamWins( TEAM_AXIS );
		}
		break;
	default:
		break;
	}
}

void CControlPointMaster::InputRoundInit( inputdata_t &input )
{
	//clear out old control points
	m_ControlPoints.RemoveAll();

	//find the control points

	//if successful, do CPMThink
	if( FindControlPoints() )
	{
		SetContextThink( &CControlPointMaster::CPMThink, gpGlobals->curtime + 0.1, FLAGS_CONTEXT );
	}

	//init the ClientAreas
	int index = 0;
	
	CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "dod_capture_area" );
	while( pEnt )
	{
		CAreaCapture *pArea = (CAreaCapture *)pEnt;
		Assert( pArea );
		pArea->area_SetIndex( index );
		index++;

		pEnt = gEntList.FindEntityByClassname( pEnt, "dod_capture_area" );
	}
	
	g_pObjectiveResource->ResetControlPoints();
}

void CControlPointMaster::FireTeamWinOutput( int iWinningTeam )
{
	switch( iWinningTeam )
	{
	case TEAM_ALLIES:
		m_AlliesWinOutput.FireOutput(this,this);
		break;
	case TEAM_AXIS:
		m_AxisWinOutput.FireOutput(this,this);
		break;
	default:
		Assert(0);
		break;
	}
}

void CControlPointMaster::TeamWins( int iWinningTeam )
{
	DODGameRules()->SetWinningTeam( iWinningTeam );

	FireTeamWinOutput( iWinningTeam );
}

void CControlPointMaster::BecomeActive( void )
{
	Assert( m_bDisabled );
	m_bDisabled = false;
}

void CControlPointMaster::BecomeInactive( void )
{
	Assert( !m_bDisabled );
	m_bDisabled = true;
}

int CControlPointMaster::GetPointOwner( int point )
{
	Assert( point >= 0 );
	Assert( point < MAX_CONTROL_POINTS );

	CControlPoint *pPoint = m_ControlPoints[point];

	if( pPoint )
	{
		return pPoint->GetOwner();
	}
	else
		return TEAM_UNASSIGNED;
}

// TeamOwnsAllPoints
// =================
// This function returns the team that owns all
// the cap points. if its not the case that one 
// team owns them all, it returns 0

// New - cps are now broken into groups. 
// A team can win by owning all flags within a single group.

// Can be passed an overriding team. If this is not null, the passed team
// number will be used for that cp. Used to predict if that CP changing would
// win the game.

int CControlPointMaster::TeamOwnsAllPoints( CControlPoint *pOverridePoint /* = NULL */, int iOverrideNewTeam /* = TEAM_UNASSIGNED */ )
{
	unsigned int i;

	int iWinningTeam[MAX_CONTROL_POINT_GROUPS];

	for( i=0;i<MAX_CONTROL_POINT_GROUPS;i++	)
	{
		iWinningTeam[i] = TEAM_INVALID;
	}

	// if TEAM_INVALID, haven't found a flag for this group yet
	// if TEAM_UNASSIGNED, the group is still being contested 

	// for each control point
	for( i=0;i<m_ControlPoints.Count();i++ )
	{
		int group = m_ControlPoints[i]->GetCPGroup();
		int owner = m_ControlPoints[i]->GetOwner();

		if ( pOverridePoint == m_ControlPoints[i] )
		{
			owner = iOverrideNewTeam;
		}

		// the first one we find in this group, set the win to true
		if ( iWinningTeam[group] == TEAM_INVALID )
		{
			iWinningTeam[group] = owner;
		}
		// unassigned means this group is already contested, move on
		else if ( iWinningTeam[group] == TEAM_UNASSIGNED )
		{
			continue;
		}
		// if we find another one in the group that isn't the same owner, set the win to false
		else if ( owner != iWinningTeam[group] )
		{
			iWinningTeam[group] = TEAM_UNASSIGNED;
		}		
	}

	// report the first win we find as the winner
	for ( i=0;i<MAX_CONTROL_POINT_GROUPS;i++ )
	{
		if ( iWinningTeam[i] == TEAM_ALLIES || iWinningTeam[i] == TEAM_AXIS )
			return iWinningTeam[i];
	}

	// no wins yet
	return TEAM_UNASSIGNED;
}

// an advantage flag is a flag that we've taken that didn't initially
// belong to our team
int CControlPointMaster::CountAdvantageFlags( int team )
{
	int numFlags = 0;

	unsigned int i;
	for( i = 0;i<m_ControlPoints.Count();i++ )
	{
		CControlPoint *pPoint = m_ControlPoints[i];

		if ( pPoint->GetOwner() != pPoint->GetDefaultOwner() )
		{
			if ( pPoint->GetOwner() == team )
			{
				// we own a flag we didn't initially
				numFlags++;
			}
			else // 
			{
				// the enemy owns one of our flags
				numFlags--;
			}
		}
	}

	return numFlags;
}

void CControlPointMaster::InputAddTimerSeconds( inputdata_t &inputdata )
{
	DODGameRules()->AddTimerSeconds( inputdata.value.Int() );
}

void CControlPointMaster::GetTimerData( int &iTimerSeconds, int &iTimerWinTeam )
{
	iTimerSeconds = m_iTimerLength;
	iTimerWinTeam = m_iTimerTeam;
}

bool CControlPointMaster::WouldNewCPOwnerWinGame( CControlPoint *pPoint, int iNewOwner )
{
	return ( TeamOwnsAllPoints( pPoint, iNewOwner ) == iNewOwner );
}

int CControlPointMaster::GetNumPoints( void )
{
	return m_ControlPoints.Count();
}

CControlPoint *CControlPointMaster::GetCPByIndex( int index )
{
	CControlPoint *pPoint = NULL;

	if ( index >= 0 && index < (int)m_ControlPoints.Count() )
	{
		pPoint = m_ControlPoints[index];
	}

	return pPoint;
}

// custom scoring entity
BEGIN_DATADESC( CDODCustomScoring )
	DEFINE_INPUTFUNC( FIELD_INTEGER, "GiveTickPoints", InputGivePoints ),

	DEFINE_KEYFIELD( m_iPointTeam, FIELD_INTEGER, "TeamNum" ),
	DEFINE_KEYFIELD( m_iTickLength, FIELD_INTEGER, "point_give_delay" ),
	DEFINE_KEYFIELD( m_iPointsToGive, FIELD_INTEGER, "point_give_amount" ),
	DEFINE_KEYFIELD( m_iNumPointGives, FIELD_INTEGER, "point_give_max_times" ),

	DEFINE_THINKFUNC( PointsThink ),
END_DATADESC()

LINK_ENTITY_TO_CLASS( dod_scoring, CDODCustomScoring );