Fix line endings. WHAMMY.

1 files changed, 751 insertions, 751 deletions

diff --git a/sp/src/game/server/ai_navigator.h b/sp/src/game/server/ai_navigator.h
index 07321570..a2100943 100644
--- a/sp/src/game/server/ai_navigator.h
+++ b/sp/src/game/server/ai_navigator.h
@@ -1,751 +1,751 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose:

-//

-// $NoKeywords: $

-//=============================================================================//

-

-#ifndef AI_NAVIGATOR_H

-#define AI_NAVIGATOR_H

-

-#ifdef _WIN32

-#pragma once

-#endif

-

-#include "simtimer.h"

-#include "ai_component.h"

-#include "ai_navgoaltype.h"

-#include "ai_navtype.h"

-#include "ai_motor.h"

-

-class CAI_BaseNPC;

-class CAI_Motor;

-class CAI_Route;

-class CAI_Path;

-class CAI_Pathfinder;

-class CAI_LocalNavigator;

-struct AI_Waypoint_t;

-class CAI_WaypointList;

-class CAI_Network;

-struct AIMoveTrace_t;

-struct AILocalMoveGoal_t;

-typedef int AI_TaskFailureCode_t;

-

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

-// Debugging tools

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

-

-#define DEBUG_AI_NAVIGATION 1

-#ifdef DEBUG_AI_NAVIGATION

-extern ConVar ai_debug_nav;

-#define DbgNav() ai_debug_nav.GetBool()

-#define DbgNavMsg( pAI, pszMsg ) \

-	do \

-	{ \

-		if (DbgNav()) \

-			DevMsg( pAI, CFmtStr( "[Nav] %s", static_cast<const char *>(pszMsg) ) ); \

-	} while (0)

-#define DbgNavMsg1( pAI, pszMsg, a ) DbgNavMsg( pAI, CFmtStr(static_cast<const char *>(pszMsg), (a) ) )

-#define DbgNavMsg2( pAI, pszMsg, a, b ) DbgNavMsg( pAI, CFmtStr(static_cast<const char *>(pszMsg), (a), (b) ) )

-#else

-#define DbgNav() false

-#define DbgNavMsg( pAI, pszMsg ) ((void)0)

-#define DbgNavMsg1( pAI, pszMsg, a ) ((void)0)

-#define DbgNavMsg2( pAI, pszMsg, a, b ) ((void)0)

-#endif

-

-

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

-// STRUCTURES & ENUMERATIONS

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

-

-DECLARE_POINTER_HANDLE( AI_PathNode_t );

-

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

-// Purpose: Constants used to specify the properties of a requested navigation

-//			goal.

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

-

-// Navigator should use the default or previously set tolerance

-const float AIN_DEF_TOLERANCE  = -1.0;

-

-// Navigator should use the hull size as the tolerance

-const float AIN_HULL_TOLERANCE = -2.0;

-

-// Goal does not specify a new activity

-const Activity AIN_DEF_ACTIVITY = ACT_INVALID;

-

-// Goal has no target

-CBaseEntity * const AIN_NO_TARGET  = NULL;

-

-// Goal does not specify a new target, use the existing one, if any

-CBaseEntity * const AIN_DEF_TARGET = (AIN_NO_TARGET + 1);

-

-// Goal does not specify a vector location

-extern const Vector AIN_NO_DEST;

-

-// Goal does not specify a node location

-#define AIN_NO_NODE ((AI_PathNode_t)-1)

-

-

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

-

-enum AI_NavGoalFlags_t

-{

-	// While navigating, try to face the destination point

-	AIN_YAW_TO_DEST			= 0x01,

-	

-	// If I'm a goal of type GOALTYPE_TARGETENT, update my goal position every time I think

-	AIN_UPDATE_TARGET_POS	= 0x02,

-

-	// If navigating on a designer placed path, don't use pathfinder between waypoints, just do it

-	AIN_NO_PATHCORNER_PATHFINDING = 0x04,

-

-	AIN_DEF_FLAGS			= 0,

-};

-

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

-

-enum AI_NavSetGoalFlags_t

-{

-	// Reset the navigator's navigation to the default state

-	AIN_CLEAR_PREVIOUS_STATE 	= 0x01,

-	

-	// Clear out the target entity, while retaining other settings

-	AIN_CLEAR_TARGET			= 0x02,

-	

-	// If the navigate fails, return navigation to the default state

-	AIN_DISCARD_IF_FAIL			= 0x04,

-

-	// Don't signal TaskFail() if the pathfind fails, just return the result

-	AIN_NO_PATH_TASK_FAIL		= 0x08,

-};

-

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

-

-enum AI_NpcBlockHandling_t

-{

-	AISF_BLOCK,

-	AISF_AVOID,

-	AISF_IGNORE,

-};

-

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

-

-enum AI_NavPathProgress_t

-{

-	AINPP_NO_CHANGE,

-	AINPP_ADVANCED,

-	AINPP_COMPLETE,

-	AINPP_BLOCKED,

-};

-

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

-// Purpose: Describes a navigation request. The various constructors simply

-//			allow ease of use in the common cases.

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

-

-struct AI_NavGoal_t

-{

-	// Goal is unspecifed, or not a specific location

-	AI_NavGoal_t( GoalType_t    type	  = GOALTYPE_INVALID,

-				  Activity		activity  = AIN_DEF_ACTIVITY, 

-				  float			tolerance = AIN_DEF_TOLERANCE,

-				  unsigned 		flags     = AIN_DEF_FLAGS,

-				  CBaseEntity * pTarget   = AIN_DEF_TARGET);

-	

-	// Goal is a specific location, and GOALTYPE_LOCATION

-	AI_NavGoal_t( const Vector &dest,

-				  Activity		activity  = AIN_DEF_ACTIVITY, 

-				  float			tolerance = AIN_DEF_TOLERANCE,

-				  unsigned 		flags     = AIN_DEF_FLAGS,

-				  CBaseEntity * pTarget   = AIN_DEF_TARGET);

-

-	// Goal is a specific location and goal type

-	AI_NavGoal_t( GoalType_t 	type,

-				  const Vector &dest,

-				  Activity		activity  = AIN_DEF_ACTIVITY, 

-				  float			tolerance = AIN_DEF_TOLERANCE,

-				  unsigned 		flags     = AIN_DEF_FLAGS,

-				  CBaseEntity * pTarget   = AIN_DEF_TARGET);

-

-	// Goal is a specific node, and GOALTYPE_LOCATION

-	AI_NavGoal_t( AI_PathNode_t	destNode,

-				  Activity		activity  = AIN_DEF_ACTIVITY, 

-				  float			tolerance = AIN_DEF_TOLERANCE,

-				  unsigned 		flags     = AIN_DEF_FLAGS,

-				  CBaseEntity *	pTarget   = AIN_DEF_TARGET);

-				  

-	// Goal is a specific location and goal type

-	AI_NavGoal_t( GoalType_t	type,

-				  AI_PathNode_t	destNode,

-				  Activity		activity  = AIN_DEF_ACTIVITY, 

-				  float			tolerance = AIN_DEF_TOLERANCE,

-				  unsigned 		flags     = AIN_DEF_FLAGS,

-				  CBaseEntity *	pTarget   = AIN_DEF_TARGET);

-				  

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

-	

-	// What type of goal is this

-	GoalType_t 		type;

-

-	// The destination, either as a vector, or as a path node

-	Vector 			dest;

-	AI_PathNode_t	destNode;

-

-	// The activity to use, or none if a previosly set activity should be used

-	Activity		activity;

-	

-	// The predicted activity used after arrival

-	Activity		arrivalActivity;

-	int				arrivalSequence;

-

-	// The tolerance of success, or none if a previosly set tolerance should be used

-	float			tolerance;

-

-	// How far to permit an initial simplification of path

-	// (will use default if this value is less than the default)

-	float			maxInitialSimplificationDist;

-

-	// Optional flags specifying

-	unsigned		flags;

-

-	// The target of the navigation, primarily used to ignore the entity in hull and line traces

-	CBaseEntity *	pTarget;

-};

