Bunch of improvements and additions to make fast movement work more consistently

Author: Causeless

CHANGELOG.md

@@ -31,7 +31,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - New `SoundContainer` features.  
 	Lua property `Paused` (R/W) to pause or unpause all sounds of a SoundContainer. Newly played sounds will not begin playback until unpaused.  
 	Lua function `GetAudibleVolume` to get the real audible volume of a SoundContainer's sounds as a float from 0 to 1. This accounts for literally everything, including game volume.
-	
+
+- New `LimbPath` features.
+	New `LimbPath` INI property `ScaleMultiplier`, which is a vector. This will scale the X/Y axes of the limbpath accordingly, allowing for easily adjusting limbpaths to differently sized actors.  
+	New `LimbPath` INI property `SegmentEndedThreshold`, which defines the distance the limb must be from the end of the segment before it's considered complete. This defaults to 2.5.  
+	The `TravelSpeedMultiplier` property has been adjusted to work more consistently when interacting with script.
+
 - New `AEmitter` and `PEmitter` INI and Lua (R/W) property `PlayBurstSound` which denotes whether the BurstSound should play when appropriate. This should not be confused for a trigger - it's just a enable/disable toggle to avoid having to remove and add BurstSound altogether.
 
 - Allow lua scripts to use LuaJIT's BitOp module (see https://bitop.luajit.org/api.html)
@@ -40,10 +45,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 <details><summary><b>Changed</b></summary>
 
-- Conquest activities will once again fall-back to using base dropships and rockets if a random selection of the selected tech's craft can't find one capable of carrying passengers and/or cargo.
-
-- All music-related functionality from AudioMan has been removed due to the addition of the MusicMan. Generic DynamicSongs have been put in to use instead.
-	Mod activities that used to queue up all the vanilla music should now instead call, for example, `MusicMan:PlayDynamicSong("Generic Battle Music")`
+- Improved navigation, making running and fast walkpaths much more consistent.
 
 - Increased fog-of-war resolution in all vanilla activities, and conquest, from 20x20 to 4x4.
 	The Ronin Scrambler, the basic scanner, and `SceneMan:CastUnseenRay` have been changed to accomodate fog-of-war resolutions as fine as 1x1 and as course as 20x20.
@@ -52,7 +54,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - All vanilla scenario activities have had their settings polished, respecting settings which make sense and disabling settings which don't.
 	You can now have fog of war in the test scene, and can no longer require path to orbit in Zero-G Diggers-Only One Man Army.
 
-- The Signal Hunt activity no longer has a preview image, as it was not formatted correctly and spoiled the interior structure of the cave.
+- Conquest activities will once again fall-back to using base dropships and rockets if a random selection of the selected tech's craft can't find one capable of carrying passengers and/or cargo.
 
 - `MovableMan:OpenAllDoors()`, when passed `NOTEAM`, will now open/close doors specifically for `NOTEAM` (instead of all doors).
 
@@ -74,6 +76,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 </details>
 
+<details><summary><b>Removed</b></summary>
+
+- All music-related functionality from AudioMan has been removed due to the addition of the MusicMan. Generic DynamicSongs have been put in to use instead.
+	Mod activities that used to queue up all the vanilla music should now instead call, for example, `MusicMan:PlayDynamicSong("Generic Battle Music")`
+
+- The Signal Hunt activity no longer has a preview image, as it was not formatted correctly and spoiled the interior structure of the cave.
+
+</details>
+
 ## [Release v6.2.2] - 2024/02/24
 
 <details><summary><b>Added</b></summary>

Source/Entities/AHuman.cpp

