Re-added support for infinite jumpheight (legacy pathfinds, dropships etc)

Causeless · Causeless · commit ccf13b51fb93 · 2024-08-21T18:45:32.000+01:00
Added lua bindings and plumbing to allow configurable jumpHeight from actor. Crabs right now are assumed to have 0 height, Humans are assumed to have 20, and anything else has infinite.
diff --git a/Source/Entities/ACrab.cpp b/Source/Entities/ACrab.cpp
@@ -758,6 +758,10 @@ MovableObject* ACrab::LookForMOs(float FOVSpread, unsigned char ignoreMaterial,
 	return pSeenMO;
 }
 
+float ACrab::EstimateJumpHeight() const {
+	return 0.0f; // todo, add support to detect crabs with jetpacks
+}
+
 void ACrab::OnNewMovePath() {
 	Actor::OnNewMovePath();
 }
diff --git a/Source/Entities/ACrab.h b/Source/Entities/ACrab.h
@@ -267,6 +267,10 @@ namespace RTE {
 		/// @param aimRangeLowerLimit The new lower limit of this ACrab's aim range.
 		void SetAimRangeLowerLimit(float aimRangeLowerLimit) { m_AimRangeLowerLimit = aimRangeLowerLimit; }
 
+		// Estimates how high this actor can jump.
+		/// @return The actor's jump height.
+		virtual float EstimateJumpHeight() const override;
+
 		/// Protected member variable and method declarations
 	protected:
 		/// Function that is called when we get a new movepath.
diff --git a/Source/Entities/AHuman.cpp b/Source/Entities/AHuman.cpp
@@ -933,6 +933,10 @@ float AHuman::EstimateDigStrength() const {
 	return maxPenetration;
 }
 
+float AHuman::EstimateJumpHeight() const {
+	return 20.0f; // hardcoded for now
+}
+
 bool AHuman::EquipShield() {
 	if (!(m_pFGArm && m_pFGArm->IsAttached())) {
 		return false;
diff --git a/Source/Entities/AHuman.h b/Source/Entities/AHuman.h
@@ -287,6 +287,10 @@ namespace RTE {
 		/// @return The maximum material strength this AHuman's digger can penetrate, or a default dig strength if they don't have a digger.
 		float EstimateDigStrength() const override;
 
+		// Estimates how high this actor can jump.
+		/// @return The actor's jump height.
+		virtual float EstimateJumpHeight() const override;
+
 		/// Switches the currently held device (if any) to the first found shield
 		/// in the inventory. If the held device already is a shield, or no
 		/// shield is in inventory, nothing happens.
diff --git a/Source/Entities/Actor.cpp b/Source/Entities/Actor.cpp
@@ -989,17 +989,18 @@ void Actor::UpdateMovePath() {
 
 	// Estimate how much material this actor can dig through
 	float digStrength = EstimateDigStrength();
+	float jumpHeight = EstimateJumpHeight();
 
 	// 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, 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(), digStrength, jumpHeight, 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, 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, digStrength, jumpHeight, 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)) {
@@ -1013,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, static_cast<Activity::Teams>(m_Team));
+				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));
 			}
 		}
 		// 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, 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()), digStrength, jumpHeight, static_cast<Activity::Teams>(m_Team));
 		}
 	}
 
@@ -1029,6 +1030,10 @@ float Actor::EstimateDigStrength() const {
 	return m_AIBaseDigStrength;
 }
 