-

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

-// Purpose: Used to describe rules for advance on a (fly) path. There's nothing

-// 			specifically "flying" about it, other than it came from an attempte

-//			to consolodate duplicated code in the various fliers. It may serve

-//			a more general purpose in the future. The constructor takes those

-//			arguments that can usually be specified just once (as in a 

-//			local static constructor)

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

-

-struct AI_ProgressFlyPathParams_t

-{

-	AI_ProgressFlyPathParams_t( unsigned _collisionMask, 

-							   	float _strictPointTolerance = 32.0, float _blockTolerance = 0.0,

-							   	float _waypointTolerance = 100, float _goalTolerance = 12,

-							   	AI_NpcBlockHandling_t _blockHandling = AISF_BLOCK )

-	 :	collisionMask( _collisionMask ),

-		strictPointTolerance( _strictPointTolerance ),

-		blockTolerance( _blockTolerance ),

-		waypointTolerance( _waypointTolerance ),

-		goalTolerance( _goalTolerance ),

-		blockHandling( _blockHandling ),

-		pTarget( NULL ),

-		bTrySimplify( true )

-	{

-	}

-

-	void SetCurrent( const CBaseEntity *pNewTarget, bool bNewTrySimplify = true )

-	{

-		pTarget 	 = pNewTarget;

-		bTrySimplify = bNewTrySimplify;

-	}

-

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

-	

-	// Fields that tend to stay constant

-	unsigned 				collisionMask;

-	float 					strictPointTolerance;

-	float 					blockTolerance; 		// @TODO (toml 07-03-02): rename "blockTolerance". This is specifically the "simplify" block tolerance. See SimplifyFlyPath()

-	float 					waypointTolerance;

-	float 					goalTolerance;			// @TODO (toml 07-03-02): goalTolerance appears to have come into existence because

-													// noone had set a good tolerance in the path itself. It is therefore redundant,

-													// and more than likely should be excised

-	AI_NpcBlockHandling_t 	blockHandling;			// @TODO (toml 07-03-02): rename "blockHandling". This is specifically the "simplify" block handling. See SimplifyFlyPath()

-

-	// Fields that tend to change

-	const CBaseEntity *		pTarget;

-	bool 					bTrySimplify;

-};

-

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

-// CAI_Navigator

-//

-// Purpose: Implements pathing and path navigaton logic

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

-

-class CAI_Navigator : public CAI_Component,

-					  public CAI_DefMovementSink

