Merge branch 'development' into pictorial-loadouts

Author: Causeless

Source/Entities/Actor.cpp

@@ -1081,6 +1081,13 @@ void Actor::OnNewMovePath() {
 		// Nowhere to gooooo
 		m_MoveTarget = m_PrevPathTarget = m_Pos;
 	}
+
+	// Smash all non-airborne waypoints down to just above the ground, so they more accurately represent the ground path
+	std::list<Vector>::iterator finalItr = m_MovePath.end();
+	--finalItr;
+	for (std::list<Vector>::iterator lItr = m_MovePath.begin(); lItr != finalItr; ++lItr) {
+		(*lItr) = g_SceneMan.MovePointToGround((*lItr), m_CharHeight * 0.2, 0, g_SettingsMan.GetPathFinderGridNodeSize() * 2.5f);
+	}
 }
 
 void Actor::PreControllerUpdate() {
@@ -1091,7 +1098,7 @@ void Actor::PreControllerUpdate() {
 	}
 
 	// We update this after, because pathing requests are forced to take at least 1 frame for the sake of determinism for now.
-	// In future maybe we can move this back, but it doesn't make much difference (the threadpool submission overhead makes it extremely unlikely that it would complete in less time anyways)
+	// In future maybe we can move this back, but it doesn't make much difference
 	if (m_UpdateMovePath) {
 		UpdateMovePath();
 	}

Source/Lua/LuaBindingsManagers.cpp

@@ -345,9 +345,10 @@ LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, SceneMan) {
 	    .def("CastObstacleRay", &LuaAdaptersSceneMan::CastObstacleRay2)
 	    .def("CastTerrainPenetrationRay", &SceneMan::CastTerrainPenetrationRay)
 	    .def("GetLastRayHitPos", &SceneMan::GetLastRayHitPos)
-	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int)) & SceneMan::FindAltitude)
-	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int, bool)) & SceneMan::FindAltitude)
-	    .def("MovePointToGround", &SceneMan::MovePointToGround)
+	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int)) &SceneMan::FindAltitude)
+	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int, bool)) &SceneMan::FindAltitude)
+	    .def("MovePointToGround", (Vector(SceneMan::*)(const Vector&, int, int)) &SceneMan::MovePointToGround)
+	    .def("MovePointToGround", (Vector(SceneMan::*)(const Vector&, int, int, int)) &SceneMan::MovePointToGround)
 	    .def("IsWithinBounds", &SceneMan::IsWithinBounds)
 	    .def("ForceBounds", (bool(SceneMan::*)(Vector&) const) & SceneMan::ForceBounds) //, out_value(_2))
 	    .def("WrapPosition", (bool(SceneMan::*)(Vector&) const) & SceneMan::WrapPosition) //, out_value(_2))

Source/Managers/MovableMan.cpp

@@ -1384,11 +1384,11 @@ void MovableMan::Update() {
 		                                                                            [&](int start, int end) {
 			                                                                            ZoneScopedN("Actors See");
 			                                                                            for (int i = start; i < end; ++i) {
-													    // TODO - this null check really shouldn't be required. There's almost definitely an issue where the actor update can somehow fuck with this mid-update
-													    // this is VERY bad, and needs investigation!
-				                                                                            if (m_Actors[i]) { 
-														    m_Actors[i]->CastSeeRays();
-													    }
+																							// TODO - this null check really shouldn't be required. There's almost definitely an issue where the actor update can somehow fuck with this mid-update
+																							// this is VERY bad, and needs investigation!
+																							if (m_Actors[i]) { 
+																								m_Actors[i]->CastSeeRays();
+																							}
 			                                                                            }
 		                                                                            });
 

Source/Managers/SceneMan.cpp

@@ -2242,7 +2242,7 @@ bool SceneMan::IsPointInNoGravArea(const Vector& point) const {
 	return false;
 }
 
