1HEADmaster

1 files changed, 274 insertions, 0 deletions

diff --git a/game/server/ai_trackpather.h b/game/server/ai_trackpather.h
new file mode 100644
index 0000000..a2ce734
--- /dev/null
+++ b/game/server/ai_trackpather.h
@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#ifndef AI_TRACKPATHER_H
+#define AI_TRACKPATHER_H
+
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+
+#include "ai_basenpc.h"
+
+
+class CPathTrack;
+
+//------------------------------------------------------------------------------
+
+class CAI_TrackPather : public CAI_BaseNPC
+{
+	DECLARE_CLASS( CAI_TrackPather, CAI_BaseNPC );
+	DECLARE_DATADESC();
+public:
+
+	bool			IsOnPathTrack()							{ return (m_pCurrentPathTarget != NULL); }
+
+protected:	
+	void			InitPathingData( float flTrackArrivalTolerance, float flTargetDistance, float flAvoidDistance );
+	virtual bool	GetTrackPatherTarget( Vector *pPos ) { return false; }
+	virtual CBaseEntity *GetTrackPatherTargetEnt()	{ return NULL; }
+
+	const Vector &	GetDesiredPosition() const				{ return m_vecDesiredPosition; 	}
+	void 			SetDesiredPosition( const Vector &v )	{ m_vecDesiredPosition = v; 	}
+	const Vector &	GetGoalOrientation() const				{ return m_vecGoalOrientation; 	}
+	void 			SetGoalOrientation( const Vector &v )	{ m_vecGoalOrientation = v; 	}
+
+	bool			CurPathTargetIsDest()					{ return ( m_pDestPathTarget == m_pCurrentPathTarget ); }
+
+	virtual bool	HasReachedTarget( void ) 				{ return (WorldSpaceCenter() - m_vecDesiredPosition).Length() < 128; }
+
+	CPathTrack *	GetDestPathTarget()						{ return m_pDestPathTarget;		}
+
+	bool			IsInForcedMove() const					{ return m_bForcedMove;			}
+	void			ClearForcedMove()						{ m_bForcedMove = false;		}
+
+	float			GetPathMaxSpeed() const					{ return m_flPathMaxSpeed;		}
+
+	void			OnSave( IEntitySaveUtils *pUtils );
+	void			OnRestore( void );
+
+protected:
+	enum PauseState_t
+	{
+		PAUSE_NO_PAUSE = 0,
+		PAUSED_AT_POSITION,
+		PAUSE_AT_NEXT_LOS_POSITION,
+
+		PAUSE_FORCE_DWORD = 0xFFFFFFFF,
+	};
+
+	// Sets a track
+	void SetTrack( string_t strTrackName );
+	void SetTrack( CBaseEntity *pGoalEnt );
+
+	// Fly to a particular track point via the path
+	virtual void InputFlyToPathTrack( inputdata_t &inputdata );
+
+	// Updates the nav target if we've reached it
+	void UpdateTrackNavigation( void );
+
+	// Computes distance + nearest point from the current path..
+	float ClosestPointToCurrentPath( Vector *pVecPoint ) const;
+
+	// Computes a "path" velocity at a particular point along the current path
+	void ComputePathTangent( float t, Vector *pVecTangent ) const;
+
+	// Computes the *normalized* velocity at which the helicopter should approach the final point
+	void ComputeNormalizedDestVelocity( Vector *pVecVelocity ) const;
+
+	// Sets the farthest path distance
+	void SetFarthestPathDist( float flMaxPathDist );
+
+	// Returns the next/previous path along our current path
+	CPathTrack *NextAlongCurrentPath( CPathTrack *pPath ) const;
+	CPathTrack *PreviousAlongCurrentPath( CPathTrack *pPath ) const;
+
+	// Adjusts a "next"most node based on the current movement direction
+	CPathTrack *AdjustForMovementDirection( CPathTrack *pPath ) const;
+
+	// Enemy visibility check
+	virtual CBaseEntity *FindTrackBlocker( const Vector &vecViewPoint, const Vector &vecTargetPos );
+
+	// Compute a point n units along a path
+	void ComputePointAlongPath( const Vector &vecStartPoint, float flDistance, Vector *pTarget );
+
+	// Are we leading?
+	bool IsLeading() const { return m_bLeading && !m_bForcedMove; }
+
+	// Leading + leading distance
+	void EnableLeading( bool bEnable );
+	void SetLeadingDistance( float flLeadDistance );
+	float GetLeadingDistance( ) const;
+
+	// Compute a point n units along the current path from our current position
+	// (but don't pass the desired target point)
+	void ComputePointAlongCurrentPath( float flDistance, float flPerpDist, Vector *pTarget );
+
+	// Returns the perpendicular distance of the target from the nearest path point
+	float TargetDistanceToPath() const { return m_flTargetDistFromPath; }
+
+	// Returns the speed of the target relative to the path
+	float TargetSpeedAlongPath() const;
+
+	// Returns the speed of the target *across* the path
+	float TargetSpeedAcrossPath() const;
+
+	// Compute a path direction
+	void ComputePathDirection( CPathTrack *pPath, Vector *pVecPathDir );
+
+	// What's the current path direction?
+	void CurrentPathDirection( Vector *pVecPathDir );
+
+	// Returns the max distance we can be from the path
+	float MaxDistanceFromCurrentPath() const;
+
+	// true to use farthest, false for nearest
+	void UseFarthestPathPoint( bool useFarthest );
+
+	// Moves to an explicit track point
+	void MoveToTrackPoint( CPathTrack *pTrack );
+
+	// Sets up a new current path target
+	void SetupNewCurrentTarget( CPathTrack *pTrack );
+
+	// Compute the distance to the leading position
+	float ComputeDistanceToLeadingPosition();
+
+	// Compute the distance to the target position
+	float ComputeDistanceToTargetPosition();
+
+	// Set the pause state.
+	void SetPauseState( PauseState_t pauseState ) { m_nPauseState = pauseState; }
+
+	// Does this path track have LOS to the target?
+	bool HasLOSToTarget( CPathTrack *pTrack );
+
+	// FIXME: Work this back into the base class
+	virtual bool ShouldUseFixedPatrolLogic() { return false; }
+
+	// Deal with teleportation
+	void Teleported();
+
+private:
+
+	CPathTrack		*BestPointOnPath( CPathTrack *pPath, const Vector &targetPos, float avoidRadius, bool visible, bool bFarthestPointOnPath );
+
+	// Input methods
+	void InputSetTrack( inputdata_t &inputdata );
+	void InputChooseFarthestPathPoint( inputdata_t &inputdata );
+	void InputChooseNearestPathPoint( inputdata_t &inputdata );
+	void InputStartBreakableMovement( inputdata_t &inputdata );
+	void InputStopBreakableMovement( inputdata_t &inputdata );
+	void InputStartPatrol( inputdata_t &inputdata );
+	void InputStopPatrol( inputdata_t &inputdata );
+	void InputStartLeading( inputdata_t &inputdata );
+	void InputStopLeading( inputdata_t &inputdata );
+
+	// Obsolete, for backward compatibility
+	void InputStartPatrolBreakable( inputdata_t &inputdata );
+
+	// Flies to a point on a track
+	void FlyToPathTrack( string_t strTrackName );
+
+	// Selects a new destination target
+	void SelectNewDestTarget();
+
+	// Makes sure we've picked the right position along the path if we're chasing an enemy
+	void UpdateTargetPosition( );
+
+	// Moves to the track
+	void UpdateCurrentTarget();
+	void UpdateCurrentTargetLeading();
+
+	// Track debugging info
+	void VisualizeDebugInfo( const Vector &vecNearestPoint, const Vector &vecTarget );
+
+	// Moves to the closest track point
+	void MoveToClosestTrackPoint( CPathTrack *pTrack );
+
+	// Are the two path tracks connected?
+	bool IsOnSameTrack( CPathTrack *pPath1, CPathTrack *pPath2 ) const;
+
+	// Is pPathTest in "front" of pPath on the same path? (Namely, does GetNext() get us there?)
+	bool IsForwardAlongPath( CPathTrack *pPath, CPathTrack *pPathTest ) const;
+
+	// Purpose: 
+	void UpdateTargetPositionLeading( void );
+
+	// Compute a point n units along a path
+	CPathTrack *ComputeLeadingPointAlongPath( const Vector &vecStartPoint, CPathTrack *pFirstTrack, float flDistance, Vector *pTarget );
+
+	// Finds the closest point on the path, returns a signed perpendicular distance
+	CPathTrack *FindClosestPointOnPath( CPathTrack *pPath, const Vector &targetPos, Vector *pVecClosestPoint, Vector *pVecPathDir, float *pDistanceFromPath );
+
+	// 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 ComputePerpDistanceFromPath( const Vector &vecPointOnPath, const Vector &vecPathDir, const Vector &vecPointOffPath );
+	void ComputePointFromPerpDistance( const Vector &vecPointOnPath, const Vector &vecPathDir, float flPerpDist, Vector *pResult );
+
+	// Returns the direction of the path at the closest point to the target
+	const Vector &TargetPathDirection() const;
+	const Vector &TargetPathAcrossDirection() const;
+
+	// Returns distance along path to target, returns -1 if there's no path
+	float ComputePathDistance( CPathTrack *pStart, CPathTrack *pDest, bool bForward ) const;
+
+	// Compute the distance to a particular point on the path
+	float ComputeDistanceAlongPathToPoint( CPathTrack *pStartTrack, CPathTrack *pDestTrack, const Vector &vecDestPosition, bool bMovingForward );
+
+private:
+	//---------------------------------
+	Vector			m_vecDesiredPosition;
+	Vector			m_vecGoalOrientation; // orientation of the goal entity.
+
+	// NOTE: CurrentPathTarget changes meaning based on movement direction
+	// For this *after* means the "next" (m_pnext) side of the line segment
+	// and "before" means the "prev" (m_pprevious) side of the line segment
+	// CurrentPathTarget is *after* the desired point when moving forward, 
+	// and *before* the desired point when moving backward.
+	// DestPathTarget + TargetNearestPath always represent points
+	// *after* the desired point.
+	CHandle<CPathTrack> m_pCurrentPathTarget;
+	CHandle<CPathTrack> m_pDestPathTarget;
+	CHandle<CPathTrack> m_pLastPathTarget;
+	CHandle<CPathTrack> m_pTargetNearestPath;	// Used only by leading, it specifies the path point *after* where the target is
+
+	string_t		m_strCurrentPathName;
+	string_t		m_strDestPathName;
+	string_t		m_strLastPathName;
+	string_t		m_strTargetNearestPathName;
+
+	Vector			m_vecLastGoalCheckPosition;	// Last position checked for moving towards
+	float			m_flEnemyPathUpdateTime;	// Next time to update our enemies position
+	bool			m_bForcedMove;				// Means the destination point must be reached regardless of enemy position
+	bool			m_bPatrolling;				// If set, move back and forth along the current track until we see an enemy
+	bool			m_bPatrolBreakable;			// If set, I'll stop patrolling if I see an enemy
+	bool			m_bLeading;					// If set, we can lead our enemies
+
+	// Derived class pathing data
+	float			m_flTargetDistanceThreshold;// Distance threshold used to determine when a target has moved enough to update our navigation to it
+	float			m_flAvoidDistance;			//
+	
+	float			m_flTargetTolerance;		// How far from a path track do we need to be before we 'reached' it?
+	Vector			m_vecSegmentStartPoint;		// Starting point for the current segment
+	Vector			m_vecSegmentStartSplinePoint;	// Used to define a spline which is used to compute path velocity
+	bool			m_bMovingForward;
+	bool			m_bChooseFarthestPoint;
+	float			m_flFarthestPathDist;		// How far from a path track do we need to be before we 'reached' it?
+
+	float			m_flPathMaxSpeed;
+	float			m_flTargetDistFromPath;		// How far is the target from the closest point on the path?
+	float			m_flLeadDistance;
+	Vector			m_vecTargetPathDir;
+	Vector			m_vecTargetPathPoint;		// What point on the path is closest to the target?
+
+	PauseState_t	m_nPauseState;
+};
+
+//------------------------------------------------------------------------------
+
+#endif // AI_TRACKPATHER_H