prone is now prone, crouch is now crouch, CanRun, other improvements

Author: pawnishoovy

CHANGELOG.md

@@ -16,12 +16,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 	New `Actor` Lua property `JumpHeight` (R) to estimate the jump height of the actor (in metres), based on the actor's jetpack and weight. Actors without a jetpack return 0.  
 	The new function `GetPathFindingFlyingJumpHeight()` can be used to get a jumpHeight that allows flying (i.e infinite jump height). This is also the value that `ACRocket`s and `ACDropships` return for `JumpHeight`.
 
-- Improved Locomotion.
+- Improved locomotion.
 	Added the ability to run. When running, you cannot sharpaim whatsoever.
-	Added the ability to manually crouch. When crouching, your sharpaim distance is sligtly increased.
+	Added the ability to manually crouch. When crouching, your sharpaim distance is slightly increased.
 	Players on PC can enable running by holding the shift key, or crouch by holding control. Players using the arrow keys can use right ctrl/shift. Controllers can run by clicking in the left stick, or crouch by holding the left stick down. Prone on controllers is now performed by clicking in the right stick. SNES/d-pad controllers run using the right bumper.
-	Added new `MovementState` type `RUN` for script.
-	Added new `Controller` state `WALKCROUCH` for crouching, and `PRONE` for prone. The existing `CROUCH` state has been deprecated, as it referred to PRONE. 
+	Prone input now immediately throws you to the ground instead of crouching first.
+	Added new `MovementState` type `RUN` for scripts.
+	Added new `Controller` state `WALKCROUCH` for crouching, and `PRONE` for prone. The existing `CROUCH` state has been deprecated, as it referred to PRONE.
+	Added new `Actor` INI and Lua (R/W) property `CanRun` which denotes whether the Actor can run or not.
 
 - 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.
@@ -90,6 +92,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - The Signal Hunt activity no longer has a preview image, as it was not formatted correctly and spoiled the interior structure of the cave.
 
+- Removed `AHUman` property MaxCrouchRotation. CrouchRotAngleTarget is now used.
+
 </details>
 
 ## [Release v6.2.2] - 2024/02/24

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

@@ -525,6 +525,7 @@ AddActor = AHuman
 	SharpAimDelay = 280
 	Perceptiveness = 0.9
 	CharHeight = 100
+	CanRun = 0
 	HolsterOffset = Vector
 		X = -6
 		Y = -4

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

@@ -483,6 +483,7 @@ AddActor = AHuman
 	SharpAimDelay = 300
 	Perceptiveness = 0.8
 	CharHeight = 100
+	CanRun = 0
 	HolsterOffset = Vector
 		X = -6
 		Y = -10

Source/Entities/AHuman.cpp