-Vector SceneMan::MovePointToGround(const Vector& from, int maxAltitude, int accuracy) {
+Vector SceneMan::MovePointToGround(const Vector& from, int heightAboveGround, int accuracy, int maxDistance) {
 	if (IsPointInNoGravArea(from)) {
 		return from;
 	}
@@ -2253,12 +2253,11 @@ Vector SceneMan::MovePointToGround(const Vector& from, int maxAltitude, int accu
 	float altitude = FindAltitude(temp, g_SceneMan.GetSceneHeight(), accuracy);
 
 	// If there's no ground beneath us, do nothing
-	if (altitude == g_SceneMan.GetSceneHeight()) {
+	if (altitude == g_SceneMan.GetSceneHeight() || (maxDistance != 0 && altitude > maxDistance)) {
 		return temp;
 	}
 
-	// Only move down if we're above the maxAltitude over the ground
-	Vector groundPoint(temp.m_X, temp.m_Y + (altitude > maxAltitude ? altitude - maxAltitude : 0));
+	Vector groundPoint(temp.m_X, temp.m_Y + (altitude - heightAboveGround));
 	return groundPoint;
 }
 

Source/Managers/SceneMan.h

@@ -787,12 +787,17 @@ namespace RTE {
 		/// down at a certain maximum distance from the ground.
 		/// @param from The point to start from. Should be in the air, or the same point will
 		/// be returned (null operation)
-		/// @param maxAltitude The max altitude in px you want the point to be above the ground. (default: 0)
-		/// @param accuracy The accuracy within screen measurement is acceptable. Higher number (default: 0)
-		/// here means less calculation.
+		/// @param heightAboveGround The altitude in px you want the point to be above the ground. (default: 0)
+		/// @param accuracy The accuracy within screen measurement is acceptable. Higher number (default: 0) here means less calculation.
+		/// @param maxDistance The maximum distance downwards the point will be moved. Points higher than this will not be moved down.
 		/// @return The new point screen is no higher than accuracy + max altitude over
 		/// the terrain.
-		Vector MovePointToGround(const Vector& from, int maxAltitude = 0, int accuracy = 0);
+		Vector MovePointToGround(const Vector& from, int heightAboveGround, int accuracy, int maxDistance);
+
+		// Luabind makes this such a pain
+		Vector MovePointToGround(const Vector& from, int heightAboveGround = 0, int accuracy = 0) {
+			return MovePointToGround(from, heightAboveGround, accuracy, 0);
+		}
 
 		/// Returns whether the integer coordinates passed in are within the
 		/// bounds of the current Scene, considering its wrapping.

Source/System/PathFinder.cpp

@@ -361,7 +361,10 @@ void PathFinder::AdjacentCost(void* state, std::vector<micropather::StateCost>*
 					break;
 				}
 
-				totalMaterialCost += 1.0F + extraUpCost + (GetMaterialTransitionCost(*currentNode->UpMaterial) * 3.0F) + radiatedCost;
+				float f = i + 2; // Exponential cost increase for jumping higher
+				float extraJumpCost = f * f * 0.5F; // Exponential cost increase for jumping higher
+
+				totalMaterialCost += 1.0F + extraUpCost + extraJumpCost + (GetMaterialTransitionCost(*currentNode->UpMaterial) * 3.0F) + radiatedCost;
 
 				adjCost.cost = totalMaterialCost;
 				adjCost.state = static_cast<void*>(currentNode->Up);
@@ -385,7 +388,10 @@ void PathFinder::AdjacentCost(void* state, std::vector<micropather::StateCost>*
 					break;
 				}
 
-				totalMaterialCost += 1.4F + (extraUpCost * 1.4F) + (GetMaterialTransitionCost(*currentNode->UpRightMaterial) * 1.4F * 3.0F) + radiatedCost;
+				float f = i + 2; // Exponential cost increase for jumping higher
+				float extraJumpCost = f * f * 0.5F; // Exponential cost increase for jumping higher
+
+				totalMaterialCost += 1.4F + (extraUpCost * 1.4F) + (extraJumpCost * 1.4f) + (GetMaterialTransitionCost(*currentNode->UpRightMaterial) * 1.4F * 3.0F) + radiatedCost;
 
 				adjCost.cost = totalMaterialCost;
 				adjCost.state = static_cast<void*>(currentNode->UpRight);
@@ -404,7 +410,10 @@ void PathFinder::AdjacentCost(void* state, std::vector<micropather::StateCost>*
 					break;
 				}
 
-				totalMaterialCost += 1.4F + (extraUpCost * 1.4F) + (GetMaterialTransitionCost(*currentNode->LeftUpMaterial) * 1.4F * 3.0F) + radiatedCost;
+				float f = i + 2; // Exponential cost increase for jumping higher
+				float extraJumpCost = f * f * 0.5F; // Exponential cost increase for jumping higher
+
+				totalMaterialCost += 1.4F + (extraUpCost * 1.4F) + (extraJumpCost * 1.4f) + (GetMaterialTransitionCost(*currentNode->LeftUpMaterial) * 1.4F * 3.0F) + radiatedCost;
 
 				adjCost.cost = totalMaterialCost;
 				adjCost.state = static_cast<void*>(currentNode->LeftUp);