First version of the SOurce SDK 2013

1 files changed, 555 insertions, 0 deletions

diff --git a/mp/src/game/server/team_objectiveresource.cpp b/mp/src/game/server/team_objectiveresource.cpp
new file mode 100644
index 00000000..9f8d0e7f
--- /dev/null
+++ b/mp/src/game/server/team_objectiveresource.cpp
@@ -0,0 +1,555 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: An entity that networks the state of the game's objectives.

+//			May contain data for objectives that aren't used by your mod, but

+//			the extra data will never be networked as long as it's zeroed out.

+//

+//=============================================================================

+#include "cbase.h"

+#include "team_objectiveresource.h"

+#include "shareddefs.h"

+#include <coordsize.h>

+#include "team.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+#define CAPHUD_PARITY_BITS		6

+#define CAPHUD_PARITY_MASK		((1<<CAPHUD_PARITY_BITS)-1)

+

+#define LAZY_UPDATE_TIME		3

+

+// Datatable

+IMPLEMENT_SERVERCLASS_ST_NOBASE(CBaseTeamObjectiveResource, DT_BaseTeamObjectiveResource)

+

+	SendPropInt( SENDINFO(m_iTimerToShowInHUD), MAX_EDICT_BITS, SPROP_UNSIGNED ),

+	SendPropInt( SENDINFO(m_iStopWatchTimer), MAX_EDICT_BITS, SPROP_UNSIGNED ),

+

+	SendPropInt( SENDINFO(m_iNumControlPoints), 4, SPROP_UNSIGNED ),

+	SendPropBool( SENDINFO(m_bPlayingMiniRounds) ),

+	SendPropBool( SENDINFO(m_bControlPointsReset) ),

+	SendPropInt( SENDINFO(m_iUpdateCapHudParity), CAPHUD_PARITY_BITS, SPROP_UNSIGNED ),

+

+	// data variables

+	SendPropArray( SendPropVector( SENDINFO_ARRAY(m_vCPPositions), -1, SPROP_COORD), m_vCPPositions ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bCPIsVisible), SendPropInt( SENDINFO_ARRAY(m_bCPIsVisible), 1, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flLazyCapPerc), SendPropFloat( SENDINFO_ARRAY(m_flLazyCapPerc) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iTeamIcons), SendPropInt( SENDINFO_ARRAY(m_iTeamIcons), 8, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iTeamOverlays), SendPropInt( SENDINFO_ARRAY(m_iTeamOverlays), 8, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iTeamReqCappers), SendPropInt( SENDINFO_ARRAY(m_iTeamReqCappers), 4, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flTeamCapTime), SendPropTime( SENDINFO_ARRAY(m_flTeamCapTime) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iPreviousPoints), SendPropInt( SENDINFO_ARRAY(m_iPreviousPoints), 8 ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bTeamCanCap), SendPropBool( SENDINFO_ARRAY(m_bTeamCanCap) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iTeamBaseIcons), SendPropInt( SENDINFO_ARRAY(m_iTeamBaseIcons), 8 ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iBaseControlPoints), SendPropInt( SENDINFO_ARRAY(m_iBaseControlPoints), 8 ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bInMiniRound), SendPropBool( SENDINFO_ARRAY(m_bInMiniRound) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iWarnOnCap), SendPropInt( SENDINFO_ARRAY(m_iWarnOnCap), 4, SPROP_UNSIGNED ) ),

+	SendPropArray( SendPropStringT( SENDINFO_ARRAY( m_iszWarnSound ) ), m_iszWarnSound ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flPathDistance), SendPropFloat( SENDINFO_ARRAY(m_flPathDistance), 8, 0, 0.0f, 1.0f ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iCPGroup), SendPropInt( SENDINFO_ARRAY(m_iCPGroup), 5 ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bCPLocked), SendPropBool( SENDINFO_ARRAY(m_bCPLocked) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_nNumNodeHillData), SendPropInt( SENDINFO_ARRAY(m_nNumNodeHillData), 4, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flNodeHillData), SendPropFloat( SENDINFO_ARRAY(m_flNodeHillData), 8, 0, 0.0f, 1.0f ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bTrackAlarm), SendPropBool( SENDINFO_ARRAY(m_bTrackAlarm) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flUnlockTimes), SendPropFloat( SENDINFO_ARRAY(m_flUnlockTimes) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bHillIsDownhill), SendPropBool( SENDINFO_ARRAY(m_bHillIsDownhill) ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_flCPTimerTimes), SendPropFloat( SENDINFO_ARRAY(m_flCPTimerTimes) ) ),

