added capability for bots to reuse paths stored in memory instead of constantly recomputing, causing significant performance impact

Author: Vortex-Quake2

src/ai/AStar.c

@@ -3,40 +3,43 @@
 #include "ai_local.h"
 
 //==========================================
-// 
-// 
+// Related data:
+// pLinks - links or connections between nodes loaded from file that are used for pathfinding (determining distance/cost between nodes)
+// nodes - data structures loaded from file that have map coordinates of nodes
 //==========================================
 
-static int	alist[MAX_NODES];	//list contains all studied nodes, Open and Closed together
-static int	alist_numNodes;
+static int	alist[MAX_NODES];	//list contains indexes (node numbers) of all studied nodes, Open and Closed together
+static int	alist_numNodes;		//number of nodes in list
 
 enum {
-	NOLIST,
-	OPENLIST,
-	CLOSEDLIST
+	NOLIST,		//unprocessed nodes to be added to OPENLIST
+	OPENLIST,	//nodes to explore and then move to CLOSEDLIST
+	CLOSEDLIST	//nodes explored--stop when end (target/destination) node is added
 };
 
 typedef struct
 {
-	int		parent;
-	int		G;
-	int		H;
+	int		parent;	//previous link in path chain (start<-end)
+	int		G;		//(pLink) distance between current node and the start node
+	int		H;		//heuristic - estimated distance from the current node to the end node
 
-	int		list;
+	int		list;	//which list node is currently in, i.e. NOLIST/OPENLIST/CLOSEDLIST
 
 } astarnode_t;
 
-astarnode_t	astarnodes[MAX_NODES];
+astarnode_t	astarnodes[MAX_NODES]; //working list of nodes being processed by A* algo
+
+// note: Apath is populated by AStar_ListsToPath and this is copied to (astarpath_t)path to determine the cost of path traversal via AI_FindCost
+static int Apath[MAX_NODES]; //array of node#s (node indexes) from start to end
+static int Apath_numNodes; //number of nodes in path
 
-static int Apath[MAX_NODES];
-static int Apath_numNodes;
 //==========================================
 // 
 // 
 //==========================================
-static int originNode;
-static int goalNode;
-static int currentNode;
+static int originNode; //starting node closest to origin of search and beginning of path
+static int goalNode; //ending node closest to destination
+static int currentNode; //current node being processed by A* algo
 
 int ValidLinksMask;
 #define DEFAULT_MOVETYPES_MASK (LINK_MOVE|LINK_STAIRS|LINK_FALL|LINK_WATER|LINK_WATERJUMP|LINK_JUMPPAD|LINK_PLATFORM|LINK_TELEPORT);
@@ -78,6 +81,11 @@ int	AStar_nodeIsInOpen( int node )
 	return 0;
 }
 
+//==========================================
+// Reset values of astarnodes, Apath, and alist
+// Moves all nodes to NOLIST
+// Run before a new path is generated
+//==========================================
 static void AStar_InitLists (void)
 {
 	int i;
@@ -224,14 +232,20 @@ static int AStar_FindInOpen_BestF ( void )
 			best = node;
 		}
 	}
-	//printf("BEST:%i\n", best);
+	//gi.dprintf("BEST:%i\n", best);
 	return best;
 }
 