-{

-	typedef CAI_Component BaseClass;

-public:

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

-	

-	CAI_Navigator(CAI_BaseNPC *pOuter);

-	virtual ~CAI_Navigator();

-

-	virtual void Init( CAI_Network *pNetwork );

-	

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

-

-	void SetPathcornerPathfinding( bool fNewVal)					{ m_bNoPathcornerPathfinds = !fNewVal; }

-	void SetRememberStaleNodes( bool fNewVal)						{ m_fRememberStaleNodes = fNewVal; }

-	void SetValidateActivitySpeed( bool bValidateActivitySpeed )	{ m_bValidateActivitySpeed = bValidateActivitySpeed; }

-	void SetLocalSucceedOnWithinTolerance( bool fNewVal )			{ m_bLocalSucceedOnWithinTolerance = fNewVal; }

-

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

-

-	void Save( ISave &save );

-	void Restore( IRestore &restore );

-	

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

-	// Methods to issue movement directives

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

-

-	// Simple pathfind

-	virtual bool 		SetGoal( const AI_NavGoal_t &goal, unsigned flags = 0 );

-	

-	// Change the target of the path

-	virtual bool		SetGoalTarget( CBaseEntity *pEntity, const Vector &offset );

-	

-	// Fancy pathing

-	bool				SetRadialGoal( const Vector &destination, const Vector &center, float radius, float arc, float stepDist, bool bClockwise, bool bAirRoute = false );

-	bool 				SetRandomGoal( float minPathLength, const Vector &dir = vec3_origin );

-	bool 				SetRandomGoal( const Vector &from, float minPathLength, const Vector &dir = vec3_origin );

-	bool				SetDirectGoal( const Vector &goalPos, Navigation_t navType = NAV_GROUND );

-	

-	bool				SetWanderGoal( float minRadius, float maxRadius );

-	bool				SetVectorGoal( const Vector &dir, float targetDist, float minDist = 0, bool fShouldDeflect = false );

-	bool				SetVectorGoalFromTarget( const Vector &goalPos, float minDist = 0, bool fShouldDeflect = false );

-

-	bool				FindVectorGoal( Vector *pResult, const Vector &dir, float targetDist, float minDist = 0, bool fShouldDeflect = false );

-	

-	// Path manipulation

-	bool 				PrependLocalAvoidance( float distObstacle, const AIMoveTrace_t &directTrace );

-	void 				PrependWaypoint( const Vector &newPoint, Navigation_t navType, unsigned waypointFlags = 0 );

-	

-	// Query or change the movement activity

-	Activity 			GetMovementActivity() const;

-	Activity 			SetMovementActivity(Activity activity);

-	int		 			GetMovementSequence();

-	void				SetMovementSequence( int sequence );

-

-	// Query or change the Arrival activity

-	Activity 			GetArrivalActivity() const;

-	void				SetArrivalActivity( Activity activity );

-	int					GetArrivalSequence( int curSequence );

-	void				SetArrivalSequence( int sequence );

-

-	// Set the facing direction at arrival

-	void				SetArrivalDirection( const Vector &goalDirection );

-	void				SetArrivalDirection( const QAngle &goalAngle );

-	void				SetArrivalDirection( CBaseEntity *pTarget );

-	Vector				GetArrivalDirection( );

-

-	// Set the speed to reach at arrival (

-	void				SetArrivalSpeed( float flSpeed );

-	float				GetArrivalSpeed();

-

-	// Set the estimated distance to stop before the actual goal

-	void				SetArrivalDistance( float flDistance );

-	float				GetArrivalDistance( ) const;

-

-	// Query or change the goal tolerance

-	float				GetGoalTolerance() const;

-	void				SetGoalTolerance(float tolerance);

-

-	GoalType_t			GetGoalType() const;

-	const Vector &		GetGoalPos() const;

-	CBaseEntity *		GetGoalTarget();

-	int					GetGoalFlags() const;

-	

-	const Vector &		GetCurWaypointPos() const;

-	int 				GetCurWaypointFlags() const;

-

-	bool				CurWaypointIsGoal() const;

-

-	bool				GetPointAlongPath( Vector *pResult, float distance, bool fReducibleOnly = false );

-

-	float				GetPathDistanceToGoal();

-	float				GetPathTimeToGoal();

-

-	// Query if there is a current goal

-	bool				IsGoalSet() const;

-

-	// Query if the current goal is active, meaning the navigator has a path in can progress on

-	bool				IsGoalActive() const;

-

-	// Update the goal position to reflect current conditions

-	bool 				RefindPathToGoal( bool fSignalTaskStatus = true, bool bDontIgnoreBadLinks = false );

-	bool 				UpdateGoalPos( const Vector & );

-	

-	// Wrap up current locomotion

-	void				StopMoving( bool bImmediate = true );

-

-	// Discard the current goal, use StopMoving() if just executing a normal stop

-	bool 				ClearGoal();

-

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

-

-	void				SetAllowBigStep( CBaseEntity *pEntToStepOff )	{ if ( !pEntToStepOff || !pEntToStepOff->IsWorld() ) m_hBigStepGroundEnt = pEntToStepOff; }

-

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

-	bool				SetGoalFromStoppingPath();

-	void				IgnoreStoppingPath();

-	

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

-	// Navigation mode

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

-	Navigation_t		GetNavType() const					{ return m_navType; }

-	void				SetNavType( Navigation_t navType );

-

-	bool 				IsInterruptable() const				{ return ( m_navType != NAV_CLIMB && m_navType != NAV_JUMP ); }

-	

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

-	// Pathing

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

-	

-	AI_NavPathProgress_t ProgressFlyPath( const AI_ProgressFlyPathParams_t &params); // note: will not return "blocked"

-

-	AI_PathNode_t		GetNearestNode();

-	Vector				GetNodePos( AI_PathNode_t );

-

-	CAI_Network *		GetNetwork()						{ return m_pAINetwork; }

-	const CAI_Network *	GetNetwork() const					{ return m_pAINetwork; }

-	void 				SetNetwork( CAI_Network *pNetwork ) { m_pAINetwork = pNetwork; }

-	

-	CAI_Path *			GetPath()							{ return m_pPath; }

-	const CAI_Path *	GetPath() const						{ return m_pPath; }

-

-	void				AdvancePath();

-

-	virtual bool		SimplifyPath( bool bFirstForPath = false, float maxDist = -1 );

-	void				SimplifyFlyPath( unsigned collisionMask, const CBaseEntity *pTarget, 

-										 float strictPointTolerance = 32.0, float blockTolerance = 0.0,

-										 AI_NpcBlockHandling_t blockHandling = AISF_BLOCK);

-	bool				SimplifyFlyPath(  const AI_ProgressFlyPathParams_t &params );

-	

-	bool				CanFitAtNode(int nodeNum, unsigned int collisionMask = MASK_NPCSOLID_BRUSHONLY); 

-	float				MovementCost( int moveType, Vector &vecStart, Vector &vecEnd );

-

-	bool				CanFitAtPosition( const Vector &vStartPos, unsigned int collisionMask, bool bIgnoreTransients = false, bool bAllowPlayerAvoid = true );

-	bool				IsOnNetwork() const			{ return !m_bNotOnNetwork; }

-

-	void				SetMaxRouteRebuildTime(float time) { m_timePathRebuildMax = time;			}

-

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

-	void				DrawDebugRouteOverlay( void );

-

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

-	// Miscellany

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

-

-	float				CalcYawSpeed();

-	float				GetStepDownMultiplier();

-	CBaseEntity *		GetNextPathcorner( CBaseEntity *pPathCorner );

-	virtual void		OnScheduleChange();

-	

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

-	

-	// See comments at CAI_BaseNPC::Move()

-	virtual bool		Move( float flInterval = 0.1 );

-

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

-

-	CBaseEntity *		GetBlockingEntity()	{ return m_hLastBlockingEnt; }

-	

-protected:

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

-	//

-	// Common services provided by CAI_BaseNPC

-	//

-	CBaseEntity *		GetNavTargetEntity();

-	void				TaskMovementComplete();

-	float				MaxYawSpeed();

-	void				SetSpeed( float );

-

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

-

-	CAI_Motor *			GetMotor()			{ return m_pMotor; }

-	const CAI_Motor *	GetMotor() const	{ return m_pMotor; }

-

-	CAI_MoveProbe *		GetMoveProbe()		{ return m_pMoveProbe; }

-	const CAI_MoveProbe *GetMoveProbe() const { return m_pMoveProbe; }

-

-	CAI_LocalNavigator *GetLocalNavigator()				{ return m_pLocalNavigator; }

-	const CAI_LocalNavigator *GetLocalNavigator() const { return m_pLocalNavigator; }

-

-	CAI_Pathfinder *	GetPathfinder();

-	const CAI_Pathfinder *GetPathfinder() const;

-

-	virtual void		OnClearPath(void);

-

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

-	

-	virtual void OnNewGoal();

-	virtual void OnNavComplete();

-			void OnNavFailed( bool bMovement = false );

-			void OnNavFailed( AI_TaskFailureCode_t code, bool bMovement = false );

-			void OnNavFailed( const char *pszGeneralFailText, bool bMovement = false );

-	

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

-	

- 	virtual AIMoveResult_t MoveNormal();

-

-	// Navigation execution

-	virtual AIMoveResult_t MoveClimb();

-	virtual AIMoveResult_t MoveJump();

-

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

-	

-	virtual AIMoveResult_t MoveEnact( const AILocalMoveGoal_t &baseMove );

-		

-protected:

-	// made this virtual so strider can implement hover behavior with a navigator

-	virtual void 		MoveCalcBaseGoal(  AILocalMoveGoal_t *pMoveGoal);

-	

-private:

-	virtual bool		OnCalcBaseMove( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );

-	virtual bool		OnObstructionPreSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );

-	virtual bool		OnFailedSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );

-	virtual bool 		OnFailedLocalNavigation( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );

-	virtual bool		OnInsufficientStopDist( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );

-	virtual bool		OnMoveStalled( const AILocalMoveGoal_t &move );

-	virtual bool		OnMoveExecuteFailed( const AILocalMoveGoal_t &move, const AIMoveTrace_t &trace, AIMotorMoveResult_t fMotorResult, AIMoveResult_t *pResult );

-	virtual bool		OnMoveBlocked( AIMoveResult_t *pResult );

-	

-	void ResetCalculations();

-	

-	// Methods shared between ground and fly movement

-	bool 				PreMove();

-	virtual bool 		MoveUpdateWaypoint( AIMoveResult_t *pResult );

-	bool 				IsMovingOutOfWay( const AILocalMoveGoal_t &moveGoal, float distClear );

-	bool 				DelayNavigationFailure( const AIMoveTrace_t &trace );

-

-	static void			CalculateDeflection( const Vector &start, const Vector &dir, const Vector &normal, Vector *pResult );

-

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

-	// Pathfinding

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

-

-public:

-	float				GetPathDistToCurWaypoint() const;

-	float				GetPathDistToGoal() const;

-	float				BuildAndGetPathDistToGoal();

-

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

-

-	int					GetNavFailCounter() const;

-	void 				ClearNavFailCounter();

-	float				GetLastNavFailTime() const;

-	bool				TeleportAlongPath();

-

-private:

-	bool				DoFindPath( void );							// Find a route

-	bool				DoFindPathToPathcorner( CBaseEntity *pPathCorner );

-

-protected:

-	virtual bool		DoFindPathToPos(void);

-	virtual	bool		ShouldOptimizeInitialPathSegment( AI_Waypoint_t * ) { return true; }

-

-private:

