void CAI_Enemies::RefreshMemories(void)
{
AI_PROFILE_SCOPE(CAI_Enemies_RefreshMemories);
// -------------------
// Check each record
// -------------------
CMemMap::IndexType_t i = m_Map.FirstInorder();
while ( i != m_Map.InvalidIndex() )
{
AI_EnemyInfo_t *pMemory = m_Map[i];
CBaseEntity *pEnemy = pMemory->hEnemy;
CMemMap::IndexType_t iNext = m_Map.NextInorder( i ); // save so can remove
if ( !pEnemy ||
( pEnemy->MyNPCPointer() != NULL && pEnemy->MyNPCPointer()->GetState() == NPC_STATE_DEAD ) ||
gpGlobals->curtime > pMemory->flLastTimeSeen + ENEMY_DISCARD_TIME )
{
delete pMemory;
m_Map.RemoveAt(i);
}
else
{
if ( gpGlobals->curtime <= pMemory->flLastTimeSeen + m_flFreeKnowledgeDuration )
pMemory->vLastKnownLocation = pMemory->hEnemy->GetAbsOrigin();
}
i = iNext;
}
}
bool CAI_TacticalServices::FindCoverPos( const Vector &vNearPos, const Vector &vThreatPos, const Vector &vThreatEyePos, float flMinDist, float flMaxDist, Vector *pResult )
{
AI_PROFILE_SCOPE( CAI_TacticalServices_FindCoverPos );
MARK_TASK_EXPENSIVE();
int node = FindCoverNode( vNearPos, vThreatPos, vThreatEyePos, flMinDist, flMaxDist );
if (node == NO_NODE)
return false;
*pResult = GetNodePos( node );
return true;
}
void CAI_Senses::PerformSensing( void )
{
AI_PROFILE_SCOPE (CAI_BaseNPC_PerformSensing);
// -----------------
// Look
// -----------------
if( !HasSensingFlags(SENSING_FLAGS_DONT_LOOK) )
Look( m_LookDist );
// ------------------
// Listen
// ------------------
if( !HasSensingFlags(SENSING_FLAGS_DONT_LISTEN) )
Listen();
}
bool CAI_TacticalServices::FindLos(const Vector &threatPos, const Vector &threatEyePos, float minThreatDist, float maxThreatDist, float blockTime, FlankType_t eFlankType, const Vector &vecFlankRefPos, float flFlankParam, Vector *pResult)
{
AI_PROFILE_SCOPE( CAI_TacticalServices_FindLos );
MARK_TASK_EXPENSIVE();
int node = FindLosNode( threatPos, threatEyePos,
minThreatDist, maxThreatDist,
blockTime, eFlankType, vecFlankRefPos, flFlankParam );
if (node == NO_NODE)
return false;
*pResult = GetNodePos( node );
return true;
}
bool CAI_PlaneSolver::MoveLimit( Navigation_t navType, const Vector &target, bool ignoreTransients, bool fCheckStep, int contents, AIMoveTrace_t *pMoveTrace )
{
AI_PROFILE_SCOPE( CAI_PlaneSolver_MoveLimit );
int flags = ( navType == NAV_GROUND ) ? AIMLF_2D : AIMLF_DEFAULT;
if ( ignoreTransients )
{
Assert( !ProbeForNpcs() );
flags |= AIMLF_IGNORE_TRANSIENTS;
}
CAI_MoveProbe *pProbe = m_pNpc->GetMoveProbe();
return pProbe->MoveLimit( navType, GetLocalOrigin(), target, contents,
m_pNpc->GetNavTargetEntity(), (fCheckStep) ? 100 : 0,
flags,
pMoveTrace );
}
void CAI_Enemies::RefreshMemories(void)
{
AI_PROFILE_SCOPE(CAI_Enemies_RefreshMemories);
if ( m_flFreeKnowledgeDuration >= m_flEnemyDiscardTime )
{
m_flFreeKnowledgeDuration = m_flEnemyDiscardTime - .1;
}
// -------------------
// Check each record
// -------------------
CMemMap::IndexType_t i = m_Map.FirstInorder();
while ( i != m_Map.InvalidIndex() )
{
AI_EnemyInfo_t *pMemory = m_Map[i];
CMemMap::IndexType_t iNext = m_Map.NextInorder( i ); // save so can remove
if ( ShouldDiscardMemory( pMemory ) )
{
delete pMemory;
m_Map.RemoveAt(i);
}
else if ( pMemory->hEnemy )
{
if ( gpGlobals->curtime <= pMemory->timeLastSeen + m_flFreeKnowledgeDuration )
{
// Free knowledge is ignored if the target has notarget on
if ( !(pMemory->hEnemy->GetFlags() & FL_NOTARGET) )
{
pMemory->vLastKnownLocation = pMemory->hEnemy->GetAbsOrigin();
}
}
if ( gpGlobals->curtime <= pMemory->timeLastSeen )
{
pMemory->vLastSeenLocation = pMemory->hEnemy->GetAbsOrigin();
}
}
i = iNext;
}
}
bool CAI_LocalNavigator::MoveCalcSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult )
{
if ( (pMoveGoal->flags & AILMG_NO_STEER) )
return false;
if ( ai_no_steer.GetBool() )
return false;
if ( GetOuter()->IsFlaggedEfficient() )
return false;
AI_PROFILE_SCOPE(CAI_Motor_MoveCalcSteer);
Vector moveSolution;
if ( m_pPlaneSolver->Solve( *pMoveGoal, distClear, &moveSolution ) )
{
if ( moveSolution != pMoveGoal->dir )
{
float dot = moveSolution.AsVector2D().Dot( pMoveGoal->dir.AsVector2D() );
const float COS_HALF_30 = 0.966;
if ( dot > COS_HALF_30 )
{
float probeDist = m_pPlaneSolver->CalcProbeDist( pMoveGoal->speed );
if ( pMoveGoal->maxDist < probeDist * 0.33333 && distClear > probeDist * 0.6666)
{
// A waypoint is coming up, but there's probably time to steer
// away after hitting it
*pResult = AIMR_OK;
return true;
}
}
pMoveGoal->facing = pMoveGoal->dir = moveSolution;
}
*pResult = AIMR_OK;
return true;
}
return false;
}
AIMoveResult_t CAI_Motor::MoveNormalExecute( const AILocalMoveGoal_t &move )
{
AI_PROFILE_SCOPE(CAI_Motor_MoveNormalExecute);
// --------------------------------
AIMotorMoveResult_t fMotorResult;
AIMoveTrace_t moveTrace;
if ( move.navType == NAV_GROUND )
{
fMotorResult = MoveGroundExecute( move, &moveTrace );
}
else
{
Assert( move.navType == NAV_FLY );
fMotorResult = MoveFlyExecute( move, &moveTrace );
}
static AIMoveResult_t moveResults[] =
{
AIMR_ILLEGAL, // AIM_FAILED
AIMR_OK, // AIM_SUCCESS
AIMR_BLOCKED_NPC, // AIM_PARTIAL_HIT_NPC
AIMR_BLOCKED_WORLD, // AIM_PARTIAL_HIT_WORLD
AIMR_BLOCKED_WORLD, // AIM_PARTIAL_HIT_TARGET
};
Assert( ARRAYSIZE( moveResults ) == AIM_NUM_RESULTS && fMotorResult >= 0 && fMotorResult <= ARRAYSIZE( moveResults ) );
AIMoveResult_t result = moveResults[fMotorResult];
if ( result != AIMR_OK )
{
OnMoveExecuteFailed( move, moveTrace, fMotorResult, &result );
SetMoveInterval( 0 ); // always consume interval on failure, even if overridden by OnMoveExecuteFailed()
}
return DbgResult( result );
}
bool CAI_TacticalServices::FindLateralLos( const Vector &vecThreat, Vector *pResult )
{
AI_PROFILE_SCOPE( CAI_TacticalServices_FindLateralLos );
if( !m_bAllowFindLateralLos )
{
return false;
}
MARK_TASK_EXPENSIVE();
Vector vecLeftTest;
Vector vecRightTest;
Vector vecStepRight;
Vector vecCheckStart;
bool bLookingForEnemy = GetEnemy() && VectorsAreEqual(vecThreat, GetEnemy()->EyePosition(), 0.1f);
int i;
if( !bLookingForEnemy || GetOuter()->HasCondition(COND_SEE_ENEMY) || GetOuter()->HasCondition(COND_HAVE_ENEMY_LOS) ||
GetOuter()->GetTimeScheduleStarted() == gpGlobals->curtime ) // Conditions get nuked before tasks run, assume should try
{
// My current position might already be valid.
if ( TestLateralLos(vecThreat, GetLocalOrigin()) )
{
*pResult = GetLocalOrigin();
return true;
}
}
if( !ai_find_lateral_los.GetBool() )
{
// Allows us to turn off lateral LOS at the console. Allow the above code to run
// just in case the NPC has line of sight to begin with.
return false;
}
int iChecks = COVER_CHECKS;
int iDelta = COVER_DELTA;
// If we're limited in how far we're allowed to move laterally, don't bother checking past it
int iMaxLateralDelta = GetOuter()->GetMaxTacticalLateralMovement();
if ( iMaxLateralDelta != MAXTACLAT_IGNORE && iMaxLateralDelta < iDelta )
{
iChecks = 1;
iDelta = iMaxLateralDelta;
}
Vector right;
AngleVectors( GetLocalAngles(), NULL, &right, NULL );
vecStepRight = right * iDelta;
vecStepRight.z = 0;
vecLeftTest = vecRightTest = GetLocalOrigin();
vecCheckStart = vecThreat;
for ( i = 0 ; i < iChecks; i++ )
{
vecLeftTest = vecLeftTest - vecStepRight;
vecRightTest = vecRightTest + vecStepRight;
if (TestLateralLos( vecCheckStart, vecLeftTest ))
{
*pResult = vecLeftTest;
return true;
}
if (TestLateralLos( vecCheckStart, vecRightTest ))
{
*pResult = vecRightTest;
return true;
}
}
return false;
}
int CAI_TacticalServices::FindLosNode(const Vector &vThreatPos, const Vector &vThreatEyePos, float flMinThreatDist, float flMaxThreatDist, float flBlockTime, FlankType_t eFlankType, const Vector &vecFlankRefPos, float flFlankParam )
{
if ( !CAI_NetworkManager::NetworksLoaded() )
return NO_NODE;
AI_PROFILE_SCOPE( CAI_TacticalServices_FindLosNode );
MARK_TASK_EXPENSIVE();
int iMyNode = GetPathfinder()->NearestNodeToNPC();
if ( iMyNode == NO_NODE )
{
Vector pos = GetOuter()->GetAbsOrigin();
DevWarning( 2, "FindCover() - %s has no nearest node! (Check near %f %f %f)\n", GetEntClassname(), pos.x, pos.y, pos.z);
return NO_NODE;
}
// ------------------------------------------------------------------------------------
// We're going to search for a shoot node by expanding to our current node's neighbors
// and then their neighbors, until a shooting position is found, or all nodes are beyond MaxDist
// ------------------------------------------------------------------------------------
AI_NearNode_t *pBuffer = (AI_NearNode_t *)stackalloc( sizeof(AI_NearNode_t) * GetNetwork()->NumNodes() );
CNodeList list( pBuffer, GetNetwork()->NumNodes() );
CVarBitVec wasVisited(GetNetwork()->NumNodes()); // Nodes visited
// mark start as visited
wasVisited.Set( iMyNode );
list.Insert( AI_NearNode_t(iMyNode, 0) );
static int nSearchRandomizer = 0; // tries to ensure the links are searched in a different order each time;
while ( list.Count() )
{
int nodeIndex = list.ElementAtHead().nodeIndex;
// remove this item from the list
list.RemoveAtHead();
const Vector &nodeOrigin = GetNetwork()->GetNode(nodeIndex)->GetPosition(GetHullType());
// HACKHACK: Can't we rework this loop and get rid of this?
// skip the starting node, or we probably wouldn't have called this function.
if ( nodeIndex != iMyNode )
{
bool skip = false;
// See if the node satisfies the flanking criteria.
switch ( eFlankType )
{
case FLANKTYPE_NONE:
break;
case FLANKTYPE_RADIUS:
{
Vector vecDist = nodeOrigin - vecFlankRefPos;
if ( vecDist.Length() < flFlankParam )
{
skip = true;
}
break;
}
case FLANKTYPE_ARC:
{
Vector vecEnemyToRef = vecFlankRefPos - vThreatPos;
VectorNormalize( vecEnemyToRef );
Vector vecEnemyToNode = nodeOrigin - vThreatPos;
VectorNormalize( vecEnemyToNode );
float flDot = DotProduct( vecEnemyToRef, vecEnemyToNode );
if ( RAD2DEG( acos( flDot ) ) < flFlankParam )
{
skip = true;
}
break;
}
}
// Don't accept climb nodes, and assume my nearest node isn't valid because
// we decided to make this check in the first place. Keep moving
if ( !skip && !GetNetwork()->GetNode(nodeIndex)->IsLocked() &&
GetNetwork()->GetNode(nodeIndex)->GetType() != NODE_CLIMB )
{
// Now check its distance and only accept if in range
float flThreatDist = ( nodeOrigin - vThreatPos ).Length();
if ( flThreatDist < flMaxThreatDist &&
flThreatDist > flMinThreatDist )
{
CAI_Node *pNode = GetNetwork()->GetNode(nodeIndex);
if ( GetOuter()->IsValidShootPosition( nodeOrigin, pNode, pNode->GetHint() ) )
{
if (GetOuter()->TestShootPosition(nodeOrigin,vThreatEyePos))
{
// Note when this node was used, so we don't try
// to use it again right away.
GetNetwork()->GetNode(nodeIndex)->Lock( flBlockTime );
#if 0
if ( GetOuter()->GetHintNode() )
{
GetOuter()->GetHintNode()->Unlock(GetOuter()->GetHintDelay(GetOuter()->GetHintNode()->HintType()));
GetOuter()->SetHintNode( NULL );
}
// This used to not be set, why? (kenb)
// @Note (toml 05-19-04): I think because stomping the hint can lead to
// unintended side effects. The hint node is primarily a high level
// tool, and certain NPCs break if it gets slammed here. If we need
// this, we should propagate it out and let the schedule selector
// or task decide to set the hint node
GetOuter()->SetHintNode( GetNetwork()->GetNode(nodeIndex)->GetHint() );
#endif
if ( ShouldDebugLos( nodeIndex ) )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:los!", nodeIndex), false, 1 );
}
// The next NPC who searches should use a slight different pattern
nSearchRandomizer = nodeIndex;
return nodeIndex;
}
else
{
if ( ShouldDebugLos( nodeIndex ) )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:!shoot", nodeIndex), false, 1 );
}
}
}
else
{
if ( ShouldDebugLos( nodeIndex ) )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:!valid", nodeIndex), false, 1 );
}
}
}
else
{
if ( ShouldDebugLos( nodeIndex ) )
{
CFmtStr msg( "%d:%s", nodeIndex, ( flThreatDist < flMaxThreatDist ) ? "too close" : "too far" );
NDebugOverlay::Text( nodeOrigin, msg, false, 1 );
}
}
}
}
// Go through each link and add connected nodes to the list
for (int link=0; link < GetNetwork()->GetNode(nodeIndex)->NumLinks();link++)
{
int index = (link + nSearchRandomizer) % GetNetwork()->GetNode(nodeIndex)->NumLinks();
CAI_Link *nodeLink = GetNetwork()->GetNode(nodeIndex)->GetLinkByIndex(index);
if ( !m_pPathfinder->IsLinkUsable( nodeLink, iMyNode ) )
continue;
int newID = nodeLink->DestNodeID(nodeIndex);
// If not already visited, add to the list
if (!wasVisited.IsBitSet(newID))
{
float dist = (GetLocalOrigin() - GetNetwork()->GetNode(newID)->GetPosition(GetHullType())).LengthSqr();
list.Insert( AI_NearNode_t(newID, dist) );
wasVisited.Set( newID );
}
}
}
// We failed. No range attack node node was found
return NO_NODE;
}
int CAI_TacticalServices::FindCoverNode(const Vector &vNearPos, const Vector &vThreatPos, const Vector &vThreatEyePos, float flMinDist, float flMaxDist )
{
if ( !CAI_NetworkManager::NetworksLoaded() )
return NO_NODE;
AI_PROFILE_SCOPE( CAI_TacticalServices_FindCoverNode );
MARK_TASK_EXPENSIVE();
DebugFindCover( NO_NODE, GetOuter()->EyePosition(), vThreatEyePos, 0, 255, 255 );
int iMyNode = GetPathfinder()->NearestNodeToPoint( vNearPos );
if ( iMyNode == NO_NODE )
{
Vector pos = GetOuter()->GetAbsOrigin();
DevWarning( 2, "FindCover() - %s has no nearest node! (Check near %f %f %f)\n", GetEntClassname(), pos.x, pos.y, pos.z);
return NO_NODE;
}
if ( !flMaxDist )
{
// user didn't supply a MaxDist, so work up a crazy one.
flMaxDist = 784;
}
if ( flMinDist > 0.5 * flMaxDist)
{
flMinDist = 0.5 * flMaxDist;
}
// ------------------------------------------------------------------------------------
// We're going to search for a cover node by expanding to our current node's neighbors
// and then their neighbors, until cover is found, or all nodes are beyond MaxDist
// ------------------------------------------------------------------------------------
AI_NearNode_t *pBuffer = (AI_NearNode_t *)stackalloc( sizeof(AI_NearNode_t) * GetNetwork()->NumNodes() );
CNodeList list( pBuffer, GetNetwork()->NumNodes() );
CVarBitVec wasVisited(GetNetwork()->NumNodes()); // Nodes visited
// mark start as visited
list.Insert( AI_NearNode_t(iMyNode, 0) );
wasVisited.Set( iMyNode );
float flMinDistSqr = flMinDist*flMinDist;
float flMaxDistSqr = flMaxDist*flMaxDist;
static int nSearchRandomizer = 0; // tries to ensure the links are searched in a different order each time;
// Search until the list is empty
while( list.Count() )
{
// Get the node that is closest in the number of steps and remove from the list
int nodeIndex = list.ElementAtHead().nodeIndex;
list.RemoveAtHead();
CAI_Node *pNode = GetNetwork()->GetNode(nodeIndex);
Vector nodeOrigin = pNode->GetPosition(GetHullType());
float dist = (vNearPos - nodeOrigin).LengthSqr();
if (dist >= flMinDistSqr && dist < flMaxDistSqr)
{
Activity nCoverActivity = GetOuter()->GetCoverActivity( pNode->GetHint() );
Vector vEyePos = nodeOrigin + GetOuter()->EyeOffset(nCoverActivity);
if ( GetOuter()->IsValidCover( nodeOrigin, pNode->GetHint() ) )
{
// Check if this location will block the threat's line of sight to me
if (GetOuter()->IsCoverPosition(vThreatEyePos, vEyePos))
{
// --------------------------------------------------------
// Don't let anyone else use this node for a while
// --------------------------------------------------------
pNode->Lock( 1.0 );
if ( pNode->GetHint() && ( pNode->GetHint()->HintType() == HINT_TACTICAL_COVER_MED || pNode->GetHint()->HintType() == HINT_TACTICAL_COVER_LOW ) )
{
if ( GetOuter()->GetHintNode() )
{
GetOuter()->GetHintNode()->Unlock(GetOuter()->GetHintDelay(GetOuter()->GetHintNode()->HintType()));
GetOuter()->SetHintNode( NULL );
}
GetOuter()->SetHintNode( pNode->GetHint() );
}
// The next NPC who searches should use a slight different pattern
nSearchRandomizer = nodeIndex;
DebugFindCover( pNode->GetId(), vEyePos, vThreatEyePos, 0, 255, 0 );
return nodeIndex;
}
else
{
DebugFindCover( pNode->GetId(), vEyePos, vThreatEyePos, 255, 0, 0 );
}
}
else
{
DebugFindCover( pNode->GetId(), vEyePos, vThreatEyePos, 0, 0, 255 );
}
}
// Add its children to the search list
// Go through each link
// UNDONE: Pass in a cost function to measure each link?
for ( int link = 0; link < GetNetwork()->GetNode(nodeIndex)->NumLinks(); link++ )
{
int index = (link + nSearchRandomizer) % GetNetwork()->GetNode(nodeIndex)->NumLinks();
CAI_Link *nodeLink = GetNetwork()->GetNode(nodeIndex)->GetLinkByIndex(index);
if ( !m_pPathfinder->IsLinkUsable( nodeLink, iMyNode ) )
continue;
int newID = nodeLink->DestNodeID(nodeIndex);
// If not already on the closed list, add to it and set its distance
if (!wasVisited.IsBitSet(newID))
{
// Don't accept climb nodes or nodes that aren't ready to use yet
if ( GetNetwork()->GetNode(newID)->GetType() != NODE_CLIMB && !GetNetwork()->GetNode(newID)->IsLocked() )
{
// UNDONE: Shouldn't we really accumulate the distance by path rather than
// absolute distance. After all, we are performing essentially an A* here.
nodeOrigin = GetNetwork()->GetNode(newID)->GetPosition(GetHullType());
dist = (vNearPos - nodeOrigin).LengthSqr();
// use distance to threat as a heuristic to keep AIs from running toward
// the threat in order to take cover from it.
float threatDist = (vThreatPos - nodeOrigin).LengthSqr();
// Now check this node is not too close towards the threat
if ( dist < threatDist * 1.5 )
{
list.Insert( AI_NearNode_t(newID, dist) );
}
}
// mark visited
wasVisited.Set(newID);
}
}
}
// We failed. Not cover node was found
// Clear hint node used to set ducking
GetOuter()->ClearHintNode();
return NO_NODE;
}
bool CAI_TacticalServices::FindLateralCover( const Vector &vNearPos, const Vector &vecThreat, float flMinDist, float distToCheck, int numChecksPerDir, Vector *pResult )
{
AI_PROFILE_SCOPE( CAI_TacticalServices_FindLateralCover );
MARK_TASK_EXPENSIVE();
Vector vecLeftTest;
Vector vecRightTest;
Vector vecStepRight;
Vector vecCheckStart;
int i;
if ( TestLateralCover( vecThreat, vNearPos, flMinDist ) )
{
*pResult = GetLocalOrigin();
return true;
}
if( !ai_find_lateral_cover.GetBool() )
{
// Force the NPC to use the nodegraph to find cover. NOTE: We let the above code run
// to detect the case where the NPC may already be standing in cover, but we don't
// make any additional lateral checks.
return false;
}
Vector right = vecThreat - vNearPos;
float temp;
right.z = 0;
VectorNormalize( right );
temp = right.x;
right.x = -right.y;
right.y = temp;
vecStepRight = right * (distToCheck / (float)numChecksPerDir);
vecStepRight.z = 0;
vecLeftTest = vecRightTest = vNearPos;
vecCheckStart = vecThreat;
for ( i = 0 ; i < numChecksPerDir ; i++ )
{
vecLeftTest = vecLeftTest - vecStepRight;
vecRightTest = vecRightTest + vecStepRight;
if (TestLateralCover( vecCheckStart, vecLeftTest, flMinDist ))
{
*pResult = vecLeftTest;
return true;
}
if (TestLateralCover( vecCheckStart, vecRightTest, flMinDist ))
{
*pResult = vecRightTest;
return true;
}
}
return false;
}
AIMoveResult_t CAI_LocalNavigator::MoveCalcRaw( AILocalMoveGoal_t *pMoveGoal, bool bOnlyCurThink )
{
AI_PROFILE_SCOPE(CAI_Motor_MoveCalc);
AIMoveResult_t result = AIMR_OK; // Assume success
AIMoveTrace_t directTrace;
float distClear;
// --------------------------------------------------
bool bDirectClear = MoveCalcDirect( pMoveGoal, bOnlyCurThink, &distClear, &result);
if ( OnCalcBaseMove( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
bool bShouldSteer = ( !(pMoveGoal->flags & AILMG_NO_STEER) && ( !bDirectClear || HaveObstacles() ) );
if ( bDirectClear && !bShouldSteer )
{
SetSolveCookie();
return DbgResult( result );
}
// --------------------------------------------------
if ( bShouldSteer )
{
if ( !bDirectClear )
{
if ( OnObstructionPreSteer( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
}
if ( MoveCalcSteer( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
}
if ( OnFailedSteer( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
// --------------------------------------------------
if ( OnFailedLocalNavigation( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
if ( distClear < GetOuter()->GetMotor()->MinStoppingDist() )
{
if ( OnInsufficientStopDist( pMoveGoal, distClear, &result ) )
{
SetSolveCookie();
return DbgResult( result );
}
if ( MoveCalcStop( pMoveGoal, distClear, &result) )
{
SetSolveCookie();
return DbgResult( result );
}
}
// A hopeful result... may get in trouble at next waypoint and obstruction is still there
if ( distClear > pMoveGoal->curExpectedDist )
{
SetSolveCookie();
return DbgResult( AIMR_OK );
}
// --------------------------------------------------
DebugNoteMovementFailure();
SetSolveCookie();
return DbgResult( IsMoveBlocked( pMoveGoal->directTrace.fStatus ) ? pMoveGoal->directTrace.fStatus : AIMR_ILLEGAL );
}
bool CAI_LocalNavigator::MoveCalcDirect( AILocalMoveGoal_t *pMoveGoal, bool bOnlyCurThink, float *pDistClear, AIMoveResult_t *pResult )
{
AI_PROFILE_SCOPE(CAI_LocalNavigator_MoveCalcDirect);
bool bRetVal = false;
if ( pMoveGoal->speed )
{
CAI_Motor *pMotor = GetOuter()->GetMotor();
float minCheckDist = pMotor->MinCheckDist();
float probeDist = m_pPlaneSolver->CalcProbeDist( pMoveGoal->speed ); // having this match steering allows one fewer traces
float checkDist = MAX( minCheckDist, probeDist );
float checkStepDist = MAX( 16.0, probeDist * 0.5 );
if ( pMoveGoal->flags & ( AILMG_TARGET_IS_TRANSITION | AILMG_TARGET_IS_GOAL ) )
{
// clamp checkDist to be no farther than MAX distance to goal
checkDist = MIN( checkDist, pMoveGoal->maxDist );
}
if ( checkDist <= 0.0 )
{
*pResult = AIMR_OK;
return true;
}
float moveThisInterval = pMotor->CalcIntervalMove();
bool bExpectingArrival = (moveThisInterval >= checkDist);
if ( !m_FullDirectTimer.Expired() )
{
if ( !m_fLastWasClear ||
( !VectorsAreEqual(pMoveGoal->target, m_LastMoveGoal.target, 0.1) ||
!VectorsAreEqual(pMoveGoal->dir, m_LastMoveGoal.dir, 0.1) ) ||
bExpectingArrival )
{
m_FullDirectTimer.Force();
}
}
if ( bOnlyCurThink ) // Outer code claims to have done a validation (probably a simplify operation)
{
m_FullDirectTimer.Set( TIME_DELAY_FULL_DIRECT_PROBE[AIStrongOpt()] );
}
// First, check the probable move for this cycle
bool bTraceClear = true;
Vector testPos;
if ( !bExpectingArrival )
{
testPos = GetLocalOrigin() + pMoveGoal->dir * moveThisInterval;
bTraceClear = GetMoveProbe()->MoveLimit( pMoveGoal->navType, GetLocalOrigin(), testPos,
GetOuter()->GetAITraceMask(), pMoveGoal->pMoveTarget,
100.0,
( pMoveGoal->navType == NAV_GROUND ) ? AIMLF_2D : AIMLF_DEFAULT,
&pMoveGoal->directTrace );
if ( !bTraceClear )
{
// Adjust probe top match expected probe dist (relied on later in process)
pMoveGoal->directTrace.flDistObstructed = (checkDist - moveThisInterval) + pMoveGoal->directTrace.flDistObstructed;
}
if ( !IsRetail() && ai_debug_directnavprobe.GetBool() )
{
if ( !bTraceClear )
{
DevMsg( GetOuter(), "Close obstruction %f\n", checkDist - pMoveGoal->directTrace.flDistObstructed );
NDebugOverlay::Line( WorldSpaceCenter(), Vector( testPos.x, testPos.y, WorldSpaceCenter().z ), 255, 0, 0, false, 0.1 );
if ( pMoveGoal->directTrace.pObstruction )
NDebugOverlay::Line( WorldSpaceCenter(), pMoveGoal->directTrace.pObstruction->WorldSpaceCenter(), 255, 0, 255, false, 0.1 );
}
else
{
NDebugOverlay::Line( WorldSpaceCenter(), Vector( testPos.x, testPos.y, WorldSpaceCenter().z ), 0, 255, 0, false, 0.1 );
}
}
pMoveGoal->thinkTrace = pMoveGoal->directTrace;
}
// Now project out for future obstructions
if ( bTraceClear )
{
if ( m_FullDirectTimer.Expired() )
{
testPos = GetLocalOrigin() + pMoveGoal->dir * checkDist;
float checkStepPct = (checkStepDist / checkDist) * 100.0;
if ( checkStepPct > 100.0 )
checkStepPct = 100.0;
bTraceClear = GetMoveProbe()->MoveLimit( pMoveGoal->navType, GetLocalOrigin(), testPos,
GetOuter()->GetAITraceMask(), pMoveGoal->pMoveTarget,
checkStepPct,
( pMoveGoal->navType == NAV_GROUND ) ? AIMLF_2D : AIMLF_DEFAULT,
&pMoveGoal->directTrace );
if ( bExpectingArrival )
pMoveGoal->thinkTrace = pMoveGoal->directTrace;
if (ai_debug_directnavprobe.GetBool() )
{
if ( !bTraceClear )
{
NDebugOverlay::Line( GetOuter()->EyePosition(), Vector( testPos.x, testPos.y, GetOuter()->EyePosition().z ), 255, 0, 0, false, 0.1 );
DevMsg( GetOuter(), "Obstruction %f\n", checkDist - pMoveGoal->directTrace.flDistObstructed );
}
else
{
NDebugOverlay::Line( GetOuter()->EyePosition(), Vector( testPos.x, testPos.y, GetOuter()->EyePosition().z ), 0, 255, 0, false, 0.1 );
DevMsg( GetOuter(), "No obstruction\n" );
}
}
}
else
{
if ( ai_debug_directnavprobe.GetBool() )
DevMsg( GetOuter(), "No obstruction (Near probe only)\n" );
}
}
pMoveGoal->bHasTraced = true;
float distClear = checkDist - pMoveGoal->directTrace.flDistObstructed;
if (distClear < 0.001)
distClear = 0;
if ( bTraceClear )
{
*pResult = AIMR_OK;
bRetVal = true;
m_fLastWasClear = true;
}
else if ( ( pMoveGoal->flags & ( AILMG_TARGET_IS_TRANSITION | AILMG_TARGET_IS_GOAL ) ) &&
pMoveGoal->maxDist < distClear )
{
*pResult = AIMR_OK;
bRetVal = true;
m_fLastWasClear = true;
}
else
{
*pDistClear = distClear;
m_fLastWasClear = false;
}
}
else
{
// Should never end up in this function with speed of zero. Probably an activity problem.
*pResult = AIMR_ILLEGAL;
bRetVal = true;
}
m_LastMoveGoal = *pMoveGoal;
if ( bRetVal && m_FullDirectTimer.Expired() )
m_FullDirectTimer.Set( TIME_DELAY_FULL_DIRECT_PROBE[AIStrongOpt()] );
return bRetVal;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if pTestHint passes the criteria specified in hintCriteria
//-----------------------------------------------------------------------------
bool CAI_Hint::HintMatchesCriteria( CAI_BaseNPC *pNPC, const CHintCriteria &hintCriteria, const Vector &position, float *flNearestDistance, bool bIgnoreLock, bool bIgnoreHintType )
{
// Cannot be locked
if ( !bIgnoreLock && IsLocked() )
{
REPORTFAILURE( "Node is locked." );
return false;
}
if ( !bIgnoreHintType && !hintCriteria.MatchesHintType( HintType() ) )
{
return false;
}
if ( GetMinState() > NPC_STATE_IDLE || GetMaxState() < NPC_STATE_COMBAT )
{
if ( pNPC && ( pNPC->GetState() < GetMinState() || pNPC->GetState() > GetMaxState() ) )
{
REPORTFAILURE( "NPC not in correct state." );
return false;
}
}
// See if we're filtering by group name
if ( hintCriteria.GetGroup() != NULL_STRING )
{
AssertIsValidString( GetGroup() );
AssertIsValidString( hintCriteria.GetGroup() );
if ( GetGroup() == NULL_STRING || GetGroup() != hintCriteria.GetGroup() )
{
Assert(GetGroup() == NULL_STRING || strcmp( STRING(GetGroup()), STRING(hintCriteria.GetGroup())) != 0 );
REPORTFAILURE( "Doesn't match NPC hint group." );
return false;
}
}
// If we're watching for include zones, test it
if ( ( hintCriteria.HasIncludeZones() ) && ( hintCriteria.InIncludedZone( GetAbsOrigin() ) == false ) )
{
REPORTFAILURE( "Not inside include zones." );
return false;
}
// If we're watching for exclude zones, test it
if ( ( hintCriteria.HasExcludeZones() ) && ( hintCriteria.InExcludedZone( GetAbsOrigin() ) ) )
{
REPORTFAILURE( "Inside exclude zones." );
return false;
}
// See if the class handles this hint type
if ( ( pNPC != NULL ) && ( pNPC->FValidateHintType( this ) == false ) )
{
REPORTFAILURE( "NPC doesn't know how to handle that type." );
return false;
}
if ( hintCriteria.HasFlag(bits_HINT_NPC_IN_NODE_FOV) )
{
if ( pNPC == NULL )
{
AssertMsg(0,"Hint node attempted to verify NPC in node FOV without NPC!\n");
}
else
{
if( !IsInNodeFOV(pNPC) )
{
REPORTFAILURE( "NPC Not in hint's FOV" );
return false;
}
}
}
if ( hintCriteria.HasFlag( bits_HINT_NODE_IN_AIMCONE ) )
{
if ( pNPC == NULL )
{
AssertMsg( 0, "Hint node attempted to find node in aimcone without specifying NPC!\n" );
}
else
{
if( !pNPC->FInAimCone( GetAbsOrigin() ) )
{
REPORTFAILURE( "Hint isn't in NPC's aimcone" );
return false;
}
}
}
if ( hintCriteria.HasFlag( bits_HINT_NODE_IN_VIEWCONE ) )
{
if ( pNPC == NULL )
{
AssertMsg( 0, "Hint node attempted to find node in viewcone without specifying NPC!\n" );
}
else
{
if( !pNPC->FInViewCone( this ) )
{
REPORTFAILURE( "Hint isn't in NPC's viewcone" );
return false;
}
}
}
{
AI_PROFILE_SCOPE( HINT_FVisible );
// See if we're requesting a visible node
if ( hintCriteria.HasFlag( bits_HINT_NODE_VISIBLE ) )
{
if ( pNPC == NULL )
{
//NOTENOTE: If you're hitting this, you've asked for a visible node without specifing an NPC!
AssertMsg( 0, "Hint node attempted to find visible node without specifying NPC!\n" );
}
else
{
if( m_NodeData.nNodeID == NO_NODE )
{
// This is just an info_hint, not a node.
if( !pNPC->FVisible( this ) )
{
REPORTFAILURE( "Hint isn't visible to NPC." );
return false;
}
}
else
{
// This hint associated with a node.
trace_t tr;
Vector vHintPos;
GetPosition(pNPC,&vHintPos);
AI_TraceLine ( pNPC->EyePosition(), vHintPos + pNPC->GetViewOffset(), MASK_NPCSOLID_BRUSHONLY, pNPC, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0f )
{
REPORTFAILURE( "Node isn't visible to NPC." );
return false;
}
}
}
}
}
// Check for clear if requested
if ( hintCriteria.HasFlag( bits_HINT_NODE_CLEAR ) )
{
if ( pNPC == NULL )
{
//NOTENOTE: If you're hitting this, you've asked for a clear node without specifing an NPC!
AssertMsg( 0, "Hint node attempted to find clear node without specifying NPC!\n" );
}
else
{
trace_t tr;
// Can my bounding box fit there?
AI_TraceHull ( GetAbsOrigin(), GetAbsOrigin(), pNPC->WorldAlignMins(), pNPC->WorldAlignMaxs(),
MASK_SOLID, pNPC, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
REPORTFAILURE( "Node isn't clear." );
return false;
}
}
}
// See if this is our next, closest node
if ( hintCriteria.HasFlag( bits_HINT_NODE_NEAREST ) )
{
Assert( flNearestDistance );
// Calculate our distance
float distance = (GetAbsOrigin() - position).Length();
// Must be closer than the current best
if ( distance > *flNearestDistance )
{
REPORTFAILURE( "Not the nearest node." );
return false;
}
// Remember the distance
*flNearestDistance = distance;
}
// Must either be visible or not if requested
if ( hintCriteria.HasFlag( bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER|bits_HINT_NODE_VISIBLE_TO_PLAYER ) )
{
bool bWasSeen = false;
// Test all potential seers
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
if ( pPlayer )
{
// Only spawn if the player's looking away from me
Vector vLookDir = pPlayer->EyeDirection3D();
Vector vTargetDir = GetAbsOrigin() - pPlayer->EyePosition();
VectorNormalize(vTargetDir);
float fDotPr = DotProduct(vLookDir,vTargetDir);
if ( fDotPr > 0 )
{
trace_t tr;
UTIL_TraceLine( pPlayer->EyePosition(), GetAbsOrigin(), MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, &tr);
if ( tr.fraction == 1.0 )
{
if ( hintCriteria.HasFlag( bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER ) )
{
REPORTFAILURE( "Node is visible to player." );
return false;
}
bWasSeen = true;
}
}
}
}
if ( !bWasSeen && hintCriteria.HasFlag( bits_HINT_NODE_VISIBLE_TO_PLAYER ) )
{
REPORTFAILURE( "Node isn't visible to player." );
return false;
}
}
return true;
}