+	

+	// state variables

+	SendPropArray3( SENDINFO_ARRAY3(m_iNumTeamMembers), SendPropInt( SENDINFO_ARRAY(m_iNumTeamMembers), 4, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iCappingTeam), SendPropInt( SENDINFO_ARRAY(m_iCappingTeam), 4, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iTeamInZone), SendPropInt( SENDINFO_ARRAY(m_iTeamInZone), 4, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_bBlocked), SendPropInt( SENDINFO_ARRAY(m_bBlocked), 1, SPROP_UNSIGNED ) ),

+	SendPropArray3( SENDINFO_ARRAY3(m_iOwner), SendPropInt( SENDINFO_ARRAY(m_iOwner), 4, SPROP_UNSIGNED ) ),

+	SendPropString( SENDINFO(m_pszCapLayoutInHUD) ),

+

+END_SEND_TABLE()

+

+BEGIN_DATADESC( CBaseTeamObjectiveResource )

+	DEFINE_FIELD( m_iTimerToShowInHUD, FIELD_INTEGER ),

+	DEFINE_FIELD( m_iStopWatchTimer, FIELD_INTEGER ),

+	DEFINE_FIELD( m_iNumControlPoints, FIELD_INTEGER ),

+	DEFINE_FIELD( m_bPlayingMiniRounds, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_bControlPointsReset, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_iUpdateCapHudParity, FIELD_INTEGER ),

+	DEFINE_ARRAY( m_vCPPositions, FIELD_VECTOR, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_bCPIsVisible, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_flLazyCapPerc, FIELD_FLOAT, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iTeamIcons, FIELD_INTEGER, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_iTeamOverlays, FIELD_INTEGER, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_iTeamReqCappers, FIELD_INTEGER, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_flTeamCapTime, FIELD_FLOAT, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_iPreviousPoints, FIELD_INTEGER, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS*MAX_PREVIOUS_POINTS ),

+	DEFINE_ARRAY( m_bTeamCanCap, FIELD_BOOLEAN, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_iTeamBaseIcons, FIELD_INTEGER, MAX_TEAMS ),

+	DEFINE_ARRAY( m_iBaseControlPoints, FIELD_INTEGER, MAX_TEAMS ),

+	DEFINE_ARRAY( m_bInMiniRound, FIELD_BOOLEAN, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iWarnOnCap, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iszWarnSound, FIELD_STRING, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iNumTeamMembers, FIELD_INTEGER, MAX_CONTROL_POINTS*MAX_CONTROL_POINT_TEAMS ),

+	DEFINE_ARRAY( m_iCappingTeam, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iTeamInZone, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_bBlocked, FIELD_BOOLEAN, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_iOwner, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_pszCapLayoutInHUD, FIELD_CHARACTER, MAX_CAPLAYOUT_LENGTH ),

+	DEFINE_ARRAY( m_flCapPercentages, FIELD_FLOAT,  MAX_CONTROL_POINTS  ),

+	DEFINE_ARRAY( m_iCPGroup, FIELD_INTEGER, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_bCPLocked, FIELD_BOOLEAN, MAX_CONTROL_POINTS ),

+	DEFINE_ARRAY( m_nNumNodeHillData, FIELD_INTEGER, TEAM_TRAIN_MAX_TEAMS ),

+	DEFINE_ARRAY( m_flNodeHillData, FIELD_FLOAT, TEAM_TRAIN_HILLS_ARRAY_SIZE ),

+	DEFINE_ARRAY( m_bTrackAlarm, FIELD_BOOLEAN, TEAM_TRAIN_MAX_TEAMS ),

+	DEFINE_ARRAY( m_flUnlockTimes, FIELD_FLOAT,  MAX_CONTROL_POINTS  ),