-	void				ClearPath(void);

-	void				SaveStoppingPath( void );

-

-protected:

-	virtual bool 		GetStoppingPath( CAI_WaypointList *pClippedWaypoints );

-

-private:

-	bool				FindPath( const AI_NavGoal_t &goal, unsigned flags );

-	bool				FindPath( bool fSignalTaskStatus = true, bool bDontIgnoreBadLinks = false );

-	bool				MarkCurWaypointFailedLink( void );			// Call when route fails

-

-	struct SimplifyForwardScanParams

-	{

-		float scanDist;

-		float radius;

-		float increment;

-		int maxSamples;

-	};

-

-	bool 				ShouldAttemptSimplifyTo( const Vector &pos );

-	bool 				ShouldSimplifyTo( bool passedDetour, const Vector &pos );

-	bool 				SimplifyPathForwardScan( const CAI_Navigator::SimplifyForwardScanParams &params );

-	bool				SimplifyPathForwardScan( const SimplifyForwardScanParams &params, AI_Waypoint_t *pCurWaypoint, const Vector &curPoint, float distRemaining, bool skip, bool passedDetour, int *pTestCount );

-	bool 				SimplifyPathForward( float maxDist = -1 );

-	bool 				SimplifyPathBacktrack();

-	bool 				SimplifyPathQuick();

-	void				SimplifyPathInsertSimplification( AI_Waypoint_t *pSegmentStart, const Vector &point );

-

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

-

-	static bool			ActivityIsLocomotive( Activity );

-    

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

-

-	Navigation_t		m_navType;									// My current navigation type (walk,fly)

-	bool				m_fNavComplete;

-	bool				m_bLastNavFailed;

-

-	// Cached pointers to other components, for efficiency

-	CAI_Motor *			m_pMotor;

-	CAI_MoveProbe *		m_pMoveProbe;

-	CAI_LocalNavigator *m_pLocalNavigator;

-

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

-

-	CAI_Network*		m_pAINetwork;			 					// My current AINetwork

-	CAI_Path*			m_pPath;									// My current route

-

-	CAI_WaypointList *	m_pClippedWaypoints;

-	float				m_flTimeClipped;

-	Activity			m_PreviousMoveActivity;

-	Activity			m_PreviousArrivalActivity;

-

-	bool				m_bValidateActivitySpeed;

-	bool				m_bCalledStartMove;

-	

-	bool				m_bNotOnNetwork;							// This NPC has no reachable nodes!

-

-	float				m_flNextSimplifyTime;						// next time we should try to simplify our route

-	bool				m_bForcedSimplify;

-	float				m_flLastSuccessfulSimplifyTime;

-

-	float				m_flTimeLastAvoidanceTriangulate;

-

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

-

-	float				m_timePathRebuildMax;						// How long to try rebuilding path before failing task

-	float				m_timePathRebuildDelay;						// How long to wait before trying to rebuild again

-

-	float				m_timePathRebuildFail;						// Current global time when should fail building path

-	float				m_timePathRebuildNext;						// Global time to try rebuilding again

-

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

-	

-	bool				m_fRememberStaleNodes;

-	bool				m_bNoPathcornerPathfinds;

-	bool				m_bLocalSucceedOnWithinTolerance;

-

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

-	

-	bool				m_fPeerMoveWait;

-	EHANDLE				m_hPeerWaitingOn;

-	CSimTimer 			m_PeerWaitMoveTimer;

-	CSimTimer			m_PeerWaitClearTimer;

-

-	CSimTimer			m_NextSidestepTimer;

-

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

-

-	EHANDLE				m_hBigStepGroundEnt;

-	EHANDLE				m_hLastBlockingEnt;

-

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

-

-	Vector				m_vPosBeginFailedSteer;

-	float				m_timeBeginFailedSteer;

-

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

-

-	int					m_nNavFailCounter;

-	float				m_flLastNavFailTime;

-public:

-	DECLARE_SIMPLE_DATADESC();

-};

-

-

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

-// AI_NavGoal_t inline methods

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

-

-inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t   type,

-								   Activity		activity, 

-								   float		tolerance,

-								   unsigned 	flags,

-								   CBaseEntity *pTarget)

- :	type(type),

-	dest(AIN_NO_DEST),

-	destNode(AIN_NO_NODE),

-	activity(activity),

-	tolerance(tolerance),

-	maxInitialSimplificationDist(-1),

-	flags(flags),

-	pTarget(pTarget),

-	arrivalActivity( AIN_DEF_ACTIVITY ),

-	arrivalSequence( ACT_INVALID )

-{

-}

-

-inline AI_NavGoal_t::AI_NavGoal_t( const Vector &dest,

-								   Activity		activity, 

-								   float		tolerance,

-								   unsigned 	flags,

-								   CBaseEntity *pTarget)

- :	type(GOALTYPE_LOCATION),

-	dest(dest),

-	destNode(AIN_NO_NODE),

-	activity(activity),

-	tolerance(tolerance),

-	maxInitialSimplificationDist(-1),

-	flags(flags),

-	pTarget(pTarget),

-	arrivalActivity( AIN_DEF_ACTIVITY ),

-	arrivalSequence( ACT_INVALID )

-{

-}

-

-inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t 	type,

-								   const Vector &dest,

-								   Activity		activity, 

-								   float		tolerance,

-								   unsigned 	flags,

-								   CBaseEntity *pTarget)

- :	type(type),

-	dest(dest),

-	destNode(AIN_NO_NODE),

-	activity(activity),

-	tolerance(tolerance),

-	maxInitialSimplificationDist(-1),

-	flags(flags),

-	pTarget(pTarget),

-	arrivalActivity( AIN_DEF_ACTIVITY ),

-	arrivalSequence( ACT_INVALID )

-{

-}

-

-inline AI_NavGoal_t::AI_NavGoal_t( AI_PathNode_t destNode,

-								   Activity		 activity, 

-								   float		 tolerance,

-								   unsigned 	 flags,

-								   CBaseEntity * pTarget)

- :	type(GOALTYPE_LOCATION),

-	dest(AIN_NO_DEST),

-	destNode(destNode),

-	activity(activity),

-	tolerance(tolerance),

-	maxInitialSimplificationDist(-1),

-	flags(flags),

-	pTarget(pTarget),

-	arrivalActivity( AIN_DEF_ACTIVITY ),

-	arrivalSequence( ACT_INVALID )

-{

-}

-

-inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t	 type,

-								   AI_PathNode_t destNode,

-								   Activity		 activity, 

-								   float		 tolerance,

-								   unsigned 	 flags,

-								   CBaseEntity * pTarget)

- :	type(type),

-	dest(AIN_NO_DEST),

-	destNode(destNode),

-	activity(activity),

-	tolerance(tolerance),

-	maxInitialSimplificationDist(-1),

-	flags(flags),

-	pTarget(pTarget),

-	arrivalActivity( AIN_DEF_ACTIVITY ),

-	arrivalSequence( ACT_INVALID )

-{

-}

-

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

-

