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

This reverts commit c44d395.

Author: garethyr

Entities/Scene.cpp

@@ -452,13 +452,9 @@ void Scene::Clear()
     m_AutoDesigned = true;
     m_TotalInvestment = 0;
     m_pTerrain = 0;
-	m_NoTeamPathFinder.reset();
-    for (std::unique_ptr<PathFinder> &pathFinder : m_PathFinders) {
+    for (std::unique_ptr<PathFinder> &pathFinder : m_pPathFinders) {
         pathFinder.reset();
     }
-	for (std::unique_ptr<PathFinder> &defaultDigStrengthPathFinder : m_DefaultDigStrengthPathfinders) {
-		defaultDigStrengthPathFinder.reset();
-	}
     m_PathfindingUpdated = false;
     m_PartialPathUpdateTimer.Reset();
 
@@ -937,12 +933,8 @@ int Scene::LoadData(bool placeObjects, bool initPathfinding, bool placeUnits)
 		//unsigned int numberOfBlocksToAllocate = std::min(128000, sceneArea / (pathFinderGridNodeSize * pathFinderGridNodeSize));
 		unsigned int numberOfBlocksToAllocate = 4000;
 
-		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);
+        for (int i = 0; i < m_pPathFinders.size(); ++i) {
+            m_pPathFinders[i] = std::make_unique<PathFinder>(pathFinderGridNodeSize, numberOfBlocksToAllocate);
         }
         ResetPathFinding();
     }
@@ -2986,7 +2978,6 @@ 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);
 	}
 }
@@ -3022,7 +3013,6 @@ 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);
@@ -3043,7 +3033,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, digStrength)) {
+    if (const std::unique_ptr<PathFinder> &pathFinder = GetPathFinder(team)) {
         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
@@ -3126,14 +3116,9 @@ void Scene::Update()
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-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)];
-	}
+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];
 }
 
 } // namespace RTE

Entities/Scene.h

@@ -1338,9 +1338,8 @@ const SceneObject * PickPlacedActorInRange(int whichSet, Vector &scenePoint, int
     SLTerrain *m_pTerrain;
 
     // Pathfinding graph and logic. Owned by this
-	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.
+    // 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;
     // 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
@@ -1395,9 +1394,8 @@ 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, float digStrength = -1);
+	std::unique_ptr<PathFinder> & GetPathFinder(Activity::Teams team);
 
 	/// <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 (std::abs(digStrength - m_DigStrength) > 1.0F) {
+		if (m_DigStrength != digStrength) {
 			// 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.