mittorn/Paranoia2
1
0
Fork 0
forked from FWGS/Paranoia2
Code Issues Pull Requests Projects Releases Wiki Activity
5cc388c45e
Paranoia2/dlls/plats.cpp
Alibek Omarov 5cc388c45e CRLF to LF
2020-08-31 19:50:41 +03:00

3287 lines
86 KiB
C++
Raw Blame History

/***
*
* Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
/*
===== plats.cpp ========================================================
spawn, think, and touch functions for trains, etc
*/
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "trains.h"
#include "saverestore.h"
#include "movewith.h"
static void PlatSpawnInsideTrigger(entvars_t* pevPlatform);
static float Fix( float angle )
{
if ( IS_NAN(angle) )
{
ALERT(at_debug, "NaN error during Fix!\n");
return angle;
}
while ( angle < 0 )
angle += 360;
while ( angle > 360 )
angle -= 360;
return angle;
}
static void FixupAngles( Vector &v )
{
v.x = Fix( v.x );
v.y = Fix( v.y );
v.z = Fix( v.z );
}
class CFuncTrain;
//LRC - scripted_trainsequence
class CTrainSequence : public CBaseEntity
{
public:
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EndThink( void );
void TimeOutThink( void );
void KeyValue( KeyValueData *pkvd );
STATE GetState( void ) { return (m_pTrain||m_pTrackTrain)?STATE_ON:STATE_OFF; }
virtual int ObjectCaps( void );
void StopSequence( void );
void ArrivalNotify( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
string_t m_iszEntity;
string_t m_iszDestination;
string_t m_iszTerminate;
int m_iDirection;
int m_iPostDirection;
float m_fDuration;
// at any given time, at most one of these pointers will be set.
CFuncTrain *m_pTrain;
CFuncTrackTrain *m_pTrackTrain;
CBaseEntity *m_pDestination;
};
#define SF_PLAT_TOGGLE 0x0001
class CBasePlatTrain : public CBaseToggle
{
public:
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void KeyValue( KeyValueData* pkvd);
void Precache( void );
// This is done to fix spawn flag collisions between this class and a derived class
virtual BOOL IsTogglePlat( void ) { return (pev->spawnflags & SF_PLAT_TOGGLE) ? TRUE : FALSE; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
BYTE m_bMoveSnd; // sound a plat makes while moving
BYTE m_bStopSnd; // sound a plat makes when it stops
float m_volume; // Sound volume
};
TYPEDESCRIPTION CBasePlatTrain::m_SaveData[] =
{
DEFINE_FIELD( CBasePlatTrain, m_bMoveSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBasePlatTrain, m_bStopSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBasePlatTrain, m_volume, FIELD_FLOAT ),
};
IMPLEMENT_SAVERESTORE( CBasePlatTrain, CBaseToggle );
void CBasePlatTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "lip"))
{
m_flLip = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "wait"))
{
m_flWait = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_flHeight = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "rotation"))
{
m_vecFinalAngle.x = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "movesnd"))
{
m_bMoveSnd = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "stopsnd"))
{
m_bStopSnd = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "custommovesnd"))
{
pev->noise = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "customstopsnd"))
{
pev->noise1 = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "volume"))
{
m_volume = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseToggle::KeyValue( pkvd );
}
#define noiseMoving noise
#define noiseArrived noise1
void CBasePlatTrain::Precache( void )
{
// set the plat's "in-motion" sound
if (FStringNull(pev->noiseMoving))
{
switch (m_bMoveSnd)
{
case 1:
pev->noiseMoving = MAKE_STRING("plats/bigmove1.wav");
break;
case 2:
pev->noiseMoving = MAKE_STRING("plats/bigmove2.wav");
break;
case 3:
pev->noiseMoving = MAKE_STRING("plats/elevmove1.wav");
break;
case 4:
pev->noiseMoving = MAKE_STRING("plats/elevmove2.wav");
break;
case 5:
pev->noiseMoving = MAKE_STRING("plats/elevmove3.wav");
break;
case 6:
pev->noiseMoving = MAKE_STRING("plats/freightmove1.wav");
break;
case 7:
pev->noiseMoving = MAKE_STRING("plats/freightmove2.wav");
break;
case 8:
pev->noiseMoving = MAKE_STRING("plats/heavymove1.wav");
break;
case 9:
pev->noiseMoving = MAKE_STRING("plats/rackmove1.wav");
break;
case 10:
pev->noiseMoving = MAKE_STRING("plats/railmove1.wav");
break;
case 11:
pev->noiseMoving = MAKE_STRING("plats/squeekmove1.wav");
break;
case 12:
pev->noiseMoving = MAKE_STRING("plats/talkmove1.wav");
break;
case 13:
pev->noiseMoving = MAKE_STRING("plats/talkmove2.wav");
break;
default:
pev->noiseMoving = MAKE_STRING("common/null.wav");
break;
}
}
PRECACHE_SOUND ((char*)STRING(pev->noiseMoving));
// set the plat's 'reached destination' stop sound
if (FStringNull(pev->noiseArrived))
{
switch (m_bStopSnd)
{
case 1:
pev->noiseArrived = MAKE_STRING("plats/bigstop1.wav");
break;
case 2:
pev->noiseArrived = MAKE_STRING("plats/bigstop2.wav");
break;
case 3:
pev->noiseArrived = MAKE_STRING("plats/freightstop1.wav");
break;
case 4:
pev->noiseArrived = MAKE_STRING("plats/heavystop2.wav");
break;
case 5:
pev->noiseArrived = MAKE_STRING("plats/rackstop1.wav");
break;
case 6:
pev->noiseArrived = MAKE_STRING("plats/railstop1.wav");
break;
case 7:
pev->noiseArrived = MAKE_STRING("plats/squeekstop1.wav");
break;
case 8:
pev->noiseArrived = MAKE_STRING("plats/talkstop1.wav");
break;
default:
pev->noiseArrived = MAKE_STRING("common/null.wav");
break;
}
}
PRECACHE_SOUND ((char*)STRING(pev->noiseArrived));
}
//
//====================== PLAT code ====================================================
//
#define noiseMovement noise
#define noiseStopMoving noise1
class CFuncPlat : public CBasePlatTrain
{
public:
void Spawn( void );
void Precache( void );
void Setup( void );
virtual void Blocked( CBaseEntity *pOther );
void EXPORT PlatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CallGoUp( void ) { GoUp(); }
void EXPORT CallGoDown( void ) { GoDown(); }
void EXPORT CallHitTop( void ) { HitTop(); }
void EXPORT CallHitBottom( void ) { HitBottom(); }
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
};
LINK_ENTITY_TO_CLASS( func_plat, CFuncPlat );
// UNDONE: Need to save this!!! It needs class & linkage
class CPlatTrigger : public CBaseEntity
{
public:
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
void SpawnInsideTrigger( CFuncPlat *pPlatform );
void Touch( CBaseEntity *pOther );
CFuncPlat *m_pPlatform;
};
/*QUAKED func_plat (0 .5 .8) ? PLAT_LOW_TRIGGER
speed default 150
Plats are always drawn in the extended position, so they will light correctly.
If the plat is the target of another trigger or button, it will start out disabled in
the extended position until it is trigger, when it will lower and become a normal plat.
If the "height" key is set, that will determine the amount the plat moves, instead of
being implicitly determined by the model's height.
Set "sounds" to one of the following:
1) base fast
2) chain slow
*/
void CFuncPlat :: Setup( void )
{
//pev->noiseMovement = MAKE_STRING("plats/platmove1.wav");
//pev->noiseStopMoving = MAKE_STRING("plats/platstop1.wav");
if (m_flTLength == 0)
m_flTLength = 80;
if (m_flTWidth == 0)
m_flTWidth = 10;
pev->angles = g_vecZero;
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(this, pev->origin); // set size and link into world
UTIL_SetSize(pev, pev->mins, pev->maxs);
SET_MODEL(ENT(pev), STRING(pev->model) );
// vecPosition1 is the top position, vecPosition2 is the bottom
if (m_pMoveWith)
m_vecPosition1 = pev->origin - m_pMoveWith->pev->origin;
else
m_vecPosition1 = pev->origin;
m_vecPosition2 = m_vecPosition1;
if (m_flHeight != 0)
m_vecPosition2.z = m_vecPosition2.z - m_flHeight;
else
m_vecPosition2.z = m_vecPosition2.z - pev->size.z + 8;
if (pev->speed == 0)
pev->speed = 150;
if ( m_volume == 0 )
m_volume = 0.85;
}
void CFuncPlat :: Precache( )
{
CBasePlatTrain::Precache();
//PRECACHE_SOUND("plats/platmove1.wav");
//PRECACHE_SOUND("plats/platstop1.wav");
if ( !IsTogglePlat() )
PlatSpawnInsideTrigger( pev ); // the "start moving" trigger
}
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 ( !FStringNull(pev->targetname) )
{
if (m_pMoveWith)
UTIL_AssignOrigin (this, m_vecPosition1 + m_pMoveWith->pev->origin);
else
UTIL_AssignOrigin (this, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
SetUse(&CFuncPlat :: PlatUse );
}
else
{
if (m_pMoveWith)
UTIL_AssignOrigin (this, m_vecPosition2 + m_pMoveWith->pev->origin);
else
UTIL_AssignOrigin (this, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
}
}
static void PlatSpawnInsideTrigger(entvars_t* pevPlatform)
{
GetClassPtr( (CPlatTrigger *)NULL)->SpawnInsideTrigger( GetClassPtr( (CFuncPlat *)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
pev->solid = SOLID_TRIGGER;
pev->movetype = MOVETYPE_NONE;
pev->origin = pPlatform->pev->origin;
// Establish the trigger field's size
Vector vecTMin = m_pPlatform->pev->mins + Vector ( 25 , 25 , 0 );
Vector vecTMax = m_pPlatform->pev->maxs + Vector ( 25 , 25 , 8 );
vecTMin.z = vecTMax.z - ( m_pPlatform->m_vecPosition1.z - m_pPlatform->m_vecPosition2.z + 8 );
if (m_pPlatform->pev->size.x <= 50)
{
vecTMin.x = (m_pPlatform->pev->mins.x + m_pPlatform->pev->maxs.x) / 2;
vecTMax.x = vecTMin.x + 1;
}
if (m_pPlatform->pev->size.y <= 50)
{
vecTMin.y = (m_pPlatform->pev->mins.y + m_pPlatform->pev->maxs.y) / 2;
vecTMax.y = vecTMin.y + 1;
}
UTIL_SetSize ( pev, vecTMin, vecTMax );
}
//
// When the platform's trigger field is touched, the platform ???
//
void CPlatTrigger :: Touch( CBaseEntity *pOther )
{
// Ignore touches by non-players
entvars_t* pevToucher = pOther->pev;
if ( !FClassnameIs (pevToucher, "player") )
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->SetNextThink( 1 );// delay going down
}
//
// Used by SUB_UseTargets, when a platform is the target of a button.
// Start bringing platform down.
//
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)
{
SetNextThink( 0.01 );
SetThink(&CFuncPlat :: CallGoDown );
}
else if ( m_toggle_state == TS_AT_BOTTOM )
{
SetNextThink( 0.01 );
SetThink(&CFuncPlat :: CallGoUp );
}
}
else
{
SetUse( NULL );
if (m_toggle_state == TS_AT_TOP)
{
SetNextThink( 0.01 );
SetThink(&CFuncPlat :: CallGoDown );
}
}
}
//
// Platform is at top, now starts moving down.
//
void CFuncPlat :: GoDown( void )
{
if(pev->noiseMovement)
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
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, pev->speed);
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlat :: HitBottom( void )
{
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
if (pev->noiseStopMoving)
EMIT_SOUND(ENT(pev), CHAN_WEAPON, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
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 )
{
if (pev->noiseMovement)
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
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, pev->speed);
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlat :: HitTop( void )
{
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
if (pev->noiseStopMoving)
EMIT_SOUND(ENT(pev), CHAN_WEAPON, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
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.
SetThink(&CFuncPlat :: CallGoDown );
SetNextThink( 3 );
}
}
void CFuncPlat :: Blocked( CBaseEntity *pOther )
{
ALERT( at_aiconsole, "%s Blocked by %s\n", STRING(pev->classname), STRING(pOther->pev->classname) );
// Hurt the blocker a little
pOther->TakeDamage(pev, pev, 1, DMG_CRUSH);
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
// 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)
{
SetNextThink( 0 );
SetThink(&CFuncPlat :: GoDown );
}
else if (m_toggle_state == TS_GOING_DOWN)
{
SetNextThink( 0 );
SetThink(&CFuncPlat :: GoUp );
}
}
class CFuncPlatRot : public CFuncPlat
{
public:
void Spawn( void );
void SetupRotation( void );
virtual void KeyValue( KeyValueData *pkvd );
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
void RotMove( Vector &destAngle, float time );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
Vector m_end, m_start;
};
LINK_ENTITY_TO_CLASS( func_platrot, CFuncPlatRot );
TYPEDESCRIPTION CFuncPlatRot::m_SaveData[] =
{
DEFINE_FIELD( CFuncPlatRot, m_end, FIELD_VECTOR ),
DEFINE_FIELD( CFuncPlatRot, m_start, FIELD_VECTOR ),
};
IMPLEMENT_SAVERESTORE( CFuncPlatRot, CFuncPlat );
void CFuncPlatRot::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "axes"))
{
UTIL_StringToVector((float*)(pev->movedir), pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CFuncPlat::KeyValue( pkvd );
}
void CFuncPlatRot :: SetupRotation( void )
{
if ( m_vecFinalAngle.x != 0 ) // This plat rotates too!
{
CBaseToggle :: AxisDir( pev );
m_start = pev->angles;
m_end = pev->angles + pev->movedir * m_vecFinalAngle.x;
}
else
{
m_start = g_vecZero;
m_end = g_vecZero;
}
if ( !FStringNull(pev->targetname) ) // Start at top
{
UTIL_SetAngles(this, m_end);
//pev->angles = m_end;
}
}
void CFuncPlatRot :: Spawn( void )
{
CFuncPlat :: Spawn();
SetupRotation();
}
void CFuncPlatRot :: GoDown( void )
{
CFuncPlat :: GoDown();
Vector vecDest;
if (m_pMoveWith)
{
vecDest = m_vecFinalDest + m_pMoveWith->pev->origin;
}
else
vecDest = m_vecFinalDest;
Vector vecDestDelta = vecDest - pev->origin;
float flTravelTime = vecDestDelta.Length() / m_flLinearMoveSpeed;
RotMove( m_start, flTravelTime );
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlatRot :: HitBottom( void )
{
CFuncPlat :: HitBottom();
UTIL_SetAvelocity(this, g_vecZero);
//pev->avelocity = g_vecZero;
UTIL_SetAngles(this, m_start);
//pev->angles = m_start;
}
//
// Platform is at bottom, now starts moving up
//
void CFuncPlatRot :: GoUp( void )
{
CFuncPlat :: GoUp();
Vector vecDest;
if (m_pMoveWith)
{
vecDest = m_vecFinalDest + m_pMoveWith->pev->origin;
}
else
vecDest = m_vecFinalDest;
Vector vecDestDelta = vecDest - pev->origin;
float flTravelTime = vecDestDelta.Length() / m_flLinearMoveSpeed;
RotMove( m_end, flTravelTime );
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlatRot :: HitTop( void )
{
CFuncPlat :: HitTop();
UTIL_SetAvelocity(this, g_vecZero);
//pev->avelocity = g_vecZero;
UTIL_SetAngles(this, m_end);
//pev->angles = m_end;
}
void CFuncPlatRot :: RotMove( Vector &destAngle, float time )
{
// set destdelta to the vector needed to move
Vector vecDestDelta = destAngle - pev->angles;
// Travel time is so short, we're practically there already; make it so.
if ( time >= 0.1)
{
UTIL_SetAvelocity(this, vecDestDelta / time);
//pev->avelocity = vecDestDelta / time;
}
else
{
UTIL_SetAvelocity(this, vecDestDelta);
//pev->avelocity = vecDestDelta;
SetNextThink( 1 );
}
}
//
//====================== TRAIN code ==================================================
//
//the others are defined in const.h
// SF_TRAIN_WAIT_RETRIGGER 1
#define SF_TRAIN_SETORIGIN 2
// SF_TRAIN_START_ON 4 // Train is initially moving
// SF_TRAIN_PASSABLE 8 // Train is not solid -- used to make water trains
#define SF_TRAIN_REVERSE 0x800000
class CFuncTrain : public CBasePlatTrain
{
public:
void Spawn( void );
void Precache( void );
void PostSpawn( void );
void OverrideReset( void );
void Blocked( CBaseEntity *pOther );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void KeyValue( KeyValueData *pkvd );
//LRC
void StartSequence(CTrainSequence *pSequence);
void StopSequence( );
CTrainSequence *m_pSequence;
void EXPORT Wait( void );
void EXPORT Next( void );
void EXPORT ThinkDoNext( void );
void EXPORT SoundSetup( void );
STATE GetState( void ) { return m_iState; }
virtual void ThinkCorrection( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
entvars_t *m_pevCurrentTarget;
int m_sounds;
//LRC - now part of CBaseEntity: BOOL m_activated;
STATE m_iState;
float m_fStoredThink;
Vector m_vecAvelocity;
};
LINK_ENTITY_TO_CLASS( func_train, CFuncTrain );
TYPEDESCRIPTION CFuncTrain::m_SaveData[] =
{
DEFINE_FIELD( CFuncTrain, m_sounds, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrain, m_pevCurrentTarget, FIELD_EVARS ),
//LRC - now part of CBaseEntity: DEFINE_FIELD( CFuncTrain, m_activated, FIELD_BOOLEAN ),
DEFINE_FIELD( CFuncTrain, m_iState, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrain, m_fStoredThink, FIELD_TIME ),
DEFINE_FIELD( CFuncTrain, m_pSequence, FIELD_CLASSPTR ), //LRC
DEFINE_FIELD( CFuncTrain, m_vecAvelocity, FIELD_VECTOR ), //LRC
};
IMPLEMENT_SAVERESTORE( CFuncTrain, CBasePlatTrain );
void CFuncTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "sounds"))
{
m_sounds = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBasePlatTrain::KeyValue( pkvd );
}
void CFuncTrain :: Blocked( CBaseEntity *pOther )
{
// Keep "movewith" entities in line
UTIL_AssignOrigin(this, pev->origin);
if ( gpGlobals->time < m_flActivateFinished)
return;
m_flActivateFinished = gpGlobals->time + 0.5;
if (pev->dmg)
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
void CFuncTrain :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( ShouldToggle( useType ) )
{
if (pev->spawnflags & SF_TRAIN_WAIT_RETRIGGER)
{
// Move toward my target
// ALERT(at_console, "Unset Retrigger (use)\n");
pev->spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
Next();
}
else
{
// ALERT(at_console, "Set Retrigger (use)\n");
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
// Pop back to last target if it's available
if ( pev->enemy )
pev->target = pev->enemy->v.targetname;
DontThink();
UTIL_SetVelocity(this, g_vecZero);
UTIL_SetAvelocity(this, g_vecZero);
m_iState = STATE_OFF;
// pev->velocity = g_vecZero;
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
}
}
}
void CFuncTrain :: Wait( void )
{
// ALERT(at_console, "Wait t %s, m %s\n", STRING(pev->target), STRING(pev->message));
if (m_pSequence)
m_pSequence->ArrivalNotify();
// Fire the pass target if there is one
if ( m_pevCurrentTarget->message )
{
FireTargets( STRING(m_pevCurrentTarget->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( m_pevCurrentTarget->spawnflags, SF_CORNER_FIREONCE ) )
m_pevCurrentTarget->message = 0;
}
// need pointer to LAST target.
if ( FBitSet (m_pevCurrentTarget->spawnflags , SF_TRAIN_WAIT_RETRIGGER ) || ( pev->spawnflags & SF_TRAIN_WAIT_RETRIGGER ) )
{
// if (FBitSet (m_pevCurrentTarget->spawnflags , SF_TRAIN_WAIT_RETRIGGER ))
// ALERT(at_console, "Wait: wait for retrigger from path %s\n", STRING(m_pevCurrentTarget->targetname));
// else
// ALERT(at_console, "Wait: wait for retrigger from train\n");
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
m_iState = STATE_OFF;
// clear the sound channel.
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
UTIL_SetVelocity(this, g_vecZero);
UTIL_SetAvelocity(this, g_vecZero);
DontThink();
return;
}
// ALERT ( at_console, "%f\n", m_flWait );
if (m_flWait != 0)
{// -1 wait will wait forever!
m_iState = STATE_OFF;
UTIL_SetAvelocity(this, g_vecZero);
UTIL_SetVelocity(this, g_vecZero);
SetNextThink( m_flWait );
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
SetThink(&CFuncTrain :: Next );
// ALERT(at_console, "Wait: doing Next in %f\n", m_flWait);
}
else
{
// ALERT(at_console, "Wait: doing Next now\n");
Next();// do it right now!
}
}
//
// Train next - path corner needs to change to next target
//
void CFuncTrain :: Next( void )
{
CBaseEntity *pTarg;
// now find our next target
pTarg = GetNextTarget();
if ( !pTarg )
{
// no destination, just come to a halt
m_iState = STATE_OFF;
UTIL_SetVelocity(this, g_vecZero);
UTIL_SetAvelocity(this, g_vecZero);
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
// Play stop sound
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
return;
}
// Save last target in case we need to find it again
pev->message = pev->target;
// if (m_pevCurrentTarget)
// ALERT(at_console, "Next, pTarg %s, pevTarg %s\n", STRING(pTarg->pev->targetname), STRING(m_pevCurrentTarget->targetname));
// else
// ALERT(at_console, "Next, pTarg %s, pevTarg null\n", STRING(pTarg->pev->targetname));
if (pev->spawnflags & SF_TRAIN_REVERSE && m_pSequence)
{
//LRC - search backwards
CBaseEntity *pSearch = m_pSequence->m_pDestination;
while (pSearch)
{
if (FStrEq(STRING(pSearch->pev->target), STRING(pev->target)))
{
// pSearch leads to the current corner, so it's the next thing we're moving to.
pev->target = pSearch->pev->targetname;
// ALERT(at_console, "Next, pSearch %s\n", STRING(pSearch->pev->targetname));
break;
}
pSearch = pSearch->GetNextTarget();
}
}
else
{
pev->target = pTarg->pev->target;
}
// ALERT(at_console, "Next, new pevtarget %s, new message %s\n", STRING(pev->target), STRING(pev->message));
m_flWait = pTarg->GetDelay();
// don't copy speed from target if it is 0 (uninitialized)
if ( m_pevCurrentTarget )
{
if ( m_pevCurrentTarget->speed != 0 )
{
switch ((int)(m_pevCurrentTarget->armortype))
{
case PATHSPEED_SET:
pev->speed = m_pevCurrentTarget->speed;
ALERT( at_aiconsole, "Train %s speed set to %4.2f\n", STRING(pev->targetname), pev->speed );
break;
case PATHSPEED_ACCEL:
pev->speed += m_pevCurrentTarget->speed;
ALERT( at_aiconsole, "Train %s speed accel to %4.2f\n", STRING(pev->targetname), pev->speed );
break;
case PATHSPEED_TIME:
float distance;
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
distance = (pev->origin - pTarg->pev->origin).Length();
else
distance = (pev->origin - (pTarg->pev->origin - (pev->mins + pev->maxs) * 0.5)).Length();
pev->speed = distance / m_pevCurrentTarget->speed;
ALERT( at_aiconsole, "Train %s speed to %4.2f (timed)\n", STRING(pev->targetname), pev->speed );
break;
}
}
if (m_pevCurrentTarget->spawnflags & SF_CORNER_AVELOCITY)
{
m_vecAvelocity = pTarg->pev->avelocity;
UTIL_SetAvelocity(this, m_vecAvelocity);
//pev->avelocity = pTarg->pev->avelocity; //LRC
}
if (m_pevCurrentTarget->armorvalue)
{
UTIL_SetAngles(this, m_pevCurrentTarget->angles);
//pev->angles = m_pevCurrentTarget->angles; //LRC - if we just passed a "turn to face" corner, set angle exactly.
}
}
m_pevCurrentTarget = pTarg->pev;// keep track of this since path corners change our target for us.
pev->enemy = pTarg->edict();//hack
if( FBitSet(pTarg->pev->spawnflags, SF_CORNER_TELEPORT) ) //LRC - cosmetic change to use pTarg
{
// Path corner has indicated a teleport to the next corner.
SetBits(pev->effects, EF_NOINTERP);
if (m_pMoveWith)
{
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
UTIL_AssignOrigin(this, pTarg->pev->origin - m_pMoveWith->pev->origin );
else
UTIL_AssignOrigin(this, pTarg->pev->origin - (pev->mins + pev->maxs) * 0.5 - m_pMoveWith->pev->origin );
}
else
{
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
UTIL_AssignOrigin(this, pTarg->pev->origin );
else
UTIL_AssignOrigin(this, pTarg->pev->origin - (pev->mins + pev->maxs) * 0.5 );
}
if (pTarg->pev->armorvalue) //LRC - "teleport and turn to face" means you set an angle as you teleport.
{
UTIL_SetAngles(this, pTarg->pev->angles);
//pev->angles = pTarg->pev->angles;
}
Wait(); // Get on with doing the next path corner.
}
else
{
// Normal linear move.
// CHANGED this from CHAN_VOICE to CHAN_STATIC around OEM beta time because trains should
// use CHAN_STATIC for their movement sounds to prevent sound field problems.
// this is not a hack or temporary fix, this is how things should be. (sjb).
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseMovement )
EMIT_SOUND (ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
ClearBits(pev->effects, EF_NOINTERP);
SetMoveDone(&CFuncTrain :: Wait );
if (pTarg->pev->armorvalue) //LRC - "turn to face" the next corner
{
Vector vTemp = pev->angles;
FixupAngles( vTemp );
UTIL_SetAngles(this, vTemp);
Vector oDelta = pTarg->pev->origin - pev->origin;
Vector aDelta = pTarg->pev->angles - pev->angles;
float timeTaken = oDelta.Length() / pev->speed;
m_vecAvelocity = aDelta / timeTaken;
//pev->avelocity = aDelta / timeTaken;
}
UTIL_SetAvelocity(this, m_vecAvelocity);
m_iState = STATE_ON;
if (m_pMoveWith)
{
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
LinearMove( pTarg->pev->origin - m_pMoveWith->pev->origin, pev->speed );
else
LinearMove (pTarg->pev->origin - (pev->mins + pev->maxs)* 0.5 - m_pMoveWith->pev->origin, pev->speed);
}
else
{
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
LinearMove( pTarg->pev->origin, pev->speed );
else
LinearMove (pTarg->pev->origin - (pev->mins + pev->maxs)* 0.5, pev->speed);
}
// ALERT(at_console, "Next: LMove done\n");
// ALERT(at_console, "Next ends, nextthink %f, flags %f\n", pev->nextthink, m_iLFlags);
}
}
//LRC- called by Activate. (but not when a game is loaded.)
void CFuncTrain :: PostSpawn( void )
{
CBaseEntity *pTarget = UTIL_FindEntityByTargetname (NULL, STRING(pev->target) );
entvars_t *pevTarg;
m_iState = STATE_OFF;
if (pTarget)
{
pevTarg = pTarget->pev;
}
else
{
ALERT(at_debug, "Missing train target \"%s\"\n", STRING(pev->target));
return;
}
pev->message = pevTarg->targetname; //LRC - record the old target so that we can find it again
pev->target = pevTarg->target;
m_pevCurrentTarget = pevTarg;// keep track of this since path corners change our target for us.
if (pev->avelocity != g_vecZero)
{
m_vecAvelocity = pev->avelocity;
UTIL_SetAvelocity(this, g_vecZero);
}
if (pev->spawnflags & SF_TRAIN_SETORIGIN)
{
m_vecSpawnOffset = m_vecSpawnOffset + pevTarg->origin - pev->origin;
if (m_pMoveWith)
UTIL_AssignOrigin (this, pevTarg->origin - m_pMoveWith->pev->origin );
else
UTIL_AssignOrigin (this, pevTarg->origin );
}
else
{
m_vecSpawnOffset = m_vecSpawnOffset + (pevTarg->origin - (pev->mins + pev->maxs) * 0.5) - pev->origin;
if (m_pMoveWith)
UTIL_AssignOrigin (this, pevTarg->origin - (pev->mins + pev->maxs) * 0.5 - m_pMoveWith->pev->origin );
else
UTIL_AssignOrigin (this, pevTarg->origin - (pev->mins + pev->maxs) * 0.5 );
}
if ( FStringNull(pev->targetname) || pev->spawnflags & SF_TRAIN_START_ON)
{ // not triggered, so start immediately
SetNextThink( 1.5 );
// SetThink( Next );
SetThink(&CFuncTrain :: ThinkDoNext );
}
else
{
// ALERT(at_console, "Set Retrigger (postspawn)\n");
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
}
// ALERT(at_console, "func_train postspawn: origin %f %f %f\n", pev->origin.x, pev->origin.y, pev->origin.z);
}
void CFuncTrain :: ThinkDoNext( void )
{
SetNextThink( 0.1 );
// ALERT(at_console, "TDN ");
if (gpGlobals->time != 1.0) // only go on if the game has properly started yet
SetThink(&CFuncTrain :: Next );
}
//LRC
void CFuncTrain :: StartSequence(CTrainSequence *pSequence)
{
m_pSequence = pSequence;
// ALERT(at_console, "Unset Retrigger (startsequence)\n");
pev->spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
// m_iState = STATE_ON;
//...
}
//LRC
void CFuncTrain :: StopSequence( )
{
m_pSequence = NULL;
// pev->spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
pev->spawnflags &= ~SF_TRAIN_REVERSE;
Use(this, this, USE_OFF, 0);
//...
}
/*QUAKED func_train (0 .5 .8) ?
Trains are moving platforms that players can ride.
The targets origin specifies the min point of the train at each corner.
The train spawns at the first target it is pointing at.
If the train is the target of a button or trigger, it will not begin moving until activated.
speed default 100
dmg default 2
sounds
1) ratchet metal
*/
void CFuncTrain :: Spawn( void )
{
Precache();
if (pev->speed == 0)
pev->speed = 100;
// if (!(pev->origin == g_vecZero))
// {
// pev->spawnflags |= SF_TRAIN_SETORIGIN;
// m_vecSpawnOffset = pev->origin;
// }
if ( FStringNull(pev->target) )
ALERT(at_debug, "func_train \"%s\" has no target\n", STRING(pev->targetname));
if (pev->dmg == 0)
pev->dmg = 2;
else if (pev->dmg == -1) //LRC- a train that doesn't crush people!
pev->dmg = 0;
pev->movetype = MOVETYPE_PUSH;
if ( FBitSet (pev->spawnflags, SF_TRACKTRAIN_PASSABLE) )
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize (pev, pev->mins, pev->maxs);
UTIL_SetOrigin(this, pev->origin);
m_iState = STATE_OFF;
if ( m_volume == 0 )
m_volume = 0.85;
}
//LRC - making movement sounds which continue after a game is loaded.
void CFuncTrain :: SoundSetup( void )
{
EMIT_SOUND (ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
SetNextThink( m_fStoredThink - pev->ltime );
// ALERT(at_console, "SoundSetup: mfNT %f, pevNT %f, stored was %f, time %f", m_fNextThink, pev->nextthink, m_fStoredThink, pev->ltime );
m_fStoredThink = 0;
SetThink(&CFuncTrain :: LinearMoveDone );
}
//LRC
void CFuncTrain :: ThinkCorrection( void )
{
if (m_fStoredThink && pev->nextthink != m_fPevNextThink)
{
// ALERT(at_console, "StoredThink Correction for train \"%s\", %f -> %f\n", STRING(pev->targetname), m_fStoredThink, m_fStoredThink + pev->nextthink - m_fPevNextThink);
m_fStoredThink += pev->nextthink - m_fPevNextThink;
}
CBasePlatTrain::ThinkCorrection();
}
void CFuncTrain :: Precache( void )
{
CBasePlatTrain::Precache();
//LRC - continue the movement sound after loading a game
if (m_iState == STATE_ON && pev->noiseMovement)
{
// we can't set up SFX during precache, so get a think to do it.
// Unfortunately, since we're moving, we must be already thinking.
// So we store the current think time, and will restore it after SFX are done.
if (!m_fStoredThink)
m_fStoredThink = m_fNextThink;
SetNextThink( 0.1 );
// ALERT(at_console, "preparing SoundSetup: stored %f, mfNT %f, pevNT %f, ltime %f", m_fStoredThink, m_fNextThink, pev->nextthink, pev->ltime);
SetThink(&CFuncTrain :: SoundSetup );
}
#if 0 // obsolete
// otherwise use preset sound
switch (m_sounds)
{
case 0:
pev->noise = 0;
pev->noise1 = 0;
break;
case 1:
PRECACHE_SOUND ("plats/train2.wav");
PRECACHE_SOUND ("plats/train1.wav");
pev->noise = MAKE_STRING("plats/train2.wav");
pev->noise1 = MAKE_STRING("plats/train1.wav");
break;
case 2:
PRECACHE_SOUND ("plats/platmove1.wav");
PRECACHE_SOUND ("plats/platstop1.wav");
pev->noise = MAKE_STRING("plats/platstop1.wav");
pev->noise1 = MAKE_STRING("plats/platmove1.wav");
break;
}
#endif
}
void CFuncTrain::OverrideReset( void )
{
CBaseEntity *pTarg;
// Are we moving?
if ( m_iState == STATE_ON ) //pev->velocity != g_vecZero && pev->nextthink != 0 )
{
pev->target = pev->message;
// now find our next target
pTarg = GetNextTarget();
if ( !pTarg )
{
DontThink();
UTIL_SetVelocity(this, g_vecZero);
m_iState = STATE_OFF;
}
else // Keep moving for 0.1 secs, then find path_corner again and restart
{
SetThink(&CFuncTrain:: Next );
SetNextThink( 0.1 );
}
}
}
// ---------------------------------------------------------------------
//
// Track Train
//
// ---------------------------------------------------------------------
void CFuncTrackTrain :: Spawn( void )
{
if ( pev->speed == 0 )
m_speed = 100;
else
m_speed = pev->speed;
pev->speed = 0;
pev->velocity = g_vecZero; // why do they set this stuff? --LRC
m_vecBaseAvel = pev->avelocity; //LRC - save it for later
pev->avelocity = g_vecZero;
pev->impulse = m_speed;
m_dir = 1;
if ( FStringNull(pev->target) )
{
if ( FStringNull(pev->targetname) )
ALERT( at_debug, "func_tracktrain with no target\n" );
else
ALERT( at_debug, "func_tracktrain %s has no target\n", STRING(pev->targetname));
}
if ( pev->spawnflags & SF_TRACKTRAIN_PASSABLE )
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetOrigin( this, pev->origin );
// ALERT(at_console, "SpawnOrigin %f %f %f\n", pev->origin.x, pev->origin.y, pev->origin.z);
// Cache off placed origin for train controls
pev->oldorigin = pev->origin;
m_controlMins = pev->mins;
m_controlMaxs = pev->maxs;
m_controlMaxs.z += 72;
// start trains on the next frame, to make sure their targets have had
// a chance to spawn/activate
NextThink( 0.1, FALSE );
SetThink(&CFuncTrackTrain :: Find );
Precache();
}
void CFuncTrackTrain :: Precache( void )
{
if (m_flVolume == 0.0)
m_flVolume = 1.0;
switch (m_sounds)
{
default:
//pev->noise = 0; LRC - allow custom sounds to be set in worldcraft.
break;
case 1: pev->noise = MAKE_STRING("plats/ttrain1.wav");break;
case 2: pev->noise = MAKE_STRING("plats/ttrain2.wav");break;
case 3: pev->noise = MAKE_STRING("plats/ttrain3.wav");break;
case 4: pev->noise = MAKE_STRING("plats/ttrain4.wav");break;
case 5: pev->noise = MAKE_STRING("plats/ttrain6.wav");break;
case 6: pev->noise = MAKE_STRING("plats/ttrain7.wav");break;
}
if (FStringNull(pev->noise1))
pev->noise1 = MAKE_STRING("plats/ttrain_brake1.wav");
if (FStringNull(pev->noise2))
pev->noise2 = MAKE_STRING("plats/ttrain_start1.wav");
if (pev->noise)
PRECACHE_SOUND((char*)STRING(pev->noise)); //LRC
PRECACHE_SOUND((char*)STRING(pev->noise1));
PRECACHE_SOUND((char*)STRING(pev->noise2));
m_usAdjustPitch = PRECACHE_EVENT( 1, "evTrainSound" );
}
TYPEDESCRIPTION CFuncTrackTrain::m_SaveData[] =
{
DEFINE_FIELD( CFuncTrackTrain, m_ppath, FIELD_CLASSPTR ),
DEFINE_FIELD( CFuncTrackTrain, m_length, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_height, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_speed, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_dir, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_startSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_controlMins, FIELD_VECTOR ),
DEFINE_FIELD( CFuncTrackTrain, m_controlMaxs, FIELD_VECTOR ),
DEFINE_FIELD( CFuncTrackTrain, m_sounds, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackTrain, m_flVolume, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_flBank, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_oldSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_vecMasterAvel, FIELD_VECTOR ), //LRC
DEFINE_FIELD( CFuncTrackTrain, m_vecBaseAvel, FIELD_VECTOR ), //LRC
DEFINE_FIELD( CFuncTrackTrain, m_pSequence, FIELD_CLASSPTR ), //LRC
};
IMPLEMENT_SAVERESTORE( CFuncTrackTrain, CBaseEntity );
LINK_ENTITY_TO_CLASS( func_tracktrain, CFuncTrackTrain );
void CFuncTrackTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "wheels"))
{
m_length = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_height = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "startspeed"))
{
m_startSpeed = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "sounds"))
{
m_sounds = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "custommovesound"))
{
pev->noise = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "custombrakesound"))
{
pev->noise1 = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "customstartsound"))
{
pev->noise2 = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "volume"))
{
m_flVolume = (float) (atoi(pkvd->szValue));
m_flVolume *= 0.1;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "bank"))
{
m_flBank = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue( pkvd );
}
void CFuncTrackTrain :: NextThink( float thinkTime, BOOL alwaysThink )
{
if ( alwaysThink )
// m_iLFlags |= LF_ALWAYSTHINK;
pev->flags |= FL_ALWAYSTHINK;
else
// m_iLFlags &= ~LF_ALWAYSTHINK;
pev->flags &= ~FL_ALWAYSTHINK;
SetNextThink( thinkTime, TRUE );
}
void CFuncTrackTrain :: Blocked( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
// Blocker is on-ground on the train
if ( FBitSet( pevOther->flags, FL_ONGROUND ) && VARS(pevOther->groundentity) == pev )
{
float deltaSpeed = fabs(pev->speed);
if ( deltaSpeed > 50 )
deltaSpeed = 50;
if ( !pevOther->velocity.z )
pevOther->velocity.z += deltaSpeed;
return;
}
else
pevOther->velocity = (pevOther->origin - pev->origin ).Normalize() * pev->dmg;
ALERT( at_aiconsole, "TRAIN(%s): Blocked by %s (dmg:%.2f)\n", STRING(pev->targetname), STRING(pOther->pev->classname), pev->dmg );
if ( pev->dmg <= 0 )
return;
// we can't hurt this thing, so we're not concerned with it
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
void CFuncTrackTrain :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// ALERT(at_debug, "TRAIN: use\n");
if ( useType != USE_SET )
{
if ( !ShouldToggle( useType, (pev->speed != 0) ) )
return;
if ( pev->speed == 0 )
{
pev->speed = m_speed * m_dir;
PostponeNext();
}
else
{
pev->speed = 0;
UTIL_SetVelocity(this, g_vecZero); //LRC
//pev->velocity = g_vecZero;
if (!FBitSet(pev->spawnflags, SF_TRACKTRAIN_AVELOCITY))
UTIL_SetAvelocity(this, g_vecZero); //LRC
//pev->avelocity = g_vecZero;
StopSound();
SetThink( NULL );
}
}
else
{
float delta = value;
delta = ((int)(pev->speed * 4) / (int)m_speed)*0.25 + 0.25 * delta;
if ( delta > 1 )
delta = 1;
else if ( delta < -1 )
delta = -1;
if ( pev->spawnflags & SF_TRACKTRAIN_FORWARDONLY )
{
if ( delta < 0 )
delta = 0;
}
pev->speed = m_speed * delta;
if ( pev->spawnflags & SF_TRACKTRAIN_AVEL_GEARS )
{
UTIL_SetAvelocity(this, m_vecMasterAvel * delta);
//pev->avelocity = m_vecMasterAvel * delta; //LRC
}
PostponeNext();
ALERT( at_aiconsole, "TRAIN(%s), speed to %.2f\n", STRING(pev->targetname), pev->speed );
}
}
#define TRAIN_STARTPITCH 60
#define TRAIN_MAXPITCH 200
#define TRAIN_MAXSPEED 1000 // approx max speed for sound pitch calculation
void CFuncTrackTrain :: StopSound( void )
{
// if sound playing, stop it
if (m_soundPlaying && pev->noise)
{
if (m_sounds) //LRC - flashy event-based method, for normal sounds.
{
unsigned short us_encode;
unsigned short us_sound = ( ( unsigned short )( m_sounds ) & 0x0007 ) << 12;
us_encode = us_sound;
PLAYBACK_EVENT_FULL( FEV_RELIABLE | FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, us_encode, 0, 1, 0 );
}
else
{
//LRC - down-to-earth method, for custom sounds.
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
}
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, (char*)STRING(pev->noise1), m_flVolume, ATTN_NORM, 0, 100);
}
m_soundPlaying = 0;
}
// update pitch based on speed, start sound if not playing
// NOTE: when train goes through transition, m_soundPlaying should go to 0,
// which will cause the looped sound to restart.
void CFuncTrackTrain :: UpdateSound( void )
{
float flpitch;
if (!pev->noise)
return;
flpitch = TRAIN_STARTPITCH + (abs(pev->speed) * (TRAIN_MAXPITCH - TRAIN_STARTPITCH) / TRAIN_MAXSPEED);
if (!m_soundPlaying)
{
// play startup sound for train
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, (char*)STRING(pev->noise2), m_flVolume, ATTN_NORM, 0, 100);
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, 0, (int) flpitch);
m_soundPlaying = 1;
}
else
{
if (m_sounds) //LRC - flashy event-based method, for normal sounds.
{
// volume 0.0 - 1.0 - 6 bits
// m_sounds 3 bits
// flpitch = 6 bits
// 15 bits total
unsigned short us_encode;
unsigned short us_sound = ( ( unsigned short )( m_sounds ) & 0x0007 ) << 12;
unsigned short us_pitch = ( ( unsigned short )( flpitch / 10.0 ) & 0x003f ) << 6;
unsigned short us_volume = ( ( unsigned short )( m_flVolume * 40.0 ) & 0x003f );
us_encode = us_sound | us_pitch | us_volume;
PLAYBACK_EVENT_FULL( FEV_RELIABLE | FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, us_encode, 0, 0, 0 );
}
else
{
//LRC - down-to-earth method, for custom sounds.
// update pitch
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, SND_CHANGE_PITCH, (int) flpitch);
}
}
}
void CFuncTrackTrain :: PostponeNext( void )
{
UTIL_DesiredAction(this);
}
void CFuncTrackTrain :: DesiredAction( void ) // Next( void )
{
float time = 0.5;
// ALERT(at_console, "Next: pos %f %f %f, vel %f %f %f. Child pos %f %f %f, vel %f %f %f\n", pev->origin.x, pev->origin.y, pev->origin.z, pev->velocity.x, pev->velocity.y, pev->velocity.z, m_pChildMoveWith->pev->origin.x, m_pChildMoveWith->pev->origin.y, m_pChildMoveWith->pev->origin.z, m_pChildMoveWith->pev->velocity.x, m_pChildMoveWith->pev->velocity.y, m_pChildMoveWith->pev->velocity.z);
// UTIL_DesiredInfo(this);
// static float stime;
// ALERT(at_console, "TRAIN: think delay = %f\n", gpGlobals->time - stime);
// stime = gpGlobals->time;
if ( !pev->speed )
{
// ALERT(at_console, "TRAIN: no speed\n");
UTIL_SetVelocity(this, g_vecZero);
DontThink();
ALERT( at_aiconsole, "TRAIN(%s): Speed is 0\n", STRING(pev->targetname) );
StopSound();
return;
}
// if ( !m_ppath )
// m_ppath = UTIL_FindEntityByTargetname( NULL, STRING(pev->target) );
if ( !m_ppath )
{
// ALERT(at_debug, "TRAIN: no path\n");
UTIL_SetVelocity(this, g_vecZero);
DontThink();
ALERT( at_aiconsole, "TRAIN(%s): Lost path\n", STRING(pev->targetname) );
StopSound();
return;
}
UpdateSound();
Vector nextPos = pev->origin;
nextPos.z -= m_height;
CPathTrack *pnext = m_ppath->LookAhead( &nextPos, pev->speed * 0.1, 1 );
nextPos.z += m_height;
UTIL_SetVelocity( this, (nextPos - pev->origin) * 10 ); //LRC
// Vector vD = (nextPos - pev->origin) * 10;
// ALERT(at_debug, "TRAIN: Set vel to (%f %f %f)\n", vD.x, vD.y, vD.z);
//pev->velocity = (nextPos - pev->origin) * 10;
Vector nextFront = pev->origin;
nextFront.z -= m_height;
if ( m_length > 0 )
m_ppath->LookAhead( &nextFront, m_length, 0 );
else
m_ppath->LookAhead( &nextFront, 100, 0 );
nextFront.z += m_height;
if (!FBitSet(pev->spawnflags, SF_TRACKTRAIN_AVELOCITY)) //LRC
{
Vector delta = nextFront - pev->origin;
Vector angles = UTIL_VecToAngles( delta );
// The train actually points west
angles.y += 180; //LRC, FIXME: add a 'built facing' field.
// !!! All of this crap has to be done to make the angles not wrap around, revisit this.
FixupAngles( angles );
FixupAngles( pev->angles );
if ( !pnext || (delta.x == 0 && delta.y == 0) )
angles = pev->angles;
float vy, vx, vz;
if ( !(pev->spawnflags & SF_TRACKTRAIN_NOPITCH) )
vx = 10*UTIL_AngleDistance( angles.x, pev->angles.x );
else
vx = m_vecBaseAvel.x;
if ( !(pev->spawnflags & SF_TRACKTRAIN_NOYAW) ) //LRC
vy = 10*UTIL_AngleDistance( angles.y, pev->angles.y );
else
vy = m_vecBaseAvel.y;
if ( m_flBank != 0 )
{
if ( pev->avelocity.y < -5 )
vz = UTIL_AngleDistance( UTIL_ApproachAngle( -m_flBank, pev->angles.z, m_flBank*2 ), pev->angles.z);
else if ( pev->avelocity.y > 5 )
vz = UTIL_AngleDistance( UTIL_ApproachAngle( m_flBank, pev->angles.z, m_flBank*2 ), pev->angles.z);
else
vz = UTIL_AngleDistance( UTIL_ApproachAngle( 0, pev->angles.z, m_flBank*4 ), pev->angles.z) * 4;
}
else
{
vz = m_vecBaseAvel.z;
}
UTIL_SetAvelocity(this, Vector(vx, vy, vz));
//pev->avelocity.y = vy;
//pev->avelocity.x = vx;
}
if ( pnext )
{
if ( pnext != m_ppath )
{
// ALERT(at_debug, "TRAIN: new m_ppath %s, was %s. Origin %f %f %f\n", STRING(pnext->pev->targetname), STRING(m_ppath->pev->targetname), pev->origin.x, pev->origin.y, pev->origin.z);
CPathTrack *pFire;
if ( pev->speed >= 0 ) // check whether we're going forwards or backwards
pFire = pnext;
else
pFire = m_ppath;
m_ppath = pnext;
// Fire the pass target if there is one
if ( pFire->pev->message )
{
FireTargets( STRING(pFire->pev->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( pFire->pev->spawnflags, SF_PATH_FIREONCE ) )
pFire->pev->message = 0;
}
if ( pFire->pev->spawnflags & SF_PATH_DISABLE_TRAIN )
pev->spawnflags |= SF_TRACKTRAIN_NOCONTROL;
//LRC is "match angle" set to "Yes"? If so, set the angle exactly, because we've reached the corner.
if ( pFire->pev->armorvalue == PATHMATCH_YES && pev->spawnflags & SF_TRACKTRAIN_AVELOCITY )
{
Vector vTemp = pFire->pev->angles;
vTemp.y -= 180; //the train is actually built facing west.
UTIL_SetAngles(this, vTemp);
//pev->angles = pFire->pev->angles;
//pev->angles.y -= 180; //the train is actually built facing west.
}
float setting = ((int)(pev->speed*4) / (int)m_speed) / 4.0; //LRC - one of { 1, 0.75, 0.5, 0.25, 0, ... -1 }
//LRC
if ( pFire->pev->frags == PATHTURN_RESET )
{
pev->spawnflags &= ~(SF_TRACKTRAIN_AVEL_GEARS | SF_TRACKTRAIN_AVELOCITY);
}
else if ( pFire->pev->spawnflags & SF_PATH_AVELOCITY)
{
if ( pFire->pev->frags == PATHTURN_SET_MASTER )
{
m_vecMasterAvel = pFire->pev->avelocity;
UTIL_SetAvelocity(this, m_vecMasterAvel * setting);
//pev->avelocity = m_vecMasterAvel * setting;
pev->spawnflags |= (SF_TRACKTRAIN_AVEL_GEARS | SF_TRACKTRAIN_AVELOCITY);
}
else if ( pFire->pev->frags == PATHTURN_SET )
{
UTIL_SetAvelocity(this, pFire->pev->avelocity);
//pev->avelocity = pFire->pev->avelocity;
pev->spawnflags |= SF_TRACKTRAIN_AVELOCITY;
pev->spawnflags &= ~SF_TRACKTRAIN_AVEL_GEARS;
}
}
CPathTrack* pDest; //LRC - the path_track we're heading for, after pFire.
if (pev->speed > 0)
pDest = pFire->GetNext();
else
pDest = pFire->GetPrevious();
// ALERT(at_debug, "and pDest is %s\n", STRING(pDest->pev->targetname));
//LRC
// don't look at speed from target if it is 0 (uninitialized)
if ( pFire->pev->speed != 0)
{
//ALERT( at_console, "TrackTrain setting is %d / %d = %.2f\n", (int)(pev->speed*4), (int)m_speed, setting );
switch ( (int)(pFire->pev->armortype) )
{
case PATHSPEED_SET:
// Don't override speed if under user control
if (pev->spawnflags & SF_TRACKTRAIN_NOCONTROL)
pev->speed = pFire->pev->speed;
ALERT( at_aiconsole, "TrackTrain %s speed set to %4.2f\n", STRING(pev->targetname), pev->speed );
break;
case PATHSPEED_SET_MASTER:
m_speed = pFire->pev->speed;
pev->impulse = m_speed;
pev->speed = setting * m_speed;
ALERT( at_aiconsole, "TrackTrain %s master speed set to %4.2f\n", STRING(pev->targetname), pev->speed );
break;
case PATHSPEED_ACCEL:
m_speed += pFire->pev->speed;
pev->impulse = m_speed;
pev->speed = setting * m_speed;
ALERT( at_aiconsole, "TrackTrain %s speed accel to %4.2f\n", STRING(pev->targetname), pev->speed );
break;
case PATHSPEED_TIME:
float distance = (pev->origin - pDest->pev->origin).Length();
//ALERT(at_debug, "pFire=%s, distance=%.2f, ospeed=%.2f, nspeed=%.2f\n", STRING(pFire->pev->targetname), distance, pev->speed, distance / pFire->pev->speed);
m_speed = distance / pFire->pev->speed;
pev->impulse = m_speed;
pev->speed = setting * m_speed;
ALERT( at_aiconsole, "TrackTrain %s speed to %4.2f (timed)\n", STRING(pev->targetname), pev->speed );
break;
}
}
//LRC
if (pDest->pev->armorvalue == PATHMATCH_YES)
{
pev->spawnflags |= SF_TRACKTRAIN_AVELOCITY | SF_TRACKTRAIN_AVEL_GEARS;
Vector vTemp = pev->angles;
FixupAngles( vTemp );
UTIL_SetAngles(this, vTemp );
Vector oDelta = pDest->pev->origin - pev->origin;
Vector aDelta;
if (setting > 0)
{
aDelta.x = UTIL_AngleDistance(pDest->pev->angles.x, pev->angles.x);
aDelta.y = UTIL_AngleDistance(pDest->pev->angles.y, pev->angles.y);
aDelta.z = UTIL_AngleDistance(pDest->pev->angles.z, pev->angles.z);
}
else
{
aDelta.x = UTIL_AngleDistance(pev->angles.x, pDest->pev->angles.x);
aDelta.y = UTIL_AngleDistance(pev->angles.y, pDest->pev->angles.y);
aDelta.z = UTIL_AngleDistance(pev->angles.z, pDest->pev->angles.z);
}
if (aDelta.y > 0) // the train is actually built facing west.
aDelta.y -= 180;
else
aDelta.y += 180;
float timeTaken = oDelta.Length() / m_speed;
m_vecMasterAvel = aDelta / timeTaken;
UTIL_SetAvelocity(this, setting * m_vecMasterAvel);
//pev->avelocity = setting * m_vecMasterAvel;
}
//LRC- FIXME: add support, here, for a Teleport flag.
}
// else
// {
// ALERT(at_debug, "TRAIN: same pnext\n");
// }
SetThink(&CFuncTrackTrain :: PostponeNext );
NextThink( time, TRUE );
}
else // end of path, stop
{
Vector vecTemp; //LRC
StopSound();
vecTemp = (nextPos - pev->origin); //LRC
// ALERT(at_debug, "TRAIN: path end\n");
// UTIL_SetVelocity( this, (nextPos - pev->origin) * 10 ); //LRC
// pev->velocity = (nextPos - pev->origin);
if (!FBitSet(pev->spawnflags, SF_TRACKTRAIN_AVELOCITY)) //LRC
UTIL_SetAvelocity(this, g_vecZero);
//pev->avelocity = g_vecZero;
float distance = vecTemp.Length(); //LRC
//float distance = pev->velocity.Length();
m_oldSpeed = pev->speed;
pev->speed = 0;
// Move to the dead end
// Are we there yet?
if ( distance > 0 )
{
// no, how long to get there?
time = distance / m_oldSpeed;
UTIL_SetVelocity( this, vecTemp * (m_oldSpeed / distance) ); //LRC
//pev->velocity = pev->velocity * (m_oldSpeed / distance);
SetThink(&CFuncTrackTrain :: DeadEnd );
NextThink( time, FALSE );
}
else
{
UTIL_SetVelocity( this, vecTemp ); //LRC
DeadEnd();
}
}
}
void CFuncTrackTrain::DeadEnd( void )
{
// Fire the dead-end target if there is one
CPathTrack *pTrack, *pNext;
pTrack = m_ppath;
ALERT( at_aiconsole, "TRAIN(%s): Dead end ", STRING(pev->targetname) );
// 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 );
}
}
UTIL_SetVelocity( this, g_vecZero ); //LRC
// pev->velocity = g_vecZero;
if (!FBitSet(pev->spawnflags, SF_TRACKTRAIN_AVELOCITY)) //LRC
UTIL_SetAvelocity(this, g_vecZero );
//pev->avelocity = g_vecZero;
if ( pTrack )
{
ALERT( at_aiconsole, "at %s\n", STRING(pTrack->pev->targetname) );
if ( pTrack->pev->netname )
FireTargets( STRING(pTrack->pev->netname), this, this, USE_TOGGLE, 0 );
}
else
ALERT( at_aiconsole, "\n" );
}
void CFuncTrackTrain :: SetControls( entvars_t *pevControls )
{
Vector offset = pevControls->origin - pev->oldorigin;
m_controlMins = pevControls->mins + offset;
m_controlMaxs = pevControls->maxs + offset;
}
BOOL CFuncTrackTrain :: OnControls( entvars_t *pevTest )
{
Vector offset = pevTest->origin - pev->origin;
if ( pev->spawnflags & SF_TRACKTRAIN_NOCONTROL )
return FALSE;
// Transform offset into local coordinates
UTIL_MakeVectors( pev->angles );
Vector local;
local.x = DotProduct( offset, gpGlobals->v_forward );
local.y = -DotProduct( offset, gpGlobals->v_right );
local.z = DotProduct( offset, gpGlobals->v_up );
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*)UTIL_FindEntityByTargetname( NULL, STRING(pev->target) );
if ( !m_ppath )
return;
entvars_t *pevTarget = m_ppath->pev;
if ( !FClassnameIs( pevTarget, "path_track" ) )
{
ALERT( at_error, "func_track_train must be on a path of path_track\n" );
m_ppath = NULL;
return;
}
Vector nextPos = pevTarget->origin;
nextPos.z += m_height;
Vector look = nextPos;
look.z -= m_height;
m_ppath->LookAhead( &look, m_length, 0 );
look.z += m_height;
Vector vTemp = UTIL_VecToAngles( look - nextPos );
vTemp.y += 180;
// The train actually points west
//pev->angles.y += 180;
if ( pev->spawnflags & SF_TRACKTRAIN_NOPITCH )
{
vTemp.x = 0;
//pev->angles.x = 0;
}
UTIL_SetAngles(this, vTemp); //LRC
UTIL_AssignOrigin ( this, nextPos ); //LRC
// ALERT(at_console, "Train Find; origin %f %f %f\n", pev->origin.x, pev->origin.y, pev->origin.z);
//UTIL_SetOrigin( this, nextPos );
NextThink( 0.1, FALSE );
// NextThink( 8, FALSE ); //LRC - What was this for?!
// SetThink( Next );
SetThink(&CFuncTrackTrain :: PostponeNext );
pev->speed = m_startSpeed;
UpdateSound();
}
void CFuncTrackTrain :: NearestPath( void )
{
CBaseEntity *pTrack = NULL;
CBaseEntity *pNearest = NULL;
float dist, closest;
closest = 1024;
while ((pTrack = UTIL_FindEntityInSphere( pTrack, pev->origin, 1024 )) != NULL)
{
// filter out non-tracks
if ( !(pTrack->pev->flags & (FL_CLIENT|FL_MONSTER)) && FClassnameIs( pTrack->pev, "path_track" ) )
{
dist = (pev->origin - pTrack->pev->origin).Length();
if ( dist < closest )
{
closest = dist;
pNearest = pTrack;
}
}
}
if ( !pNearest )
{
ALERT( at_debug, "Can't find a nearby track !!!\n" );
SetThink(NULL);
return;
}
ALERT( at_aiconsole, "TRAIN: %s, Nearest track is %s\n", STRING(pev->targetname), STRING(pNearest->pev->targetname) );
// 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 ( (pev->origin - pTrack->pev->origin).Length() < (pev->origin - pNearest->pev->origin).Length() )
pNearest = pTrack;
}
m_ppath = (CPathTrack *)pNearest;
if ( pev->speed != 0 )
{
NextThink( 0.1, FALSE );
SetThink(&CFuncTrackTrain :: PostponeNext );
}
}
void CFuncTrackTrain::OverrideReset( void )
{
NextThink( 0.1, FALSE );
SetThink(&CFuncTrackTrain:: NearestPath );
}
CFuncTrackTrain *CFuncTrackTrain::Instance( edict_t *pent )
{
if ( FClassnameIs( pent, "func_tracktrain" ) )
return (CFuncTrackTrain *)GET_PRIVATE(pent);
return NULL;
}
//LRC
void CFuncTrackTrain :: StartSequence(CTrainSequence *pSequence)
{
m_pSequence = pSequence;
// ALERT(at_console, "Unset Retrigger (startsequence)\n");
pev->spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
//...
}
//LRC
void CFuncTrackTrain :: StopSequence( )
{
DontThink();
m_pSequence = NULL;
//...
}
// This class defines the volume of space that the player must stand in to control the train
class CFuncTrainControls : public CBaseEntity
{
public:
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void Spawn( void );
void EXPORT Find( void );
};
LINK_ENTITY_TO_CLASS( func_traincontrols, CFuncTrainControls );
void CFuncTrainControls :: Find( void )
{
CBaseEntity *pTarget = NULL;
do
{
pTarget = UTIL_FindEntityByTargetname( pTarget, STRING(pev->target) );
} while ( pTarget && !FClassnameIs(pTarget->pev, "func_tracktrain") );
if ( !pTarget )
{
ALERT( at_debug, "TrackTrainControls: No train %s\n", STRING(pev->target) );
return;
}
CFuncTrackTrain *ptrain = (CFuncTrackTrain*)pTarget;
ptrain->SetControls( pev );
UTIL_Remove( this );
}
void CFuncTrainControls :: Spawn( void )
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetOrigin( this, pev->origin );
SetThink(&CFuncTrainControls :: Find );
SetNextThink( 0 );
}
// ----------------------------------------------------------------------------
//
// Track changer / Train elevator
//
// ----------------------------------------------------------------------------
#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
//
// 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.
//
typedef enum { TRAIN_SAFE, TRAIN_BLOCKING, TRAIN_FOLLOWING } TRAIN_CODE;
class CFuncTrackChange : public CFuncPlatRot
{
public:
void Spawn( void );
void Precache( void );
// virtual void Blocked( void );
virtual void EXPORT GoUp( void );
virtual void EXPORT GoDown( void );
void KeyValue( KeyValueData* pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT Find( void );
TRAIN_CODE EvaluateTrain( CPathTrack *pcurrent );
void UpdateTrain( Vector &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; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual void OverrideReset( void );
CPathTrack *m_trackTop;
CPathTrack *m_trackBottom;
CFuncTrackTrain *m_train;
int m_trackTopName;
int m_trackBottomName;
int m_trainName;
TRAIN_CODE m_code;
int m_targetState;
int m_use;
};
LINK_ENTITY_TO_CLASS( func_trackchange, CFuncTrackChange );
TYPEDESCRIPTION CFuncTrackChange::m_SaveData[] =
{
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackTop, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackBottom, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_train, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackTopName, FIELD_STRING ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackBottomName, FIELD_STRING ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trainName, FIELD_STRING ),
DEFINE_FIELD( CFuncTrackChange, m_code, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackChange, m_targetState, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackChange, m_use, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CFuncTrackChange, CFuncPlatRot );
void CFuncTrackChange :: Spawn( void )
{
Setup();
if ( FBitSet( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
m_vecPosition2.z = pev->origin.z;
SetupRotation();
if ( FBitSet( pev->spawnflags, SF_TRACK_STARTBOTTOM ) )
{
UTIL_SetOrigin (this, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
pev->angles = m_start;
m_targetState = TS_AT_TOP;
}
else
{
UTIL_SetOrigin (this, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
pev->angles = m_end;
m_targetState = TS_AT_BOTTOM;
}
EnableUse();
pev->nextthink = pev->ltime + 2.0;
SetThink(&CFuncTrackChange :: Find );
Precache();
}
void CFuncTrackChange :: Precache( void )
{
// Can't trigger sound
PRECACHE_SOUND( "buttons/button11.wav" );
CFuncPlatRot::Precache();
}
// UNDONE: Filter touches before re-evaluating the train.
void CFuncTrackChange :: Touch( CBaseEntity *pOther )
{
#if 0
TRAIN_CODE code;
entvars_t *pevToucher = pOther->pev;
#endif
}
void CFuncTrackChange :: KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "train") )
{
m_trainName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "toptrack") )
{
m_trackTopName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "bottomtrack") )
{
m_trackBottomName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
{
CFuncPlatRot::KeyValue( pkvd ); // Pass up to base class
}
}
void CFuncTrackChange::OverrideReset( void )
{
pev->nextthink = pev->ltime + 1.0;
SetThink(&CFuncTrackChange:: Find );
}
void CFuncTrackChange :: Find( void )
{
// Find track entities
CBaseEntity *pTarget;
pTarget = UTIL_FindEntityByTargetname( NULL, STRING(m_trackTopName) );
if ( pTarget && FClassnameIs(pTarget->pev, "path_track"))
{
m_trackTop = (CPathTrack*)pTarget;
pTarget = UTIL_FindEntityByTargetname( NULL, STRING(m_trackBottomName) );
if ( pTarget && FClassnameIs(pTarget->pev, "path_track"))
{
m_trackBottom = (CPathTrack*)pTarget;
pTarget = UTIL_FindEntityByTargetname( NULL, STRING(m_trainName) );
if ( pTarget && FClassnameIs(pTarget->pev, "func_tracktrain"))
{
m_train = (CFuncTrackTrain*)pTarget;
Vector center = (pev->absmin + pev->absmax) * 0.5;
m_trackBottom = m_trackBottom->Nearest( center );
m_trackTop = m_trackTop->Nearest( center );
UpdateAutoTargets( m_toggle_state );
SetThink( NULL );
return;
}
else
ALERT( at_error, "Can't find train for track change! %s\n", STRING(m_trainName) );
}
else
ALERT( at_error, "Can't find bottom track for track change! %s\n", STRING(m_trackBottomName) );
}
else
ALERT( at_error, "Can't find top track for track change! %s\n", STRING(m_trackTopName) );
}
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->pev->speed != 0 )
return TRAIN_BLOCKING;
Vector dist = pev->origin - m_train->pev->origin;
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( Vector &dest )
{
float time;
Vector vel = pev->velocity;
if (m_pfnThink == LinearMoveNow)
{
// we're going to do a LinearMoveNow: calculate the velocity it'll have
Vector vecDest;
if (m_pMoveWith)
vecDest = m_vecFinalDest + m_pMoveWith->pev->origin;
else
vecDest = m_vecFinalDest;
Vector vecDestDelta = vecDest - pev->origin;
time = vecDestDelta.Length() / m_flLinearMoveSpeed;
vel = vecDestDelta / time;
}
else
{
time = (pev->nextthink - pev->ltime);
}
m_train->pev->velocity = vel;
m_train->pev->avelocity = pev->avelocity;
m_train->NextThink( m_train->pev->ltime + time, FALSE );
// Attempt at getting the train to rotate properly around the origin of the trackchange
if ( time <= 0 )
{
// ALERT(at_console, "no time, set trainvel %f %f %f\n", m_train->pev->velocity.x, m_train->pev->velocity.y, m_train->pev->velocity.z);
return;
}
Vector offset = m_train->pev->origin - pev->origin;
Vector delta = dest - pev->angles;
// Transform offset into local coordinates
UTIL_MakeInvVectors( delta, gpGlobals );
Vector local;
local.x = DotProduct( offset, gpGlobals->v_forward );
local.y = DotProduct( offset, gpGlobals->v_right );
local.z = DotProduct( offset, gpGlobals->v_up );
local = local - offset;
m_train->pev->velocity = vel + (local * (1.0/time));
// ALERT(at_console, "set trainvel %f %f %f\n", m_train->pev->velocity.x, m_train->pev->velocity.y, m_train->pev->velocity.z);
}
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( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
{
SetMoveDone(&CFuncTrackChange :: CallHitBottom );
m_toggle_state = TS_GOING_DOWN;
AngularMove( m_start, pev->speed );
}
else
{
CFuncPlat :: GoDown();
SetMoveDone(&CFuncTrackChange :: CallHitBottom );
Vector vecDest;
if (m_pMoveWith)
{
vecDest = m_vecFinalDest + m_pMoveWith->pev->origin;
}
else
vecDest = m_vecFinalDest;
Vector vecDestDelta = vecDest - pev->origin;
float flTravelTime = vecDestDelta.Length() / m_flLinearMoveSpeed;
RotMove( m_start, flTravelTime );
// RotMove( m_start, pev->nextthink - pev->ltime );
}
// 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;
}
}
//
// 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( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
{
m_toggle_state = TS_GOING_UP;
SetMoveDone(&CFuncTrackChange :: CallHitTop );
AngularMove( m_end, pev->speed );
}
else
{
// If ROTMOVE, move & rotate
CFuncPlat :: GoUp();
SetMoveDone(&CFuncTrackChange :: CallHitTop );
Vector vecDest;
if (m_pMoveWith)
{
vecDest = m_vecFinalDest + m_pMoveWith->pev->origin;
}
else
vecDest = m_vecFinalDest;
Vector vecDestDelta = vecDest - pev->origin;
float flTravelTime = vecDestDelta.Length() / m_flLinearMoveSpeed;
RotMove( m_end, flTravelTime );
// RotMove( m_end, pev->nextthink - pev->ltime );
}
// 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;
}
}
// Normal track change
void CFuncTrackChange :: UpdateAutoTargets( int toggleState )
{
if ( !m_trackTop || !m_trackBottom )
return;
if ( toggleState == TS_AT_TOP )
ClearBits( m_trackTop->pev->spawnflags, SF_PATH_DISABLED );
else
SetBits( m_trackTop->pev->spawnflags, SF_PATH_DISABLED );
if ( toggleState == TS_AT_BOTTOM )
ClearBits( m_trackBottom->pev->spawnflags, SF_PATH_DISABLED );
else
SetBits( m_trackBottom->pev->spawnflags, 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
EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/button11.wav", 1, ATTN_NORM);
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 )
{
CFuncPlatRot :: HitBottom();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackBottom );
}
SetThink( NULL );
pev->nextthink = -1;
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncTrackChange :: HitTop( void )
{
CFuncPlatRot :: HitTop();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackTop );
}
// Don't let the plat go back down
SetThink( NULL );
pev->nextthink = -1;
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
class CFuncTrackAuto : public CFuncTrackChange
{
public:
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual void UpdateAutoTargets( int toggleState );
};
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 )
{
ClearBits( pTarget->pev->spawnflags, SF_PATH_DISABLED );
if ( m_code == TRAIN_FOLLOWING && m_train && m_train->pev->speed == 0 )
m_train->Use( this, this, USE_ON, 0 );
}
if ( pNextTarget )
SetBits( pNextTarget->pev->spawnflags, SF_PATH_DISABLED );
}
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->pev, "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 );
}
}
// ----------------------------------------------------------
//
//
// pev->speed is the travel speed
// pev->health is current health
// pev->max_health is the amount to reset to each time it starts
#define FGUNTARGET_START_ON 0x0001
class CGunTarget : public CBaseMonster
{
public:
void Spawn( void );
void Activate( void );
void EXPORT Next( void );
void EXPORT Start( void );
void EXPORT Wait( void );
void Stop( void );
int BloodColor( void ) { return DONT_BLEED; }
int Classify( void ) { return CLASS_MACHINE; }
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
Vector BodyTarget( const Vector &posSrc ) { return pev->origin; }
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
BOOL m_on;
};
LINK_ENTITY_TO_CLASS( func_guntarget, CGunTarget );
TYPEDESCRIPTION CGunTarget::m_SaveData[] =
{
DEFINE_FIELD( CGunTarget, m_on, FIELD_BOOLEAN ),
};
IMPLEMENT_SAVERESTORE( CGunTarget, CBaseMonster );
void CGunTarget::Spawn( void )
{
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(this, pev->origin);
SET_MODEL(ENT(pev), STRING(pev->model) );
if ( pev->speed == 0 )
pev->speed = 100;
// Don't take damage until "on"
pev->takedamage = DAMAGE_NO;
pev->flags |= FL_MONSTER;
m_on = FALSE;
pev->max_health = pev->health;
if ( pev->spawnflags & FGUNTARGET_START_ON )
{
SetThink(&CGunTarget:: Start );
SetNextThink( 0.3 );
}
}
void CGunTarget::Activate( void )
{
CBaseEntity *pTarg;
// now find our next target
pTarg = GetNextTarget();
if ( pTarg )
{
m_hTargetEnt = pTarg;
UTIL_SetOrigin( this, pTarg->pev->origin - (pev->mins + pev->maxs) * 0.5 );
}
CBaseMonster::Activate();
}
void CGunTarget::Start( void )
{
Use( this, this, USE_ON, 0 );
}
void CGunTarget::Next( void )
{
SetThink( NULL );
m_hTargetEnt = GetNextTarget();
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
{
Stop();
return;
}
SetMoveDone(&CGunTarget:: Wait );
LinearMove( pTarget->pev->origin - (pev->mins + pev->maxs) * 0.5, pev->speed );
}
void CGunTarget::Wait( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
{
Stop();
return;
}
// Fire the pass target if there is one
if ( pTarget->pev->message )
{
FireTargets( STRING(pTarget->pev->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( pTarget->pev->spawnflags, SF_CORNER_FIREONCE ) )
pTarget->pev->message = 0;
}
m_flWait = pTarget->GetDelay();
pev->target = pTarget->pev->target;
SetThink(&CGunTarget:: Next );
if (m_flWait != 0)
{// -1 wait will wait forever!
SetNextThink( m_flWait );
}
else
{
Next();// do it RIGHT now!
}
}
void CGunTarget::Stop( void )
{
pev->velocity = g_vecZero;
DontThink();
pev->takedamage = DAMAGE_NO;
}
int CGunTarget::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if ( pev->health > 0 )
{
pev->health -= flDamage;
if ( pev->health <= 0 )
{
pev->health = 0;
Stop();
if ( pev->message )
FireTargets( STRING(pev->message), this, this, USE_TOGGLE, 0 );
}
}
return 0;
}
void CGunTarget::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( !ShouldToggle( useType, m_on ) )
return;
if ( m_on )
{
Stop();
}
else
{
pev->takedamage = DAMAGE_AIM;
m_hTargetEnt = GetNextTarget();
if ( m_hTargetEnt == NULL )
return;
pev->health = pev->max_health;
Next();
}
}
//============================================================================
//LRC - Scripted Train Sequence
//============================================================================
#define DIRECTION_NONE 0
#define DIRECTION_FORWARDS 1
#define DIRECTION_BACKWARDS 2
#define DIRECTION_STOP 3
#define DIRECTION_DESTINATION 4
#define SF_TRAINSEQ_REMOVE 2
#define SF_TRAINSEQ_DIRECT 4
#define SF_TRAINSEQ_DEBUG 8
LINK_ENTITY_TO_CLASS( scripted_trainsequence, CTrainSequence );
TYPEDESCRIPTION CTrainSequence::m_SaveData[] =
{
DEFINE_FIELD( CTrainSequence, m_iszEntity, FIELD_STRING ),
DEFINE_FIELD( CTrainSequence, m_iszDestination, FIELD_STRING ),
DEFINE_FIELD( CTrainSequence, m_pDestination, FIELD_CLASSPTR),
DEFINE_FIELD( CTrainSequence, m_iszTerminate, FIELD_STRING ),
DEFINE_FIELD( CTrainSequence, m_fDuration, FIELD_FLOAT ),
DEFINE_FIELD( CTrainSequence, m_iDirection, FIELD_INTEGER ),
DEFINE_FIELD( CTrainSequence, m_iPostDirection, FIELD_INTEGER ),
DEFINE_FIELD( CTrainSequence, m_pTrain, FIELD_CLASSPTR),
DEFINE_FIELD( CTrainSequence, m_pTrackTrain, FIELD_CLASSPTR),
};
IMPLEMENT_SAVERESTORE( CTrainSequence, CBaseEntity );
int CTrainSequence :: ObjectCaps( void )
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
}
void CTrainSequence :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "m_iDirection"))
{
m_iDirection = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iPostDirection"))
{
m_iPostDirection = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iszEntity"))
{
m_iszEntity = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iszDestination"))
{
m_iszDestination = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iszTerminate"))
{
m_iszTerminate = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue( pkvd );
}
void CTrainSequence :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// ALERT(at_console, "SeqUse\n");
if (!ShouldToggle(useType))
{
// ALERT(at_console, "SeqUse, don't toggle\n");
return;
}
else
{
// ALERT(at_console, "SeqUse ok\n");
}
if (GetState() == STATE_OFF)
{
// start the sequence, take control of the train
CBaseEntity* pEnt = UTIL_FindEntityByTargetname(NULL, STRING(m_iszEntity), pActivator);
if (pEnt)
{
m_pDestination = UTIL_FindEntityByTargetname(NULL, STRING(m_iszDestination), pActivator);
if (pev->spawnflags & SF_TRAINSEQ_DEBUG)
{
ALERT(at_console, "trainsequence \"%s\" found train \"%s\"", STRING(pev->targetname), STRING(pEnt->pev->targetname));
if (m_pDestination)
ALERT(at_console, "found destination %s\n", STRING(m_pDestination->pev->targetname));
else
ALERT(at_console, "missing destination\n");
}
if (FStrEq(STRING(pEnt->pev->classname), "func_train"))
{
CFuncTrain *pTrain = (CFuncTrain*)pEnt;
// check whether it's being controlled by another sequence
if (pTrain->m_pSequence)
{
// ALERT(at_console, "SeqUse: Train sequence already set\n");
return;
}
// ALERT(at_console, "SeqUse: Train takecontrol\n");
//ok, we can now take control of it.
pTrain->StartSequence(this);
m_pTrain = pTrain;
if (pev->spawnflags & SF_TRAINSEQ_DIRECT)
{
pTrain->pev->target = m_pDestination->pev->targetname;
pTrain->Next();
}
else
{
int iDir = DIRECTION_NONE;
switch (m_iDirection)
{
case DIRECTION_DESTINATION:
if (m_pDestination)
{
Vector vecFTemp, vecBTemp;
CBaseEntity *pTrainDest = UTIL_FindEntityByTargetname(NULL, STRING(pTrain->pev->message));
float fForward;
if (pTrain->pev->spawnflags & SF_TRAIN_SETORIGIN)
fForward = (pTrainDest->pev->origin - pTrain->pev->origin).Length();
else
fForward = (pTrainDest->pev->origin - (pTrain->pev->origin + (pTrain->pev->maxs + pTrain->pev->mins)*0.5)).Length();
float fBackward = -fForward; // the further back from the TrainDest entity we are, the shorter the backward distance.
CBaseEntity *pCurForward = pTrainDest;
CBaseEntity *pCurBackward = m_pDestination;
vecFTemp = pCurForward->pev->origin;
vecBTemp = pCurBackward->pev->origin;
int loopbreaker = 10;
while(iDir == DIRECTION_NONE)
{
if (pCurForward)
{
fForward += (pCurForward->pev->origin - vecFTemp).Length();
vecFTemp = pCurForward->pev->origin;
// ALERT(at_console, "SeqUse: Forward %f %s (%p == %p)\n", fForward, STRING(pCurForward->pev->targetname), pCurForward, m_pDestination);
// if we've finished tracing the forward line
if (pCurForward == m_pDestination)
{
// if the backward line is longest
if (fBackward >= fForward || pCurBackward == NULL)
iDir = DIRECTION_FORWARDS;
}
else
{
pCurForward = pCurForward->GetNextTarget();
}
}
if (pCurBackward)
{
fBackward += (pCurBackward->pev->origin - vecBTemp).Length();
vecBTemp = pCurBackward->pev->origin;
// ALERT(at_console, "SeqUse: Backward %f %s (%p == %p)\n", fBackward, STRING(pCurBackward->pev->targetname), pCurBackward, pTrainDest);
// if we've finished tracng the backward line
if (pCurBackward == pTrainDest)
{
// if the forward line is shorter
if (fBackward < fForward || pCurForward == NULL)
iDir = DIRECTION_BACKWARDS;
}
else
{
pCurBackward = pCurBackward->GetNextTarget();
}
}
loopbreaker--;
if (loopbreaker <= 0)
iDir = DIRECTION_STOP;
}
}
else
{
iDir = DIRECTION_STOP;
}
break;
case DIRECTION_FORWARDS: iDir = DIRECTION_FORWARDS; break;
case DIRECTION_BACKWARDS: iDir = DIRECTION_BACKWARDS; break;
case DIRECTION_STOP: iDir = DIRECTION_STOP; break;
}
// ALERT(at_console, "SeqUse: iDir is %d\n", iDir);
if (iDir == DIRECTION_BACKWARDS && !(pTrain->pev->spawnflags & SF_TRAIN_REVERSE))
{
// ALERT(at_console, "Reversing from \"%s\" \"%s\"\n", STRING(pTrain->pev->target), STRING(pTrain->pev->message));
// change direction
pTrain->pev->spawnflags |= SF_TRAIN_REVERSE;
CBaseEntity *pSearch = m_pDestination;
while (pSearch)
{
if (FStrEq(STRING(pSearch->pev->target), STRING(pTrain->pev->message)))
{
// ALERT(at_console, "SeqUse reverse: pSearch is %s\n", STRING(pSearch->pev->targetname));
CBaseEntity *pTrainTarg = pSearch->GetNextTarget();
if (pTrainTarg)
pTrain->pev->enemy = pTrainTarg->edict();
else
pTrain->pev->enemy = NULL;
pTrain->pev->target = pSearch->pev->targetname;
break;
}
pSearch = pSearch->GetNextTarget();
}
if (!pSearch)
{
// this shouldn't happen.
ALERT(at_error, "Found no path to reach destination! (train has t %s, m %s; dest is %s)\n", STRING(pTrain->pev->target), STRING(pTrain->pev->message), STRING(m_pDestination->pev->targetname));
return;
}
pTrain->m_pevCurrentTarget = NULL; // we haven't reached the corner, so don't use its settings
// if (pTrain->pev->enemy)
// ALERT(at_console, "SeqUse: pTrain target %s, enemy %s\n", STRING(pTrain->pev->target), STRING(pTrain->pev->enemy->v.targetname));
// else
// ALERT(at_console, "SeqUse: pTrain target %s, no enemy\n", STRING(pTrain->pev->target));
pTrain->Next();
}
else if (iDir == DIRECTION_FORWARDS)
{
// ALERT(at_console, "Dir_Forwards targ %s\n", STRING(pTrain->pev->target));
pTrain->pev->target = pTrain->pev->message;
pTrain->Next();
}
else if (iDir == DIRECTION_STOP)
{
SetNextThink(0.1);
SetThink(&CTrainSequence ::EndThink);
return;
}
}
}
else if (FStrEq(STRING(pEnt->pev->classname), "func_tracktrain"))
{
CFuncTrackTrain *pTrackTrain = (CFuncTrackTrain*)pEnt;
// check whether it's being controlled by another sequence
if (pTrackTrain->m_pSequence)
return;
//ok, we can now take control of it.
pTrackTrain->StartSequence(this);
m_pTrackTrain = pTrackTrain;
}
else
{
ALERT(at_error, "scripted_trainsequence %s can't affect %s \"%s\": not a train!\n", STRING(pev->targetname), STRING(pEnt->pev->classname), STRING(pEnt->pev->targetname));
return;
}
}
else // no entity with that name
{
ALERT(at_error, "Missing train \"%s\" for scripted_trainsequence %s!\n", STRING(m_iszEntity), STRING(pev->targetname));
return;
}
// if we got here, we've set up a sequence successfully.
// do the rest of the setup.
if (m_fDuration)
{
SetThink(&CTrainSequence :: TimeOutThink );
SetNextThink( m_fDuration );
}
// if (m_pTrain)
// ALERT(at_console, "m_pTrain nextthink %f, flags %f\n", STRING(m_pTrain->pev->nextthink), m_pTrain->m_iLFlags);
}
else // prematurely end the sequence
{
//disable the other end conditions
DontThink();
// release control of the train
StopSequence();
}
}
void CTrainSequence :: ArrivalNotify()
{
// ALERT(at_console, "ArrivalNotify\n");
// check whether the current path is our destination,
// and end the sequence if it is.
if (m_pTrain)
{
if (m_pTrain->m_pevCurrentTarget == m_pDestination->pev)
{
// we've reached the destination. Stop now.
// ALERT(at_console, "ArrivalNotify %s stop\n", STRING(pev->targetname));
EndThink();
}
else
{
// ALERT(at_console, "ArrivalNotify %s continue\n", STRING(pev->targetname));
}
}
else if (m_pTrackTrain)
{
//...
}
else
{
ALERT(at_error, "scripted_trainsequence: ArrivalNotify without a train!?\n");
return; // this shouldn't happen.
}
}
void CTrainSequence :: EndThink()
{
//the sequence has expired. Release control.
StopSequence();
FireTargets(STRING(pev->target), this, this, USE_TOGGLE, 0);
}
void CTrainSequence :: TimeOutThink()
{
//the sequence has timed out. Release control.
StopSequence();
FireTargets(STRING(pev->netname), this, this, USE_TOGGLE, 0);
}
void CTrainSequence :: StopSequence()
{
if (m_pTrain)
{
// ALERT(at_console, "StopSequence called\n");
//stuff...
m_pTrain->StopSequence();
m_pTrain = NULL;
if (FBitSet(pev->spawnflags, SF_TRAINSEQ_REMOVE))
UTIL_Remove( this );
}
else if (m_pTrackTrain)
{
//stuff...
}
else
{
ALERT(at_error, "scripted_trainsequence: StopSequence without a train!?\n");
return; // this shouldn't happen.
}
FireTargets(STRING(m_iszTerminate), this, this, USE_TOGGLE, 0);
}
Reference in New Issue View Git Blame Copy Permalink