Improved walkpath auto crouch

Author: Causeless

Entities/AHuman.cpp

@@ -2233,17 +2233,17 @@ void AHuman::PreControllerUpdate()
 			if (m_pFGLeg && (!m_pBGLeg || !(m_Paths[FGROUND][WALK].PathEnded() && BGLegProg < 0.5F) || m_StrideStart)) {
 				// Reset the stride timer if the path is about to restart.
 				if (m_Paths[FGROUND][WALK].PathEnded() || m_Paths[FGROUND][WALK].PathIsAtStart()) { m_StrideTimer.Reset(); }
-				Vector jointPos = m_Pos + RotateOffset(m_pFGLeg->GetParentOffset()) + Vector(0.0F, -m_WalkPathYOffset);
-				m_ArmClimbing[BGROUND] = !m_pFGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[FGROUND], m_Paths[FGROUND][WALK], deltaTime, &restarted, false, Vector(0.0F, m_Paths[FGROUND][WALK].GetLowestY()));
+				Vector jointPos = m_Pos + RotateOffset(m_pFGLeg->GetParentOffset());
+				m_ArmClimbing[BGROUND] = !m_pFGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[FGROUND], m_Paths[FGROUND][WALK], deltaTime, &restarted, false, Vector(0.0F, m_Paths[FGROUND][WALK].GetLowestY()), Vector(0.0F, -m_WalkPathYOffset));
 			} else {
 				m_ArmClimbing[BGROUND] = false;
 			}
 			if (m_pBGLeg && (!m_pFGLeg || !(m_Paths[BGROUND][WALK].PathEnded() && FGLegProg < 0.5F))) {
 				m_StrideStart = false;
 				// Reset the stride timer if the path is about to restart.
 				if (m_Paths[BGROUND][WALK].PathEnded() || m_Paths[BGROUND][WALK].PathIsAtStart()) { m_StrideTimer.Reset(); }
-				Vector jointPos = m_Pos + RotateOffset(m_pBGLeg->GetParentOffset()) + Vector(0.0F, -m_WalkPathYOffset);
-				m_ArmClimbing[FGROUND] = !m_pBGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[BGROUND], m_Paths[BGROUND][WALK], deltaTime, &restarted, false, Vector(0.0F, m_Paths[BGROUND][WALK].GetLowestY()));
+				Vector jointPos = m_Pos + RotateOffset(m_pBGLeg->GetParentOffset());
+				m_ArmClimbing[FGROUND] = !m_pBGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[BGROUND], m_Paths[BGROUND][WALK], deltaTime, &restarted, false, Vector(0.0F, m_Paths[BGROUND][WALK].GetLowestY()), Vector(0.0F, -m_WalkPathYOffset));
 			} else {
 				if (m_pBGLeg) { m_pBGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pBGLeg->GetParentOffset()), m_pBGLeg->GetMaxLength(), m_PrevVel, m_AngularVel, m_pBGLeg->GetMass(), deltaTime); }
 				m_ArmClimbing[FGROUND] = false;
@@ -2382,13 +2382,13 @@ void AHuman::PreControllerUpdate()
 					m_Paths[BGROUND][ARMCRAWL].Terminate();
 
 					if (m_pFGLeg) {
-						Vector jointPos = m_Pos.GetFloored() + m_pFGLeg->GetParentOffset().GetXFlipped(m_HFlipped) + Vector(0.0F, -m_WalkPathYOffset);
-						m_pFGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[FGROUND], m_Paths[FGROUND][STAND], deltaTime, nullptr, !m_pBGLeg, Vector(0.0F, m_Paths[FGROUND][STAND].GetLowestY())); 
+						Vector jointPos = m_Pos.GetFloored() + m_pFGLeg->GetParentOffset().GetXFlipped(m_HFlipped);
+						m_pFGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[FGROUND], m_Paths[FGROUND][STAND], deltaTime, nullptr, !m_pBGLeg, Vector(0.0F, m_Paths[FGROUND][STAND].GetLowestY()), Vector(0.0F, -m_WalkPathYOffset)); 
 					}
 
 					if (m_pBGLeg) {
-						Vector jointPos = m_Pos.GetFloored() + m_pBGLeg->GetParentOffset().GetXFlipped(m_HFlipped) + Vector(0.0F, -m_WalkPathYOffset);
-						m_pBGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[BGROUND], m_Paths[BGROUND][STAND], deltaTime, nullptr, !m_pFGLeg, Vector(0.0F, m_Paths[FGROUND][STAND].GetLowestY())); 
+						Vector jointPos = m_Pos.GetFloored() + m_pBGLeg->GetParentOffset().GetXFlipped(m_HFlipped);
+						m_pBGFootGroup->PushAsLimb(jointPos, m_Vel, m_WalkAngle[BGROUND], m_Paths[BGROUND][STAND], deltaTime, nullptr, !m_pFGLeg, Vector(0.0F, m_Paths[FGROUND][STAND].GetLowestY()), Vector(0.0F, -m_WalkPathYOffset)); 
 					}
 				}
 			}

