//========= 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->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 );
	}
}
