Refactored and moved some stuff around to replace MovePathToGround with jumpheight

Author: Causeless

CHANGELOG.md

@@ -9,7 +9,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 <details><summary><b>Added</b></summary>
 
 - Pathfinding and navigation overhaul, including jetpack/jump-aware pathfinding.  
-	Actors will now intelligently choose their path depending on how high they can jump, instead of always taking the shortest path. This will reduce instances of the AI getting stuck while trying to take impossible paths.
+	Actors will now intelligently choose their path depending on how high they can jump, instead of always taking the shortest path. This will reduce instances of the AI getting stuck while trying to take impossible paths.  
+	In the `CalculatePath` and `CalculatePathAsync` functions, the parameter `movePathToGround` has been replaced with `jumpHeight`, which is the height in metres the pathfind can jump vertically.  
+	The new function `GetPathFindingFlyingJumpHeight()` can be used to get a jumpHeight that allows flying (i.e infinite jump height).  
+	New `Actor` Lua property `JumpHeight` (R) to estimate the jump height of the actor (in metres), based on the actor's jetpack and weight.
 
 - New music system, including a dynamic horizontal sequencing system, under the new music manager `MusicMan`.  
 	`PlayDynamicSong(string songName, string songSectionName, bool playImmediately, bool playTransition, bool smoothFade)` to play a new DynamicSong.

Data/Base.rte/AI/HumanBehaviors.lua

@@ -1007,7 +1007,7 @@ function HumanBehaviors.WeaponSearch(AI, Owner, Abort)
 							end
 							searchesRemaining = searchesRemaining - 1;
 						end, 
-						Owner.Pos, device.Pos, false, Owner.DigStrength, Owner.Team
+						Owner.Pos, device.Pos, Owner.JumpHeight, Owner.DigStrength, Owner.Team
 					);
 				end
 			end
@@ -1123,7 +1123,7 @@ function HumanBehaviors.ToolSearch(AI, Owner, Abort)
 						end
 						searchesRemaining = searchesRemaining - 1;
 					end, 
-					Owner.Pos, device.Pos, false, Owner.DigStrength, Owner.Team
+					Owner.Pos, device.Pos, Owner.JumpHeight, Owner.DigStrength, Owner.Team
 				);
 			end
 		end

Data/Base.rte/Activities/BunkerBreach.lua

@@ -504,7 +504,7 @@ function BunkerBreach:SendDefenderGuardsAtEnemiesInsideBunker()
 			local closestFriendlyUnitData = {};
 			for _, friendlyUnitInsideBunker in pairs(self.AI.friendlyUnitsInsideBunker) do
 				if not friendlyUnitInsideBunker:IsInGroup("Brains") then
-					local pathLengthFromFriendlyUnitToEnemy = SceneMan.Scene:CalculatePath(friendlyUnitInsideBunker.Pos, enemyUnitInsideBunker.Pos, false, GetPathFindingDefaultDigStrength(), self.CPUTeam);
+					local pathLengthFromFriendlyUnitToEnemy = SceneMan.Scene:CalculatePath(friendlyUnitInsideBunker.Pos, enemyUnitInsideBunker.Pos, GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength(), self.CPUTeam);
 					if closestFriendlyUnitData.pathLengthToEnemy == nil or pathLengthFromFriendlyUnitToEnemy < closestFriendlyUnitData.pathLengthToEnemy then
 						closestFriendlyUnitData.pathLengthToEnemy = pathLengthFromFriendlyUnitToEnemy;
 						closestFriendlyUnitData.actor = friendlyUnitInsideBunker;