+float Actor::EstimateJumpHeight() const {
+	return FLT_MAX;
+}
+
 void Actor::VerifyMOIDs() {
 	std::vector<MOID> MOIDs;
 	GetMOIDs(MOIDs);
diff --git a/Source/Entities/Actor.h b/Source/Entities/Actor.h
@@ -647,6 +647,10 @@ namespace RTE {
 		/// @return The actor's dig strength.
 		virtual float EstimateDigStrength() const;
 
+		/// Estimates how high this actor can jump.
+		/// @return The actor's jump height.
+		virtual float EstimateJumpHeight() const;
+
 		/// Gets this Actor's base dig strength, or the strength of terrain they can expect to walk through without tools.
 		/// @return The actors base dig strength.
 		float GetAIBaseDigStrength() const { return m_AIBaseDigStrength; }
diff --git a/Source/Entities/Scene.cpp b/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, Activity::Teams team) {
+float Scene::CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength, float jumpHeight, Activity::Teams team) {
 	float totalCostResult = -1;
-	int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, digStrength);
+	int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, digStrength, jumpHeight);
 
 	// 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, Activity::Teams team, PathCompleteCallback callback) {
-	return GetPathFinder(team).CalculatePathAsync(start, end, digStrength, callback);
+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);
 }
 
 int Scene::GetScenePathSize() const {
diff --git a/Source/Entities/Scene.h b/Source/Entities/Scene.h
@@ -652,20 +652,24 @@ namespace RTE {
 		/// When pathing using the NoTeam pathFinder, no doors are considered passable.
 		/// @param start Start and end positions on the scene to find the path between.
 		/// @param end A list which will be filled out with waypoints between the start and end.
-		/// @param pathResult The maximum material strength any actor traveling along the path can dig through.
-		/// @param digStrength The team we're pathing for (doors for this team will be considered passable) (default: c_PathFindingDefaultDigStrength)
+		/// @param pathResult The generated path.
+		/// @param digStrength The maximum material strength any actor traveling along the path can dig through.
+		/// @param jumpHeight How high, in metres, the search can jump vertically.
+		/// @param team The team we're pathing for (doors for this team will be considered passable).
 		/// @return The total minimum difficulty cost calculated between the two points on
 		/// the scene.
-		float CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength = c_PathFindingDefaultDigStrength, Activity::Teams team = Activity::Teams::NoTeam);
+		float CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength = c_PathFindingDefaultDigStrength, float jumpHeight = FLT_MAX, Activity::Teams team = Activity::Teams::NoTeam);
 
 		/// Asynchronously calculates the least difficult path between two points on the current Scene. Takes both distance and materials into account.
 		/// When pathing using the NoTeam pathFinder, no doors are considered passable.
 		/// @param start Start position of the pathfinding request.
 		/// @param end End position of the pathfinding request.
 		/// @param digStrength The maximum material strength any actor traveling along the path can dig through.
-		/// @param team The team we're pathing for (doors for this team will be considered passable)
+		/// @param jumpHeight How high, in metres, the search can jump vertically.
+		/// @param team The team we're pathing for (doors for this team will be considered passable).
+		/// @param callback The callback function we'll call after our pathfind request has finished calculating.
 		/// @return A shared pointer to the volatile PathRequest to be used to track whehter the asynchrnous path calculation has been completed, and check its results.
-		std::shared_ptr<volatile PathRequest> CalculatePathAsync(const Vector& start, const Vector& end, float digStrength = c_PathFindingDefaultDigStrength, Activity::Teams team = Activity::Teams::NoTeam, PathCompleteCallback callback = nullptr);
+		std::shared_ptr<volatile PathRequest> CalculatePathAsync(const Vector& start, const Vector& end, float digStrength = c_PathFindingDefaultDigStrength, float jumpHeight = FLT_MAX, Activity::Teams team = Activity::Teams::NoTeam, PathCompleteCallback callback = nullptr);
 
 		/// Gets how many waypoints there are in the ScenePath currently
 		/// @return The number of waypoints in the ScenePath.
