// If we are not on the navigation mesh (m_currentArea == nullptr),
// move towards last known area.
// Return false if off mesh.
bool CCSBot::StayOnNavMesh()
{
if (m_currentArea)
return true;
// move back onto the area map
// if we have no lastKnownArea, we probably started off
// of the nav mesh - find the closest nav area and use it
CNavArea *goalArea;
if (!m_currentArea && !m_lastKnownArea)
{
goalArea = TheNavAreaGrid.GetNearestNavArea(&pev->origin);
PrintIfWatched("Started off the nav mesh - moving to closest nav area...\n");
}
else
{
goalArea = m_lastKnownArea;
PrintIfWatched("Getting out of NULL area...\n");
}
if (goalArea)
{
Vector pos;
goalArea->GetClosestPointOnArea(&pev->origin, &pos);
// move point into area
Vector to = pos - pev->origin;
to.NormalizeInPlace();
// how far to "step into" an area - must be less than min area size
const float stepInDist = 5.0f;
pos = pos + (stepInDist * to);
MoveTowardsPosition(&pos);
}
// if we're stuck, try to get un-stuck
// do stuck movements last, so they override normal movement
if (m_isStuck)
{
Wiggle();
}
return false;
}
void CHostageImprov::UpdatePosition(float deltaT)
{
CNavArea *area = TheNavAreaGrid.GetNavArea(&m_hostage->pev->origin);
if (area != NULL)
{
m_lastKnownArea = area;
}
DrawAxes(m_moveGoal, 255, 255, 0);
if (IsJumping())
{
Vector dir;
const float pushSpeed = 100.0f;
if (!m_hasJumped)
{
m_hasJumped = true;
m_hasJumpedIntoAir = false;
m_hostage->pev->velocity.z += 300.0f;
}
else
ResetJump();
dir = m_jumpTarget - GetFeet();
dir.z = 0;
#ifndef PLAY_GAMEDLL
// TODO: fix test demo
dir.NormalizeInPlace();
m_hostage->pev->velocity.x = dir.x * pushSpeed;
m_hostage->pev->velocity.y = dir.y * pushSpeed;
#else
Vector vecRet = NormalizeMulScalar<float_precision, float_precision, float_precision, float>(dir, pushSpeed);
m_hostage->pev->velocity.x = vecRet.x;
m_hostage->pev->velocity.y = vecRet.y;
#endif
m_hostage->SetBoneController(0);
m_hostage->SetBoneController(1);
FaceTowards(m_jumpTarget, deltaT);
return;
}
if (m_isLookingAt)
{
Vector angles = UTIL_VecToAngles(m_viewGoal - GetEyes());
float_precision pitch = angles.x - m_hostage->pev->angles.x;
float_precision yaw = angles.y - m_hostage->pev->angles.y;
while (yaw > 180.0f)
yaw -= 360.0f;
while (yaw < -180.0f)
yaw += 360.0f;
while (pitch > 180.0f)
pitch -= 360.0f;
while (pitch < -180.0f)
pitch += 360.0f;
m_hostage->SetBoneController(0, yaw);
m_hostage->SetBoneController(1, -pitch);
if (IsAtMoveGoal() && !HasFaceTo())
{
if (yaw < -45.0f || yaw > 45.0f)
{
FaceTowards(m_viewGoal, deltaT);
}
}
}
else
{
m_hostage->SetBoneController(0);
m_hostage->SetBoneController(1);
}
if (HasFaceTo() && FaceTowards(m_faceGoal, deltaT))
ClearFaceTo();
if (!IsAtMoveGoal() || m_path.GetSegmentCount() > 0)
{
if (m_path.GetSegmentCount() <= 0)
{
HostagePathCost pathCost;
if (m_path.Compute(&GetFeet(), &m_moveGoal, pathCost))
{
m_follower.SetPath(&m_path);
m_follower.SetImprov(this);
m_follower.Reset();
m_follower.Debug(cv_hostage_debug.value > 0.0);
}
}
m_follower.Update(deltaT, m_inhibitObstacleAvoidance.IsElapsed());
if (m_moveType == Stopped)
{
m_follower.ResetStuck();
}
if (m_follower.IsStuck())
{
Wiggle();
}
}
const float friction = 3.0f;
m_vel.x += m_vel.x * -friction * deltaT;
m_vel.y += m_vel.y * -friction * deltaT;
float_precision speed = m_vel.NormalizeInPlace();
const float maxSpeed = 285.0f;
if (speed > maxSpeed)
{
speed = maxSpeed;
}
m_vel.x = m_vel.x * speed;
m_vel.y = m_vel.y * speed;
KeepPersonalSpace spacer(this);
ForEachPlayer(spacer);
if (g_pHostages != NULL)
{
g_pHostages->ForEachHostage(spacer);
}
m_hostage->pev->velocity.x = m_vel.x;
m_hostage->pev->velocity.y = m_vel.y;
m_moveFlags = 0;
}
// Navigate our current ladder. Return true if we are doing ladder navigation.
// TODO: Need Push() and Pop() for run/walk context to keep ladder speed contained.
bool CCSBot::UpdateLadderMovement()
{
if (!m_pathLadder)
return false;
bool giveUp = false;
// check for timeout
const float ladderTimeoutDuration = 10.0f;
if (gpGlobals->time - m_pathLadderTimestamp > ladderTimeoutDuration)
{
PrintIfWatched("Ladder timeout!\n");
giveUp = true;
}
else if (m_pathLadderState == APPROACH_ASCENDING_LADDER
|| m_pathLadderState == APPROACH_DESCENDING_LADDER
|| m_pathLadderState == ASCEND_LADDER
|| m_pathLadderState == DESCEND_LADDER
|| m_pathLadderState == DISMOUNT_ASCENDING_LADDER
|| m_pathLadderState == MOVE_TO_DESTINATION)
{
if (m_isStuck)
{
PrintIfWatched("Giving up ladder - stuck\n");
giveUp = true;
}
}
if (giveUp)
{
// jump off ladder and give up
Jump(MUST_JUMP);
Wiggle();
ResetStuckMonitor();
DestroyPath();
Run();
return false;
}
ResetStuckMonitor();
// check if somehow we totally missed the ladder
switch (m_pathLadderState)
{
case MOUNT_ASCENDING_LADDER:
case MOUNT_DESCENDING_LADDER:
case ASCEND_LADDER:
case DESCEND_LADDER:
{
const float farAway = 200.0f;
Vector2D d = (m_pathLadder->m_top - pev->origin).Make2D();
if (d.IsLengthGreaterThan(farAway))
{
PrintIfWatched("Missed ladder\n");
Jump(MUST_JUMP);
DestroyPath();
Run();
return false;
}
break;
}
}
m_areaEnteredTimestamp = gpGlobals->time;
const float tolerance = 10.0f;
const float closeToGoal = 25.0f;
switch (m_pathLadderState)
{
case APPROACH_ASCENDING_LADDER:
{
bool approached = false;
Vector2D d(pev->origin.x - m_goalPosition.x, pev->origin.y - m_goalPosition.y);
if (d.x * m_pathLadder->m_dirVector.x + d.y * m_pathLadder->m_dirVector.y < 0.0f)
{
Vector2D perp(-m_pathLadder->m_dirVector.y, m_pathLadder->m_dirVector.x);
#ifdef REGAMEDLL_FIXES
if (Q_abs(d.x * perp.x + d.y * perp.y) < tolerance && d.Length() < closeToGoal)
#else
if (Q_abs(int64(d.x * perp.x + d.y * perp.y)) < tolerance && d.Length() < closeToGoal)
#endif
approached = true;
}
// small radius will just slow them down a little for more accuracy in hitting their spot
const float walkRange = 50.0f;
if (d.IsLengthLessThan(walkRange))
{
Walk();
StandUp();
}
// TODO: Check that we are on the ladder we think we are
if (IsOnLadder())
{
m_pathLadderState = ASCEND_LADDER;
PrintIfWatched("ASCEND_LADDER\n");
// find actual top in case m_pathLadder penetrates the ceiling
ComputeLadderEndpoint(true);
}
else if (approached)
{
// face the m_pathLadder
m_pathLadderState = FACE_ASCENDING_LADDER;
PrintIfWatched("FACE_ASCENDING_LADDER\n");
}
else
{
// move toward ladder mount point
MoveTowardsPosition(&m_goalPosition);
}
break;
}
case APPROACH_DESCENDING_LADDER:
{
// fall check
if (GetFeetZ() <= m_pathLadder->m_bottom.z + HalfHumanHeight)
{
PrintIfWatched("Fell from ladder.\n");
m_pathLadderState = MOVE_TO_DESTINATION;
m_path[m_pathIndex].area->GetClosestPointOnArea(&m_pathLadder->m_bottom, &m_goalPosition);
AddDirectionVector(&m_goalPosition, m_pathLadder->m_dir, HalfHumanWidth);
PrintIfWatched("MOVE_TO_DESTINATION\n");
}
else
{
bool approached = false;
Vector2D d(pev->origin.x - m_goalPosition.x, pev->origin.y - m_goalPosition.y);
if (d.x * m_pathLadder->m_dirVector.x + d.y * m_pathLadder->m_dirVector.y > 0.0f)
{
Vector2D perp(-m_pathLadder->m_dirVector.y, m_pathLadder->m_dirVector.x);
if (Q_abs(int64(d.x * perp.x + d.y * perp.y)) < tolerance && d.Length() < closeToGoal)
approached = true;
}
// if approaching ladder from the side or "ahead", walk
if (m_pathLadder->m_topBehindArea != m_lastKnownArea)
{
const float walkRange = 150.0f;
if (!IsCrouching() && d.IsLengthLessThan(walkRange))
Walk();
}
// TODO: Check that we are on the ladder we think we are
if (IsOnLadder())
{
// we slipped onto the ladder - climb it
m_pathLadderState = DESCEND_LADDER;
Run();
PrintIfWatched("DESCEND_LADDER\n");
// find actual bottom in case m_pathLadder penetrates the floor
ComputeLadderEndpoint(false);
}
else if (approached)
{
// face the ladder
m_pathLadderState = FACE_DESCENDING_LADDER;
PrintIfWatched("FACE_DESCENDING_LADDER\n");
}
else
{
// move toward ladder mount point
MoveTowardsPosition(&m_goalPosition);
}
}
break;
}
case FACE_ASCENDING_LADDER:
{
// find yaw to directly aim at ladder
Vector to = m_pathLadder->m_bottom - pev->origin;
Vector idealAngle = UTIL_VecToAngles(to);
const float angleTolerance = 5.0f;
if (AnglesAreEqual(pev->v_angle.y, idealAngle.y, angleTolerance))
{
// move toward ladder until we become "on" it
Run();
ResetStuckMonitor();
m_pathLadderState = MOUNT_ASCENDING_LADDER;
PrintIfWatched("MOUNT_ASCENDING_LADDER\n");
}
break;
}
case FACE_DESCENDING_LADDER:
{
// find yaw to directly aim at ladder
Vector to = m_pathLadder->m_top - pev->origin;
Vector idealAngle = UTIL_VecToAngles(to);
const float angleTolerance = 5.0f;
if (AnglesAreEqual(pev->v_angle.y, idealAngle.y, angleTolerance))
{
// move toward ladder until we become "on" it
m_pathLadderState = MOUNT_DESCENDING_LADDER;
ResetStuckMonitor();
PrintIfWatched("MOUNT_DESCENDING_LADDER\n");
}
break;
}
case MOUNT_ASCENDING_LADDER:
{
if (IsOnLadder())
{
m_pathLadderState = ASCEND_LADDER;
PrintIfWatched("ASCEND_LADDER\n");
// find actual top in case m_pathLadder penetrates the ceiling
ComputeLadderEndpoint(true);
}
MoveForward();
break;
}
case MOUNT_DESCENDING_LADDER:
{
// fall check
if (GetFeetZ() <= m_pathLadder->m_bottom.z + HalfHumanHeight)
{
PrintIfWatched("Fell from ladder.\n");
m_pathLadderState = MOVE_TO_DESTINATION;
m_path[m_pathIndex].area->GetClosestPointOnArea(&m_pathLadder->m_bottom, &m_goalPosition);
AddDirectionVector(&m_goalPosition, m_pathLadder->m_dir, HalfHumanWidth);
PrintIfWatched("MOVE_TO_DESTINATION\n");
}
else
{
if (IsOnLadder())
{
m_pathLadderState = DESCEND_LADDER;
PrintIfWatched("DESCEND_LADDER\n");
// find actual bottom in case m_pathLadder penetrates the floor
ComputeLadderEndpoint(false);
}
// move toward ladder mount point
MoveForward();
}
break;
}
case ASCEND_LADDER:
{
// run, so we can make our dismount jump to the side, if necessary
Run();
// if our destination area requires us to crouch, do it
if (m_path[m_pathIndex].area->GetAttributes() & NAV_CROUCH)
Crouch();
// did we reach the top?
if (GetFeetZ() >= m_pathLadderEnd)
{
// we reached the top - dismount
m_pathLadderState = DISMOUNT_ASCENDING_LADDER;
PrintIfWatched("DISMOUNT_ASCENDING_LADDER\n");
if (m_path[m_pathIndex].area == m_pathLadder->m_topForwardArea)
m_pathLadderDismountDir = FORWARD;
else if (m_path[m_pathIndex].area == m_pathLadder->m_topLeftArea)
m_pathLadderDismountDir = LEFT;
else if (m_path[m_pathIndex].area == m_pathLadder->m_topRightArea)
m_pathLadderDismountDir = RIGHT;
m_pathLadderDismountTimestamp = gpGlobals->time;
}
else if (!IsOnLadder())
{
// we fall off the ladder, repath
DestroyPath();
return false;
}
// move up ladder
MoveForward();
break;
}
case DESCEND_LADDER:
{
Run();
float destHeight = m_pathLadderEnd + HalfHumanHeight;
if (!IsOnLadder() || GetFeetZ() <= destHeight)
{
// we reached the bottom, or we fell off - dismount
m_pathLadderState = MOVE_TO_DESTINATION;
m_path[m_pathIndex].area->GetClosestPointOnArea(&m_pathLadder->m_bottom, &m_goalPosition);
AddDirectionVector(&m_goalPosition, m_pathLadder->m_dir, HalfHumanWidth);
PrintIfWatched("MOVE_TO_DESTINATION\n");
}
// Move down ladder
MoveForward();
break;
}
case DISMOUNT_ASCENDING_LADDER:
{
if (gpGlobals->time - m_pathLadderDismountTimestamp >= 0.4f)
{
m_pathLadderState = MOVE_TO_DESTINATION;
m_path[m_pathIndex].area->GetClosestPointOnArea(&pev->origin, &m_goalPosition);
PrintIfWatched("MOVE_TO_DESTINATION\n");
}
// We should already be facing the dismount point
if (m_pathLadderFaceIn)
{
switch (m_pathLadderDismountDir)
{
case LEFT: StrafeLeft(); break;
case RIGHT: StrafeRight(); break;
case FORWARD: MoveForward(); break;
}
}
else
{
switch (m_pathLadderDismountDir)
{
case LEFT: StrafeRight(); break;
case RIGHT: StrafeLeft(); break;
case FORWARD: MoveBackward(); break;
}
}
break;
}
case MOVE_TO_DESTINATION:
{
if (m_path[m_pathIndex].area->Contains(&pev->origin))
{
// successfully traversed ladder and reached destination area
// exit ladder state machine
PrintIfWatched("Ladder traversed.\n");
m_pathLadder = nullptr;
// incrememnt path index to next step beyond this ladder
SetPathIndex(m_pathIndex + 1);
return false;
}
MoveTowardsPosition(&m_goalPosition);
break;
}
}
return true;
}
// Move along the path. Return false if end of path reached.
CCSBot::PathResult CCSBot::UpdatePathMovement(bool allowSpeedChange)
{
if (m_pathLength == 0)
return PATH_FAILURE;
if (cv_bot_walk.value != 0.0f)
Walk();
// If we are navigating a ladder, it overrides all other path movement until complete
if (UpdateLadderMovement())
return PROGRESSING;
// ladder failure can destroy the path
if (m_pathLength == 0)
return PATH_FAILURE;
// we are not supposed to be on a ladder - if we are, jump off
if (IsOnLadder())
Jump(MUST_JUMP);
assert(m_pathIndex < m_pathLength);
// Check if reached the end of the path
bool nearEndOfPath = false;
if (m_pathIndex >= m_pathLength - 1)
{
Vector toEnd(pev->origin.x, pev->origin.y, GetFeetZ());
Vector d = GetPathEndpoint() - toEnd; // can't use 2D because path end may be below us (jump down)
const float walkRange = 200.0f;
// walk as we get close to the goal position to ensure we hit it
if (d.IsLengthLessThan(walkRange))
{
// don't walk if crouching - too slow
if (allowSpeedChange && !IsCrouching())
Walk();
// note if we are near the end of the path
const float nearEndRange = 50.0f;
if (d.IsLengthLessThan(nearEndRange))
nearEndOfPath = true;
const float closeEpsilon = 20.0f;
if (d.IsLengthLessThan(closeEpsilon))
{
// reached goal position - path complete
DestroyPath();
// TODO: We should push and pop walk state here, in case we want to continue walking after reaching goal
if (allowSpeedChange)
Run();
return END_OF_PATH;
}
}
}
// To keep us moving smoothly, we will move towards
// a point farther ahead of us down our path.
int prevIndex = 0; // closest index on path just prior to where we are now
const float aheadRange = 300.0f;
int newIndex = FindPathPoint(aheadRange, &m_goalPosition, &prevIndex);
// BOTPORT: Why is prevIndex sometimes -1?
if (prevIndex < 0)
prevIndex = 0;
// if goal position is near to us, we must be about to go around a corner - so look ahead!
const float nearCornerRange = 100.0f;
if (m_pathIndex < m_pathLength - 1 && (m_goalPosition - pev->origin).IsLengthLessThan(nearCornerRange))
{
ClearLookAt();
InhibitLookAround(0.5f);
}
// if we moved to a new node on the path, setup movement
if (newIndex > m_pathIndex)
{
SetPathIndex(newIndex);
}
if (!IsUsingLadder())
{
// Crouching
// if we are approaching a crouch area, crouch
// if there are no crouch areas coming up, stand
const float crouchRange = 50.0f;
bool didCrouch = false;
for (int i = prevIndex; i < m_pathLength; i++)
{
const CNavArea *to = m_path[i].area;
// if there is a jump area on the way to the crouch area, don't crouch as it messes up the jump
// unless we are already higher than the jump area - we must've jumped already but not moved into next area
if ((to->GetAttributes() & NAV_JUMP)/* && to->GetCenter()->z > GetFeetZ()*/)
break;
Vector close;
to->GetClosestPointOnArea(&pev->origin, &close);
if ((close - pev->origin).Make2D().IsLengthGreaterThan(crouchRange))
break;
if (to->GetAttributes() & NAV_CROUCH)
{
Crouch();
didCrouch = true;
break;
}
}
if (!didCrouch && !IsJumping())
{
// no crouch areas coming up
StandUp();
}
// end crouching logic
}
// compute our forward facing angle
m_forwardAngle = UTIL_VecToYaw(m_goalPosition - pev->origin);
// Look farther down the path to "lead" our view around corners
Vector toGoal;
if (m_pathIndex == 0)
{
toGoal = m_path[1].pos;
}
else if (m_pathIndex < m_pathLength)
{
toGoal = m_path[m_pathIndex].pos - pev->origin;
// actually aim our view farther down the path
const float lookAheadRange = 500.0f;
if (!m_path[m_pathIndex].ladder && !IsNearJump() && toGoal.Make2D().IsLengthLessThan(lookAheadRange))
{
float along = toGoal.Length2D();
int i;
for (i = m_pathIndex + 1; i < m_pathLength; i++)
{
Vector delta = m_path[i].pos - m_path[i - 1].pos;
float segmentLength = delta.Length2D();
if (along + segmentLength >= lookAheadRange)
{
// interpolate between points to keep look ahead point at fixed distance
float t = (lookAheadRange - along) / (segmentLength + along);
Vector target;
if (t <= 0.0f)
target = m_path[i - 1].pos;
else if (t >= 1.0f)
target = m_path[i].pos;
else
target = m_path[i - 1].pos + t * delta;
toGoal = target - pev->origin;
break;
}
// if we are coming up to a ladder or a jump, look at it
if (m_path[i].ladder || (m_path[i].area->GetAttributes() & NAV_JUMP))
{
toGoal = m_path[i].pos - pev->origin;
break;
}
along += segmentLength;
}
if (i == m_pathLength)
{
toGoal = GetPathEndpoint() - pev->origin;
}
}
}
else
{
toGoal = GetPathEndpoint() - pev->origin;
}
m_lookAheadAngle = UTIL_VecToYaw(toGoal);
// initialize "adjusted" goal to current goal
Vector adjustedGoal = m_goalPosition;
// Use short "feelers" to veer away from close-range obstacles
// Feelers come from our ankles, just above StepHeight, so we avoid short walls, too
// Don't use feelers if very near the end of the path, or about to jump
// TODO: Consider having feelers at several heights to deal with overhangs, etc.
if (!nearEndOfPath && !IsNearJump() && !IsJumping())
{
FeelerReflexAdjustment(&adjustedGoal);
}
// draw debug visualization
if ((cv_bot_traceview.value == 1.0f && IsLocalPlayerWatchingMe()) || cv_bot_traceview.value == 10.0f)
{
DrawPath();
const Vector *pos = &m_path[m_pathIndex].pos;
UTIL_DrawBeamPoints(*pos, *pos + Vector(0, 0, 50), 1, 255, 255, 0);
UTIL_DrawBeamPoints(adjustedGoal, adjustedGoal + Vector(0, 0, 50), 1, 255, 0, 255);
UTIL_DrawBeamPoints(pev->origin, adjustedGoal + Vector(0, 0, 50), 1, 255, 0, 255);
}
// dont use adjustedGoal, as it can vary wildly from the feeler adjustment
if (!IsAttacking() && IsFriendInTheWay(&m_goalPosition))
{
if (!m_isWaitingBehindFriend)
{
m_isWaitingBehindFriend = true;
const float politeDuration = 5.0f - 3.0f * GetProfile()->GetAggression();
m_politeTimer.Start(politeDuration);
}
else if (m_politeTimer.IsElapsed())
{
// we have run out of patience
m_isWaitingBehindFriend = false;
ResetStuckMonitor();
// repath to avoid clump of friends in the way
DestroyPath();
}
}
else if (m_isWaitingBehindFriend)
{
// we're done waiting for our friend to move
m_isWaitingBehindFriend = false;
ResetStuckMonitor();
}
// Move along our path if there are no friends blocking our way,
// or we have run out of patience
if (!m_isWaitingBehindFriend || m_politeTimer.IsElapsed())
{
// Move along path
MoveTowardsPosition(&adjustedGoal);
// Stuck check
if (m_isStuck && !IsJumping())
{
Wiggle();
}
}
// if our goal is high above us, we must have fallen
bool didFall = false;
if (m_goalPosition.z - GetFeetZ() > JumpCrouchHeight)
{
const float closeRange = 75.0f;
Vector2D to(pev->origin.x - m_goalPosition.x, pev->origin.y - m_goalPosition.y);
if (to.IsLengthLessThan(closeRange))
{
// we can't reach the goal position
// check if we can reach the next node, in case this was a "jump down" situation
if (m_pathIndex < m_pathLength - 1)
{
if (m_path[m_pathIndex + 1].pos.z - GetFeetZ() > JumpCrouchHeight)
{
// the next node is too high, too - we really did fall of the path
didFall = true;
}
}
else
{
// fell trying to get to the last node in the path
didFall = true;
}
}
}
// This timeout check is needed if the bot somehow slips way off
// of its path and cannot progress, but also moves around
// enough that it never becomes "stuck"
const float giveUpDuration = 5.0f; // 4.0f
if (didFall || gpGlobals->time - m_areaEnteredTimestamp > giveUpDuration)
{
if (didFall)
{
PrintIfWatched("I fell off!\n");
}
// if we havent made any progress in a long time, give up
if (m_pathIndex < m_pathLength - 1)
{
PrintIfWatched("Giving up trying to get to area #%d\n", m_path[m_pathIndex].area->GetID());
}
else
{
PrintIfWatched("Giving up trying to get to end of path\n");
}
Run();
StandUp();
DestroyPath();
return PATH_FAILURE;
}
return PROGRESSING;
}
void CHostage::DoFollow(void)
{
if (m_hTargetEnt == NULL)
return;
CBaseEntity *pFollowing;
Vector vecDest;
float flRadius;
int nindexPath;
pFollowing = GetClassPtr((CBaseEntity *)m_hTargetEnt->pev);
m_LocalNav->SetTargetEnt(pFollowing);
vecDest = pFollowing->pev->origin;
vecDest.z += pFollowing->pev->mins.z;
flRadius = (vecDest - pev->origin).Length();
if (flRadius < 80)
{
if (m_fHasPath)
return;
if (m_LocalNav->PathTraversable(pev->origin, vecDest, TRUE) != TRAVERSABLE_NO)
return;
}
if (FBitSet(pev->flags, FL_ONGROUND))
{
if (gpGlobals->time > m_flLastPathCheck + m_flPathCheckInterval)
{
if (!m_fHasPath || pFollowing->pev->velocity.Length2D() > 1)
{
m_flLastPathCheck = gpGlobals->time;
m_LocalNav->RequestNav(this);
}
}
}
if (m_fHasPath)
{
nTargetNode = nindexPath = m_LocalNav->GetFurthestTraversableNode(pev->origin, vecNodes, m_nPathNodes, TRUE);
if (!nindexPath)
{
if ((vecNodes[nTargetNode] - pev->origin).Length2D() < HOSTAGE_STEPSIZE)
nTargetNode = -1;
}
if (nTargetNode == -1)
{
m_fHasPath = FALSE;
m_flPathCheckInterval = 0.1;
}
}
if (gpGlobals->time < m_flFlinchTime)
return;
if (nTargetNode != -1)
{
if (FBitSet(pev->flags, FL_ONGROUND))
PointAt(vecNodes[nTargetNode]);
if (IsOnLadder())
pev->v_angle.x = -60;
MoveToward(vecNodes[nTargetNode]);
m_bStuck = FALSE;
}
if (pev->takedamage == DAMAGE_YES)
{
if (m_improv)
{
}
if (m_hTargetEnt != NULL && m_State == FOLLOW)
{
if (!m_bStuck)
{
if (flRadius > 200)
{
m_bStuck = TRUE;
m_flStuckTime = gpGlobals->time;
}
}
}
}
if (FBitSet(pev->flags, FL_ONGROUND))
{
if (m_flPathAcquired != -1 && m_flPathAcquired + 2 > gpGlobals->time)
{
if (pev->velocity.Length2D() < 1 || nTargetNode == -1)
Wiggle();
}
}
}