@@ -632,7 +632,7 @@ function BunkerBreach:CalculateInternalReinforcementPositionsToEnemyTargets(numb
 		local internalReinforcementPositionForEnemy;
 		local pathLengthFromClosestInternalReinforcementPositionToEnemy = SceneMan.SceneWidth * SceneMan.SceneHeight;
 		for _, internalReinforcementPosition in pairs(self.AI.internalReinforcementPositions) do
-			local pathLengthFromInternalReinforcementPositionToEnemy = SceneMan.Scene:CalculatePath(internalReinforcementPosition, enemyToTarget.Pos, false, GetPathFindingDefaultDigStrength(), self.CPUTeam);
+			local pathLengthFromInternalReinforcementPositionToEnemy = SceneMan.Scene:CalculatePath(internalReinforcementPosition, enemyToTarget.Pos, GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength(), self.CPUTeam);
 			if pathLengthFromInternalReinforcementPositionToEnemy < pathLengthFromClosestInternalReinforcementPositionToEnemy then
 				internalReinforcementPositionForEnemy = internalReinforcementPosition;
 				pathLengthFromClosestInternalReinforcementPositionToEnemy = pathLengthFromInternalReinforcementPositionToEnemy;

Data/Base.rte/Activities/Siege.lua

@@ -469,7 +469,7 @@ function Siege:PlayerBrainsReachable()
 
 	for actor in MovableMan.Actors do
 		if actor.Team == self.PlayerTeam and actor:IsInGroup("Brains") then
-			local pathCost = SceneMan.Scene:CalculatePath(actor.Pos, Vector(actor.Pos.X, 0), false, 0);
+			local pathCost = SceneMan.Scene:CalculatePath(actor.Pos, Vector(actor.Pos.X, 0), GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength());
 			if pathCost > 10000 then
 				reachable = false;
 				break;

Data/Base.rte/Activities/Utility/LandingZoneMap.lua

@@ -454,7 +454,7 @@ function LandingZoneMap:FindLZ(team, Destination, digStrenght)
 end
 
 -- A coroutine that search for a LZ. Input is team and destination. Output is LZ x-pos and obstacle height for two LZs, one close and one with an easy path
-function LandingZoneMap.SearchForLZ(self, team, Destination, digStrenght)
+function LandingZoneMap.SearchForLZ(self, team, Destination, digStrength)
 	-- estimate how visible our descent is to the enemy
 	local LOSgrid = self.EnemyTeamLOS[team];
 	local GoodLZs = {};
@@ -493,7 +493,7 @@ function LandingZoneMap.SearchForLZ(self, team, Destination, digStrenght)
 				pathRequestsCompleted = pathRequestsCompleted + 1;
 				completedPathRequests[k] = pathRequest;
 			end, 
-			Vector(LZ.X, LZ.Y), Destination, false, digStrenght, team);
+			Vector(LZ.X, LZ.Y), Destination, GetPathFindingFlyingJumpHeight(), digStrength, team);
 	end
 
 	while pathRequestsCompleted < #GoodLZs do
@@ -650,7 +650,7 @@ function LandingZoneMap:FindStartLZ(team, OccupiedLZs)
 		distance = nil;
 		local PosLZ = Vector(LZ.X, LZ.Y);
 		for _, PosEnemy in pairs(EnemyLocations) do
-			local wpts = SceneMan.Scene:CalculatePath(PosEnemy, PosLZ, false, 1, team);
+			local wpts = SceneMan.Scene:CalculatePath(PosEnemy, PosLZ, GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength(), team);
 			if wpts > -1 then
 				if distance then
 					distance = math.min(wpts, distance);

Data/Base.rte/Scenes/Objects/Bunkers/BunkerSystems/Automovers/Controller/Controller.lua

