minor refactoring regarding LimbPaths and locomotion

Author: pawnishoovy

CHANGELOG.md

@@ -42,9 +42,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 	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 and Lua (R/W) property `BaseTravelSpeedMultiplier` which is a multiplier on the TravelSpeed of that LimbPath, on top of any other gameplay multipliers like from crouching.
+	New `LimbPath` INI and Lua (R/W) property `BaseScaleMultiplier`, which is a vector. This will scale the X/Y axes of the limbpath accordingly, allowing for easily adjusting limbpaths to differently sized actors, on top of any other gameplay multipliers like from running.
 	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.
+	Exposed `LimbPath` properties `TravelSpeed` and `PushForce` to Lua (R/W).
 
 - 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.
 
@@ -69,6 +70,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - MOs now only play the BurstSound of the first Wound they receive in a frame, which not only solves audio spam during e.g. explosions but also preserves intended audio when firing guns with a high ParticleCount at them.
 
+- Changed how Get and SetLimbPathSpeed/PushForce work for `AHuman` and `ACrab`. The functions are as following:
+	`GetLimbPathSpeed` has been renamed to `GetLimbPathTravelSpeed`.
+	`SetLimbPathSpeed` has been renamed to `SetLimbPathTravelSpeed`.
+	`GetLimbPathTravelSpeed(Actor.MovementState)` returns the FG/left side (for crabs) limb path travel speed for that specific movement state, instead of being hardcoded to walking only.
+	`SetLimbPathTravelSpeed(Actor.MovementState, float newValue)` sets the travel speed for all layers and sides of any particular movement state's limb paths, instead of being hardcoded to walking only.
+	`GetLimbPathPushForce(Actor.MovementState)` returns the FG/left side (for crabs) limb path push force for that specific movement state, instead of being hardcoded to walking only.
+	`SetLimbPathPushForce(Actor.MovementState, float newValue)` sets the push force for all layers and sides of any particular movement state's limb paths, instead of being hardcoded to walking only.
+	
+- The `LimbPath` property `NormalTravelSpeed` has been renamed to just `TravelSpeed`.
+
 </details>
 
 <details><summary><b>Fixed</b></summary>
@@ -94,6 +105,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Removed `AHuman` property `MaxCrouchRotation`. `CrouchRotAngleTarget` is now used instead.
 
+- Deprecated `LimbPath` properties `SlowTravelSpeed`, `NormalTravelSpeed` and `FastTravelSpeed`. For the sake of backwards compatibility they will not crash the game and `NormalTravelSpeed` is a valid synonym for the new `TravelSpeed`.
+
 </details>
 
 ## [Release v6.2.2] - 2024/02/24

Data/Base.rte/Scripts/Global/FasterWalking.lua

@@ -23,9 +23,9 @@ function FasterWalkingScript:BoostWalkSpeed(actor)
 	end
 	if walker then
 		actor:SetNumberValue("FasterWalkingScript", 1);
-		walker:SetLimbPathSpeed(0, walker:GetLimbPathSpeed(0) * self.multiplier);
-		walker:SetLimbPathSpeed(1, walker:GetLimbPathSpeed(1) * self.multiplier);
-		walker:SetLimbPathSpeed(2, walker:GetLimbPathSpeed(2) * self.multiplier);
-		walker.LimbPathPushForce = walker.LimbPathPushForce * self.pushForceDenominator;
+		walker:SetLimbPathTravelSpeed(Actor.WALK, walker:GetLimbPathTravelSpeed(Actor.WALK) * self.multiplier);
+		walker:SetLimbPathTravelSpeed(Actor.RUN, walker:GetLimbPathTravelSpeed(Actor.RUN) * self.multiplier);
+		walker:SetLimbPathPushForce(Actor.WALK, walker:GetLimbPathPushForce(Actor.WALK) * self.pushForceDenominator);
+		walker:SetLimbPathPushForce(Actor.RUN, walker:GetLimbPathPushForce(Actor.RUN) * self.pushForceDenominator);
 	end
 end

Data/Imperatus.rte/Actors/Infantry/AllPurpose/AllPurposeRobot.ini

@@ -606,6 +606,7 @@ AddActor = AHuman
 	CrouchLimbPathBG = LimbPath
 		CopyOf = Human Crouch Path BG
 	CrouchRotAngleTarget = -0.5
+	CrouchWalkSpeedMultiplier = 0.6
 	CrawlLimbPath = LimbPath
 		PresetName = Robot Crawl Path
 		StartOffset = Vector

