Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2024-12-23 01:59:43 +08:00
Code
5c7d90ed0f
hl2sdk/game/server/ai_networkmanager.cpp
Nicholas Hastings e2781a0000 SDK sync.
2014-02-28 14:08:09 -05:00

3249 lines
102 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "fmtstr.h"
#include "filesystem.h"
#include "filesystem/IQueuedLoader.h"
#include "utlbuffer.h"
#include "utlrbtree.h"
#include "editor_sendcommand.h"
#include "ai_networkmanager.h"
#include "ai_network.h"
#include "ai_node.h"
#include "ai_navigator.h"
#include "ai_link.h"
#include "ai_dynamiclink.h"
#include "ai_initutils.h"
#include "ai_moveprobe.h"
#include "ai_hull.h"
#include "ndebugoverlay.h"
#include "ai_hint.h"
#include "tier0/icommandline.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Increment this to force rebuilding of all networks
#define AINET_VERSION_NUMBER 37
//-----------------------------------------------------------------------------
int g_DebugConnectNode1 = -1;
int g_DebugConnectNode2 = -1;
#define DebuggingConnect( node1, node2 ) ( ( node1 == g_DebugConnectNode1 && node2 == g_DebugConnectNode2 ) || ( node1 == g_DebugConnectNode2 && node2 == g_DebugConnectNode1 ) )
inline void DebugConnectMsg( int node1, int node2, const char *pszFormat, ... )
{
if ( DebuggingConnect( node1, node2 ) )
{
char string[ 2048 ];
va_list argptr;
va_start( argptr, pszFormat );
Q_vsnprintf( string, sizeof(string), pszFormat, argptr );
va_end( argptr );
DevMsg( "%s", string );
}
}
CON_COMMAND( ai_debug_node_connect, "Debug the attempted connection between two nodes" )
{
g_DebugConnectNode1 = atoi( args[1] );
g_DebugConnectNode2 = atoi( args[2] );
DevMsg( "ai_debug_node_connect: debugging enbabled for %d <--> %d\n", g_DebugConnectNode1, g_DebugConnectNode2 );
}
//-----------------------------------------------------------------------------
// This CVAR allows level designers to override the building
// of node graphs due to date conflicts with the BSP and AIN
// files. That way they don't have to wait for the node graph
// to rebuild following small only-ents changes. This CVAR
// always defaults to 0 and must be set at the command
// line to properly override the node graph building.
ConVar g_ai_norebuildgraph( "ai_norebuildgraph", "0" );
//-----------------------------------------------------------------------------
// CAI_NetworkManager
//
//-----------------------------------------------------------------------------
CAI_NetworkManager *g_pAINetworkManager;
//-----------------------------------------------------------------------------
bool CAI_NetworkManager::gm_fNetworksLoaded;
LINK_ENTITY_TO_CLASS(ai_network,CAI_NetworkManager);
BEGIN_DATADESC( CAI_NetworkManager )
DEFINE_FIELD( m_bNeedGraphRebuild, FIELD_BOOLEAN ),
// m_pEditOps
// m_pNetwork
// DEFINE_FIELD( m_bDontSaveGraph, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fInitalized, FIELD_BOOLEAN ),
// Function pointers
DEFINE_FUNCTION( DelayedInit ),
DEFINE_FUNCTION( RebuildThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
CAI_NetworkManager::CAI_NetworkManager(void)
{
m_pNetwork = new CAI_Network;
m_pEditOps = new CAI_NetworkEditTools(this);
m_bNeedGraphRebuild = false;
m_fInitalized = false;
CAI_DynamicLink::gm_bInitialized = false;
// ---------------------------------
// Add to linked list of networks
// ---------------------------------
};
//-----------------------------------------------------------------------------
CAI_NetworkManager::~CAI_NetworkManager(void)
{
// ---------------------------------------
// Remove from linked list of AINetworks
// ---------------------------------------
delete m_pEditOps;
delete m_pNetwork;
if ( g_pAINetworkManager == this )
{
g_pAINetworkManager = NULL;
}
}
//------------------------------------------------------------------------------
// Purpose : Think function so we can put message on screen saying we are
// going to rebuild the network, before we hang during the rebuild
//------------------------------------------------------------------------------
void CAI_NetworkManager::RebuildThink( void )
{
SetThink(NULL);
GetEditOps()->m_debugNetOverlays &= ~bits_debugNeedRebuild;
StartRebuild( );
}
//------------------------------------------------------------------------------
// Purpose : Delay function so we can put message on screen saying we are
// going to rebuild the network, before we hang during the rebuild
//------------------------------------------------------------------------------
void CAI_NetworkManager::RebuildNetworkGraph( void )
{
if (m_pfnThink != (void (CBaseEntity::*)())&CAI_NetworkManager::RebuildThink)
{
UTIL_CenterPrintAll( "Doing partial rebuild of Node Graph...\n" );
SetThink(&CAI_NetworkManager::RebuildThink);
SetNextThink( gpGlobals->curtime + 0.1f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Used for WC edit move to rebuild the network around the given
// location. Rebuilding the entire network takes too long
//-----------------------------------------------------------------------------
void CAI_NetworkManager::StartRebuild( void )
{
CAI_DynamicLink::gm_bInitialized = false;
g_AINetworkBuilder.Rebuild( m_pNetwork );
// ------------------------------------------------------------
// Purge any dynamic links for links that don't exist any more
// ------------------------------------------------------------
CAI_DynamicLink::PurgeDynamicLinks();
// ------------------------
// Reset all dynamic links
// ------------------------
CAI_DynamicLink::ResetDynamicLinks();
// --------------------------------------------------
// Update display of usable nodes for displayed hull
// --------------------------------------------------
GetEditOps()->RecalcUsableNodesForHull();
GetEditOps()->ClearRebuildFlags();
}
//-----------------------------------------------------------------------------
// Purpose: Called by save restore code if no valid load graph was loaded at restore time.
// Prevents writing out of a "bogus" node graph...
// Input : -
//-----------------------------------------------------------------------------
void CAI_NetworkManager::MarkDontSaveGraph()
{
m_bDontSaveGraph = true;
}
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkManager::SaveNetworkGraph( void )
{
if ( m_bDontSaveGraph )
return;
if ( !m_bNeedGraphRebuild )
return;
//if ( g_AI_Manager.NumAIs() && m_pNetwork->m_iNumNodes == 0 )
//{
// return;
//}
if ( !g_pGameRules->FAllowNPCs() )
{
return;
}
// -----------------------------
// Make sure directories have been made
// -----------------------------
char szNrpFilename [MAX_PATH];// text node report filename
Q_strncpy( szNrpFilename, "maps/graphs" ,sizeof(szNrpFilename));
// Usually adding on the map filename and stripping it does nothing, but if the map is under a subdir,
// this makes it create the correct subdir under maps/graphs.
char tempFilename[MAX_PATH];
Q_snprintf( tempFilename, sizeof( tempFilename ), "%s/%s", szNrpFilename, STRING( gpGlobals->mapname ) );
// Remove the filename.
int len = strlen( tempFilename );
for ( int i=0; i < len; i++ )
{
if ( tempFilename[len-i-1] == '/' || tempFilename[len-i-1] == '\\' )
{
tempFilename[len-i-1] = 0;
break;
}
}
// Make sure the directories we need exist.
filesystem->CreateDirHierarchy( tempFilename, "DEFAULT_WRITE_PATH" );
// Now add the real map filename.
Q_strncat( szNrpFilename, "/", sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, STRING( gpGlobals->mapname ), sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, IsX360() ? ".360.ain" : ".ain", sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
CUtlBuffer buf;
// ---------------------------
// Save the version number
// ---------------------------
buf.PutInt(AINET_VERSION_NUMBER);
buf.PutInt(gpGlobals->mapversion);
// -------------------------------
// Dump all the nodes to the file
// -------------------------------
buf.PutInt( m_pNetwork->m_iNumNodes);
int node;
int totalNumLinks = 0;
for ( node = 0; node < m_pNetwork->m_iNumNodes; node++)
{
CAI_Node *pNode = m_pNetwork->GetNode(node);
Assert( pNode->GetZone() != AI_NODE_ZONE_UNKNOWN );
buf.PutFloat( pNode->GetOrigin().x );
buf.PutFloat( pNode->GetOrigin().y );
buf.PutFloat( pNode->GetOrigin().z );
buf.PutFloat( pNode->GetYaw() );
buf.Put( pNode->m_flVOffset, sizeof( pNode->m_flVOffset ) );
buf.PutChar( pNode->GetType() );
if ( IsX360() )
{
buf.SeekPut( CUtlBuffer::SEEK_CURRENT, 3 );
}
buf.PutUnsignedShort( pNode->m_eNodeInfo );
buf.PutShort( pNode->GetZone() );
for (int link = 0; link < pNode->NumLinks(); link++)
{
// Only dump if link source
if (node == pNode->GetLinkByIndex(link)->m_iSrcID)
{
totalNumLinks++;
}
}
}
// -------------------------------
// Dump all the links to the file
// -------------------------------
buf.PutInt( totalNumLinks );
for (node = 0; node < m_pNetwork->m_iNumNodes; node++)
{
CAI_Node *pNode = m_pNetwork->GetNode(node);
for (int link = 0; link < pNode->NumLinks(); link++)
{
// Only dump if link source
CAI_Link *pLink = pNode->GetLinkByIndex(link);
if (node == pLink->m_iSrcID)
{
buf.PutShort( pLink->m_iSrcID );
buf.PutShort( pLink->m_iDestID );
buf.Put( pLink->m_iAcceptedMoveTypes, sizeof( pLink->m_iAcceptedMoveTypes) );
}
}
}
// -------------------------------
// Dump WC lookup table
// -------------------------------
CUtlMap<int, int> wcIDs;
SetDefLessFunc(wcIDs);
bool bCheckForProblems = false;
for (node = 0; node < m_pNetwork->m_iNumNodes; node++)
{
int iPreviousNodeBinding = wcIDs.Find( GetEditOps()->m_pNodeIndexTable[node] );
if ( iPreviousNodeBinding != wcIDs.InvalidIndex() )
{
if ( !bCheckForProblems )
{
DevWarning( "******* MAP CONTAINS DUPLICATE HAMMER NODE IDS! CHECK FOR PROBLEMS IN HAMMER TO CORRECT *******\n" );
bCheckForProblems = true;
}
DevWarning( " AI node %d is associated with Hammer node %d, but %d is already bound to node %d\n", node, GetEditOps()->m_pNodeIndexTable[node], GetEditOps()->m_pNodeIndexTable[node], wcIDs[iPreviousNodeBinding] );
}
else
{
wcIDs.Insert( GetEditOps()->m_pNodeIndexTable[node], node );
}
buf.PutInt( GetEditOps()->m_pNodeIndexTable[node] );
}
// -------------------------------
// Write the file out
// -------------------------------
FileHandle_t fh = filesystem->Open( szNrpFilename, "wb" );
if ( !fh )
{
DevWarning( 2, "Couldn't create %s!\n", szNrpFilename );
return;
}
filesystem->Write( buf.Base(), buf.TellPut(), fh );
filesystem->Close(fh);
}
/* Keep this around for debugging
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkManager::SaveNetworkGraph( void )
{
// -----------------------------
// Make sure directories have been made
// -----------------------------
char szNrpFilename [MAX_PATH];// text node report filename
Q_strncpy( szNrpFilename, "maps" ,sizeof(szNrpFilename));
filesystem->CreateDirHierarchy( szNrpFilename );
Q_strncat( szNrpFilename, "/graphs", COPY_ALL_CHARACTERS );
filesystem->CreateDirHierarchy( szNrpFilename );
Q_strncat( szNrpFilename, "/", COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, STRING( gpGlobals->mapname ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, ".ain", COPY_ALL_CHARACTERS );
FileHandle_t file = filesystem->Open ( szNrpFilename, "w+" );
// -----------------------------
// Make sure the file opened ok
// -----------------------------
if ( !file )
{
DevWarning( 2, "Couldn't create %s!\n", szNrpFilename );
return;
}
// ---------------------------
// Save the version number
// ---------------------------
filesystem->FPrintf(file,"Version %4d\n",AINET_VERSION_NUMBER);
// -------------------------------
// Dump all the nodes to the file
// -------------------------------
filesystem->FPrintf ( file, "NumNodes: %d\n", m_iNumNodes);
int totalNumLinks = 0;
for (int node = 0; node < m_iNumNodes; node++)
{
filesystem->FPrintf ( file, "Location %4f,%4f,%4f\n",m_pAInode[node]->GetOrigin().x, m_pAInode[node]->GetOrigin().y, m_pAInode[node]->GetOrigin().z );
for (int hull =0;hull<NUM_HULLS;hull++)
{
filesystem->FPrintf ( file, "Voffset %4f\n", m_pAInode[node]->m_flVOffset[hull]);
}
filesystem->FPrintf ( file, "HintType: %4d\n", m_pAInode[node]->m_eHintType );
filesystem->FPrintf ( file, "HintYaw: %4f\n", m_pAInode[node]->GetYaw() );
filesystem->FPrintf ( file, "NodeType %4d\n",m_pAInode[node]->GetType());
filesystem->FPrintf ( file, "NodeInfo %4d\n",m_pAInode[node]->m_eNodeInfo);
filesystem->FPrintf ( file, "Neighbors ");
m_pAInode[node]->m_pNeighborBS->SaveBitString(file);
filesystem->FPrintf ( file, "Visible ");
m_pAInode[node]->m_pVisibleBS->SaveBitString(file);
filesystem->FPrintf ( file, "Connected ");
m_pAInode[node]->m_pConnectedBS->SaveBitString(file);
filesystem->FPrintf ( file, "NumLinks %4d\n",m_pAInode[node]->NumLinks());
for (int link = 0; link < m_pAInode[node]->NumLinks(); link++)
{
// Only dump if link source
if (node == m_pAInode[node]->GetLinkByIndex(link)->m_iSrcID)
{
totalNumLinks++;
}
}
}
// -------------------------------
// Dump all the links to the file
// -------------------------------
filesystem->FPrintf ( file, "TotalNumLinks %4d\n",totalNumLinks);
for (node = 0; node < m_iNumNodes; node++)
{
for (int link = 0; link < m_pAInode[node]->NumLinks(); link++)
{
// Only dump if link source
if (node == m_pAInode[node]->GetLinkByIndex(link)->m_iSrcID)
{
filesystem->FPrintf ( file, "LinkSrcID %4d\n", m_pAInode[node]->GetLinkByIndex(link)->m_iSrcID);
filesystem->FPrintf ( file, "LinkDestID %4d\n", m_pAInode[node]->GetLinkByIndex(link)->m_iDestID);
for (int hull =0;hull<NUM_HULLS;hull++)
{
filesystem->FPrintf ( file, "Hulls %4d\n", m_pAInode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[hull]);
}
}
}
}
// -------------------------------
// Dump WC lookup table
// -------------------------------
for (node = 0; node < m_iNumNodes; node++)
{
filesystem->FPrintf( file, "%4d\n",m_pNodeIndexTable[node]);
}
filesystem->Close(file);
}
*/
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
//-----------------------------------------------------------------------------
void CAI_NetworkManager::LoadNetworkGraph( void )
{
// ---------------------------------------------------
// If I'm in edit mode don't load, always recalculate
// ---------------------------------------------------
DevMsg( "Loading AI graph\n" );
if (engine->IsInEditMode())
{
DevMsg( "Not loading AI due to edit mode\n" );
return;
}
if ( !g_pGameRules->FAllowNPCs() )
{
DevMsg( "Not loading AI due to games rules\n" );
return;
}
DevMsg( "Step 1 loading\n" );
// -----------------------------
// Make sure directories have been made
// -----------------------------
char szNrpFilename[MAX_PATH];// text node report filename
Q_strncpy( szNrpFilename, "maps" ,sizeof(szNrpFilename));
filesystem->CreateDirHierarchy( szNrpFilename, "DEFAULT_WRITE_PATH" );
Q_strncat( szNrpFilename, "/graphs", sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
filesystem->CreateDirHierarchy( szNrpFilename, "DEFAULT_WRITE_PATH" );
Q_strncat( szNrpFilename, "/", sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, STRING( gpGlobals->mapname ), sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, IsX360() ? ".360.ain" : ".ain", sizeof( szNrpFilename ), COPY_ALL_CHARACTERS );
MEM_ALLOC_CREDIT();
// Read the file in one gulp
CUtlBuffer buf;
bool bHaveAIN = false;
if ( IsX360() && g_pQueuedLoader->IsMapLoading() )
{
// .ain was loaded anonymously by bsp, should be ready
void *pData;
int nDataSize;
if ( g_pQueuedLoader->ClaimAnonymousJob( szNrpFilename, &pData, &nDataSize ) )
{
if ( nDataSize != 0 )
{
buf.Put( pData, nDataSize );
bHaveAIN = true;
}
filesystem->FreeOptimalReadBuffer( pData );
}
}
if ( !bHaveAIN && !filesystem->ReadFile( szNrpFilename, "game", buf ) )
{
DevWarning( 2, "Couldn't read %s!\n", szNrpFilename );
return;
}
DevMsg( "Checking version\n" );
// ---------------------------
// Check the version number
// ---------------------------
if ( buf.GetChar() == 'V' && buf.GetChar() == 'e' && buf.GetChar() == 'r' )
{
DevMsg( "AI node graph %s is out of date\n", szNrpFilename );
return;
}
DevMsg( "Passed first ver check\n" );
buf.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
int version = buf.GetInt();
DevMsg( "Got version %d\n", version );
if ( version != AINET_VERSION_NUMBER)
{
DevMsg( "AI node graph %s is out of date\n", szNrpFilename );
return;
}
int mapversion = buf.GetInt();
DevMsg( "Map version %d\n", mapversion );
if ( mapversion != gpGlobals->mapversion && !g_ai_norebuildgraph.GetBool() )
{
bool bOK = false;
const char *pGameDir = CommandLine()->ParmValue( "-game", "hl2" );
char szLoweredGameDir[256];
Q_strncpy( szLoweredGameDir, pGameDir, sizeof( szLoweredGameDir ) );
Q_strlower( szLoweredGameDir );
// hack for shipped ep1 and hl2 maps
// they were rebuilt a week after they were actually shipped so allow the slightly
// older node graphs to load for these maps
if ( !V_stricmp( szLoweredGameDir, "hl2" ) || !V_stricmp( szLoweredGameDir, "episodic" ) )
{
bOK = true;
}
if ( !bOK )
{
DevMsg( "AI node graph %s is out of date (map version changed)\n", szNrpFilename );
return;
}
}
DevMsg( "Done version checks\n" );
// ----------------------------------------
// Get the network size and allocate space
// ----------------------------------------
int numNodes = buf.GetInt();
if ( numNodes > MAX_NODES || numNodes < 0 )
{
Error( "AI node graph %s is corrupt\n", szNrpFilename );
DevMsg( "%s", (const char *)buf.Base() );
DevMsg( "\n" );
Assert( 0 );
return;
}
DevMsg( "Finishing load\n" );
// ------------------------------------------------------------------------
// If in wc_edit mode allocate extra space for nodes that might be created
// ------------------------------------------------------------------------
if ( engine->IsInEditMode() )
{
numNodes = MAX( numNodes, 1024 );
}
m_pNetwork->m_pAInode = new CAI_Node*[MAX( numNodes, 1 )];
memset( m_pNetwork->m_pAInode, 0, sizeof( CAI_Node* ) * MAX( numNodes, 1 ) );
// -------------------------------
// Load all the nodes to the file
// -------------------------------
int node;
for ( node = 0; node < numNodes; node++)
{
Vector origin;
float yaw;
origin.x = buf.GetFloat();
origin.y = buf.GetFloat();
origin.z = buf.GetFloat();
yaw = buf.GetFloat();
CAI_Node *new_node = m_pNetwork->AddNode( origin, yaw );
buf.Get( new_node->m_flVOffset, sizeof(new_node->m_flVOffset) );
new_node->m_eNodeType = (NodeType_e)buf.GetChar();
if ( IsX360() )
{
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, 3 );
}
new_node->m_eNodeInfo = buf.GetUnsignedShort();
new_node->m_zone = buf.GetShort();
}
// -------------------------------
// Load all the links to the fild
// -------------------------------
int totalNumLinks = buf.GetInt();
for (int link = 0; link < totalNumLinks; link++)
{
int srcID, destID;
srcID = buf.GetShort();
destID = buf.GetShort();
CAI_Link *pLink = m_pNetwork->CreateLink( srcID, destID );;
byte ignored[NUM_HULLS];
byte *pDest = ( pLink ) ? &pLink->m_iAcceptedMoveTypes[0] : &ignored[0];
buf.Get( pDest, sizeof(ignored) );
}
// -------------------------------
// Load WC lookup table
// -------------------------------
delete [] GetEditOps()->m_pNodeIndexTable;
GetEditOps()->m_pNodeIndexTable = new int[MAX( m_pNetwork->m_iNumNodes, 1 )];
memset( GetEditOps()->m_pNodeIndexTable, 0, sizeof( int ) *MAX( m_pNetwork->m_iNumNodes, 1 ) );
for (node = 0; node < m_pNetwork->m_iNumNodes; node++)
{
GetEditOps()->m_pNodeIndexTable[node] = buf.GetInt();
}
#if 1
CUtlRBTree<int> usedIds;
CUtlRBTree<int> reportedIds;
SetDefLessFunc( usedIds );
SetDefLessFunc( reportedIds );
bool printedHeader = false;
for (node = 0; node < m_pNetwork->m_iNumNodes; node++)
{
int editorId = GetEditOps()->m_pNodeIndexTable[node];
if ( editorId != NO_NODE )
{
if ( usedIds.Find( editorId ) != usedIds.InvalidIndex() )
{
if ( !printedHeader )
{
Warning( "** Duplicate Hammer Node IDs: " );
printedHeader = true;
}
if ( reportedIds.Find( editorId ) == reportedIds.InvalidIndex() )
{
DevMsg( "%d, ", editorId );
reportedIds.Insert( editorId );
}
}
else
usedIds.Insert( editorId );
}
}
if ( printedHeader )
DevMsg( "\n** Should run \"Check For Problems\" on the VMF then verify dynamic links\n" );
#endif
gm_fNetworksLoaded = true;
CAI_DynamicLink::gm_bInitialized = false;
}
/* Keep this around for debugging
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkManager::LoadNetworkGraph( void )
{
// ---------------------------------------------------
// If I'm in edit mode don't load, always recalculate
// ---------------------------------------------------
if (engine->IsInEditMode())
{
return;
}
// -----------------------------
// Make sure directories have been made
// -----------------------------
char szNrpFilename [MAX_PATH];// text node report filename
Q_strncpy( szNrpFilename, "maps" ,sizeof(szNrpFilename));
filesystem->CreateDirHierarchy( szNrpFilename );
Q_strncat( szNrpFilename, "/graphs", COPY_ALL_CHARACTERS );
filesystem->CreateDirHierarchy( szNrpFilename );
Q_strncat( szNrpFilename, "/", COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, STRING( gpGlobals->mapname ), COPY_ALL_CHARACTERS );
Q_strncat( szNrpFilename, ".ain", COPY_ALL_CHARACTERS );
FileHandle_t file = filesystem->Open ( szNrpFilename, "r" );
// -----------------------------
// Make sure the file opened ok
// -----------------------------
if ( !file )
{
DevWarning( 2, "Couldn't create %s!\n", szNrpFilename );
return;
}
// ---------------------------
// Check the version number
// ---------------------------
char temps[256];
int version;
fscanf(file,"%255s",&temps);
fscanf(file, "%i\n",&version);
if (version!=AINET_VERSION_NUMBER)
{
return;
}
// ----------------------------------------
// Get the network size and allocate space
// ----------------------------------------
int numNodes;
fscanf(file,"%255s",&temps);
fscanf ( file, "%d\n", &numNodes);
// ------------------------------------------------------------------------
// If in wc_edit mode allocate extra space for nodes that might be created
// ------------------------------------------------------------------------
if ( engine->IsInEditMode() )
{
numNodes = MAX( numNodes, 1024 );
}
m_pAInode = new CAI_Node*[numNodes];
if ( !m_pAInode )
{
Warning( "LoadNetworkGraph: Not enough memory to create %i nodes\n", numNodes );
Assert(0);
return;
}
// -------------------------------
// Load all the nodes to the file
// -------------------------------
for (int node = 0; node < numNodes; node++)
{
CAI_Node *new_node = AddNode();
Vector origin;
fscanf(file,"%255s",&temps);
fscanf(file, "%f,%f,%f\n", &new_node->GetOrigin().x, &new_node->GetOrigin().y, &new_node->GetOrigin().z );
for (int hull =0;hull<NUM_HULLS;hull++)
{
fscanf(file,"%255s",&temps);
fscanf(file, "%f\n", &new_node->m_flVOffset[hull]);
}
fscanf(file,"%255s",&temps);
fscanf(file, "%d\n", &new_node->m_eHintType );
fscanf(file,"%255s",&temps);
fscanf(file, "%f\n", &new_node->GetYaw() );
fscanf(file,"%255s",&temps);
fscanf(file, "%d\n",&new_node->GetType());
fscanf(file,"%255s",&temps);
fscanf(file, "%d\n",&new_node->m_eNodeInfo);
fscanf(file,"%255s",&temps);
new_node->m_pNeighborBS = new CVarBitVec(numNodes);
new_node->m_pNeighborBS->LoadBitString(file);
fscanf(file,"%255s",&temps);
new_node->m_pVisibleBS = new CVarBitVec(numNodes);
new_node->m_pVisibleBS->LoadBitString(file);
fscanf(file,"%255s",&temps);
new_node->m_pConnectedBS = new CVarBitVec(numNodes);
new_node->m_pConnectedBS->LoadBitString(file);
fscanf(file,"%255s",&temps);
int numLinks;
fscanf (file, "%4d",&numLinks);
// ------------------------------------------------------------------------
// If in wc_edit mode allocate extra space for nodes that might be created
// ------------------------------------------------------------------------
if ( engine->IsInEditMode() )
{
numLinks = AI_MAX_NODE_LINKS;
}
//Assert ( numLinks >= 1 );
new_node->AllocateLinkSpace( numLinks );
}
// -------------------------------
// Load all the links to the fild
// -------------------------------
int totalNumLinks;
fscanf(file,"%255s",&temps);
fscanf ( file, "%d\n",&totalNumLinks);
for (int link = 0; link < totalNumLinks; link++)
{
CAI_Link *new_link = new CAI_Link;
fscanf(file,"%255s",&temps);
fscanf ( file, "%4d\n", &new_link->m_iSrcID);
fscanf(file,"%255s",&temps);
fscanf ( file, "%4d\n", &new_link->m_iDestID);
for (int hull =0;hull<NUM_HULLS;hull++)
{
fscanf(file,"%255s",&temps);
fscanf ( file, "%d\n", &new_link->m_iAcceptedMoveTypes[hull]);
}
// Now add link to source and destination nodes
m_pAInode[new_link->m_iSrcID]->AddLink(new_link);
m_pAInode[new_link->m_iDestID]->AddLink(new_link);
}
// -------------------------------
// Load WC lookup table
// -------------------------------
m_pNodeIndexTable = new int[m_iNumNodes];
for (node = 0; node < m_iNumNodes; node++)
{
fscanf( file, "%d\n",&m_pNodeIndexTable[node]);
}
CAI_NetworkManager::NetworksLoaded() = true;
fclose(file);
}
*/
//-----------------------------------------------------------------------------
// Purpose: Deletes all AINetworks from memory
//-----------------------------------------------------------------------------
void CAI_NetworkManager::DeleteAllAINetworks(void)
{
CAI_DynamicLink::gm_bInitialized = false;
gm_fNetworksLoaded = false;
g_pBigAINet = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
//-----------------------------------------------------------------------------
void CAI_NetworkManager::BuildNetworkGraph( void )
{
if ( m_bDontSaveGraph )
return;
CAI_DynamicLink::gm_bInitialized = false;
g_AINetworkBuilder.Build( m_pNetwork );
// If I'm loading for the first time save. Otherwise I'm
// doing a wc edit and I don't want to save
if (!CAI_NetworkManager::NetworksLoaded())
{
SaveNetworkGraph();
gm_fNetworksLoaded = true;
}
}
//------------------------------------------------------------------------------
bool g_bAIDisabledByUser = false;
void CAI_NetworkManager::InitializeAINetworks()
{
// For not just create a single AI Network called "BigNet"
// At some later point we may have mulitple AI networks
CAI_NetworkManager *pNetwork;
g_pAINetworkManager = pNetwork = CREATE_ENTITY( CAI_NetworkManager, "ai_network" );
pNetwork->AddEFlags( EFL_KEEP_ON_RECREATE_ENTITIES );
g_pBigAINet = pNetwork->GetNetwork();
pNetwork->SetName( AllocPooledString("BigNet") );
pNetwork->Spawn();
if ( engine->IsInEditMode() )
{
g_ai_norebuildgraph.SetValue( 0 );
}
if ( CAI_NetworkManager::IsAIFileCurrent( STRING( gpGlobals->mapname ) ) )
{
pNetwork->LoadNetworkGraph();
if ( !g_bAIDisabledByUser )
{
CAI_BaseNPC::m_nDebugBits &= ~bits_debugDisableAI;
}
}
// Reset node counter used during load
CNodeEnt::m_nNodeCount = 0;
pNetwork->SetThink( &CAI_NetworkManager::DelayedInit );
pNetwork->SetNextThink( gpGlobals->curtime );
}
// UNDONE: Where should this be defined?
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
//-----------------------------------------------------------------------------
// Purpose: Returns true if the AINetwork data files are up to date
//-----------------------------------------------------------------------------
bool CAI_NetworkManager::IsAIFileCurrent ( const char *szMapName )
{
char szBspFilename[MAX_PATH];
char szGraphFilename[MAX_PATH];
if ( !g_pGameRules->FAllowNPCs() )
{
return false;
}
if ( IsX360() && ( filesystem->GetDVDMode() == DVDMODE_STRICT ) )
{
// dvd build process validates and guarantees correctness, timestamps are allowed to be wrong
return true;
}
{
const char *pGameDir = CommandLine()->ParmValue( "-game", "hl2" );
char szLoweredGameDir[256];
Q_strncpy( szLoweredGameDir, pGameDir, sizeof( szLoweredGameDir ) );
Q_strlower( szLoweredGameDir );
if ( !V_stricmp( szLoweredGameDir, "hl2" ) || !V_stricmp( szLoweredGameDir, "episodic" ) || !V_stricmp( szLoweredGameDir, "ep2" ) || !V_stricmp( szLoweredGameDir, "portal" ) || !V_stricmp( szLoweredGameDir, "lostcoast" ) || !V_stricmp( szLoweredGameDir, "hl1" ) )
{
// we shipped good node graphs for our games
return true;
}
}
Q_snprintf( szBspFilename, sizeof( szBspFilename ), "maps/%s%s.bsp" ,szMapName, GetPlatformExt() );
Q_snprintf( szGraphFilename, sizeof( szGraphFilename ), "maps/graphs/%s%s.ain", szMapName, GetPlatformExt() );
int iCompare;
if ( engine->CompareFileTime( szBspFilename, szGraphFilename, &iCompare ) )
{
if ( iCompare > 0 )
{
// BSP file is newer.
if ( g_ai_norebuildgraph.GetInt() )
{
// The user has specified that they wish to override the
// rebuilding of outdated nodegraphs (see top of this file)
if ( filesystem->FileExists( szGraphFilename ) )
{
// Display these messages only if the graph exists, and the
// user is asking to override the rebuilding. If the graph does
// not exist, we're going to build it whether the user wants to or
// not.
DevMsg( 2, ".AIN File will *NOT* be updated. User Override.\n\n" );
DevMsg( "\n*****Node Graph Rebuild OVERRIDDEN by user*****\n\n" );
}
return true;
}
else
{
// Graph is out of date. Rebuild at usual.
DevMsg( 2, ".AIN File will be updated\n\n" );
return false;
}
}
return true;
}
return false;
}
//------------------------------------------------------------------------------
void CAI_NetworkManager::Spawn ( void )
{
SetSolid( SOLID_NONE );
SetMoveType( MOVETYPE_NONE );
}
//------------------------------------------------------------------------------
void CAI_NetworkManager::DelayedInit( void )
{
if ( !g_pGameRules->FAllowNPCs() )
{
SetThink ( NULL );
return;
}
if ( !g_ai_norebuildgraph.GetInt() )
{
// ----------------------------------------------------------
// Actually enter DelayedInit twice when rebuilding the
// node graph. The first time through we just print the
// warning message. We only actually do the rebuild on
// the second pass to make sure the message hits the screen
// ----------------------------------------------------------
if (m_bNeedGraphRebuild)
{
Assert( !m_bDontSaveGraph );
BuildNetworkGraph(); // For now only one AI Network
if (engine->IsInEditMode())
{
engine->ServerCommand("exec map_edit.cfg\n");
}
SetThink ( NULL );
if ( !g_bAIDisabledByUser )
{
CAI_BaseNPC::m_nDebugBits &= ~bits_debugDisableAI;
}
}
// --------------------------------------------
// If I haven't loaded a network, or I'm in
// WorldCraft edit mode rebuild the network
// --------------------------------------------
else if ( !m_bDontSaveGraph && ( !CAI_NetworkManager::NetworksLoaded() || engine->IsInEditMode() ) )
{
#ifdef _WIN32
// --------------------------------------------------------
// If in edit mode start WC session and make sure we are
// running the same map in WC and the engine
// --------------------------------------------------------
if (engine->IsInEditMode())
{
int status = Editor_BeginSession(STRING(gpGlobals->mapname), gpGlobals->mapversion, false);
if (status == Editor_NotRunning)
{
DevMsg("\nAborting map_edit\nWorldcraft not running...\n\n");
UTIL_CenterPrintAll( "Worldcraft not running...\n" );
engine->ServerCommand("disconnect\n");
SetThink(NULL);
return;
}
else if (status == Editor_BadCommand)
{
DevMsg("\nAborting map_edit\nWC/Engine map versions different...\n\n");
UTIL_CenterPrintAll( "WC/Engine map versions different...\n" );
engine->ServerCommand("disconnect\n");
SetThink(NULL);
return;
}
else
{
// Increment version number when session begins
gpGlobals->mapversion++;
}
}
#endif
DevMsg( "Node Graph out of Date. Rebuilding... (%d, %d, %d)\n", (int)m_bDontSaveGraph, (int)!CAI_NetworkManager::NetworksLoaded(), (int) engine->IsInEditMode() );
UTIL_CenterPrintAll( "Node Graph out of Date. Rebuilding...\n" );
m_bNeedGraphRebuild = true;
g_pAINetworkManager->SetNextThink( gpGlobals->curtime + 1 );
return;
}
}
// --------------------------------------------
// Initialize any dynamic links
// --------------------------------------------
CAI_DynamicLink::InitDynamicLinks();
FixupHints();
GetEditOps()->OnInit();
m_fInitalized = true;
if ( g_AI_Manager.NumAIs() != 0 && g_pBigAINet->NumNodes() == 0 )
DevMsg( "WARNING: Level contains NPCs but has no path nodes\n" );
}
//------------------------------------------------------------------------------
void CAI_NetworkManager::FixupHints()
{
AIHintIter_t iter;
CAI_Hint *pHint = CAI_HintManager::GetFirstHint( &iter );
while ( pHint )
{
pHint->FixupTargetNode();
pHint = CAI_HintManager::GetNextHint( &iter );
}
}
//-----------------------------------------------------------------------------
// CAI_NetworkEditTools
//-----------------------------------------------------------------------------
CAI_Node* CAI_NetworkEditTools::m_pLastDeletedNode = NULL; // For undo in wc edit mode
int CAI_NetworkEditTools::m_iHullDrawNum = HULL_HUMAN; // Which hulls to draw
int CAI_NetworkEditTools::m_iVisibilityNode = NO_NODE;
int CAI_NetworkEditTools::m_iGConnectivityNode = NO_NODE;
bool CAI_NetworkEditTools::m_bAirEditMode = false;
bool CAI_NetworkEditTools::m_bLinkEditMode = false;
float CAI_NetworkEditTools::m_flAirEditDistance = 300;
#ifdef AI_PERF_MON
// Performance stats (only for development)
int CAI_NetworkEditTools::m_nPerfStatNN = 0;
int CAI_NetworkEditTools::m_nPerfStatPB = 0;
float CAI_NetworkEditTools::m_fNextPerfStatTime = -1;
#endif
//------------------------------------------------------------------------------
void CAI_NetworkEditTools::OnInit()
{
// --------------------------------------------
// If I'm not in edit mode delete WC ID table
// --------------------------------------------
if ( !engine->IsInEditMode() )
{
// delete[] m_pNodeIndexTable; // For now only one AI Network called "BigNet"
// m_pNodeIndexTable = NULL;
}
}
//------------------------------------------------------------------------------
// Purpose : Given a WorldCraft node ID, return the associated engine ID
// Input :
// Output :
//------------------------------------------------------------------------------
int CAI_NetworkEditTools::GetNodeIdFromWCId( int nWCId )
{
if ( nWCId == -1 )
return -1;
if (!m_pNodeIndexTable)
{
DevMsg("ERROR: Trying to get WC ID with no table!\n");
return -1;
}
if (!m_pNetwork->NumNodes())
{
DevMsg("ERROR: Trying to get WC ID with no network!\n");
return -1;
}
for (int i=0;i<m_pNetwork->NumNodes();i++)
{
if (m_pNodeIndexTable[i] == nWCId)
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
int CAI_NetworkEditTools::GetWCIdFromNodeId( int nNodeId )
{
if ( nNodeId == -1 || nNodeId >= m_pNetwork->NumNodes() )
return -1;
return m_pNodeIndexTable[nNodeId];
}
//-----------------------------------------------------------------------------
// Purpose: Find the nearest ainode that is faced from the given location
// and within the angular threshold (ignores worldspawn).
// DO NOT USE FOR ANY RUN TIME RELEASE CODE
// Used for selection of nodes in debugging display only!
//
//-----------------------------------------------------------------------------
CAI_Node *CAI_NetworkEditTools::FindAINodeNearestFacing( const Vector &origin, const Vector &facing, float threshold, int nNodeType)
{
float bestDot = threshold;
CAI_Node *best = NULL;
CAI_Network* aiNet = g_pBigAINet;
for (int node =0; node < aiNet->NumNodes();node++)
{
if (aiNet->GetNode(node)->GetType() != NODE_DELETED)
{
// Pick nodes that are in the current editing type
if ( nNodeType == NODE_ANY ||
nNodeType == aiNet->GetNode(node)->GetType() )
{
// Make vector to node
Vector to_node = (aiNet->GetNode(node)->GetPosition(m_iHullDrawNum) - origin);
VectorNormalize( to_node );
float dot = DotProduct (facing , to_node );
if (dot > bestDot)
{
// Make sure I have a line of sight to it
trace_t tr;
AI_TraceLine ( origin, aiNet->GetNode(node)->GetPosition(m_iHullDrawNum),
MASK_BLOCKLOS, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 )
{
bestDot = dot;
best = aiNet->GetNode(node);
}
}
}
}
}
return best;
}
Vector PointOnLineNearestPoint(const Vector& vStartPos, const Vector& vEndPos, const Vector& vPoint)
{
Vector vEndToStart = (vEndPos - vStartPos);
Vector vOrgToStart = (vPoint - vStartPos);
float fNumerator = DotProduct(vEndToStart,vOrgToStart);
float fDenominator = vEndToStart.Length() * vOrgToStart.Length();
float fIntersectDist = vOrgToStart.Length()*(fNumerator/fDenominator);
VectorNormalize( vEndToStart );
Vector vIntersectPos = vStartPos + vEndToStart * fIntersectDist;
return vIntersectPos;
}
//-----------------------------------------------------------------------------
// Purpose: Find the nearest ainode that is faced from the given location
// and within the angular threshold (ignores worldspawn).
// DO NOT USE FOR ANY RUN TIME RELEASE CODE
// Used for selection of nodes in debugging display only!
//-----------------------------------------------------------------------------
CAI_Link *CAI_NetworkEditTools::FindAILinkNearestFacing( const Vector &vOrigin, const Vector &vFacing, float threshold)
{
float bestDot = threshold;
CAI_Link *best = NULL;
CAI_Network* aiNet = g_pBigAINet;
for (int node =0; node < aiNet->NumNodes();node++)
{
if (aiNet->GetNode(node)->GetType() != NODE_DELETED)
{
// Pick nodes that are in the current editing type
if (( m_bAirEditMode && aiNet->GetNode(node)->GetType() == NODE_AIR) ||
(!m_bAirEditMode && aiNet->GetNode(node)->GetType() == NODE_GROUND))
{
// Go through each link
for (int link=0; link < aiNet->GetNode(node)->NumLinks();link++)
{
CAI_Link *nodeLink = aiNet->GetNode(node)->GetLinkByIndex(link);
// Find position on link that I am looking
int endID = nodeLink->DestNodeID(node);
Vector startPos = aiNet->GetNode(node)->GetPosition(m_iHullDrawNum);
Vector endPos = aiNet->GetNode(endID)->GetPosition(m_iHullDrawNum);
Vector vNearest = PointOnLineNearestPoint(startPos, endPos, vOrigin);
// Get angle between viewing dir. and nearest point on line
Vector vOriginToNearest = (vNearest - vOrigin);
float fNumerator = DotProduct(vOriginToNearest,vFacing);
float fDenominator = vOriginToNearest.Length();
float fAngleToNearest = acos(fNumerator/fDenominator);
// If not facing the line reject
if (fAngleToNearest > 1.57)
{
continue;
}
// Calculate intersection of facing direction to nearest point
float fIntersectDist = vOriginToNearest.Length() * tan(fAngleToNearest);
Vector dir = endPos-startPos;
float fLineLen = VectorNormalize( dir );
Vector vIntersection = vNearest + (fIntersectDist * dir);
// Reject of beyond end of line
if (((vIntersection - startPos).Length() > fLineLen) ||
((vIntersection - endPos ).Length() > fLineLen) )
{
continue;
}
// Now test dot to the look position
Vector toLink = vIntersection - vOrigin;
VectorNormalize(toLink);
float lookDot = DotProduct (vFacing , toLink);
if (lookDot > bestDot)
{
// Make sure I have a line of sight to it
trace_t tr;
AI_TraceLine ( vOrigin, vIntersection, MASK_BLOCKLOS, NULL, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 )
{
bestDot = lookDot;
best = nodeLink;
}
}
}
}
}
}
return best;
}
//-----------------------------------------------------------------------------
// Purpose: Used for WC edit more. Marks that the network should be
// rebuild and turns of any displays that have been invalidated
// as the network is now out of date
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::SetRebuildFlags( void )
{
m_debugNetOverlays |= bits_debugNeedRebuild;
m_debugNetOverlays &= ~bits_debugOverlayConnections;
m_debugNetOverlays &= ~bits_debugOverlayGraphConnect;
m_debugNetOverlays &= ~bits_debugOverlayVisibility;
m_debugNetOverlays &= ~bits_debugOverlayHulls;
// Not allowed to edit links when graph outdated
m_bLinkEditMode = false;
}
//-----------------------------------------------------------------------------
// Purpose: Used for WC edit more. After node graph has been rebuild
// marks it as so and turns connection display back on
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::ClearRebuildFlags( void )
{
m_debugNetOverlays |= bits_debugOverlayConnections;
// ------------------------------------------
// Clear all rebuild flags in nodes
// ------------------------------------------
for (int i = 0; i < m_pNetwork->NumNodes(); i++)
{
m_pNetwork->GetNode(i)->m_eNodeInfo &= ~bits_NODE_WC_CHANGED;
m_pNetwork->GetNode(i)->ClearNeedsRebuild();
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the next hull to draw, or none if at end of hulls
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::DrawNextHull(const char *ainet_name)
{
m_iHullDrawNum++;
if (m_iHullDrawNum == NUM_HULLS)
{
m_iHullDrawNum = 0;
}
// Recalculate usable nodes for current hull
g_pAINetworkManager->GetEditOps()->RecalcUsableNodesForHull();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::DrawHull(Hull_t eHull)
{
m_iHullDrawNum = eHull;
if (m_iHullDrawNum >= NUM_HULLS)
{
m_iHullDrawNum = 0;
}
// Recalculate usable nodes for current hull
g_pAINetworkManager->GetEditOps()->RecalcUsableNodesForHull();
}
//-----------------------------------------------------------------------------
// Purpose: Used just for debug display, to color nodes grey that the
// currently selected hull size can't use.
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::RecalcUsableNodesForHull(void)
{
// -----------------------------------------------------
// Use test hull to check hull sizes
// -----------------------------------------------------
CAI_TestHull *m_pTestHull = CAI_TestHull::GetTestHull();
m_pTestHull->GetNavigator()->SetNetwork( g_pBigAINet );
m_pTestHull->SetHullType((Hull_t)m_iHullDrawNum);
m_pTestHull->SetHullSizeNormal();
for (int node=0;node<m_pNetwork->NumNodes();node++)
{
if ( ( m_pNetwork->GetNode(node)->m_eNodeInfo & ( HullToBit( (Hull_t)m_iHullDrawNum ) << NODE_ENT_FLAGS_SHIFT ) ) ||
m_pTestHull->GetNavigator()->CanFitAtNode(node))
{
m_pNetwork->GetNode(node)->m_eNodeInfo &= ~bits_NODE_WONT_FIT_HULL;
}
else
{
m_pNetwork->GetNode(node)->m_eNodeInfo |= bits_NODE_WONT_FIT_HULL;
}
}
CAI_TestHull::ReturnTestHull();
}
//-----------------------------------------------------------------------------
// Purpose: Sets debug bits
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::SetDebugBits(const char *ainet_name,int debug_bit)
{
CAI_NetworkEditTools *pEditOps = g_pAINetworkManager->GetEditOps();
if ( !pEditOps )
return;
if (debug_bit & bits_debugOverlayNodes)
{
if (pEditOps->m_debugNetOverlays & bits_debugOverlayNodesLev2)
{
pEditOps->m_debugNetOverlays &= ~bits_debugOverlayNodes;
pEditOps->m_debugNetOverlays &= ~bits_debugOverlayNodesLev2;
}
else if (pEditOps->m_debugNetOverlays & bits_debugOverlayNodes)
{
pEditOps->m_debugNetOverlays |= bits_debugOverlayNodesLev2;
}
else
{
pEditOps->m_debugNetOverlays |= bits_debugOverlayNodes;
// Recalculate usable nodes for current hull
pEditOps->RecalcUsableNodesForHull();
}
}
else if (pEditOps->m_debugNetOverlays & debug_bit)
{
pEditOps->m_debugNetOverlays &= ~debug_bit;
}
else
{
pEditOps->m_debugNetOverlays |= debug_bit;
}
}
//-----------------------------------------------------------------------------
// Purpose: Draws edit display info on screen
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::DrawEditInfoOverlay(void)
{
hudtextparms_s tTextParam;
tTextParam.x = 0.8;
tTextParam.y = 0.8;
tTextParam.effect = 0;
tTextParam.r1 = 255;
tTextParam.g1 = 255;
tTextParam.b1 = 255;
tTextParam.a1 = 255;
tTextParam.r2 = 255;
tTextParam.g2 = 255;
tTextParam.b2 = 255;
tTextParam.a2 = 255;
tTextParam.fadeinTime = 0;
tTextParam.fadeoutTime = 0;
tTextParam.holdTime = 1;
tTextParam.fxTime = 0;
tTextParam.channel = 0;
char hullTypeTxt[50];
char nodeTypeTxt[50];
char editTypeTxt[50];
char outTxt[255];
Q_snprintf(hullTypeTxt,sizeof(hullTypeTxt)," %s",NAI_Hull::Name(m_iHullDrawNum));
Q_snprintf(outTxt,sizeof(outTxt),"Displaying:\n%s\n\n", hullTypeTxt);
if (engine->IsInEditMode())
{
char outTxt2[255];
Q_snprintf(nodeTypeTxt,sizeof(nodeTypeTxt)," %s (l)", m_bLinkEditMode ? "Links":"Nodes");
Q_snprintf(editTypeTxt,sizeof(editTypeTxt)," %s (m)", m_bAirEditMode ? "Air":"Ground");
Q_snprintf(outTxt2,sizeof(outTxt2),"Editing:\n%s\n%s", editTypeTxt,nodeTypeTxt);
Q_strncat(outTxt,outTxt2,sizeof(outTxt), COPY_ALL_CHARACTERS);
// Print in red if network needs rebuilding
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
tTextParam.g1 = 0;
tTextParam.b1 = 0;
}
}
UTIL_HudMessageAll( tTextParam, outTxt );
}
//-----------------------------------------------------------------------------
// Purpose: Draws AINetwork on the screen
//-----------------------------------------------------------------------------
void CAI_NetworkEditTools::DrawAINetworkOverlay(void)
{
// ------------------------------------
// If network isn't loaded yet return
// ------------------------------------
if (!CAI_NetworkManager::NetworksLoaded())
{
return;
}
// ----------------------------------------------
// So we don't fill up the client message queue
// with node drawing messages, only send them
// in chuncks
// ----------------------------------------------
static int startDrawNode = 0;
static int endDrawNode = 0;
static float flDrawDuration;
endDrawNode = startDrawNode + 20;
flDrawDuration = 0.1 * (m_pNetwork->NumNodes()-1)/20;
if ( flDrawDuration < .1 )
flDrawDuration = .1;
if (endDrawNode > m_pNetwork->NumNodes())
{
endDrawNode = m_pNetwork->NumNodes();
}
// ---------------------
// Draw grid
// ---------------------
if (m_debugNetOverlays & bits_debugOverlayGrid)
{
// Trace a line to where player is looking
CBasePlayer* pPlayer = UTIL_PlayerByIndex(CBaseEntity::m_nDebugPlayer);
if (pPlayer)
{
Vector vForward;
Vector vSource = pPlayer->EyePosition();
pPlayer->EyeVectors( &vForward );
trace_t tr;
AI_TraceLine ( vSource, vSource + vForward * 2048, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
float dotPr = DotProduct(Vector(0,0,1),tr.plane.normal);
if (tr.fraction != 1.0 && dotPr > 0.5)
{
NDebugOverlay::Grid( tr.endpos + Vector(0,0,1) );
}
}
}
// --------------------
CAI_Node **pAINode = m_pNetwork->AccessNodes();
// --------------------
// Draw the graph connectivity
// ---------------------
if (m_debugNetOverlays & bits_debugOverlayGraphConnect)
{
// ---------------------------------------------------
// If network needs rebuilding do so before display
// --------------------------------------------------
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
m_pManager->RebuildNetworkGraph();
}
else if (m_iGConnectivityNode != NO_NODE)
{
for (int node=0;node<m_pNetwork->NumNodes();node++)
{
if ( m_pNetwork->IsConnected( m_iGConnectivityNode, node) )
{
Vector srcPos = pAINode[m_iGConnectivityNode]->GetPosition(m_iHullDrawNum);
Vector desPos = pAINode[node]->GetPosition(m_iHullDrawNum);
NDebugOverlay::Line(srcPos, desPos, 255,0,255, false,0);
}
}
}
}
// --------------------
// Draw the hulls
// ---------------------
if (m_debugNetOverlays & bits_debugOverlayHulls)
{
// ---------------------------------------------------
// If network needs rebuilding do so before display
// --------------------------------------------------
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
m_pManager->RebuildNetworkGraph();
}
else
{
for (int node=startDrawNode;node<endDrawNode;node++)
{
for (int link=0;link<pAINode[node]->NumLinks();link++)
{
// Only draw link once
if (pAINode[node]->GetLinkByIndex(link)->DestNodeID(node) < node)
{
Vector srcPos = pAINode[pAINode[node]->GetLinkByIndex(link)->m_iSrcID]->GetPosition(m_iHullDrawNum);
Vector desPos = pAINode[pAINode[node]->GetLinkByIndex(link)->m_iDestID]->GetPosition(m_iHullDrawNum);
Vector direction = desPos - srcPos;
float length = VectorNormalize(direction);
Vector hullMins = NAI_Hull::Mins(m_iHullDrawNum);
Vector hullMaxs = NAI_Hull::Maxs(m_iHullDrawNum);
hullMaxs.x = length + hullMaxs.x;
if (pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[m_iHullDrawNum] & bits_CAP_MOVE_FLY)
{
NDebugOverlay::BoxDirection(srcPos, hullMins, hullMaxs, direction, 100,255,255,20,flDrawDuration);
}
if (pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[m_iHullDrawNum] & bits_CAP_MOVE_CLIMB)
{
// Display as a vertical slice up the climbing surface unless dismount node
if (pAINode[pAINode[node]->GetLinkByIndex(link)->m_iSrcID]->GetOrigin() != pAINode[pAINode[node]->GetLinkByIndex(link)->m_iDestID]->GetOrigin())
{
hullMaxs.x = hullMaxs.x - length;
if (srcPos.z < desPos.z)
{
hullMaxs.z = length + hullMaxs.z;
}
else
{
hullMins.z = hullMins.z - length;
}
direction = Vector(0,1,0);
}
NDebugOverlay::BoxDirection(srcPos, hullMins, hullMaxs, direction, 255,0,255,20,flDrawDuration);
}
if (pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[m_iHullDrawNum] & bits_CAP_MOVE_GROUND)
{
NDebugOverlay::BoxDirection(srcPos, hullMins, hullMaxs, direction, 0,255,50,20,flDrawDuration);
}
else if (pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[m_iHullDrawNum] & bits_CAP_MOVE_JUMP)
{
NDebugOverlay::BoxDirection(srcPos, hullMins, hullMaxs, direction, 0,0,255,20,flDrawDuration);
}
}
}
}
}
}
// --------------------
// Draw the hints
// ---------------------
if (m_debugNetOverlays & bits_debugOverlayHints)
{
CAI_HintManager::DrawHintOverlays(flDrawDuration);
}
// -------------------------------
// Draw the nodes and connections
// -------------------------------
if (m_debugNetOverlays & (bits_debugOverlayNodes | bits_debugOverlayConnections))
{
for (int node=startDrawNode;node<endDrawNode;node++) {
// This gets expensive, so see if the node is visible to the client
if (pAINode[node]->GetType() != NODE_DELETED)
{
// --------------------
// Draw the connections
// ---------------------
if (m_debugNetOverlays & bits_debugOverlayConnections)
{
// ---------------------------------------------------
// If network needs rebuilding do so before display
// --------------------------------------------------
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
m_pManager->RebuildNetworkGraph();
}
else
{
for (int link=0;link<pAINode[node]->NumLinks();link++) {
// Only draw link once
if (pAINode[node]->GetLinkByIndex(link)->DestNodeID(node) < node)
{
int srcID = pAINode[node]->GetLinkByIndex(link)->m_iSrcID;
int desID = pAINode[node]->GetLinkByIndex(link)->m_iDestID;
Vector srcPos = pAINode[srcID]->GetPosition(m_iHullDrawNum);
Vector desPos = pAINode[desID]->GetPosition(m_iHullDrawNum);
int srcType = pAINode[pAINode[node]->GetLinkByIndex(link)->m_iSrcID]->GetType();
int desType = pAINode[pAINode[node]->GetLinkByIndex(link)->m_iDestID]->GetType();
int linkInfo = pAINode[node]->GetLinkByIndex(link)->m_LinkInfo;
int moveTypes = pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[m_iHullDrawNum];
// when rendering, raise NODE_GROUND off the floor slighty as they seem to clip too much
if ( srcType == NODE_GROUND)
{
srcPos.z += 1.0;
}
if ( desType == NODE_GROUND)
{
desPos.z += 1.0;
}
// Draw in red if stale link
if (linkInfo & bits_LINK_STALE_SUGGESTED)
{
NDebugOverlay::Line(srcPos, desPos, 255,0,0, false, flDrawDuration);
}
// Draw in grey if link turned off
else if (linkInfo & bits_LINK_OFF)
{
NDebugOverlay::Line(srcPos, desPos, 100,100,100, false, flDrawDuration);
}
else if ((m_debugNetOverlays & bits_debugOverlayFlyConnections) && (moveTypes & bits_CAP_MOVE_FLY))
{
NDebugOverlay::Line(srcPos, desPos, 100,255,255, false, flDrawDuration);
}
else if (moveTypes & bits_CAP_MOVE_CLIMB)
{
NDebugOverlay::Line(srcPos, desPos, 255,0,255, false, flDrawDuration);
}
else if (moveTypes & bits_CAP_MOVE_GROUND)
{
NDebugOverlay::Line(srcPos, desPos, 0,255,50, false, flDrawDuration);
}
else if ((m_debugNetOverlays & bits_debugOverlayJumpConnections) && (moveTypes & bits_CAP_MOVE_JUMP) )
{
NDebugOverlay::Line(srcPos, desPos, 0,0,255, false, flDrawDuration);
}
else
{ // Dark red if this hull can't use
bool isFly = ( srcType == NODE_AIR || desType == NODE_AIR );
bool isJump = true;
for ( int i = HULL_HUMAN; i < NUM_HULLS; i++ )
{
if ( pAINode[node]->GetLinkByIndex(link)->m_iAcceptedMoveTypes[i] & ~bits_CAP_MOVE_JUMP )
{
isJump = false;
break;
}
}
if ( ( isFly && (m_debugNetOverlays & bits_debugOverlayFlyConnections) ) ||
( isJump && (m_debugNetOverlays & bits_debugOverlayJumpConnections) ) ||
( !isFly && !isJump ) )
{
NDebugOverlay::Line(srcPos, desPos, 100,25,25, false, flDrawDuration);
}
}
}
}
}
}
if (m_debugNetOverlays & bits_debugOverlayNodes)
{
int r = 255;
int g = 0;
int b = 0;
// If checking visibility base color off of visibility info
if (m_debugNetOverlays & bits_debugOverlayVisibility &&
m_iVisibilityNode != NO_NODE)
{
// ---------------------------------------------------
// If network needs rebuilding do so before display
// --------------------------------------------------
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
m_pManager->RebuildNetworkGraph();
}
}
// If checking graph connectivity base color off of connectivity info
if (m_debugNetOverlays & bits_debugOverlayGraphConnect &&
m_iGConnectivityNode != NO_NODE)
{
// ---------------------------------------------------
// If network needs rebuilding do so before display
// --------------------------------------------------
if (m_debugNetOverlays & bits_debugNeedRebuild)
{
m_pManager->RebuildNetworkGraph();
}
else if (m_pNetwork->IsConnected( m_iGConnectivityNode, node) )
{
r = 0;
g = 0;
b = 255;
}
}
// Otherwise base color off of node type
else
{
// If node is new and hasn't been rebuild yet
if (pAINode[node]->m_eNodeInfo & bits_NODE_WC_CHANGED)
{
r = 200;
g = 200;
b = 200;
}
// If node doesn't fit the current hull size
else if (pAINode[node]->m_eNodeInfo & bits_NODE_WONT_FIT_HULL)
{
r = 255;
g = 25;
b = 25;
}
else if (pAINode[node]->GetType() == NODE_CLIMB)
{
r = 255;
g = 0;
b = 255;
}
else if (pAINode[node]->GetType() == NODE_AIR)
{
r = 0;
g = 255;
b = 255;
}
else if (pAINode[node]->GetType() == NODE_GROUND)
{
r = 0;
g = 255;
b = 100;
}
}
Vector nodePos;
nodePos = pAINode[node]->GetPosition(m_iHullDrawNum);
NDebugOverlay::Box(nodePos, Vector(-5,-5,-5), Vector(5,5,5), r,g,b,0,flDrawDuration);
// If climb node draw line in facing direction
if (pAINode[node]->GetType() == NODE_CLIMB)
{
Vector offsetDir = 12.0 * Vector(cos(DEG2RAD(pAINode[node]->GetYaw())),sin(DEG2RAD(pAINode[node]->GetYaw())),flDrawDuration);
NDebugOverlay::Line(nodePos, nodePos+offsetDir, r,g,b,false,flDrawDuration);
}
if ( pAINode[node]->GetHint() )
{
NDebugOverlay::Box( nodePos, Vector(-7,-7,-7), Vector(7,7,7), 255,255,0,0,flDrawDuration);
}
if (m_debugNetOverlays & bits_debugOverlayNodesLev2)
{
CFmtStr msg;
if ( m_pNodeIndexTable )
msg.sprintf("%i (wc:%i; z:%i)",node,m_pNodeIndexTable[pAINode[node]->GetId()], pAINode[node]->GetZone());
else
msg.sprintf("%i (z:%i)",node,pAINode[node]->GetZone());
Vector loc = nodePos;
loc.x+=6;
loc.y+=6;
loc.z+=6;
NDebugOverlay::Text( loc, msg, true, flDrawDuration);
// Print the hintgroup if we have one
if ( pAINode[node]->GetHint() )
{
msg.sprintf("%s", STRING( pAINode[node]->GetHint()->GetGroup() ));
loc.z-=3;
NDebugOverlay::Text( loc, msg, true, flDrawDuration);
}
}
}
}
}
}
// -------------------------------
// Identify hull being displayed
// -------------------------------
if (m_debugNetOverlays & (bits_debugOverlayNodes | bits_debugOverlayConnections | bits_debugOverlayHulls))
{
DrawEditInfoOverlay();
}
// ----------------------------
// Increment node draw chunk
// ----------------------------
startDrawNode = endDrawNode;
if (startDrawNode >= m_pNetwork->NumNodes())
{
startDrawNode = 0;
}
// ----------------------------
// Output performance stats
// ----------------------------
#ifdef AI_PERF_MON
if (m_fNextPerfStatTime < gpGlobals->curtime)
{
char temp[512];
Q_snprintf(temp,sizeof(temp),"%3.2f NN/m\n%3.2f P/m\n",(m_nPerfStatNN/1.0),(m_nPerfStatPB/1.0));
UTIL_CenterPrintAll(temp);
m_fNextPerfStatTime = gpGlobals->curtime + 1;
m_nPerfStatNN = 0;
m_nPerfStatPB = 0;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CAI_NetworkEditTools::CAI_NetworkEditTools(CAI_NetworkManager *pNetworkManager)
{
// ----------------------------------------------------------------------------
// If in wc_edit mode
// ----------------------------------------------------------------------------
if (engine->IsInEditMode())
{
// ----------------------------------------------------------------------------
// Allocate extra space for storing undropped node positions
// ----------------------------------------------------------------------------
m_pWCPosition = new Vector[MAX_NODES];
}
else
{
m_pWCPosition = NULL;
}
m_pNodeIndexTable = NULL;
m_debugNetOverlays = 0;
// ----------------------------------------------------------------------------
// Allocate table of WC Id's. If not in edit mode Deleted after initialization
// ----------------------------------------------------------------------------
m_pNodeIndexTable = new int[MAX_NODES];
for ( int i = 0; i < MAX_NODES; i++ )
m_pNodeIndexTable[i] = NO_NODE;
m_nNextWCIndex = 0;
m_pNetwork = pNetworkManager->GetNetwork(); // @tbd
m_pManager = pNetworkManager;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CAI_NetworkEditTools::~CAI_NetworkEditTools()
{
// --------------------------------------------------------
// If in edit mode tell WC I'm ending my session
// --------------------------------------------------------
#ifdef _WIN32
Editor_EndSession(false);
#endif
delete[] m_pNodeIndexTable;
}
//-----------------------------------------------------------------------------
// CAI_NetworkBuilder
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::FloodFillZone( CAI_Node **ppNodes, CAI_Node *pNode, int zone )
{
pNode->SetZone( zone );
for (int link = 0; link < pNode->NumLinks(); link++)
{
CAI_Link *pLink = pNode->GetLinkByIndex(link);
CAI_Node *pLinkedNode = ( pLink->m_iDestID == pNode->GetId()) ? ppNodes[pLink->m_iSrcID] : ppNodes[pLink->m_iDestID];
if ( pLinkedNode->GetZone() == AI_NODE_ZONE_UNKNOWN )
FloodFillZone( ppNodes, pLinkedNode, zone );
Assert( pLinkedNode->GetZone() == pNode->GetZone() && pNode->GetZone() == zone );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitZones( CAI_Network *pNetwork )
{
int nNodes = pNetwork->NumNodes();
CAI_Node **ppNodes = pNetwork->AccessNodes();
if ( !nNodes )
return;
int i;
for (i = 0; i < nNodes; i++)
{
ppNodes[i]->SetZone( AI_NODE_ZONE_UNKNOWN );
}
// Mark solo nodes
for (i = 0; i < nNodes; i++)
{
if ( ppNodes[i]->NumLinks() == 0 )
ppNodes[i]->SetZone( AI_NODE_ZONE_SOLO );
}
int curZone = AI_NODE_FIRST_ZONE;
for (i = 0; i < nNodes; i++)
{
if ( ppNodes[i]->GetZone() == AI_NODE_ZONE_UNKNOWN )
{
FloodFillZone( (CAI_Node **)ppNodes, ppNodes[i], curZone );
curZone++;
}
}
#ifdef DEBUG
for (i = 0; i < nNodes; i++)
{
Assert( ppNodes[i]->GetZone() != AI_NODE_ZONE_UNKNOWN );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Used for WC edit move to rebuild the network around the given
// location. Rebuilding the entire network takes too long
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::Rebuild( CAI_Network *pNetwork )
{
int nNodes = pNetwork->NumNodes();
CAI_Node **ppNodes = pNetwork->AccessNodes();
if ( !nNodes )
return;
BeginBuild();
// ------------------------------------------------------------
// First mark all nodes around vecPos as having to be rebuilt
// ------------------------------------------------------------
int i;
for (i = 0; i < nNodes; i++)
{
// --------------------------------------------------------------------
// If changed, mark all nodes that are within the max link distance to
// the changed node as having to be rebuild
// --------------------------------------------------------------------
if (ppNodes[i]->m_eNodeInfo & bits_NODE_WC_CHANGED)
{
Vector vRebuildPos = ppNodes[i]->GetOrigin();
ppNodes[i]->SetNeedsRebuild();
ppNodes[i]->SetZone( AI_NODE_ZONE_UNIVERSAL );
for (int node = 0; node < nNodes; node++)
{
if ( ppNodes[node]->GetType() == NODE_AIR )
{
if ((ppNodes[node]->GetOrigin() - vRebuildPos).LengthSqr() < MAX_AIR_NODE_LINK_DIST_SQ)
{
ppNodes[node]->SetNeedsRebuild();
ppNodes[node]->SetZone( AI_NODE_ZONE_UNIVERSAL );
}
}
else
{
if ((ppNodes[node]->GetOrigin() - vRebuildPos).LengthSqr() < MAX_NODE_LINK_DIST_SQ)
{
ppNodes[node]->SetNeedsRebuild();
ppNodes[node]->SetZone( AI_NODE_ZONE_UNIVERSAL );
}
}
}
}
}
// ---------------------------
// Initialize node positions
// ---------------------------
for (i = 0; i < nNodes; i++)
{
if (ppNodes[i]->NeedsRebuild())
{
InitNodePosition( pNetwork, ppNodes[i] );
}
}
nNodes = pNetwork->NumNodes(); // InitNodePosition can create nodes
// ---------------------------
// Initialize node neighbors
// ---------------------------
m_DidSetNeighborsTable.Resize( nNodes );
m_DidSetNeighborsTable.ClearAll();
m_NeighborsTable.SetSize( nNodes );
for (i = 0; i < nNodes; i++)
{
m_NeighborsTable[i].Resize( nNodes );
}
for (i = 0; i < nNodes; i++)
{
// If near point of change recalculate
if (ppNodes[i]->NeedsRebuild())
{
InitNeighbors( pNetwork, ppNodes[i] );
}
}
// ---------------------------
// Force node neighbors for dynamic links
// ---------------------------
ForceDynamicLinkNeighbors();
// ---------------------------
// Initialize accepted hulls
// ---------------------------
for (i = 0; i < nNodes; i++)
{
if (ppNodes[i]->NeedsRebuild())
{
ppNodes[i]->ClearLinks();
}
}
for (i = 0; i < nNodes; i++)
{
if (ppNodes[i]->NeedsRebuild())
{
InitLinks( pNetwork, ppNodes[i] );
}
}
g_pAINetworkManager->FixupHints();
EndBuild();
}
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::BeginBuild()
{
m_pTestHull = CAI_TestHull::GetTestHull();
}
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::EndBuild()
{
m_NeighborsTable.SetSize(0);
m_DidSetNeighborsTable.Resize(0);
CAI_TestHull::ReturnTestHull();
}
//-----------------------------------------------------------------------------
// Purpose: Only called if network has changed since last time level
// was loaded
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::Build( CAI_Network *pNetwork )
{
int nNodes = pNetwork->NumNodes();
CAI_Node **ppNodes = pNetwork->AccessNodes();
if ( !nNodes )
return;
CAI_NetworkBuildHelper *pHelper = (CAI_NetworkBuildHelper *)CreateEntityByName( "ai_network_build_helper" );
VPROF( "AINet" );
BeginBuild();
CFastTimer masterTimer;
CFastTimer timer;
DevMsg( "Building AI node graph...\n");
masterTimer.Start();
// ---------------------------
// Initialize node positions
// ---------------------------
DevMsg( "Initializing node positions...\n" );
timer.Start();
int i;
for ( i = 0; i < nNodes; i++)
{
InitNodePosition( pNetwork, ppNodes[i] );
if ( pHelper )
pHelper->PostInitNodePosition( pNetwork, ppNodes[i] );
}
nNodes = pNetwork->NumNodes(); // InitNodePosition can create nodes
timer.End();
DevMsg( "...done initializing node positions. %f seconds\n", timer.GetDuration().GetSeconds() );
// ---------------------------
// Initialize node neighbors
// ---------------------------
DevMsg( "Initializing node neighbors...\n" );
timer.Start();
m_DidSetNeighborsTable.Resize( nNodes );
m_DidSetNeighborsTable.ClearAll();
m_NeighborsTable.SetSize( nNodes );
for (i = 0; i < nNodes; i++)
{
m_NeighborsTable[i].Resize( nNodes );
m_NeighborsTable[i].ClearAll();
}
for (i = 0; i < nNodes; i++)
{
InitNeighbors( pNetwork, ppNodes[i] );
}
timer.End();
DevMsg( "...done initializing node neighbors. %f seconds\n", timer.GetDuration().GetSeconds() );
// ---------------------------
// Force node neighbors for dynamic links
// ---------------------------
DevMsg( "Forcing dynamic link neighbors...\n" );
timer.Start();
ForceDynamicLinkNeighbors();
timer.End();
DevMsg( "...done forcing dynamic link neighbors. %f seconds\n", timer.GetDuration().GetSeconds() );
// ---------------------------
// Initialize accepted hulls
// ---------------------------
DevMsg( "Determining links...\n" );
timer.Start();
for (i = 0; i < nNodes; i++)
{
// Make sure all the links are clear
ppNodes[i]->ClearLinks();
}
for (i = 0; i < nNodes; i++)
{
InitLinks( pNetwork, ppNodes[i] );
}
timer.End();
DevMsg( "...done determining links. %f seconds\n", timer.GetDuration().GetSeconds() );
// ------------------------------
// Initialize disconnected nodes
// ------------------------------
DevMsg( "Determining zones...\n" );
timer.Start();
InitZones( pNetwork);
timer.End();
masterTimer.End();
DevMsg( "...done determining zones. %f seconds\n", timer.GetDuration().GetSeconds() );
DevMsg( "...done building AI node graph, %f seconds\n", masterTimer.GetDuration().GetSeconds() );
g_pAINetworkManager->FixupHints();
EndBuild();
if ( pHelper )
UTIL_Remove( pHelper );
}
//------------------------------------------------------------------------------
// Purpose : Forces testing of a connection between src and dest IDs for all dynamic links
//
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_NetworkBuilder::ForceDynamicLinkNeighbors(void)
{
if (!g_pAINetworkManager->GetEditOps()->m_pNodeIndexTable)
{
DevMsg("ERROR: Trying initialize links with no WC ID table!\n");
return;
}
CAI_DynamicLink* pDynamicLink = CAI_DynamicLink::m_pAllDynamicLinks;
while (pDynamicLink)
{
// -------------------------------------------------------------
// First convert this links WC IDs to engine IDs
// -------------------------------------------------------------
int nSrcID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( pDynamicLink->m_nSrcEditID );
if (nSrcID == -1)
{
DevMsg("ERROR: Dynamic link source WC node %d not found\n", pDynamicLink->m_nSrcEditID );
}
int nDestID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( pDynamicLink->m_nDestEditID );
if (nDestID == -1)
{
DevMsg("ERROR: Dynamic link dest WC node %d not found\n", pDynamicLink->m_nDestEditID );
}
if ( nSrcID != -1 && nDestID != -1 )
{
if ( nSrcID < g_pBigAINet->NumNodes() && nDestID < g_pBigAINet->NumNodes() )
{
CAI_Node *pSrcNode = g_pBigAINet->GetNode( nSrcID );
CAI_Node *pDestNode = g_pBigAINet->GetNode( nDestID );
// -------------------------------------------------------------
// Force visibility and neighbor-ness between the nodes
// -------------------------------------------------------------
Assert( pSrcNode );
Assert( pDestNode );
m_NeighborsTable[pSrcNode->GetId()].Set(pDestNode->GetId());
m_NeighborsTable[pDestNode->GetId()].Set(pSrcNode->GetId());
}
}
// Go on to the next dynamic link
pDynamicLink = pDynamicLink->m_pNextDynamicLink;
}
}
CAI_NetworkBuilder g_AINetworkBuilder;
//-----------------------------------------------------------------------------
// Purpose: Initializes position of climb node in the world. Climb nodes are
// set to be just above the floor or at the same level at the
// dismount point for the node
//
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitClimbNodePosition(CAI_Network *pNetwork, CAI_Node *pNode)
{
AI_PROFILE_SCOPE( CAI_Node_InitClimbNodePosition );
// If this is a node for mounting/dismounting the climb skip it
if ( pNode->m_eNodeInfo & (bits_NODE_CLIMB_OFF_FORWARD | bits_NODE_CLIMB_OFF_LEFT | bits_NODE_CLIMB_OFF_RIGHT) )
{
return;
}
// Figure out which directions I can dismount from the climb node
//float hullLength = NAI_Hull::Length(HULL_SMALL);
//Vector offsetDir = Vector(cos(DEG2RAD(m_flYaw)),sin(DEG2RAD(m_flYaw)),0);
// ----------------
// Check position
// ----------------
trace_t trace;
Vector posOnLadder = pNode->GetPosition(HULL_SMALL_CENTERED);
AI_TraceHull( posOnLadder, posOnLadder + Vector( 0, 0, -37 ),
NAI_Hull::Mins(HULL_SMALL_CENTERED), NAI_Hull::Maxs(HULL_SMALL_CENTERED),
MASK_NPCSOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace );
// --------------------------------------------------------------------
// If climb node is right above the floor, we don't need any dismount
// nodes. Accept this dropped position and note that this climb node
// is at the bottom
// --------------------------------------------------------------------
if (!trace.startsolid && trace.fraction != 1)
{
pNode->m_eNodeInfo = bits_NODE_CLIMB_BOTTOM;
InitGroundNodePosition( pNetwork, pNode );
return;
}
// ---------------------------------------------------------------------
// If network was already loaded this means we are in wc edit mode
// so we shouldn't recreate the added climb nodes
// ---------------------------------------------------------------------
if (g_pAINetworkManager->NetworksLoaded())
{
return;
}
// ---------------------------------------------------------------------
// Otherwise we need to create climb nodes for dismounting the climb
// and place the height of the climb node at the dismount position
// ---------------------------------------------------------------------
int checkNodeTypes[3] = { bits_NODE_CLIMB_OFF_FORWARD, bits_NODE_CLIMB_OFF_LEFT, bits_NODE_CLIMB_OFF_RIGHT };
int numExits = 0;
// DevMsg( "testing %f %f %f\n", GetOrigin().x, GetOrigin().y, GetOrigin().z );
for (int i = 0; i < 3; i++)
{
pNode->m_eNodeInfo = checkNodeTypes[i];
Vector origin = pNode->GetPosition(HULL_SMALL_CENTERED);
// DevMsg( "testing %f %f %f\n", origin.x, origin.y, origin.z );
// ----------------
// Check outward
// ----------------
AI_TraceLine ( posOnLadder,
origin,
MASK_NPCSOLID_BRUSHONLY,
NULL,
COLLISION_GROUP_NONE,
&trace );
// DevMsg( "to %f %f %f : %d %f", origin.x, origin.y, origin.z, trace.startsolid, trace.fraction );
if (!trace.startsolid && trace.fraction == 1.0)
{
float floorZ = GetFloorZ(origin); // FIXME: don't use this
if (abs(pNode->GetOrigin().z - floorZ) < 36)
{
CAI_Node *new_node = pNetwork->AddNode( pNode->GetOrigin(), pNode->m_flYaw );
new_node->m_pHint = NULL;
new_node->m_eNodeType = NODE_CLIMB;
new_node->m_eNodeInfo = pNode->m_eNodeInfo;
InitGroundNodePosition( pNetwork, new_node );
// copy over the offsets for the first CLIMB_OFF node
// FIXME: this method is broken for when the CLIMB_OFF nodes are at different heights
if (numExits == 0)
{
for (int hull = 0; hull < NUM_HULLS; hull++)
{
pNode->m_flVOffset[hull] = new_node->m_flVOffset[hull];
}
}
else
{
for (int hull = 0; hull < NUM_HULLS; hull++)
{
if (fabs(pNode->m_flVOffset[hull] - new_node->m_flVOffset[hull]) > 1)
{
DevMsg(2, "Warning: Climb Node %i has different exit heights for hull %s\n", pNode->m_iID, NAI_Hull::Name(hull));
}
}
}
numExits++;
}
}
// DevMsg( "\n");
}
if (numExits == 0)
{
DevMsg("ERROR: Climb Node %i has no way off\n",pNode->m_iID);
}
// this is a node that can't get gotten to directly
pNode->m_eNodeInfo = bits_NODE_CLIMB_ON;
}
//-----------------------------------------------------------------------------
// Purpose: Initializes position of the node sitting on the ground.
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitGroundNodePosition(CAI_Network *pNetwork, CAI_Node *pNode)
{
AI_PROFILE_SCOPE( CAI_Node_InitGroundNodePosition );
if ( pNode->m_eNodeInfo & bits_DONT_DROP )
return;
// find actual floor for each hull type
for (int hull = 0; hull < NUM_HULLS; hull++)
{
trace_t tr;
Vector origin = pNode->GetOrigin();
Vector mins, maxs;
// turn hull into pancake to avoid problems with ceiling
mins = NAI_Hull::Mins(hull);
maxs = NAI_Hull::Maxs(hull);
maxs.z = mins.z;
// Add an epsilon for cast
origin.z += 0.1;
// shift up so bottom of box is at center of node
origin.z -= mins.z;
AI_TraceHull( origin, origin + Vector( 0, 0, -384 ), mins, maxs, MASK_NPCSOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
if ( !tr.startsolid )
pNode->m_flVOffset[hull] = tr.endpos.z - pNode->GetOrigin().z + 0.1;
else
pNode->m_flVOffset[hull] = -mins.z + 0.1;
}
}
//-----------------------------------------------------------------------------
// Purpose: Initializes position of the node in the world. Only called if
// the network was never initialized
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitNodePosition(CAI_Network *pNetwork, CAI_Node *pNode)
{
AI_PROFILE_SCOPE( CAI_Node_InitNodePosition );
if (pNode->m_eNodeType == NODE_AIR)
{
return;
}
else if (pNode->m_eNodeType == NODE_CLIMB)
{
InitClimbNodePosition(pNetwork, pNode);
return;
}
// Otherwise mark as a land node and drop to the floor
else if (pNode->m_eNodeType == NODE_GROUND)
{
InitGroundNodePosition( pNetwork, pNode );
if (pNode->m_flVOffset[HULL_SMALL_CENTERED] < -100)
{
Assert( pNetwork == g_pBigAINet );
DevWarning("ERROR: Node %.0f %.0f %.0f, WC ID# %i, is either too low (fell through floor) or too high (>100 units above floor)\n",
pNode->GetOrigin().x, pNode->GetOrigin().y, pNode->GetOrigin().z,
g_pAINetworkManager->GetEditOps()->m_pNodeIndexTable[pNode->m_iID]);
pNode->m_eNodeInfo |= bits_NODE_FALLEN;
}
return;
}
/* // If under water, not that the node is in water <<TODO>> when we get water
else if ( UTIL_PointContents(GetOrigin()) & MASK_WATER )
{
m_eNodeType |= NODE_WATER;
}
*/
else if (pNode->m_eNodeType != NODE_DELETED)
{
DevMsg( "Bad node type!\n" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Set the visibility for this node. (What nodes it can see with a
// line trace)
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitVisibility(CAI_Network *pNetwork, CAI_Node *pNode)
{
AI_PROFILE_SCOPE( CAI_Node_InitVisibility );
// If a deleted node bail
if (pNode->m_eNodeType == NODE_DELETED)
{
return;
}
// The actual position of some nodes may be inside geometry as they have
// hull specific position offsets (e.g. climb nodes). Get the hull specific
// position using the smallest hull to make sure were not in geometry
Vector srcPos = pNode->GetPosition(HULL_SMALL_CENTERED);
// Check the visibility on every other node in the network
for (int testnode = 0; testnode < pNetwork->NumNodes(); testnode++ )
{
CAI_Node *testNode = pNetwork->GetNode( testnode );
if ( DebuggingConnect( pNode->m_iID, testnode ) )
{
DevMsg( " " ); // break here..
}
// We know we can view ourself
if (pNode->m_iID == testnode)
{
m_NeighborsTable[pNode->m_iID].Set(testNode->m_iID);
continue;
}
// Remove duplicate nodes unless a climb node as they move
if (testNode->GetOrigin() == pNode->GetOrigin() && testNode->GetType() != NODE_CLIMB)
{
testNode->SetType( NODE_DELETED );
DevMsg( 2, "Probable duplicate node placed at %s\n", VecToString(testNode->GetOrigin()) );
continue;
}
// If a deleted node we don't care about it
if (testNode->GetType() == NODE_DELETED)
{
continue;
}
if ( m_DidSetNeighborsTable.IsBitSet( testNode->m_iID ) )
{
if ( m_NeighborsTable[testNode->m_iID].IsBitSet(pNode->m_iID))
m_NeighborsTable[pNode->m_iID].Set(testNode->m_iID);
continue;
}
float flDistToCheckNode = ( testNode->GetOrigin() - pNode->GetOrigin() ).LengthSqr();
if ( testNode->GetType() == NODE_AIR )
{
if (flDistToCheckNode > MAX_AIR_NODE_LINK_DIST_SQ)
continue;
}
else
{
if (flDistToCheckNode > MAX_NODE_LINK_DIST_SQ)
continue;
}
// The actual position of some nodes may be inside geometry as they have
// hull specific position offsets (e.g. climb nodes). Get the hull specific
// position using the smallest hull to make sure were not in geometry
Vector destPos = pNetwork->GetNode( testnode )->GetPosition(HULL_SMALL_CENTERED);
trace_t tr;
tr.m_pEnt = NULL;
// Try several line of sight checks
bool isVisible = false;
// ------------------
// Bottom to bottom
// ------------------
AI_TraceLine ( srcPos, destPos,MASK_NPCWORLDSTATIC,NULL,COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
isVisible = true;
}
// ------------------
// Top to top
// ------------------
if (!isVisible)
{
AI_TraceLine ( srcPos + Vector( 0, 0, 70 ),destPos + Vector( 0, 0, 70 ),MASK_NPCWORLDSTATIC,NULL,COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
isVisible = true;
}
}
// ------------------
// Top to Bottom
// ------------------
if (!isVisible)
{
AI_TraceLine ( srcPos + Vector( 0, 0, 70 ),destPos,MASK_NPCWORLDSTATIC,NULL,COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
isVisible = true;
}
}
// ------------------
// Bottom to Top
// ------------------
if (!isVisible)
{
AI_TraceLine ( srcPos,destPos + Vector( 0, 0, 70 ),MASK_NPCWORLDSTATIC,NULL,COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
isVisible = true;
}
}
// ------------------
// Failure
// ------------------
if (!isVisible)
{
continue;
}
/* <<TODO>> may not apply with editable connections.......
// trace hit a brush ent, trace backwards to make sure that this ent is the only thing in the way.
if ( tr.fraction != 1.0 )
{
pTraceEnt = tr.u.ent;// store the ent that the trace hit, for comparison
AI_TraceLine ( srcPos,
destPos,
MASK_NPCSOLID_BRUSHONLY,
NULL,
&tr );
// there is a solid_bsp ent in the way of these two nodes, so we must record several things about in order to keep
// track of it in the pathfinding code, as well as through save and restore of the node graph. ANY data that is manipulated
// as part of the process of adding a LINKENT to a connection here must also be done in CGraph::SetGraphPointers, where reloaded
// graphs are prepared for use.
if ( tr.u.ent == pTraceEnt && !FClassnameIs( tr.u.ent, "worldspawn" ) )
{
// get a pointer
pLinkPool [ cTotalLinks ].m_pLinkEnt = tr.u.ent;
// record the modelname, so that we can save/load node trees
memcpy( pLinkPool [ cTotalLinks ].m_szLinkEntModelname, STRING( tr.u.ent->model ), 4 );
// set the flag for this ent that indicates that it is attached to the world graph
// if this ent is removed from the world, it must also be removed from the connections
// that it formerly blocked.
CBaseEntity *e = CBaseEntity::Instance( tr.u.ent );
if ( e )
{
if ( !(e->GetFlags() & FL_GRAPHED ) )
{
e->AddFlag( FL_GRAPHED );
}
}
}
// even if the ent wasn't there, these nodes couldn't be connected. Skip.
else
{
continue;
}
}
*/
m_NeighborsTable[pNode->m_iID].Set(testNode->m_iID);
}
}
//-----------------------------------------------------------------------------
// Purpose: Initializes the neighbors list
// Input :
// Output :
//-----------------------------------------------------------------------------
void CAI_NetworkBuilder::InitNeighbors(CAI_Network *pNetwork, CAI_Node *pNode)
{
m_NeighborsTable[pNode->m_iID].ClearAll();
// Begin by establishing viewability to limit the number of nodes tested
InitVisibility( pNetwork, pNode );
AI_PROFILE_SCOPE_BEGIN( CAI_Node_InitNeighbors );
// Now check each neighbor against all other neighbors to see if one of
// them is a redundant connection
for (int checknode = 0; checknode < pNetwork->NumNodes(); checknode++ )
{
if ( DebuggingConnect( pNode->m_iID, checknode ) )
{
DevMsg( " " ); // break here..
}
// I'm not a neighbor of myself
if ( pNode->m_iID == checknode )
{
m_NeighborsTable[pNode->m_iID].Clear(checknode);
continue;
}
// Only check if already on the neightbor list
if (!m_NeighborsTable[pNode->m_iID].IsBitSet(checknode))
{
continue;
}
CAI_Node *pCheckNode = pNetwork->GetNode(checknode);
for (int testnode = 0; testnode < pNetwork->NumNodes(); testnode++ )
{
// don't check against itself
if (( testnode == checknode ) || (testnode == pNode->m_iID))
{
continue;
}
// Only check if already on the neightbor list
if (!m_NeighborsTable[pNode->m_iID].IsBitSet(testnode))
{
continue;
}
CAI_Node *pTestNode = pNetwork->GetNode(testnode);
// ----------------------------------------------------------
// Don't check air nodes against nodes of a different types
// ----------------------------------------------------------
if ((pCheckNode->GetType() == NODE_AIR && pTestNode->GetType() != NODE_AIR)||
(pCheckNode->GetType() != NODE_AIR && pTestNode->GetType() == NODE_AIR))
{
continue;
}
// ----------------------------------------------------------
// If climb node pairs, don't consider redundancy
// ----------------------------------------------------------
if (pNode->GetType() == NODE_CLIMB &&
(pCheckNode->GetType() == NODE_CLIMB || pTestNode->GetType() == NODE_CLIMB))
{
continue;
}
// ----------------------------------------------------------
// If a climb node mounting point is involved, don't consider redundancy
// ----------------------------------------------------------
if ( ( pCheckNode->GetOrigin() == pNode->GetOrigin() && pNode->GetType() == NODE_CLIMB && pCheckNode->GetType() == NODE_CLIMB ) ||
( pTestNode->GetOrigin() == pNode->GetOrigin() && pNode->GetType() == NODE_CLIMB && pTestNode->GetType() == NODE_CLIMB ) ||
( pTestNode->GetOrigin() == pCheckNode->GetOrigin() && pCheckNode->GetType() == NODE_CLIMB && pTestNode->GetType() == NODE_CLIMB ) )
{
continue;
}
// @HACKHACK (toml 02-25-04): Ignore redundancy if both nodes are air nodes with
// hint type "strider node". Really, really should do this in a clean manner
bool nodeIsStrider = ( pNode->GetHint() && pNode->GetHint()->HintType() == HINT_STRIDER_NODE );
bool other1IsStrider = ( pCheckNode->GetHint() && pCheckNode->GetHint()->HintType() == HINT_STRIDER_NODE );
bool other2IsStrider = ( pTestNode->GetHint() && pTestNode->GetHint()->HintType() == HINT_STRIDER_NODE );
if ( nodeIsStrider && other1IsStrider != other2IsStrider )
{
continue;
}
Vector vec2DirToCheckNode = pCheckNode->GetOrigin() - pNode->GetOrigin();
float flDistToCheckNode = VectorNormalize( vec2DirToCheckNode );
Vector vec2DirToTestNode = ( pTestNode->GetOrigin() - pNode->GetOrigin() );
float flDistToTestNode = VectorNormalize( vec2DirToTestNode );
float tolerance = 0.92388; // 45 degrees
if ( DotProduct ( vec2DirToCheckNode, vec2DirToTestNode ) >= tolerance )
{
if ( flDistToTestNode < flDistToCheckNode )
{
DebugConnectMsg( pNode->m_iID, checknode, " Revoking neighbor status to to closer redundant link %d\n", testnode );
m_NeighborsTable[pNode->m_iID].Clear(checknode);
}
else
{
DebugConnectMsg( pNode->m_iID, testnode, " Revoking neighbor status to to closer redundant link %d\n", checknode );
m_NeighborsTable[pNode->m_iID].Clear(testnode);
}
}
}
}
AI_PROFILE_SCOPE_END();
m_DidSetNeighborsTable.Set(pNode->m_iID);
}
//-----------------------------------------------------------------------------
// Purpose: For the current node, check its connection to all other nodes
// Input :
// Output :
//-----------------------------------------------------------------------------
static bool IsInLineForClimb( const Vector &srcPos, const Vector &srcFacing, const Vector &destPos, const Vector &destFacing )
{
#ifdef DEBUG
Vector normSrcFacing( srcFacing ), normDestFacing( destFacing );
VectorNormalize( normSrcFacing );
VectorNormalize( normDestFacing );
Assert( VectorsAreEqual( srcFacing, normSrcFacing, 0.01 ) && VectorsAreEqual( destFacing, normDestFacing, 0.01 ) );
#endif
// If they are not facing the same way...
if ( 1 - srcFacing.Dot( destFacing ) > 0.01 )
return false;
// If they aren't in line along the facing...
if ( CalcDistanceToLine2D( destPos.AsVector2D(), srcPos.AsVector2D(), srcPos.AsVector2D() + srcFacing.AsVector2D() ) > 0.01 )
return false;
// Check that the angle between them is either staight up, or on at angle of ladder-stairs
Vector vecDelta = srcPos - destPos;
VectorNormalize( vecDelta );
float fabsCos = fabs( srcFacing.Dot( vecDelta ) );
const float CosAngLadderStairs = 0.4472; // rise 2 & run 1
if ( fabsCos > 0.05 && fabs( fabsCos - CosAngLadderStairs ) > 0.05 )
return false;
// *************************** --------------------------------
return true;
}
//-------------------------------------
int CAI_NetworkBuilder::ComputeConnection( CAI_Node *pSrcNode, CAI_Node *pDestNode, Hull_t hull )
{
int srcId = pSrcNode->m_iID;
int destId = pDestNode->m_iID;
int result = 0;
trace_t tr;
// Set the size of the test hull
if ( m_pTestHull->GetHullType() != hull )
{
m_pTestHull->SetHullType( hull );
m_pTestHull->SetHullSizeNormal( true );
}
if ( !( m_pTestHull->GetFlags() & FL_ONGROUND ) )
{
DevWarning( 2, "OFFGROUND!\n" );
}
m_pTestHull->AddFlag( FL_ONGROUND );
// ==============================================================
// FIRST CHECK IF HULL CAN EVEN FIT AT THESE NODES
// ==============================================================
// @Note (toml 02-10-03): this should be optimized, caching the results of CanFitAtNode()
if ( !( pSrcNode->m_eNodeInfo & ( HullToBit( hull ) << NODE_ENT_FLAGS_SHIFT ) ) &&
!m_pTestHull->GetNavigator()->CanFitAtNode(srcId,MASK_NPCWORLDSTATIC) )
{
DebugConnectMsg( srcId, destId, " Cannot fit at node %d\n", srcId );
return 0;
}
if ( !( pDestNode->m_eNodeInfo & ( HullToBit( hull ) << NODE_ENT_FLAGS_SHIFT ) ) &&
!m_pTestHull->GetNavigator()->CanFitAtNode(destId,MASK_NPCWORLDSTATIC) )
{
DebugConnectMsg( srcId, destId, " Cannot fit at node %d\n", destId );
return 0;
}
// ==============================================================
// AIR NODES (FLYING)
// ==============================================================
if (pSrcNode->m_eNodeType == NODE_AIR || pDestNode->GetType() == NODE_AIR)
{
AI_PROFILE_SCOPE( CAI_Node_InitLinks_Air );
// Air nodes only connect to other air nodes and nothing else
if (pSrcNode->m_eNodeType == NODE_AIR && pDestNode->GetType() == NODE_AIR)
{
AI_TraceHull( pSrcNode->GetOrigin(), pDestNode->GetOrigin(), NAI_Hull::Mins(hull),NAI_Hull::Maxs(hull), MASK_NPCWORLDSTATIC, m_pTestHull, COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
result |= bits_CAP_MOVE_FLY;
DebugConnectMsg( srcId, destId, " Connect by flying\n" );
}
}
}
// =============================================================================
// > CLIMBING
// =============================================================================
// If both are climb nodes just make sure they are above each other
// and there is room for the hull to pass between them
else if ((pSrcNode->m_eNodeType == NODE_CLIMB) && (pDestNode->GetType() == NODE_CLIMB))
{
AI_PROFILE_SCOPE( CAI_Node_InitLinks_Climb );
Vector srcPos = pSrcNode->GetPosition(hull);
Vector destPos = pDestNode->GetPosition(hull);
// If a code genereted climb dismount node the two origins will be the same
if (pSrcNode->GetOrigin() == pDestNode->GetOrigin())
{
AI_TraceHull( srcPos, destPos,
NAI_Hull::Mins(hull),NAI_Hull::Maxs(hull),
MASK_NPCWORLDSTATIC, m_pTestHull, COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
result |= bits_CAP_MOVE_CLIMB;
DebugConnectMsg( srcId, destId, " Connect by climbing\n" );
}
}
else
{
if ( !IsInLineForClimb(srcPos, UTIL_YawToVector( pSrcNode->m_flYaw ), destPos, UTIL_YawToVector( pDestNode->m_flYaw ) ) )
{
Assert( !IsInLineForClimb(destPos, UTIL_YawToVector( pDestNode->m_flYaw ), srcPos, UTIL_YawToVector( pSrcNode->m_flYaw ) ) );
DebugConnectMsg( srcId, destId, " Not lined up for proper climbing\n" );
return 0;
}
AI_TraceHull( srcPos, destPos, NAI_Hull::Mins(hull),NAI_Hull::Maxs(hull), MASK_NPCWORLDSTATIC, m_pTestHull, COLLISION_GROUP_NONE, &tr );
if (!tr.startsolid && tr.fraction == 1.0)
{
result |= bits_CAP_MOVE_CLIMB;
DebugConnectMsg( srcId, destId, " Connect by climbing\n" );
}
}
}
// ====================================================
// > TWO LAND NODES
// =====================================================
else if ((pSrcNode->m_eNodeType == NODE_GROUND) || (pDestNode->GetType() == NODE_GROUND))
{
// BUG: this could use GroundMoveLimit, except there's no version of world but not brushes (doors open, etc).
// ====================================================
// > WALKING : walk the space between the nodes
// =====================================================
// in this loop we take tiny steps from the current node to the nodes that it links to, one at a time.
bool fStandFailed = false;
bool fWalkFailed = true;
AI_PROFILE_SCOPE_BEGIN( CAI_Node_InitLinks_Ground );
Vector srcPos = pSrcNode->GetPosition(hull);
Vector destPos = pDestNode->GetPosition(hull);
if (!m_pTestHull->GetMoveProbe()->CheckStandPosition( srcPos, MASK_NPCWORLDSTATIC))
{
DebugConnectMsg( srcId, destId, " Failed to stand at %d\n", srcId );
fStandFailed = true;
}
if (!m_pTestHull->GetMoveProbe()->CheckStandPosition( destPos, MASK_NPCWORLDSTATIC))
{
DebugConnectMsg( srcId, destId, " Failed to stand at %d\n", destId );
fStandFailed = true;
}
//if (hull == 0)
// DevMsg("from %.1f %.1f %.1f to %.1f %.1f %.1f\n", srcPos.x, srcPos.y, srcPos.z, destPos.x, destPos.y, destPos.z );
if ( !fStandFailed )
{
fWalkFailed = !m_pTestHull->GetMoveProbe()->TestGroundMove( srcPos, destPos, MASK_NPCWORLDSTATIC, AITGM_IGNORE_INITIAL_STAND_POS, NULL );
if ( fWalkFailed )
DebugConnectMsg( srcId, destId, " Failed to walk between nodes\n" );
}
// Add to our list of accepable hulls
if (!fWalkFailed && !fStandFailed)
{
result |= bits_CAP_MOVE_GROUND;
DebugConnectMsg( srcId, destId, " Nodes connect for ground movement\n" );
}
AI_PROFILE_SCOPE_END();
// =============================================================================
// > JUMPING : jump the space between the nodes, but only if walk failed
// =============================================================================
if (!fStandFailed && fWalkFailed && (pSrcNode->m_eNodeType == NODE_GROUND) && (pDestNode->GetType() == NODE_GROUND))
{
AI_PROFILE_SCOPE( CAI_Node_InitLinks_Jump );
Vector srcPos = pSrcNode->GetPosition(hull);
Vector destPos = pDestNode->GetPosition(hull);
// Jumps aren't bi-directional. We can jump down further than we can jump up so
// we have to test for either one
bool canDestJump = m_pTestHull->IsJumpLegal(srcPos, destPos, destPos);
bool canSrcJump = m_pTestHull->IsJumpLegal(destPos, srcPos, srcPos);
if (canDestJump || canSrcJump)
{
CAI_MoveProbe *pMoveProbe = m_pTestHull->GetMoveProbe();
bool fJumpLegal = false;
m_pTestHull->SetGravity(1.0);
AIMoveTrace_t moveTrace;
pMoveProbe->MoveLimit( NAV_JUMP, srcPos,destPos, MASK_NPCWORLDSTATIC, NULL, &moveTrace);
if (!IsMoveBlocked(moveTrace))
{
fJumpLegal = true;
}
pMoveProbe->MoveLimit( NAV_JUMP, destPos,srcPos, MASK_NPCWORLDSTATIC, NULL, &moveTrace);
if (!IsMoveBlocked(moveTrace))
{
fJumpLegal = true;
}
// Add to our list of accepable hulls
if (fJumpLegal)
{
result |= bits_CAP_MOVE_JUMP;
DebugConnectMsg( srcId, destId, " Nodes connect for jumping\n" );
}
}
}
}
return result;
}
//-------------------------------------
void CAI_NetworkBuilder::InitLinks(CAI_Network *pNetwork, CAI_Node *pNode)
{
AI_PROFILE_SCOPE( CAI_Node_InitLinks );
// -----------------------------------------------------
// Get test hull
// -----------------------------------------------------
m_pTestHull->GetNavigator()->SetNetwork( pNetwork );
// -----------------------------------------------------
// Initialize links to every node
// -----------------------------------------------------
for (int i = 0; i < pNetwork->NumNodes(); i++ )
{
// -------------------------------------------------
// Check for redundant link building
// -------------------------------------------------
DebugConnectMsg( pNode->m_iID, i, "Testing connection between %d and %d:\n", pNode->m_iID, i );
if (pNode->HasLink(i))
{
// A link has been already created when the other node was processed...
DebugConnectMsg( pNode->m_iID, i, " Nodes already connected\n" );
continue;
}
// ---------------------------------------------------------------------
// If link has been already created in other node just share it
// ---------------------------------------------------------------------
CAI_Node *pDestNode = pNetwork->GetNode( i );
CAI_Link *pOldLink = pDestNode->HasLink(pNode->m_iID);
if (pOldLink)
{
DebugConnectMsg( pNode->m_iID, i, " Sharing previously establish connection\n" );
((CAI_Node *)pNode)->AddLink(pOldLink);
continue;
}
// Only check if the node is a neighbor
if ( m_NeighborsTable[pNode->m_iID].IsBitSet(pDestNode->m_iID) )
{
int acceptedMotions[NUM_HULLS];
bool bAllFailed = true;
if ( DebuggingConnect( pNode->m_iID, i ) )
{
DevMsg( " " ); // break here..
}
if ( !(pNode->m_eNodeInfo & bits_NODE_FALLEN) && !(pDestNode->m_eNodeInfo & bits_NODE_FALLEN) )
{
for (int hull = 0 ; hull < NUM_HULLS; hull++ )
{
DebugConnectMsg( pNode->m_iID, i, " Testing for hull %s\n", NAI_Hull::Name( (Hull_t)hull ) );
acceptedMotions[hull] = ComputeConnection( pNode, pDestNode, (Hull_t)hull );
if ( acceptedMotions[hull] != 0 )
bAllFailed = false;
}
}
else
DebugConnectMsg( pNode->m_iID, i, " No connection: one or both are fallen nodes\n" );
// If there were any passible hulls create link
if (!bAllFailed)
{
CAI_Link *pLink = pNetwork->CreateLink( pNode->m_iID, pDestNode->m_iID);
if ( pLink )
{
for (int hull=0;hull<NUM_HULLS;hull++)
{
pLink->m_iAcceptedMoveTypes[hull] = acceptedMotions[hull];
}
DebugConnectMsg( pNode->m_iID, i, " Added link\n" );
}
}
else
{
m_NeighborsTable[pNode->m_iID].Clear(pDestNode->m_iID);
DebugConnectMsg(pNode->m_iID, i, " NO LINK\n" );
}
}
else
DebugConnectMsg( pNode->m_iID, i, " NO LINK (not neighbors)\n" );
}
}
//-----------------------------------------------------------------------------
View Git Blame Copy Permalink