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.
48 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0b5a04e732
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0b5a04e732'
${ noResults }
source-engine/game/server/team_train_watcher.cpp

1615 lines
44 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "cbase.h"
#include "team_train_watcher.h"
#include "team_control_point.h"
#include "trains.h"
#include "team_objectiveresource.h"
#include "teamplayroundbased_gamerules.h"
#include "team_control_point.h"
#include "team_control_point_master.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
#include "mp_shareddefs.h"
#include "props.h"
#include "physconstraint.h"
#ifdef TF_DLL
#include "tf_shareddefs.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
/*
#define TWM_FIRSTSTAGEOUTCOME01 "Announcer.PLR_FirstStageOutcome01"
#define TWM_FIRSTSTAGEOUTCOME02 "Announcer.PLR_FirstStageOutcome02"
#define TWM_RACEGENERAL01 "Announcer.PLR_RaceGeneral01"
#define TWM_RACEGENERAL02 "Announcer.PLR_RaceGeneral02"
#define TWM_RACEGENERAL03 "Announcer.PLR_RaceGeneral03"
#define TWM_RACEGENERAL04 "Announcer.PLR_RaceGeneral04"
#define TWM_RACEGENERAL05 "Announcer.PLR_RaceGeneral05"
#define TWM_RACEGENERAL08 "Announcer.PLR_RaceGeneral08"
#define TWM_RACEGENERAL06 "Announcer.PLR_RaceGeneral06"
#define TWM_RACEGENERAL07 "Announcer.PLR_RaceGeneral07"
#define TWM_RACEGENERAL09 "Announcer.PLR_RaceGeneral09"
#define TWM_RACEGENERAL12 "Announcer.PLR_RaceGeneral12"
#define TWM_RACEGENERAL13 "Announcer.PLR_RaceGeneral13"
#define TWM_RACEGENERAL14 "Announcer.PLR_RaceGeneral14"
#define TWM_RACEGENERAL15 "Announcer.PLR_RaceGeneral15"
#define TWM_RACEGENERAL10 "Announcer.PLR_RaceGeneral10"
#define TWM_RACEGENERAL11 "Announcer.PLR_RaceGeneral11"
#define TWM_SECONDSTAGEOUTCOME01 "Announcer.PLR_SecondStageOutcome01"
#define TWM_SECONDSTAGEOUTCOME04 "Announcer.PLR_SecondStageOutcome04"
#define TWM_SECONDSTAGEOUTCOME02 "Announcer.PLR_SecondStageOutcome02"
#define TWM_SECONDSTAGEOUTCOME03 "Announcer.PLR_SecondStageOutcome03"
#define TWM_FINALSTAGEOUTCOME01 "Announcer.PLR_FinalStageOutcome01"
#define TWM_FINALSTAGEOUTCOME02 "Announcer.PLR_FinalStageOutcome02"
#define TWM_FINALSTAGESTART01 "Announcer.PLR_FinalStageStart01"
#define TWM_FINALSTAGESTART04 "Announcer.PLR_FinalStageStart04"
#define TWM_FINALSTAGESTART08 "Announcer.PLR_FinalStageStart08"
#define TWM_FINALSTAGESTART09 "Announcer.PLR_FinalStageStart09"
#define TWM_FINALSTAGESTART07 "Announcer.PLR_FinalStageStart07"
#define TWM_FINALSTAGESTART02 "Announcer.PLR_FinalStageStart02"
#define TWM_FINALSTAGESTART03 "Announcer.PLR_FinalStageStart03"
#define TWM_FINALSTAGESTART05 "Announcer.PLR_FinalStageStart05"
#define TWM_FINALSTAGESTART06 "Announcer.PLR_FinalStageStart06"
EHANDLE g_hTeamTrainWatcherMaster = NULL;
*/
#define MAX_ALARM_TIME_NO_RECEDE 18 // max amount of time to play the alarm if the train isn't going to recede
BEGIN_DATADESC( CTeamTrainWatcher )
// Inputs.
DEFINE_INPUTFUNC( FIELD_VOID, "RoundActivate", InputRoundActivate ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetNumTrainCappers", InputSetNumTrainCappers ),
DEFINE_INPUTFUNC( FIELD_VOID, "OnStartOvertime", InputOnStartOvertime ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeedForwardModifier", InputSetSpeedForwardModifier ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetTrainRecedeTime", InputSetTrainRecedeTime ),
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetTrainCanRecede", InputSetTrainCanRecede ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetTrainRecedeTimeAndUpdate", InputSetTrainRecedeTimeAndUpdate ),
// Outputs
DEFINE_OUTPUT( m_OnTrainStartRecede, "OnTrainStartRecede" ),
// key
DEFINE_KEYFIELD( m_iszTrain, FIELD_STRING, "train" ),
DEFINE_KEYFIELD( m_iszStartNode, FIELD_STRING, "start_node" ),
DEFINE_KEYFIELD( m_iszGoalNode, FIELD_STRING, "goal_node" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[0], FIELD_STRING, "linked_pathtrack_1" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[0], FIELD_STRING, "linked_cp_1" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[1], FIELD_STRING, "linked_pathtrack_2" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[1], FIELD_STRING, "linked_cp_2" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[2], FIELD_STRING, "linked_pathtrack_3" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[2], FIELD_STRING, "linked_cp_3" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[3], FIELD_STRING, "linked_pathtrack_4" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[3], FIELD_STRING, "linked_cp_4" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[4], FIELD_STRING, "linked_pathtrack_5" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[4], FIELD_STRING, "linked_cp_5" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[5], FIELD_STRING, "linked_pathtrack_6" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[5], FIELD_STRING, "linked_cp_6" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[6], FIELD_STRING, "linked_pathtrack_7" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[6], FIELD_STRING, "linked_cp_7" ),
DEFINE_KEYFIELD( m_iszLinkedPathTracks[7], FIELD_STRING, "linked_pathtrack_8" ),
DEFINE_KEYFIELD( m_iszLinkedCPs[7], FIELD_STRING, "linked_cp_8" ),
DEFINE_KEYFIELD( m_bTrainCanRecede, FIELD_BOOLEAN, "train_can_recede" ),
DEFINE_KEYFIELD( m_bHandleTrainMovement, FIELD_BOOLEAN, "handle_train_movement" ),
// can be up to 8 links
// min speed for train hud speed levels
DEFINE_KEYFIELD( m_flSpeedLevels[0], FIELD_FLOAT, "hud_min_speed_level_1" ),
DEFINE_KEYFIELD( m_flSpeedLevels[1], FIELD_FLOAT, "hud_min_speed_level_2" ),
DEFINE_KEYFIELD( m_flSpeedLevels[2], FIELD_FLOAT, "hud_min_speed_level_3" ),
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ),
DEFINE_KEYFIELD( m_iszSparkName, FIELD_STRING, "env_spark_name" ),
DEFINE_KEYFIELD( m_flSpeedForwardModifier, FIELD_FLOAT, "speed_forward_modifier" ),
DEFINE_KEYFIELD( m_nTrainRecedeTime, FIELD_INTEGER, "train_recede_time" ),
END_DATADESC()
IMPLEMENT_SERVERCLASS_ST(CTeamTrainWatcher, DT_TeamTrainWatcher)
SendPropFloat( SENDINFO( m_flTotalProgress ), 11, 0, 0.0f, 1.0f ),
SendPropInt( SENDINFO( m_iTrainSpeedLevel ), 4 ),
SendPropTime( SENDINFO( m_flRecedeTime ) ),
SendPropInt( SENDINFO( m_nNumCappers ) ),
#ifdef GLOWS_ENABLE
SendPropEHandle( SENDINFO( m_hGlowEnt ) ),
#endif // GLOWS_ENABLE
END_SEND_TABLE()
LINK_ENTITY_TO_CLASS( team_train_watcher, CTeamTrainWatcher );
IMPLEMENT_AUTO_LIST( ITFTeamTrainWatcher );
/*
LINK_ENTITY_TO_CLASS( team_train_watcher_master, CTeamTrainWatcherMaster );
PRECACHE_REGISTER( team_train_watcher_master );
CTeamTrainWatcherMaster::CTeamTrainWatcherMaster()
{
m_pBlueWatcher = NULL;
m_pRedWatcher = NULL;
m_flBlueProgress = 0.0f;
m_flRedProgress = 0.0f;
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "teamplay_round_win" );
}
CTeamTrainWatcherMaster::~CTeamTrainWatcherMaster()
{
if ( g_hTeamTrainWatcherMaster.Get() == this )
{
g_hTeamTrainWatcherMaster = NULL;
}
}
void CTeamTrainWatcherMaster::Precache( void )
{
PrecacheScriptSound( TWM_FIRSTSTAGEOUTCOME01 );
PrecacheScriptSound( TWM_FIRSTSTAGEOUTCOME02 );
PrecacheScriptSound( TWM_RACEGENERAL01 );
PrecacheScriptSound( TWM_RACEGENERAL02 );
PrecacheScriptSound( TWM_RACEGENERAL03 );
PrecacheScriptSound( TWM_RACEGENERAL04 );
PrecacheScriptSound( TWM_RACEGENERAL05 );
PrecacheScriptSound( TWM_RACEGENERAL08 );
PrecacheScriptSound( TWM_RACEGENERAL06 );
PrecacheScriptSound( TWM_RACEGENERAL07 );
PrecacheScriptSound( TWM_RACEGENERAL09 );
PrecacheScriptSound( TWM_RACEGENERAL12 );
PrecacheScriptSound( TWM_RACEGENERAL13 );
PrecacheScriptSound( TWM_RACEGENERAL14 );
PrecacheScriptSound( TWM_RACEGENERAL15 );
PrecacheScriptSound( TWM_RACEGENERAL10 );
PrecacheScriptSound( TWM_RACEGENERAL11 );
PrecacheScriptSound( TWM_SECONDSTAGEOUTCOME01 );
PrecacheScriptSound( TWM_SECONDSTAGEOUTCOME04 );
PrecacheScriptSound( TWM_SECONDSTAGEOUTCOME02 );
PrecacheScriptSound( TWM_SECONDSTAGEOUTCOME03 );
PrecacheScriptSound( TWM_FINALSTAGEOUTCOME01 );
PrecacheScriptSound( TWM_FINALSTAGEOUTCOME02 );
PrecacheScriptSound( TWM_FINALSTAGESTART01 );
PrecacheScriptSound( TWM_FINALSTAGESTART04 );
PrecacheScriptSound( TWM_FINALSTAGESTART08 );
PrecacheScriptSound( TWM_FINALSTAGESTART09 );
PrecacheScriptSound( TWM_FINALSTAGESTART07 );
PrecacheScriptSound( TWM_FINALSTAGESTART02 );
PrecacheScriptSound( TWM_FINALSTAGESTART03 );
PrecacheScriptSound( TWM_FINALSTAGESTART05 );
PrecacheScriptSound( TWM_FINALSTAGESTART06 );
BaseClass::Precache();
}
bool CTeamTrainWatcherMaster::FindTrainWatchers( void )
{
m_pBlueWatcher = NULL;
m_pRedWatcher = NULL;
// find the train_watchers for this round
CTeamTrainWatcher *pTrainWatcher = (CTeamTrainWatcher *)gEntList.FindEntityByClassname( NULL, "team_train_watcher" );
while ( pTrainWatcher )
{
if ( pTrainWatcher->IsDisabled() == false )
{
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_BLUE )
{
m_pBlueWatcher = pTrainWatcher;
}
else if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
{
m_pRedWatcher = pTrainWatcher;
}
}
pTrainWatcher = (CTeamTrainWatcher *)gEntList.FindEntityByClassname( pTrainWatcher, "team_train_watcher" );
}
return ( m_pBlueWatcher && m_pRedWatcher );
}
void CTeamTrainWatcherMaster::TWMThink( void )
{
if ( TeamplayRoundBasedRules() && TeamplayRoundBasedRules()->State_Get() != GR_STATE_RND_RUNNING )
{
// the next time we 'think'
SetContextThink( &CTeamTrainWatcherMaster::TWMThink, gpGlobals->curtime + 0.2, TWMASTER_THINK );
return;
}
// the next time we 'think'
SetContextThink( &CTeamTrainWatcherMaster::TWMThink, gpGlobals->curtime + 0.2, TWMASTER_THINK );
}
void CTeamTrainWatcherMaster::FireGameEvent( IGameEvent *event )
{
const char *eventname = event->GetName();`
if ( FStrEq( "teamplay_round_start", eventname ) )
{
if ( TeamplayRoundBasedRules() && TeamplayRoundBasedRules()->HasMultipleTrains() )
{
if ( FindTrainWatchers() )
{
// we found train watchers so start thinking
SetContextThink( &CTeamTrainWatcherMaster::TWMThink, gpGlobals->curtime + 0.2, TWMASTER_THINK );
}
}
}
else if ( FStrEq( "teamplay_round_win", eventname ) )
{
if ( TeamplayRoundBasedRules() )
{
int iWinningTeam = event->GetInt( "team" );
int iLosingTeam = ( iWinningTeam == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED;
bool bFullRound = event->GetBool( "full_round" );
CTeamRecipientFilter filterWinner( iWinningTeam, true );
CTeamRecipientFilter filterLoser( iLosingTeam, true );
if ( bFullRound )
{
EmitSound( filterWinner, entindex(), TWM_FINALSTAGEOUTCOME01 );
EmitSound( filterLoser, entindex(), TWM_FINALSTAGEOUTCOME02 );
}
else
{
EmitSound( filterWinner, entindex(), TWM_FIRSTSTAGEOUTCOME01 );
EmitSound( filterLoser, entindex(), TWM_FIRSTSTAGEOUTCOME02 );
}
}
}
}
*/
CTeamTrainWatcher::CTeamTrainWatcher()
{
m_bDisabled = false;
m_flRecedeTime = 0;
m_bWaitingToRecede = false;
m_bCapBlocked = false;
m_flNextSpeakForwardConceptTime = 0;
m_hAreaCap = NULL;
m_bTrainCanRecede = true;
m_bAlarmPlayed = false;
m_pAlarm = NULL;
m_flAlarmEndTime = -1;
m_bHandleTrainMovement = false;
m_flSpeedForwardModifier = 1.0f;
m_iCurrentHillType = HILL_TYPE_NONE;
m_flCurrentSpeed = 0.0f;
m_bReceding = false;
m_flTrainDistanceFromStart = 0.0f;
m_flTrainDistanceAccumulator = 0.f;
m_nTrainRecedeTime = 0;
#ifdef GLOWS_ENABLE
m_hGlowEnt.Set( NULL );
#endif // GLOWS_ENABLE
#ifdef TF_DLL
ChangeTeam( TF_TEAM_BLUE );
#else
ChangeTeam( TEAM_UNASSIGNED );
#endif
/*
// create a CTeamTrainWatcherMaster entity
if ( g_hTeamTrainWatcherMaster.Get() == NULL )
{
g_hTeamTrainWatcherMaster = CreateEntityByName( "team_train_watcher_master" );
}
*/
ListenForGameEvent( "path_track_passed" );
}
CTeamTrainWatcher::~CTeamTrainWatcher()
{
m_Sparks.Purge();
}
void CTeamTrainWatcher::UpdateOnRemove( void )
{
StopCaptureAlarm();
BaseClass::UpdateOnRemove();
}
int CTeamTrainWatcher::UpdateTransmitState()
{
if ( m_bDisabled )
{
return SetTransmitState( FL_EDICT_DONTSEND );
}
return SetTransmitState( FL_EDICT_ALWAYS );
}
void CTeamTrainWatcher::InputRoundActivate( inputdata_t &inputdata )
{
StopCaptureAlarm();
if ( !m_bDisabled )
{
WatcherActivate();
}
}
void CTeamTrainWatcher::InputEnable( inputdata_t &inputdata )
{
StopCaptureAlarm();
m_bDisabled = false;
WatcherActivate();
UpdateTransmitState();
}
void CTeamTrainWatcher::InputDisable( inputdata_t &inputdata )
{
StopCaptureAlarm();
m_bDisabled = true;
SetContextThink( NULL, 0, TW_THINK );
m_bWaitingToRecede = false;
m_Sparks.Purge();
#ifdef GLOWS_ENABLE
m_hGlowEnt.Set( NULL );
#endif // GLOWS_ENABLE
// if we're moving the train, let's shut it down
if ( m_bHandleTrainMovement )
{
m_flCurrentSpeed = 0.0f;
if ( m_hTrain )
{
m_hTrain->SetSpeedDirAccel( m_flCurrentSpeed );
}
// handle the sparks under the train
HandleSparks( false );
}
UpdateTransmitState();
}
ConVar tf_escort_recede_time( "tf_escort_recede_time", "30", 0, "", true, 0, false, 0 );
ConVar tf_escort_recede_time_overtime( "tf_escort_recede_time_overtime", "5", 0, "", true, 0, false, 0 );
void CTeamTrainWatcher::FireGameEvent( IGameEvent *event )
{
if ( IsDisabled() || !m_bHandleTrainMovement )
return;
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "path_track_passed" ) )
{
int iIndex = event->GetInt( "index" );
CPathTrack *pNode = dynamic_cast< CPathTrack* >( UTIL_EntityByIndex( iIndex ) );
if ( pNode )
{
bool bHandleEvent = false;
CPathTrack *pTempNode = m_hStartNode.Get();
// is this a node in the track we're watching?
while ( pTempNode )
{
if ( pTempNode == pNode )
{
bHandleEvent = true;
break;
}
pTempNode = pTempNode->GetNext();
}
if ( bHandleEvent )
{
// If we're receding and we've hit a node but the next node (going backwards) is disabled
// the train is going to stop (like at the base of a downhill section) when we start forward
// again we won't pass this node again so don't change our hill state based on this node.
if ( m_bReceding )
{
if ( pNode->GetPrevious() && pNode->GetPrevious()->IsDisabled() )
{
return;
}
}
int iHillType = pNode->GetHillType();
bool bUpdate = ( m_iCurrentHillType != iHillType );
if ( !bUpdate )
{
// the hill settings are the same, but are we leaving an uphill or downhill segment?
if ( m_iCurrentHillType != HILL_TYPE_NONE )
{
// let's peek at the next node
CPathTrack *pNextNode = pNode->GetNext();
if ( m_flCurrentSpeed < 0 )
{
// we're going backwards
pNextNode = pNode->GetPrevious();
}
if ( pNextNode )
{
int iNextHillType = pNextNode->GetHillType();
if ( m_iCurrentHillType != iNextHillType )
{
// we're leaving an uphill or downhill segment...so reset our state until we pass the next node
bUpdate = true;
iHillType = HILL_TYPE_NONE;
}
}
}
}
if ( bUpdate )
{
m_iCurrentHillType = iHillType;
HandleTrainMovement();
}
}
}
}
}
void CTeamTrainWatcher::HandleSparks( bool bSparks )
{
if ( IsDisabled() || !m_bHandleTrainMovement )
return;
for ( int i = 0 ; i < m_Sparks.Count() ; i++ )
{
CEnvSpark* pSpark = m_Sparks[i].Get();
if ( pSpark && ( pSpark->IsSparking() != bSparks ) )
{
if ( bSparks )
{
pSpark->StartSpark();
}
else
{
pSpark->StopSpark();
}
}
}
}
void CTeamTrainWatcher::HandleTrainMovement( bool bStartReceding /* = false */ )
{
if ( IsDisabled() || !m_bHandleTrainMovement )
return;
if ( m_hTrain )
{
float flSpeed = 0.0f;
if ( bStartReceding )
{
flSpeed = -0.1f;
m_bReceding = true;
}
else
{
// do we have cappers on the train?
if ( m_nNumCappers > 0 )
{
m_bReceding = false;
if ( m_iCurrentHillType == HILL_TYPE_DOWNHILL )
{
flSpeed = 1.0f;
}
else
{
switch( m_nNumCappers )
{
case 1:
flSpeed = 0.55f;
break;
case 2:
flSpeed = 0.77f;
break;
case 3:
default:
flSpeed = 1.0f;
break;
}
}
}
else if ( m_nNumCappers == -1 )
{
// we'll get a -1 for a blocked cart (speed should be 0 for that unless we're on a hill)
if ( m_iCurrentHillType == HILL_TYPE_DOWNHILL )
{
flSpeed = 1.0f;
}
}
else
{
// there's nobody on the train, what should it be doing?
if ( m_flCurrentSpeed > 0 )
{
if ( m_iCurrentHillType == HILL_TYPE_DOWNHILL )
{
flSpeed = 1.0f;
}
}
else
{
// we're rolling backwards
if ( m_iCurrentHillType == HILL_TYPE_UPHILL )
{
flSpeed = -1.0f;
}
else
{
if ( m_bReceding )
{
// resume our previous backup speed
flSpeed = -0.1f;
}
}
}
}
}
// only need to update the train if our speed has changed
if ( m_flCurrentSpeed != flSpeed )
{
if ( flSpeed >= 0.0f )
{
m_bReceding = false;
}
m_flCurrentSpeed = flSpeed;
m_hTrain->SetSpeedDirAccel( m_flCurrentSpeed );
// handle the sparks under the train
bool bSparks = false;
if ( m_flCurrentSpeed < 0 )
{
bSparks = true;
}
HandleSparks( bSparks );
}
}
}
void CTeamTrainWatcher::InputSetSpeedForwardModifier( inputdata_t &inputdata )
{
InternalSetSpeedForwardModifier( inputdata.value.Float() );
}
void CTeamTrainWatcher::InternalSetSpeedForwardModifier( float flModifier )
{
if ( IsDisabled() || !m_bHandleTrainMovement )
return;
// store the passed value
float flSpeedForwardModifier = flModifier;
flSpeedForwardModifier = fabs( flSpeedForwardModifier );
m_flSpeedForwardModifier = clamp( flSpeedForwardModifier, 0.f, 1.f );
if ( m_hTrain )
{
m_hTrain->SetSpeedForwardModifier( m_flSpeedForwardModifier );
}
}
void CTeamTrainWatcher::InternalSetNumTrainCappers( int iNumCappers, CBaseEntity *pTrigger )
{
if ( IsDisabled() )
return;
m_nNumCappers = iNumCappers;
// inputdata.pCaller is hopefully an area capture
// lets see if its blocked, and not start receding if it is
CTriggerAreaCapture *pAreaCap = dynamic_cast<CTriggerAreaCapture *>( pTrigger );
if ( pAreaCap )
{
m_bCapBlocked = pAreaCap->IsBlocked();
m_hAreaCap = pAreaCap;
}
if ( iNumCappers <= 0 && !m_bCapBlocked && m_bTrainCanRecede )
{
if ( !m_bWaitingToRecede )
{
// start receding in [tf_escort_cart_recede_time] seconds
m_bWaitingToRecede = true;
if ( TeamplayRoundBasedRules() && TeamplayRoundBasedRules()->InOvertime() )
{
m_flRecedeTotalTime = tf_escort_recede_time_overtime.GetFloat();
}
else
{
m_flRecedeTotalTime = tf_escort_recede_time.GetFloat();
if ( m_nTrainRecedeTime > 0 )
{
m_flRecedeTotalTime = m_nTrainRecedeTime;
}
}
m_flRecedeStartTime = gpGlobals->curtime;
m_flRecedeTime = m_flRecedeStartTime + m_flRecedeTotalTime;
}
}
else
{
// cancel receding
m_bWaitingToRecede = false;
m_flRecedeTime = 0;
}
HandleTrainMovement();
}
// only used for train watchers that control the train movement
void CTeamTrainWatcher::SetNumTrainCappers( int iNumCappers, CBaseEntity *pTrigger )
{
if ( IsDisabled() || !m_bHandleTrainMovement )
return;
InternalSetNumTrainCappers( iNumCappers, pTrigger );
}
void CTeamTrainWatcher::InputSetNumTrainCappers( inputdata_t &inputdata )
{
InternalSetNumTrainCappers( inputdata.value.Int(), inputdata.pCaller );
}
void CTeamTrainWatcher::InputSetTrainRecedeTime( inputdata_t &inputdata )
{
int nSeconds = inputdata.value.Int();
if ( nSeconds >= 0 )
{
m_nTrainRecedeTime = nSeconds;
}
else
{
m_nTrainRecedeTime = 0;
}
}
void CTeamTrainWatcher::InputSetTrainRecedeTimeAndUpdate(inputdata_t &inputdata)
{
InputSetTrainRecedeTime( inputdata );
// update our time if we're already counting down
if ( m_flRecedeTime > 0 )
{
m_flRecedeTotalTime = tf_escort_recede_time.GetFloat();
if ( m_nTrainRecedeTime > 0 )
{
m_flRecedeTotalTime = m_nTrainRecedeTime;
}
m_flRecedeStartTime = gpGlobals->curtime;
m_flRecedeTime = m_flRecedeStartTime + m_flRecedeTotalTime;
}
}
void CTeamTrainWatcher::InputSetTrainCanRecede( inputdata_t &inputdata )
{
m_bTrainCanRecede = inputdata.value.Bool();
}
void CTeamTrainWatcher::InputOnStartOvertime( inputdata_t &inputdata )
{
// recalculate the recede time
if ( m_bWaitingToRecede )
{
float flRecedeTimeRemaining = m_flRecedeTime - gpGlobals->curtime;
float flOvertimeRecedeLen = tf_escort_recede_time_overtime.GetFloat();
// drop to overtime recede time if it's more than that
if ( flRecedeTimeRemaining > flOvertimeRecedeLen )
{
m_flRecedeTotalTime = flOvertimeRecedeLen;
m_flRecedeStartTime = gpGlobals->curtime;
m_flRecedeTime = m_flRecedeStartTime + m_flRecedeTotalTime;
}
}
}
#ifdef GLOWS_ENABLE
void CTeamTrainWatcher::FindGlowEntity( void )
{
if ( m_hTrain && ( m_hTrain->GetEntityName() != NULL_STRING ) )
{
string_t iszTrainName = m_hTrain->GetEntityName();
CBaseEntity *pGlowEnt = NULL;
// first try to find a phys_constraint relationship with the train
CPhysFixed *pPhysConstraint = dynamic_cast<CPhysFixed*>( gEntList.FindEntityByClassname( NULL, "phys_constraint" ) );
while ( pPhysConstraint )
{
string_t iszName1 = pPhysConstraint->GetNameAttach1();
string_t iszName2 = pPhysConstraint->GetNameAttach2();
if ( iszTrainName == iszName1 )
{
pGlowEnt = gEntList.FindEntityByName( NULL, STRING( iszName2 ) );
break;
}
else if ( iszTrainName == iszName2 )
{
pGlowEnt = gEntList.FindEntityByName( NULL, STRING( iszName1 ) );
break;
}
pPhysConstraint = dynamic_cast<CPhysFixed*>( gEntList.FindEntityByClassname( pPhysConstraint, "phys_constraint" ) );
}
if ( !pGlowEnt )
{
// if we're here, we haven't found the glow entity yet...try all of the prop_dynamic entities
CDynamicProp *pPropDynamic = dynamic_cast<CDynamicProp*>( gEntList.FindEntityByClassname( NULL, "prop_dynamic" ) );
while ( pPropDynamic )
{
if ( pPropDynamic->GetParent() == m_hTrain )
{
pGlowEnt = pPropDynamic;
break;
}
pPropDynamic = dynamic_cast<CDynamicProp*>( gEntList.FindEntityByClassname( pPropDynamic, "prop_dynamic" ) );
}
}
// if we still haven't found a glow entity, just have the CFuncTrackTrain glow
if ( !pGlowEnt )
{
pGlowEnt = m_hTrain.Get();
}
if ( pGlowEnt )
{
pGlowEnt->SetTransmitState( FL_EDICT_ALWAYS );
m_hGlowEnt.Set( pGlowEnt );
}
}
}
#endif // GLOWS_ENABLE
// ==========================================================
// given a start node and a list of goal nodes
// calculate the distance between each
// ==========================================================
void CTeamTrainWatcher::WatcherActivate( void )
{
m_flRecedeTime = 0;
m_bWaitingToRecede = false;
m_bCapBlocked = false;
m_flNextSpeakForwardConceptTime = 0;
m_hAreaCap = NULL;
m_flTrainDistanceFromStart = 0.0f;
m_bAlarmPlayed = false;
m_Sparks.Purge();
StopCaptureAlarm();
// init our train
m_hTrain = dynamic_cast<CFuncTrackTrain*>( gEntList.FindEntityByName( NULL, m_iszTrain ) );
if ( !m_hTrain )
{
Warning("%s failed to find train named '%s'\n", GetClassname(), STRING( m_iszTrain ) );
}
// find the trigger area that will give us movement updates and find the sparks (if we're going to handle the train movement)
if ( m_bHandleTrainMovement )
{
if ( m_hTrain )
{
for ( int i=0; i<ITriggerAreaCaptureAutoList::AutoList().Count(); ++i )
{
CTriggerAreaCapture *pArea = static_cast< CTriggerAreaCapture * >( ITriggerAreaCaptureAutoList::AutoList()[i] );
if ( pArea->GetParent() == m_hTrain.Get() )
{
// this is the capture area we care about, so let it know that we want updates on the capture numbers
pArea->SetTrainWatcher( this );
break;
}
}
}
// init the sprites (if any)
CEnvSpark *pSpark = dynamic_cast<CEnvSpark*>( gEntList.FindEntityByName( NULL, m_iszSparkName ) );
while ( pSpark )
{
m_Sparks.AddToTail( pSpark );
pSpark = dynamic_cast<CEnvSpark*>( gEntList.FindEntityByName( pSpark, m_iszSparkName ) );
}
}
// init our array of path_tracks linked to control points
m_iNumCPLinks = 0;
int i;
for ( i = 0 ; i < MAX_CONTROL_POINTS ; i++ )
{
CPathTrack *pPathTrack = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, m_iszLinkedPathTracks[i] ) );
CTeamControlPoint *pCP = dynamic_cast<CTeamControlPoint*>( gEntList.FindEntityByName( NULL, m_iszLinkedCPs[i] ) );
if ( pPathTrack && pCP )
{
m_CPLinks[m_iNumCPLinks].hPathTrack = pPathTrack;
m_CPLinks[m_iNumCPLinks].hCP = pCP;
m_CPLinks[m_iNumCPLinks].flDistanceFromStart = 0; // filled in when we parse the nodes
m_CPLinks[m_iNumCPLinks].bAlertPlayed = false;
m_iNumCPLinks++;
}
}
// init our start and goal nodes
m_hStartNode = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, m_iszStartNode ) );
if ( !m_hStartNode )
{
Warning("%s failed to find path_track named '%s'\n", GetClassname(), STRING(m_iszStartNode) );
}
m_hGoalNode = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, m_iszGoalNode ) );
if ( !m_hGoalNode )
{
Warning("%s failed to find path_track named '%s'\n", GetClassname(), STRING(m_iszGoalNode) );
}
m_flTotalPathDistance = 0.0f;
CUtlVector< float > hillData;
bool bOnHill = false;
bool bDownHillData[TEAM_TRAIN_MAX_HILLS];
Q_memset( bDownHillData, 0, sizeof( bDownHillData ) );
int iHillCount = 0;
if( m_hStartNode.Get() && m_hGoalNode.Get() )
{
CPathTrack *pNode = m_hStartNode;
CPathTrack *pPrev = pNode;
CPathTrack *pHillStart = NULL;
pNode = pNode->GetNext();
int iHillType = HILL_TYPE_NONE;
// don't check the start node for links. If it's linked, it will have 0 distance anyway
while ( pNode )
{
Vector dir = pNode->GetLocalOrigin() - pPrev->GetLocalOrigin();
float length = dir.Length();
m_flTotalPathDistance += length;
// gather our hill data for the HUD
if ( pNode->GetHillType() != iHillType )
{
if ( !bOnHill ) // we're at the start of a hill
{
hillData.AddToTail( m_flTotalPathDistance );
bOnHill = true;
pHillStart = pNode;
if ( iHillCount < TEAM_TRAIN_MAX_HILLS )
{
bDownHillData[iHillCount] = pNode->IsDownHill() ? true : false;
iHillCount++;
}
}
else // we're at the end of a hill
{
float flDistance = m_flTotalPathDistance - length; // subtract length because the prev node was the end of the hill (not this one)
if ( pHillStart && ( pHillStart == pPrev ) )
{
flDistance = m_flTotalPathDistance; // we had a single node marked as a hill, so we'll use the current distance as the next marker
}
hillData.AddToTail( flDistance );
// is our current node the start of another hill?
if ( pNode->GetHillType() != HILL_TYPE_NONE )
{
hillData.AddToTail( m_flTotalPathDistance );
bOnHill = true;
pHillStart = pNode;
if ( iHillCount < TEAM_TRAIN_MAX_HILLS )
{
bDownHillData[iHillCount] = pNode->IsDownHill() ? true : false;
iHillCount++;
}
}
else
{
bOnHill = false;
pHillStart = NULL;
}
}
iHillType = pNode->GetHillType();
}
// if pNode is one of our cp nodes, store its distance from m_hStartNode
for ( i = 0 ; i < m_iNumCPLinks ; i++ )
{
if ( m_CPLinks[i].hPathTrack == pNode )
{
m_CPLinks[i].flDistanceFromStart = m_flTotalPathDistance;
break;
}
}
if ( pNode == m_hGoalNode )
break;
pPrev = pNode;
pNode = pNode->GetNext();
}
}
// if we don't have an even number of entries in our hill data (beginning/end) add the final distance
if ( ( hillData.Count() % 2 ) != 0 )
{
hillData.AddToTail( m_flTotalPathDistance );
}
if ( ObjectiveResource() )
{
ObjectiveResource()->ResetHillData( GetTeamNumber() );
// convert our hill data into 0-1 percentages for networking
if ( m_flTotalPathDistance > 0 && hillData.Count() > 0 )
{
i = 0;
while ( i < hillData.Count() )
{
if ( i < TEAM_TRAIN_HILLS_ARRAY_SIZE - 1 ) // - 1 because we want to use 2 entries
{
// add/subtract to the hill start/end to fix rounding errors in the HUD when the train
// stops at the bottom/top of a hill but the HUD thinks the train is still on the hill
ObjectiveResource()->SetHillData( GetTeamNumber(), (hillData[i] / m_flTotalPathDistance) + 0.005f, (hillData[i+1] / m_flTotalPathDistance) - 0.005f, bDownHillData[i/2] );
}
i = i + 2;
}
}
}
// We have total distance and increments in our links array
for ( i=0;i<m_iNumCPLinks;i++ )
{
int iCPIndex = m_CPLinks[i].hCP.Get()->GetPointIndex();
// This can be pulled once DoD includes team_objectiveresource.* and c_team_objectiveresource.*
#ifndef DOD_DLL
ObjectiveResource()->SetTrainPathDistance( iCPIndex, m_CPLinks[i].flDistanceFromStart / m_flTotalPathDistance );
#endif
}
#ifdef GLOWS_ENABLE
FindGlowEntity();
#endif // GLOWS_ENABLE
InternalSetSpeedForwardModifier( m_flSpeedForwardModifier );
SetContextThink( &CTeamTrainWatcher::WatcherThink, gpGlobals->curtime + 0.1, TW_THINK );
}
void CTeamTrainWatcher::StopCaptureAlarm( void )
{
if ( m_pAlarm )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pAlarm );
m_pAlarm = NULL;
m_flAlarmEndTime = -1.0f;
}
SetContextThink( NULL, 0, TW_ALARM_THINK );
}
void CTeamTrainWatcher::StartCaptureAlarm( CTeamControlPoint *pPoint )
{
StopCaptureAlarm();
if ( pPoint )
{
CReliableBroadcastRecipientFilter filter;
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
m_pAlarm = controller.SoundCreate( filter, pPoint->entindex(), CHAN_STATIC, TEAM_TRAIN_ALARM, ATTN_NORM );
controller.Play( m_pAlarm, 1.0, PITCH_NORM );
m_flAlarmEndTime = gpGlobals->curtime + MAX_ALARM_TIME_NO_RECEDE;
}
}
void CTeamTrainWatcher::PlayCaptureAlert( CTeamControlPoint *pPoint, bool bFinalPointInMap )
{
if ( !pPoint )
return;
if ( TeamplayRoundBasedRules() )
{
TeamplayRoundBasedRules()->PlayTrainCaptureAlert( pPoint, bFinalPointInMap );
}
}
ConVar tf_show_train_path( "tf_show_train_path", "0", FCVAR_CHEAT );
void CTeamTrainWatcher::WatcherThink( void )
{
if ( m_bWaitingToRecede )
{
if ( m_flRecedeTime < gpGlobals->curtime )
{
m_bWaitingToRecede = false;
// don't actually recede in overtime
if ( TeamplayRoundBasedRules() && !TeamplayRoundBasedRules()->InOvertime() )
{
// fire recede output
m_OnTrainStartRecede.FireOutput( this, this );
HandleTrainMovement( true );
}
}
}
bool bDisableAlarm = (TeamplayRoundBasedRules() && TeamplayRoundBasedRules()->State_Get() != GR_STATE_RND_RUNNING);
if ( bDisableAlarm )
{
StopCaptureAlarm();
}
// given its next node, we can walk the nodes and find the linear
// distance to the next cp node, or to the goal node
CFuncTrackTrain *pTrain = m_hTrain;
if ( pTrain )
{
int iOldTrainSpeedLevel = m_iTrainSpeedLevel;
// how fast is the train moving?
float flSpeed = pTrain->GetDesiredSpeed();
// divide speed into regions
// anything negative is -1
if ( flSpeed < 0 )
{
m_iTrainSpeedLevel = -1;
// even though our desired speed might be negative,
// our actual speed might be zero if we're at a dead end...
// this will turn off the < image when the train is done moving backwards
if ( pTrain->GetCurrentSpeed() == 0 )
{
m_iTrainSpeedLevel = 0;
}
}
else if ( flSpeed > m_flSpeedLevels[2] )
{
m_iTrainSpeedLevel = 3;
}
else if ( flSpeed > m_flSpeedLevels[1] )
{
m_iTrainSpeedLevel = 2;
}
else if ( flSpeed > m_flSpeedLevels[0] )
{
m_iTrainSpeedLevel = 1;
}
else
{
m_iTrainSpeedLevel = 0;
}
if ( m_iTrainSpeedLevel != iOldTrainSpeedLevel )
{
// make sure the sparks are off if we're not moving backwards anymore
if ( m_bHandleTrainMovement )
{
if ( m_iTrainSpeedLevel == 0 && iOldTrainSpeedLevel != 0 )
{
HandleSparks( false );
}
}
// play any concepts that we might need to play
if ( TeamplayRoundBasedRules() )
{
if ( m_iTrainSpeedLevel == 0 && iOldTrainSpeedLevel != 0 )
{
TeamplayRoundBasedRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_CART_STOP );
m_flNextSpeakForwardConceptTime = 0;
}
else if ( m_iTrainSpeedLevel < 0 && iOldTrainSpeedLevel == 0 )
{
TeamplayRoundBasedRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_CART_MOVING_BACKWARD );
m_flNextSpeakForwardConceptTime = 0;
}
}
}
if ( m_iTrainSpeedLevel > 0 && m_flNextSpeakForwardConceptTime < gpGlobals->curtime )
{
if ( m_hAreaCap.Get() )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
if ( m_hAreaCap->IsTouching( pPlayer ) )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_CART_MOVING_FORWARD );
}
}
}
}
m_flNextSpeakForwardConceptTime = gpGlobals->curtime + 3.0;
}
// what percent progress are we at?
CPathTrack *pNode = ( pTrain->m_ppath ) ? pTrain->m_ppath->GetNext() : NULL;
// if we're moving backwards, GetNext is going to be wrong
if ( flSpeed < 0 )
{
pNode = pTrain->m_ppath;
}
if ( pNode )
{
float flDistanceToGoal = 0;
// distance to next node
Vector vecDir = pNode->GetLocalOrigin() - pTrain->GetLocalOrigin();
flDistanceToGoal = vecDir.Length();
// distance of next node to goal node
if ( pNode && pNode != m_hGoalNode )
{
// walk this until we get to goal node, or a dead end
CPathTrack *pPrev = pNode;
pNode = pNode->GetNext();
while ( pNode )
{
vecDir = pNode->GetLocalOrigin() - pPrev->GetLocalOrigin();
flDistanceToGoal += vecDir.Length();
if ( pNode == m_hGoalNode )
break;
pPrev = pNode;
pNode = pNode->GetNext();
}
}
if ( m_flTotalPathDistance <= 0 )
{
Assert( !"No path distance in team_train_watcher\n" );
m_flTotalPathDistance = 1;
}
m_flTotalProgress = clamp( 1.0 - ( flDistanceToGoal / m_flTotalPathDistance ), 0.0, 1.0 );
float flLastDistanceFromStart = m_flTrainDistanceFromStart;
m_flTrainDistanceFromStart = m_flTotalPathDistance - flDistanceToGoal;
//engine->Con_NPrintf( 0, "%f", m_flTrainDistanceAccumulator );
const int nMinProgressToReport = 16; // 16 hammer units per foot
// Check if we've made forward progress.
if ( m_flTrainDistanceFromStart > flLastDistanceFromStart )
{
// Accumulate distance traveled
m_flTrainDistanceAccumulator += m_flTrainDistanceFromStart - flLastDistanceFromStart;
// If we're travelling forward and made enough progress to warrant firing an event
if ( m_iTrainSpeedLevel > 0 && m_flTrainDistanceAccumulator >= nMinProgressToReport )
{
m_flTrainDistanceAccumulator -= nMinProgressToReport;
// Fire an event for all the touching players
if ( m_hAreaCap.Get() )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
if ( m_hAreaCap->IsTouching( pPlayer ) )
{
IGameEvent *pEvent = gameeventmanager->CreateEvent( "payload_pushed" );
if ( pEvent )
{
pEvent->SetInt( "pusher", pPlayer->GetUserID() );
pEvent->SetInt( "distance", 1 );
gameeventmanager->FireEvent( pEvent, true );
}
}
}
}
}
}
}
// play alert sounds if necessary
for ( int iCount = 0 ; iCount < m_iNumCPLinks ; iCount++ )
{
if ( m_flTrainDistanceFromStart < m_CPLinks[iCount].flDistanceFromStart - TEAM_TRAIN_ALERT_DISTANCE )
{
// back up twice the alert distance before resetting our flag to play the warning again
if ( ( m_flTrainDistanceFromStart < m_CPLinks[iCount].flDistanceFromStart - ( TEAM_TRAIN_ALERT_DISTANCE * 2 ) ) || // has receded back twice the alert distance or...
( !m_bTrainCanRecede ) ) // used to catch the case where the train doesn't normally recede but has rolled back down a hill away from the CP
{
// reset our alert flag
m_CPLinks[iCount].bAlertPlayed = false;
}
}
else
{
if ( m_flTrainDistanceFromStart < m_CPLinks[iCount].flDistanceFromStart && !m_CPLinks[iCount].bAlertPlayed )
{
m_CPLinks[iCount].bAlertPlayed = true;
bool bFinalPointInMap = false;
CTeamControlPoint *pCurrentPoint = m_CPLinks[iCount].hCP.Get();
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
// if we're not playing mini-rounds
if ( !pMaster->PlayingMiniRounds() )
{
for ( int i = FIRST_GAME_TEAM ; i < MAX_CONTROL_POINT_TEAMS ; i++ )
{
if ( ObjectiveResource() && ObjectiveResource()->TeamCanCapPoint( pCurrentPoint->GetPointIndex(), i ) )
{
if ( pMaster->WouldNewCPOwnerWinGame( pCurrentPoint, i ) )
{
bFinalPointInMap = true;
}
}
}
}
else
{
// or this is the last round
if ( pMaster->NumPlayableControlPointRounds() == 1 )
{
CTeamControlPointRound *pRound = pMaster->GetCurrentRound();
if ( pRound )
{
for ( int i = FIRST_GAME_TEAM ; i < MAX_CONTROL_POINT_TEAMS ; i++ )
{
if ( ObjectiveResource() && ObjectiveResource()->TeamCanCapPoint( pCurrentPoint->GetPointIndex(), i ) )
{
if ( pRound->WouldNewCPOwnerWinGame( pCurrentPoint, i ) )
{
bFinalPointInMap = true;
}
}
}
}
}
}
}
PlayCaptureAlert( pCurrentPoint, bFinalPointInMap );
}
}
}
// check to see if we need to start or stop the alarm
if ( flDistanceToGoal <= TEAM_TRAIN_ALARM_DISTANCE )
{
if ( ObjectiveResource() )
{
ObjectiveResource()->SetTrackAlarm( GetTeamNumber(), true );
}
if ( !bDisableAlarm )
{
if ( !m_pAlarm )
{
if ( m_iNumCPLinks > 0 && !m_bAlarmPlayed )
{
// start the alarm at the final point
StartCaptureAlarm( m_CPLinks[m_iNumCPLinks-1].hCP.Get() );
m_bAlarmPlayed = true; // used to prevent the alarm from starting again on maps where the train doesn't recede (alarm loops for short time then only plays singles)
}
}
else
{
if ( !m_bTrainCanRecede ) // if the train won't recede, we only want to play the alarm for a short time
{
if ( m_flAlarmEndTime > 0 && m_flAlarmEndTime < gpGlobals->curtime )
{
StopCaptureAlarm();
SetContextThink( &CTeamTrainWatcher::WatcherAlarmThink, gpGlobals->curtime + TW_ALARM_THINK_INTERVAL, TW_ALARM_THINK );
}
}
}
}
}
else
{
if ( ObjectiveResource() )
{
ObjectiveResource()->SetTrackAlarm( GetTeamNumber(), false );
}
StopCaptureAlarm();
m_bAlarmPlayed = false;
}
}
if ( tf_show_train_path.GetBool() )
{
CPathTrack *nextNode = NULL;
CPathTrack *node = m_hStartNode;
CPathTrack::BeginIteration();
while( node )
{
node->Visit();
nextNode = node->GetNext();
if ( !nextNode || nextNode->HasBeenVisited() )
break;
NDebugOverlay::Line( node->GetAbsOrigin(), nextNode->GetAbsOrigin(), 255, 255, 0, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
node = nextNode;
}
CPathTrack::EndIteration();
// show segment of path train is actually on
node = pTrain->m_ppath;
if ( node && node->GetNext() )
{
NDebugOverlay::HorzArrow( node->GetAbsOrigin(), node->GetNext()->GetAbsOrigin(), 5.0f, 255, 0, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
}
}
}
SetContextThink( &CTeamTrainWatcher::WatcherThink, gpGlobals->curtime + 0.1, TW_THINK );
}
void CTeamTrainWatcher::WatcherAlarmThink( void )
{
CTeamControlPoint *pPoint = m_CPLinks[m_iNumCPLinks-1].hCP.Get();
if ( pPoint )
{
pPoint->EmitSound( TEAM_TRAIN_ALARM_SINGLE );
}
SetContextThink( &CTeamTrainWatcher::WatcherAlarmThink, gpGlobals->curtime + TW_ALARM_THINK_INTERVAL, TW_ALARM_THINK );
}
CBaseEntity *CTeamTrainWatcher::GetTrainEntity( void )
{
return m_hTrain.Get();
}
bool CTeamTrainWatcher::TimerMayExpire( void )
{
if ( IsDisabled() )
{
return true;
}
// Still in overtime if we're waiting to recede
if ( m_bWaitingToRecede )
return false;
// capture blocked so we're not receding, but game shouldn't end
if ( m_bCapBlocked )
return false;
// not waiting, so we're capping, in which case the area capture
// will not let us expire
return true;
}
// Project the given position onto the track and return the point and how far along that projected position is
void CTeamTrainWatcher::ProjectPointOntoPath( const Vector &pos, Vector *posOnPathResult, float *distanceAlongPathResult ) const
{
CPathTrack *nextNode = NULL;
CPathTrack *node = m_hStartNode;
Vector toPos;
Vector alongPath;
float distanceAlong = 0.0f;
Vector closestPointOnPath = vec3_origin;
float closestPerpendicularDistanceSq = FLT_MAX;
float closestDistanceAlongPath = FLT_MAX;
CPathTrack::BeginIteration();
while( node )
{
node->Visit();
nextNode = node->GetNext();
if ( !nextNode || nextNode->HasBeenVisited() )
break;
alongPath = nextNode->GetAbsOrigin() - node->GetAbsOrigin();
float segmentLength = alongPath.NormalizeInPlace();
toPos = pos - node->GetAbsOrigin();
float segmentOverlap = DotProduct( toPos, alongPath );
if ( segmentOverlap >= 0.0f && segmentOverlap < segmentLength )
{
// projection is within segment bounds
Vector onPath = node->GetAbsOrigin() + alongPath * segmentOverlap;
float perpendicularDistanceSq = ( onPath - pos ).LengthSqr();
if ( perpendicularDistanceSq < closestPerpendicularDistanceSq )
{
closestPointOnPath = onPath;
closestPerpendicularDistanceSq = perpendicularDistanceSq;
closestDistanceAlongPath = distanceAlong + segmentOverlap;
}
}
distanceAlong += segmentLength;
node = nextNode;
}
CPathTrack::EndIteration();
if ( posOnPathResult )
{
*posOnPathResult = closestPointOnPath;
}
if ( distanceAlongPathResult )
{
*distanceAlongPathResult = closestDistanceAlongPath;
}
}
// Return true if the given position is farther down the track than the train is
bool CTeamTrainWatcher::IsAheadOfTrain( const Vector &pos ) const
{
float distanceAlongPath;
ProjectPointOntoPath( pos, NULL, &distanceAlongPath );
return ( distanceAlongPath > m_flTrainDistanceFromStart );
}
// return true if the train is almost at the next checkpoint
bool CTeamTrainWatcher::IsTrainNearCheckpoint( void ) const
{
for( int i = 0; i < m_iNumCPLinks ; ++i )
{
if ( m_flTrainDistanceFromStart > m_CPLinks[i].flDistanceFromStart - TEAM_TRAIN_ALERT_DISTANCE &&
m_flTrainDistanceFromStart < m_CPLinks[i].flDistanceFromStart )
{
return true;
}
}
return false;
}
// return true if the train hasn't left its starting position yet
bool CTeamTrainWatcher::IsTrainAtStart( void ) const
{
return ( m_flTrainDistanceFromStart < TEAM_TRAIN_ALARM_DISTANCE );
}
// return world space location of next checkpoint along the path
Vector CTeamTrainWatcher::GetNextCheckpointPosition( void ) const
{
for( int i = 0; i < m_iNumCPLinks ; ++i )
{
if ( m_flTrainDistanceFromStart < m_CPLinks[i].flDistanceFromStart )
{
return m_CPLinks[i].hPathTrack->GetAbsOrigin();
}
}
Assert( !"No checkpoint found in team train watcher\n" );
return vec3_origin;
}
#if defined( STAGING_ONLY ) && defined( TF_DLL )
CON_COMMAND_F( tf_dumptrainstats, "Dump the stats for the current train watcher to the console", FCVAR_GAMEDLL )
{
// Listenserver host or rcon access only!
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
CTeamTrainWatcher *pWatcher = NULL;
while( ( pWatcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( pWatcher, "team_train_watcher" ) ) ) != NULL )
{
pWatcher->DumpStats();
}
}
void CTeamTrainWatcher::DumpStats( void )
{
float flLastPosition = 0.0f;
float flTotalDistance = 0.0f;
char szOutput[2048];
char szTemp[256];
V_strcpy_safe( szOutput, "\n\nTrain Watcher stats for team " );
V_strcat_safe( szOutput, ( GetTeamNumber() == TF_TEAM_RED ) ? "Red\n" : "Blue\n" );
for( int i = 0; i < m_iNumCPLinks ; ++i )
{
float flDistance = m_CPLinks[i].flDistanceFromStart - flLastPosition;
if ( i == 0 )
{
V_sprintf_safe( szTemp, "\tControl Point: %d\tDistance from start: %0.2f\n", i + 1, flDistance );
}
else
{
V_sprintf_safe( szTemp, "\tControl Point: %d\tDistance from previous point: %0.2f\n", i + 1, flDistance );
}
V_strcat_safe( szOutput, szTemp );
flTotalDistance += flDistance;
flLastPosition = m_CPLinks[i].flDistanceFromStart;
}
V_sprintf_safe( szTemp, "\tTotal Distance: %0.2f\n\n", flTotalDistance );
V_strcat_safe( szOutput, szTemp );
Msg( "%s", szOutput );
}
#endif // STAGING_ONLY && TF_DLL