Data/Imperatus.rte/Actors/Infantry/Combat/CombatRobot.ini

@@ -571,6 +571,7 @@ AddActor = AHuman
 	CrouchLimbPathBG = LimbPath
 		CopyOf = Human Crouch Path BG
 	CrouchRotAngleTarget = -0.4
+	CrouchWalkSpeedMultiplier = 0.45
 	CrawlLimbPath = LimbPath
 		CopyOf = Robot Crawl Path
 	ArmCrawlLimbPath = LimbPath

Data/Imperatus.rte/Actors/Shared/Robot.lua

@@ -1,15 +1,17 @@
 function Create(self)
-	self.walkSpeed = self:GetLimbPathSpeed(1);
+	self.baseWalkSpeed = self:GetLimbPathTravelSpeed(Actor.WALK);
 end
 
 function ThreadedUpdate(self)
-	if self.Health > 0 then
+	self:SetLimbPathTravelSpeed(Actor.WALK, self.baseWalkSpeed);
+	local controller = self:GetController();
+	if self.Health > 0 and not controller:IsState(Controller.BODY_WALKCROUCH) then
 		local walkSpeedScalar = 2.3;
 		local legs = {self.FGLeg, self.BGLeg};
 		for _, leg in pairs(legs) do
 			walkSpeedScalar = walkSpeedScalar - (leg and leg.Frame/leg.FrameCount or 1.1);
 		end
