//-----------------------------------------------------------------------------
// Computes the link type
//-----------------------------------------------------------------------------
Navigation_t CAI_Pathfinder::ComputeWaypointType( CAI_Node **ppNodes, int parentID, int destID )
{
Navigation_t navType = NAV_NONE;
CAI_Node *pNode = ppNodes[parentID];
for (int link=0; link < pNode->NumLinks();link++)
{
if (pNode->GetLinkByIndex(link)->DestNodeID(parentID) == destID)
{
// BRJ 10/1/02
// FIXME: pNPC->CapabilitiesGet() is actually the mechanism by which fliers
// filter out the bitfields in the waypoint type (most importantly, bits_MOVE_CAP_GROUND)
// that would cause the waypoint distance to be computed in a 2D, as opposed to 3D fashion
// This is a super-scary weak link if you ask me.
int linkMoveTypeBits = pNode->GetLinkByIndex(link)->m_iAcceptedMoveTypes[GetHullType()];
int moveTypeBits = ( linkMoveTypeBits & CapabilitiesGet());
if ( !moveTypeBits && linkMoveTypeBits == bits_CAP_MOVE_JUMP )
{
Assert( pNode->GetHint() && pNode->GetHint()->HintType() == HINT_JUMP_OVERRIDE );
ppNodes[destID]->Lock(0.3);
moveTypeBits = linkMoveTypeBits;
}
Navigation_t linkType = MoveBitsToNavType( moveTypeBits );
// This will only trigger if the links disagree about their nav type
Assert( (navType == NAV_NONE) || (navType == linkType) );
navType = linkType;
break;
}
}
// @TODO (toml 10-15-02): one would not expect to come out of the above logic
// with NAV_NONE. However, if a graph is newly built, it can contain malformed
// links that are referred to by the destination node, not the source node.
// This has to be fixed
if ( navType == NAV_NONE )
{
pNode = ppNodes[destID];
for (int link=0; link < pNode->NumLinks();link++)
{
if (pNode->GetLinkByIndex(link)->DestNodeID(parentID) == destID)
{
int npcMoveBits = CapabilitiesGet();
int nodeMoveBits = pNode->GetLinkByIndex(link)->m_iAcceptedMoveTypes[GetHullType()];
int moveTypeBits = ( npcMoveBits & nodeMoveBits );
Navigation_t linkType = MoveBitsToNavType( moveTypeBits );
Assert( (navType == NAV_NONE) || (navType == linkType) );
navType = linkType;
DevMsg( "Note: Strange link found between nodes in AI node graph\n" );
break;
}
}
}
AssertMsg( navType != NAV_NONE, "Pathfinder appears to have output a path with consecutive nodes thate are not actually connected\n" );
return navType;
}
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;
}