@@ -752,7 +752,7 @@ automoverUtilityFunctions.findNodeWithShortestScenePath = function(self, positio
 
 	local shortestPathCoroutine = coroutine.create(FindStartPositionWithShortestPathToEndPosition);
 	while coroutine.status(shortestPathCoroutine) ~= "dead" do
-		local _, result = coroutine.resume(shortestPathCoroutine, potentialClosestNodes, positionToFindClosestNodeFor, pathfinderTeam, false, pathfinderDigStrength);
+		local _, result = coroutine.resume(shortestPathCoroutine, potentialClosestNodes, positionToFindClosestNodeFor, pathfinderTeam, GetPathFindingFlyingJumpHeight(), pathfinderDigStrength);
 		if result then
 			return result;
 		else
@@ -1490,7 +1490,7 @@ automoverActorFunctions.handleActorThatHasReachedItsEndNode = function(self, act
 						end
 					end
 				end,
-				actor.Pos, waypointData.targetPosition, false, GetPathFindingDefaultDigStrength(), self.Team
+				actor.Pos, waypointData.targetPosition, GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength(), self.Team
 			);
 		elseif waypointData.exitPath ~= nil and #waypointData.exitPath > 0 then
 			local distanceFromActorToFirstExitPathPosition = SceneMan:ShortestDistance(waypointData.exitPath[1], actor.Pos, self.checkWrapping);

Data/Base.rte/Utilities.lua

@@ -1,4 +1,4 @@
-function FindStartPositionWithShortestPathToEndPosition(startPositions, endPosition, team, movePathToGround, digStrength)
+function FindStartPositionWithShortestPathToEndPosition(startPositions, endPosition, team, jumpHeight, digStrength)
 	if startPositions == nil or type(startPositions) ~= "table" then
 		print("FindShortestPathAsync Error: A table of start positions is required.");
 		return;
@@ -12,7 +12,7 @@ function FindStartPositionWithShortestPathToEndPosition(startPositions, endPosit
 		return;
 	end
 
-	movePathToGround = movePathToGround or false;
+	jumpHeight = jumpHeight or GetPathFindingFlyingJumpHeight();
 	digStrength = digStrength or GetPathFindingDefaultDigStrength();
 
 	local closestStartPositionKey;
@@ -30,7 +30,7 @@ function FindStartPositionWithShortestPathToEndPosition(startPositions, endPosit
 				end
 				pathRequestsCompleted = pathRequestsCompleted + 1;
 			end, 
-			startPosition, endPosition, movePathToGround, digStrength, team
+			startPosition, endPosition, jumpHeight, digStrength, team
 		);
 		totalPathingRequests = totalPathingRequests + 1;
 	end

Data/Missions.rte/Activities/DecisionDay.lua

@@ -1673,7 +1673,7 @@ function DecisionDay:UpdateAIDecisions()
 					for movableObject in MovableMan:GetMOsInRadius(captureAreaCenter, self.aiData.bunkerRegionDefenseRange, self.humanTeam, true) do
 						if (IsAHuman(movableObject) or IsACrab(movableObject)) and (not movableObject:IsInGroup("AI Region Defenders") or movableObject:IsInGroup("AI Region Defenders - " .. bunkerRegionName)) and movableObject.PinStrength == 0 and not movableObject:IsInGroup("Actors - Turrets")  then
 							--TODO when we have calculate path async with limited max path length, use it here. Will have to do coroutine, etc.
-							--local pathLengthToCaptureArea = SceneMan.Scene:CalculatePath(movableObject.Pos, captureAreaCenter, false, GetPathFindingDefaultDigStrength(), self.aiTeam) * 20;
+							--local pathLengthToCaptureArea = SceneMan.Scene:CalculatePath(movableObject.Pos, captureAreaCenter, GetPathFindingFlyingJumpHeight(), GetPathFindingDefaultDigStrength(), self.aiTeam) * 20;
 							--if pathLengthToCaptureArea < self.aiData.bunkerRegionDefenseRange then
 								local actor = ToActor(movableObject);
 								actor.AIMode = Actor.AIMODE_GOTO;

Source/Entities/Actor.cpp

@@ -993,14 +993,14 @@ void Actor::UpdateMovePath() {
 
 	// If we're following someone/thing, then never advance waypoints until that thing disappears
 	if (g_MovableMan.ValidMO(m_pMOMoveTarget)) {
-		m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_pMOMoveTarget->GetPos(), digStrength, jumpHeight, static_cast<Activity::Teams>(m_Team));
+		m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_pMOMoveTarget->GetPos(), jumpHeight, digStrength, static_cast<Activity::Teams>(m_Team));
 	} else {
 		// Do we currently have a path to a static target we would like to still pursue?
 		if (m_MovePath.empty()) {
 			// Ok no path going, so get a new path to the next waypoint, if there is a next waypoint
 			if (!m_Waypoints.empty()) {
 				// Make sure the path starts from the ground and not somewhere up in the air if/when dropped out of ship
-				m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_Waypoints.front().first, digStrength, jumpHeight, static_cast<Activity::Teams>(m_Team));
+				m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_Waypoints.front().first, jumpHeight, digStrength, static_cast<Activity::Teams>(m_Team));
 
 				// If the waypoint was tied to an MO to pursue, then load it into the current MO target
 				if (g_MovableMan.ValidMO(m_Waypoints.front().second)) {
@@ -1014,12 +1014,12 @@ void Actor::UpdateMovePath() {
 			}
 			// Just try to get to the last Move Target
 			else {
-				m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_MoveTarget, digStrength, jumpHeight, static_cast<Activity::Teams>(m_Team));
+				m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), m_MoveTarget, jumpHeight, digStrength, static_cast<Activity::Teams>(m_Team));
 			}
 		}
 		// We had a path before trying to update, so use its last point as the final destination
 		else {
-			m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), Vector(m_MovePath.back()), digStrength, jumpHeight, static_cast<Activity::Teams>(m_Team));
+			m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(g_SceneMan.MovePointToGround(m_Pos, m_CharHeight * 0.2, 10), Vector(m_MovePath.back()), jumpHeight, digStrength, static_cast<Activity::Teams>(m_Team));
 		}
 	}
 

Source/Entities/Scene.cpp

@@ -2398,16 +2398,16 @@ void Scene::UpdatePathFinding() {
 	m_PathfindingUpdated = true;
 }
 
-float Scene::CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength, float jumpHeight, Activity::Teams team) {
+float Scene::CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float jumpHeight, float digStrength, Activity::Teams team) {
 	float totalCostResult = -1;
-	int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, digStrength, jumpHeight);
+	int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, jumpHeight, 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
 	return (result == micropather::MicroPather::SOLVED || result == micropather::MicroPather::START_END_SAME) ? totalCostResult : -1;
 }
 
-std::shared_ptr<volatile PathRequest> Scene::CalculatePathAsync(const Vector& start, const Vector& end, float digStrength, float jumpHeight, Activity::Teams team, PathCompleteCallback callback) {
-	return GetPathFinder(team).CalculatePathAsync(start, end, digStrength, jumpHeight, callback);
+std::shared_ptr<volatile PathRequest> Scene::CalculatePathAsync(const Vector& start, const Vector& end, float jumpHeight, float digStrength, Activity::Teams team, PathCompleteCallback callback) {
+	return GetPathFinder(team).CalculatePathAsync(start, end, jumpHeight, digStrength, callback);
 }
 
 int Scene::GetScenePathSize() const {