Entities/AtomGroup.cpp

@@ -1214,7 +1214,7 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool AtomGroup::PushAsLimb(const Vector &jointPos, const Vector &velocity, const Matrix &rotation, LimbPath &limbPath, const float travelTime, bool *restarted, bool affectRotation, Vector rotationOffset) {
+	bool AtomGroup::PushAsLimb(const Vector &jointPos, const Vector &velocity, const Matrix &rotation, LimbPath &limbPath, const float travelTime, bool *restarted, bool affectRotation, Vector rotationOffset, Vector positionOffset) {
 		RTEAssert(m_OwnerMOSR, "Tried to push-as-limb an AtomGroup that has no parent!");
 
 		bool didWrap = false;
@@ -1234,6 +1234,7 @@ namespace RTE {
 		limbPath.SetJointVel(velocity);
 		limbPath.SetRotation(rotation);
 		limbPath.SetRotationOffset(rotationOffset);
+		limbPath.SetPositionOffset(positionOffset);
 		limbPath.SetFrameTime(travelTime);
 
 		Vector limbDist = g_SceneMan.ShortestDistance(adjustedJointPos, m_LimbPos, g_SceneMan.SceneWrapsX());

Entities/AtomGroup.h

@@ -289,8 +289,9 @@ namespace RTE {
 		/// <param name="restarted">Pointer to a bool which gets set to true if the LimbPath got restarted during this push. It does NOT get initialized to false!</param>
 		/// <param name="affectRotation">Whether the forces created by this should have rotational leverage on the owner or only have translational effect.</param>
 		/// <param name="rotationOffset">The position, relative to the owning actor's position, that we should rotate around.</param>
+		/// <param name="rotationOffset">The positional offset to apply to our limb path.</param>
 		/// <returns>Whether the LimbPath passed in could start free of terrain or not.</returns>
-		bool PushAsLimb(const Vector &jointPos, const Vector &velocity, const Matrix &rotation, LimbPath &limbPath, const float travelTime, bool *restarted = nullptr, bool affectRotation = true, Vector rotationOffset = Vector());
+		bool PushAsLimb(const Vector &jointPos, const Vector &velocity, const Matrix &rotation, LimbPath &limbPath, const float travelTime, bool *restarted = nullptr, bool affectRotation = true, Vector rotationOffset = Vector(), Vector positionOffset = Vector());
 
 		/// <summary>
 		/// Makes this AtomGroup travel as a lifeless limb, constrained to a radius around the joint pin in the center.

Entities/LimbPath.cpp

@@ -42,6 +42,7 @@ void LimbPath::Clear()
     m_JointVel.Reset();
     m_Rotation.Reset();
     m_RotationOffset.Reset();
+    m_PositionOffset.Reset();
     m_TimeLeft = 0.0;
     m_PathTimer.Reset();
     m_SegTimer.Reset();
@@ -188,7 +189,7 @@ int LimbPath::ReadProperty(const std::string_view &propName, Reader &reader)
 
 
 Vector LimbPath::RotatePoint(const Vector &point) const {
-    Vector offset = m_RotationOffset.GetXFlipped(m_HFlipped);
+    Vector offset = (m_RotationOffset + m_PositionOffset).GetXFlipped(m_HFlipped);
     return ((point - offset) * m_Rotation) + offset;
 }
 
@@ -246,7 +247,7 @@ void LimbPath::Destroy(bool notInherited)
 
 Vector LimbPath::GetProgressPos()
 {
-    Vector returnVec(m_Start);
+    Vector returnVec(m_Start + m_PositionOffset);
     if (IsStaticPoint()) {
         return m_JointPos + RotatePoint(returnVec);
     }
@@ -273,7 +274,7 @@ Vector LimbPath::GetProgressPos()
 
 Vector LimbPath::GetCurrentSegTarget()
 {
-    Vector returnVec(m_Start);
+    Vector returnVec(m_Start + m_PositionOffset);
     if (IsStaticPoint()) {
         return m_JointPos + RotatePoint(returnVec);
     }
@@ -561,14 +562,11 @@ bool LimbPath::RestartFree(Vector &limbPos, MOID MOIDToIgnore, int ignoreTeam)
     m_SegProgress = 0;
     bool found = false;
     float result = 0;
-
-    g_SceneMan.GetTerrain()->LockBitmaps();
-    acquire_bitmap(g_SceneMan.GetMOIDBitmap());
 
     if (IsStaticPoint())
 	{
 		Vector notUsed;
-        Vector targetPos = m_JointPos + RotatePoint(m_Start);
+        Vector targetPos = m_JointPos + RotatePoint(m_Start + m_PositionOffset);
         Vector beginPos = targetPos;
 // TODO: don't hardcode the beginpos
         beginPos.m_Y -= 24;
@@ -590,14 +588,14 @@ bool LimbPath::RestartFree(Vector &limbPos, MOID MOIDToIgnore, int ignoreTeam)
         int i = 0;
         for (; i < m_StartSegCount; ++i)
         {
-            result = g_SceneMan.CastObstacleRay(GetProgressPos(), RotatePoint(*m_CurrentSegment), notUsed, limbPos, MOIDToIgnore, ignoreTeam, g_MaterialGrass);
+            result = g_SceneMan.CastObstacleRay(GetProgressPos(), RotatePoint(*m_CurrentSegment + m_PositionOffset), notUsed, limbPos, MOIDToIgnore, ignoreTeam, g_MaterialGrass);
 
             // If we found an obstacle after the first pixel, report the current segment as the starting one and that there is free space here
             if (result > 0)
             {
                 // Set accurate segment progress
 // TODO: See if this is a good idea, or if we should just set it to 0 and set limbPos to the start of current segment
-                m_SegProgress = g_SceneMan.ShortestDistance(GetProgressPos(), limbPos).GetMagnitude() / (*m_CurrentSegment).GetMagnitude();
+                m_SegProgress = g_SceneMan.ShortestDistance(GetProgressPos(), limbPos).GetMagnitude() / (*m_CurrentSegment + m_PositionOffset).GetMagnitude();
                 limbPos = GetProgressPos();
 //                m_SegProgress = 0;
                 m_Ended = false;
@@ -639,8 +637,6 @@ bool LimbPath::RestartFree(Vector &limbPos, MOID MOIDToIgnore, int ignoreTeam)
             found = true;
         }
     }
-    release_bitmap(g_SceneMan.GetMOIDBitmap());
-    g_SceneMan.GetTerrain()->UnlockBitmaps();
 
     if (found)
     {
@@ -689,7 +685,7 @@ void LimbPath::Draw(BITMAP *pTargetBitmap,
                     const Vector &targetPos,
                     unsigned char color) const
 {
-    Vector prevPoint = m_Start;
+    Vector prevPoint = m_Start + m_PositionOffset;
     Vector nextPoint = prevPoint;
     for (std::deque<Vector>::const_iterator itr = m_Segments.begin(); itr != m_Segments.end(); ++itr)
     {

Entities/LimbPath.h

@@ -494,6 +494,12 @@ ClassInfoGetters;
     /// <param name="rotationOffset">The new rotation offset, in local space.</param>
     void SetRotationOffset(const Vector& rotationOffset) { m_RotationOffset = rotationOffset; }
 
+    /// <summary>
+    /// Sets the new position offset.
+    /// </summary>
+    /// <param name="rotationOffset">The new position offset, in local space.</param>
+    void SetPositionOffset(const Vector& positionOffset) { m_PositionOffset = positionOffset; }
+
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Method:          FrameDone
@@ -666,6 +672,8 @@ ClassInfoGetters;
     Matrix m_Rotation;
     // The point we should be rotated around, in local space.
     Vector m_RotationOffset;
+    // The offset to apply to our walkpath position, in local space.
+    Vector m_PositionOffset;
 
     // If GetNextTimeSeg() couldn't use up all frame time because the current segment
     // ended,this var stores the remainder of time that should be used to progress