You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
683 lines
18 KiB
683 lines
18 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//=============================================================================// |
|
|
|
#include "cbase.h" |
|
#include "ai_link.h" |
|
#include "ai_navtype.h" |
|
#include "ai_waypoint.h" |
|
#include "ai_pathfinder.h" |
|
#include "ai_navgoaltype.h" |
|
#include "ai_routedist.h" |
|
#include "ai_route.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
BEGIN_SIMPLE_DATADESC(CAI_Path) |
|
// m_Waypoints (reconsititute on load) |
|
DEFINE_FIELD( m_goalTolerance, FIELD_FLOAT ), |
|
DEFINE_CUSTOM_FIELD( m_activity, ActivityDataOps() ), |
|
DEFINE_FIELD( m_target, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_sequence, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_vecTargetOffset, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_waypointTolerance, FIELD_FLOAT ), |
|
DEFINE_CUSTOM_FIELD( m_arrivalActivity, ActivityDataOps() ), |
|
DEFINE_FIELD( m_arrivalSequence, FIELD_INTEGER ), |
|
// m_iLastNodeReached |
|
DEFINE_FIELD( m_bGoalPosSet, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_goalPos, FIELD_POSITION_VECTOR), |
|
DEFINE_FIELD( m_bGoalTypeSet, FIELD_BOOLEAN ), |
|
DEFINE_FIELD( m_goalType, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_goalFlags, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_routeStartTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_goalDirection, FIELD_VECTOR ), |
|
DEFINE_FIELD( m_goalDirectionTarget, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_goalSpeed, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_goalSpeedTarget, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_goalStoppingDistance, FIELD_FLOAT ), |
|
END_DATADESC() |
|
|
|
//----------------------------------------------------------------------------- |
|
AI_Waypoint_t CAI_Path::gm_InvalidWaypoint( Vector(0,0,0), 0, NAV_NONE, 0, 0 ); |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetWaypoints(AI_Waypoint_t* route, bool fSetGoalFromLast) |
|
{ |
|
m_Waypoints.Set(route); |
|
|
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast ) |
|
{ |
|
pLast->flPathDistGoal = -1; |
|
if ( fSetGoalFromLast ) |
|
{ |
|
if ( pLast ) |
|
{ |
|
m_bGoalPosSet = false; |
|
pLast->ModifyFlags( bits_WP_TO_GOAL, true ); |
|
SetGoalPosition(pLast->GetPos()); |
|
} |
|
} |
|
} |
|
|
|
AssertRouteValid( m_Waypoints.GetFirst() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::PrependWaypoints( AI_Waypoint_t *pWaypoints ) |
|
{ |
|
m_Waypoints.PrependWaypoints( pWaypoints ); |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
pLast->flPathDistGoal = -1; |
|
|
|
AssertRouteValid( m_Waypoints.GetFirst() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::PrependWaypoint( const Vector &newPoint, Navigation_t navType, unsigned waypointFlags ) |
|
{ |
|
m_Waypoints.PrependWaypoint( newPoint, navType, waypointFlags ); |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
pLast->flPathDistGoal = -1; |
|
|
|
AssertRouteValid( m_Waypoints.GetFirst() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
float CAI_Path::GetPathLength() |
|
{ |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast && pLast->flPathDistGoal == -1 ) |
|
{ |
|
ComputeRouteGoalDistances( pLast ); |
|
} |
|
AI_Waypoint_t *pCurrent = GetCurWaypoint(); |
|
return ( ( pCurrent ) ? pCurrent->flPathDistGoal : 0 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
float CAI_Path::GetPathDistanceToGoal( const Vector &startPos ) |
|
{ |
|
AI_Waypoint_t *pCurrent = GetCurWaypoint(); |
|
if ( pCurrent ) |
|
{ |
|
return ( GetPathLength() + ComputePathDistance(pCurrent->NavType(), startPos, pCurrent->GetPos()) ); |
|
} |
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
Activity CAI_Path::SetMovementActivity(Activity activity) |
|
{ |
|
Assert( activity != ACT_RESET && activity != ACT_INVALID ); |
|
//Msg("Set movement to %s\n", ActivityList_NameForIndex(activity) ); |
|
|
|
m_sequence = ACT_INVALID; |
|
return (m_activity = activity); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
Activity CAI_Path::GetArrivalActivity( ) const |
|
{ |
|
if ( !m_Waypoints.IsEmpty() ) |
|
{ |
|
return m_arrivalActivity; |
|
} |
|
return ACT_INVALID; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetArrivalActivity(Activity activity) |
|
{ |
|
m_arrivalActivity = activity; |
|
m_arrivalSequence = ACT_INVALID; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
int CAI_Path::GetArrivalSequence( ) const |
|
{ |
|
if ( !m_Waypoints.IsEmpty() ) |
|
{ |
|
return m_arrivalSequence; |
|
} |
|
return ACT_INVALID; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetArrivalSequence( int sequence ) |
|
{ |
|
m_arrivalSequence = sequence; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetGoalDirection( const Vector &goalDirection ) |
|
{ |
|
m_goalDirectionTarget = NULL; |
|
m_goalDirection = goalDirection; |
|
VectorNormalize( m_goalDirection ); |
|
/* |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast ) |
|
{ |
|
NDebugOverlay::Box( pLast->vecLocation, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 0,0,255, 0, 2.0 ); |
|
NDebugOverlay::Line( pLast->vecLocation, pLast->vecLocation + m_goalDirection * 32, 0,0,255, true, 2.0 ); |
|
} |
|
*/ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetGoalDirection( CBaseEntity *pTarget ) |
|
{ |
|
m_goalDirectionTarget = pTarget; |
|
|
|
if (pTarget) |
|
{ |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast ) |
|
{ |
|
m_goalDirection = pTarget->GetAbsOrigin() - pLast->vecLocation; |
|
VectorNormalize( m_goalDirection ); |
|
/* |
|
NDebugOverlay::Box( pLast->vecLocation, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 0,0,255, 0, 2.0 ); |
|
NDebugOverlay::Line( pLast->vecLocation, pLast->vecLocation + m_goalDirection * 32, 0,0,255, true, 2.0 ); |
|
*/ |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
Vector CAI_Path::GetGoalDirection( const Vector &startPos ) |
|
{ |
|
if (m_goalDirectionTarget) |
|
{ |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast ) |
|
{ |
|
AI_Waypoint_t *pPrev = pLast->GetPrev(); |
|
if (pPrev) |
|
{ |
|
Vector goalDirection = m_goalDirectionTarget->GetAbsOrigin() - pPrev->vecLocation; |
|
VectorNormalize( goalDirection ); |
|
return goalDirection; |
|
} |
|
else |
|
{ |
|
Vector goalDirection = m_goalDirectionTarget->GetAbsOrigin() - startPos; |
|
VectorNormalize( goalDirection ); |
|
return goalDirection; |
|
} |
|
} |
|
} |
|
else if (m_goalDirection == vec3_origin) |
|
{ |
|
// Assert(0); // comment out the default directions in SetGoal() to find test cases for missing initialization |
|
AI_Waypoint_t *pLast = m_Waypoints.GetLast(); |
|
if ( pLast ) |
|
{ |
|
AI_Waypoint_t *pPrev = pLast->GetPrev(); |
|
if (pPrev) |
|
{ |
|
Vector goalDirection = pLast->vecLocation - pPrev->vecLocation; |
|
VectorNormalize( goalDirection ); |
|
return goalDirection; |
|
} |
|
else |
|
{ |
|
Vector goalDirection =pLast->vecLocation - startPos; |
|
VectorNormalize( goalDirection ); |
|
return goalDirection; |
|
} |
|
} |
|
} |
|
|
|
return m_goalDirection; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetGoalSpeed( float flSpeed ) |
|
{ |
|
m_goalSpeed = flSpeed; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetGoalSpeed( CBaseEntity *pTarget ) |
|
{ |
|
m_goalSpeedTarget = pTarget; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
float CAI_Path::GetGoalSpeed( const Vector &startPos ) |
|
{ |
|
if (m_goalSpeedTarget) |
|
{ |
|
Vector goalDirection = GetGoalDirection( startPos ); |
|
Vector targetVelocity = m_goalSpeedTarget->GetSmoothedVelocity(); |
|
float dot = DotProduct( goalDirection, targetVelocity ); |
|
dot = MAX( 0.0f, dot ); |
|
// return a relative impact speed of m_goalSpeed |
|
if (m_goalSpeed > 0.0) |
|
{ |
|
return dot + m_goalSpeed; |
|
} |
|
return dot; |
|
} |
|
return m_goalSpeed; |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::SetGoalStoppingDistance( float flDistance ) |
|
{ |
|
m_goalStoppingDistance = flDistance; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
float CAI_Path::GetGoalStoppingDistance( ) const |
|
{ |
|
return m_goalStoppingDistance; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
const Vector &CAI_Path::CurWaypointPos() const |
|
{ |
|
if ( GetCurWaypoint() ) |
|
return GetCurWaypoint()->GetPos(); |
|
AssertMsg(0, "Invalid call to CurWaypointPos()"); |
|
return gm_InvalidWaypoint.GetPos(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
const Vector &CAI_Path::NextWaypointPos() const |
|
{ |
|
if ( GetCurWaypoint() && GetCurWaypoint()->GetNext()) |
|
return GetCurWaypoint()->GetNext()->GetPos(); |
|
static Vector invalid( 0, 0, 0 ); |
|
AssertMsg(0, "Invalid call to NextWaypointPos()"); |
|
return gm_InvalidWaypoint.GetPos(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
float CAI_Path::CurWaypointYaw() const |
|
{ |
|
return GetCurWaypoint()->flYaw; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::SetGoalPosition(const Vector &goalPos) |
|
{ |
|
|
|
#ifdef _DEBUG |
|
// Make sure goal position isn't set more than once |
|
if (m_bGoalPosSet == true) |
|
{ |
|
DevMsg( "GetCurWaypoint Goal Position Set Twice!\n"); |
|
} |
|
#endif |
|
|
|
m_bGoalPosSet = true; |
|
VectorAdd( goalPos, m_vecTargetOffset, m_goalPos ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sets last node as goal and goal position |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::SetLastNodeAsGoal(bool bReset) |
|
{ |
|
#ifdef _DEBUG |
|
// Make sure goal position isn't set more than once |
|
if (!bReset && m_bGoalPosSet == true) |
|
{ |
|
DevMsg( "GetCurWaypoint Goal Position Set Twice!\n"); |
|
} |
|
#endif |
|
|
|
// Find the last node |
|
if (GetCurWaypoint()) |
|
{ |
|
AI_Waypoint_t* waypoint = GetCurWaypoint(); |
|
|
|
while (waypoint) |
|
{ |
|
if (!waypoint->GetNext()) |
|
{ |
|
m_goalPos = waypoint->GetPos(); |
|
m_bGoalPosSet = true; |
|
waypoint->ModifyFlags( bits_WP_TO_GOAL, true ); |
|
return; |
|
} |
|
waypoint = waypoint->GetNext(); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Explicitly change the goal position w/o check |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::ResetGoalPosition(const Vector &goalPos) |
|
{ |
|
m_bGoalPosSet = true; |
|
VectorAdd( goalPos, m_vecTargetOffset, m_goalPos ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the *base* goal position (without the offset applied) |
|
//----------------------------------------------------------------------------- |
|
const Vector& CAI_Path::BaseGoalPosition() const |
|
{ |
|
#ifdef _DEBUG |
|
// Make sure goal position was set |
|
if (m_bGoalPosSet == false) |
|
{ |
|
DevMsg( "GetCurWaypoint Goal Position Never Set!\n"); |
|
} |
|
#endif |
|
|
|
// FIXME: A little risky; store the base if this becomes a problem |
|
static Vector vecResult; |
|
VectorSubtract( m_goalPos, m_vecTargetOffset, vecResult ); |
|
return vecResult; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the *actual* goal position (with the offset applied) |
|
//----------------------------------------------------------------------------- |
|
const Vector & CAI_Path::ActualGoalPosition(void) const |
|
{ |
|
#ifdef _DEBUG |
|
// Make sure goal position was set |
|
if (m_bGoalPosSet == false) |
|
{ |
|
DevMsg( "GetCurWaypoint Goal Position Never Set!\n"); |
|
} |
|
#endif |
|
|
|
return m_goalPos; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::SetGoalType(GoalType_t goalType) |
|
{ |
|
|
|
#ifdef _DEBUG |
|
// Make sure goal position isn't set more than once |
|
if (m_goalType != GOALTYPE_NONE && goalType != GOALTYPE_NONE ) |
|
{ |
|
DevMsg( "GetCurWaypoint Goal Type Set Twice!\n"); |
|
} |
|
#endif |
|
|
|
if (m_goalType != GOALTYPE_NONE) |
|
{ |
|
m_routeStartTime = gpGlobals->curtime; |
|
m_bGoalTypeSet = true; |
|
} |
|
else |
|
m_bGoalTypeSet = false; |
|
|
|
m_goalType = goalType; |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
GoalType_t CAI_Path::GoalType(void) const |
|
{ |
|
return m_goalType; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
void CAI_Path::Advance( void ) |
|
{ |
|
if ( CurWaypointIsGoal() ) |
|
return; |
|
|
|
// ------------------------------------------------------- |
|
// If I have another waypoint advance my path |
|
// ------------------------------------------------------- |
|
if (GetCurWaypoint()->GetNext()) |
|
{ |
|
AI_Waypoint_t *pNext = GetCurWaypoint()->GetNext(); |
|
|
|
// If waypoint was a node take note of it |
|
if (GetCurWaypoint()->Flags() & bits_WP_TO_NODE) |
|
{ |
|
m_iLastNodeReached = GetCurWaypoint()->iNodeID; |
|
} |
|
|
|
delete GetCurWaypoint(); |
|
SetWaypoints(pNext); |
|
|
|
return; |
|
} |
|
// ------------------------------------------------- |
|
// This is an error catch that should *not* happen |
|
// It means a route was created with no goal |
|
// ------------------------------------------------- |
|
else |
|
{ |
|
DevMsg( "!!ERROR!! Force end of route with no goal!\n"); |
|
GetCurWaypoint()->ModifyFlags( bits_WP_TO_GOAL, true ); |
|
} |
|
|
|
AssertRouteValid( m_Waypoints.GetFirst() ); |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Clears the route and resets all its fields to default values |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::Clear( void ) |
|
{ |
|
m_Waypoints.RemoveAll(); |
|
|
|
m_goalType = GOALTYPE_NONE; // Type of goal |
|
m_goalPos = vec3_origin; // Our ultimate goal position |
|
m_bGoalPosSet = false; // Was goal position set |
|
m_bGoalTypeSet = false; // Was goal position set |
|
m_goalFlags = false; |
|
m_vecTargetOffset = vec3_origin; |
|
m_routeStartTime = FLT_MAX; |
|
|
|
m_goalTolerance = 0.0; // How close do we need to get to the goal |
|
// FIXME: split m_goalTolerance into m_buildTolerance and m_moveTolerance, let them be seperatly controllable. |
|
|
|
m_activity = ACT_INVALID; |
|
m_sequence = ACT_INVALID; |
|
m_target = NULL; |
|
|
|
m_arrivalActivity = ACT_INVALID; |
|
m_arrivalSequence = ACT_INVALID; |
|
|
|
m_goalDirectionTarget = NULL; |
|
m_goalDirection = vec3_origin; |
|
|
|
m_goalSpeedTarget = NULL; |
|
m_goalSpeed = -1.0f; // init to an invalid speed |
|
|
|
m_goalStoppingDistance = 0.0; // How close to we want to get to the goal |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
Navigation_t CAI_Path::CurWaypointNavType() const |
|
{ |
|
if (!GetCurWaypoint()) |
|
{ |
|
return NAV_NONE; |
|
} |
|
else |
|
{ |
|
return GetCurWaypoint()->NavType(); |
|
} |
|
} |
|
|
|
int CAI_Path::CurWaypointFlags() const |
|
{ |
|
if (!GetCurWaypoint()) |
|
{ |
|
return 0; |
|
} |
|
else |
|
{ |
|
return GetCurWaypoint()->Flags(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the goal's flags |
|
// Output : unsigned |
|
//----------------------------------------------------------------------------- |
|
unsigned CAI_Path::GoalFlags( void ) const |
|
{ |
|
return m_goalFlags; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns true if current waypoint is my goal |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CAI_Path::CurWaypointIsGoal( void ) const |
|
{ |
|
// Assert( GetCurWaypoint() ); |
|
|
|
if( !GetCurWaypoint() ) |
|
return false; |
|
|
|
|
|
if ( GetCurWaypoint()->Flags() & bits_WP_TO_GOAL ) |
|
{ |
|
#ifdef _DEBUG |
|
if (GetCurWaypoint()->GetNext()) |
|
{ |
|
DevMsg( "!!ERROR!! Goal is not last waypoint!\n"); |
|
} |
|
if ((GetCurWaypoint()->GetPos() - m_goalPos).Length() > 0.1) |
|
{ |
|
DevMsg( "!!ERROR!! Last waypoint isn't in goal position!\n"); |
|
} |
|
#endif |
|
return true; |
|
} |
|
if ( GetCurWaypoint()->Flags() & bits_WP_TO_PATHCORNER ) |
|
{ |
|
// UNDONE: Refresh here or somewhere else? |
|
} |
|
#ifdef _DEBUG |
|
if (!GetCurWaypoint()->GetNext()) |
|
{ |
|
DevMsg( "!!ERROR!! GetCurWaypoint has no goal!\n"); |
|
} |
|
#endif |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the goal distance for each waypoint along the route |
|
//----------------------------------------------------------------------------- |
|
void CAI_Path::ComputeRouteGoalDistances(AI_Waypoint_t *pGoalWaypoint) |
|
{ |
|
// The goal distance is the distance from any waypoint to the goal waypoint |
|
|
|
// Backup through the list and calculate distance to goal |
|
AI_Waypoint_t *pPrev; |
|
AI_Waypoint_t *pCurWaypoint = pGoalWaypoint; |
|
pCurWaypoint->flPathDistGoal = 0; |
|
while (pCurWaypoint->GetPrev()) |
|
{ |
|
pPrev = pCurWaypoint->GetPrev(); |
|
|
|
float flWaypointDist = ComputePathDistance(pCurWaypoint->NavType(), pPrev->GetPos(), pCurWaypoint->GetPos()); |
|
pPrev->flPathDistGoal = pCurWaypoint->flPathDistGoal + flWaypointDist; |
|
|
|
pCurWaypoint = pPrev; |
|
} |
|
} |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
CAI_Path::CAI_Path() |
|
{ |
|
m_goalType = GOALTYPE_NONE; // Type of goal |
|
m_goalPos = vec3_origin; // Our ultimate goal position |
|
m_goalTolerance = 0.0; // How close do we need to get to the goal |
|
m_activity = ACT_INVALID; // The activity to use during motion |
|
m_sequence = ACT_INVALID; |
|
m_target = NULL; |
|
m_goalFlags = 0; |
|
m_routeStartTime = FLT_MAX; |
|
m_arrivalActivity = ACT_INVALID; |
|
m_arrivalSequence = ACT_INVALID; |
|
|
|
m_iLastNodeReached = NO_NODE; |
|
|
|
m_waypointTolerance = DEF_WAYPOINT_TOLERANCE; |
|
|
|
} |
|
|
|
CAI_Path::~CAI_Path() |
|
{ |
|
DeleteAll( GetCurWaypoint() ); |
|
} |
|
|
|
|
|
|