d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
523 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 91a76f2a13
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '91a76f2a13'
${ noResults }
source-engine/game/server/team_control_point.cpp

901 lines
26 KiB
Raw Blame History

//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
//===========================================================================//
#include "cbase.h"
#include "team_control_point.h"
#include "player.h"
#include "teamplay_gamerules.h"
#include "teamplayroundbased_gamerules.h"
#include "team.h"
#include "team_control_point_master.h"
#include "mp_shareddefs.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
// NOTE: This has to be the last file included!
#include "tier0/memdbgon.h"
BEGIN_DATADESC(CTeamControlPoint)
DEFINE_KEYFIELD( m_iszPrintName, FIELD_STRING, "point_printname" ),
DEFINE_KEYFIELD( m_iCPGroup, FIELD_INTEGER, "point_group" ),
DEFINE_KEYFIELD( m_iDefaultOwner, FIELD_INTEGER, "point_default_owner" ),
DEFINE_KEYFIELD( m_iPointIndex, FIELD_INTEGER, "point_index" ),
DEFINE_KEYFIELD( m_iWarnOnCap, FIELD_INTEGER, "point_warn_on_cap" ),
DEFINE_KEYFIELD( m_iszWarnSound, FIELD_STRING, "point_warn_sound" ),
DEFINE_KEYFIELD( m_iszCaptureStartSound, FIELD_STRING, "point_capture_start_sound" ),
DEFINE_KEYFIELD( m_iszCaptureEndSound, FIELD_STRING, "point_capture_end_sound" ),
DEFINE_KEYFIELD( m_iszCaptureInProgress, FIELD_STRING, "point_capture_progress_sound" ),
DEFINE_KEYFIELD( m_iszCaptureInterrupted, FIELD_STRING, "point_capture_interrupted_sound" ),
DEFINE_KEYFIELD( m_bRandomOwnerOnRestart, FIELD_BOOLEAN, "random_owner_on_restart" ),
// DEFINE_FIELD( m_iTeam, FIELD_INTEGER ),
// DEFINE_FIELD( m_iIndex, FIELD_INTEGER ),
// DEFINE_FIELD( m_TeamData, CUtlVector < perteamdata_t > ),
// DEFINE_FIELD( m_bPointVisible, FIELD_INTEGER ),
// DEFINE_FIELD( m_bActive, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_iszName, FIELD_STRING ),
// DEFINE_FIELD( m_bStartDisabled, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_flLastContestedAt, FIELD_FLOAT ),
// DEFINE_FIELD( m_pCaptureInProgressSound, CSoundPatch ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetOwner", InputSetOwner ),
DEFINE_INPUTFUNC( FIELD_VOID, "ShowModel", InputShowModel ),
DEFINE_INPUTFUNC( FIELD_VOID, "HideModel", InputHideModel ),
DEFINE_INPUTFUNC( FIELD_VOID, "RoundActivate", InputRoundActivate ),
DEFINE_OUTPUT( m_OnCapTeam1, "OnCapTeam1" ), // these are fired whenever the point changes modes
DEFINE_OUTPUT( m_OnCapTeam2, "OnCapTeam2" ),
DEFINE_OUTPUT( m_OnCapReset, "OnCapReset" ),
DEFINE_OUTPUT( m_OnOwnerChangedToTeam1, "OnOwnerChangedToTeam1" ), // these are fired when a team does the work to change the owner
DEFINE_OUTPUT( m_OnOwnerChangedToTeam2, "OnOwnerChangedToTeam2" ),
DEFINE_OUTPUT( m_OnRoundStartOwnedByTeam1, "OnRoundStartOwnedByTeam1" ), // these are fired when a round is starting
DEFINE_OUTPUT( m_OnRoundStartOwnedByTeam2, "OnRoundStartOwnedByTeam2" ),
DEFINE_THINKFUNC( AnimThink ),
END_DATADESC();
LINK_ENTITY_TO_CLASS( team_control_point, CTeamControlPoint );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTeamControlPoint::CTeamControlPoint()
{
m_TeamData.SetSize( GetNumberOfTeams() );
m_pCaptureInProgressSound = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::Spawn( void )
{
// Validate our default team
if ( m_iDefaultOwner < 0 || m_iDefaultOwner >= GetNumberOfTeams() )
{
Warning( "team_control_point '%s' has bad point_default_owner.\n", GetDebugName() );
m_iDefaultOwner = TEAM_UNASSIGNED;
}
Precache();
InternalSetOwner( m_iDefaultOwner, false ); //init the owner of this point
SetActive( !m_bStartDisabled );
BaseClass::Spawn();
SetPlaybackRate( 1.0 );
SetThink( &CTeamControlPoint::AnimThink );
SetNextThink( gpGlobals->curtime + 0.1f );
if ( FBitSet( m_spawnflags, SF_CAP_POINT_HIDE_MODEL ) )
{
AddEffects( EF_NODRAW );
}
if ( FBitSet( m_spawnflags, SF_CAP_POINT_HIDE_SHADOW ) )
{
AddEffects( EF_NOSHADOW );
}
m_flLastContestedAt = -1;
m_pCaptureInProgressSound = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTeamControlPoint::KeyValue( const char *szKeyName, const char *szValue )
{
if ( !Q_strncmp( szKeyName, "team_capsound_", 14 ) )
{
int iTeam = atoi(szKeyName+14);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iszCapSound = AllocPooledString(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_model_", 11 ) )
{
int iTeam = atoi(szKeyName+11);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iszModel = AllocPooledString(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_timedpoints_", 17 ) )
{
int iTeam = atoi(szKeyName+17);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iTimedPoints = atoi(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_bodygroup_", 15 ) )
{
int iTeam = atoi(szKeyName+15);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iModelBodygroup = atoi(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_icon_", 10 ) )
{
int iTeam = atoi(szKeyName+10);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iszIcon = AllocPooledString(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_overlay_", 13 ) )
{
int iTeam = atoi(szKeyName+13);
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
m_TeamData[iTeam].iszOverlay = AllocPooledString(szValue);
}
else if ( !Q_strncmp( szKeyName, "team_previouspoint_", 19 ) )
{
int iTeam;
int iPoint = 0;
sscanf( szKeyName+19, "%d_%d", &iTeam, &iPoint );
Assert( iTeam >= 0 && iTeam < m_TeamData.Count() );
Assert( iPoint >= 0 && iPoint < MAX_PREVIOUS_POINTS );
m_TeamData[iTeam].iszPreviousPoint[iPoint] = AllocPooledString(szValue);
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::Precache( void )
{
for ( int i = 0; i < m_TeamData.Count(); i++ )
{
// Skip over spectator
if ( i == TEAM_SPECTATOR )
continue;
if ( m_TeamData[i].iszCapSound != NULL_STRING )
{
PrecacheScriptSound( STRING(m_TeamData[i].iszCapSound) );
}
if ( m_TeamData[i].iszModel != NULL_STRING )
{
PrecacheModel( STRING(m_TeamData[i].iszModel) );
}
if ( m_TeamData[i].iszIcon != NULL_STRING )
{
PrecacheMaterial( STRING( m_TeamData[i].iszIcon ) );
m_TeamData[i].iIcon = GetMaterialIndex( STRING( m_TeamData[i].iszIcon ) );
Assert( m_TeamData[i].iIcon != 0 );
}
if ( !m_TeamData[i].iIcon )
{
Warning( "Invalid hud icon material for team %d in control point '%s' ( point index %d )\n", i, GetDebugName(), GetPointIndex() );
}
if ( m_TeamData[i].iszOverlay != NULL_STRING )
{
PrecacheMaterial( STRING( m_TeamData[i].iszOverlay ) );
m_TeamData[i].iOverlay = GetMaterialIndex( STRING( m_TeamData[i].iszOverlay ) );
Assert( m_TeamData[i].iOverlay != 0 );
if ( !m_TeamData[i].iOverlay )
{
Warning( "Invalid hud overlay material for team %d in control point '%s' ( point index %d )\n", i, GetDebugName(), GetPointIndex() );
}
}
}
PrecacheScriptSound( STRING( m_iszCaptureStartSound ) );
PrecacheScriptSound( STRING( m_iszCaptureEndSound ) );
PrecacheScriptSound( STRING( m_iszCaptureInProgress ) );
PrecacheScriptSound( STRING( m_iszCaptureInterrupted ) );
if ( m_iszWarnSound != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszWarnSound ) );
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CTeamControlPoint::AnimThink( void )
{
StudioFrameAdvance();
DispatchAnimEvents(this);
SetNextThink( gpGlobals->curtime + 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose: Used by ControlMaster to this point to its default owner
//-----------------------------------------------------------------------------
void CTeamControlPoint::InputReset( inputdata_t &input )
{
m_flLastContestedAt = -1;
InternalSetOwner( m_iDefaultOwner, false );
ObjectiveResource()->SetOwningTeam( GetPointIndex(), m_iTeam );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::HandleScoring( int iTeam )
{
if ( TeamplayRoundBasedRules() && !TeamplayRoundBasedRules()->ShouldScorePerRound() )
{
GetGlobalTeam( iTeam )->AddScore( 1 );
TeamplayRoundBasedRules()->HandleTeamScoreModify( iTeam, 1 );
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster && !pMaster->WouldNewCPOwnerWinGame( this, iTeam ) )
{
CTeamRecipientFilter filter( iTeam );
EmitSound( filter, entindex(), "Hud.EndRoundScored" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Used by Area caps to set the owner
//-----------------------------------------------------------------------------
void CTeamControlPoint::InputSetOwner( inputdata_t &input )
{
int iCapTeam = input.value.Int();
Assert( iCapTeam >= 0 && iCapTeam < GetNumberOfTeams() );
Assert( input.pCaller );
if ( GetOwner() == iCapTeam )
return;
if ( TeamplayGameRules()->PointsMayBeCaptured() )
{
// must be done before setting the owner
HandleScoring( iCapTeam );
if ( input.pCaller->IsPlayer() )
{
int iCappingPlayer = input.pCaller->entindex();
InternalSetOwner( iCapTeam, true, 1, &iCappingPlayer );
}
else
{
InternalSetOwner( iCapTeam, false );
}
ObjectiveResource()->SetOwningTeam( GetPointIndex(), m_iTeam );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::InputShowModel( inputdata_t &input )
{
RemoveEffects( EF_NODRAW );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::InputHideModel( inputdata_t &input )
{
AddEffects( EF_NODRAW );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetCurrentHudIconIndex( void )
{
return m_TeamData[GetOwner()].iIcon;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetHudIconIndexForTeam( int iGameTeam )
{
return m_TeamData[iGameTeam].iIcon;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetHudOverlayIndexForTeam( int iGameTeam )
{
return m_TeamData[iGameTeam].iOverlay;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetPreviousPointForTeam( int iGameTeam, int iPrevPoint )
{
Assert( iPrevPoint >= 0 && iPrevPoint < MAX_PREVIOUS_POINTS );
int iRetVal = -1;
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, STRING(m_TeamData[iGameTeam].iszPreviousPoint[iPrevPoint]) );
if ( pEntity )
{
CTeamControlPoint *pPoint = dynamic_cast<CTeamControlPoint*>( pEntity );
if ( pPoint )
{
iRetVal = pPoint->GetPointIndex();
}
}
return iRetVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::ForceOwner( int iTeam )
{
InternalSetOwner( iTeam, false, 0, 0 );
ObjectiveResource()->SetOwningTeam( GetPointIndex(), m_iTeam );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::SetOwner( int iCapTeam, bool bMakeSound, int iNumCappers, int *pCappingPlayers )
{
if ( TeamplayGameRules()->PointsMayBeCaptured() )
{
// must be done before setting the owner
HandleScoring( iCapTeam );
InternalSetOwner( iCapTeam, bMakeSound, iNumCappers, pCappingPlayers );
ObjectiveResource()->SetOwningTeam( GetPointIndex(), m_iTeam );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureStart( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers )
{
int iNumCappers = iNumCappingPlayers;
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_startcapture" );
if ( event )
{
event->SetInt( "cp", m_iPointIndex );
event->SetString( "cpname", STRING( m_iszPrintName ) );
event->SetInt( "team", m_iTeam );
event->SetInt( "capteam", iCapTeam );
// safety check
if ( iNumCappers > 8 )
{
iNumCappers = 8;
}
char cappers[9]; // pCappingPlayers should be max length 8
int i;
for( i = 0 ; i < iNumCappers ; i++ )
{
cappers[i] = (char)pCappingPlayers[i];
}
cappers[i] = '\0';
// pCappingPlayers is a null terminated list of player indices
event->SetString( "cappers", cappers );
event->SetInt( "priority", 7 );
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureEnd( void )
{
StopLoopingSounds();
if ( !FBitSet( m_spawnflags, SF_CAP_POINT_NO_CAP_SOUNDS ) )
{
EmitSound( STRING( m_iszCaptureEndSound ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureInterrupted( bool bBlocked )
{
StopLoopingSounds();
if ( FBitSet( m_spawnflags, SF_CAP_POINT_NO_CAP_SOUNDS ) )
{
return;
}
const char *pSoundName = NULL;
if ( bBlocked == true )
{
pSoundName = STRING( m_iszCaptureInterrupted );
}
else
{
pSoundName = STRING( m_iszCaptureInProgress );
EmitSound( STRING( m_iszCaptureStartSound ) );
}
if ( m_pCaptureInProgressSound == NULL && pSoundName != NULL )
{
CPASFilter filter( GetAbsOrigin() );
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
m_pCaptureInProgressSound = controller.SoundCreate( filter, entindex(), pSoundName );
controller.Play( m_pCaptureInProgressSound, 1.0, 100 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::StopLoopingSounds( void )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
if ( m_pCaptureInProgressSound )
{
controller.SoundDestroy( m_pCaptureInProgressSound );
m_pCaptureInProgressSound = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the new owner of the point, plays the appropriate sound and shows the right model
//-----------------------------------------------------------------------------
void CTeamControlPoint::InternalSetOwner( int iCapTeam, bool bMakeSound, int iNumCappers, int *pCappingPlayers )
{
Assert( iCapTeam >= 0 && iCapTeam < GetNumberOfTeams() );
int iOldTeam = m_iTeam;
m_iTeam = iCapTeam;
ChangeTeam( iCapTeam );
if ( bMakeSound )
{
CBroadcastRecipientFilter filter;
EmitSound( filter, entindex(), STRING( m_TeamData[m_iTeam].iszCapSound ) );
}
// Update visuals
SetModel( STRING(m_TeamData[m_iTeam].iszModel) );
SetBodygroup( 0, m_iTeam );
m_nSkin = ( m_iTeam == TEAM_UNASSIGNED ) ? 2 : (m_iTeam - 2);
ResetSequence( LookupSequence("idle") );
// We add 1 to the index because we consider the default "no points capped" as 0.
TeamplayGameRules()->SetLastCapPointChanged( m_iPointIndex+1 );
// Determine the pose parameters for each team
for ( int i = 0; i < m_TeamData.Count(); i++ )
{
// Skip spectator
if ( i == TEAM_SPECTATOR )
continue;
if ( GetModelPtr() && GetModelPtr()->SequencesAvailable() )
{
m_TeamData[i].iTeamPoseParam = LookupPoseParameter( UTIL_VarArgs( "cappoint_%d_percentage", i ) );
}
else
{
m_TeamData[i].iTeamPoseParam = -1;
}
}
UpdateCapPercentage();
if ( m_iTeam == TEAM_UNASSIGNED )
{
m_OnCapReset.FireOutput( this, this );
}
else
{
// Remap team to get first game team = 1
switch ( m_iTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnCapTeam1.FireOutput( this, this );
break;
case 2:
m_OnCapTeam2.FireOutput( this, this );
break;
default:
Assert(0);
break;
}
}
// If we're playing a sound, this is a true cap by players.
if ( bMakeSound )
{
if ( iOldTeam > LAST_SHARED_TEAM && iOldTeam != m_iTeam )
{
// Make the members of our old team say something
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
if ( pPlayer->GetTeamNumber() == iOldTeam )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_LOST_CONTROL_POINT );
}
}
}
for( int i = 0; i < iNumCappers; i++ )
{
int playerIndex = pCappingPlayers[i];
Assert( playerIndex > 0 && playerIndex <= gpGlobals->maxClients );
PlayerCapped( ToBaseMultiplayerPlayer(UTIL_PlayerByIndex( playerIndex )) );
}
// Remap team to get first game team = 1
switch ( m_iTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnOwnerChangedToTeam1.FireOutput( this, this );
break;
case 2:
m_OnOwnerChangedToTeam2.FireOutput( this, this );
break;
}
if ( m_iTeam != TEAM_UNASSIGNED && iNumCappers )
{
SendCapString( m_iTeam, iNumCappers, pCappingPlayers );
}
}
// Have control point master check the win conditions now!
CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, GetControlPointMasterName() );
while( pEnt )
{
CTeamControlPointMaster *pMaster = dynamic_cast<CTeamControlPointMaster *>( pEnt );
if ( pMaster->IsActive() )
{
pMaster->CheckWinConditions();
}
pEnt = gEntList.FindEntityByClassname( pEnt, GetControlPointMasterName() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::SendCapString( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers )
{
if ( strlen( STRING(m_iszPrintName) ) <= 0 )
return;
int iNumCappers = iNumCappingPlayers;
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_captured" );
if ( event )
{
event->SetInt( "cp", m_iPointIndex );
event->SetString( "cpname", STRING( m_iszPrintName ) );
event->SetInt( "team", iCapTeam );
// safety check
if ( iNumCappers > 8 )
{
iNumCappers = 8;
}
char cappers[9]; // pCappingPlayers should be max length 8
int i;
for( i = 0 ; i < iNumCappers ; i++ )
{
cappers[i] = (char)pCappingPlayers[i];
}
cappers[i] = '\0';
// pCappingPlayers is a null terminated list of player indices
event->SetString( "cappers", cappers );
event->SetInt( "priority", 9 );
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureBlocked( CBaseMultiplayerPlayer *pPlayer )
{
if( strlen( STRING(m_iszPrintName) ) <= 0 )
return;
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_capture_blocked" );
if ( event )
{
event->SetInt( "cp", m_iPointIndex );
event->SetString( "cpname", STRING(m_iszPrintName) );
event->SetInt( "blocker", pPlayer->entindex() );
event->SetInt( "priority", 9 );
gameeventmanager->FireEvent( event );
}
PlayerBlocked( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetOwner( void ) const
{
return m_iTeam;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetDefaultOwner( void ) const
{
return m_iDefaultOwner;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::GetCPGroup( void )
{
return m_iCPGroup;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the time-based point value of this control point
//-----------------------------------------------------------------------------
int CTeamControlPoint::PointValue( void )
{
if ( GetOwner() != m_iDefaultOwner )
return m_TeamData[ GetOwner() ].iTimedPoints;
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::SetActive( bool active )
{
m_bActive = active;
if( active )
{
RemoveEffects( EF_NODRAW );
}
else
{
AddEffects( EF_NODRAW );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::SetCappersRequiredForTeam( int iGameTeam, int iCappers )
{
m_TeamData[iGameTeam].iPlayersRequired = iCappers;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTeamControlPoint::LastContestedAt( void )
{
return m_flLastContestedAt;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::SetLastContestedAt( float flTime )
{
m_flLastContestedAt = flTime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::UpdateCapPercentage( void )
{
for ( int i = LAST_SHARED_TEAM+1; i < m_TeamData.Count(); i++ )
{
// Skip spectator
if ( i == TEAM_SPECTATOR )
continue;
float flPerc = GetTeamCapPercentage(i);
if ( m_TeamData[i].iTeamPoseParam != -1 )
{
SetPoseParameter( m_TeamData[i].iTeamPoseParam, flPerc );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTeamControlPoint::GetTeamCapPercentage( int iTeam )
{
int iCappingTeam = ObjectiveResource()->GetCappingTeam( GetPointIndex() );
if ( iCappingTeam == TEAM_UNASSIGNED )
{
// No-one's capping this point.
if ( iTeam == m_iTeam )
return 1.0;
return 0.0;
}
float flCapPerc = ObjectiveResource()->GetCPCapPercentage( GetPointIndex() );
if ( iTeam == iCappingTeam )
return (1.0 - flCapPerc);
if ( iTeam == m_iTeam )
return flCapPerc;
return 0.0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTeamControlPoint::DrawDebugTextOverlays( void )
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[1024];
Q_snprintf(tempstr, sizeof(tempstr), "INDEX: (%d)", GetPointIndex() );
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf( tempstr, sizeof(tempstr), "Red Previous Points: ");
for ( int i = 0; i < MAX_PREVIOUS_POINTS; i++ )
{
if ( m_TeamData[2].iszPreviousPoint[i] != NULL_STRING )
{
Q_strncat( tempstr, STRING(m_TeamData[2].iszPreviousPoint[i]), 1024, COPY_ALL_CHARACTERS );
Q_strncat( tempstr, ", ", 1024, COPY_ALL_CHARACTERS );
}
}
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf( tempstr, sizeof(tempstr), "Blue Previous Points: " );
for ( int i = 0; i < MAX_PREVIOUS_POINTS; i++ )
{
if ( m_TeamData[3].iszPreviousPoint[i] != NULL_STRING )
{
Q_strncat( tempstr, STRING(m_TeamData[3].iszPreviousPoint[i]), 1024, COPY_ALL_CHARACTERS );
Q_strncat( tempstr, ", ", 1024, COPY_ALL_CHARACTERS );
}
}
EntityText(text_offset,tempstr,0);
text_offset++;
for ( int i = 0; i < MAX_CONTROL_POINT_TEAMS; i++ )
{
if ( ObjectiveResource()->GetBaseControlPointForTeam(i) == GetPointIndex() )
{
Q_snprintf(tempstr, sizeof(tempstr), "Base Control Point for Team %d", i );
EntityText(text_offset,tempstr,0);
text_offset++;
}
}
}
return text_offset;
}
//-----------------------------------------------------------------------------
// Purpose: The specified player took part in capping this point.
//-----------------------------------------------------------------------------
void CTeamControlPoint::PlayerCapped( CBaseMultiplayerPlayer *pPlayer )
{
if ( pPlayer )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_CAPTURED_POINT );
}
}
//-----------------------------------------------------------------------------
// Purpose: The specified player blocked the enemy team from capping this point.
//-----------------------------------------------------------------------------
void CTeamControlPoint::PlayerBlocked( CBaseMultiplayerPlayer *pPlayer )
{
if ( pPlayer )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_CAPTURE_BLOCKED );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTeamControlPoint::InputRoundActivate( inputdata_t &inputdata )
{
switch ( m_iTeam - FIRST_GAME_TEAM+1 )
{
case 1:
m_OnRoundStartOwnedByTeam1.FireOutput( this, this );
break;
case 2:
m_OnRoundStartOwnedByTeam2.FireOutput( this, this );
break;
}
}