+//==========================================
+// Called after A* path has been computed on astarnodes[]
+// Works backwards from end (goalNode) and copies parent node indices to Apath[]
+// Apath[] will then contain a list of node#s (indexes) for the path from start to end
+//==========================================
 static void AStar_ListsToPath ( void )
 {
 	int count = 0;
 	int cur = goalNode;
+	qboolean Spath_added = false;//GHz
 
 	while ( cur != originNode ) 
 	{
@@ -244,9 +258,91 @@ static void AStar_ListsToPath ( void )
 	{
 		Apath[count] = cur;
 		Apath_numNodes++;
+		//GHz
+		// save to list to speed up future searches
+		if (Spath_numNodes < MAX_SPATH)
+		{
+			Spath[Spath_numNodes].path[count] = cur;
+			Spath[Spath_numNodes].numNodes++;
+			Spath_added = true;
+		}
+		//GHz
 		count--;
 		cur = astarnodes[cur].parent;
 	}
+	//GHz
+	if (Spath_added)
+		Spath_numNodes++;
+	//GHz
+}
+
+// copies saved path (Spath.path) data to Apath
+// Spath_index is the index in Spath with the data you want copied to Apath
+// path_index_start is the starting index in Spath.path with the data you want copied
+// path_index_end is the ending index in Spath.path
+// path_index_start and path_index_end tell the function which subset of the path you want copied
+static void AStar_UseSavedPath(int Spath_index, int path_index_start, int path_index_end)
+{
+	int i, cur = 0, len = abs(path_index_end - path_index_start) + 1;
+
+	if (path_index_start > path_index_end)
+	{
+		// starting index is higher than ending index, so copy backwards from this index
+		cur = path_index_start;
+		for (i = 0;i < len;i++)
+		{
+			Apath[i] = Spath[Spath_index].path[cur];
+			Apath_numNodes++;
+			cur--;
+		}
+	}
+	else
+	{
+		cur = path_index_start;
+		for (i = 0;i < len;i++)
+		{
+			Apath[i] = Spath[Spath_index].path[cur];
+			Apath_numNodes++;
+			cur++;
+		}
+	}
+	//gi.dprintf("AStar_UseSavedPath\n");
+}
+
+// searches saved path array for a path that contains start and end nodes
+// if found, it copies the indexes to Apath and returns true
+static qboolean AStar_FindSavedPath(int start_node, int end_node)
+{
+	int i, j;
+
+	for (i = 0;i < Spath_numNodes;i++)
+	{
+		int start_index = 0, end_index = 0;
+		qboolean found_start = false, found_end = false;
+		for (j = 0;j < Spath[i].numNodes;j++)
+		{
+			if (Spath[i].path[j] == start_node)
+			{
+				start_index = j;
+				found_start = true;
+			}
+			else if (Spath[i].path[j] == end_node)
+			{
+				end_index = j;
+				found_end = true;
+			}
+			if (found_start && found_end 
+				&& end_index > start_index) //GHz: reverse order is disabled for now because jump links would be impossible to do backwards!
+			{
+				//if (start_index != 0)
+				//	gi.dprintf("saved path found in subset of data!\n");
+				//gi.dprintf("saved path found! index: %d, start: %d end: %d %d->%d\n", i, start_index, end_index, start_node, end_node);
+					AStar_UseSavedPath(i, start_index, end_index);
+				return true;
+			}
+		}
+	}
+	return false;
 }
 
 static int	AStar_FillLists ( void )
@@ -265,25 +361,35 @@ static int	AStar_FillLists ( void )
 
 int	AStar_ResolvePath ( int n1, int n2, int movetypes )
 {
+	//int i=0;//GHz
 	ValidLinksMask = movetypes;
+
 	if ( !ValidLinksMask )
 		ValidLinksMask = DEFAULT_MOVETYPES_MASK;
 
 	AStar_InitLists();
 
+	if (AStar_FindSavedPath(n1, n2))//GHz
+		return 1;
+
 	originNode = n1;
 	goalNode = n2;
 	currentNode = originNode;
 
 	while ( !AStar_nodeIsInOpen(goalNode) )
 	{
+		//i++;//GHz
 		if( !AStar_FillLists() )
 			return 0;	//failed
 	}
 
 	AStar_ListsToPath();
 
-	// printf("RESULT:\n Origin:%i\n Goal:%i\n numNodes:%i\n FirstInPath:%i\n LastInPath:%i\n", originNode, goalNode, Apath_numNodes, Apath[0], Apath[Apath_numNodes-1]);
+	//GHz: debugging A* perf issues
+	//gi.dprintf("RESULT:\n Origin:%i\n Goal:%i\n numNodes:%i\n FirstInPath:%i\n LastInPath:%i\n", originNode, goalNode, Apath_numNodes, Apath[0], Apath[Apath_numNodes-1]);
+	//gi.dprintf("AStar_FillLists() ran %d times\n", i);
+	//gi.dprintf("Spath[%d]: start:%d end:%d length:%d\n", 
+	//	Spath_numNodes-1, Spath[Spath_numNodes-1].path[0], Spath[Spath_numNodes-1].path[Spath[Spath_numNodes - 1].numNodes-1], Spath[Spath_numNodes-1].numNodes);
 
 	return 1;
 }

src/ai/ai_class_dmbot.c

@@ -421,7 +421,7 @@ qboolean BOT_DMclass_FindEnemy(edict_t* self)
 		if (self->ai.status.playersWeights[i] == 0)
 			continue;
 
-		if (!visible1(self, AIEnemies[i]))
+		if (!visible(self, AIEnemies[i]))
 			continue;
 		if (!infront(self, AIEnemies[i]))
 			continue;

src/ai/ai_dropnodes.c

@@ -27,7 +27,7 @@ in NO WAY supported by Steve Yeager.
 #include "ai_local.h"
 
 
-nav_plink_t pLinks[MAX_NODES];		// pLinks array
+nav_plink_t pLinks[MAX_NODES];		// pLinks array - links or connections between nodes; used for pathfinding (determining distance/cost between nodes)
 nav_node_t nodes[MAX_NODES];		// nodes array
 ai_navigation_t	nav;
 
@@ -87,7 +87,7 @@ int AI_AddNode( vec3_t origin, int flagsmask )
 	nodes[nav.num_nodes].flags = flagsmask;
 	nodes[nav.num_nodes].flags |= AI_FlagsForNode( nodes[nav.num_nodes].origin, player.ent );
 
-	//Com_Printf("Dropped Node\n");
+	//gi.dprintf("Dropped Node\n");
 	//if( sv_cheats->value )
 	//	Com_Printf("Dropped Node\n");
 

src/ai/ai_main.c

@@ -368,7 +368,8 @@ void AI_PickShortRangeGoal(edict_t *self)
 			return;
 
 		// Missile detection code
-		if(strcmp(target->classname,"rocket")==0 || strcmp(target->classname,"grenade")==0)
+		if((strcmp(target->classname,"rocket")==0 || strcmp(target->classname,"grenade")==0) && target->owner 
+			&& target->owner->inuse && !OnSameTeam(self, target->owner)) // GHz: don't get angry at teammates
 		{
 			//if player who shoot is a potential enemy
 			if (self->ai.status.playersWeights[target->owner->s.number-1])

src/ai/ai_nodes.c

@@ -898,6 +898,8 @@ void AI_InitNavigationData(void)
 	nav.num_nodes = 0;
 	memset( nodes, 0, sizeof(nav_node_t) * MAX_NODES );
 	memset( pLinks, 0, sizeof(nav_plink_t) * MAX_NODES );
+	memset( Spath, 0, sizeof(spath_t) * MAX_SPATH );//GHz
+	Spath_numNodes = 0;//GHz
 
 	//Load nodes from file
 	nav.loaded = AI_LoadPLKFile( level.mapname );

src/ai/ai_nodes_shared.h

@@ -78,17 +78,17 @@ in NO WAY supported by Steve Yeager.
 
 #define LINK_INVALID			0x00001000
 
+#define MAX_SPATH	1024 //GHz: maximum number of previous paths to store in memory
 
 typedef struct nav_plink_s
 {
-	int			numLinks;
-	int			nodes[NODES_MAX_PLINKS];
-	int			dist[NODES_MAX_PLINKS];
-	int			moveType[NODES_MAX_PLINKS];
+	int			numLinks;					// number of links between adjacent nodes
+	int			nodes[NODES_MAX_PLINKS];	// adjacent node indexes
+	int			dist[NODES_MAX_PLINKS];		// distance to adjacent nodes
+	int			moveType[NODES_MAX_PLINKS];	// move type between adjacent nodes
 
 } nav_plink_t;
 
-
 typedef struct nav_node_s
 {
 	vec3_t		origin;
@@ -97,3 +97,11 @@ typedef struct nav_node_s
 
 } nav_node_t;
 
+typedef struct
+{
+	int	numNodes;
+	int path[MAX_NODES];
+} spath_t;
+
+spath_t Spath[MAX_SPATH];	//GHz: searchable list of previously computed paths, used to speed up pathfinding
+int	Spath_numNodes;		//GHz: number of saved paths

src/ai/bot_spawn.c

@@ -304,7 +304,7 @@ void BOT_DMClass_JoinGame (edict_t *ent, char *team_name)
 	char *s;
 	//int rnd = CLASS_PALADIN;
 
-	gi.dprintf("BOT_DMClass_JoinGame\n");
+	//gi.dprintf("BOT_DMClass_JoinGame\n");
 
 	if ( !BOT_JoinCTFTeam(ent, team_name) )
 		gi.bprintf (PRINT_HIGH,  "[BOT] %s joined the game.\n",
@@ -363,7 +363,7 @@ void BOT_DMClass_JoinGame (edict_t *ent, char *team_name)
 //==========================================
 void BOT_StartAsSpectator (edict_t *ent)
 {
-	gi.dprintf("BOT_StartAsSpectator\n");
+	//gi.dprintf("BOT_StartAsSpectator\n");
 
 	// start as 'observer'
 	ent->movetype = MOVETYPE_NOCLIP;