//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//

#include "cbase.h"

#include "trains.h"
#include "ai_trackpather.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#define	TRACKPATHER_DEBUG_LEADING	1
#define	TRACKPATHER_DEBUG_PATH		2
#define TRACKPATHER_DEBUG_TRACKS	3
ConVar g_debug_trackpather( "g_debug_trackpather", "0", FCVAR_CHEAT );

//------------------------------------------------------------------------------

BEGIN_DATADESC( CAI_TrackPather )
	DEFINE_FIELD( m_vecDesiredPosition,		FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_vecGoalOrientation,		FIELD_VECTOR ),

	DEFINE_FIELD( m_pCurrentPathTarget,		FIELD_CLASSPTR ),
	DEFINE_FIELD( m_pDestPathTarget,		FIELD_CLASSPTR ),
	DEFINE_FIELD( m_pLastPathTarget,		FIELD_CLASSPTR ),
	DEFINE_FIELD( m_pTargetNearestPath,		FIELD_CLASSPTR ),
	
	DEFINE_FIELD( m_strCurrentPathName,		FIELD_STRING ),
	DEFINE_FIELD( m_strDestPathName,		FIELD_STRING ),
	DEFINE_FIELD( m_strLastPathName,		FIELD_STRING ),
	DEFINE_FIELD( m_strTargetNearestPathName,	FIELD_STRING ),
	
	DEFINE_FIELD( m_vecLastGoalCheckPosition,	FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_flEnemyPathUpdateTime,	FIELD_TIME ),
	DEFINE_FIELD( m_bForcedMove,			FIELD_BOOLEAN ),
	DEFINE_FIELD( m_bPatrolling,			FIELD_BOOLEAN ),
	DEFINE_FIELD( m_bPatrolBreakable,		FIELD_BOOLEAN ),
	DEFINE_FIELD( m_bLeading,				FIELD_BOOLEAN ),

	// Derived class pathing data
	DEFINE_FIELD( m_flTargetDistanceThreshold,	FIELD_FLOAT ),
	DEFINE_FIELD( m_flAvoidDistance,		FIELD_FLOAT ),

	DEFINE_FIELD( m_flTargetTolerance,		FIELD_FLOAT ),
	DEFINE_FIELD( m_vecSegmentStartPoint,	FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_vecSegmentStartSplinePoint,	FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_bMovingForward,			FIELD_BOOLEAN ),
	DEFINE_FIELD( m_bChooseFarthestPoint,	FIELD_BOOLEAN ),
	DEFINE_FIELD( m_flFarthestPathDist,		FIELD_FLOAT ),
	DEFINE_FIELD( m_flPathMaxSpeed,			FIELD_FLOAT ),
	DEFINE_FIELD( m_flTargetDistFromPath,	FIELD_FLOAT ),
	DEFINE_FIELD( m_flLeadDistance,			FIELD_FLOAT ),
	DEFINE_FIELD( m_vecTargetPathDir,		FIELD_VECTOR ),
	DEFINE_FIELD( m_vecTargetPathPoint,		FIELD_POSITION_VECTOR ),

	DEFINE_FIELD( m_nPauseState,			FIELD_INTEGER ),

	// Inputs
	DEFINE_INPUTFUNC( FIELD_STRING, "SetTrack", InputSetTrack ),
	DEFINE_INPUTFUNC( FIELD_STRING, "FlyToSpecificTrackViaPath", InputFlyToPathTrack ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "StartPatrol", InputStartPatrol ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "StopPatrol", InputStopPatrol ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "StartBreakableMovement", InputStartBreakableMovement ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "StopBreakableMovement", InputStopBreakableMovement ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "ChooseFarthestPathPoint", InputChooseFarthestPathPoint ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "ChooseNearestPathPoint", InputChooseNearestPathPoint ),
	DEFINE_INPUTFUNC( FIELD_INTEGER,"InputStartLeading", InputStartLeading ),
	DEFINE_INPUTFUNC( FIELD_VOID,	 "InputStopLeading", InputStopLeading ),

	// Obsolete, for backwards compatibility	
	DEFINE_INPUTFUNC( FIELD_VOID,	 "StartPatrolBreakable", InputStartPatrolBreakable ),
	DEFINE_INPUTFUNC( FIELD_STRING, "FlyToPathTrack", InputFlyToPathTrack ),
END_DATADESC()