-#endif // AI_NAVIGATOR_H

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef AI_NAVIGATOR_H
+#define AI_NAVIGATOR_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "simtimer.h"
+#include "ai_component.h"
+#include "ai_navgoaltype.h"
+#include "ai_navtype.h"
+#include "ai_motor.h"
+
+class CAI_BaseNPC;
+class CAI_Motor;
+class CAI_Route;
+class CAI_Path;
+class CAI_Pathfinder;
+class CAI_LocalNavigator;
+struct AI_Waypoint_t;
+class CAI_WaypointList;
+class CAI_Network;
+struct AIMoveTrace_t;
+struct AILocalMoveGoal_t;
+typedef int AI_TaskFailureCode_t;
+
+//-----------------------------------------------------------------------------
+// Debugging tools
+//-----------------------------------------------------------------------------
+
+#define DEBUG_AI_NAVIGATION 1
+#ifdef DEBUG_AI_NAVIGATION
+extern ConVar ai_debug_nav;
+#define DbgNav() ai_debug_nav.GetBool()
+#define DbgNavMsg( pAI, pszMsg ) \
+	do \
+	{ \
+		if (DbgNav()) \
+			DevMsg( pAI, CFmtStr( "[Nav] %s", static_cast<const char *>(pszMsg) ) ); \
+	} while (0)
+#define DbgNavMsg1( pAI, pszMsg, a ) DbgNavMsg( pAI, CFmtStr(static_cast<const char *>(pszMsg), (a) ) )
+#define DbgNavMsg2( pAI, pszMsg, a, b ) DbgNavMsg( pAI, CFmtStr(static_cast<const char *>(pszMsg), (a), (b) ) )
+#else
+#define DbgNav() false
+#define DbgNavMsg( pAI, pszMsg ) ((void)0)
+#define DbgNavMsg1( pAI, pszMsg, a ) ((void)0)
+#define DbgNavMsg2( pAI, pszMsg, a, b ) ((void)0)
+#endif
+
+
+//-----------------------------------------------------------------------------
+// STRUCTURES & ENUMERATIONS
+//-----------------------------------------------------------------------------
+
+DECLARE_POINTER_HANDLE( AI_PathNode_t );
+
+//-------------------------------------
+// Purpose: Constants used to specify the properties of a requested navigation
+//			goal.
+//-------------------------------------
+
+// Navigator should use the default or previously set tolerance
+const float AIN_DEF_TOLERANCE  = -1.0;
+
+// Navigator should use the hull size as the tolerance
+const float AIN_HULL_TOLERANCE = -2.0;
+
+// Goal does not specify a new activity
+const Activity AIN_DEF_ACTIVITY = ACT_INVALID;
+
+// Goal has no target
+CBaseEntity * const AIN_NO_TARGET  = NULL;
+
+// Goal does not specify a new target, use the existing one, if any
+CBaseEntity * const AIN_DEF_TARGET = (AIN_NO_TARGET + 1);
+
+// Goal does not specify a vector location
+extern const Vector AIN_NO_DEST;
+
+// Goal does not specify a node location
+#define AIN_NO_NODE ((AI_PathNode_t)-1)
+
+
+//-------------------------------------
+
+enum AI_NavGoalFlags_t
+{
+	// While navigating, try to face the destination point
+	AIN_YAW_TO_DEST			= 0x01,
+	
+	// If I'm a goal of type GOALTYPE_TARGETENT, update my goal position every time I think
+	AIN_UPDATE_TARGET_POS	= 0x02,
+
+	// If navigating on a designer placed path, don't use pathfinder between waypoints, just do it
+	AIN_NO_PATHCORNER_PATHFINDING = 0x04,
+
+	AIN_DEF_FLAGS			= 0,
+};
+
+//-------------------------------------
+
+enum AI_NavSetGoalFlags_t
+{
+	// Reset the navigator's navigation to the default state
+	AIN_CLEAR_PREVIOUS_STATE 	= 0x01,
+	
+	// Clear out the target entity, while retaining other settings
+	AIN_CLEAR_TARGET			= 0x02,
+	
+	// If the navigate fails, return navigation to the default state
+	AIN_DISCARD_IF_FAIL			= 0x04,
+
+	// Don't signal TaskFail() if the pathfind fails, just return the result
+	AIN_NO_PATH_TASK_FAIL		= 0x08,
+};
+
+//-------------------------------------
+
+enum AI_NpcBlockHandling_t
+{
+	AISF_BLOCK,
+	AISF_AVOID,
+	AISF_IGNORE,
+};
+
+//-------------------------------------
+
+enum AI_NavPathProgress_t
+{
+	AINPP_NO_CHANGE,
+	AINPP_ADVANCED,
+	AINPP_COMPLETE,
+	AINPP_BLOCKED,
+};
+
+//-------------------------------------
+// Purpose: Describes a navigation request. The various constructors simply
+//			allow ease of use in the common cases.
+//-------------------------------------
+
+struct AI_NavGoal_t
+{
+	// Goal is unspecifed, or not a specific location
+	AI_NavGoal_t( GoalType_t    type	  = GOALTYPE_INVALID,
+				  Activity		activity  = AIN_DEF_ACTIVITY, 
+				  float			tolerance = AIN_DEF_TOLERANCE,
+				  unsigned 		flags     = AIN_DEF_FLAGS,
+				  CBaseEntity * pTarget   = AIN_DEF_TARGET);
+	
+	// Goal is a specific location, and GOALTYPE_LOCATION
+	AI_NavGoal_t( const Vector &dest,
+				  Activity		activity  = AIN_DEF_ACTIVITY, 
+				  float			tolerance = AIN_DEF_TOLERANCE,
+				  unsigned 		flags     = AIN_DEF_FLAGS,
+				  CBaseEntity * pTarget   = AIN_DEF_TARGET);
+
+	// Goal is a specific location and goal type
+	AI_NavGoal_t( GoalType_t 	type,
+				  const Vector &dest,
+				  Activity		activity  = AIN_DEF_ACTIVITY, 
+				  float			tolerance = AIN_DEF_TOLERANCE,
+				  unsigned 		flags     = AIN_DEF_FLAGS,
+				  CBaseEntity * pTarget   = AIN_DEF_TARGET);
+
+	// Goal is a specific node, and GOALTYPE_LOCATION
+	AI_NavGoal_t( AI_PathNode_t	destNode,
+				  Activity		activity  = AIN_DEF_ACTIVITY, 
+				  float			tolerance = AIN_DEF_TOLERANCE,
+				  unsigned 		flags     = AIN_DEF_FLAGS,
+				  CBaseEntity *	pTarget   = AIN_DEF_TARGET);
+				  
+	// Goal is a specific location and goal type
+	AI_NavGoal_t( GoalType_t	type,
+				  AI_PathNode_t	destNode,
+				  Activity		activity  = AIN_DEF_ACTIVITY, 
+				  float			tolerance = AIN_DEF_TOLERANCE,
+				  unsigned 		flags     = AIN_DEF_FLAGS,
+				  CBaseEntity *	pTarget   = AIN_DEF_TARGET);
+				  
+	//----------------------------------
+	
+	// What type of goal is this
+	GoalType_t 		type;
+
+	// The destination, either as a vector, or as a path node
+	Vector 			dest;
+	AI_PathNode_t	destNode;
+
+	// The activity to use, or none if a previosly set activity should be used
+	Activity		activity;
+	
+	// The predicted activity used after arrival
+	Activity		arrivalActivity;
+	int				arrivalSequence;
+
+	// The tolerance of success, or none if a previosly set tolerance should be used
+	float			tolerance;
+
+	// How far to permit an initial simplification of path
+	// (will use default if this value is less than the default)
+	float			maxInitialSimplificationDist;
+
+	// Optional flags specifying
+	unsigned		flags;
+
+	// The target of the navigation, primarily used to ignore the entity in hull and line traces
+	CBaseEntity *	pTarget;
+};
+
+//-------------------------------------
+// Purpose: Used to describe rules for advance on a (fly) path. There's nothing
+// 			specifically "flying" about it, other than it came from an attempte
+//			to consolodate duplicated code in the various fliers. It may serve
+//			a more general purpose in the future. The constructor takes those
+//			arguments that can usually be specified just once (as in a 
+//			local static constructor)
+//-------------------------------------
+
+struct AI_ProgressFlyPathParams_t
+{
+	AI_ProgressFlyPathParams_t( unsigned _collisionMask, 
+							   	float _strictPointTolerance = 32.0, float _blockTolerance = 0.0,
+							   	float _waypointTolerance = 100, float _goalTolerance = 12,
+							   	AI_NpcBlockHandling_t _blockHandling = AISF_BLOCK )
+	 :	collisionMask( _collisionMask ),
+		strictPointTolerance( _strictPointTolerance ),
+		blockTolerance( _blockTolerance ),
+		waypointTolerance( _waypointTolerance ),
+		goalTolerance( _goalTolerance ),
+		blockHandling( _blockHandling ),
+		pTarget( NULL ),
+		bTrySimplify( true )
+	{
+	}
+
+	void SetCurrent( const CBaseEntity *pNewTarget, bool bNewTrySimplify = true )
+	{
+		pTarget 	 = pNewTarget;
+		bTrySimplify = bNewTrySimplify;
+	}
+
+	//----------------------------------
+	
+	// Fields that tend to stay constant
+	unsigned 				collisionMask;
+	float 					strictPointTolerance;
+	float 					blockTolerance; 		// @TODO (toml 07-03-02): rename "blockTolerance". This is specifically the "simplify" block tolerance. See SimplifyFlyPath()
+	float 					waypointTolerance;
+	float 					goalTolerance;			// @TODO (toml 07-03-02): goalTolerance appears to have come into existence because
+													// noone had set a good tolerance in the path itself. It is therefore redundant,
+													// and more than likely should be excised
+	AI_NpcBlockHandling_t 	blockHandling;			// @TODO (toml 07-03-02): rename "blockHandling". This is specifically the "simplify" block handling. See SimplifyFlyPath()
+
+	// Fields that tend to change
+	const CBaseEntity *		pTarget;
+	bool 					bTrySimplify;
+};
+
+//-----------------------------------------------------------------------------
+// CAI_Navigator
+//
+// Purpose: Implements pathing and path navigaton logic
+//-----------------------------------------------------------------------------
+
+class CAI_Navigator : public CAI_Component,
+					  public CAI_DefMovementSink
+{
+	typedef CAI_Component BaseClass;
+public:
+	// --------------------------------
+	
+	CAI_Navigator(CAI_BaseNPC *pOuter);
+	virtual ~CAI_Navigator();
+
+	virtual void Init( CAI_Network *pNetwork );
+	
+	// --------------------------------
+
+	void SetPathcornerPathfinding( bool fNewVal)					{ m_bNoPathcornerPathfinds = !fNewVal; }
+	void SetRememberStaleNodes( bool fNewVal)						{ m_fRememberStaleNodes = fNewVal; }
+	void SetValidateActivitySpeed( bool bValidateActivitySpeed )	{ m_bValidateActivitySpeed = bValidateActivitySpeed; }
+	void SetLocalSucceedOnWithinTolerance( bool fNewVal )			{ m_bLocalSucceedOnWithinTolerance = fNewVal; }
+
+	// --------------------------------
+
+	void Save( ISave &save );
+	void Restore( IRestore &restore );
+	
+	// --------------------------------
+	// Methods to issue movement directives
+	// --------------------------------
+
+	// Simple pathfind
+	virtual bool 		SetGoal( const AI_NavGoal_t &goal, unsigned flags = 0 );
+	
+	// Change the target of the path
+	virtual bool		SetGoalTarget( CBaseEntity *pEntity, const Vector &offset );
+	
+	// Fancy pathing
+	bool				SetRadialGoal( const Vector &destination, const Vector &center, float radius, float arc, float stepDist, bool bClockwise, bool bAirRoute = false );
+	bool 				SetRandomGoal( float minPathLength, const Vector &dir = vec3_origin );
+	bool 				SetRandomGoal( const Vector &from, float minPathLength, const Vector &dir = vec3_origin );
+	bool				SetDirectGoal( const Vector &goalPos, Navigation_t navType = NAV_GROUND );
+	
+	bool				SetWanderGoal( float minRadius, float maxRadius );
+	bool				SetVectorGoal( const Vector &dir, float targetDist, float minDist = 0, bool fShouldDeflect = false );
+	bool				SetVectorGoalFromTarget( const Vector &goalPos, float minDist = 0, bool fShouldDeflect = false );
+
+	bool				FindVectorGoal( Vector *pResult, const Vector &dir, float targetDist, float minDist = 0, bool fShouldDeflect = false );
+	
+	// Path manipulation
+	bool 				PrependLocalAvoidance( float distObstacle, const AIMoveTrace_t &directTrace );
+	void 				PrependWaypoint( const Vector &newPoint, Navigation_t navType, unsigned waypointFlags = 0 );
+	
+	// Query or change the movement activity
+	Activity 			GetMovementActivity() const;
+	Activity 			SetMovementActivity(Activity activity);
+	int		 			GetMovementSequence();
+	void				SetMovementSequence( int sequence );
+
+	// Query or change the Arrival activity
+	Activity 			GetArrivalActivity() const;
+	void				SetArrivalActivity( Activity activity );
+	int					GetArrivalSequence( int curSequence );
+	void				SetArrivalSequence( int sequence );
+
+	// Set the facing direction at arrival
+	void				SetArrivalDirection( const Vector &goalDirection );
+	void				SetArrivalDirection( const QAngle &goalAngle );
+	void				SetArrivalDirection( CBaseEntity *pTarget );
+	Vector				GetArrivalDirection( );
+
+	// Set the speed to reach at arrival (
+	void				SetArrivalSpeed( float flSpeed );
+	float				GetArrivalSpeed();
+
+	// Set the estimated distance to stop before the actual goal
+	void				SetArrivalDistance( float flDistance );
+	float				GetArrivalDistance( ) const;
+
+	// Query or change the goal tolerance
+	float				GetGoalTolerance() const;
+	void				SetGoalTolerance(float tolerance);
+
+	GoalType_t			GetGoalType() const;
+	const Vector &		GetGoalPos() const;
+	CBaseEntity *		GetGoalTarget();
+	int					GetGoalFlags() const;
+	
+	const Vector &		GetCurWaypointPos() const;
+	int 				GetCurWaypointFlags() const;
+
+	bool				CurWaypointIsGoal() const;
+
+	bool				GetPointAlongPath( Vector *pResult, float distance, bool fReducibleOnly = false );
+
+	float				GetPathDistanceToGoal();
+	float				GetPathTimeToGoal();
+
+	// Query if there is a current goal
+	bool				IsGoalSet() const;
+
+	// Query if the current goal is active, meaning the navigator has a path in can progress on
+	bool				IsGoalActive() const;
+
+	// Update the goal position to reflect current conditions
+	bool 				RefindPathToGoal( bool fSignalTaskStatus = true, bool bDontIgnoreBadLinks = false );
+	bool 				UpdateGoalPos( const Vector & );
+	
+	// Wrap up current locomotion
+	void				StopMoving( bool bImmediate = true );
+
+	// Discard the current goal, use StopMoving() if just executing a normal stop
+	bool 				ClearGoal();
+
+	// --------------------------------
+
+	void				SetAllowBigStep( CBaseEntity *pEntToStepOff )	{ if ( !pEntToStepOff || !pEntToStepOff->IsWorld() ) m_hBigStepGroundEnt = pEntToStepOff; }
+
+	// --------------------------------
+	bool				SetGoalFromStoppingPath();
+	void				IgnoreStoppingPath();
+	
+	// --------------------------------
+	// Navigation mode
+	// --------------------------------
+	Navigation_t		GetNavType() const					{ return m_navType; }
+	void				SetNavType( Navigation_t navType );
+
+	bool 				IsInterruptable() const				{ return ( m_navType != NAV_CLIMB && m_navType != NAV_JUMP ); }
+	
+	// --------------------------------
+	// Pathing
+	// --------------------------------
+	
+	AI_NavPathProgress_t ProgressFlyPath( const AI_ProgressFlyPathParams_t &params); // note: will not return "blocked"
+
+	AI_PathNode_t		GetNearestNode();
+	Vector				GetNodePos( AI_PathNode_t );
+
+	CAI_Network *		GetNetwork()						{ return m_pAINetwork; }
+	const CAI_Network *	GetNetwork() const					{ return m_pAINetwork; }
+	void 				SetNetwork( CAI_Network *pNetwork ) { m_pAINetwork = pNetwork; }
+	
+	CAI_Path *			GetPath()							{ return m_pPath; }
+	const CAI_Path *	GetPath() const						{ return m_pPath; }
+
+	void				AdvancePath();
+
+	virtual bool		SimplifyPath( bool bFirstForPath = false, float maxDist = -1 );
+	void				SimplifyFlyPath( unsigned collisionMask, const CBaseEntity *pTarget, 
+										 float strictPointTolerance = 32.0, float blockTolerance = 0.0,
+										 AI_NpcBlockHandling_t blockHandling = AISF_BLOCK);
+	bool				SimplifyFlyPath(  const AI_ProgressFlyPathParams_t &params );
+	
+	bool				CanFitAtNode(int nodeNum, unsigned int collisionMask = MASK_NPCSOLID_BRUSHONLY); 
+	float				MovementCost( int moveType, Vector &vecStart, Vector &vecEnd );
+
+	bool				CanFitAtPosition( const Vector &vStartPos, unsigned int collisionMask, bool bIgnoreTransients = false, bool bAllowPlayerAvoid = true );
+	bool				IsOnNetwork() const			{ return !m_bNotOnNetwork; }
+
+	void				SetMaxRouteRebuildTime(float time) { m_timePathRebuildMax = time;			}
+
+	// --------------------------------
+	void				DrawDebugRouteOverlay( void );
+
+	// --------------------------------
+	// Miscellany
+	// --------------------------------
+
+	float				CalcYawSpeed();
+	float				GetStepDownMultiplier();
+	CBaseEntity *		GetNextPathcorner( CBaseEntity *pPathCorner );
+	virtual void		OnScheduleChange();
+	
+	// --------------------------------
+	
+	// See comments at CAI_BaseNPC::Move()
+	virtual bool		Move( float flInterval = 0.1 );
+
+	// --------------------------------
+
+	CBaseEntity *		GetBlockingEntity()	{ return m_hLastBlockingEnt; }
+	
+protected:
+	// --------------------------------
+	//
+	// Common services provided by CAI_BaseNPC
+	//
+	CBaseEntity *		GetNavTargetEntity();
+	void				TaskMovementComplete();
+	float				MaxYawSpeed();
+	void				SetSpeed( float );
+
+	// --------------------------------
+
+	CAI_Motor *			GetMotor()			{ return m_pMotor; }
+	const CAI_Motor *	GetMotor() const	{ return m_pMotor; }
+
+	CAI_MoveProbe *		GetMoveProbe()		{ return m_pMoveProbe; }
+	const CAI_MoveProbe *GetMoveProbe() const { return m_pMoveProbe; }
+
+	CAI_LocalNavigator *GetLocalNavigator()				{ return m_pLocalNavigator; }
+	const CAI_LocalNavigator *GetLocalNavigator() const { return m_pLocalNavigator; }
+
+	CAI_Pathfinder *	GetPathfinder();
+	const CAI_Pathfinder *GetPathfinder() const;
+
+	virtual void		OnClearPath(void);
+
+	// --------------------------------
+	
+	virtual void OnNewGoal();
+	virtual void OnNavComplete();
+			void OnNavFailed( bool bMovement = false );
+			void OnNavFailed( AI_TaskFailureCode_t code, bool bMovement = false );
+			void OnNavFailed( const char *pszGeneralFailText, bool bMovement = false );
+	
+	// --------------------------------
+	
+ 	virtual AIMoveResult_t MoveNormal();
+
+	// Navigation execution
+	virtual AIMoveResult_t MoveClimb();
+	virtual AIMoveResult_t MoveJump();
+
+	// --------------------------------
+	
+	virtual AIMoveResult_t MoveEnact( const AILocalMoveGoal_t &baseMove );
+		
+protected:
+	// made this virtual so strider can implement hover behavior with a navigator
+	virtual void 		MoveCalcBaseGoal(  AILocalMoveGoal_t *pMoveGoal);
+	
+private:
+	virtual bool		OnCalcBaseMove( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );
+	virtual bool		OnObstructionPreSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );
+	virtual bool		OnFailedSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );
+	virtual bool 		OnFailedLocalNavigation( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );
+	virtual bool		OnInsufficientStopDist( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult );
+	virtual bool		OnMoveStalled( const AILocalMoveGoal_t &move );
+	virtual bool		OnMoveExecuteFailed( const AILocalMoveGoal_t &move, const AIMoveTrace_t &trace, AIMotorMoveResult_t fMotorResult, AIMoveResult_t *pResult );
+	virtual bool		OnMoveBlocked( AIMoveResult_t *pResult );
+	
+	void ResetCalculations();
+	
+	// Methods shared between ground and fly movement
+	bool 				PreMove();
+	virtual bool 		MoveUpdateWaypoint( AIMoveResult_t *pResult );
+	bool 				IsMovingOutOfWay( const AILocalMoveGoal_t &moveGoal, float distClear );
+	bool 				DelayNavigationFailure( const AIMoveTrace_t &trace );
+
+	static void			CalculateDeflection( const Vector &start, const Vector &dir, const Vector &normal, Vector *pResult );
+
+	// --------------------------------
+	// Pathfinding
+	// --------------------------------
+
+public:
+	float				GetPathDistToCurWaypoint() const;
+	float				GetPathDistToGoal() const;
+	float				BuildAndGetPathDistToGoal();
+
+	// --------------------------------
+
+	int					GetNavFailCounter() const;
+	void 				ClearNavFailCounter();
+	float				GetLastNavFailTime() const;
+	bool				TeleportAlongPath();
+
+private:
+	bool				DoFindPath( void );							// Find a route
+	bool				DoFindPathToPathcorner( CBaseEntity *pPathCorner );
+
+protected:
+	virtual bool		DoFindPathToPos(void);
+	virtual	bool		ShouldOptimizeInitialPathSegment( AI_Waypoint_t * ) { return true; }
+
+private:
+	void				ClearPath(void);
+	void				SaveStoppingPath( void );
+
+protected:
+	virtual bool 		GetStoppingPath( CAI_WaypointList *pClippedWaypoints );
+
+private:
+	bool				FindPath( const AI_NavGoal_t &goal, unsigned flags );
+	bool				FindPath( bool fSignalTaskStatus = true, bool bDontIgnoreBadLinks = false );
+	bool				MarkCurWaypointFailedLink( void );			// Call when route fails
+
+	struct SimplifyForwardScanParams
+	{
+		float scanDist;
+		float radius;
+		float increment;
+		int maxSamples;
+	};
+
+	bool 				ShouldAttemptSimplifyTo( const Vector &pos );
+	bool 				ShouldSimplifyTo( bool passedDetour, const Vector &pos );
+	bool 				SimplifyPathForwardScan( const CAI_Navigator::SimplifyForwardScanParams &params );
+	bool				SimplifyPathForwardScan( const SimplifyForwardScanParams &params, AI_Waypoint_t *pCurWaypoint, const Vector &curPoint, float distRemaining, bool skip, bool passedDetour, int *pTestCount );
+	bool 				SimplifyPathForward( float maxDist = -1 );
+	bool 				SimplifyPathBacktrack();
+	bool 				SimplifyPathQuick();
+	void				SimplifyPathInsertSimplification( AI_Waypoint_t *pSegmentStart, const Vector &point );
+
+    // ---------------------------------
+
+	static bool			ActivityIsLocomotive( Activity );
+    
+    // ---------------------------------
+
+	Navigation_t		m_navType;									// My current navigation type (walk,fly)
+	bool				m_fNavComplete;
+	bool				m_bLastNavFailed;
+
+	// Cached pointers to other components, for efficiency
+	CAI_Motor *			m_pMotor;
+	CAI_MoveProbe *		m_pMoveProbe;
+	CAI_LocalNavigator *m_pLocalNavigator;
+
+    // ---------------------------------
+
+	CAI_Network*		m_pAINetwork;			 					// My current AINetwork
+	CAI_Path*			m_pPath;									// My current route
+
+	CAI_WaypointList *	m_pClippedWaypoints;
+	float				m_flTimeClipped;
+	Activity			m_PreviousMoveActivity;
+	Activity			m_PreviousArrivalActivity;
+
+	bool				m_bValidateActivitySpeed;
+	bool				m_bCalledStartMove;
+	
+	bool				m_bNotOnNetwork;							// This NPC has no reachable nodes!
+
+	float				m_flNextSimplifyTime;						// next time we should try to simplify our route
+	bool				m_bForcedSimplify;
+	float				m_flLastSuccessfulSimplifyTime;
+
+	float				m_flTimeLastAvoidanceTriangulate;
+
+	// --------------
+
+	float				m_timePathRebuildMax;						// How long to try rebuilding path before failing task
+	float				m_timePathRebuildDelay;						// How long to wait before trying to rebuild again
+
+	float				m_timePathRebuildFail;						// Current global time when should fail building path
+	float				m_timePathRebuildNext;						// Global time to try rebuilding again
+
+	// --------------
+	
+	bool				m_fRememberStaleNodes;
+	bool				m_bNoPathcornerPathfinds;
+	bool				m_bLocalSucceedOnWithinTolerance;
+
+	// --------------
+	
+	bool				m_fPeerMoveWait;
+	EHANDLE				m_hPeerWaitingOn;
+	CSimTimer 			m_PeerWaitMoveTimer;
+	CSimTimer			m_PeerWaitClearTimer;
+
+	CSimTimer			m_NextSidestepTimer;
+
+	// --------------
+
+	EHANDLE				m_hBigStepGroundEnt;
+	EHANDLE				m_hLastBlockingEnt;
+
+	// --------------
+
+	Vector				m_vPosBeginFailedSteer;
+	float				m_timeBeginFailedSteer;
+
+	// --------------
+
+	int					m_nNavFailCounter;
+	float				m_flLastNavFailTime;
+public:
+	DECLARE_SIMPLE_DATADESC();
+};
+
+
+//-----------------------------------------------------------------------------
+// AI_NavGoal_t inline methods
+//-----------------------------------------------------------------------------
+
+inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t   type,
+								   Activity		activity, 
+								   float		tolerance,
+								   unsigned 	flags,
+								   CBaseEntity *pTarget)
+ :	type(type),
+	dest(AIN_NO_DEST),
+	destNode(AIN_NO_NODE),
+	activity(activity),
+	tolerance(tolerance),
+	maxInitialSimplificationDist(-1),
+	flags(flags),
+	pTarget(pTarget),
+	arrivalActivity( AIN_DEF_ACTIVITY ),
+	arrivalSequence( ACT_INVALID )
+{
+}
+
+inline AI_NavGoal_t::AI_NavGoal_t( const Vector &dest,
+								   Activity		activity, 
+								   float		tolerance,
+								   unsigned 	flags,
+								   CBaseEntity *pTarget)
+ :	type(GOALTYPE_LOCATION),
+	dest(dest),
+	destNode(AIN_NO_NODE),
+	activity(activity),
+	tolerance(tolerance),
+	maxInitialSimplificationDist(-1),
+	flags(flags),
+	pTarget(pTarget),
+	arrivalActivity( AIN_DEF_ACTIVITY ),
+	arrivalSequence( ACT_INVALID )
+{
+}
+
+inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t 	type,
+								   const Vector &dest,
+								   Activity		activity, 
+								   float		tolerance,
+								   unsigned 	flags,
+								   CBaseEntity *pTarget)
+ :	type(type),
+	dest(dest),
+	destNode(AIN_NO_NODE),
+	activity(activity),
+	tolerance(tolerance),
+	maxInitialSimplificationDist(-1),
+	flags(flags),
+	pTarget(pTarget),
+	arrivalActivity( AIN_DEF_ACTIVITY ),
+	arrivalSequence( ACT_INVALID )
+{
+}
+
+inline AI_NavGoal_t::AI_NavGoal_t( AI_PathNode_t destNode,
+								   Activity		 activity, 
+								   float		 tolerance,
+								   unsigned 	 flags,
+								   CBaseEntity * pTarget)
+ :	type(GOALTYPE_LOCATION),
+	dest(AIN_NO_DEST),
+	destNode(destNode),
+	activity(activity),
+	tolerance(tolerance),
+	maxInitialSimplificationDist(-1),
+	flags(flags),
+	pTarget(pTarget),
+	arrivalActivity( AIN_DEF_ACTIVITY ),
+	arrivalSequence( ACT_INVALID )
+{
+}
+
+inline AI_NavGoal_t::AI_NavGoal_t( GoalType_t	 type,
+								   AI_PathNode_t destNode,
+								   Activity		 activity, 
+								   float		 tolerance,
+								   unsigned 	 flags,
+								   CBaseEntity * pTarget)
+ :	type(type),
+	dest(AIN_NO_DEST),
+	destNode(destNode),
+	activity(activity),
+	tolerance(tolerance),
+	maxInitialSimplificationDist(-1),
+	flags(flags),
+	pTarget(pTarget),
+	arrivalActivity( AIN_DEF_ACTIVITY ),
+	arrivalSequence( ACT_INVALID )
+{
+}
+
+//-----------------------------------------------------------------------------
+
+#endif // AI_NAVIGATOR_H