@@ -1372,8 +1372,13 @@ void AHuman::UpdateWalkAngle(AHuman::Layer whichLayer) {
 		const float maxAngleDegrees = 40.0F;
 		float terrainRotationDegs = std::clamp((hitPosRight - hitPosLeft).GetAbsDegAngle(), -maxAngleDegrees, maxAngleDegrees);
 
+		//const float fastMovementAngleReduction = 10.0F;
+		//const float ourMaxMovementSpeed = std::max(m_Paths[FGROUND][WALK].GetSpeed(), m_Paths[BGROUND][WALK].GetSpeed()) * 0.5F;
+		//float speedRotationDegs = Lerp(0.0F, ourMaxMovementSpeed, fastMovementAngleReduction, -fastMovementAngleReduction, m_Vel.m_X);
+		float speedRotationDegs = 0.0F; // TODO, this makes things stumble more although looks a bit better
+
 		Matrix walkAngle;
-		walkAngle.SetDegAngle(terrainRotationDegs);
+		walkAngle.SetDegAngle(terrainRotationDegs + speedRotationDegs);
 		m_WalkAngle[whichLayer] = walkAngle;
 	}
 }
@@ -1409,12 +1414,6 @@ void AHuman::UpdateCrouching() {
 		float finalWalkPathYOffset = std::clamp(Lerp(0.0F, 1.0F, -m_WalkPathOffset.m_Y, desiredWalkPathYOffset, 0.3F), 0.0F, m_MaxWalkPathCrouchShift);
 		m_WalkPathOffset.m_Y = -finalWalkPathYOffset;
 
-		// If crouching, move at reduced speed
-		const float crouchSpeedMultiplier = 0.5F;
-		float travelSpeedMultiplier = Lerp(0.0F, m_MaxWalkPathCrouchShift, 1.0F, crouchSpeedMultiplier, -m_WalkPathOffset.m_Y);
-		m_Paths[FGROUND][WALK].SetTravelSpeedMultiplier(travelSpeedMultiplier);
-		m_Paths[BGROUND][WALK].SetTravelSpeedMultiplier(travelSpeedMultiplier);
-
 		// Adjust our X offset to try to keep our legs under our centre-of-mass
 		const float ratioBetweenBodyAndHeadToAimFor = 0.15F;
 		float predictedPosition = ((m_pHead->GetPos().m_X - m_Pos.m_X) * ratioBetweenBodyAndHeadToAimFor) + m_Vel.m_X;
@@ -1424,6 +1423,35 @@ void AHuman::UpdateCrouching() {
 	}
 }
 
