Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2024-12-22 17:47:38 +08:00
Code
sdk2013
hl2sdk/game/server/trains.cpp
Nicholas Hastings e2781a0000 SDK sync.
2014-02-28 14:08:09 -05:00

3379 lines
87 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Spawn, think, and touch functions for trains, etc.
//
//=============================================================================//
#include "cbase.h"
#include "ai_basenpc.h"
#include "trains.h"
#include "ndebugoverlay.h"
#include "entitylist.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
#include "physics_npc_solver.h"
#include "vphysics/friction.h"
#include "hierarchy.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static void PlatSpawnInsideTrigger(edict_t *pevPlatform);
#define SF_PLAT_TOGGLE 0x0001
class CBasePlatTrain : public CBaseToggle
{
DECLARE_CLASS( CBasePlatTrain, CBaseToggle );
public:
~CBasePlatTrain();
bool KeyValue( const char *szKeyName, const char *szValue );
void Precache( void );
// This is done to fix spawn flag collisions between this class and a derived class
virtual bool IsTogglePlat( void ) { return (m_spawnflags & SF_PLAT_TOGGLE) ? true : false; }
DECLARE_DATADESC();
void PlayMovingSound();
void StopMovingSound();
string_t m_NoiseMoving; // sound a plat makes while moving
string_t m_NoiseArrived;
CSoundPatch *m_pMovementSound;
#ifdef HL1_DLL
int m_MoveSound;
int m_StopSound;
#endif
float m_volume; // Sound volume
float m_flTWidth;
float m_flTLength;
};
BEGIN_DATADESC( CBasePlatTrain )
DEFINE_KEYFIELD( m_NoiseMoving, FIELD_SOUNDNAME, "noise1" ),
DEFINE_KEYFIELD( m_NoiseArrived, FIELD_SOUNDNAME, "noise2" ),
#ifdef HL1_DLL
DEFINE_KEYFIELD( m_MoveSound, FIELD_INTEGER, "movesnd" ),
DEFINE_KEYFIELD( m_StopSound, FIELD_INTEGER, "stopsnd" ),
#endif
DEFINE_SOUNDPATCH( m_pMovementSound ),
DEFINE_KEYFIELD( m_volume, FIELD_FLOAT, "volume" ),
DEFINE_FIELD( m_flTWidth, FIELD_FLOAT ),
DEFINE_FIELD( m_flTLength, FIELD_FLOAT ),
DEFINE_KEYFIELD( m_flLip, FIELD_FLOAT, "lip" ),
DEFINE_KEYFIELD( m_flWait, FIELD_FLOAT, "wait" ),
DEFINE_KEYFIELD( m_flHeight, FIELD_FLOAT, "height" ),
END_DATADESC()
bool CBasePlatTrain::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "rotation"))
{
m_vecFinalAngle.x = atof(szValue);
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
CBasePlatTrain::~CBasePlatTrain()
{
StopMovingSound();
}
void CBasePlatTrain::PlayMovingSound()
{
StopMovingSound();
if(m_NoiseMoving != NULL_STRING )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CPASAttenuationFilter filter( this );
m_pMovementSound = controller.SoundCreate( filter, entindex(), CHAN_STATIC, STRING(m_NoiseMoving), ATTN_NORM );
controller.Play( m_pMovementSound, m_volume, PITCH_NORM );
}
}
void CBasePlatTrain::StopMovingSound()
{
if ( m_pMovementSound )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pMovementSound );
m_pMovementSound = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlatTrain::Precache( void )
{
//Fill in a default value if necessary
UTIL_ValidateSoundName( m_NoiseMoving, "Plat.DefaultMoving" );
UTIL_ValidateSoundName( m_NoiseArrived, "Plat.DefaultArrive" );
#ifdef HL1_DLL
// set the plat's "in-motion" sound
switch (m_MoveSound)
{
default:
case 0:
m_NoiseMoving = MAKE_STRING( "Plat.DefaultMoving" );
break;
case 1:
m_NoiseMoving = MAKE_STRING("Plat.BigElev1");
break;
case 2:
m_NoiseMoving = MAKE_STRING("Plat.BigElev2");
break;
case 3:
m_NoiseMoving = MAKE_STRING("Plat.TechElev1");
break;
case 4:
m_NoiseMoving = MAKE_STRING("Plat.TechElev2");
break;
case 5:
m_NoiseMoving = MAKE_STRING("Plat.TechElev3");
break;
case 6:
m_NoiseMoving = MAKE_STRING("Plat.FreightElev1");
break;
case 7:
m_NoiseMoving = MAKE_STRING("Plat.FreightElev2");
break;
case 8:
m_NoiseMoving = MAKE_STRING("Plat.HeavyElev");
break;
case 9:
m_NoiseMoving = MAKE_STRING("Plat.RackElev");
break;
case 10:
m_NoiseMoving = MAKE_STRING("Plat.RailElev");
break;
case 11:
m_NoiseMoving = MAKE_STRING("Plat.SqueakElev");
break;
case 12:
m_NoiseMoving = MAKE_STRING("Plat.OddElev1");
break;
case 13:
m_NoiseMoving = MAKE_STRING("Plat.OddElev2");
break;
}
// set the plat's 'reached destination' stop sound
switch (m_StopSound)
{
default:
case 0:
m_NoiseArrived = MAKE_STRING( "Plat.DefaultArrive" );
break;
case 1:
m_NoiseArrived = MAKE_STRING("Plat.BigElevStop1");
break;
case 2:
m_NoiseArrived = MAKE_STRING("Plat.BigElevStop2");
break;
case 3:
m_NoiseArrived = MAKE_STRING("Plat.FreightElevStop");
break;
case 4:
m_NoiseArrived = MAKE_STRING("Plat.HeavyElevStop");
break;
case 5:
m_NoiseArrived = MAKE_STRING("Plat.RackStop");
break;
case 6:
m_NoiseArrived = MAKE_STRING("Plat.RailStop");
break;
case 7:
m_NoiseArrived = MAKE_STRING("Plat.SqueakStop");
break;
case 8:
m_NoiseArrived = MAKE_STRING("Plat.QuickStop");
break;
}
#endif // HL1_DLL
//Precache them all
PrecacheScriptSound( (char *) STRING(m_NoiseMoving) );
PrecacheScriptSound( (char *) STRING(m_NoiseArrived) );
}
class CFuncPlat : public CBasePlatTrain
{
DECLARE_CLASS( CFuncPlat, CBasePlatTrain );
public:
void Spawn( void );
void Precache( void );
bool CreateVPhysics();
void Setup( void );
virtual void Blocked( CBaseEntity *pOther );
void PlatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void CallGoDown( void ) { GoDown(); }
void CallHitTop( void ) { HitTop(); }
void CallHitBottom( void ) { HitBottom(); }
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
void InputToggle(inputdata_t &data);
void InputGoUp(inputdata_t &data);
void InputGoDown(inputdata_t &data);
DECLARE_DATADESC();
private:
string_t m_sNoise;
};
BEGIN_DATADESC( CFuncPlat )
DEFINE_FIELD( m_sNoise, FIELD_STRING ),
// Function Pointers
DEFINE_FUNCTION( PlatUse ),
DEFINE_FUNCTION( CallGoDown ),
DEFINE_FUNCTION( CallHitTop ),
DEFINE_FUNCTION( CallHitBottom ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_VOID, "GoUp", InputGoUp ),
DEFINE_INPUTFUNC( FIELD_VOID, "GoDown", InputGoDown ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_plat, CFuncPlat );
//==================================================
// CPlatTrigger
//==================================================
class CPlatTrigger : public CBaseEntity
{
DECLARE_CLASS( CPlatTrigger, CBaseEntity );
public:
virtual int ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_DONT_SAVE; }
void SpawnInsideTrigger( CFuncPlat *pPlatform );
void Touch( CBaseEntity *pOther );
CFuncPlat *m_pPlatform;
};
void CFuncPlat::Setup( void )
{
if (m_flTLength == 0)
{
m_flTLength = 80;
}
if (m_flTWidth == 0)
{
m_flTWidth = 10;
}
SetLocalAngles( vec3_angle );
SetSolid( SOLID_BSP );
SetMoveType( MOVETYPE_PUSH );
// Set size and link into world
SetModel( STRING( GetModelName() ) );
m_vecPosition1 = GetLocalOrigin(); //Top
m_vecPosition2 = GetLocalOrigin(); //Bottom
if ( m_flHeight != 0 )
{
m_vecPosition2.z = GetLocalOrigin().z - m_flHeight;
}
else
{
// NOTE: This works because the angles were set to vec3_angle above
m_vecPosition2.z = GetLocalOrigin().z - CollisionProp()->OBBSize().z + 8;
}
if (m_flSpeed == 0)
{
m_flSpeed = 150;
}
if ( m_volume == 0.0f )
{
m_volume = 0.85f;
}
}
void CFuncPlat::Precache( )
{
BaseClass::Precache();
if ( IsTogglePlat() == false )
{
// Create the "start moving" trigger
PlatSpawnInsideTrigger( edict() );
}
}
void CFuncPlat::Spawn( )
{
Setup();
Precache();
// If this platform is the target of some button, it starts at the TOP position,
// and is brought down by that button. Otherwise, it starts at BOTTOM.
if ( GetEntityName() != NULL_STRING )
{
UTIL_SetOrigin( this, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
SetUse( &CFuncPlat::PlatUse );
}
else
{
UTIL_SetOrigin( this, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
}
CreateVPhysics();
}
bool CFuncPlat::CreateVPhysics()
{
VPhysicsInitShadow( false, false );
return true;
}
static void PlatSpawnInsideTrigger(edict_t* pevPlatform)
{
// old code: //GetClassPtr( (CPlatTrigger *)NULL)->SpawnInsideTrigger( GetClassPtr( (CFuncPlat *)pevPlatform ) );
CPlatTrigger *plattrig = CREATE_UNSAVED_ENTITY( CPlatTrigger, "plat_trigger" );
plattrig->SpawnInsideTrigger( (CFuncPlat *)GetContainingEntity( pevPlatform ) );
}
//
// Create a trigger entity for a platform.
//
void CPlatTrigger::SpawnInsideTrigger( CFuncPlat *pPlatform )
{
m_pPlatform = pPlatform;
// Create trigger entity, "point" it at the owning platform, give it a touch method
SetSolid( SOLID_BSP );
AddSolidFlags( FSOLID_TRIGGER );
SetMoveType( MOVETYPE_NONE );
SetLocalOrigin( pPlatform->GetLocalOrigin() );
// Establish the trigger field's size
CCollisionProperty *pCollision = m_pPlatform->CollisionProp();
Vector vecTMin = pCollision->OBBMins() + Vector ( 25 , 25 , 0 );
Vector vecTMax = pCollision->OBBMaxs() + Vector ( 25 , 25 , 8 );
vecTMin.z = vecTMax.z - ( m_pPlatform->m_vecPosition1.z - m_pPlatform->m_vecPosition2.z + 8 );
if ( pCollision->OBBSize().x <= 50 )
{
vecTMin.x = (pCollision->OBBMins().x + pCollision->OBBMaxs().x) / 2;
vecTMax.x = vecTMin.x + 1;
}
if ( pCollision->OBBSize().y <= 50 )
{
vecTMin.y = (pCollision->OBBMins().y + pCollision->OBBMaxs().y) / 2;
vecTMax.y = vecTMin.y + 1;
}
UTIL_SetSize ( this, vecTMin, vecTMax );
}
//
// When the platform's trigger field is touched, the platform ???
//
void CPlatTrigger::Touch( CBaseEntity *pOther )
{
// Ignore touches by non-players
if ( !pOther->IsPlayer() )
return;
// Ignore touches by corpses
if (!pOther->IsAlive())
return;
// Make linked platform go up/down.
if (m_pPlatform->m_toggle_state == TS_AT_BOTTOM)
m_pPlatform->GoUp();
else if (m_pPlatform->m_toggle_state == TS_AT_TOP)
m_pPlatform->SetMoveDoneTime( 1 );// delay going down
}
//-----------------------------------------------------------------------------
// Purpose: Used when a platform is the target of a button.
// Start bringing platform down.
// Input : pActivator -
// pCaller -
// useType -
// value -
//-----------------------------------------------------------------------------
void CFuncPlat::InputToggle(inputdata_t &data)
{
if ( IsTogglePlat() )
{
if (m_toggle_state == TS_AT_TOP)
GoDown();
else if ( m_toggle_state == TS_AT_BOTTOM )
GoUp();
}
else
{
SetUse( NULL );
if (m_toggle_state == TS_AT_TOP)
GoDown();
}
}
void CFuncPlat::InputGoUp(inputdata_t &data)
{
if ( m_toggle_state == TS_AT_BOTTOM )
GoUp();
}
void CFuncPlat::InputGoDown(inputdata_t &data)
{
if ( m_toggle_state == TS_AT_TOP )
GoDown();
}
//-----------------------------------------------------------------------------
// Purpose: Used when a platform is the target of a button.
// Start bringing platform down.
// Input : pActivator -
// pCaller -
// useType -
// value -
//-----------------------------------------------------------------------------
void CFuncPlat::PlatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( IsTogglePlat() )
{
// Top is off, bottom is on
bool on = (m_toggle_state == TS_AT_BOTTOM) ? true : false;
if ( !ShouldToggle( useType, on ) )
return;
if (m_toggle_state == TS_AT_TOP)
GoDown();
else if ( m_toggle_state == TS_AT_BOTTOM )
GoUp();
}
else
{
SetUse( NULL );
if (m_toggle_state == TS_AT_TOP)
GoDown();
}
}
//
// Platform is at top, now starts moving down.
//
void CFuncPlat::GoDown( void )
{
PlayMovingSound();
ASSERT(m_toggle_state == TS_AT_TOP || m_toggle_state == TS_GOING_UP);
m_toggle_state = TS_GOING_DOWN;
SetMoveDone(&CFuncPlat::CallHitBottom);
LinearMove(m_vecPosition2, m_flSpeed);
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlat::HitBottom( void )
{
StopMovingSound();
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_WEAPON;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
ASSERT(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM;
}
//
// Platform is at bottom, now starts moving up
//
void CFuncPlat::GoUp( void )
{
PlayMovingSound();
ASSERT(m_toggle_state == TS_AT_BOTTOM || m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_GOING_UP;
SetMoveDone(&CFuncPlat::CallHitTop);
LinearMove(m_vecPosition1, m_flSpeed);
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlat::HitTop( void )
{
StopMovingSound();
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_WEAPON;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
ASSERT(m_toggle_state == TS_GOING_UP);
m_toggle_state = TS_AT_TOP;
if ( !IsTogglePlat() )
{
// After a delay, the platform will automatically start going down again.
SetMoveDone( &CFuncPlat::CallGoDown );
SetMoveDoneTime( 3 );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when we are blocked.
//-----------------------------------------------------------------------------
void CFuncPlat::Blocked( CBaseEntity *pOther )
{
DevMsg( 2, "%s Blocked by %s\n", GetClassname(), pOther->GetClassname() );
// Hurt the blocker a little
pOther->TakeDamage( CTakeDamageInfo( this, this, 1, DMG_CRUSH ) );
if (m_sNoise != NULL_STRING)
{
StopSound(entindex(), CHAN_STATIC, (char*)STRING(m_sNoise));
}
// Send the platform back where it came from
ASSERT(m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN);
if (m_toggle_state == TS_GOING_UP)
{
GoDown();
}
else if (m_toggle_state == TS_GOING_DOWN)
{
GoUp ();
}
}
class CFuncPlatRot : public CFuncPlat
{
DECLARE_CLASS( CFuncPlatRot, CFuncPlat );
public:
void Spawn( void );
void SetupRotation( void );
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
void RotMove( QAngle &destAngle, float time );
DECLARE_DATADESC();
QAngle m_end, m_start;
};
LINK_ENTITY_TO_CLASS( func_platrot, CFuncPlatRot );
BEGIN_DATADESC( CFuncPlatRot )
DEFINE_FIELD( m_end, FIELD_VECTOR ),
DEFINE_FIELD( m_start, FIELD_VECTOR ),
END_DATADESC()
void CFuncPlatRot::SetupRotation( void )
{
if ( m_vecFinalAngle.x != 0 ) // This plat rotates too!
{
CBaseToggle::AxisDir();
m_start = GetLocalAngles();
m_end = GetLocalAngles() + m_vecMoveAng * m_vecFinalAngle.x;
}
else
{
m_start = vec3_angle;
m_end = vec3_angle;
}
if ( GetEntityName() != NULL_STRING ) // Start at top
{
SetLocalAngles( m_end );
}
}
void CFuncPlatRot::Spawn( void )
{
BaseClass::Spawn();
SetupRotation();
}
void CFuncPlatRot::GoDown( void )
{
BaseClass::GoDown();
RotMove( m_start, GetMoveDoneTime() );
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlatRot::HitBottom( void )
{
BaseClass::HitBottom();
SetLocalAngularVelocity( vec3_angle );
SetLocalAngles( m_start );
}
//
// Platform is at bottom, now starts moving up
//
void CFuncPlatRot::GoUp( void )
{
BaseClass::GoUp();
RotMove( m_end, GetMoveDoneTime() );
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlatRot::HitTop( void )
{
BaseClass::HitTop();
SetLocalAngularVelocity( vec3_angle );
SetLocalAngles( m_end );
}
void CFuncPlatRot::RotMove( QAngle &destAngle, float time )
{
// set destdelta to the vector needed to move
QAngle vecDestDelta = destAngle - GetLocalAngles();
// Travel time is so short, we're practically there already; so make it so.
if ( time >= 0.1)
SetLocalAngularVelocity( vecDestDelta * (1.0 / time) );
else
{
SetLocalAngularVelocity( vecDestDelta );
SetMoveDoneTime( 1 );
}
}
class CFuncTrain : public CBasePlatTrain
{
DECLARE_CLASS( CFuncTrain, CBasePlatTrain );
public:
void Spawn( void );
void Precache( void );
void Activate( void );
void OnRestore( void );
void SetupTarget( void );
void Blocked( CBaseEntity *pOther );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void Wait( void );
void Next( void );
//Inputs
void InputToggle(inputdata_t &data);
void InputStart(inputdata_t &data);
void InputStop(inputdata_t &data);
void Start( void );
void Stop( void );
DECLARE_DATADESC();
public:
EHANDLE m_hCurrentTarget;
bool m_activated;
EHANDLE m_hEnemy;
float m_flBlockDamage; // Damage to inflict when blocked.
float m_flNextBlockTime;
string_t m_iszLastTarget;
};
LINK_ENTITY_TO_CLASS( func_train, CFuncTrain );
BEGIN_DATADESC( CFuncTrain )
DEFINE_FIELD( m_hCurrentTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_activated, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hEnemy, FIELD_EHANDLE ),
DEFINE_FIELD( m_iszLastTarget, FIELD_STRING ),
DEFINE_FIELD( m_flNextBlockTime, FIELD_TIME ),
DEFINE_KEYFIELD( m_flBlockDamage, FIELD_FLOAT, "dmg" ),
// Function Pointers
DEFINE_FUNCTION( Wait ),
DEFINE_FUNCTION( Next ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_VOID, "Start", InputStart ),
DEFINE_INPUTFUNC( FIELD_VOID, "Stop", InputStop ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Handles a train being blocked by an entity.
// Input : pOther - What was hit.
//-----------------------------------------------------------------------------
void CFuncTrain::Blocked( CBaseEntity *pOther )
{
if ( gpGlobals->curtime < m_flNextBlockTime )
return;
m_flNextBlockTime = gpGlobals->curtime + 0.5;
//Inflict damage
pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );
}
void CFuncTrain::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
//If we've been waiting to be retriggered, move to the next destination
if ( m_spawnflags & SF_TRAIN_WAIT_RETRIGGER )
{
// Move toward my target
m_spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
Next();
}
else
{
m_spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
// Pop back to last target if it's available
if ( m_hEnemy )
{
m_target = m_hEnemy->GetEntityName();
}
SetNextThink( TICK_NEVER_THINK );
SetLocalVelocity( vec3_origin );
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
}
}
void CFuncTrain::Wait( void )
{
//If we're moving passed a path track, then trip its output
variant_t emptyVariant;
m_hCurrentTarget->AcceptInput( "InPass", this, this, emptyVariant, 0 );
// need pointer to LAST target.
if ( m_hCurrentTarget->HasSpawnFlags( SF_TRAIN_WAIT_RETRIGGER ) || HasSpawnFlags( SF_TRAIN_WAIT_RETRIGGER ) )
{
AddSpawnFlags( SF_TRAIN_WAIT_RETRIGGER );
// Clear the sound channel.
StopMovingSound();
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
SetMoveDoneTime( -1 );
return;
}
//NOTENOTE: -1 wait will wait forever
if ( m_flWait != 0 )
{
SetMoveDoneTime( m_flWait );
StopMovingSound();
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
SetMoveDone( &CFuncTrain::Next );
}
else
{
// Do it right now
Next();
}
}
//-----------------------------------------------------------------------------
// Purpose: Advances the train to the next path corner on the path.
//-----------------------------------------------------------------------------
void CFuncTrain::Next( void )
{
//Find our next target
CBaseEntity *pTarg = GetNextTarget();
//If none, we're done
if ( pTarg == NULL )
{
//Stop the moving sound
StopMovingSound();
// Play stop sound
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
return;
}
// Save last target in case we need to find it again
m_iszLastTarget = m_target;
m_target = pTarg->m_target;
m_flWait = pTarg->GetDelay();
// If our target has a speed, take it
if ( m_hCurrentTarget && m_hCurrentTarget->m_flSpeed != 0 )
{
m_flSpeed = m_hCurrentTarget->m_flSpeed;
DevMsg( 2, "Train %s speed to %4.2f\n", GetDebugName(), m_flSpeed );
}
// Keep track of this since path corners change our target for us
m_hCurrentTarget = pTarg;
m_hEnemy = pTarg;
//Check for teleport
if ( m_hCurrentTarget->HasSpawnFlags( SF_CORNER_TELEPORT ) )
{
IncrementInterpolationFrame();
// This is supposed to place the center of the func_train at the target's origin.
// FIXME: This is totally busted! It's using the wrong space for the computation...
UTIL_SetOrigin( this, pTarg->GetLocalOrigin() - CollisionProp()->OBBCenter() );
// Get on with doing the next path corner.
Wait();
}
else
{
// Normal linear move
PlayMovingSound();
SetMoveDone( &CFuncTrain::Wait );
// This is supposed to place the center of the func_train at the target's origin.
// FIXME: This is totally busted! It's using the wrong space for the computation...
LinearMove ( pTarg->GetLocalOrigin() - CollisionProp()->OBBCenter(), m_flSpeed );
}
}
//-----------------------------------------------------------------------------
// Purpose: Called after all the entities spawn.
//-----------------------------------------------------------------------------
void CFuncTrain::Activate( void )
{
BaseClass::Activate();
// Not yet active, so teleport to first target
if ( m_activated == false )
{
SetupTarget();
m_activated = true;
if ( m_hCurrentTarget.Get() == NULL )
return;
// This is supposed to place the center of the func_train at the target's origin.
// FIXME: This is totally busted! It's using the wrong space for the computation...
UTIL_SetOrigin( this, m_hCurrentTarget->GetLocalOrigin() - CollisionProp()->OBBCenter() );
if ( GetSolid() == SOLID_BSP )
{
VPhysicsInitShadow( false, false );
}
// Start immediately if not triggered
if ( !GetEntityName() )
{
SetMoveDoneTime( 0.1 );
SetMoveDone( &CFuncTrain::Next );
}
else
{
m_spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrain::SetupTarget( void )
{
// Find our target whenever we don't have one (level transition)
if ( !m_hCurrentTarget )
{
CBaseEntity *pTarg = gEntList.FindEntityByName( NULL, m_target );
if ( pTarg == NULL )
{
Msg( "Can't find target of train %s\n", STRING(m_target) );
return;
}
// Keep track of this since path corners change our target for us
m_target = pTarg->m_target;
m_hCurrentTarget = pTarg;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrain::Spawn( void )
{
Precache();
if ( m_flSpeed == 0 )
{
m_flSpeed = 100;
}
if ( !m_target )
{
Warning("FuncTrain '%s' has no target.\n", GetDebugName());
}
if ( m_flBlockDamage == 0 )
{
m_flBlockDamage = 2;
}
SetMoveType( MOVETYPE_PUSH );
SetSolid( SOLID_BSP );
SetModel( STRING( GetModelName() ) );
if ( m_spawnflags & SF_TRACKTRAIN_PASSABLE )
{
AddSolidFlags( FSOLID_NOT_SOLID );
}
m_activated = false;
if ( m_volume == 0.0f )
{
m_volume = 0.85f;
}
}
void CFuncTrain::Precache( void )
{
BaseClass::Precache();
}
void CFuncTrain::OnRestore( void )
{
BaseClass::OnRestore();
// Are we moving?
if ( IsMoving() )
{
// Continue moving to the same target
m_target = m_iszLastTarget;
}
SetupTarget();
}
void CFuncTrain::InputToggle( inputdata_t &data )
{
//If we've been waiting to be retriggered, move to the next destination
if( HasSpawnFlags( SF_TRAIN_WAIT_RETRIGGER ) )
{
Start();
}
else
{
Stop();
}
}
void CFuncTrain::InputStart( inputdata_t &data )
{
Start();
}
void CFuncTrain::InputStop( inputdata_t &data )
{
Stop();
}
void CFuncTrain::Start( void )
{
//start moving
if( HasSpawnFlags( SF_TRAIN_WAIT_RETRIGGER ) )
{
// Move toward my target
RemoveSpawnFlags( SF_TRAIN_WAIT_RETRIGGER );
Next();
}
}
void CFuncTrain::Stop( void )
{
//stop moving
if( !HasSpawnFlags( SF_TRAIN_WAIT_RETRIGGER ) )
{
AddSpawnFlags( SF_TRAIN_WAIT_RETRIGGER );
// Pop back to last target if it's available
if ( m_hEnemy )
{
m_target = m_hEnemy->GetEntityName();
}
SetNextThink( TICK_NEVER_THINK );
SetAbsVelocity( vec3_origin );
if ( m_NoiseArrived != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = STRING(m_NoiseArrived);
ep.m_flVolume = m_volume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
//Do not teleport to our final move destination
SetMoveDone( NULL );
SetMoveDoneTime( -1 );
}
}
BEGIN_DATADESC( CFuncTrackTrain )
DEFINE_KEYFIELD( m_length, FIELD_FLOAT, "wheels" ),
DEFINE_KEYFIELD( m_height, FIELD_FLOAT, "height" ),
DEFINE_KEYFIELD( m_maxSpeed, FIELD_FLOAT, "startspeed" ),
DEFINE_KEYFIELD( m_flBank, FIELD_FLOAT, "bank" ),
DEFINE_KEYFIELD( m_flBlockDamage, FIELD_FLOAT, "dmg" ),
DEFINE_KEYFIELD( m_iszSoundMove, FIELD_SOUNDNAME, "MoveSound" ),
DEFINE_KEYFIELD( m_iszSoundMovePing, FIELD_SOUNDNAME, "MovePingSound" ),
DEFINE_KEYFIELD( m_iszSoundStart, FIELD_SOUNDNAME, "StartSound" ),
DEFINE_KEYFIELD( m_iszSoundStop, FIELD_SOUNDNAME, "StopSound" ),
DEFINE_KEYFIELD( m_nMoveSoundMinPitch, FIELD_INTEGER, "MoveSoundMinPitch" ),
DEFINE_KEYFIELD( m_nMoveSoundMaxPitch, FIELD_INTEGER, "MoveSoundMaxPitch" ),
DEFINE_KEYFIELD( m_flMoveSoundMinTime, FIELD_FLOAT, "MoveSoundMinTime" ),
DEFINE_KEYFIELD( m_flMoveSoundMaxTime, FIELD_FLOAT, "MoveSoundMaxTime" ),
DEFINE_FIELD( m_flNextMoveSoundTime, FIELD_TIME ),
DEFINE_KEYFIELD( m_eVelocityType, FIELD_INTEGER, "velocitytype" ),
DEFINE_KEYFIELD( m_eOrientationType, FIELD_INTEGER, "orientationtype" ),
DEFINE_FIELD( m_ppath, FIELD_CLASSPTR ),
DEFINE_FIELD( m_dir, FIELD_FLOAT ),
DEFINE_FIELD( m_controlMins, FIELD_VECTOR ),
DEFINE_FIELD( m_controlMaxs, FIELD_VECTOR ),
DEFINE_FIELD( m_flVolume, FIELD_FLOAT ),
DEFINE_FIELD( m_oldSpeed, FIELD_FLOAT ),
//DEFINE_FIELD( m_lastBlockPos, FIELD_POSITION_VECTOR ), // temp values for blocking, don't save
//DEFINE_FIELD( m_lastBlockTick, FIELD_INTEGER ),
DEFINE_FIELD( m_bSoundPlaying, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_bManualSpeedChanges, FIELD_BOOLEAN, "ManualSpeedChanges" ),
DEFINE_KEYFIELD( m_flAccelSpeed, FIELD_FLOAT, "ManualAccelSpeed" ),
DEFINE_KEYFIELD( m_flDecelSpeed, FIELD_FLOAT, "ManualDecelSpeed" ),
#ifdef HL1_DLL
DEFINE_FIELD( m_bOnTrackChange, FIELD_BOOLEAN ),
#endif
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Stop", InputStop ),
DEFINE_INPUTFUNC( FIELD_VOID, "StartForward", InputStartForward ),
DEFINE_INPUTFUNC( FIELD_VOID, "StartBackward", InputStartBackward ),
DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),
DEFINE_INPUTFUNC( FIELD_VOID, "Resume", InputResume ),
DEFINE_INPUTFUNC( FIELD_VOID, "Reverse", InputReverse ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeed", InputSetSpeed ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeedDir", InputSetSpeedDir ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeedReal", InputSetSpeedReal ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeedDirAccel", InputSetSpeedDirAccel ),
DEFINE_INPUTFUNC( FIELD_STRING, "TeleportToPathTrack", InputTeleportToPathTrack ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeedForwardModifier", InputSetSpeedForwardModifier ),
// Outputs
DEFINE_OUTPUT( m_OnStart, "OnStart" ),
DEFINE_OUTPUT( m_OnNext, "OnNextPoint" ),
// Function Pointers
DEFINE_FUNCTION( Next ),
DEFINE_FUNCTION( Find ),
DEFINE_FUNCTION( NearestPath ),
DEFINE_FUNCTION( DeadEnd ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_tracktrain, CFuncTrackTrain );
//-----------------------------------------------------------------------------
// Datatable
//-----------------------------------------------------------------------------
IMPLEMENT_SERVERCLASS_ST( CFuncTrackTrain, DT_FuncTrackTrain )
END_SEND_TABLE()
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CFuncTrackTrain::CFuncTrackTrain()
{
#ifdef _DEBUG
m_controlMins.Init();
m_controlMaxs.Init();
#endif
// These defaults match old func_tracktrains. Changing these defaults would
// require a vmf_tweak of older content to keep it from breaking.
m_eOrientationType = TrainOrientation_AtPathTracks;
m_eVelocityType = TrainVelocity_Instantaneous;
m_lastBlockPos.Init();
m_lastBlockTick = gpGlobals->tickcount;
m_flSpeedForwardModifier = 1.0f;
m_flUnmodifiedDesiredSpeed = 0.0f;
m_bDamageChild = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CFuncTrackTrain::DrawDebugTextOverlays( void )
{
int nOffset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
Q_snprintf( tempstr,sizeof(tempstr), "angles: %g %g %g", (double)GetLocalAngles()[PITCH], (double)GetLocalAngles()[YAW], (double)GetLocalAngles()[ROLL] );
EntityText( nOffset, tempstr, 0 );
nOffset++;
float flCurSpeed = GetLocalVelocity().Length();
Q_snprintf( tempstr,sizeof(tempstr), "current speed (goal): %g (%g)", (double)flCurSpeed, (double)m_flSpeed );
EntityText( nOffset, tempstr, 0 );
nOffset++;
Q_snprintf( tempstr,sizeof(tempstr), "max speed: %g", (double)m_maxSpeed );
EntityText( nOffset, tempstr, 0 );
nOffset++;
}
return nOffset;
}
void CFuncTrackTrain::DrawDebugGeometryOverlays()
{
BaseClass::DrawDebugGeometryOverlays();
if (m_debugOverlays & OVERLAY_BBOX_BIT)
{
NDebugOverlay::Box( GetAbsOrigin(), -Vector(4,4,4),Vector(4,4,4), 255, 0, 255, 0, 0);
Vector out;
VectorTransform( Vector(m_length,0,0), EntityToWorldTransform(), out );
NDebugOverlay::Box( out, -Vector(4,4,4),Vector(4,4,4), 255, 0, 255, 0, 0);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CFuncTrackTrain::KeyValue( const char *szKeyName, const char *szValue )
{
if (FStrEq(szKeyName, "volume"))
{
m_flVolume = (float) (atoi(szValue));
m_flVolume *= 0.1f;
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that stops the train.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputStop( inputdata_t &inputdata )
{
Stop();
}
//------------------------------------------------------------------------------
// Purpose: Input handler that starts the train moving.
//------------------------------------------------------------------------------
void CFuncTrackTrain::InputResume( inputdata_t &inputdata )
{
m_flSpeed = m_oldSpeed;
Start();
}
//------------------------------------------------------------------------------
// Purpose: Input handler that reverses the trains current direction of motion.
//------------------------------------------------------------------------------
void CFuncTrackTrain::InputReverse( inputdata_t &inputdata )
{
SetDirForward( !IsDirForward() );
SetSpeed( m_flSpeed );
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether we are travelling forward along our path.
//-----------------------------------------------------------------------------
bool CFuncTrackTrain::IsDirForward()
{
return ( m_dir == 1 );
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether we go forward or backward along our path.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SetDirForward( bool bForward )
{
if ( bForward && ( m_dir != 1 ) )
{
// Reverse direction.
if ( m_ppath && m_ppath->GetPrevious() )
{
m_ppath = m_ppath->GetPrevious();
}
m_dir = 1;
}
else if ( !bForward && ( m_dir != -1 ) )
{
// Reverse direction.
if ( m_ppath && m_ppath->GetNext() )
{
m_ppath = m_ppath->GetNext();
}
m_dir = -1;
}
}
//------------------------------------------------------------------------------
// Purpose: Input handler that starts the train moving.
//------------------------------------------------------------------------------
void CFuncTrackTrain::InputStartForward( inputdata_t &inputdata )
{
SetDirForward( true );
SetSpeed( m_maxSpeed );
}
//------------------------------------------------------------------------------
// Purpose: Input handler that starts the train moving.
//------------------------------------------------------------------------------
void CFuncTrackTrain::InputStartBackward( inputdata_t &inputdata )
{
SetDirForward( false );
SetSpeed( m_maxSpeed );
}
//------------------------------------------------------------------------------
// Purpose: Starts the train moving.
//------------------------------------------------------------------------------
void CFuncTrackTrain::Start( void )
{
m_OnStart.FireOutput(this,this);
Next();
}
//-----------------------------------------------------------------------------
// Purpose: Toggles the train between moving and not moving.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputToggle( inputdata_t &inputdata )
{
if ( m_flSpeed == 0 )
{
SetSpeed( m_maxSpeed );
}
else
{
SetSpeed( 0 );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles player use so players can control the speed of the train.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// player +USE
if ( useType == USE_SET )
{
float delta = value;
delta = ((int)(m_flSpeed * 4) / (int)m_maxSpeed)*0.25 + 0.25 * delta;
if ( delta > 1 )
delta = 1;
else if ( delta < -0.25 )
delta = -0.25;
if ( m_spawnflags & SF_TRACKTRAIN_FORWARDONLY )
{
if ( delta < 0 )
delta = 0;
}
SetDirForward( delta >= 0 );
delta = fabs(delta);
SetSpeed( m_maxSpeed * delta );
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that sets the speed of the train.
// Input : Float speed from 0 to max speed, in units per second.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputSetSpeedReal( inputdata_t &inputdata )
{
SetSpeed( clamp( inputdata.value.Float(), 0.f, m_maxSpeed ) );
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that sets the speed of the train.
// Input : Float speed scale from 0 to 1.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputSetSpeed( inputdata_t &inputdata )
{
float flScale = clamp( inputdata.value.Float(), 0.f, 1.f );
SetSpeed( m_maxSpeed * flScale );
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that sets the speed of the train and the direction
// based on the sign of the speed.
// Input : Float speed scale from -1 to 1. Negatives values indicate a reversed
// direction.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputSetSpeedDir( inputdata_t &inputdata )
{
float newSpeed = inputdata.value.Float();
SetDirForward( newSpeed >= 0 );
newSpeed = fabs(newSpeed);
float flScale = clamp( newSpeed, 0.f, 1.f );
SetSpeed( m_maxSpeed * flScale );
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that sets the speed of the train and the direction
// based on the sign of the speed, and accels/decels to that speed
// Input : Float speed scale from -1 to 1. Negatives values indicate a reversed
// direction.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputSetSpeedDirAccel( inputdata_t &inputdata )
{
SetSpeedDirAccel( inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SetSpeedDirAccel( float flNewSpeed )
{
float newSpeed = flNewSpeed;
SetDirForward( newSpeed >= 0 );
newSpeed = fabs( newSpeed );
float flScale = clamp( newSpeed, 0.f, 1.f );
SetSpeed( m_maxSpeed * flScale, true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputSetSpeedForwardModifier( inputdata_t &inputdata )
{
SetSpeedForwardModifier( inputdata.value.Float() ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SetSpeedForwardModifier( float flModifier )
{
float flSpeedForwardModifier = flModifier;
flSpeedForwardModifier = fabs( flSpeedForwardModifier );
m_flSpeedForwardModifier = clamp( flSpeedForwardModifier, 0.f, 1.f );
SetSpeed( m_flUnmodifiedDesiredSpeed, true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::InputTeleportToPathTrack( inputdata_t &inputdata )
{
const char *pszName = inputdata.value.String();
CPathTrack *pTrack = dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, pszName ) );
if ( pTrack )
{
TeleportToPathTrack( pTrack );
m_ppath = pTrack;
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the speed of the train to the given value in units per second.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SetSpeed( float flSpeed, bool bAccel /*= false */ )
{
m_bAccelToSpeed = bAccel;
m_flUnmodifiedDesiredSpeed = flSpeed;
float flOldSpeed = m_flSpeed;
// are we using a speed forward modifier?
if ( m_flSpeedForwardModifier < 1.0 && m_dir > 0 )
{
flSpeed = flSpeed * m_flSpeedForwardModifier;
}
if ( m_bAccelToSpeed )
{
m_flDesiredSpeed = fabs( flSpeed ) * m_dir;
m_flSpeedChangeTime = gpGlobals->curtime;
if ( m_flSpeed == 0 && abs(m_flDesiredSpeed) > 0 )
{
m_flSpeed = 0.1; // little push to get us going
}
Start();
return;
}
m_flSpeed = fabs( flSpeed ) * m_dir;
if ( m_flSpeed != flOldSpeed)
{
// Changing speed.
if ( m_flSpeed != 0 )
{
if ( flOldSpeed == 0 )
{
// Starting to move.
Start();
}
else
{
// Continuing to move.
Next();
}
}
else
{
// Stopping.
Stop();
}
}
DevMsg( 2, "TRAIN(%s), speed to %.2f\n", GetDebugName(), m_flSpeed );
}
//-----------------------------------------------------------------------------
// Purpose: Stops the train.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Stop( void )
{
SetLocalVelocity( vec3_origin );
SetLocalAngularVelocity( vec3_angle );
m_oldSpeed = m_flSpeed;
m_flSpeed = 0;
SoundStop();
SetThink(NULL);
}
static CBaseEntity *FindPhysicsBlockerForHierarchy( CBaseEntity *pParentEntity )
{
CUtlVector<CBaseEntity *> list;
GetAllInHierarchy( pParentEntity, list );
CBaseEntity *pPhysicsBlocker = NULL;
float maxForce = 0;
for ( int i = 0; i < list.Count(); i++ )
{
IPhysicsObject *pPhysics = list[i]->VPhysicsGetObject();
if ( pPhysics )
{
IPhysicsFrictionSnapshot *pSnapshot = pPhysics->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject(1);
CBaseEntity *pOtherEntity = static_cast<CBaseEntity *>(pOther->GetGameData());
if ( pOtherEntity && pOtherEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
Vector normal;
pSnapshot->GetSurfaceNormal(normal);
float dot = DotProduct( pParentEntity->GetAbsVelocity(), pSnapshot->GetNormalForce() * normal );
if ( !pPhysicsBlocker || dot > maxForce )
{
pPhysicsBlocker = pOtherEntity;
maxForce = dot;
}
}
pSnapshot->NextFrictionData();
}
pPhysics->DestroyFrictionSnapshot( pSnapshot );
}
}
return pPhysicsBlocker;
}
//-----------------------------------------------------------------------------
// Purpose: Called when we are blocked by another entity.
// Input : pOther -
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Blocked( CBaseEntity *pOther )
{
// Blocker is on-ground on the train
if ( ( pOther->GetFlags() & FL_ONGROUND ) && pOther->GetGroundEntity() == this )
{
DevMsg( 1, "TRAIN(%s): Blocked by %s\n", GetDebugName(), pOther->GetClassname() );
float deltaSpeed = fabs(m_flSpeed);
if ( deltaSpeed > 50 )
deltaSpeed = 50;
Vector vecNewVelocity;
pOther->GetVelocity( &vecNewVelocity );
if ( !vecNewVelocity.z )
{
pOther->ApplyAbsVelocityImpulse( Vector(0,0,deltaSpeed) );
}
return;
}
else
{
Vector vecNewVelocity;
vecNewVelocity = pOther->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize(vecNewVelocity);
vecNewVelocity *= m_flBlockDamage;
pOther->SetAbsVelocity( vecNewVelocity );
}
if ( HasSpawnFlags(SF_TRACKTRAIN_UNBLOCKABLE_BY_PLAYER) )
{
CBaseEntity *pPhysicsBlocker = FindPhysicsBlockerForHierarchy(this);
if ( pPhysicsBlocker )
{
// This code keeps track of how long this train has been blocked
// The heuristic here is to keep instantaneous blocks from invoking the somewhat
// heavy-handed solver (which will disable collisions until we're clear) in cases
// where physics can solve it easily enough.
int ticksBlocked = gpGlobals->tickcount - m_lastBlockTick;
float dist = 0.0f;
// wait at least 10 ticks and make sure the train isn't actually moving before really blocking
const int MIN_BLOCKED_TICKS = 10;
if ( ticksBlocked > MIN_BLOCKED_TICKS )
{
dist = (GetAbsOrigin() - m_lastBlockPos).Length();
// must have moved at least 10% of normal velocity over the blocking interval, or we're being blocked
float minLength = GetAbsVelocity().Length() * TICK_INTERVAL * MIN_BLOCKED_TICKS * 0.10f;
if ( dist < minLength )
{
// been stuck for more than one tick without moving much?
// yes, disable collisions with the physics object most likely to be blocking us
EntityPhysics_CreateSolver( this, pPhysicsBlocker, true, 4.0f );
}
}
// first time blocking or moved too far since last block, reset
if ( dist > 1.0f || m_lastBlockTick < 0 )
{
m_lastBlockPos = GetAbsOrigin();
m_lastBlockTick = gpGlobals->tickcount;
}
}
// unblockable shouldn't damage the player in this case
if ( pOther->IsPlayer() )
return;
}
DevWarning( 2, "TRAIN(%s): Blocked by %s (dmg:%.2f)\n", GetDebugName(), pOther->GetClassname(), m_flBlockDamage );
if ( m_flBlockDamage <= 0 )
return;
// we can't hurt this thing, so we're not concerned with it
pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );
}
extern void FixupAngles( QAngle &v );
#define TRAIN_MAXSPEED 1000 // approx max speed for sound pitch calculation
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SoundStop( void )
{
// if sound playing, stop it
if ( m_bSoundPlaying )
{
if ( m_iszSoundMove != NULL_STRING )
{
StopSound( entindex(), CHAN_STATIC, STRING( m_iszSoundMove ) );
}
if ( m_iszSoundStop != NULL_STRING )
{
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_ITEM;
ep.m_pSoundName = STRING(m_iszSoundStop);
ep.m_flVolume = m_flVolume;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
}
m_bSoundPlaying = false;
}
//-----------------------------------------------------------------------------
// Purpose: Update pitch based on speed, start sound if not playing.
// NOTE: when train goes through transition, m_bSoundPlaying should become
// false, which will cause the looped sound to restart.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::SoundUpdate( void )
{
if ( ( !m_iszSoundMove ) && ( !m_iszSoundStart ) && ( !m_iszSoundMovePing ))
{
return;
}
// In multiplayer, only update the sound once a second
if ( g_pGameRules->IsMultiplayer() && m_bSoundPlaying )
{
if ( m_flNextMPSoundTime > gpGlobals->curtime )
return;
m_flNextMPSoundTime = gpGlobals->curtime + 1.0;
}
float flSpeedRatio = 0;
if ( HasSpawnFlags( SF_TRACKTRAIN_USE_MAXSPEED_FOR_PITCH ) )
{
flSpeedRatio = clamp( fabs( m_flSpeed ) / m_maxSpeed, 0.f, 1.f );
}
else
{
flSpeedRatio = clamp( fabs( m_flSpeed ) / TRAIN_MAXSPEED, 0.f, 1.f );
}
float flpitch = RemapVal( flSpeedRatio, 0, 1, m_nMoveSoundMinPitch, m_nMoveSoundMaxPitch );
CPASAttenuationFilter filter( this );
CPASAttenuationFilter filterReliable( this );
filterReliable.MakeReliable();
Vector vecWorldSpaceCenter = WorldSpaceCenter();
if (!m_bSoundPlaying)
{
if ( m_iszSoundStart != NULL_STRING )
{
EmitSound_t ep;
ep.m_nChannel = CHAN_ITEM;
ep.m_pSoundName = STRING(m_iszSoundStart);
ep.m_flVolume = m_flVolume;
ep.m_SoundLevel = SNDLVL_NORM;
ep.m_pOrigin = &vecWorldSpaceCenter;
EmitSound( filter, entindex(), ep );
}
if ( m_iszSoundMove != NULL_STRING )
{
EmitSound_t ep;
ep.m_nChannel = CHAN_STATIC;
ep.m_pSoundName = STRING(m_iszSoundMove);
ep.m_flVolume = m_flVolume;
ep.m_SoundLevel = SNDLVL_NORM;
ep.m_nPitch = (int)flpitch;
ep.m_pOrigin = &vecWorldSpaceCenter;
EmitSound( filterReliable, entindex(), ep );
}
// We've just started moving. Delay the next move ping sound.
m_flNextMoveSoundTime = gpGlobals->curtime + RemapVal( flSpeedRatio, 0, 1, m_flMoveSoundMaxTime, m_flMoveSoundMinTime );
m_bSoundPlaying = true;
}
else
{
if ( m_iszSoundMove != NULL_STRING )
{
// update pitch
EmitSound_t ep;
ep.m_nChannel = CHAN_STATIC;
ep.m_pSoundName = STRING(m_iszSoundMove);
ep.m_flVolume = m_flVolume;
ep.m_SoundLevel = SNDLVL_NORM;
ep.m_nPitch = (int)flpitch;
ep.m_nFlags = SND_CHANGE_PITCH;
ep.m_pOrigin = &vecWorldSpaceCenter;
// In multiplayer, don't make this reliable
if ( g_pGameRules->IsMultiplayer() )
{
EmitSound( filter, entindex(), ep );
}
else
{
EmitSound( filterReliable, entindex(), ep );
}
}
if ( ( m_iszSoundMovePing != NULL_STRING ) && ( gpGlobals->curtime > m_flNextMoveSoundTime ) )
{
EmitSound(STRING(m_iszSoundMovePing));
m_flNextMoveSoundTime = gpGlobals->curtime + RemapVal( flSpeedRatio, 0, 1, m_flMoveSoundMaxTime, m_flMoveSoundMinTime );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNode -
//-----------------------------------------------------------------------------
void CFuncTrackTrain::ArriveAtNode( CPathTrack *pNode )
{
// BUGBUG: This is wrong. We need to fire all targets between the one we've passed and the one
// we've switched to.
FirePassInputs( pNode, pNode->GetNext(), true );
//
// Disable train controls if this path track says to do so.
//
if ( pNode->HasSpawnFlags( SF_PATH_DISABLE_TRAIN ) )
{
m_spawnflags |= SF_TRACKTRAIN_NOCONTROL;
}
//
// Don't override the train speed if it's under user control.
//
if ( m_spawnflags & SF_TRACKTRAIN_NOCONTROL )
{
//
// Don't copy speed from path track if it is 0 (uninitialized).
//
if ( pNode->m_flSpeed != 0 )
{
SetSpeed( pNode->m_flSpeed );
DevMsg( 2, "TrackTrain %s arrived at %s, speed to %4.2f\n", GetDebugName(), pNode->GetDebugName(), pNode->m_flSpeed );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Controls how the train accelerates as it moves along the path.
//-----------------------------------------------------------------------------
TrainVelocityType_t CFuncTrackTrain::GetTrainVelocityType()
{
return m_eVelocityType;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pnext -
//-----------------------------------------------------------------------------
void CFuncTrackTrain::UpdateTrainVelocity( CPathTrack *pPrev, CPathTrack *pNext, const Vector &nextPos, float flInterval )
{
switch ( GetTrainVelocityType() )
{
case TrainVelocity_Instantaneous:
{
Vector velDesired = nextPos - GetLocalOrigin();
VectorNormalize( velDesired );
velDesired *= fabs( m_flSpeed );
SetLocalVelocity( velDesired );
break;
}
case TrainVelocity_LinearBlend:
case TrainVelocity_EaseInEaseOut:
{
if ( m_bAccelToSpeed )
{
float flPrevSpeed = m_flSpeed;
float flNextSpeed = m_flDesiredSpeed;
if ( flPrevSpeed != flNextSpeed )
{
float flSpeedChangeTime = ( abs(flNextSpeed) > abs(flPrevSpeed) ) ? m_flAccelSpeed : m_flDecelSpeed;
m_flSpeed = UTIL_Approach( m_flDesiredSpeed, m_flSpeed, flSpeedChangeTime * gpGlobals->frametime );
}
}
else if ( pPrev && pNext )
{
// Get the speed to blend from.
float flPrevSpeed = m_flSpeed;
if ( pPrev->m_flSpeed != 0 )
{
flPrevSpeed = pPrev->m_flSpeed;
}
// Get the speed to blend to.
float flNextSpeed = flPrevSpeed;
if ( pNext->m_flSpeed != 0 )
{
flNextSpeed = pNext->m_flSpeed;
}
// If they're different, do the blend.
if ( flPrevSpeed != flNextSpeed )
{
Vector vecSegment = pNext->GetLocalOrigin() - pPrev->GetLocalOrigin();
float flSegmentLen = vecSegment.Length();
if ( flSegmentLen )
{
Vector vecCurOffset = GetLocalOrigin() - pPrev->GetLocalOrigin();
float p = vecCurOffset.Length() / flSegmentLen;
if ( GetTrainVelocityType() == TrainVelocity_EaseInEaseOut )
{
p = SimpleSplineRemapVal( p, 0.0f, 1.0f, 0.0f, 1.0f );
}
m_flSpeed = m_dir * ( flPrevSpeed * ( 1 - p ) + flNextSpeed * p );
}
}
else
{
m_flSpeed = m_dir * flPrevSpeed;
}
}
Vector velDesired = nextPos - GetLocalOrigin();
VectorNormalize( velDesired );
velDesired *= fabs( m_flSpeed );
SetLocalVelocity( velDesired );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Controls how the train blends angles as it moves along the path.
//-----------------------------------------------------------------------------
TrainOrientationType_t CFuncTrackTrain::GetTrainOrientationType()
{
#ifdef HL1_DLL
return TrainOrientation_AtPathTracks;
#else
return m_eOrientationType;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pnext -
//-----------------------------------------------------------------------------
void CFuncTrackTrain::UpdateTrainOrientation( CPathTrack *pPrev, CPathTrack *pNext, const Vector &nextPos, float flInterval )
{
// FIXME: old way of doing fixed orienation trains, remove!
if ( HasSpawnFlags( SF_TRACKTRAIN_FIXED_ORIENTATION ) )
return;
// Trains *can* work in local space, but only if all elements of the track share
// the same move parent as the train.
Assert( !pPrev || (pPrev->GetMoveParent() == GetMoveParent()) );
switch ( GetTrainOrientationType() )
{
case TrainOrientation_Fixed:
{
// Fixed orientation. Do nothing.
break;
}
case TrainOrientation_AtPathTracks:
{
UpdateOrientationAtPathTracks( pPrev, pNext, nextPos, flInterval );
break;
}
case TrainOrientation_EaseInEaseOut:
case TrainOrientation_LinearBlend:
{
UpdateOrientationBlend( GetTrainOrientationType(), pPrev, pNext, nextPos, flInterval );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Adjusts our angles as we hit each path track. This is for support of
// trains with wheels that round corners a la HL1 trains.
// FIXME: move into path_track, have the angles come back from LookAhead
//-----------------------------------------------------------------------------
void CFuncTrackTrain::UpdateOrientationAtPathTracks( CPathTrack *pPrev, CPathTrack *pNext, const Vector &nextPos, float flInterval )
{
if ( !m_ppath )
return;
Vector nextFront = GetLocalOrigin();
CPathTrack *pNextNode = NULL;
nextFront.z -= m_height;
if ( m_length > 0 )
{
m_ppath->LookAhead( nextFront, IsDirForward() ? m_length : -m_length, 0, &pNextNode );
}
else
{
m_ppath->LookAhead( nextFront, IsDirForward() ? 100 : -100, 0, &pNextNode );
}
nextFront.z += m_height;
Vector vecFaceDir = nextFront - GetLocalOrigin();
if ( !IsDirForward() )
{
vecFaceDir *= -1;
}
QAngle angles;
VectorAngles( vecFaceDir, angles );
// !!! All of this crap has to be done to make the angles not wrap around, revisit this.
FixupAngles( angles );
// Wrapped with this bool so we don't affect old trains
if ( m_bManualSpeedChanges )
{
if ( pNextNode && pNextNode->GetOrientationType() == TrackOrientation_FacePathAngles )
{
angles = pNextNode->GetOrientation( IsDirForward() );
}
}
QAngle curAngles = GetLocalAngles();
FixupAngles( curAngles );
if ( !pPrev || (vecFaceDir.x == 0 && vecFaceDir.y == 0) )
angles = curAngles;
DoUpdateOrientation( curAngles, angles, flInterval );
}
//-----------------------------------------------------------------------------
// Purpose: Blends our angles using one of two orientation blending types.
// ASSUMES that eOrientationType is either LinearBlend or EaseInEaseOut.
// FIXME: move into path_track, have the angles come back from LookAhead
//-----------------------------------------------------------------------------
void CFuncTrackTrain::UpdateOrientationBlend( TrainOrientationType_t eOrientationType, CPathTrack *pPrev, CPathTrack *pNext, const Vector &nextPos, float flInterval )
{
// Get the angles to blend from.
QAngle angPrev = pPrev->GetOrientation( IsDirForward() );
FixupAngles( angPrev );
// Get the angles to blend to.
QAngle angNext;
if ( pNext )
{
angNext = pNext->GetOrientation( IsDirForward() );
FixupAngles( angNext );
}
else
{
// At a dead end, just use the last path track's angles.
angNext = angPrev;
}
if ( m_spawnflags & SF_TRACKTRAIN_NOPITCH )
{
angNext[PITCH] = angPrev[PITCH];
}
// Calculate our parametric distance along the path segment from 0 to 1.
float p = 0;
if ( pPrev && ( angPrev != angNext ) )
{
Vector vecSegment = pNext->GetLocalOrigin() - pPrev->GetLocalOrigin();
float flSegmentLen = vecSegment.Length();
if ( flSegmentLen )
{
Vector vecCurOffset = GetLocalOrigin() - pPrev->GetLocalOrigin();
p = vecCurOffset.Length() / flSegmentLen;
}
}
if ( eOrientationType == TrainOrientation_EaseInEaseOut )
{
p = SimpleSplineRemapVal( p, 0.0f, 1.0f, 0.0f, 1.0f );
}
//Msg( "UpdateOrientationFacePathAngles: %s->%s, p=%f, ", pPrev->GetDebugName(), pNext->GetDebugName(), p );
Quaternion qtPrev;
Quaternion qtNext;
AngleQuaternion( angPrev, qtPrev );
AngleQuaternion( angNext, qtNext );
QAngle angNew = angNext;
float flAngleDiff = QuaternionAngleDiff( qtPrev, qtNext );
if ( flAngleDiff )
{
Quaternion qtNew;
QuaternionSlerp( qtPrev, qtNext, p, qtNew );
QuaternionAngles( qtNew, angNew );
}
if ( m_spawnflags & SF_TRACKTRAIN_NOPITCH )
{
angNew[PITCH] = angPrev[PITCH];
}
DoUpdateOrientation( GetLocalAngles(), angNew, flInterval );
}
//-----------------------------------------------------------------------------
// Purpose: Sets our angular velocity to approach the target angles over the given interval.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::DoUpdateOrientation( const QAngle &curAngles, const QAngle &angles, float flInterval )
{
float vy, vx;
if ( !(m_spawnflags & SF_TRACKTRAIN_NOPITCH) )
{
vx = UTIL_AngleDistance( angles.x, curAngles.x );
}
else
{
vx = 0;
}
vy = UTIL_AngleDistance( angles.y, curAngles.y );
// HACKHACK: Clamp really small angular deltas to avoid rotating movement on things
// that are close enough
if ( fabs(vx) < 0.1 )
{
vx = 0;
}
if ( fabs(vy) < 0.1 )
{
vy = 0;
}
if ( flInterval == 0 )
{
// Avoid dividing by zero
flInterval = 0.1;
}
QAngle vecAngVel( vx / flInterval, vy / flInterval, GetLocalAngularVelocity().z );
if ( m_flBank != 0 )
{
if ( vecAngVel.y < -5 )
{
vecAngVel.z = UTIL_AngleDistance( UTIL_ApproachAngle( -m_flBank, curAngles.z, m_flBank*2 ), curAngles.z);
}
else if ( vecAngVel.y > 5 )
{
vecAngVel.z = UTIL_AngleDistance( UTIL_ApproachAngle( m_flBank, curAngles.z, m_flBank*2 ), curAngles.z);
}
else
{
vecAngVel.z = UTIL_AngleDistance( UTIL_ApproachAngle( 0, curAngles.z, m_flBank*4 ), curAngles.z) * 4;
}
}
SetLocalAngularVelocity( vecAngVel );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pTeleport -
//-----------------------------------------------------------------------------
void CFuncTrackTrain::TeleportToPathTrack( CPathTrack *pTeleport )
{
QAngle angCur = GetLocalAngles();
Vector nextPos = pTeleport->GetLocalOrigin();
Vector look = nextPos;
pTeleport->LookAhead( look, m_length, 0 );
QAngle nextAngles;
if ( HasSpawnFlags( SF_TRACKTRAIN_FIXED_ORIENTATION ) || ( look == nextPos ) )
{
nextAngles = GetLocalAngles();
}
else
{
nextAngles = pTeleport->GetOrientation( IsDirForward() );
if ( HasSpawnFlags( SF_TRACKTRAIN_NOPITCH ) )
{
nextAngles[PITCH] = angCur[PITCH];
}
}
Teleport( &pTeleport->GetLocalOrigin(), &nextAngles, NULL );
SetLocalAngularVelocity( vec3_angle );
variant_t emptyVariant;
pTeleport->AcceptInput( "InTeleport", this, this, emptyVariant, 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Advances the train to the next path corner on the path.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Next( void )
{
if ( !m_flSpeed )
{
DevMsg( 2, "TRAIN(%s): Speed is 0\n", GetDebugName() );
SoundStop();
return;
}
if ( !m_ppath )
{
DevMsg( 2, "TRAIN(%s): Lost path\n", GetDebugName() );
SoundStop();
m_flSpeed = 0;
return;
}
SoundUpdate();
//
// Based on our current position and speed, look ahead along our path and see
// where we should be in 0.1 seconds.
//
Vector nextPos = GetLocalOrigin();
float flSpeed = m_flSpeed;
nextPos.z -= m_height;
CPathTrack *pNextNext = NULL;
CPathTrack *pNext = m_ppath->LookAhead( nextPos, flSpeed * 0.1, 1, &pNextNext );
//Assert( pNext != NULL );
// If we're moving towards a dead end, but our desired speed goes in the opposite direction
// this fixes us from stalling
if ( m_bManualSpeedChanges && ( ( flSpeed < 0 ) != ( m_flDesiredSpeed < 0 ) ) )
{
if ( !pNext )
pNext = m_ppath;
}
if (m_debugOverlays & OVERLAY_BBOX_BIT)
{
if ( pNext != NULL )
{
NDebugOverlay::Line( GetAbsOrigin(), pNext->GetAbsOrigin(), 255, 0, 0, true, 0.1 );
NDebugOverlay::Line( pNext->GetAbsOrigin(), pNext->GetAbsOrigin() + Vector( 0,0,32), 255, 0, 0, true, 0.1 );
NDebugOverlay::Box( pNext->GetAbsOrigin(), Vector( -8, -8, -8 ), Vector( 8, 8, 8 ), 255, 0, 0, 0, 0.1 );
}
if ( pNextNext != NULL )
{
NDebugOverlay::Line( GetAbsOrigin(), pNextNext->GetAbsOrigin(), 0, 255, 0, true, 0.1 );
NDebugOverlay::Line( pNextNext->GetAbsOrigin(), pNextNext->GetAbsOrigin() + Vector( 0,0,32), 0, 255, 0, true, 0.1 );
NDebugOverlay::Box( pNextNext->GetAbsOrigin(), Vector( -8, -8, -8 ), Vector( 8, 8, 8 ), 0, 255, 0, 0, 0.1 );
}
}
nextPos.z += m_height;
// Trains *can* work in local space, but only if all elements of the track share
// the same move parent as the train.
Assert( !pNext || (pNext->GetMoveParent() == GetMoveParent()) );
if ( pNext )
{
UpdateTrainVelocity( pNext, pNextNext, nextPos, gpGlobals->frametime );
UpdateTrainOrientation( pNext, pNextNext, nextPos, gpGlobals->frametime );
if ( pNext != m_ppath )
{
//
// We have reached a new path track. Fire its OnPass output.
//
m_ppath = pNext;
ArriveAtNode( pNext );
#ifdef HL1_DLL
m_bOnTrackChange = false;
#endif
//
// See if we should teleport to the next path track.
//
CPathTrack *pTeleport = pNext->GetNext();
if ( ( pTeleport != NULL ) && pTeleport->HasSpawnFlags( SF_PATH_TELEPORT ) )
{
TeleportToPathTrack( pTeleport );
}
}
m_OnNext.FireOutput( pNext, this );
SetThink( &CFuncTrackTrain::Next );
SetMoveDoneTime( 0.5 );
SetNextThink( gpGlobals->curtime );
SetMoveDone( NULL );
}
else
{
//
// We've reached the end of the path, stop.
//
SoundStop();
SetLocalVelocity(nextPos - GetLocalOrigin());
SetLocalAngularVelocity( vec3_angle );
float distance = GetLocalVelocity().Length();
m_oldSpeed = m_flSpeed;
m_flSpeed = 0;
// Move to the dead end
// Are we there yet?
if ( distance > 0 )
{
// no, how long to get there?
float flTime = distance / fabs( m_oldSpeed );
SetLocalVelocity( GetLocalVelocity() * (m_oldSpeed / distance) );
SetMoveDone( &CFuncTrackTrain::DeadEnd );
SetNextThink( TICK_NEVER_THINK );
SetMoveDoneTime( flTime );
}
else
{
DeadEnd();
}
}
}
void CFuncTrackTrain::FirePassInputs( CPathTrack *pStart, CPathTrack *pEnd, bool forward )
{
CPathTrack *pCurrent = pStart;
// swap if going backward
if ( !forward )
{
pCurrent = pEnd;
pEnd = pStart;
}
variant_t emptyVariant;
while ( pCurrent && pCurrent != pEnd )
{
//Msg("Fired pass on %s\n", STRING(pCurrent->GetEntityName()) );
pCurrent->AcceptInput( "InPass", this, this, emptyVariant, 0 );
pCurrent = forward ? pCurrent->GetNext() : pCurrent->GetPrevious();
}
}
void CFuncTrackTrain::DeadEnd( void )
{
// Fire the dead-end target if there is one
CPathTrack *pTrack, *pNext;
pTrack = m_ppath;
DevMsg( 2, "TRAIN(%s): Dead end ", GetDebugName() );
// Find the dead end path node
// HACKHACK -- This is bugly, but the train can actually stop moving at a different node depending on it's speed
// so we have to traverse the list to it's end.
if ( pTrack )
{
if ( m_oldSpeed < 0 )
{
do
{
pNext = pTrack->ValidPath( pTrack->GetPrevious(), true );
if ( pNext )
pTrack = pNext;
} while ( pNext );
}
else
{
do
{
pNext = pTrack->ValidPath( pTrack->GetNext(), true );
if ( pNext )
pTrack = pNext;
} while ( pNext );
}
}
SetLocalVelocity( vec3_origin );
SetLocalAngularVelocity( vec3_angle );
if ( pTrack )
{
DevMsg( 2, "at %s\n", pTrack->GetDebugName() );
variant_t emptyVariant;
pTrack->AcceptInput( "InPass", this, this, emptyVariant, 0 );
}
else
{
DevMsg( 2, "\n" );
}
}
void CFuncTrackTrain::SetControls( CBaseEntity *pControls )
{
Vector offset = pControls->GetLocalOrigin();
m_controlMins = pControls->WorldAlignMins() + offset;
m_controlMaxs = pControls->WorldAlignMaxs() + offset;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the entity's origin is within the controls region.
//-----------------------------------------------------------------------------
bool CFuncTrackTrain::OnControls( CBaseEntity *pTest )
{
Vector offset = pTest->GetLocalOrigin() - GetLocalOrigin();
if ( m_spawnflags & SF_TRACKTRAIN_NOCONTROL )
return false;
// Transform offset into local coordinates
VMatrix tmp = SetupMatrixAngles( GetLocalAngles() );
// rotate into local space
Vector local = tmp.VMul3x3Transpose( offset );
/*
NDebugOverlay::Box( GetLocalOrigin(), m_controlMins, m_controlMaxs,
255, 0, 0, 100, 5.0 );
NDebugOverlay::Box( GetLocalOrigin() + local, Vector(-5,-5,-5), Vector(5,5,5),
0, 0, 255, 100, 5.0 );
*/
if ( local.x >= m_controlMins.x && local.y >= m_controlMins.y && local.z >= m_controlMins.z &&
local.x <= m_controlMaxs.x && local.y <= m_controlMaxs.y && local.z <= m_controlMaxs.z )
return true;
return false;
}
void CFuncTrackTrain::Find( void )
{
m_ppath = (CPathTrack *)gEntList.FindEntityByName( NULL, m_target );
if ( !m_ppath )
return;
if ( !FClassnameIs( m_ppath, "path_track" )
#ifndef PORTAL //env_portal_path_track is a child of path_track and would like to get found
&& !FClassnameIs( m_ppath, "env_portal_path_track" )
#endif //#ifndef PORTAL
)
{
Warning( "func_track_train must be on a path of path_track\n" );
Assert(0);
m_ppath = NULL;
return;
}
Vector nextPos = m_ppath->GetLocalOrigin();
Vector look = nextPos;
m_ppath->LookAhead( look, m_length, 0 );
nextPos.z += m_height;
look.z += m_height;
QAngle nextAngles;
if ( HasSpawnFlags( SF_TRACKTRAIN_FIXED_ORIENTATION ) )
{
nextAngles = GetLocalAngles();
}
else
{
VectorAngles( look - nextPos, nextAngles );
if ( HasSpawnFlags( SF_TRACKTRAIN_NOPITCH ) )
{
nextAngles.x = 0;
}
}
Teleport( &nextPos, &nextAngles, NULL );
ArriveAtNode( m_ppath );
if ( m_flSpeed != 0 )
{
SetNextThink( gpGlobals->curtime + 0.1f );
SetThink( &CFuncTrackTrain::Next );
SoundUpdate();
}
}
void CFuncTrackTrain::NearestPath( void )
{
CBaseEntity *pTrack = NULL;
CBaseEntity *pNearest = NULL;
float dist, closest;
closest = 1024;
for ( CEntitySphereQuery sphere( GetAbsOrigin(), 1024 ); ( pTrack = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
{
// filter out non-tracks
if ( !(pTrack->GetFlags() & (FL_CLIENT|FL_NPC)) && FClassnameIs( pTrack, "path_track" ) )
{
dist = (GetAbsOrigin() - pTrack->GetAbsOrigin()).Length();
if ( dist < closest )
{
closest = dist;
pNearest = pTrack;
}
}
}
if ( !pNearest )
{
Msg( "Can't find a nearby track !!!\n" );
SetThink(NULL);
return;
}
DevMsg( 2, "TRAIN: %s, Nearest track is %s\n", GetDebugName(), pNearest->GetDebugName() );
// If I'm closer to the next path_track on this path, then it's my real path
pTrack = ((CPathTrack *)pNearest)->GetNext();
if ( pTrack )
{
if ( (GetLocalOrigin() - pTrack->GetLocalOrigin()).Length() < (GetLocalOrigin() - pNearest->GetLocalOrigin()).Length() )
pNearest = pTrack;
}
m_ppath = (CPathTrack *)pNearest;
if ( m_flSpeed != 0 )
{
SetMoveDoneTime( 0.1 );
SetMoveDone( &CFuncTrackTrain::Next );
}
}
void CFuncTrackTrain::OnRestore( void )
{
BaseClass::OnRestore();
if ( !m_ppath
#ifdef HL1_DLL
&& !m_bOnTrackChange
#endif
)
{
NearestPath();
SetThink( NULL );
}
}
CFuncTrackTrain *CFuncTrackTrain::Instance( edict_t *pent )
{
CBaseEntity *pEntity = CBaseEntity::Instance( pent );
if ( FClassnameIs( pEntity, "func_tracktrain" ) )
return (CFuncTrackTrain *)pEntity;
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Spawn( void )
{
if ( m_maxSpeed == 0 )
{
if ( m_flSpeed == 0 )
{
m_maxSpeed = 100;
}
else
{
m_maxSpeed = m_flSpeed;
}
}
if ( m_nMoveSoundMinPitch == 0 )
{
m_nMoveSoundMinPitch = 60;
}
if ( m_nMoveSoundMaxPitch == 0 )
{
m_nMoveSoundMaxPitch = 200;
}
SetLocalVelocity(vec3_origin);
SetLocalAngularVelocity( vec3_angle );
m_dir = 1;
if ( !m_target )
{
Msg("FuncTrackTrain '%s' has no target.\n", GetDebugName());
}
SetModel( STRING( GetModelName() ) );
SetMoveType( MOVETYPE_PUSH );
#ifdef HL1_DLL
// BUGBUG: For now, just force this for testing. Remove if we want to tag all of the trains in the levels
SetSolid( SOLID_BSP );
#else
SetSolid( HasSpawnFlags( SF_TRACKTRAIN_HL1TRAIN ) ? SOLID_BSP : SOLID_VPHYSICS );
//SetSolid( SOLID_VPHYSICS );
#endif
if ( HasSpawnFlags( SF_TRACKTRAIN_UNBLOCKABLE_BY_PLAYER ) )
{
AddFlag( FL_UNBLOCKABLE_BY_PLAYER );
}
if ( m_spawnflags & SF_TRACKTRAIN_PASSABLE )
{
AddSolidFlags( FSOLID_NOT_SOLID );
}
m_controlMins = CollisionProp()->OBBMins();
m_controlMaxs = CollisionProp()->OBBMaxs();
m_controlMaxs.z += 72;
// start trains on the next frame, to make sure their targets have had
// a chance to spawn/activate
SetThink( &CFuncTrackTrain::Find );
SetNextThink( gpGlobals->curtime );
Precache();
CreateVPhysics();
}
bool CFuncTrackTrain::CreateVPhysics( void )
{
VPhysicsInitShadow( false, false );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Precaches the train sounds.
//-----------------------------------------------------------------------------
void CFuncTrackTrain::Precache( void )
{
if (m_flVolume == 0.0)
{
m_flVolume = 1.0;
}
if ( m_iszSoundMove != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszSoundMove ) );
}
if ( m_iszSoundMovePing != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszSoundMovePing ) );
}
if ( m_iszSoundStart != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszSoundStart ) );
}
if ( m_iszSoundStop != NULL_STRING )
{
PrecacheScriptSound( STRING( m_iszSoundStop ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFuncTrackTrain::UpdateOnRemove()
{
SoundStop();
BaseClass::UpdateOnRemove();
}
void CFuncTrackTrain::MoveDone()
{
m_lastBlockPos.Init();
m_lastBlockTick = -1;
BaseClass::MoveDone();
}
int CFuncTrackTrain::OnTakeDamage( const CTakeDamageInfo &info )
{
if ( m_bDamageChild )
{
if ( FirstMoveChild() )
{
FirstMoveChild()->TakeDamage( info );
}
return 0;
}
else
{
return BaseClass::OnTakeDamage( info );
}
}
//-----------------------------------------------------------------------------
// Purpose: Defines the volume of space that the player must stand in to
// control the train
//-----------------------------------------------------------------------------
class CFuncTrainControls : public CBaseEntity
{
DECLARE_CLASS( CFuncTrainControls, CBaseEntity );
public:
void Spawn( void );
void Find( void );
DECLARE_DATADESC();
};
BEGIN_DATADESC( CFuncTrainControls )
// Function Pointers
DEFINE_FUNCTION( Find ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_traincontrols, CFuncTrainControls );
void CFuncTrainControls::Find( void )
{
CBaseEntity *pTarget = NULL;
do
{
pTarget = gEntList.FindEntityByName( pTarget, m_target );
} while ( pTarget && !FClassnameIs(pTarget, "func_tracktrain") );
if ( !pTarget )
{
Msg( "No train %s\n", STRING(m_target) );
return;
}
CFuncTrackTrain *ptrain = (CFuncTrackTrain*) pTarget;
ptrain->SetControls( this );
SetThink( NULL );
}
void CFuncTrainControls::Spawn( void )
{
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
SetModel( STRING( GetModelName() ) );
AddEffects( EF_NODRAW );
Assert( GetParent() && "func_traincontrols needs parent to properly align to train" );
SetThink( &CFuncTrainControls::Find );
SetNextThink( gpGlobals->curtime );
}
#define SF_TRACK_ACTIVATETRAIN 0x00000001
#define SF_TRACK_RELINK 0x00000002
#define SF_TRACK_ROTMOVE 0x00000004
#define SF_TRACK_STARTBOTTOM 0x00000008
#define SF_TRACK_DONT_MOVE 0x00000010
typedef enum { TRAIN_SAFE, TRAIN_BLOCKING, TRAIN_FOLLOWING } TRAIN_CODE;
//-----------------------------------------------------------------------------
// This entity is a rotating/moving platform that will carry a train to a new track.
// It must be larger in X-Y planar area than the train, since it must contain the
// train within these dimensions in order to operate when the train is near it.
//-----------------------------------------------------------------------------
class CFuncTrackChange : public CFuncPlatRot
{
DECLARE_CLASS( CFuncTrackChange, CFuncPlatRot );
public:
void Spawn( void );
void Precache( void );
// virtual void Blocked( void );
virtual void GoUp( void );
virtual void GoDown( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void Find( void );
TRAIN_CODE EvaluateTrain( CPathTrack *pcurrent );
void UpdateTrain( QAngle &dest );
virtual void HitBottom( void );
virtual void HitTop( void );
void Touch( CBaseEntity *pOther );
virtual void UpdateAutoTargets( int toggleState );
virtual bool IsTogglePlat( void ) { return true; }
void DisableUse( void ) { m_use = 0; }
void EnableUse( void ) { m_use = 1; }
int UseEnabled( void ) { return m_use; }
DECLARE_DATADESC();
CPathTrack *m_trackTop;
CPathTrack *m_trackBottom;
CFuncTrackTrain *m_train;
string_t m_trackTopName;
string_t m_trackBottomName;
string_t m_trainName;
TRAIN_CODE m_code;
int m_targetState;
int m_use;
};
LINK_ENTITY_TO_CLASS( func_trackchange, CFuncTrackChange );
BEGIN_DATADESC( CFuncTrackChange )
DEFINE_GLOBAL_FIELD( m_trackTop, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( m_trackBottom, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( m_train, FIELD_CLASSPTR ),
DEFINE_GLOBAL_KEYFIELD( m_trackTopName, FIELD_STRING, "toptrack" ),
DEFINE_GLOBAL_KEYFIELD( m_trackBottomName, FIELD_STRING, "bottomtrack" ),
DEFINE_GLOBAL_KEYFIELD( m_trainName, FIELD_STRING, "train" ),
DEFINE_FIELD( m_code, FIELD_INTEGER ),
DEFINE_FIELD( m_targetState, FIELD_INTEGER ),
DEFINE_FIELD( m_use, FIELD_INTEGER ),
// Function Pointers
DEFINE_FUNCTION( Find ),
END_DATADESC()
void CFuncTrackChange::Spawn( void )
{
Setup();
if ( FBitSet( m_spawnflags, SF_TRACK_DONT_MOVE ) )
m_vecPosition2.z = GetLocalOrigin().z;
SetupRotation();
if ( FBitSet( m_spawnflags, SF_TRACK_STARTBOTTOM ) )
{
UTIL_SetOrigin( this, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
SetLocalAngles( m_start );
m_targetState = TS_AT_TOP;
}
else
{
UTIL_SetOrigin( this, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
SetLocalAngles( m_end );
m_targetState = TS_AT_BOTTOM;
}
EnableUse();
SetThink( &CFuncTrackChange::Find );
SetNextThink( gpGlobals->curtime + 2 );
Precache();
}
void CFuncTrackChange::Precache( void )
{
BaseClass::Precache();
PrecacheScriptSound( "FuncTrackChange.Blocking" );
}
// UNDONE: Filter touches before re-evaluating the train.
void CFuncTrackChange::Touch( CBaseEntity *pOther )
{
}
void CFuncTrackChange::Find( void )
{
// Find track entities
CBaseEntity *target;
target = gEntList.FindEntityByName( NULL, m_trackTopName );
if ( target )
{
m_trackTop = (CPathTrack*) target;
target = gEntList.FindEntityByName( NULL, m_trackBottomName );
if ( target )
{
m_trackBottom = (CPathTrack*) target;
target = gEntList.FindEntityByName( NULL, m_trainName );
if ( target )
{
m_train = (CFuncTrackTrain *)gEntList.FindEntityByName( NULL, m_trainName );
if ( !m_train )
{
Warning( "Can't find train for track change! %s\n", STRING(m_trainName) );
Assert(0);
return;
}
Vector center = WorldSpaceCenter();
m_trackBottom = m_trackBottom->Nearest( center );
m_trackTop = m_trackTop->Nearest( center );
UpdateAutoTargets( m_toggle_state );
SetThink( NULL );
return;
}
else
{
Warning( "Can't find train for track change! %s\n", STRING(m_trainName) );
Assert(0);
target = gEntList.FindEntityByName( NULL, m_trainName );
}
}
else
{
Warning( "Can't find bottom track for track change! %s\n", STRING(m_trackBottomName) );
Assert(0);
}
}
else
{
Warning( "Can't find top track for track change! %s\n", STRING(m_trackTopName) );
Assert(0);
}
}
TRAIN_CODE CFuncTrackChange::EvaluateTrain( CPathTrack *pcurrent )
{
// Go ahead and work, we don't have anything to switch, so just be an elevator
if ( !pcurrent || !m_train )
return TRAIN_SAFE;
if ( m_train->m_ppath == pcurrent || (pcurrent->m_pprevious && m_train->m_ppath == pcurrent->m_pprevious) ||
(pcurrent->m_pnext && m_train->m_ppath == pcurrent->m_pnext) )
{
if ( m_train->m_flSpeed != 0 )
return TRAIN_BLOCKING;
Vector dist = GetLocalOrigin() - m_train->GetLocalOrigin();
float length = dist.Length2D();
if ( length < m_train->m_length ) // Empirically determined close distance
return TRAIN_FOLLOWING;
else if ( length > (150 + m_train->m_length) )
return TRAIN_SAFE;
return TRAIN_BLOCKING;
}
return TRAIN_SAFE;
}
void CFuncTrackChange::UpdateTrain( QAngle &dest )
{
float time = GetMoveDoneTime();
m_train->SetAbsVelocity( GetAbsVelocity() );
m_train->SetLocalAngularVelocity( GetLocalAngularVelocity() );
m_train->SetMoveDoneTime( time );
// Attempt at getting the train to rotate properly around the origin of the trackchange
if ( time <= 0 )
return;
Vector offset = m_train->GetLocalOrigin() - GetLocalOrigin();
QAngle delta = dest - GetLocalAngles();
// Transform offset into local coordinates
Vector forward, right, up;
AngleVectorsTranspose( delta, &forward, &right, &up );
Vector local;
local.x = DotProduct( offset, forward );
local.y = DotProduct( offset, right );
local.z = DotProduct( offset, up );
local = local - offset;
m_train->SetAbsVelocity( GetAbsVelocity() + (local * (1.0/time)) );
}
void CFuncTrackChange::GoDown( void )
{
if ( m_code == TRAIN_BLOCKING )
return;
// HitBottom may get called during CFuncPlat::GoDown(), so set up for that
// before you call GoDown()
UpdateAutoTargets( TS_GOING_DOWN );
// If ROTMOVE, move & rotate
if ( FBitSet( m_spawnflags, SF_TRACK_DONT_MOVE ) )
{
SetMoveDone( &CFuncTrackChange::CallHitBottom );
m_toggle_state = TS_GOING_DOWN;
AngularMove( m_start, m_flSpeed );
}
else
{
BaseClass::GoDown();
SetMoveDone( &CFuncTrackChange::CallHitBottom );
RotMove( m_start, GetMoveDoneTime() );
}
// Otherwise, rotate first, move second
// If the train is moving with the platform, update it
if ( m_code == TRAIN_FOLLOWING )
{
UpdateTrain( m_start );
m_train->m_ppath = NULL;
#ifdef HL1_DLL
m_train->m_bOnTrackChange = true;
#endif
}
}
//
// Platform is at bottom, now starts moving up
//
void CFuncTrackChange::GoUp( void )
{
if ( m_code == TRAIN_BLOCKING )
return;
// HitTop may get called during CFuncPlat::GoUp(), so set up for that
// before you call GoUp();
UpdateAutoTargets( TS_GOING_UP );
if ( FBitSet( m_spawnflags, SF_TRACK_DONT_MOVE ) )
{
m_toggle_state = TS_GOING_UP;
SetMoveDone( &CFuncTrackChange::CallHitTop );
AngularMove( m_end, m_flSpeed );
}
else
{
// If ROTMOVE, move & rotate
BaseClass::GoUp();
SetMoveDone( &CFuncTrackChange::CallHitTop );
RotMove( m_end, GetMoveDoneTime() );
}
// Otherwise, move first, rotate second
// If the train is moving with the platform, update it
if ( m_code == TRAIN_FOLLOWING )
{
UpdateTrain( m_end );
m_train->m_ppath = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Normal track change
// Input : toggleState -
//-----------------------------------------------------------------------------
void CFuncTrackChange::UpdateAutoTargets( int toggleState )
{
if ( !m_trackTop || !m_trackBottom )
return;
if ( toggleState == TS_AT_TOP )
{
m_trackTop->RemoveSpawnFlags( SF_PATH_DISABLED );
}
else
{
m_trackTop->AddSpawnFlags( SF_PATH_DISABLED );
}
if ( toggleState == TS_AT_BOTTOM )
{
m_trackBottom->RemoveSpawnFlags( SF_PATH_DISABLED );
}
else
{
m_trackBottom->AddSpawnFlags( SF_PATH_DISABLED );
}
}
void CFuncTrackChange::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( m_toggle_state != TS_AT_TOP && m_toggle_state != TS_AT_BOTTOM )
return;
// If train is in "safe" area, but not on the elevator, play alarm sound
if ( m_toggle_state == TS_AT_TOP )
m_code = EvaluateTrain( m_trackTop );
else if ( m_toggle_state == TS_AT_BOTTOM )
m_code = EvaluateTrain( m_trackBottom );
else
m_code = TRAIN_BLOCKING;
if ( m_code == TRAIN_BLOCKING )
{
// Play alarm and return
EmitSound( "FuncTrackChange.Blocking" );
return;
}
// Otherwise, it's safe to move
// If at top, go down
// at bottom, go up
DisableUse();
if (m_toggle_state == TS_AT_TOP)
GoDown();
else
GoUp();
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncTrackChange::HitBottom( void )
{
BaseClass::HitBottom();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackBottom );
}
SetMoveDone( NULL );
SetMoveDoneTime( -1 );
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncTrackChange::HitTop( void )
{
BaseClass::HitTop();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackTop );
}
// Don't let the plat go back down
SetMoveDone( NULL );
SetMoveDoneTime( -1 );
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
class CFuncTrackAuto : public CFuncTrackChange
{
DECLARE_CLASS( CFuncTrackAuto, CFuncTrackChange );
public:
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual void UpdateAutoTargets( int toggleState );
void TriggerTrackChange( inputdata_t &inputdata );
DECLARE_DATADESC();
};
BEGIN_DATADESC( CFuncTrackAuto )
DEFINE_INPUTFUNC( FIELD_VOID, "Trigger", TriggerTrackChange ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( func_trackautochange, CFuncTrackAuto );
// Auto track change
void CFuncTrackAuto::UpdateAutoTargets( int toggleState )
{
CPathTrack *pTarget, *pNextTarget;
if ( !m_trackTop || !m_trackBottom )
return;
if ( m_targetState == TS_AT_TOP )
{
pTarget = m_trackTop->GetNext();
pNextTarget = m_trackBottom->GetNext();
}
else
{
pTarget = m_trackBottom->GetNext();
pNextTarget = m_trackTop->GetNext();
}
if ( pTarget )
{
pTarget->RemoveSpawnFlags( SF_PATH_DISABLED );
if ( m_code == TRAIN_FOLLOWING && m_train && m_train->m_flSpeed == 0 )
{
m_train->SetSpeed( pTarget->m_flSpeed );
m_train->Use( this, this, USE_SET, 0 );
}
}
if ( pNextTarget )
{
pNextTarget->AddSpawnFlags( SF_PATH_DISABLED );
}
}
void CFuncTrackAuto::TriggerTrackChange ( inputdata_t &inputdata )
{
CPathTrack *pTarget;
if ( !UseEnabled() )
return;
if ( m_toggle_state == TS_AT_TOP )
pTarget = m_trackTop;
else if ( m_toggle_state == TS_AT_BOTTOM )
pTarget = m_trackBottom;
else
pTarget = NULL;
if ( inputdata.pActivator && FClassnameIs( inputdata.pActivator, "func_tracktrain" ) )
{
m_code = EvaluateTrain( pTarget );
// Safe to fire?
if ( m_code == TRAIN_FOLLOWING && m_toggle_state != m_targetState )
{
DisableUse();
if (m_toggle_state == TS_AT_TOP)
GoDown();
else
GoUp();
}
}
else
{
if ( pTarget )
pTarget = pTarget->GetNext();
if ( pTarget && m_train->m_ppath != pTarget && ShouldToggle( USE_TOGGLE, m_targetState ) )
{
if ( m_targetState == TS_AT_TOP )
m_targetState = TS_AT_BOTTOM;
else
m_targetState = TS_AT_TOP;
}
UpdateAutoTargets( m_targetState );
}
}
void CFuncTrackAuto::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
CPathTrack *pTarget;
if ( !UseEnabled() )
return;
if ( m_toggle_state == TS_AT_TOP )
pTarget = m_trackTop;
else if ( m_toggle_state == TS_AT_BOTTOM )
pTarget = m_trackBottom;
else
pTarget = NULL;
if ( FClassnameIs( pActivator, "func_tracktrain" ) )
{
m_code = EvaluateTrain( pTarget );
// Safe to fire?
if ( m_code == TRAIN_FOLLOWING && m_toggle_state != m_targetState )
{
DisableUse();
if (m_toggle_state == TS_AT_TOP)
GoDown();
else
GoUp();
}
}
else
{
if ( pTarget )
pTarget = pTarget->GetNext();
if ( pTarget && m_train->m_ppath != pTarget && ShouldToggle( useType, m_targetState ) )
{
if ( m_targetState == TS_AT_TOP )
m_targetState = TS_AT_BOTTOM;
else
m_targetState = TS_AT_TOP;
}
UpdateAutoTargets( m_targetState );
}
}
View Git Blame Copy Permalink