Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

574 lines
23 KiB

5 years ago
//========= 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 ) ),
SendPropArray3( SENDINFO_ARRAY3(m_bCPCapRateScalesWithPlayers), SendPropBool( SENDINFO_ARRAY(m_bCPCapRateScalesWithPlayers) ) ),
SendPropString( SENDINFO(m_pszCapLayoutInHUD) ),
SendPropFloat( SENDINFO( m_flCustomPositionX ) ),
SendPropFloat( SENDINFO( m_flCustomPositionY ) ),
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_FIELD( m_flCustomPositionX, FIELD_FLOAT ),
DEFINE_FIELD( m_flCustomPositionY, FIELD_FLOAT ),
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_bCPCapRateScalesWithPlayers, FIELD_BOOLEAN, 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;
m_flCustomPositionX = -1.f;
m_flCustomPositionY = -1.f;
}
//-----------------------------------------------------------------------------
// 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 );
m_bCPCapRateScalesWithPlayers.Set( i, true );
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::SetCPCapTimeScalesWithPlayers( int index, bool bScales )
{
AssertValidIndex(index);
m_bCPCapRateScalesWithPlayers.Set( index, bScales );
}
//-----------------------------------------------------------------------------
// 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 );
}