diff --git a/Source/Lua/LuaAdapterDefinitions.h b/Source/Lua/LuaAdapterDefinitions.h
@@ -301,11 +301,21 @@ namespace RTE {
 
 #pragma region Scene Lua Adapters
 	struct LuaAdaptersScene {
-		static int CalculatePath1(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength) { return CalculatePath2(luaSelfObject, start, end, movePathToGround, digStrength, Activity::Teams::NoTeam); }
-		static int CalculatePath2(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team);
-
-		static void CalculatePathAsync1(Scene* luaSelfObject, const luabind::object& callback, const Vector& start, const Vector& end, bool movePathToGround, float digStrength) { return CalculatePathAsync2(luaSelfObject, callback, start, end, movePathToGround, digStrength, Activity::Teams::NoTeam); }
-		static void CalculatePathAsync2(Scene* luaSelfObject, const luabind::object& callback, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team);
+		static int CalculatePath1(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength) { 
+			return CalculatePath(luaSelfObject, start, end, movePathToGround, digStrength, FLT_MAX, Activity::Teams::NoTeam); 
+		}
+		static int CalculatePath2(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team) {
+			return CalculatePath(luaSelfObject, start, end, movePathToGround, digStrength, FLT_MAX, team); 
+		}
+		static int CalculatePath(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, float jumpHeight, Activity::Teams team);
+
+		static void CalculatePathAsync1(Scene* luaSelfObject, const luabind::object& callback, const Vector& start, const Vector& end, bool movePathToGround, float digStrength) { 
+			return CalculatePathAsync(luaSelfObject, callback, start, end, movePathToGround, digStrength, FLT_MAX, Activity::Teams::NoTeam);
+		}
+		static void CalculatePathAsync2(Scene* luaSelfObject, const luabind::object& callback, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team) {
+			return CalculatePathAsync(luaSelfObject, callback, start, end, movePathToGround, digStrength, FLT_MAX, team);
+		}
+		static void CalculatePathAsync(Scene* luaSelfObject, const luabind::object& callback, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, float jumpHeight, Activity::Teams team);
 	};
 #pragma endregion
 
diff --git a/Source/Lua/LuaAdapters.cpp b/Source/Lua/LuaAdapters.cpp
@@ -275,10 +275,10 @@ std::vector<Vector>* LuaAdaptersActor::GetSceneWaypoints(Actor* luaSelfObject) {
 	return sceneWaypoints;
 }
 
-int LuaAdaptersScene::CalculatePath2(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team) {
+int LuaAdaptersScene::CalculatePath(Scene* luaSelfObject, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, float jumpHeight, Activity::Teams team) {
 	std::list<Vector>& threadScenePath = luaSelfObject->GetScenePath();
 	team = std::clamp(team, Activity::Teams::NoTeam, Activity::Teams::TeamFour);
-	luaSelfObject->CalculatePath(start, end, threadScenePath, digStrength, team);
+	luaSelfObject->CalculatePath(start, end, threadScenePath, digStrength, jumpHeight, team);
 	if (!threadScenePath.empty()) {
 		if (movePathToGround) {
 			for (Vector& scenePathPoint: threadScenePath) {
@@ -291,7 +291,7 @@ int LuaAdaptersScene::CalculatePath2(Scene* luaSelfObject, const Vector& start,
 	return -1;
 }
 
-void LuaAdaptersScene::CalculatePathAsync2(Scene* luaSelfObject, const luabind::object& callbackParam, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, Activity::Teams team) {
+void LuaAdaptersScene::CalculatePathAsync(Scene* luaSelfObject, const luabind::object& callbackParam, const Vector& start, const Vector& end, bool movePathToGround, float digStrength, float jumpHeight, Activity::Teams team) {
 	team = std::clamp(team, Activity::Teams::NoTeam, Activity::Teams::TeamFour);
 
 	// So, luabind::object is a weak reference, holding just a stack and a position in the stack
@@ -319,7 +319,7 @@ void LuaAdaptersScene::CalculatePathAsync2(Scene* luaSelfObject, const luabind::
 		});
 	};
 
-	luaSelfObject->CalculatePathAsync(start, end, digStrength, team, callLuaCallback);
+	luaSelfObject->CalculatePathAsync(start, end, digStrength, jumpHeight, team, callLuaCallback);
 }
 
 void LuaAdaptersAHuman::ReloadFirearms(AHuman* luaSelfObject) {
diff --git a/Source/Lua/LuaBindingsEntities.cpp b/Source/Lua/LuaBindingsEntities.cpp
@@ -206,6 +206,7 @@ LuaBindingRegisterFunctionDefinitionForType(EntityLuaBindings, Actor) {
 	    .property("PieMenu", &Actor::GetPieMenu, &LuaAdaptersPropertyOwnershipSafetyFaker::ActorSetPieMenu)
 	    .property("AIBaseDigStrength", &Actor::GetAIBaseDigStrength, &Actor::SetAIBaseDigStrength)
 	    .property("DigStrength", &Actor::EstimateDigStrength)
+	    .property("JumpHeight", &Actor::EstimateJumpHeight)
 	    .property("SceneWaypoints", &LuaAdaptersActor::GetSceneWaypoints, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
 	    .property("LimbPushForcesAndCollisionsDisabled", &Actor::GetLimbPushForcesAndCollisionsDisabled, &Actor::SetLimbPushForcesAndCollisionsDisabled)
 	    .property("MoveProximityLimit", &Actor::GetMoveProximityLimit, &Actor::SetMoveProximityLimit)
@@ -1173,8 +1174,10 @@ LuaBindingRegisterFunctionDefinitionForType(EntityLuaBindings, Scene) {
 	    .def("ResetPathFinding", &Scene::ResetPathFinding)
 	    .def("UpdatePathFinding", &Scene::UpdatePathFinding)
 	    .def("PathFindingUpdated", &Scene::PathFindingUpdated)
+	    .def("CalculatePath", &LuaAdaptersScene::CalculatePath)
 	    .def("CalculatePath", &LuaAdaptersScene::CalculatePath1)
 	    .def("CalculatePath", &LuaAdaptersScene::CalculatePath2)
+	    .def("CalculatePathAsync", &LuaAdaptersScene::CalculatePathAsync)
 	    .def("CalculatePathAsync", &LuaAdaptersScene::CalculatePathAsync1)
 	    .def("CalculatePathAsync", &LuaAdaptersScene::CalculatePathAsync2)
 
diff --git a/Source/Menus/AssemblyEditorGUI.cpp b/Source/Menus/AssemblyEditorGUI.cpp
@@ -860,14 +860,14 @@ void AssemblyEditorGUI::Draw(BITMAP* pTargetBitmap, const Vector& targetPos) con
 bool AssemblyEditorGUI::UpdateBrainPath() {
 	// First see if we have a brain in hand
 	if (m_pCurrentObject && m_pCurrentObject->IsInGroup("Brains")) {
-		m_BrainSkyPathCost = g_SceneMan.GetScene()->CalculatePath(m_CursorPos, Vector(m_CursorPos.m_X, 0), m_BrainSkyPath, c_PathFindingDefaultDigStrength, static_cast<Activity::Teams>(m_pController->GetTeam()));
+		m_BrainSkyPathCost = g_SceneMan.GetScene()->CalculatePath(m_CursorPos, Vector(m_CursorPos.m_X, 0), m_BrainSkyPath, c_PathFindingDefaultDigStrength, FLT_MAX, static_cast<Activity::Teams>(m_pController->GetTeam()));
 		return true;
 	}
 
 	// If not, then do we have a resident?
 	SceneObject* pBrain = g_SceneMan.GetScene()->GetResidentBrain(m_pController->GetPlayer());
 	if (pBrain)
-		m_BrainSkyPathCost = g_SceneMan.GetScene()->CalculatePath(pBrain->GetPos(), Vector(pBrain->GetPos().m_X, 0), m_BrainSkyPath, c_PathFindingDefaultDigStrength, static_cast<Activity::Teams>(m_pController->GetTeam()));
+		m_BrainSkyPathCost = g_SceneMan.GetScene()->CalculatePath(pBrain->GetPos(), Vector(pBrain->GetPos().m_X, 0), m_BrainSkyPath, c_PathFindingDefaultDigStrength, FLT_MAX, static_cast<Activity::Teams>(m_pController->GetTeam()));
 	else {
 		m_BrainSkyPath.clear();
 		m_BrainSkyPathCost = 0;
diff --git a/Source/Menus/SceneEditorGUI.cpp b/Source/Menus/SceneEditorGUI.cpp
@@ -1421,7 +1421,7 @@ void SceneEditorGUI::UpdateBrainSkyPathAndCost(Vector brainPos) {
 	}
 
 	Activity::Teams team = static_cast<Activity::Teams>(g_ActivityMan.GetActivity()->GetTeamOfPlayer(m_pController->GetPlayer()));
-	m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(pos1, pos2, c_PathFindingDefaultDigStrength, team,
+	m_PathRequest = g_SceneMan.GetScene()->CalculatePathAsync(pos1, pos2, c_PathFindingDefaultDigStrength, FLT_MAX, team,
 	                                                          [&](std::shared_ptr<volatile PathRequest> pathRequest) {
 		                                                          m_BrainSkyPath = const_cast<std::list<Vector>&>(pathRequest->path);
 		                                                          m_BrainSkyPathCost = pathRequest->totalCost;
diff --git a/Source/System/PathFinder.cpp b/Source/System/PathFinder.cpp
diff --git a/Source/System/PathFinder.h b/Source/System/PathFinder.h

Original file line number	Diff line number	Diff line change
`@@ -758,6 +758,10 @@ MovableObject* ACrab::LookForMOs(float FOVSpread, unsigned char ignoreMaterial,`
`758`	`758`	`return pSeenMO;`
`759`	`759`	`}`
`760`	`760`
	`761`	`+float ACrab::EstimateJumpHeight() const {`
	`762`	`+ return 0.0f; // todo, add support to detect crabs with jetpacks`
	`763`	`+}`
	`764`	`+`
`761`	`765`	`void ACrab::OnNewMovePath() {`
`762`	`766`	`Actor::OnNewMovePath();`
`763`	`767`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2398,16 +2398,16 @@ void Scene::UpdatePathFinding() {`
`2398`	`2398`	`m_PathfindingUpdated = true;`
`2399`	`2399`	`}`
`2400`	`2400`
`2401`		`-float Scene::CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength, Activity::Teams team) {`
	`2401`	`+float Scene::CalculatePath(const Vector& start, const Vector& end, std::list<Vector>& pathResult, float digStrength, float jumpHeight, Activity::Teams team) {`
`2402`	`2402`	`float totalCostResult = -1;`
`2403`		`- int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, digStrength);`
	`2403`	`+ int result = GetPathFinder(team).CalculatePath(start, end, pathResult, totalCostResult, digStrength, jumpHeight);`
`2404`	`2404`
`2405`	`2405`	`// 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`
`2406`	`2406`	`return (result == micropather::MicroPather::SOLVED \|\| result == micropather::MicroPather::START_END_SAME) ? totalCostResult : -1;`
`2407`	`2407`	`}`
`2408`	`2408`
`2409`		`-std::shared_ptr<volatile PathRequest> Scene::CalculatePathAsync(const Vector& start, const Vector& end, float digStrength, Activity::Teams team, PathCompleteCallback callback) {`
`2410`		`- return GetPathFinder(team).CalculatePathAsync(start, end, digStrength, callback);`
	`2409`	`+std::shared_ptr<volatile PathRequest> Scene::CalculatePathAsync(const Vector& start, const Vector& end, float digStrength, float jumpHeight, Activity::Teams team, PathCompleteCallback callback) {`
	`2410`	`+ return GetPathFinder(team).CalculatePathAsync(start, end, digStrength, jumpHeight, callback);`
`2411`	`2411`	`}`
`2412`	`2412`
`2413`	`2413`	`int Scene::GetScenePathSize() const {`