Added team pathfinders to be used for default dig strength, so they can cache path costs

Also reorganized pathfinders a bit, so the noteam one isn't part of the array, since I didn't want a noteam default dig strength one
Added a bit of tolerance to the pathfinder cache clearing, for safety's sake. I think everything using default dig strength shouldn't have float comparison problems, but better safe than sorry

Author: garethyr

Entities/Scene.cpp

@@ -452,9 +452,13 @@ void Scene::Clear()
     m_AutoDesigned = true;
     m_TotalInvestment = 0;
     m_pTerrain = 0;
-    for (std::unique_ptr<PathFinder> &pathFinder : m_pPathFinders) {
+	m_NoTeamPathFinder.reset();
+    for (std::unique_ptr<PathFinder> &pathFinder : m_PathFinders) {
         pathFinder.reset();
     }
+	for (std::unique_ptr<PathFinder> &defaultDigStrengthPathFinder : m_DefaultDigStrengthPathfinders) {
+		defaultDigStrengthPathFinder.reset();
+	}
     m_PathfindingUpdated = false;
     m_PartialPathUpdateTimer.Reset();
 
@@ -933,8 +937,12 @@ int Scene::LoadData(bool placeObjects, bool initPathfinding, bool placeUnits)
 		//unsigned int numberOfBlocksToAllocate = std::min(128000, sceneArea / (pathFinderGridNodeSize * pathFinderGridNodeSize));
 		unsigned int numberOfBlocksToAllocate = 4000;
 
-        for (int i = 0; i < m_pPathFinders.size(); ++i) {
-            m_pPathFinders[i] = std::make_unique<PathFinder>(pathFinderGridNodeSize, numberOfBlocksToAllocate);
+		m_NoTeamPathFinder = std::make_unique<PathFinder>(pathFinderGridNodeSize, numberOfBlocksToAllocate);
+		for (int i = 0; i < m_PathFinders.size(); ++i) {
+			m_PathFinders[i] = std::make_unique<PathFinder>(pathFinderGridNodeSize, numberOfBlocksToAllocate);
+		}
+		for (int i = 0; i < m_DefaultDigStrengthPathfinders.size(); ++i) {
+			m_DefaultDigStrengthPathfinders[i] = std::make_unique<PathFinder>(pathFinderGridNodeSize, numberOfBlocksToAllocate);
         }
         ResetPathFinding();
     }
@@ -2979,6 +2987,7 @@ void Scene::ResetPathFinding() {
 	for (int team = Activity::Teams::TeamOne; team < Activity::Teams::MaxTeamCount; ++team) {
 		g_MovableMan.OverrideMaterialDoors(true, team);
 		GetPathFinder(static_cast<Activity::Teams>(team))->RecalculateAllCosts();
+		GetPathFinder(static_cast<Activity::Teams>(team), c_PathFindingDefaultDigStrength)->RecalculateAllCosts();
 		g_MovableMan.OverrideMaterialDoors(false, team);
 	}
 }
@@ -3014,6 +3023,7 @@ void Scene::UpdatePathFinding()
             g_MovableMan.OverrideMaterialDoors(true, team);
 
             GetPathFinder(static_cast<Activity::Teams>(team))->UpdateNodeList(updatedNodes);
+            GetPathFinder(static_cast<Activity::Teams>(team), c_PathFindingDefaultDigStrength)->UpdateNodeList(updatedNodes);
 
             // Place back the material representation of all doors of this team so they are as we found them.
             g_MovableMan.OverrideMaterialDoors(false, team);
@@ -3034,7 +3044,7 @@ void Scene::UpdatePathFinding()
 float Scene::CalculatePath(const Vector &start, const Vector &end, std::list<Vector> &pathResult, float digStrength, Activity::Teams team) {
     float totalCostResult = -1;
 
-    if (const std::unique_ptr<PathFinder> &pathFinder = GetPathFinder(team)) {
+    if (const std::unique_ptr<PathFinder> &pathFinder = GetPathFinder(team, digStrength)) {
         int result = pathFinder->CalculatePath(start, end, pathResult, totalCostResult, digStrength);
 
         // It's ok if start and end nodes happen to be the same, the exact pixel locations are added at the front and end of the result regardless
@@ -3117,9 +3127,14 @@ void Scene::Update()
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<PathFinder>& Scene::GetPathFinder(Activity::Teams team) {
-	// Note - we use + 1 when getting pathfinders by index, because our shared NoTeam pathfinder occupies index 0, and the rest come after that.
-	return m_pPathFinders[static_cast<int>(team) + 1];
+std::unique_ptr<PathFinder>& Scene::GetPathFinder(Activity::Teams team, float digStrength) {
+	if (team == Activity::Teams::NoTeam) {
+		return m_NoTeamPathFinder;
+	} else if (std::abs(digStrength - c_PathFindingDefaultDigStrength) < 1.0F) {
+		return m_DefaultDigStrengthPathfinders[team];
+	} else {
+		return m_PathFinders[static_cast<int>(team)];
+	}
 }
 
 } // namespace RTE

Entities/Scene.h

@@ -1338,8 +1338,9 @@ const SceneObject * PickPlacedActorInRange(int whichSet, Vector &scenePoint, int
     SLTerrain *m_pTerrain;
 
     // Pathfinding graph and logic. Owned by this
-    // The array of PathFinders for each team. Because we also have a shared pathfinder using index 0, we need to use MaxTeamCount + 1 to handle all the Teams' PathFinders.
-    std::array<std::unique_ptr<PathFinder>, Activity::Teams::MaxTeamCount + 1> m_pPathFinders;
+	std::unique_ptr<PathFinder> m_NoTeamPathFinder; //!< The shared pathfinder for when no team is specified.
+	std::array<std::unique_ptr<PathFinder>, Activity::Teams::MaxTeamCount> m_PathFinders; //!< The array of pathfinders for each team.
+	std::array<std::unique_ptr<PathFinder>, Activity::Teams::MaxTeamCount> m_DefaultDigStrengthPathfinders; //!< The array of pathfinders for each team to be used for default dig strength.
     // Is set to true on any frame the pathfinding data has been updated
     bool m_PathfindingUpdated;
     // Timer for when to do an update of the pathfinding data
@@ -1394,8 +1395,9 @@ const SceneObject * PickPlacedActorInRange(int whichSet, Vector &scenePoint, int
 	/// Gets the pathfinder for a given team.
 	/// </summary>
 	/// <param name="team">The team to get the pathfinder for. NoTeam is valid, and will give a shared pathfinder.</param>
+	/// <param name="digStrength">The dig strength to get the pathfinder for. A different pathfinder will be used if it's the default dig strength. Defaults to -1 so the normal pathfinder will be used if no argument is passed in.</param>
 	/// <returns>A pointer to the pathfinder for the given team.</returns>
-	std::unique_ptr<PathFinder> & GetPathFinder(Activity::Teams team);
+	std::unique_ptr<PathFinder> & GetPathFinder(Activity::Teams team, float digStrength = -1);
 
 	/// <summary>
 	/// Serializes the SceneObject via the Writer. Necessary because full serialization doesn't know how to deal with duplicate properties.

System/PathFinder.cpp

@@ -118,7 +118,7 @@ namespace RTE {
 		// Clear out the results if it happens to contain anything
 		pathResult.clear();
 
-		if (m_DigStrength != digStrength) {
+		if (std::abs(digStrength - m_DigStrength) > 1.0F) {
 			// Unfortunately, DigStrength-aware pathing means that we're adjusting node transition costs, so we need to reset our path cache on every call.
 			// In future we'll potentially store a different pather for different mobility bands, and reuse pathing costs.
 			// But then again it's probably more fruitful to optimize the graph node to make searches faster, instead.