-		self:SetLimbPathSpeed(1, self.walkSpeed * walkSpeedScalar);
+		self:SetLimbPathTravelSpeed(Actor.WALK, self.baseWalkSpeed * walkSpeedScalar);
 		--[[Display health as relative to physical damage? (to-do this in source instead)
 		if self.Head and (self.FGArm or self.BGArm or self.FGLeg or self.BGLeg) then
 			local limbs = {self.Head, self.FGArm, self.BGArm, self.FGLeg, self.BGLeg};

Source/Entities/ACrab.cpp

@@ -811,10 +811,11 @@ void ACrab::PreControllerUpdate() {
 
 				m_MoveState = WALK;
 
-				for (int side = 0; side < SIDECOUNT; ++side) {
-					m_Paths[side][FGROUND][m_MoveState].SetSpeed(m_Controller.IsState(MOVE_FAST) ? FAST : NORMAL);
-					m_Paths[side][BGROUND][m_MoveState].SetSpeed(m_Controller.IsState(MOVE_FAST) ? FAST : NORMAL);
-				}
+				// Was never actually used
+				//for (int side = 0; side < SIDECOUNT; ++side) {
+				//	m_Paths[side][FGROUND][m_MoveState].SetSpeed(m_Controller.IsState(MOVE_FAST) ? FAST : NORMAL);
+				//	m_Paths[side][BGROUND][m_MoveState].SetSpeed(m_Controller.IsState(MOVE_FAST) ? FAST : NORMAL);
+				//}
 			}
 
 			// Walk backwards if the aiming is already focused in the opposite direction of travel.
@@ -1434,28 +1435,28 @@ void ACrab::DrawHUD(BITMAP* pTargetBitmap, const Vector& targetPos, int whichScr
 	}
 }
 
-float ACrab::GetLimbPathSpeed(int speedPreset) const {
-	return m_Paths[LEFTSIDE][FGROUND][WALK].GetSpeed(speedPreset);
+float ACrab::GetLimbPathTravelSpeed(MovementState movementState) {
+	return m_Paths[LEFTSIDE][FGROUND][movementState].GetTravelSpeed();
 }
 
-void ACrab::SetLimbPathSpeed(int speedPreset, float speed) {
-	m_Paths[LEFTSIDE][FGROUND][WALK].OverrideSpeed(speedPreset, speed);
-	m_Paths[RIGHTSIDE][FGROUND][WALK].OverrideSpeed(speedPreset, speed);
+void ACrab::SetLimbPathTravelSpeed(MovementState movementState, float newSpeed) {
+	m_Paths[LEFTSIDE][FGROUND][movementState].SetTravelSpeed(newSpeed);
+	m_Paths[RIGHTSIDE][FGROUND][movementState].SetTravelSpeed(newSpeed);
 
-	m_Paths[LEFTSIDE][BGROUND][WALK].OverrideSpeed(speedPreset, speed);
-	m_Paths[RIGHTSIDE][BGROUND][WALK].OverrideSpeed(speedPreset, speed);
+	m_Paths[LEFTSIDE][BGROUND][movementState].SetTravelSpeed(newSpeed);
+	m_Paths[RIGHTSIDE][BGROUND][movementState].SetTravelSpeed(newSpeed);
 }
 
-float ACrab::GetLimbPathPushForce() const {
-	return m_Paths[LEFTSIDE][FGROUND][WALK].GetDefaultPushForce();
+float ACrab::GetLimbPathPushForce(MovementState movementState) {
+	return m_Paths[LEFTSIDE][FGROUND][movementState].GetPushForce();
 }
 
-void ACrab::SetLimbPathPushForce(float force) {
-	m_Paths[LEFTSIDE][FGROUND][WALK].OverridePushForce(force);
-	m_Paths[RIGHTSIDE][FGROUND][WALK].OverridePushForce(force);
+void ACrab::SetLimbPathPushForce(MovementState movementState, float newForce) {
+	m_Paths[LEFTSIDE][FGROUND][movementState].SetPushForce(newForce);
+	m_Paths[RIGHTSIDE][FGROUND][movementState].SetPushForce(newForce);
 
-	m_Paths[LEFTSIDE][BGROUND][WALK].OverridePushForce(force);
-	m_Paths[RIGHTSIDE][BGROUND][WALK].OverridePushForce(force);
+	m_Paths[LEFTSIDE][BGROUND][movementState].SetPushForce(newForce);
+	m_Paths[RIGHTSIDE][BGROUND][movementState].SetPushForce(newForce);
 }
 
 int ACrab::WhilePieMenuOpenListener(const PieMenu* pieMenu) {

Source/Entities/ACrab.h

@@ -224,24 +224,24 @@ namespace RTE {
 		/// @return The LimbPath corresponding to the passed in Layer and MovementState values.
 		LimbPath* GetLimbPath(Side side, Layer layer, MovementState movementState) { return &m_Paths[side][layer][movementState]; }
 
-		/// Get walking limb path speed for the specified preset.
-		/// @param speedPreset Speed preset to set 0 = LimbPath::SLOW, 1 = Limbpath::NORMAL, 2 = LimbPath::FAST
-		/// @return Limb path speed for the specified preset in m/s.
-		float GetLimbPathSpeed(int speedPreset) const;
-
-		/// Set walking limb path speed for the specified preset.
-		/// @param speedPreset Speed preset to set 0 = LimbPath::SLOW, 1 = Limbpath::NORMAL, 2 = LimbPath::FAST. New speed value in m/s.
-		void SetLimbPathSpeed(int speedPreset, float speed);
-
-		/// Gets the default force that a limb traveling walking LimbPath can push against
-		/// stuff in the scene with.
-		/// @return The default set force maximum, in kg * m/s^2.
-		float GetLimbPathPushForce() const;
-
-		/// Sets the default force that a limb traveling walking LimbPath can push against
-		/// stuff in the scene with.
-		/// @param force The default set force maximum, in kg * m/s^2.
-		void SetLimbPathPushForce(float force);
+		/// Shortcut to get the speed of a particular move state's FG (and left side if relevant) limb path.
+		/// @param movementState Which movement state to get the limb path speed for.
+		/// @return Limb path speed for the specified movement state in m/s.
+		float GetLimbPathTravelSpeed(MovementState movementState);
+
+		/// Shortcut to set the speed of a particular move state's limb path, including all layers (and sides if relevant)
+		/// @param movementState Which movement state to set the limb path speed for.
+		/// @param newSpeed New speed value in m/s.
+		void SetLimbPathTravelSpeed(MovementState movementStateourmaxmovement, float newSpeed);
+
+		/// Shortcut to get the push force of a particular move state's FG (and left side if relevant) limb path.
+		/// @return The push force, in kg * m/s^2.
+		float GetLimbPathPushForce(MovementState movementState);
+
+		/// Shortcut to set the push force of a particular move state's limb path, including all layers (and sides if relevant)
+		/// @param movementState Which movement state to set the limb path speed for.
+		/// @param newForce New push force value in kg * m/s^2.
+		void SetLimbPathPushForce(MovementState movementState, float newForce);
 
 		/// Gets this ACrab's stride sound. Ownership is NOT transferred!
 		/// @return The SoundContainer for this ACrab's stride sound.

Source/Entities/AHuman.cpp

@@ -218,8 +218,9 @@ int AHuman::Create(const AHuman& reference) {
 	if (m_Paths[FGROUND][RUN].GetSegCount() == 0) {
 		m_Paths[FGROUND][RUN].Create(reference.m_Paths[FGROUND][WALK]);
 		m_Paths[BGROUND][RUN].Create(reference.m_Paths[BGROUND][WALK]);
-		m_Paths[FGROUND][RUN].SetBaseSpeedMultiplier(reference.m_Paths[FGROUND][WALK].GetSpeed(Speed::FAST) / reference.m_Paths[FGROUND][WALK].GetSpeed(Speed::NORMAL));
-		m_Paths[BGROUND][RUN].SetBaseSpeedMultiplier(reference.m_Paths[BGROUND][WALK].GetSpeed(Speed::FAST) / reference.m_Paths[BGROUND][WALK].GetSpeed(Speed::NORMAL));
+		// Sensible default multiplier
+		m_Paths[FGROUND][RUN].SetTravelSpeed(m_Paths[FGROUND][RUN].GetTravelSpeed() * 1.5);
+		m_Paths[BGROUND][RUN].SetTravelSpeed(m_Paths[BGROUND][RUN].GetTravelSpeed() * 1.5);
 	}
 
 	return 0;
@@ -1419,22 +1420,17 @@ 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 == RUN || m_MoveState == CRAWL) {
 		float travelSpeedMultiplier = 1.0F;
 
 		// If crouching, move at reduced speed
 		if (m_MoveState == WALK) {
-			const float crouchSpeedMultiplier = 0.7F;
-			travelSpeedMultiplier *= Lerp(0.0F, 1.0F, 1.0F, crouchSpeedMultiplier, m_CrouchAmount);
+			travelSpeedMultiplier *= Lerp(0.0F, 1.0F, 1.0F, m_CrouchWalkSpeedMultiplier, m_CrouchAmount);
 		}
 
 		// 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 * travelSpeedMultiplier;
+		const float ourMaxMovementSpeed = std::max(m_Paths[FGROUND][m_MoveState].GetTravelSpeed(), m_Paths[BGROUND][m_MoveState].GetTravelSpeed()) * 0.5F * travelSpeedMultiplier;
 		const float minSpeed = 2.0F;
 		const float minMultiplier = minSpeed / ourMaxMovementSpeed;
 		travelSpeedMultiplier *= Lerp(0.0F, ourMaxMovementSpeed, minMultiplier, 1.0F, std::abs(m_Vel.m_X));
@@ -2817,22 +2813,25 @@ void AHuman::DrawHUD(BITMAP* pTargetBitmap, const Vector& targetPos, int whichSc
 	}
 }
 
-float AHuman::GetLimbPathSpeed(int speedPreset) const {
-	return m_Paths[FGROUND][WALK].GetSpeed(speedPreset);
+float AHuman::GetLimbPathTravelSpeed(MovementState movementState) {
+	return m_Paths[FGROUND][movementState].GetTravelSpeed();
 }
 
-void AHuman::SetLimbPathSpeed(int speedPreset, float speed) {
-	m_Paths[FGROUND][WALK].OverrideSpeed(speedPreset, speed);
-	m_Paths[BGROUND][WALK].OverrideSpeed(speedPreset, speed);
+void AHuman::SetLimbPathTravelSpeed(MovementState movementState, float newSpeed) {
+	m_Paths[FGROUND][movementState].SetTravelSpeed(newSpeed);
+	m_Paths[FGROUND][movementState].SetTravelSpeed(newSpeed);
 }
 
-float AHuman::GetLimbPathPushForce() const {
-	return m_Paths[FGROUND][WALK].GetDefaultPushForce();
+float AHuman::GetLimbPathPushForce(MovementState movementState) {
+	return m_Paths[FGROUND][movementState].GetPushForce();
 }
 
-void AHuman::SetLimbPathPushForce(float force) {
-	m_Paths[FGROUND][WALK].OverridePushForce(force);
-	m_Paths[BGROUND][WALK].OverridePushForce(force);
+void AHuman::SetLimbPathPushForce(MovementState movementState, float newForce) {
+	m_Paths[FGROUND][movementState].SetPushForce(newForce);
+	m_Paths[FGROUND][movementState].SetPushForce(newForce);
+
+	m_Paths[BGROUND][movementState].SetPushForce(newForce);
+	m_Paths[BGROUND][movementState].SetPushForce(newForce);
 }
 
 int AHuman::WhilePieMenuOpenListener(const PieMenu* pieMenu) {

Source/Entities/AHuman.h

@@ -462,24 +462,24 @@ namespace RTE {
 		/// @return The LimbPath corresponding to the passed in Layer and MovementState values.
 		LimbPath* GetLimbPath(Layer layer, MovementState movementState) { return &m_Paths[layer][movementState]; }
 
-		/// Get walking limb path speed for the specified preset.
-		/// @param speedPreset Speed preset to set 0 = LimbPath::SLOW, 1 = Limbpath::NORMAL, 2 = LimbPath::FAST
-		/// @return Limb path speed for the specified preset in m/s.
-		float GetLimbPathSpeed(int speedPreset) const;
-
-		/// Set walking limb path speed for the specified preset.
-		/// @param speedPreset Speed preset to set 0 = LimbPath::SLOW, 1 = Limbpath::NORMAL, 2 = LimbPath::FAST. New speed value in m/s.
-		void SetLimbPathSpeed(int speedPreset, float speed);
-
-		/// Gets the default force that a limb traveling walking LimbPath can push against
-		/// stuff in the scene with.
-		/// @return The default set force maximum, in kg * m/s^2.
-		float GetLimbPathPushForce() const;
-
-		/// Sets the default force that a limb traveling walking LimbPath can push against
-		/// stuff in the scene with.
-		/// @param force The default set force maximum, in kg * m/s^2.
-		void SetLimbPathPushForce(float force);
+		/// Shortcut to get the speed of a particular move state's FG (and left side if relevant) limb path.
+		/// @param movementState Which movement state to get the limb path speed for.
+		/// @return Limb path speed for the specified movement state in m/s.
+		float GetLimbPathTravelSpeed(MovementState movementState);
+
+		/// Shortcut to set the speed of a particular move state's limb path, including all layers (and sides if relevant)
+		/// @param movementState Which movement state to set the limb path speed for.
+		/// @param newSpeed New speed value in m/s.
+		void SetLimbPathTravelSpeed(MovementState movementState, float newSpeed);
+
+		/// Shortcut to get the push force of a particular move state's FG (and left side if relevant) limb path.
+		/// @return The push force, in kg * m/s^2.
+		float GetLimbPathPushForce(MovementState movementState);
+
+		/// Shortcut to set the push force of a particular move state's limb path, including all layers (and sides if relevant)
+		/// @param movementState Which movement state to set the limb path speed for.
+		/// @param newForce New push force value in kg * m/s^2.
+		void SetLimbPathPushForce(MovementState movementState, float newForce);
 
 		/// Gets the target rot angle for the given MovementState.
 		/// @param movementState The MovementState to get the rot angle target for.

Source/Entities/Actor.cpp

@@ -67,6 +67,7 @@ void Actor::Clear() {
 	m_StableVel.SetXY(15.0F, 25.0F);
 	m_StableRecoverDelay = 1000;
 	m_CanRun = true;
+	m_CrouchWalkSpeedMultiplier = 0.7F;
 	m_HeartBeat.Reset();
 	m_NewControlTmr.Reset();
 	m_DeathTmr.Reset();
@@ -200,6 +201,7 @@ int Actor::Create(const Actor& reference) {
 	m_StableVel = reference.m_StableVel;
 	m_StableRecoverDelay = reference.m_StableRecoverDelay;
 	m_CanRun = reference.m_CanRun;
+	m_CrouchWalkSpeedMultiplier = reference.m_CrouchWalkSpeedMultiplier;
 	m_GoldCarried = reference.m_GoldCarried;
 	m_AimState = reference.m_AimState;
 	m_AimRange = reference.m_AimRange;
@@ -330,6 +332,7 @@ int Actor::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("StableVelocityThreshold", { reader >> m_StableVel; });
 	MatchProperty("StableRecoveryDelay", { reader >> m_StableRecoverDelay; });
 	MatchProperty("CanRun", { reader >> m_CanRun; });
+	MatchProperty("CrouchWalkSpeedMultiplier", { reader >> m_CrouchWalkSpeedMultiplier; });
 	MatchProperty("AimAngle", { reader >> m_AimAngle; });
 	MatchProperty("AimRange", { reader >> m_AimRange; });
 	MatchProperty("AimDistance", { reader >> m_AimDistance; });
@@ -406,6 +409,8 @@ int Actor::Save(Writer& writer) const {
 	writer << m_StableRecoverDelay;
 	writer.NewProperty("CanRun");
 	writer << m_CanRun;
+	writer.NewProperty("CrouchWalkSpeedMultiplier");
+	writer << m_CrouchWalkSpeedMultiplier;
 	writer.NewProperty("AimAngle");
 	writer << m_AimAngle;
 	writer.NewProperty("AimRange");