mirror of
https://github.com/Mauler125/r5sdk.git
synced 2025-02-09 19:15:03 +01:00
f081fe6f67
The AIN dumper is now finished. Giving it a valid r1 AIN will make it spit out an identical AIN (minus the CRC header, but this is intended).
514 lines
17 KiB
C++
514 lines
17 KiB
C++
//=============================================================================//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "core/stdafx.h"
|
|
#include "tier0/fasttimer.h"
|
|
#include "tier1/cvar.h"
|
|
#include "tier1/cmd.h"
|
|
#include "mathlib/crc32.h"
|
|
#include "public/edict.h"
|
|
#include "filesystem/filesystem.h"
|
|
#include "game/server/ai_node.h"
|
|
#include "game/server/ai_network.h"
|
|
#include "game/server/ai_networkmanager.h"
|
|
#include <public/worldsize.h>
|
|
|
|
constexpr int AINET_SCRIPT_VERSION_NUMBER = 21;
|
|
constexpr int AINET_VERSION_NUMBER = 57;
|
|
constexpr int AINET_HEADER_SIZE = 16;
|
|
constexpr const char* AINETWORK_EXT = ".ain";
|
|
constexpr const char* AINETWORK_PATH = "maps/graphs/";
|
|
|
|
/*
|
|
==============================
|
|
CAI_NetworkBuilder::BuildFile
|
|
|
|
Build AI node graph file from
|
|
in-memory structures and write
|
|
to disk to be loaded
|
|
==============================
|
|
*/
|
|
void CAI_NetworkBuilder::SaveNetworkGraph(CAI_Network* pNetwork)
|
|
{
|
|
char szMeshPath[MAX_PATH];
|
|
char szGraphPath[MAX_PATH];
|
|
|
|
V_snprintf(szMeshPath, sizeof(szMeshPath), "%s%s_%s%s", NAVMESH_PATH, g_ServerGlobalVariables->m_pszMapName, S_HULL_TYPE[E_HULL_TYPE::LARGE], NAVMESH_EXT);
|
|
V_snprintf(szGraphPath, sizeof(szGraphPath), "%s%s%s", AINETWORK_PATH, g_ServerGlobalVariables->m_pszMapName, AINETWORK_EXT);
|
|
|
|
CFastTimer masterTimer;
|
|
CFastTimer timer;
|
|
|
|
// Build from memory.
|
|
Msg(eDLL_T::SERVER, "++++--------------------------------------------------------------------------------------------------------------------------++++\n");
|
|
Msg(eDLL_T::SERVER, ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AI NETWORK GRAPH FILE CONSTRUCTION STARTED <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
|
|
Msg(eDLL_T::SERVER, "++++--------------------------------------------------------------------------------------------------------------------------++++\n");
|
|
|
|
masterTimer.Start();
|
|
timer.Start();
|
|
|
|
FileSystem()->CreateDirHierarchy(AINETWORK_PATH, "GAME");
|
|
FileHandle_t pAIGraph = FileSystem()->Open(szGraphPath, "wb", "GAME");
|
|
if (!pAIGraph)
|
|
{
|
|
Error(eDLL_T::SERVER, NO_ERROR, "%s - Unable to write to '%s' (read-only?)\n", __FUNCTION__, szGraphPath);
|
|
return;
|
|
}
|
|
|
|
DevMsg(eDLL_T::SERVER, "+- Writing header...\n");
|
|
|
|
FileHandle_t pNavMesh = FileSystem()->Open(szMeshPath, "rb", "GAME");
|
|
uint32_t nNavMeshCRC = NULL;
|
|
|
|
if (!pNavMesh)
|
|
{
|
|
Warning(eDLL_T::SERVER, "%s - No %s NavMesh found. Unable to calculate CRC for AI Network\n",
|
|
__FUNCTION__, S_HULL_TYPE[E_HULL_TYPE::LARGE]);
|
|
}
|
|
else
|
|
{
|
|
const ssize_t nLen = FileSystem()->Size(pNavMesh);
|
|
std::unique_ptr<uint8_t[]> pBuf(new uint8_t[nLen]);
|
|
|
|
FileSystem()->Read(pBuf.get(), nLen, pNavMesh);
|
|
FileSystem()->Close(pNavMesh);
|
|
|
|
nNavMeshCRC = crc32::update(NULL, pBuf.get(), nLen);
|
|
}
|
|
|
|
// Large NavMesh CRC.
|
|
DevMsg(eDLL_T::SERVER, " |-- AINet version: '%d'\n", AINET_VERSION_NUMBER);
|
|
DevMsg(eDLL_T::SERVER, " |-- Map version: '%d'\n", g_ServerGlobalVariables->m_nMapVersion);
|
|
DevMsg(eDLL_T::SERVER, " |-- NavMesh CRC: '0x%lX'\n", nNavMeshCRC);
|
|
|
|
CUtlBuffer buf;
|
|
|
|
// ---------------------------
|
|
// Save the version numbers
|
|
// ---------------------------
|
|
buf.PutInt(AINET_VERSION_NUMBER);
|
|
buf.PutInt(g_ServerGlobalVariables->m_nMapVersion);
|
|
buf.PutInt(nNavMeshCRC);
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing header. %lf seconds\n", timer.GetDuration().GetSeconds());
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing path nodes...\n");
|
|
|
|
// -------------------------------
|
|
// Dump all the nodes to the file
|
|
// -------------------------------
|
|
buf.PutInt(pNetwork->NumPathNodes());
|
|
int totalNumLinks = 0;
|
|
|
|
for (int node = 0; node < pNetwork->NumPathNodes(); node++)
|
|
{
|
|
const CAI_Node* aiNode = pNetwork->GetPathNode(node);
|
|
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing node '#%d' at '0x%zX'\n", aiNode->m_iID, buf.TellPut());
|
|
|
|
buf.Put(&aiNode->m_vOrigin, sizeof(Vector3D));
|
|
buf.PutFloat(aiNode->GetYaw());
|
|
buf.Put(&aiNode->m_flVOffset, sizeof(aiNode->m_flVOffset));
|
|
buf.PutChar((char)aiNode->GetType());
|
|
buf.PutInt(aiNode->GetInfo());
|
|
|
|
for (int j = 0; j < MAX_HULLS; j++)
|
|
{
|
|
buf.PutShort((short)aiNode->unk2[j]);
|
|
}
|
|
|
|
buf.Put(&aiNode->unk3, sizeof(aiNode->unk3));
|
|
buf.PutShort(aiNode->unk6);
|
|
buf.PutShort(aiNode->unk9); // Always -1;
|
|
buf.Put(&aiNode->unk11, sizeof(aiNode->unk11));
|
|
|
|
totalNumLinks += aiNode->NumLinks();
|
|
}
|
|
|
|
pNetwork->m_iNumLinks = totalNumLinks;
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing path nodes. %lf seconds (%d nodes)\n", timer.GetDuration().GetSeconds(), pNetwork->m_iNumNodes);
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing node links...\n");
|
|
DevMsg(eDLL_T::SERVER, " |-- Cached node link count: '%d'\n", totalNumLinks);
|
|
|
|
// -------------------------------
|
|
// Dump all the links to the file
|
|
// -------------------------------
|
|
int packedLinks = totalNumLinks / 2;
|
|
buf.PutInt(packedLinks);
|
|
|
|
for (int node = 0; node < pNetwork->NumPathNodes(); node++)
|
|
{
|
|
const CAI_Node* aiNode = pNetwork->GetPathNode(node);
|
|
|
|
for (int link = 0; link < aiNode->NumLinks(); link++)
|
|
{
|
|
const CAI_NodeLink* nodeLink = aiNode->GetLinkByIndex(link);
|
|
|
|
// Skip links that don't originate from current node.
|
|
if (nodeLink->m_iSrcID == aiNode->m_iID)
|
|
{
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing link (%hd <--> %hd) at '0x%zX'\n", nodeLink->m_iSrcID, nodeLink->m_iDestID, buf.TellPut());
|
|
|
|
buf.PutShort(nodeLink->m_iSrcID);
|
|
buf.PutShort(nodeLink->m_iDestID);
|
|
|
|
buf.PutChar(nodeLink->unk1);
|
|
buf.Put(nodeLink->m_iAcceptedMoveTypes, sizeof(nodeLink->m_iAcceptedMoveTypes));
|
|
}
|
|
}
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing node links. %lf seconds (%d links)\n", timer.GetDuration().GetSeconds(), pNetwork->m_iNumLinks);
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing WC lookup table...\n");
|
|
|
|
// -------------------------------
|
|
// Dump WC lookup table
|
|
// -------------------------------
|
|
CUtlMap<int, int> wcIDs;
|
|
SetDefLessFunc(wcIDs);
|
|
bool bCheckForProblems = false;
|
|
|
|
const CAI_NetworkEditTools* const pEditOps = (*g_ppAINetworkManager)->GetEditOps();
|
|
|
|
for (int node = 0; node < pNetwork->m_iNumNodes; node++)
|
|
{
|
|
const int nIndex = pEditOps->m_pNodeIndexTable[node];
|
|
const int iPreviousNodeBinding = wcIDs.Find(nIndex);
|
|
|
|
if (iPreviousNodeBinding != wcIDs.InvalidIndex())
|
|
{
|
|
if (!bCheckForProblems)
|
|
{
|
|
DevWarning(eDLL_T::SERVER, "******* MAP CONTAINS DUPLICATE HAMMER NODE IDS! CHECK FOR PROBLEMS IN HAMMER TO CORRECT *******\n");
|
|
bCheckForProblems = true;
|
|
}
|
|
DevWarning(eDLL_T::SERVER, " AI node %d is associated with Hammer node %d, but %d is already bound to node %d\n",
|
|
node, nIndex, nIndex, wcIDs[(unsigned short)nIndex]);
|
|
}
|
|
else
|
|
{
|
|
wcIDs.Insert(nIndex, node);
|
|
}
|
|
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing Hammer node (%d <--> %d) at '0x%zX'\n", nIndex, wcIDs.Element((unsigned short)nIndex), buf.TellPut());
|
|
buf.PutInt(nIndex);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing hammer nodes. %lf seconds (%d indices)\n", timer.GetDuration().GetSeconds(), wcIDs.Count());
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing traverse ex nodes...\n");
|
|
|
|
// -------------------------------
|
|
// Dump traverse ex nodes
|
|
// -------------------------------
|
|
const int traverseExNodeCount = g_pAITraverseNodes->Count();
|
|
buf.PutShort((short)traverseExNodeCount);
|
|
|
|
FOR_EACH_VEC(*g_pAITraverseNodes, i)
|
|
{
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing traverse ex node '%d' at '0x%zX'\n", i, buf.TellPut());
|
|
|
|
const CAI_TraverseNode& traverseExNode = (*g_pAITraverseNodes)[i];
|
|
buf.Put(&traverseExNode.m_Quat, sizeof(Quaternion));
|
|
buf.PutInt(traverseExNode.m_Index_MAYBE);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing traverse ex nodes. %lf seconds (%d nodes)\n", timer.GetDuration().GetSeconds(), traverseExNodeCount);
|
|
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing hull data blocks...\n");
|
|
|
|
// -------------------------------
|
|
// Dump hull data blocks
|
|
// -------------------------------
|
|
|
|
// Pointer to numZones counter, incremented up and until
|
|
// the last counter field for the hull data block.
|
|
int* countPtr = &pNetwork->m_iNumZones;
|
|
|
|
for (int i = 0; i < MAX_HULLS; i++, countPtr++)
|
|
{
|
|
const CAI_HullData& hullData = pNetwork->m_HullData[i];
|
|
const int bufferSize = sizeof(int) * hullData.unk1;
|
|
|
|
buf.PutInt(*countPtr);
|
|
buf.PutShort(hullData.m_Count);
|
|
buf.PutShort(hullData.unk1);
|
|
buf.Put(hullData.pBuffer, bufferSize);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing hull data blocks. %lf seconds (%d blocks)\n", timer.GetDuration().GetSeconds(), MAX_HULLS);
|
|
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing path clusters...\n");
|
|
|
|
// -------------------------------
|
|
// Dump path clusters
|
|
// -------------------------------
|
|
const int numClusters = g_pAIPathClusters->Count();
|
|
buf.PutInt(numClusters);
|
|
|
|
FOR_EACH_VEC(*g_pAIPathClusters, i)
|
|
{
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing cluster '#%d' at '0x%zX'\n", i, buf.TellPut());
|
|
|
|
const CAI_Cluster* pathClusters = (*g_pAIPathClusters)[i];
|
|
|
|
buf.PutInt(pathClusters->m_nIndex);
|
|
buf.PutChar(pathClusters->unk1);
|
|
|
|
buf.PutFloat(pathClusters->GetOrigin().x);
|
|
buf.PutFloat(pathClusters->GetOrigin().y);
|
|
buf.PutFloat(pathClusters->GetOrigin().z);
|
|
|
|
const int unkVec0Size = pathClusters->unkVec0.Count();
|
|
buf.PutInt(unkVec0Size);
|
|
|
|
FOR_EACH_VEC(pathClusters->unkVec0, j)
|
|
{
|
|
short unkShort = static_cast<short>(pathClusters->unkVec0[j]);
|
|
buf.PutShort(unkShort);
|
|
}
|
|
|
|
const int unkVec1Size = pathClusters->unkVec1.Count();
|
|
buf.PutInt(unkVec1Size);
|
|
|
|
FOR_EACH_VEC(pathClusters->unkVec1, j)
|
|
{
|
|
short unkShort = static_cast<short>(pathClusters->unkVec1[j]);
|
|
buf.PutShort(unkShort);
|
|
}
|
|
|
|
buf.PutChar(pathClusters->unk5);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing path clusters. %lf seconds (%d clusters)\n", timer.GetDuration().GetSeconds(), numClusters);
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing cluster links...\n");
|
|
|
|
// -------------------------------
|
|
// Dump cluster links
|
|
// -------------------------------
|
|
const int numClusterLinks = g_pAIClusterLinks->Count();
|
|
buf.PutInt(numClusterLinks);
|
|
|
|
FOR_EACH_VEC(*g_pAIClusterLinks, i)
|
|
{
|
|
// Disk and memory structs are literally identical here so just directly write.
|
|
const CAI_ClusterLink* clusterLink = (*g_pAIClusterLinks)[i];
|
|
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing link (%hd <--> %hd) at '0x%zX'\n", clusterLink->m_iSrcID, clusterLink->m_iDestID, buf.TellPut());
|
|
|
|
buf.PutShort(clusterLink->m_iSrcID);
|
|
buf.PutShort(clusterLink->m_iDestID);
|
|
|
|
buf.PutInt(clusterLink->unk2);
|
|
buf.PutChar(clusterLink->flags);
|
|
|
|
buf.PutChar(clusterLink->unkFlags4);
|
|
buf.PutChar(clusterLink->unkFlags5);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing cluster links. %lf seconds (%d links)\n", timer.GetDuration().GetSeconds(), numClusterLinks);
|
|
|
|
// This is always set to '-1'. Likely a field for maintaining compatibility.
|
|
buf.PutInt(pNetwork->unk5);
|
|
|
|
// AIN v57 and above only (not present in r1, static array in r2, pointer to dynamic array in r5).
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing script nodes...\n");
|
|
|
|
// -------------------------------
|
|
// Dump script nodes
|
|
// -------------------------------
|
|
const int numScriptNodes = pNetwork->m_iNumScriptNodes;
|
|
buf.PutInt(numScriptNodes);
|
|
|
|
for (int node = 0; node < numScriptNodes; node++)
|
|
{
|
|
// Disk and memory structs for script nodes are identical.
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing script node '#%d' at '0x%zX'\n", node, buf.TellPut());
|
|
buf.Put(&pNetwork->m_ScriptNode[node], sizeof(CAI_ScriptNode));
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing script nodes. %lf seconds (%d nodes)\n", timer.GetDuration().GetSeconds(), numScriptNodes);
|
|
|
|
timer.Start();
|
|
DevMsg(eDLL_T::SERVER, "+- Writing hint data...\n");
|
|
|
|
// -------------------------------
|
|
// Dump hint data
|
|
// -------------------------------
|
|
const int numHinst = pNetwork->m_iNumHints;
|
|
buf.PutInt(numHinst);
|
|
|
|
for (int hint = 0; hint < numHinst; hint++)
|
|
{
|
|
DevMsg(eDLL_T::SERVER, " |-- Writing hint data '#%d' at '0x%zX'\n", hint, buf.TellPut());
|
|
buf.PutShort(pNetwork->m_Hints[hint]);
|
|
}
|
|
|
|
timer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing hint data. %lf seconds (%d hints)\n", timer.GetDuration().GetSeconds(), numHinst);
|
|
|
|
FileSystem()->Write(buf.Base(), buf.TellPut(), pAIGraph);
|
|
FileSystem()->Close(pAIGraph);
|
|
|
|
masterTimer.End();
|
|
Msg(eDLL_T::SERVER, "...done writing AI node graph. %lf seconds\n", masterTimer.GetDuration().GetSeconds());
|
|
Msg(eDLL_T::SERVER, "++++--------------------------------------------------------------------------------------------------------------------------++++\n");
|
|
Msg(eDLL_T::SERVER, "++++--------------------------------------------------------------------------------------------------------------------------++++\n");
|
|
}
|
|
|
|
/*
|
|
==============================
|
|
CAI_NetworkManager::LoadNetworkGraph
|
|
|
|
Load network from the disk
|
|
and validate status
|
|
==============================
|
|
*/
|
|
void CAI_NetworkManager::LoadNetworkGraph(CAI_NetworkManager* pManager, CUtlBuffer* pBuffer, const char* szAIGraphFile)
|
|
{
|
|
bool bNavMeshAvailable = true;
|
|
|
|
char szMeshPath[MAX_PATH];
|
|
char szGraphPath[MAX_PATH];
|
|
|
|
V_snprintf(szMeshPath, sizeof(szMeshPath), "%s%s_%s%s", NAVMESH_PATH, g_ServerGlobalVariables->m_pszMapName, S_HULL_TYPE[E_HULL_TYPE::LARGE], NAVMESH_EXT);
|
|
V_snprintf(szGraphPath, sizeof(szGraphPath), "%s%s%s", AINETWORK_PATH, g_ServerGlobalVariables->m_pszMapName, AINETWORK_EXT);
|
|
|
|
int nAiNetVersion = NULL;
|
|
int nAiMapVersion = NULL;
|
|
|
|
uint32_t nAiGraphHash = NULL;
|
|
uint32_t nNavMeshHash = NULL;
|
|
|
|
FileHandle_t pNavMesh = FileSystem()->Open(szMeshPath, "rb", "GAME");
|
|
if (!pNavMesh)
|
|
{
|
|
Warning(eDLL_T::SERVER, "%s - No %s NavMesh found. Unable to calculate CRC for AI Network\n", __FUNCTION__, S_HULL_TYPE[E_HULL_TYPE::LARGE]);
|
|
bNavMeshAvailable = false;
|
|
}
|
|
else
|
|
{
|
|
const ssize_t nLen = FileSystem()->Size(pNavMesh);
|
|
std::unique_ptr<uint8_t[]> pBuf(new uint8_t[nLen]);
|
|
|
|
FileSystem()->Read(pBuf.get(), nLen, pNavMesh);
|
|
FileSystem()->Close(pNavMesh);
|
|
|
|
nNavMeshHash = crc32::update(NULL, pBuf.get(), nLen);
|
|
}
|
|
|
|
FileHandle_t pAIGraph = FileSystem()->Open(szGraphPath, "rb", "GAME");
|
|
if (!pAIGraph)
|
|
{
|
|
Error(eDLL_T::SERVER, NO_ERROR, "%s - Unable to open '%s' (insufficient rights?)\n", __FUNCTION__, szGraphPath);
|
|
LoadNetworkGraphEx(pManager, pBuffer, szAIGraphFile);
|
|
|
|
return;
|
|
}
|
|
|
|
if (FileSystem()->Size(pAIGraph) >= AINET_HEADER_SIZE)
|
|
{
|
|
FileSystem()->Read(&nAiNetVersion, sizeof(int), pAIGraph);
|
|
FileSystem()->Read(&nAiMapVersion, sizeof(int), pAIGraph);
|
|
FileSystem()->Read(&nAiGraphHash, sizeof(int), pAIGraph);
|
|
|
|
if (nAiNetVersion > AINET_VERSION_NUMBER)
|
|
{
|
|
Warning(eDLL_T::SERVER, "AI node graph '%s' is unsupported (net version: '%d' expected: '%d')\n",
|
|
szGraphPath, nAiNetVersion, AINET_VERSION_NUMBER);
|
|
}
|
|
else if (nAiMapVersion != g_ServerGlobalVariables->m_nMapVersion)
|
|
{
|
|
Warning(eDLL_T::SERVER, "AI node graph '%s' is out of date (map version: '%d' expected: '%d')\n",
|
|
szGraphPath, nAiMapVersion, g_ServerGlobalVariables->m_nMapVersion);
|
|
}
|
|
else if (bNavMeshAvailable && nAiGraphHash != nNavMeshHash)
|
|
{
|
|
Warning(eDLL_T::SERVER, "AI node graph '%s' is out of date (checksum: '%x' expected: '%x')\n",
|
|
szGraphPath, nAiGraphHash, nNavMeshHash);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Error(eDLL_T::SERVER, NO_ERROR, "%s - AI node graph '%s' is corrupt\n", __FUNCTION__, szGraphPath);
|
|
}
|
|
|
|
FileSystem()->Close(pAIGraph);
|
|
LoadNetworkGraphEx(pManager, pBuffer, szAIGraphFile);
|
|
}
|
|
|
|
/*
|
|
==============================
|
|
CAI_NetworkManager::LoadNetworkGraphEx
|
|
|
|
Load network
|
|
(internal)
|
|
==============================
|
|
*/
|
|
void CAI_NetworkManager::LoadNetworkGraphEx(CAI_NetworkManager* pManager, CUtlBuffer* pBuffer, const char* szAIGraphFile)
|
|
{
|
|
#if defined (GAMEDLL_S0) || defined (GAMEDLL_S1)
|
|
CAI_NetworkManager__LoadNetworkGraph(pManager, pBuffer, szAIGraphFile);
|
|
#elif defined (GAMEDLL_S2) || defined (GAMEDLL_S3)
|
|
CAI_NetworkManager__LoadNetworkGraph(pManager, pBuffer, szAIGraphFile);
|
|
#endif
|
|
|
|
if (ai_ainDumpOnLoad->GetBool())
|
|
{
|
|
Msg(eDLL_T::SERVER, "Dumping AI Network '%s'\n", szAIGraphFile);
|
|
CAI_NetworkBuilder::SaveNetworkGraph(pManager->m_pNetwork);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============================
|
|
CAI_NetworkBuilder::Build
|
|
|
|
builds network in-memory
|
|
during level load
|
|
==============================
|
|
*/
|
|
void CAI_NetworkBuilder::Build(CAI_NetworkBuilder* pBuilder, CAI_Network* pAINetwork)
|
|
{
|
|
CAI_NetworkBuilder__Build(pBuilder, pAINetwork);
|
|
CAI_NetworkBuilder::SaveNetworkGraph(pAINetwork);
|
|
}
|
|
|
|
void VAI_NetworkManager::Attach() const
|
|
{
|
|
DetourAttach((LPVOID*)&CAI_NetworkManager__LoadNetworkGraph, &CAI_NetworkManager::LoadNetworkGraph);
|
|
DetourAttach((LPVOID*)&CAI_NetworkBuilder__Build, &CAI_NetworkBuilder::Build);
|
|
}
|
|
|
|
void VAI_NetworkManager::Detach() const
|
|
{
|
|
DetourDetach((LPVOID*)&CAI_NetworkManager__LoadNetworkGraph, &CAI_NetworkManager::LoadNetworkGraph);
|
|
DetourDetach((LPVOID*)&CAI_NetworkBuilder__Build, &CAI_NetworkBuilder::Build);
|
|
}
|