//-----------------------------------------------------------------------------
// Purpose: Initialize pathing data
//-----------------------------------------------------------------------------
void CAI_TrackPather::InitPathingData( float flTrackArrivalTolerance, float flTargetDistance, float flAvoidDistance )
{
	m_flTargetTolerance = flTrackArrivalTolerance;
	m_flTargetDistanceThreshold = flTargetDistance;
	m_flAvoidDistance = flAvoidDistance;

	m_pCurrentPathTarget = NULL;
	m_pDestPathTarget = NULL;
	m_pLastPathTarget = NULL;
	m_pTargetNearestPath = NULL;
	m_bLeading = false;

	m_flEnemyPathUpdateTime	= gpGlobals->curtime;
	m_bForcedMove = false;
	m_bPatrolling = false;
	m_bPatrolBreakable = false;
	m_flLeadDistance = 0.0f;
	m_bMovingForward = true;
	m_vecSegmentStartPoint = m_vecSegmentStartSplinePoint = m_vecDesiredPosition = GetAbsOrigin();
	m_bChooseFarthestPoint = true;
	m_flFarthestPathDist = 1e10;
	m_flPathMaxSpeed = 0;
	m_nPauseState = PAUSE_NO_PAUSE; 
}

	   
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_TrackPather::OnRestore( void )
{
	BaseClass::OnRestore();

	// Restore current path
	if ( m_strCurrentPathName != NULL_STRING )
	{
		m_pCurrentPathTarget = (CPathTrack *) gEntList.FindEntityByName( NULL, m_strCurrentPathName );
	}
	else
	{
		m_pCurrentPathTarget = NULL;
	}

	// Restore destination path
	if ( m_strDestPathName != NULL_STRING )
	{
		m_pDestPathTarget = (CPathTrack *) gEntList.FindEntityByName( NULL, m_strDestPathName );
	}
	else
	{
		m_pDestPathTarget = NULL;
	}

	// Restore last path
	if ( m_strLastPathName != NULL_STRING )
	{
		m_pLastPathTarget = (CPathTrack *) gEntList.FindEntityByName( NULL, m_strLastPathName );
	}
	else
	{
		m_pLastPathTarget = NULL;
	}

	// Restore target nearest path
	if ( m_strTargetNearestPathName != NULL_STRING )
	{
		m_pTargetNearestPath = (CPathTrack *) gEntList.FindEntityByName( NULL, m_strTargetNearestPathName );
	}
	else
	{
		m_pTargetNearestPath = NULL;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_TrackPather::OnSave( IEntitySaveUtils *pUtils )
{
	BaseClass::OnSave( pUtils );

	// Stash all the paths into strings for restoration later
	m_strCurrentPathName = ( m_pCurrentPathTarget != NULL ) ? m_pCurrentPathTarget->GetEntityName() : NULL_STRING;
	m_strDestPathName = ( m_pDestPathTarget != NULL ) ? m_pDestPathTarget->GetEntityName() : NULL_STRING;
	m_strLastPathName = ( m_pLastPathTarget != NULL ) ? m_pLastPathTarget->GetEntityName() : NULL_STRING;
	m_strTargetNearestPathName = ( m_pTargetNearestPath != NULL ) ? m_pTargetNearestPath->GetEntityName() : NULL_STRING;
}


//-----------------------------------------------------------------------------
// Leading distance
//-----------------------------------------------------------------------------
void CAI_TrackPather::EnableLeading( bool bEnable )
{
	bool bWasLeading = m_bLeading;
	m_bLeading = bEnable;
	if ( m_bLeading )
	{
		m_bPatrolling = false;
	}
	else if ( bWasLeading )
	{
	
		// Going from leading to not leading. Refresh the desired position
		// to prevent us from hovering around our old, no longer valid lead position.
  		if ( m_pCurrentPathTarget )
		{
			SetDesiredPosition( m_pCurrentPathTarget->GetAbsOrigin() );
		}
	}
}

void CAI_TrackPather::SetLeadingDistance( float flLeadDistance )
{
	m_flLeadDistance = flLeadDistance;
}

float CAI_TrackPather::GetLeadingDistance( ) const
{
	return m_flLeadDistance;
}


//-----------------------------------------------------------------------------
// Returns the next path along our current path
//-----------------------------------------------------------------------------
inline CPathTrack *CAI_TrackPather::NextAlongCurrentPath( CPathTrack *pPath ) const
{
	return CPathTrack::ValidPath( m_bMovingForward ? pPath->GetNext() : pPath->GetPrevious() );
}

inline CPathTrack *CAI_TrackPather::PreviousAlongCurrentPath( CPathTrack *pPath ) const
{
	return CPathTrack::ValidPath( m_bMovingForward ? pPath->GetPrevious() : pPath->GetNext() );
}

inline CPathTrack *CAI_TrackPather::AdjustForMovementDirection( CPathTrack *pPath ) const
{
	if ( !m_bMovingForward && CPathTrack::ValidPath( pPath->GetPrevious( ) ) )
	{
		pPath = CPathTrack::ValidPath( pPath->GetPrevious() );
	}
	return pPath;
}

	
//-----------------------------------------------------------------------------
// Enemy visibility check
//-----------------------------------------------------------------------------
CBaseEntity *CAI_TrackPather::FindTrackBlocker( const Vector &vecViewPoint, const Vector &vecTargetPos )
{
	trace_t	tr;
	AI_TraceHull( vecViewPoint, vecTargetPos, -Vector(4,4,4), Vector(4,4,4), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
	return (tr.fraction != 1.0f) ? tr.m_pEnt : NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &targetPos - 
// Output : CBaseEntity
//-----------------------------------------------------------------------------
CPathTrack *CAI_TrackPather::BestPointOnPath( CPathTrack *pPath, const Vector &targetPos, float flAvoidRadius, bool visible, bool bFarthestPoint )
{
	// Find the node nearest to the destination path target if a path is not specified
	if ( pPath == NULL )
	{
		pPath = m_pDestPathTarget;
	}

	// If the path node we're trying to use is not valid, then we're done.
	if ( CPathTrack::ValidPath( pPath ) == NULL )
	{
		//FIXME: Implement
		Assert(0);
		return NULL;
	}

	// Our target may be in a vehicle
	CBaseEntity *pVehicle = NULL;
	CBaseEntity *pTargetEnt = GetTrackPatherTargetEnt();	
	if ( pTargetEnt != NULL )
	{
		CBaseCombatCharacter *pCCTarget = pTargetEnt->MyCombatCharacterPointer();
		if ( pCCTarget != NULL && pCCTarget->IsInAVehicle() )
		{
			pVehicle = pCCTarget->GetVehicleEntity();
		}
	}

	// Faster math...
	flAvoidRadius *= flAvoidRadius;

	// Find the nearest node to the target (going forward)
	CPathTrack *pNearestPath	= NULL;
	float		flNearestDist	= bFarthestPoint ? 0 : 999999999;
	float		flPathDist;

	float flFarthestDistSqr = ( m_flFarthestPathDist - 2.0f * m_flTargetDistanceThreshold );
	flFarthestDistSqr *= flFarthestDistSqr;

	// NOTE: Gotta do it this crazy way because paths can be one-way.
	for ( int i = 0; i < 2; ++i )
	{
		int loopCheck = 0;
		CPathTrack *pTravPath = pPath;
		CPathTrack *pNextPath;

		BEGIN_PATH_TRACK_ITERATION();
		for ( ; CPathTrack::ValidPath( pTravPath ); pTravPath = pNextPath, loopCheck++ )
		{
			// Circular loop checking
			if ( pTravPath->HasBeenVisited() )
				break;

			pTravPath->Visit();

			pNextPath = (i == 0) ? pTravPath->GetPrevious() : pTravPath->GetNext();

			// Find the distance between this test point and our goal point
			flPathDist = ( pTravPath->GetAbsOrigin() - targetPos ).LengthSqr();

			// See if it's closer and it's also not within our avoidance radius
			if ( bFarthestPoint )
			{
				if ( ( flPathDist <= flNearestDist ) && ( flNearestDist <= flFarthestDistSqr ) )
					continue;
			}
			else
			{
				if ( flPathDist >= flNearestDist ) 
					continue;
			}

			// Don't choose points that are within the avoid radius
			if ( flAvoidRadius && ( pTravPath->GetAbsOrigin() - targetPos ).Length2DSqr() <= flAvoidRadius )
				continue;

			if ( visible )
			{
				// If it has to be visible, run those checks
				CBaseEntity *pBlocker = FindTrackBlocker( pTravPath->GetAbsOrigin(), targetPos );

				// Check to see if we've hit the target, or the player's vehicle if it's a player in a vehicle
				bool bHitTarget = ( pTargetEnt && ( pTargetEnt == pBlocker ) ) ||
									( pVehicle && ( pVehicle == pBlocker ) );

				// If we hit something, and it wasn't the target or his vehicle, then no dice
				// If we hit the target and forced move was set, *still* no dice
				if ( (pBlocker != NULL) && ( !bHitTarget || m_bForcedMove ) )
					continue;
			}

			pNearestPath	= pTravPath;
			flNearestDist	= flPathDist;
		}
	}

	return pNearestPath;
}


//-----------------------------------------------------------------------------
// Compute a point n units along a path
//-----------------------------------------------------------------------------
CPathTrack *CAI_TrackPather::ComputeLeadingPointAlongPath( const Vector &vecStartPoint, 
				CPathTrack *pFirstTrack, float flDistance, Vector *pTarget )
{
	bool bMovingForward = (flDistance > 0.0f);
	flDistance = fabs(flDistance);

	CPathTrack *pTravPath = pFirstTrack;
	if ( (!bMovingForward) && pFirstTrack->GetPrevious() )
	{
		pTravPath = pFirstTrack->GetPrevious();
	}

	*pTarget = vecStartPoint;
	CPathTrack *pNextPath;

	// No circular loop checking needed; eventually, it'll run out of distance
	for ( ; CPathTrack::ValidPath( pTravPath ); pTravPath = pNextPath )
	{
		pNextPath = bMovingForward ? pTravPath->GetNext() : pTravPath->GetPrevious();

		// Find the distance between this test point and our goal point
		float flPathDist = pTarget->DistTo( pTravPath->GetAbsOrigin() );

		// Find the distance between this test point and our goal point
		if ( flPathDist <= flDistance )
		{
			flDistance -= flPathDist;
			*pTarget = pTravPath->GetAbsOrigin();
			if ( !CPathTrack::ValidPath(pNextPath) )
				return bMovingForward ? pTravPath : pTravPath->GetNext();

			continue;
		}
		
		ComputeClosestPoint( *pTarget, flDistance, pTravPath->GetAbsOrigin(), pTarget );
		return bMovingForward ? pTravPath : pTravPath->GetNext();
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Compute the distance to a particular point on the path
//-----------------------------------------------------------------------------
float CAI_TrackPather::ComputeDistanceAlongPathToPoint( CPathTrack *pStartTrack, 
	CPathTrack *pDestTrack, const Vector &vecDestPosition, bool bMovingForward )
{													  
	float flTotalDist = 0.0f;

	Vector vecPoint;
	ClosestPointToCurrentPath( &vecPoint );

	CPathTrack *pTravPath = pStartTrack;
	CPathTrack *pNextPath, *pTestPath;
	BEGIN_PATH_TRACK_ITERATION();
	for ( ; CPathTrack::ValidPath( pTravPath ); pTravPath = pNextPath )
	{
		// Circular loop checking
		if ( pTravPath->HasBeenVisited() )
			break;

		// Mark it as being visited.
		pTravPath->Visit();

		pNextPath = bMovingForward ? pTravPath->GetNext() : pTravPath->GetPrevious();
		pTestPath = pTravPath;
		Assert( pTestPath );

		if ( pTravPath == pDestTrack )
		{
			Vector vecDelta;
			Vector vecPathDelta;
			VectorSubtract( vecDestPosition, vecPoint, vecDelta );
			ComputePathDirection( pTravPath, &vecPathDelta );
			float flDot = DotProduct( vecDelta, vecPathDelta );
			flTotalDist += (flDot > 0.0f ? 1.0f : -1.0f) * vecDelta.Length2D(); 
			break;
		}

		// NOTE: This would be made more accurate if we did the path direction check here too.
		// The starting vecPoint is sometimes *not* within the bounds of the line segment.

		// Find the distance between this test point and our goal point
		flTotalDist += (bMovingForward ? 1.0f : -1.0f) * vecPoint.AsVector2D().DistTo( pTestPath->GetAbsOrigin().AsVector2D() ); 
		vecPoint = pTestPath->GetAbsOrigin();
	}

	return flTotalDist;
}

	
//------------------------------------------------------------------------------
// Track debugging info
//------------------------------------------------------------------------------
void CAI_TrackPather::VisualizeDebugInfo( const Vector &vecNearestPoint, const Vector &vecTarget )
{
	if ( g_debug_trackpather.GetInt() == TRACKPATHER_DEBUG_PATH )
	{
		NDebugOverlay::Line( m_vecSegmentStartPoint, vecTarget, 0, 0, 255, true, 0.1f );
		NDebugOverlay::Cross3D( vecNearestPoint, -Vector(16,16,16), Vector(16,16,16), 255, 0, 0, true, 0.1f );
		NDebugOverlay::Cross3D( m_pCurrentPathTarget->GetAbsOrigin(), -Vector(16,16,16), Vector(16,16,16), 0, 255, 0, true, 0.1f );
		NDebugOverlay::Cross3D( m_vecDesiredPosition, -Vector(16,16,16), Vector(16,16,16), 0, 0, 255, true, 0.1f );
		NDebugOverlay::Cross3D( m_pDestPathTarget->GetAbsOrigin(), -Vector(16,16,16), Vector(16,16,16), 255, 255, 255, true, 0.1f );

		if ( m_pTargetNearestPath )
		{
			NDebugOverlay::Cross3D( m_pTargetNearestPath->GetAbsOrigin(), -Vector(24,24,24), Vector(24,24,24), 255, 0, 255, true, 0.1f );
		}
	}

	if ( g_debug_trackpather.GetInt() == TRACKPATHER_DEBUG_TRACKS )
	{
		if ( m_pCurrentPathTarget )
		{
			CPathTrack *pPathTrack = m_pCurrentPathTarget;
			for ( ; CPathTrack::ValidPath( pPathTrack ); pPathTrack = pPathTrack->GetNext() )
			{
				NDebugOverlay::Box( pPathTrack->GetAbsOrigin(), -Vector(2,2,2), Vector(2,2,2), 0,255, 0, 8, 0.1 );
				if ( CPathTrack::ValidPath( pPathTrack->GetNext() ) )
				{
					NDebugOverlay::Line( pPathTrack->GetAbsOrigin(), pPathTrack->GetNext()->GetAbsOrigin(), 0,255,0, true, 0.1 );
				}

				if ( pPathTrack->GetNext() == m_pCurrentPathTarget )
					break;
			}
		}
	}
}


//------------------------------------------------------------------------------
// Does this path track have LOS to the target?
//------------------------------------------------------------------------------
bool CAI_TrackPather::HasLOSToTarget( CPathTrack *pTrack )
{
	CBaseEntity *pTargetEnt = GetTrackPatherTargetEnt();
	if ( !pTargetEnt )
		return true;

	Vector targetPos;
	if ( !GetTrackPatherTarget( &targetPos ) )
		return true;

	// Translate driver into vehicle for testing
	CBaseEntity *pVehicle = NULL;
	CBaseCombatCharacter *pCCTarget = pTargetEnt->MyCombatCharacterPointer();
	if ( pCCTarget != NULL && pCCTarget->IsInAVehicle() )
	{
		pVehicle = pCCTarget->GetVehicleEntity();
	}

	// If it has to be visible, run those checks
	CBaseEntity *pBlocker = FindTrackBlocker( pTrack->GetAbsOrigin(), targetPos );

	// Check to see if we've hit the target, or the player's vehicle if it's a player in a vehicle
	bool bHitTarget = ( pTargetEnt && ( pTargetEnt == pBlocker ) ) ||
						( pVehicle && ( pVehicle == pBlocker ) );

	return (pBlocker == NULL) || bHitTarget;
}


//------------------------------------------------------------------------------
// Moves to the track
//------------------------------------------------------------------------------
void CAI_TrackPather::UpdateCurrentTarget()
{
	// Find the point along the line that we're closest to.
	const Vector &vecTarget = m_pCurrentPathTarget->GetAbsOrigin();
	Vector vecPoint;
	float t = ClosestPointToCurrentPath( &vecPoint );
	if ( (t < 1.0f) && ( vecPoint.DistToSqr( vecTarget ) > m_flTargetTolerance * m_flTargetTolerance ) )
		goto visualizeDebugInfo;

	// Forced move is gone as soon as we've reached the first point on our path
	if ( m_bLeading )
	{
		m_bForcedMove = false;
	}

	// Trip our "path_track reached" output
	if ( m_pCurrentPathTarget != m_pLastPathTarget )
	{
		// Get the path's specified max speed
		m_flPathMaxSpeed = m_pCurrentPathTarget->m_flSpeed;

		variant_t emptyVariant;
		m_pCurrentPathTarget->AcceptInput( "InPass", this, this, emptyVariant, 0 );
		m_pLastPathTarget = m_pCurrentPathTarget;
	}

	if ( m_nPauseState == PAUSED_AT_POSITION )
		return;

	if ( m_nPauseState == PAUSE_AT_NEXT_LOS_POSITION )
	{
		if ( HasLOSToTarget(m_pCurrentPathTarget) )
		{
			m_nPauseState = PAUSED_AT_POSITION;
			return;
		}
	}

	// Update our dest path target, if appropriate...
	if ( m_pCurrentPathTarget == m_pDestPathTarget )
	{
		m_bForcedMove = false;
		SelectNewDestTarget();
	}

	// Did SelectNewDestTarget give us a new point to move to?
	if ( m_pCurrentPathTarget != m_pDestPathTarget )
	{
		// Update to the next path, if there is one...
		m_pCurrentPathTarget = NextAlongCurrentPath( m_pCurrentPathTarget );
		if ( !m_pCurrentPathTarget )
		{
			m_pCurrentPathTarget = m_pLastPathTarget;
		}
	}
	else
	{
		// We're at rest (no patrolling behavior), which means we're moving forward now.
		m_bMovingForward = true;
	}

	SetDesiredPosition( m_pCurrentPathTarget->GetAbsOrigin() );
	m_vecSegmentStartSplinePoint = m_vecSegmentStartPoint;
	m_vecSegmentStartPoint = m_pLastPathTarget->GetAbsOrigin();

visualizeDebugInfo:
	VisualizeDebugInfo( vecPoint, vecTarget );
}


//-----------------------------------------------------------------------------
//
// NOTE: All code below is used exclusively for leading/trailing behavior
//
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Compute the distance to the leading position
//-----------------------------------------------------------------------------
float CAI_TrackPather::ComputeDistanceToLeadingPosition()
{
	return ComputeDistanceAlongPathToPoint( m_pCurrentPathTarget, m_pDestPathTarget, GetDesiredPosition(), m_bMovingForward );
}

	
//-----------------------------------------------------------------------------
// Compute the distance to the *target* position
//-----------------------------------------------------------------------------
float CAI_TrackPather::ComputeDistanceToTargetPosition()
{
	Assert( m_pTargetNearestPath );

	CPathTrack *pDest = m_bMovingForward ? m_pTargetNearestPath.Get() : m_pTargetNearestPath->GetPrevious();
	if ( !pDest )
	{
		pDest = m_pTargetNearestPath;
	}
	bool bMovingForward = IsForwardAlongPath( m_pCurrentPathTarget, pDest );

	CPathTrack *pStart = m_pCurrentPathTarget;
	if ( bMovingForward != m_bMovingForward )
	{
		if (bMovingForward)
		{
			if ( pStart->GetNext() )
			{
				pStart = pStart->GetNext();
			}
			if ( pDest->GetNext() )
			{
				pDest = pDest->GetNext();
			}
		}
		else
		{
			if ( pStart->GetPrevious() )
			{
				pStart = pStart->GetPrevious();
			}
			if ( pDest->GetPrevious() )
			{
				pDest = pDest->GetPrevious();
			}
		}
	}

	return ComputeDistanceAlongPathToPoint( pStart, pDest, m_vecTargetPathPoint, bMovingForward );
}


//-----------------------------------------------------------------------------
// Compute a path direction
//-----------------------------------------------------------------------------
void CAI_TrackPather::ComputePathDirection( CPathTrack *pPath, Vector *pVecPathDir )
{
	if ( pPath->GetPrevious() )
	{
		VectorSubtract( pPath->GetAbsOrigin(), pPath->GetPrevious()->GetAbsOrigin(), *pVecPathDir );
	}
	else
	{
		if ( pPath->GetNext() )
		{
			VectorSubtract( pPath->GetNext()->GetAbsOrigin(), pPath->GetAbsOrigin(), *pVecPathDir );
		}
		else
		{
			pVecPathDir->Init( 1, 0, 0 );
		}
	}
	VectorNormalize( *pVecPathDir );
}


//-----------------------------------------------------------------------------
// What's the current path direction?
//-----------------------------------------------------------------------------
void CAI_TrackPather::CurrentPathDirection( Vector *pVecPathDir )
{
	if ( m_pCurrentPathTarget )
	{
		ComputePathDirection( m_pCurrentPathTarget, pVecPathDir );
	}
	else
	{
		pVecPathDir->Init( 0, 0, 1 );
	}
}



//-----------------------------------------------------------------------------
// Compute a point n units along the current path from our current position
// (but don't pass the desired target point)
//-----------------------------------------------------------------------------
void CAI_TrackPather::ComputePointAlongCurrentPath( float flDistance, float flPerpDist, Vector *pTarget )
{
	Vector vecPathDir;
	Vector vecStartPoint;
	ClosestPointToCurrentPath( &vecStartPoint );
	*pTarget = vecStartPoint;

	if ( flDistance != 0.0f )
	{
		Vector vecPrevPoint = vecStartPoint;
		CPathTrack *pTravPath = m_pCurrentPathTarget;
		CPathTrack *pAdjustedDest = AdjustForMovementDirection( m_pDestPathTarget );
		for ( ; CPathTrack::ValidPath( pTravPath ); pTravPath = NextAlongCurrentPath( pTravPath ) )
		{
			if ( pTravPath == pAdjustedDest )
			{
				ComputePathDirection( pTravPath, &vecPathDir );

				float flPathDist = pTarget->DistTo( GetDesiredPosition() );
				if ( flDistance > flPathDist )
				{
					*pTarget = GetDesiredPosition();
				}
				else
				{
					ComputeClosestPoint( *pTarget, flDistance, GetDesiredPosition(), pTarget );
				}
				break;
			}

			// Find the distance between this test point and our goal point
			float flPathDist = pTarget->DistTo( pTravPath->GetAbsOrigin() );

			// Find the distance between this test point and our goal point
			if ( flPathDist <= flDistance )
			{
				flDistance -= flPathDist;
				*pTarget = pTravPath->GetAbsOrigin();

				// FIXME: Reduce the distance further based on the angle between this segment + the next
				continue;
			}
			
			ComputePathDirection( pTravPath, &vecPathDir );
			ComputeClosestPoint( *pTarget, flDistance, pTravPath->GetAbsOrigin(), pTarget );
			break;
		}
	}
	else
	{
		VectorSubtract( m_pCurrentPathTarget->GetAbsOrigin(), m_vecSegmentStartPoint, vecPathDir );
		VectorNormalize( vecPathDir );
	}

	// Add in the horizontal component
	ComputePointFromPerpDistance( *pTarget, vecPathDir, flPerpDist, pTarget );
}


//-----------------------------------------------------------------------------
// Methods to find a signed perp distance from the track
// and to compute a point off the path based on the signed perp distance
//-----------------------------------------------------------------------------
float CAI_TrackPather::ComputePerpDistanceFromPath( const Vector &vecPointOnPath, const Vector &vecPathDir, const Vector &vecPointOffPath )
{
	// Make it be a signed distance of the target from the path
	// Positive means on the right side, negative means on the left side
	Vector vecAcross, vecDelta;
	CrossProduct( vecPathDir, Vector( 0, 0, 1 ), vecAcross );
	VectorSubtract( vecPointOffPath, vecPointOnPath, vecDelta );
	VectorMA( vecDelta, -DotProduct( vecPathDir, vecDelta ), vecPathDir, vecDelta );

	float flDistanceFromPath = vecDelta.Length2D();
	if ( DotProduct2D( vecAcross.AsVector2D(), vecDelta.AsVector2D() ) < 0.0f )
	{
		flDistanceFromPath *= -1.0f;
	}

	return flDistanceFromPath;
}

void CAI_TrackPather::ComputePointFromPerpDistance( const Vector &vecPointOnPath, const Vector &vecPathDir, float flPerpDist, Vector *pResult )
{
	Vector vecAcross;
	CrossProduct( vecPathDir, Vector( 0, 0, 1 ), vecAcross );
	VectorMA( vecPointOnPath, flPerpDist, vecAcross, *pResult );
}


//-----------------------------------------------------------------------------
// Finds the closest point on the path, returns a signed perpendicular distance
// where negative means on the left side of the path (when travelled from prev to next)
// and positive means on the right side
//-----------------------------------------------------------------------------
CPathTrack *CAI_TrackPather::FindClosestPointOnPath( CPathTrack *pPath, 
	const Vector &targetPos, Vector *pVecClosestPoint, Vector *pVecPathDir, float *pDistanceFromPath )
{
	// Find the node nearest to the destination path target if a path is not specified
	if ( pPath == NULL )
	{
		pPath = m_pDestPathTarget;
	}

	// If the path node we're trying to use is not valid, then we're done.
	if ( CPathTrack::ValidPath( pPath ) == NULL )
	{
		//FIXME: Implement
		Assert(0);
		return NULL;
	}

	// Find the nearest node to the target (going forward)
	CPathTrack *pNearestPath	= NULL;
	float		flNearestDist2D	= 999999999;
	float		flNearestDist	= 999999999;
	float		flPathDist, flPathDist2D;

	// NOTE: Gotta do it this crazy way because paths can be one-way.
	Vector vecNearestPoint;
	Vector vecNearestPathSegment;
	for ( int i = 0; i < 2; ++i )
	{
		int loopCheck = 0;
		CPathTrack *pTravPath = pPath;
		CPathTrack *pNextPath;

		BEGIN_PATH_TRACK_ITERATION();
		for ( ; CPathTrack::ValidPath( pTravPath ); pTravPath = pNextPath, loopCheck++ )
		{
			// Circular loop checking
			if ( pTravPath->HasBeenVisited() )
				break;

			// Mark it as being visited.
			pTravPath->Visit();

			pNextPath = (i == 0) ? pTravPath->GetPrevious() : pTravPath->GetNext();

			// No alt paths allowed in leading mode.
			if ( pTravPath->m_paltpath )
			{
				Warning( "%s: Alternative paths in path_track not allowed when using the leading behavior!\n", GetEntityName().ToCStr() );
			}

			// Need line segments
			if ( !CPathTrack::ValidPath(pNextPath) )
				break;

			// Find the closest point on the line segment on the path
			Vector vecClosest;
			CalcClosestPointOnLineSegment( targetPos, pTravPath->GetAbsOrigin(), pNextPath->GetAbsOrigin(), vecClosest );

			// Find the distance between this test point and our goal point
			flPathDist2D = vecClosest.AsVector2D().DistToSqr( targetPos.AsVector2D() );
			if ( flPathDist2D > flNearestDist2D )
				continue;

			flPathDist = vecClosest.z - targetPos.z;
			flPathDist *= flPathDist;
			flPathDist += flPathDist2D;
			if (( flPathDist2D == flNearestDist2D ) && ( flPathDist >= flNearestDist ))
				continue;

			pNearestPath	= (i == 0) ? pTravPath : pNextPath;
			flNearestDist2D	= flPathDist2D;
			flNearestDist	= flPathDist;
			vecNearestPoint	= vecClosest;
			VectorSubtract( pNextPath->GetAbsOrigin(), pTravPath->GetAbsOrigin(), vecNearestPathSegment );
			if ( i == 0 )
			{
				vecNearestPathSegment *= -1.0f;
			}
		}
	}

	VectorNormalize( vecNearestPathSegment );
	*pDistanceFromPath = ComputePerpDistanceFromPath( vecNearestPoint, vecNearestPathSegment, targetPos );
	*pVecClosestPoint = vecNearestPoint;
	*pVecPathDir = vecNearestPathSegment;
	return pNearestPath;
}


//-----------------------------------------------------------------------------
// Breakable paths?
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputStartBreakableMovement( inputdata_t &inputdata )
{
	m_bPatrolBreakable = true;
}

void CAI_TrackPather::InputStopBreakableMovement( inputdata_t &inputdata )
{
	m_bPatrolBreakable = false;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &inputdata - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputStartPatrol( inputdata_t &inputdata )
{
	m_bPatrolling = true;	
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputStopPatrol( inputdata_t &inputdata )
{
	m_bPatrolling = false;	
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &inputdata - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputStartPatrolBreakable( inputdata_t &inputdata )
{
	m_bPatrolBreakable = true;
	m_bPatrolling = true;	
}


//------------------------------------------------------------------------------
// Leading behaviors
//------------------------------------------------------------------------------
void CAI_TrackPather::InputStartLeading( inputdata_t &inputdata )
{
	EnableLeading( true );
	SetLeadingDistance( inputdata.value.Int() );
}

void CAI_TrackPather::InputStopLeading( inputdata_t &inputdata )
{
	EnableLeading( false );
}


//------------------------------------------------------------------------------
// Selects a new destination target
//------------------------------------------------------------------------------
void CAI_TrackPather::SelectNewDestTarget()
{
	if ( !m_bPatrolling )
		return;

	// NOTE: This version is bugged, but I didn't want to make the fix
	// here for fear of breaking a lot of maps late in the day.
	// So, only the chopper does the "right" thing.
#ifdef HL2_EPISODIC 
	// Episodic uses the fixed logic for all trackpathers
	if ( 1 )
#else
	if ( ShouldUseFixedPatrolLogic() )
#endif
	{
		CPathTrack *pOldDest = m_pDestPathTarget;

		// Only switch polarity of movement if we're at the *end* of the path
		// This is really useful for initial conditions of patrolling
		// NOTE: We've got to do some extra work for circular paths
		bool bIsCircular = false;
		{
 			BEGIN_PATH_TRACK_ITERATION();
			CPathTrack *pTravPath = m_pDestPathTarget;
 			while( CPathTrack::ValidPath( pTravPath ) )
			{
				// Circular loop checking
				if ( pTravPath->HasBeenVisited() )
				{
					bIsCircular = true;
					break;
				}

				pTravPath->Visit();
				pTravPath = NextAlongCurrentPath( pTravPath );
			}
		}

		if ( bIsCircular || (NextAlongCurrentPath( m_pDestPathTarget ) == NULL) )
		{
			m_bMovingForward = !m_bMovingForward;
		}

		BEGIN_PATH_TRACK_ITERATION();

		while ( true )
		{
			CPathTrack *pNextTrack = NextAlongCurrentPath( m_pDestPathTarget );
			if ( !pNextTrack || (pNextTrack == pOldDest) || pNextTrack->HasBeenVisited() )
				break;

			pNextTrack->Visit();
			m_pDestPathTarget = pNextTrack;
		}
	}
	else
	{
		CPathTrack *pOldDest = m_pDestPathTarget;

		// For patrolling, switch the polarity of movement
		m_bMovingForward = !m_bMovingForward;

		int loopCount = 0;
		while ( true )
		{
			CPathTrack *pNextTrack = NextAlongCurrentPath( m_pDestPathTarget );
			if ( !pNextTrack )
				break;
			if ( ++loopCount > 1024 )
			{
				DevMsg(1,"WARNING: Looping path for %s\n", GetDebugName() );
				break;
			}

			m_pDestPathTarget = pNextTrack;
		}

		if ( m_pDestPathTarget == pOldDest )
		{
			// This can occur if we move to the first point on the path
			SelectNewDestTarget();
		}
	}
}


//------------------------------------------------------------------------------
// Moves to the track
//------------------------------------------------------------------------------
void CAI_TrackPather::UpdateCurrentTargetLeading()
{
	bool bRestingAtDest = false;
	CPathTrack *pAdjustedDest;

	// Find the point along the line that we're closest to.
	const Vector &vecTarget = m_pCurrentPathTarget->GetAbsOrigin();
	Vector vecPoint;
	float t = ClosestPointToCurrentPath( &vecPoint );
	if ( (t < 1.0f) && ( vecPoint.DistToSqr( vecTarget ) > m_flTargetTolerance * m_flTargetTolerance ) )
		goto visualizeDebugInfo;

	// Trip our "path_track reached" output
	if ( m_pCurrentPathTarget != m_pLastPathTarget )
	{
		// Get the path's specified max speed
		m_flPathMaxSpeed = m_pCurrentPathTarget->m_flSpeed;

		variant_t emptyVariant;
		m_pCurrentPathTarget->AcceptInput( "InPass", this, this, emptyVariant, 0 );
		m_pLastPathTarget = m_pCurrentPathTarget;
	}

	// NOTE: CurrentPathTarget doesn't mean the same thing as dest path target!
	// It's the "next"most when moving forward + "prev"most when moving backward
	// Must do the tests in the same space
	pAdjustedDest = AdjustForMovementDirection( m_pDestPathTarget );

	// Update our dest path target, if appropriate...
	if ( m_pCurrentPathTarget == pAdjustedDest )
	{
		m_bForcedMove = false;
		SelectNewDestTarget();

		// NOTE: Must do this again since SelectNewDestTarget may change m_pDestPathTarget
		pAdjustedDest = AdjustForMovementDirection( m_pDestPathTarget );
	}

	if ( m_pCurrentPathTarget != pAdjustedDest )
	{
		// Update to the next path, if there is one...
		m_pCurrentPathTarget = NextAlongCurrentPath( m_pCurrentPathTarget );
		if ( !m_pCurrentPathTarget )
		{
			m_pCurrentPathTarget = m_pLastPathTarget;
		}
	}
	else
	{
		// NOTE: Have to do this here because the NextAlongCurrentPath call above
		// could make m_pCurrentPathTarget == m_pDestPathTarget.
		// In this case, we're at rest (no patrolling behavior)
		bRestingAtDest = true;
	}

	if ( bRestingAtDest )
	{
		// NOTE: Must use current path target, instead of dest
		// to get the PreviousAlongCurrentPath working correctly
		CPathTrack *pSegmentStart = PreviousAlongCurrentPath( m_pCurrentPathTarget ); 
		if ( !pSegmentStart )
		{
			pSegmentStart = m_pCurrentPathTarget;
		}
		m_vecSegmentStartPoint = pSegmentStart->GetAbsOrigin();
	}
	else
	{
		m_vecSegmentStartPoint = m_pLastPathTarget->GetAbsOrigin();
	}

visualizeDebugInfo:
	VisualizeDebugInfo( vecPoint, vecTarget );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_TrackPather::UpdateTargetPositionLeading( void )
{
	Vector targetPos;
	if ( !GetTrackPatherTarget( &targetPos ) )
		return;

	// NOTE: FindClosestPointOnPath *always* returns the point on the "far",
	// end of the line segment containing the closest point (namely the 'next'
	// track, as opposed to the 'prev' track)
	Vector vecClosestPoint, vecPathDir;
	float flTargetDistanceFromPath;
	CPathTrack *pNextPath = FindClosestPointOnPath( m_pCurrentPathTarget, 
		targetPos, &vecClosestPoint, &vecPathDir, &flTargetDistanceFromPath );

	// This means that a valid path could not be found to our target!
	if ( CPathTrack::ValidPath( pNextPath ) == NULL )
		return;

//	NDebugOverlay::Cross3D( vecClosestPoint, -Vector(24,24,24), Vector(24,24,24), 0, 255, 255, true, 0.1f );
//	NDebugOverlay::Cross3D( pNextPath->GetAbsOrigin(), -Vector(24,24,24), Vector(24,24,24), 255, 255, 0, true, 0.1f );

	// Here's how far we are from the path
	m_flTargetDistFromPath = flTargetDistanceFromPath;
	m_vecTargetPathDir = vecPathDir;

	// Here's info about where the target is along the path
	m_vecTargetPathPoint = vecClosestPoint;
	m_pTargetNearestPath = pNextPath;

	// Find the best position to be on our path
	// NOTE: This will *also* return a path track on the "far" end of the line segment
	// containing the leading position, namely the "next" end of the segment as opposed
	// to the "prev" end of the segment.
	CPathTrack *pDest = ComputeLeadingPointAlongPath( vecClosestPoint, pNextPath, m_flLeadDistance, &targetPos );
	SetDesiredPosition( targetPos );

	// We only want to switch movement directions when absolutely necessary
	// so convert dest into a more appropriate value based on the current movement direction
	if ( pDest != m_pDestPathTarget )
	{
		// NOTE: This is really tricky + subtle
		// For leading, we don't want to ever change direction when the current target == the
		// adjusted destination target. Namely, if we're going forward, both dest + curr
		// mean the "next"most node so we can compare them directly against eath other.
		// If we're moving backward, dest means "next"most, but curr means "prev"most.
		// We first have to adjust the dest to mean "prev"most, and then do the comparison.
		// If the adjusted dest == curr, then maintain direction. Otherwise, use the forward along path test.
		bool bMovingForward = m_bMovingForward;
		CPathTrack *pAdjustedDest = AdjustForMovementDirection( pDest );
		if ( m_pCurrentPathTarget != pAdjustedDest )
		{
			bMovingForward = IsForwardAlongPath( m_pCurrentPathTarget, pAdjustedDest );
		}

		if ( bMovingForward != m_bMovingForward )
		{
			// As a result of the tricky note above, this should never occur
			Assert( pAdjustedDest != m_pCurrentPathTarget );

			// Oops! Need to reverse direction
			m_bMovingForward = bMovingForward;
			m_vecSegmentStartPoint = m_pCurrentPathTarget->GetAbsOrigin();
			m_pCurrentPathTarget = NextAlongCurrentPath( m_pCurrentPathTarget );
		}
		m_pDestPathTarget = pDest;
	}

//	NDebugOverlay::Cross3D( m_pCurrentPathTarget->GetAbsOrigin(), -Vector(36,36,36), Vector(36,36,36), 255, 0, 0, true, 0.1f );
//	NDebugOverlay::Cross3D( m_pDestPathTarget->GetAbsOrigin(), -Vector(48,48,48), Vector(48,48,48), 0, 255, 0, true, 0.1f );
//	NDebugOverlay::Cross3D( targetPos, -Vector(36,36,36), Vector(36,36,36), 0, 0, 255, true, 0.1f );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_TrackPather::UpdateTargetPosition( void )
{
	// Don't update our target if we're being told to go somewhere
	if ( m_bForcedMove && !m_bPatrolBreakable )
		return;

	// Don't update our target if we're patrolling
	if ( m_bPatrolling )
	{
		// If we have an enemy, and our patrol is breakable, stop patrolling
		if ( !m_bPatrolBreakable || !GetEnemy() )
			return;

		m_bPatrolling = false;
	}

	Vector targetPos;
	if ( !GetTrackPatherTarget( &targetPos ) )
		return;

	// Not time to update again
	if ( m_flEnemyPathUpdateTime > gpGlobals->curtime )
		return;

	// See if the target has moved enough to make us recheck
	float flDistSqr = ( targetPos - m_vecLastGoalCheckPosition ).LengthSqr();
	if ( flDistSqr < m_flTargetDistanceThreshold * m_flTargetDistanceThreshold )
		return;

	// Find the best position to be on our path
	CPathTrack *pDest = BestPointOnPath( m_pCurrentPathTarget, targetPos, m_flAvoidDistance, true, m_bChooseFarthestPoint );

	if ( CPathTrack::ValidPath( pDest ) == NULL )
	{
		// This means that a valid path could not be found to our target!
//		Assert(0);
		return;
	}

	if ( pDest != m_pDestPathTarget )
	{
		// This is our new destination
		bool bMovingForward = IsForwardAlongPath( m_pCurrentPathTarget, pDest );
		if ( bMovingForward != m_bMovingForward )
		{
			// Oops! Need to reverse direction
			m_bMovingForward = bMovingForward;
			if ( pDest != m_pCurrentPathTarget )
			{
				SetupNewCurrentTarget( NextAlongCurrentPath( m_pCurrentPathTarget ) );
			}
		}
		m_pDestPathTarget = pDest;
	}

	// Keep this goal point for comparisons later
	m_vecLastGoalCheckPosition = targetPos;
	
	// Only do this on set intervals
	m_flEnemyPathUpdateTime	= gpGlobals->curtime + 1.0f;
}


//------------------------------------------------------------------------------
// Returns the direction of the path at the closest point to the target
//------------------------------------------------------------------------------
const Vector &CAI_TrackPather::TargetPathDirection() const
{
	return m_vecTargetPathDir;
}

const Vector &CAI_TrackPather::TargetPathAcrossDirection() const
{
	static Vector s_Result;
	CrossProduct( m_vecTargetPathDir, Vector( 0, 0, 1 ), s_Result );
	return s_Result;
}


//------------------------------------------------------------------------------
// Returns the speed of the target relative to the path
//------------------------------------------------------------------------------
float CAI_TrackPather::TargetSpeedAlongPath() const
{
	if ( !GetEnemy() || !IsLeading() )
		return 0.0f;

	Vector vecSmoothedVelocity = GetEnemy()->GetSmoothedVelocity();
	return DotProduct( vecSmoothedVelocity, TargetPathDirection() );
}


//------------------------------------------------------------------------------
// Returns the speed of the target *across* the path
//------------------------------------------------------------------------------
float CAI_TrackPather::TargetSpeedAcrossPath() const
{
	if ( !GetEnemy() || !IsLeading() )
		return 0.0f;

	Vector vecSmoothedVelocity = GetEnemy()->GetSmoothedVelocity();
	return DotProduct( vecSmoothedVelocity, TargetPathAcrossDirection() );
}


//------------------------------------------------------------------------------
// Returns the max distance we can be from the path
//------------------------------------------------------------------------------
float CAI_TrackPather::MaxDistanceFromCurrentPath() const
{
	if ( !IsLeading() || !m_pCurrentPathTarget )
		return 0.0f;

	CPathTrack *pPrevPath = PreviousAlongCurrentPath( m_pCurrentPathTarget );
	if ( !pPrevPath )
	{
		pPrevPath = m_pCurrentPathTarget;
	}

	// NOTE: Can't use m_vecSegmentStartPoint because we don't have a radius defined for it
	float t;
	Vector vecTemp;
	CalcClosestPointOnLine( GetAbsOrigin(), pPrevPath->GetAbsOrigin(), 
		m_pCurrentPathTarget->GetAbsOrigin(), vecTemp, &t );
	t = clamp( t, 0.0f, 1.0f );
	float flRadius = (1.0f - t) * pPrevPath->GetRadius() + t * m_pCurrentPathTarget->GetRadius(); 
	return flRadius;
}


//------------------------------------------------------------------------------
// Purpose : A different version of the track pather which is more explicit about
// the meaning of dest, current, and prev path points
//------------------------------------------------------------------------------
void CAI_TrackPather::UpdateTrackNavigation( void )
{
	// No target? Use the string specified. We have no spawn method (sucky!!) so this is how that works
	if ( ( CPathTrack::ValidPath( m_pDestPathTarget ) == NULL ) && ( m_target != NULL_STRING ) )
	{
		FlyToPathTrack( m_target );
		m_target = NULL_STRING;
	}

	if ( !IsLeading() )
	{
		if ( !m_pCurrentPathTarget )
			return;

		// Updates our destination node if we're tracking something
		UpdateTargetPosition();

		// Move along our path towards our current destination
		UpdateCurrentTarget();
	}
	else
	{
		// Updates our destination position if we're leading something
		UpdateTargetPositionLeading();

		// Move along our path towards our current destination
		UpdateCurrentTargetLeading();
	}
}


//------------------------------------------------------------------------------
// Sets the farthest path distance
//------------------------------------------------------------------------------
void CAI_TrackPather::SetFarthestPathDist( float flMaxPathDist )
{
	m_flFarthestPathDist = flMaxPathDist;
}


//------------------------------------------------------------------------------
// Sets up a new current path target
//------------------------------------------------------------------------------
void CAI_TrackPather::SetupNewCurrentTarget( CPathTrack *pTrack )
{
	Assert( pTrack );
	m_vecSegmentStartPoint = GetAbsOrigin();
	VectorMA( m_vecSegmentStartPoint, -2.0f, GetAbsVelocity(), m_vecSegmentStartSplinePoint );
	m_pCurrentPathTarget = pTrack;
	SetDesiredPosition( m_pCurrentPathTarget->GetAbsOrigin() );
}


//------------------------------------------------------------------------------
// Moves to an explicit track point
//------------------------------------------------------------------------------
void CAI_TrackPather::MoveToTrackPoint( CPathTrack *pTrack )
{
	if ( IsOnSameTrack( pTrack, m_pDestPathTarget ) )
	{
		// The track must be valid
		if ( CPathTrack::ValidPath( pTrack ) == NULL )
			return;

		m_pDestPathTarget = pTrack;
		m_bMovingForward = IsForwardAlongPath( m_pCurrentPathTarget, pTrack );
		m_bForcedMove = true;
	}
	else
	{
		CPathTrack *pClosestTrack = BestPointOnPath( pTrack, WorldSpaceCenter(), 0.0f, false, false );

		// The track must be valid
		if ( CPathTrack::ValidPath( pClosestTrack ) == NULL )
			return;

		SetupNewCurrentTarget( pClosestTrack );
		m_pDestPathTarget = pTrack;
		m_bMovingForward = IsForwardAlongPath( pClosestTrack, pTrack );
		m_bForcedMove = true;
	}
}


//------------------------------------------------------------------------------
// Moves to the closest track point
//------------------------------------------------------------------------------
void CAI_TrackPather::MoveToClosestTrackPoint( CPathTrack *pTrack )
{
	if ( IsOnSameTrack( pTrack, m_pDestPathTarget ) )
		return;

	CPathTrack *pClosestTrack = BestPointOnPath( pTrack, WorldSpaceCenter(), 0.0f, false, false );

	// The track must be valid
	if ( CPathTrack::ValidPath( pClosestTrack ) == NULL )
		return;

	SetupNewCurrentTarget( pClosestTrack );
	m_pDestPathTarget = pClosestTrack;
	m_bMovingForward = true;

	// Force us to switch tracks if we're leading
	if ( IsLeading() )
	{
		m_bForcedMove = true;
	}
}


//-----------------------------------------------------------------------------
// Are the two path tracks connected?
//-----------------------------------------------------------------------------
bool CAI_TrackPather::IsOnSameTrack( CPathTrack *pPath1, CPathTrack *pPath2 ) const
{
	if ( pPath1 == pPath2 )
		return true;

	{
		BEGIN_PATH_TRACK_ITERATION();
		CPathTrack *pTravPath = pPath1->GetPrevious();
		while( CPathTrack::ValidPath( pTravPath ) && (pTravPath != pPath1) )
		{
			// Circular loop checking
			if ( pTravPath->HasBeenVisited() )
				break;

			pTravPath->Visit();

			if ( pTravPath == pPath2 )
				return true;

			pTravPath = pTravPath->GetPrevious();
		}
	}

	{
		BEGIN_PATH_TRACK_ITERATION();
		CPathTrack *pTravPath = pPath1->GetNext();
		while( CPathTrack::ValidPath( pTravPath ) && (pTravPath != pPath1) )
		{
			// Circular loop checking
			if ( pTravPath->HasBeenVisited() )
				break;

			pTravPath->Visit();

			if ( pTravPath == pPath2 )
				return true;

			pTravPath = pTravPath->GetNext();
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Deal with teleportation
//-----------------------------------------------------------------------------
void CAI_TrackPather::Teleported()
{
	// This updates the paths so they are reasonable
	CPathTrack *pClosestTrack = BestPointOnPath( GetDestPathTarget(), WorldSpaceCenter(), 0.0f, false, false );
	m_pDestPathTarget = NULL;
	MoveToClosestTrackPoint( pClosestTrack );
}

	
//-----------------------------------------------------------------------------
// Returns distance along path to target, returns FLT_MAX if there's no path
//-----------------------------------------------------------------------------
float CAI_TrackPather::ComputePathDistance( CPathTrack *pPath, CPathTrack *pDest, bool bForward ) const
{
	float flDist = 0.0f;
	CPathTrack *pLast = pPath;

	BEGIN_PATH_TRACK_ITERATION();
	while ( CPathTrack::ValidPath( pPath ) )
	{
		// Ciruclar loop checking
		if ( pPath->HasBeenVisited() )
			return FLT_MAX;

		pPath->Visit();

		flDist += pLast->GetAbsOrigin().DistTo( pPath->GetAbsOrigin() );

		if ( pDest == pPath )
			return flDist;

		pLast = pPath;
		pPath = bForward ? pPath->GetNext() : pPath->GetPrevious();
	}

	return FLT_MAX;
}


//-----------------------------------------------------------------------------
// Is pPathTest in "front" of pPath on the same path? (Namely, does GetNext() get us there?)
//-----------------------------------------------------------------------------
bool CAI_TrackPather::IsForwardAlongPath( CPathTrack *pPath, CPathTrack *pPathTest ) const
{
	// Also, in the case of looping paths, we want to return the shortest path
	float flForwardDist = ComputePathDistance( pPath, pPathTest, true );
	float flReverseDist = ComputePathDistance( pPath, pPathTest, false );

	Assert( ( flForwardDist != FLT_MAX ) || ( flReverseDist != FLT_MAX ) );
	return ( flForwardDist <= flReverseDist );
}


//-----------------------------------------------------------------------------
// Computes distance + nearest point from the current path..
//-----------------------------------------------------------------------------
float CAI_TrackPather::ClosestPointToCurrentPath( Vector *pVecPoint ) const
{
	if (!m_pCurrentPathTarget)
	{
		*pVecPoint = GetAbsOrigin();
		return 0;
	}

	float t;
	CalcClosestPointOnLine( GetAbsOrigin(), m_vecSegmentStartPoint, 
		m_pCurrentPathTarget->GetAbsOrigin(), *pVecPoint, &t );
	return t;
}


//-----------------------------------------------------------------------------
// Computes a "path" velocity at a particular point along the current path
//-----------------------------------------------------------------------------
void CAI_TrackPather::ComputePathTangent( float t, Vector *pVecTangent ) const
{
	CPathTrack *pNextTrack = NextAlongCurrentPath(m_pCurrentPathTarget);
	if ( !pNextTrack )
	{
		pNextTrack = m_pCurrentPathTarget;
	}

	t = clamp( t, 0.0f, 1.0f );
	pVecTangent->Init(0,0,0);
	Catmull_Rom_Spline_Tangent( m_vecSegmentStartSplinePoint, m_vecSegmentStartPoint, 
		m_pCurrentPathTarget->GetAbsOrigin(), pNextTrack->GetAbsOrigin(), t, *pVecTangent );
	VectorNormalize( *pVecTangent );
}


//-----------------------------------------------------------------------------
// Computes the *normalized* velocity at which the helicopter should approach the final point
//-----------------------------------------------------------------------------
void CAI_TrackPather::ComputeNormalizedDestVelocity( Vector *pVecVelocity ) const
{
	if ( m_nPauseState != PAUSE_NO_PAUSE )
	{
		pVecVelocity->Init(0,0,0);
		return;
	}

	CPathTrack *pNextTrack = NextAlongCurrentPath(m_pCurrentPathTarget);
	if ( !pNextTrack )
	{
		pNextTrack = m_pCurrentPathTarget;
	}

	if ( ( pNextTrack == m_pCurrentPathTarget ) || ( m_pCurrentPathTarget == m_pDestPathTarget ) )
	{
		pVecVelocity->Init(0,0,0);
		return;
	}

	VectorSubtract( pNextTrack->GetAbsOrigin(), m_pCurrentPathTarget->GetAbsOrigin(), *pVecVelocity );
	VectorNormalize( *pVecVelocity );

	// Slow it down if we're approaching a sharp corner
	Vector vecDelta;
	VectorSubtract( m_pCurrentPathTarget->GetAbsOrigin(), m_vecSegmentStartPoint, vecDelta );
	VectorNormalize( vecDelta );
	float flDot = DotProduct( *pVecVelocity, vecDelta );
	*pVecVelocity *= clamp( flDot, 0.0f, 1.0f );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &inputdata - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::SetTrack( CBaseEntity *pGoalEnt )
{
	// Ignore this input if we're *already* on that path.
	CPathTrack *pTrack = dynamic_cast<CPathTrack *>(pGoalEnt);
	if ( !pTrack )
	{
		DevWarning( "%s: Specified entity '%s' must be a path_track!\n", pGoalEnt->GetClassname(), pGoalEnt->GetEntityName().ToCStr() );
		return;
	}

	MoveToClosestTrackPoint( pTrack );
}

void CAI_TrackPather::SetTrack( string_t strTrackName )
{
	// Find our specified target
	CBaseEntity *pGoalEnt = gEntList.FindEntityByName( NULL, strTrackName );
	if ( pGoalEnt == NULL )
	{
		DevWarning( "%s: Could not find path_track '%s'!\n", GetClassname(), STRING( strTrackName ) );
		return;
	}

	SetTrack( pGoalEnt );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &inputdata - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputSetTrack( inputdata_t &inputdata )
{
	string_t strTrackName = MAKE_STRING( inputdata.value.String() );
	SetTrack( MAKE_STRING( inputdata.value.String() ) );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : strTrackName - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::FlyToPathTrack( string_t strTrackName )
{
	CBaseEntity *pGoalEnt = gEntList.FindEntityByName( NULL, strTrackName );
	if ( pGoalEnt == NULL )
	{
		DevWarning( "%s: Could not find path_track '%s'!\n", GetClassname(), STRING( strTrackName ) );
		return;
	}

	// Ignore this input if we're *already* on that path.
	CPathTrack *pTrack = dynamic_cast<CPathTrack *>(pGoalEnt);
	if ( !pTrack )
	{
		DevWarning( "%s: Specified entity '%s' must be a path_track!\n", GetClassname(), STRING( strTrackName ) );
		return;
	}

	// Find our specified target
	MoveToTrackPoint( pTrack );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &inputdata - 
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputFlyToPathTrack( inputdata_t &inputdata )
{ 
	// Find our specified target
	string_t strTrackName = MAKE_STRING( inputdata.value.String() );
	m_nPauseState = PAUSE_NO_PAUSE;
	FlyToPathTrack( strTrackName );
}


//-----------------------------------------------------------------------------
// Changes the mode used to determine which path point to move to
//-----------------------------------------------------------------------------
void CAI_TrackPather::InputChooseFarthestPathPoint( inputdata_t &inputdata )
{
	UseFarthestPathPoint( true );
}

void CAI_TrackPather::InputChooseNearestPathPoint( inputdata_t &inputdata )
{
	UseFarthestPathPoint( false );
}

void CAI_TrackPather::UseFarthestPathPoint( bool useFarthest )
{
	m_bChooseFarthestPoint = useFarthest;
}