+	DEFINE_ARRAY( m_flCPTimerTimes, FIELD_FLOAT,  MAX_CONTROL_POINTS  ),

+	DEFINE_THINKFUNC( ObjectiveThink ),

+END_DATADESC()

+

+CBaseTeamObjectiveResource *g_pObjectiveResource = NULL;

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+CBaseTeamObjectiveResource::CBaseTeamObjectiveResource()

+{

+	g_pObjectiveResource = this;

+	m_bPlayingMiniRounds = false;

+	m_iUpdateCapHudParity = 0;

+	m_bControlPointsReset = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+CBaseTeamObjectiveResource::~CBaseTeamObjectiveResource()

+{

+	Assert( g_pObjectiveResource == this );

+	g_pObjectiveResource = NULL;	

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::Spawn( void )

+{

+	m_iNumControlPoints = 0;

+

+	// If you hit this, you've got too many teams for the control point system to handle.

+	Assert( GetNumberOfTeams() < MAX_CONTROL_POINT_TEAMS );

+

+	for ( int i=0; i < MAX_CONTROL_POINTS; i++ )

+	{

+		// data variables

+		m_vCPPositions.Set( i, vec3_origin );

+		m_bCPIsVisible.Set( i, true );

+		m_bBlocked.Set( i, false );

+

+		// state variables

+		m_iOwner.Set( i, TEAM_UNASSIGNED );

+		m_iCappingTeam.Set( i, TEAM_UNASSIGNED );

+		m_iTeamInZone.Set( i, TEAM_UNASSIGNED );

+		m_bInMiniRound.Set( i, true );

+		m_iWarnOnCap.Set( i, CP_WARN_NORMAL );

+		m_iCPGroup.Set( i, TEAM_INVALID );

+		m_flLazyCapPerc.Set( i, 0.0 );

+		m_bCPLocked.Set( i, false );

+		m_flUnlockTimes.Set( i, 0.0 );

+		m_flCPTimerTimes.Set( i, -1.0 );

+

+		for ( int team = 0; team < MAX_CONTROL_POINT_TEAMS; team++ )

+		{

+			int iTeamIndex = TEAM_ARRAY( i, team );

+

+			m_iTeamIcons.Set( iTeamIndex, 0 );

+			m_iTeamOverlays.Set( iTeamIndex, 0 );

+			m_iTeamReqCappers.Set( iTeamIndex, 0 );

+			m_flTeamCapTime.Set( iTeamIndex, 0.0f );

+			m_iNumTeamMembers.Set( TEAM_ARRAY( i, team ), 0 );

+			for ( int ipoint = 0; ipoint < MAX_PREVIOUS_POINTS; ipoint++ )

+			{

+				int iIntIndex = ipoint + (i * MAX_PREVIOUS_POINTS) + (team * MAX_CONTROL_POINTS * MAX_PREVIOUS_POINTS);

+				m_iPreviousPoints.Set( iIntIndex, -1 );

+			}

+			m_bTeamCanCap.Set( iTeamIndex, false );

+		}

+	}

+

+	for ( int i = 0; i < MAX_TEAMS; i++ )

+	{

+		m_iBaseControlPoints.Set( i, -1 );

+	}

+

+	int nNumEntriesPerTeam = TEAM_TRAIN_MAX_HILLS * TEAM_TRAIN_FLOATS_PER_HILL;

+	for ( int i = 0; i < TEAM_TRAIN_MAX_TEAMS; i++ )

+	{

+		m_nNumNodeHillData.Set( i, 0 );

+		m_bTrackAlarm.Set( i, false );

+

+		int iStartingIndex = i * nNumEntriesPerTeam;

+		for ( int j = 0 ; j < nNumEntriesPerTeam ; j++ )

+		{

+			m_flNodeHillData.Set( iStartingIndex + j, 0 );

+		}

+

+		iStartingIndex = i * TEAM_TRAIN_MAX_HILLS;

+		for ( int j = 0; j < TEAM_TRAIN_MAX_HILLS; j++ )

+		{

+			m_bHillIsDownhill.Set( iStartingIndex + j, 0 );

+		}

+	}

+

+	SetThink( &CBaseTeamObjectiveResource::ObjectiveThink );

+	SetNextThink( gpGlobals->curtime + LAZY_UPDATE_TIME );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::ObjectiveThink( void )

+{

+	SetNextThink( gpGlobals->curtime + LAZY_UPDATE_TIME );

+

+	for ( int i = 0; i < m_iNumControlPoints; i++ )

+	{

+		if ( m_iCappingTeam[i] )

+		{

+			m_flLazyCapPerc.Set( i, m_flCapPercentages[i] );

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: The objective resource is always transmitted to clients

+//-----------------------------------------------------------------------------

+int CBaseTeamObjectiveResource::UpdateTransmitState()

+{

+	// ALWAYS transmit to all clients.

+	return SetTransmitState( FL_EDICT_ALWAYS );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Round is starting, reset state

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::ResetControlPoints( void )

+{

+	for ( int i=0; i < MAX_CONTROL_POINTS; i++ )

+	{

+		m_iCappingTeam.Set( i, TEAM_UNASSIGNED );

+		m_iTeamInZone.Set( i, TEAM_UNASSIGNED );

+		m_bInMiniRound.Set( i, true );

+

+		for ( int team = 0; team < MAX_CONTROL_POINT_TEAMS; team++ )

+		{

+			m_iNumTeamMembers.Set( TEAM_ARRAY( i, team ), 0.0f );

+		}

+	}

+

+	UpdateCapHudElement();

+	m_bControlPointsReset = !m_bControlPointsReset;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Data setting functions

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetNumControlPoints( int num )

+{

+	Assert( num <= MAX_CONTROL_POINTS );

+	m_iNumControlPoints = num;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPIcons( int index, int iTeam, int iIcon )

+{

+	AssertValidIndex(index);

+	m_iTeamIcons.Set( TEAM_ARRAY( index, iTeam ), iIcon );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPOverlays( int index, int iTeam, int iIcon )

+{

+	AssertValidIndex(index);

+	m_iTeamOverlays.Set( TEAM_ARRAY( index, iTeam ), iIcon );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetTeamBaseIcons( int iTeam, int iBaseIcon )

+{

+	Assert( iTeam >= 0 && iTeam < MAX_TEAMS );

+	m_iTeamBaseIcons.Set( iTeam, iBaseIcon );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPPosition( int index, const Vector& vPosition )

+{

+	AssertValidIndex(index);

+	m_vCPPositions.Set( index, vPosition );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPVisible( int index, bool bVisible )

+{

+	AssertValidIndex(index);

+	m_bCPIsVisible.Set( index, bVisible );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetWarnOnCap( int index, int iWarnLevel )

+{

+	AssertValidIndex(index);

+	m_iWarnOnCap.Set( index, iWarnLevel );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetWarnSound( int index, string_t iszSound )

+{

+	AssertValidIndex(index);

+	m_iszWarnSound.Set( index, iszSound );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPGroup( int index, int iCPGroup )

+{

+	AssertValidIndex(index);

+	m_iCPGroup.Set( index, iCPGroup );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPRequiredCappers( int index, int iTeam, int iReqPlayers )

+{

+	AssertValidIndex(index);

+	m_iTeamReqCappers.Set( TEAM_ARRAY( index, iTeam ), iReqPlayers );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPCapTime( int index, int iTeam, float flTime )

+{

+	AssertValidIndex(index);

+	m_flTeamCapTime.Set( TEAM_ARRAY( index, iTeam ), flTime );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPCapPercentage( int index, float flTime )

+{

+	AssertValidIndex(index);

+	m_flCapPercentages[index] = flTime;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+float CBaseTeamObjectiveResource::GetCPCapPercentage( int index )

+{

+	AssertValidIndex(index);

+	return m_flCapPercentages[index];

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPUnlockTime( int index, float flTime )

+{

+	AssertValidIndex(index);

+	m_flUnlockTimes.Set( index, flTime );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPTimerTime( int index, float flTime )

+{

+	AssertValidIndex(index);

+	m_flCPTimerTimes.Set( index, flTime );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetTeamCanCap( int index, int iTeam, bool bCanCap )

+{

+	AssertValidIndex(index);

+	m_bTeamCanCap.Set( TEAM_ARRAY( index, iTeam ), bCanCap );

+	UpdateCapHudElement();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetBaseCP( int index, int iTeam )

+{

+	Assert( iTeam < MAX_TEAMS );

+	m_iBaseControlPoints.Set( iTeam, index );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetPreviousPoint( int index, int iTeam, int iPrevIndex, int iPrevPoint )

+{

+	AssertValidIndex(index);

+	Assert( iPrevIndex >= 0 && iPrevIndex < MAX_PREVIOUS_POINTS );

+	int iIntIndex = iPrevIndex + (index * MAX_PREVIOUS_POINTS) + (iTeam * MAX_CONTROL_POINTS * MAX_PREVIOUS_POINTS);

+	m_iPreviousPoints.Set( iIntIndex, iPrevPoint );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+int CBaseTeamObjectiveResource::GetPreviousPointForPoint( int index, int team, int iPrevIndex )

+{

+	AssertValidIndex(index);

+	Assert( iPrevIndex >= 0 && iPrevIndex < MAX_PREVIOUS_POINTS );

+	int iIntIndex = iPrevIndex + (index * MAX_PREVIOUS_POINTS) + (team * MAX_CONTROL_POINTS * MAX_PREVIOUS_POINTS);

+	return m_iPreviousPoints[ iIntIndex ];

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+bool CBaseTeamObjectiveResource::TeamCanCapPoint( int index, int team )

+{

+	AssertValidIndex(index);

+	return m_bTeamCanCap[ TEAM_ARRAY( index, team ) ];

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Data setting functions

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetNumPlayers( int index, int team, int iNumPlayers )

+{

+	AssertValidIndex(index);

+	m_iNumTeamMembers.Set( TEAM_ARRAY( index, team ), iNumPlayers );

+	UpdateCapHudElement();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::StartCap( int index, int team )

+{

+	AssertValidIndex(index);

+	if ( m_iCappingTeam.Get( index ) != team )

+	{

+		m_iCappingTeam.Set( index, team );

+		UpdateCapHudElement();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetOwningTeam( int index, int team )

+{

+	AssertValidIndex(index);

+	m_iOwner.Set( index, team );

+

+	// clear the capper

+	m_iCappingTeam.Set( index, TEAM_UNASSIGNED );

+	UpdateCapHudElement();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCappingTeam( int index, int team )

+{

+	AssertValidIndex(index);

+	if ( m_iCappingTeam.Get( index ) != team )

+	{

+		m_iCappingTeam.Set( index, team );

+		UpdateCapHudElement();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetTeamInZone( int index, int team )

+{

+	AssertValidIndex(index);

+	if ( m_iTeamInZone.Get( index ) != team )

+	{

+		m_iTeamInZone.Set( index, team );

+		UpdateCapHudElement();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCapBlocked( int index, bool bBlocked )

+{

+	AssertValidIndex(index);

+	if ( m_bBlocked.Get( index ) != bBlocked )

+	{

+		m_bBlocked.Set( index, bBlocked );

+		UpdateCapHudElement();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+int CBaseTeamObjectiveResource::GetOwningTeam( int index )

+{

+	if ( index >= m_iNumControlPoints )

+		return TEAM_UNASSIGNED;

+

+	return m_iOwner[index];

+}	

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::UpdateCapHudElement( void )

+{

+	m_iUpdateCapHudParity = (m_iUpdateCapHudParity + 1) & CAPHUD_PARITY_MASK;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetTrainPathDistance( int index, float flDistance )

+{

+	AssertValidIndex(index);

+

+	m_flPathDistance.Set( index, flDistance );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetCPLocked( int index, bool bLocked )

+{

+	// This assert always fires on map load and interferes with daily development

+	//AssertValidIndex(index);

+	m_bCPLocked.Set( index, bLocked );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseTeamObjectiveResource::SetTrackAlarm( int index, bool bAlarm )

+{

+	Assert( index < TEAM_TRAIN_MAX_TEAMS );

+	m_bTrackAlarm.Set( index, bAlarm );

+}