+void AHuman::UpdateLimbPathSpeed() {
+	// Reset travel speed so limbpath GetSpeed() gives us sensible values
+	m_Paths[FGROUND][m_MoveState].SetTravelSpeedMultiplier(1.0F);
+	m_Paths[BGROUND][m_MoveState].SetTravelSpeedMultiplier(1.0F);
+
+	if (m_MoveState == WALK || m_MoveState == CRAWL) {
+		// If crouching, move at reduced speed
+		const float crouchSpeedMultiplier = 0.5F;
+		float travelSpeedMultiplier = Lerp(0.0F, m_MaxWalkPathCrouchShift, 1.0F, crouchSpeedMultiplier, -m_WalkPathOffset.m_Y);
+
+		// If we're moving slowly horizontally, move at reduced speed (otherwise our legs kick about wildly as we're not yet up to speed)
+		// Calculate a min multiplier that is based on the total walkpath speed (so a fast walkpath has a smaller multipler). This is so a slow walkpath gets up to speed faster
+		const float ourMaxMovementSpeed = std::max(m_Paths[FGROUND][m_MoveState].GetSpeed(), m_Paths[BGROUND][m_MoveState].GetSpeed()) * 0.5F;
+		const float minSpeed = 2.0F;
+		const float minMultiplier = minSpeed / ourMaxMovementSpeed;
+		travelSpeedMultiplier *= Lerp(0.0F, ourMaxMovementSpeed, minMultiplier, 1.0F, std::abs(m_Vel.m_X));
+
+		m_Paths[FGROUND][m_MoveState].SetTravelSpeedMultiplier(travelSpeedMultiplier);
+		m_Paths[BGROUND][m_MoveState].SetTravelSpeedMultiplier(travelSpeedMultiplier);
+
+		// Also extend our stride depending on speed
+		const float strideXMultiplier = Lerp(0.0F, ourMaxMovementSpeed, 0.8F, 1.2F, std::abs(m_Vel.m_X));
+		const float strideYMultiplier = Lerp(0.0F, ourMaxMovementSpeed, 0.9F, 1.1F, std::abs(m_Vel.m_X));
+		Vector scale = Vector(strideXMultiplier, strideYMultiplier);
+		m_Paths[FGROUND][m_MoveState].SetScaleMultiplier(scale);
+		m_Paths[BGROUND][m_MoveState].SetScaleMultiplier(scale);
+	}
+}
+
 void AHuman::PreControllerUpdate() {
 	ZoneScoped;
 
@@ -1947,6 +1975,8 @@ void AHuman::PreControllerUpdate() {
 			UpdateWalkAngle(BGROUND);
 		}
 
+		UpdateLimbPathSpeed();
+
 		// WALKING, OR WE ARE JETPACKING AND STUCK
 		if (m_MoveState == WALK || (m_MoveState == JUMP && isStill)) {
 			m_Paths[FGROUND][STAND].Terminate();

Source/Entities/AHuman.h

@@ -415,13 +415,6 @@ namespace RTE {
 		/// held dormant in an inventory.
 		void ResetAllTimers() override;
 
-		/// Detects slopes in terrain and updates the walk path rotation for the corresponding Layer accordingly.
-		/// @param whichLayer The Layer in question.
-		void UpdateWalkAngle(AHuman::Layer whichLayer);
-
-		/// Detects overhead ceilings and crouches for them.
-		void UpdateCrouching();
-
 		/// Gets the walk path rotation for the specified Layer.
 		/// @param whichLayer The Layer in question.
 		/// @return The walk angle in radians.
@@ -570,6 +563,16 @@ namespace RTE {
 		/// @param progressScalar A normalized scalar that determines the magnitude of the reticle, to indicate force in the throw.
 		void DrawThrowingReticle(BITMAP* targetBitmap, const Vector& targetPos = Vector(), float progressScalar = 1.0F) const;
 
+		/// Detects slopes in terrain and updates the walk path rotation for the corresponding Layer accordingly.
+		/// @param whichLayer The Layer in question.
+		void UpdateWalkAngle(AHuman::Layer whichLayer);
+
+		/// Detects overhead ceilings and crouches for them.
+		void UpdateCrouching();
+
+		/// Updates our limbpath speed based on our current movement speed and style (crouching, walking etc).
+		void UpdateLimbPathSpeed();
+
 		// Member variables
 		static Entity::ClassInfo m_sClass;
 		// Articulated head.

Source/Entities/AtomGroup.cpp

@@ -1268,11 +1268,12 @@ bool AtomGroup::PushAsLimb(const Vector& jointPos, const Vector& velocity, const
 		                              owner->GetController()->IsState(MOVE_RIGHT) && pushImpulse.m_X < 0.0F;
 		if (againstTravelDirection) {
 			// Filter some of our impulse out. We're pushing against an obstacle, but we don't want to kick backwards!
-			const float againstIntendedDirectionMultiplier = 0.5F;
+			const float againstIntendedDirectionMultiplier = 0.3F;
 
 			if (!owner->GetController()->IsState(BODY_CROUCH) && !owner->GetController()->IsState(MOVE_DOWN)) {
 				// Translate it into to upwards motion to step over what we're walking into instead ;)
-				pushImpulse.m_Y -= std::abs(pushImpulse.m_X * (1.0F - againstIntendedDirectionMultiplier));
+				// Disabled just now.. causes us to jump up at high speeds
+				//pushImpulse.m_Y -= std::abs(pushImpulse.m_X * (1.0F - againstIntendedDirectionMultiplier));
 			}
 
 			pushImpulse.m_X *= againstIntendedDirectionMultiplier;

Source/Entities/LimbPath.cpp

@@ -27,7 +27,11 @@ void LimbPath::Clear() {
 	for (int i = 0; i < SPEEDCOUNT; ++i) {
 		m_TravelSpeed[i] = 0.0;
 	}
-	m_TravelSpeedMultiplier = 1.0F;
+	m_SegmentEndedThreshold = 2.5F;
+	m_BaseTravelSpeedMultiplier = 1.0F;
+	m_CurrentTravelSpeedMultiplier = 1.0F;
+	m_BaseScaleMultiplier = Vector(1.0F, 1.0F);
+	m_CurrentScaleMultiplier = Vector(1.0F, 1.0F);
 	m_WhichSpeed = NORMAL;
 	m_PushForce = 0.0;
 	m_JointPos.Reset();
@@ -103,7 +107,11 @@ int LimbPath::Create(const LimbPath& reference) {
 	for (int i = 0; i < SPEEDCOUNT; ++i) {
 		m_TravelSpeed[i] = reference.m_TravelSpeed[i];
 	}
-	m_TravelSpeedMultiplier = reference.m_TravelSpeedMultiplier;
+	m_SegmentEndedThreshold = reference.m_SegmentEndedThreshold;
+	m_BaseTravelSpeedMultiplier = reference.m_BaseTravelSpeedMultiplier;
+	m_CurrentTravelSpeedMultiplier = reference.m_CurrentTravelSpeedMultiplier;
+	m_BaseScaleMultiplier = reference.m_BaseScaleMultiplier;
+	m_CurrentScaleMultiplier = reference.m_CurrentScaleMultiplier;
 	m_PushForce = reference.m_PushForce;
 	m_TimeLeft = reference.m_TimeLeft;
 	m_TotalLength = reference.m_TotalLength;
@@ -132,6 +140,7 @@ int LimbPath::ReadProperty(const std::string_view& propName, Reader& reader) {
 		              }
 	              });
 	MatchProperty("EndSegCount", { reader >> m_FootCollisionsDisabledSegment; });
+	MatchProperty("SegmentEndedThreshold", { reader >> m_SegmentEndedThreshold; });
 
 	MatchProperty("SlowTravelSpeed", {
 		reader >> m_TravelSpeed[SLOW];
@@ -145,7 +154,8 @@ int LimbPath::ReadProperty(const std::string_view& propName, Reader& reader) {
 		reader >> m_TravelSpeed[FAST];
 		// m_TravelSpeed[FAST] = m_TravelSpeed[FAST] * 2;
 	});
-	MatchProperty("TravelSpeedMultiplier", { reader >> m_TravelSpeedMultiplier; });
+	MatchProperty("TravelSpeedMultiplier", { reader >> m_BaseTravelSpeedMultiplier; });
+	MatchProperty("ScaleMultiplier", { reader >> m_BaseScaleMultiplier; });
 	MatchProperty("PushForce", {
 		reader >> m_PushForce;
 		// m_PushForce = m_PushForce / 1.5;
@@ -162,24 +172,21 @@ Vector LimbPath::RotatePoint(const Vector& point) const {
 int LimbPath::Save(Writer& writer) const {
 	Entity::Save(writer);
 
-	writer.NewProperty("StartOffset");
-	writer << m_Start;
-	writer.NewProperty("StartSegCount");
-	writer << m_StartSegCount;
+	writer.NewPropertyWithValue("StartOffset", m_Start);
+	writer.NewPropertyWithValue("StartSegCount", m_StartSegCount);
 	for (std::deque<Vector>::const_iterator itr = m_Segments.begin(); itr != m_Segments.end(); ++itr) {
 		writer.NewProperty("AddSegment");
 		writer << *itr;
 	}
-	writer.NewProperty("SlowTravelSpeed");
-	writer << m_TravelSpeed[SLOW];
-	writer.NewProperty("NormalTravelSpeed");
-	writer << m_TravelSpeed[NORMAL];
-	writer.NewProperty("FastTravelSpeed");
-	writer << m_TravelSpeed[FAST];
-	writer.NewProperty("TravelSpeedMultiplier");
-	writer << m_TravelSpeedMultiplier;
-	writer.NewProperty("PushForce");
-	writer << m_PushForce;
+	writer.NewPropertyWithValue("EndSegCount", m_FootCollisionsDisabledSegment);
+	writer.NewPropertyWithValue("SegmentEndedThreshold", m_SegmentEndedThreshold);
+
+	writer.NewPropertyWithValue("SlowTravelSpeed", m_TravelSpeed[SLOW]);
+	writer.NewPropertyWithValue("NormalTravelSpeed", m_TravelSpeed[NORMAL]);
+	writer.NewPropertyWithValue("FastTravelSpeed", m_TravelSpeed[FAST]);
+	writer.NewPropertyWithValue("TravelSpeedMultiplier", m_BaseTravelSpeedMultiplier);
+	writer.NewPropertyWithValue("ScaleMultiplier", m_BaseScaleMultiplier);
+	writer.NewPropertyWithValue("PushForce", m_PushForce);
 
 	return 0;
 }
@@ -214,7 +221,7 @@ Vector LimbPath::GetProgressPos() {
 Vector LimbPath::GetCurrentSegTarget() {
 	Vector returnVec(m_Start);
 	if (IsStaticPoint()) {
-		return m_JointPos + RotatePoint(returnVec);
+		return m_JointPos + (RotatePoint(returnVec) * GetScaleMultiplier());
 	}
 
 	std::deque<Vector>::const_iterator itr;
@@ -227,13 +234,13 @@ Vector LimbPath::GetCurrentSegTarget() {
 		returnVec += *m_CurrentSegment;
 	}
 
-	return m_JointPos + RotatePoint(returnVec);
+	return m_JointPos + (RotatePoint(returnVec) * GetScaleMultiplier());
 }
 
 Vector LimbPath::GetCurrentVel(const Vector& limbPos) {
 	Vector returnVel;
 	Vector distVect = g_SceneMan.ShortestDistance(limbPos, GetCurrentSegTarget());
-	float adjustedTravelSpeed = (m_TravelSpeed[m_WhichSpeed] / (1.0F + std::abs(m_JointVel.GetY()) * 0.1F)) * m_TravelSpeedMultiplier;
+	float adjustedTravelSpeed = (m_TravelSpeed[m_WhichSpeed] / (1.0F + std::abs(m_JointVel.GetY()) * 0.1F)) * GetTravelSpeedMultiplier();
 
 	if (IsStaticPoint()) {
 		returnVel = distVect * c_MPP / 0.020 /* + m_JointVel*/;
@@ -290,9 +297,7 @@ void LimbPath::ReportProgress(const Vector& limbPos) {
 		float distance = distVec.GetMagnitude();
 		float segMag = (*(m_CurrentSegment)).GetMagnitude();
 
-		// TODO: Don't hardcode this!")
-		const float segmentEndedThreshold = 1.5F;
-		if (distance < segmentEndedThreshold) {
+		if (distance < m_SegmentEndedThreshold) {
 			if (++(m_CurrentSegment) == m_Segments.end()) {
 				--(m_CurrentSegment);
 				// Get normalized progress measure toward the target.
@@ -301,7 +306,7 @@ void LimbPath::ReportProgress(const Vector& limbPos) {
 			}
 			// Next segment!
 			else {
-				m_SegProgress = 0.0;
+				m_SegProgress = 0.0F;
 				m_SegTimer.Reset();
 				m_Ended = false;
 			}

Source/Entities/LimbPath.h

@@ -130,7 +130,7 @@ namespace RTE {
 
 		/// Gets the speed that a limb traveling this LimbPath should have.
 		/// @return A float describing the speed in m/s.
-		float GetSpeed() const { return m_TravelSpeed[m_WhichSpeed] * m_TravelSpeedMultiplier; }
+		float GetSpeed() const { return m_TravelSpeed[m_WhichSpeed] * GetTravelSpeedMultiplier(); }
 
 		/// Gets the speed that a limb traveling this LimbPath should have for the specified preset.
 		/// @param speedPreset Predefined speed preset to set the value for.
@@ -144,11 +144,19 @@ namespace RTE {
 
 		/// Sets the current travel speed multiplier.
 		/// @param newValue The new travel speed multiplier.
-		void SetTravelSpeedMultiplier(float newValue) { m_TravelSpeedMultiplier = newValue; }
+		void SetTravelSpeedMultiplier(float newValue) { m_CurrentTravelSpeedMultiplier = newValue; }
 
 		/// Gets the current travel speed multiplier.
 		/// @return The current travel speed multiplier.
-		float GetTravelSpeedMultiplier() const { return m_TravelSpeedMultiplier; }
+		float GetTravelSpeedMultiplier() const { return m_BaseTravelSpeedMultiplier * m_CurrentTravelSpeedMultiplier; }
+
+		/// Sets the current scale multiplier.
+		/// @param newValue The new scale multiplier.
+		void SetScaleMultiplier(Vector newValue) { m_CurrentScaleMultiplier = newValue; }
+
+		/// Gets the current scale multiplier.
+		/// @return The current scale multiplier.
+		Vector GetScaleMultiplier() const { return m_BaseScaleMultiplier * m_CurrentScaleMultiplier; }
 
 		/// Gets the force that a limb traveling this LimbPath can push against
 		/// stuff in the scene with. It will increase to the double if progress
@@ -173,12 +181,12 @@ namespace RTE {
 		/// Gets the total time that this entire path should take to travel along
 		/// with the current speed setting, including the start segments.
 		/// @return The total time (ms) this should take to travel along, if unobstructed.
-		float GetTotalPathTime() const { return ((m_TotalLength * c_MPP) / (m_TravelSpeed[m_WhichSpeed] * m_TravelSpeedMultiplier)) * 1000; }
+		float GetTotalPathTime() const { return ((m_TotalLength * c_MPP * GetScaleMultiplier().GetMagnitude()) / (m_TravelSpeed[m_WhichSpeed] * GetTravelSpeedMultiplier())) * 1000; }
 
 		/// Gets the total time that this path should take to travel along
 		/// with the current speed setting, NOT including the start segments.
 		/// @return The total time (ms) this should take to travel along, if unobstructed.
-		float GetRegularPathTime() const { return ((m_RegularLength * c_MPP) / (m_TravelSpeed[m_WhichSpeed] * m_TravelSpeedMultiplier)) * 1000; }
+		float GetRegularPathTime() const { return ((m_RegularLength * c_MPP * GetScaleMultiplier().GetMagnitude()) / (m_TravelSpeed[m_WhichSpeed] * GetTravelSpeedMultiplier())) * 1000; }
 
 		/// Gets the ratio of time since the path was restarted and the total time
 		/// it should take to travel along the path with the current speed setting,
@@ -381,8 +389,17 @@ namespace RTE {
 		// The constant speed that the limb traveling this path has in m/s.
 		float m_TravelSpeed[SPEEDCOUNT];
 
-		// The current travel speed multiplier
-		float m_TravelSpeedMultiplier;
+		// How close we must get to the end of each segment to consider it finished
+		float m_SegmentEndedThreshold;
+
+		// The base/current travel speed multiplier
+		float m_BaseTravelSpeedMultiplier;
+		float m_CurrentTravelSpeedMultiplier;
+
+		// The base/current scale multiplier (we extend the walkpath when running fast to take longer strides)
+		// This is a vector to allow scaling on seperate axis
+		Vector m_BaseScaleMultiplier;
+		Vector m_CurrentScaleMultiplier;
 
 		// The current speed setting.
 		int m_WhichSpeed;