@@ -55,7 +55,7 @@ void AHuman::Clear() {
 	m_ProneState = NOTPRONE;
 	m_ProneTimer.Reset();
 	m_MaxWalkPathCrouchShift = 6.0F;
-	m_MaxCrouchRotation = c_QuarterPI * 0.85F;
+	m_CrouchAmount = 0.0F;
 	m_CrouchAmountOverride = -1.0F;
 	for (int i = 0; i < MOVEMENTSTATECOUNT; ++i) {
 		m_Paths[FGROUND][i].Reset();
@@ -64,6 +64,8 @@ void AHuman::Clear() {
 		m_Paths[BGROUND][i].Terminate();
 		m_RotAngleTargets[i] = 0.0F;
 	}
+	// Default CROUCH RotAngleTarget to a more sensible number
+	m_RotAngleTargets[CROUCH] = c_QuarterPI * 0.85F;
 	m_Aiming = false;
 	m_ArmClimbing[FGROUND] = false;
 	m_ArmClimbing[BGROUND] = false;
@@ -213,7 +215,6 @@ int AHuman::Create(const AHuman& reference) {
 	m_BackupBGFootGroup->SetLimbPos(atomGroupToUseAsFootGroupBG->GetLimbPos());
 
 	m_MaxWalkPathCrouchShift = reference.m_MaxWalkPathCrouchShift;
-	m_MaxCrouchRotation = reference.m_MaxCrouchRotation;
 
 	if (reference.m_StrideSound) {
 		m_StrideSound = dynamic_cast<SoundContainer*>(reference.m_StrideSound->Clone());
@@ -293,7 +294,6 @@ int AHuman::ReadProperty(const std::string_view& propName, Reader& reader) {
 		m_BackupBGFootGroup->RemoveAllAtoms();
 	});
 	MatchProperty("MaxWalkPathCrouchShift", { reader >> m_MaxWalkPathCrouchShift; });
-	MatchProperty("MaxCrouchRotation", { reader >> m_MaxCrouchRotation; });
 	MatchProperty("StrideSound", {
 		m_StrideSound = new SoundContainer;
 		reader >> m_StrideSound;
@@ -302,8 +302,8 @@ int AHuman::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("StandLimbPathBG", { reader >> m_Paths[BGROUND][STAND]; });
 	MatchProperty("WalkLimbPath", { reader >> m_Paths[FGROUND][WALK]; });
 	MatchProperty("RunLimbPath", { reader >> m_Paths[FGROUND][RUN]; });
-	MatchProperty("CrouchLimbPath", { reader >> m_Paths[FGROUND][CROUCH]; });
-	MatchProperty("CrouchLimbPathBG", { reader >> m_Paths[BGROUND][CROUCH]; });
+	MatchProperty("CrouchLimbPath", { reader >> m_Paths[FGROUND][PRONE]; });
+	MatchProperty("CrouchLimbPathBG", { reader >> m_Paths[BGROUND][PRONE]; });
 	MatchProperty("CrawlLimbPath", { reader >> m_Paths[FGROUND][CRAWL]; });
 	MatchProperty("ArmCrawlLimbPath", { reader >> m_Paths[FGROUND][ARMCRAWL]; });
 	MatchProperty("ClimbLimbPath", { reader >> m_Paths[FGROUND][CLIMB]; });
@@ -353,8 +353,6 @@ int AHuman::Save(Writer& writer) const {
 	writer << m_pBGFootGroup;
 	writer.NewProperty("MaxWalkPathCrouchShift");
 	writer << m_MaxWalkPathCrouchShift;
-	writer.NewProperty("MaxCrouchRotation");
-	writer << m_MaxCrouchRotation;
 	writer.NewProperty("StrideSound");
 	writer << m_StrideSound;
 
@@ -367,7 +365,7 @@ int AHuman::Save(Writer& writer) const {
 	writer.NewProperty("RunLimbPath");
 	writer << m_Paths[FGROUND][RUN];
 	writer.NewProperty("CrouchLimbPath");
-	writer << m_Paths[FGROUND][CROUCH];
+	writer << m_Paths[FGROUND][PRONE];
 	writer.NewProperty("CrawlLimbPath");
 	writer << m_Paths[FGROUND][CRAWL];
 	writer.NewProperty("ArmCrawlLimbPath");
@@ -382,7 +380,7 @@ int AHuman::Save(Writer& writer) const {
 	writer.NewPropertyWithValue("StandRotAngleTarget", m_RotAngleTargets[STAND]);
 	writer.NewPropertyWithValue("WalkRotAngleTarget", m_RotAngleTargets[WALK]);
 	writer.NewPropertyWithValue("RunRotAngleTarget", m_RotAngleTargets[RUN]);
-	writer.NewPropertyWithValue("CrouchRotAngleTarget", m_RotAngleTargets[CROUCH]);
+	writer.NewPropertyWithValue("CrouchRotAngleTarget", m_RotAngleTargets[PRONE]);
 	writer.NewPropertyWithValue("JumpRotAngleTarget", m_RotAngleTargets[JUMP]);
 
 	return 0;
@@ -1438,12 +1436,19 @@ 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;
+	
+	m_CrouchAmount = desiredWalkPathYOffset / m_MaxWalkPathCrouchShift;
 
 	// Adjust our X offset to try to keep our legs under our centre-of-mass
 	const float ratioBetweenBodyAndHeadToAimFor = 0.15F;
 	Vector headPos = m_pHead ? m_pHead->GetPos() : m_Pos;
 	float predictedPosition = ((headPos.m_X - m_Pos.m_X) * ratioBetweenBodyAndHeadToAimFor) + m_Vel.m_X;
 	m_WalkPathOffset.m_X = predictedPosition;
+	if (m_CrouchAmount > 0.9F && !m_MoveState == WALK ) {
+		// Let the CrouchLimbPath take over here
+		m_WalkPathOffset.m_Y = 0.0F;
+		m_WalkPathOffset.m_X = 0.0F;
+	}
 }
 
 void AHuman::UpdateLimbPathSpeed() {
@@ -1512,6 +1517,11 @@ void AHuman::PreControllerUpdate() {
 
 	if (!keepOldState) {
 		bool prone = m_Controller.IsState(BODY_PRONE);
+		// Engage prone state, this makes the body's rotational spring pull it horizontal instead of upright.
+		if (prone && m_ProneState == NOTPRONE) {
+			m_ProneState = GOPRONE;
+			m_ProneTimer.Reset();
+		}
 		if ((m_Controller.IsState(MOVE_RIGHT) || m_Controller.IsState(MOVE_LEFT) || m_MoveState == JUMP) && m_Status != INACTIVE) {
 			for (int i = WALK; i < MOVEMENTSTATECOUNT; ++i) {
 				m_Paths[FGROUND][i].SetHFlip(m_HFlipped);
@@ -1520,9 +1530,9 @@ void AHuman::PreControllerUpdate() {
 			// Only if not jumping, OR if jumping, and apparently stuck on something - then help out with the limbs.
 			if (m_MoveState != JUMP || isStill) {
 				MovementState oldMoveState = m_MoveState;
-				if (prone) {
+				if (!m_ProneState == NOTPRONE) {
 					m_MoveState = CRAWL;
-				} else if (m_Controller.IsState(MOVE_FAST) && !m_Controller.IsState(BODY_CROUCH)) {
+				} else if (m_CanRun && m_Controller.IsState(MOVE_FAST) && !m_Controller.IsState(BODY_CROUCH)) {
 					m_MoveState = RUN;
 				} else {
 					m_MoveState = WALK;
@@ -1533,12 +1543,6 @@ void AHuman::PreControllerUpdate() {
 					m_StrideStart = true;
 					MoveOutOfTerrain(g_MaterialGrass);
 				}
-
-				// Engage prone state, this makes the body's rotational spring pull it horizontal instead of upright.
-				if (m_MoveState == CRAWL && m_ProneState == NOTPRONE) {
-					m_ProneState = GOPRONE;
-					m_ProneTimer.Reset();
-				}
 			}
 
 			// Walk backwards if the aiming is already focused in the opposite direction of travel.
@@ -1562,15 +1566,18 @@ void AHuman::PreControllerUpdate() {
 				m_StrideStart = true;
 				// Stop the going prone spring.
 				if (m_ProneState == GOPRONE) {
-					m_ProneState = PRONE;
+					m_ProneState = LAYINGPRONE;
 				}
 			}
 		} else {
 			m_ArmClimbing[FGROUND] = false;
 			m_ArmClimbing[BGROUND] = false;
 			if (prone) {
 				// Don't go back to prone if we're already prone, the player has to let go of the crouch button first. If already laying down, just stay put.
-				m_MoveState = m_ProneState == NOTPRONE ? CROUCH : NOMOVE;
+				m_MoveState = m_ProneState == NOTPRONE ? PRONE : NOMOVE;
+			} else if (m_CrouchAmount > 0.9F) {
+				// Fully crouching will set the appropriate state so we can use CrouchLimbPath
+				m_MoveState = CROUCH;
 			} else {
 				m_MoveState = STAND;
 			}
@@ -1682,7 +1689,7 @@ void AHuman::PreControllerUpdate() {
 			m_StrideStart = true;
 			// Stop the going prone spring.
 			if (m_ProneState == GOPRONE) {
-				m_ProneState = PRONE;
+				m_ProneState = LAYINGPRONE;
 			}
 		}
 		// Correct angle based on flip.
@@ -1699,7 +1706,7 @@ void AHuman::PreControllerUpdate() {
 
 	// TODO: make the delay data driven by both the actor and the device!
 	//
-	if (isSharpAiming && m_Status == STABLE && (m_MoveState == STAND || m_MoveState == CROUCH || m_MoveState == NOMOVE || m_MoveState == WALK) && m_Vel.MagnitudeIsLessThan(5.0F) && GetEquippedItem()) {
+	if (isSharpAiming && m_Status == STABLE && (m_MoveState == STAND || m_MoveState == PRONE || m_MoveState == NOMOVE || m_MoveState == WALK) && m_Vel.MagnitudeIsLessThan(5.0F) && GetEquippedItem()) {
 		float aimMag = analogAim.GetMagnitude();
 
 		// If aim sharp is being done digitally, then translate to full analog aim mag
@@ -2119,7 +2126,7 @@ void AHuman::PreControllerUpdate() {
 			}
 		} else if (m_MoveState == CRAWL) {
 			// Start crawling only once we are fully prone.
-			if (m_ProneState == PRONE) {
+			if (m_ProneState == LAYINGPRONE) {
 
 				float FGLegProg = m_Paths[FGROUND][CRAWL].GetRegularProgress();
 				float BGLegProg = m_Paths[BGROUND][CRAWL].GetRegularProgress();
@@ -2184,11 +2191,11 @@ void AHuman::PreControllerUpdate() {
 					m_Paths[BGROUND][CRAWL].Terminate();
 
 					if (m_pFGLeg) {
-						m_pFGFootGroup->PushAsLimb(m_Pos.GetFloored() + m_pFGLeg->GetParentOffset().GetXFlipped(m_HFlipped), m_Vel, Matrix(), m_Paths[FGROUND][CROUCH], deltaTime);
+						m_pFGFootGroup->PushAsLimb(m_Pos.GetFloored() + m_pFGLeg->GetParentOffset().GetXFlipped(m_HFlipped), m_Vel, Matrix(), m_Paths[FGROUND][PRONE], deltaTime);
 					}
 
 					if (m_pBGLeg) {
-						m_pBGFootGroup->PushAsLimb(m_Pos.GetFloored() + m_pBGLeg->GetParentOffset().GetXFlipped(m_HFlipped), m_Vel, Matrix(), m_Paths[BGROUND][CROUCH], deltaTime);
+						m_pBGFootGroup->PushAsLimb(m_Pos.GetFloored() + m_pBGLeg->GetParentOffset().GetXFlipped(m_HFlipped), m_Vel, Matrix(), m_Paths[BGROUND][PRONE], deltaTime);
 					}
 
 				} else {
@@ -2289,7 +2296,7 @@ void AHuman::PreControllerUpdate() {
 		if (m_Status == STABLE) {
 			if (m_ArmClimbing[BGROUND]) {
 				// Can't climb or crawl with the shield
-				if (m_MoveState != CRAWL || m_ProneState == PRONE) {
+				if (m_MoveState != CRAWL || m_ProneState == LAYINGPRONE) {
 					UnequipBGArm();
 				}
 				m_pBGArm->AddHandTarget("Hand AtomGroup Limb Pos", m_pBGHandGroup->GetLimbPos(m_HFlipped));
@@ -2309,7 +2316,7 @@ void AHuman::PreControllerUpdate() {
 							m_pBGArm->SetRecoil(heldDevice->GetRecoilForce(), heldDevice->GetRecoilOffset(), heldDevice->IsRecoiled());
 						} else {
 							// BGArm did not reach to support the device. Count device as supported anyway, if crouching or prone.
-							heldDevice->SetSupported(m_MoveState == CROUCH || m_ProneState == PRONE);
+							heldDevice->SetSupported(m_MoveState == PRONE || m_ProneState == LAYINGPRONE);
 							m_pBGArm->SetRecoil(Vector(), Vector(), false);
 						}
 					}
@@ -2335,7 +2342,7 @@ void AHuman::PreControllerUpdate() {
 			if (arm && !arm->GetHeldDeviceThisArmIsTryingToSupport()) {
 				Leg* legToSwingWith = arm == m_pFGArm ? m_pBGLeg : m_pFGLeg;
 				Leg* otherLeg = legToSwingWith == m_pBGLeg ? m_pFGLeg : m_pBGLeg;
-				if (!legToSwingWith || m_MoveState == JUMP || m_MoveState == CROUCH) {
+				if (!legToSwingWith || m_MoveState == JUMP || m_MoveState == PRONE) {
 					std::swap(legToSwingWith, otherLeg);
 				}
 
@@ -2376,10 +2383,8 @@ void AHuman::Update() {
 			m_SharpAimMaxedOut = true;
 		} else if (m_MoveState == WALK) {
 			maxLength *= 0.7F;
-		}
-
-		// If we're fully crouching, improve our aim a little
-		if (m_MaxWalkPathCrouchShift > 0.0F && m_WalkPathOffset.m_Y * -1.0F >= m_MaxWalkPathCrouchShift * 0.9F) {
+		} else if (m_MoveState == CROUCH) {
+			// Only when crouching still, otherwise it's WALK
 			maxLength *= 1.2F;
 		}
 
@@ -2461,9 +2466,9 @@ void AHuman::Update() {
 				} else {
 					// Done going down, now stay down without spring.
 					m_AngularVel *= 0.5F;
-					m_ProneState = PRONE;
+					m_ProneState = LAYINGPRONE;
 				}
-			} else if (m_ProneState == PRONE) {
+			} else if (m_ProneState == LAYINGPRONE) {
 				// If down, try to keep flat against the ground.
 				if (std::abs(rotDiff) > c_SixteenthPI && std::abs(rotDiff) < c_HalfPI) {
 					m_AngularVel += rotDiff * 0.65F;
@@ -2475,18 +2480,22 @@ void AHuman::Update() {
 			// Upright body posture
 			float rotTarget = (GetRotAngleTarget(m_MoveState) * (m_AimAngle > 0 ? 1.0F - (m_AimAngle / c_HalfPI) : 1.0F) * GetFlipFactor());
 
-			// Lean forwards when crouching
-			float crouchAngleAdjust = m_HFlipped ? m_MaxCrouchRotation : -m_MaxCrouchRotation;
-			rotTarget += Lerp(0.0F, m_MaxWalkPathCrouchShift, 0.0F, crouchAngleAdjust, m_WalkPathOffset.m_Y * -1.0F);
-
+			if (m_MoveState != CROUCH) {
+				// In crouch state the above is rotated already, but in any other state we do the incremental lean here
+				float crouchAngleAdjust = m_HFlipped ? -m_RotAngleTargets[CROUCH] : m_RotAngleTargets[CROUCH];
+				float difference = crouchAngleAdjust - rotTarget;
+				rotTarget += Lerp(0.0F, 1.0F, 0.0F, difference, m_CrouchAmount);
+			}
+			
 			float rotDiff = rot - rotTarget;
-			if (std::abs(rotDiff) > c_HalfPI) {
+			if (std::abs(rotDiff) > c_PI) {
 				// We've h-flipped, so just snap to new orientation
 				rot = rotTarget;
 			} else {
 				// Lerp towards the angle
 				m_AngularVel = m_AngularVel * (0.98F - 0.06F * (m_Health / m_MaxHealth)) - (rotDiff * 0.5F);
 			}
+			
 		}
 	} else if (m_Status == UNSTABLE) {
 		float rotTarget = 0;

Source/Entities/AHuman.h

@@ -36,7 +36,7 @@ namespace RTE {
 		enum ProneState {
 			NOTPRONE = 0,
 			GOPRONE,
-			PRONE,
+			LAYINGPRONE,
 			PRONESTATECOUNT
 		};
 
@@ -523,17 +523,9 @@ namespace RTE {
 		/// @param newValue The new value for this AHuman's max walkpath adjustment.
 		void SetMaxWalkPathCrouchShift(float newValue) { m_MaxWalkPathCrouchShift = newValue; }
 
-		/// Gets this AHuman's max crouch rotation to duck below low ceilings.
-		/// @return This AHuman's max crouch rotation adjustment.
-		float GetMaxCrouchRotation() const { return m_MaxCrouchRotation; }
-
-		/// Sets this AHuman's max crouch rotation to duck below low ceilings.
-		/// @param newValue The new value for this AHuman's max crouch rotation adjustment.
-		void SetMaxCrouchRotation(float newValue) { m_MaxCrouchRotation = newValue; }
-
 		/// Gets this AHuman's current crouch amount. 0.0 == fully standing, 1.0 == fully crouched.
 		/// @return This AHuman's current crouch amount.
-		float GetCrouchAmount() const { return (m_WalkPathOffset.m_Y * -1.0F) / m_MaxWalkPathCrouchShift; }
+		float GetCrouchAmount() const { return m_CrouchAmount; }
 
 		/// Gets this AHuman's current crouch amount override. 0.0 == fully standing, 1.0 == fully crouched, -1 == no override.
 		/// @return This AHuman's current crouch amount override.
@@ -613,10 +605,10 @@ namespace RTE {
 		ProneState m_ProneState;
 		// Timer for the going prone procedural animation
 		Timer m_ProneTimer;
-		// The maximum amount our walkpath can be shifted upwards to crouch and avoid ceilings above us
+		// The maximum amount our walkpath can be shifted upwards to crouch, whether manually or automatically.
 		float m_MaxWalkPathCrouchShift;
-		// The maximum amount we will duck our head down to avoid obstacles above us.
-		float m_MaxCrouchRotation;
+		// The current crouching amount from 0.0 to 1.0, where 1.0 is applying maximum walk path shift.
+		float m_CrouchAmount;
 		// The script-set forced crouching amount. 0.0 == fully standing, 1.0 == fully crouched, -1 == no override.
 		float m_CrouchAmountOverride;
 		// Limb paths for different movement states.

Source/Entities/Actor.cpp

@@ -66,6 +66,7 @@ void Actor::Clear() {
 	m_TravelImpulseDamage = 750.0F;
 	m_StableVel.SetXY(15.0F, 25.0F);
 	m_StableRecoverDelay = 1000;
+	m_CanRun = true;
 	m_HeartBeat.Reset();
 	m_NewControlTmr.Reset();
 	m_DeathTmr.Reset();
@@ -198,6 +199,7 @@ int Actor::Create(const Actor& reference) {
 	m_TravelImpulseDamage = reference.m_TravelImpulseDamage;
 	m_StableVel = reference.m_StableVel;
 	m_StableRecoverDelay = reference.m_StableRecoverDelay;
+	m_CanRun = reference.m_CanRun;
 	m_GoldCarried = reference.m_GoldCarried;
 	m_AimState = reference.m_AimState;
 	m_AimRange = reference.m_AimRange;
@@ -327,6 +329,7 @@ int Actor::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("ImpulseDamageThreshold", { reader >> m_TravelImpulseDamage; });
 	MatchProperty("StableVelocityThreshold", { reader >> m_StableVel; });
 	MatchProperty("StableRecoveryDelay", { reader >> m_StableRecoverDelay; });
+	MatchProperty("CanRun", { reader >> m_CanRun; });
 	MatchProperty("AimAngle", { reader >> m_AimAngle; });
 	MatchProperty("AimRange", { reader >> m_AimRange; });
 	MatchProperty("AimDistance", { reader >> m_AimDistance; });
@@ -401,6 +404,8 @@ int Actor::Save(Writer& writer) const {
 	writer << m_StableVel;
 	writer.NewProperty("StableRecoveryDelay");
 	writer << m_StableRecoverDelay;
+	writer.NewProperty("CanRun");
+	writer << m_CanRun;
 	writer.NewProperty("AimAngle");
 	writer << m_AimAngle;
 	writer.NewProperty("AimRange");