3379 lines
84 KiB
C++
3379 lines
84 KiB
C++
//========= 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 );
|
|
}
|
|
}
|