Merge branch 'pre4-testing' into 4zk-content-source

Author: fourZK

CHANGELOG.md

@@ -260,6 +260,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 <details><summary><b>Changed</b></summary>
 
+- Exposed `MovableObject` property `RestThreshold` to Lua (R/W).
+
 - `ACRocket`s can now function without a full set of thrusters. This also means that "Null Emitter" thrusters are no longer required for rockets.
 
 - Changed `MOSprite` property `SpriteAnimMode` `Enum` `LOOPWHENMOVING` to `LOOPWHENACTIVE` as it also describes active devices.

Entities/ADoor.cpp

@@ -79,10 +79,10 @@ namespace RTE {
 		m_DrawMaterialLayerWhenClosed = reference.m_DrawMaterialLayerWhenClosed;
 		m_DoorMaterialID = reference.m_DoorMaterialID;
 		m_DoorMaterialTempErased = reference.m_DoorMaterialTempErased;
-		if (reference.m_DoorMoveStartSound) { m_DoorMoveStartSound = dynamic_cast<SoundContainer*>(reference.m_DoorMoveStartSound->Clone()); }
-		if (reference.m_DoorMoveSound) { m_DoorMoveSound = dynamic_cast<SoundContainer*>(reference.m_DoorMoveSound->Clone()); }
-		if (reference.m_DoorDirectionChangeSound) { m_DoorDirectionChangeSound = dynamic_cast<SoundContainer*>(reference.m_DoorDirectionChangeSound->Clone()); }
-		if (reference.m_DoorMoveEndSound) { m_DoorMoveEndSound = dynamic_cast<SoundContainer*>(reference.m_DoorMoveEndSound->Clone()); }
+		if (reference.m_DoorMoveStartSound) { m_DoorMoveStartSound.reset(dynamic_cast<SoundContainer*>(reference.m_DoorMoveStartSound->Clone())); }
+		if (reference.m_DoorMoveSound) { m_DoorMoveSound.reset(dynamic_cast<SoundContainer*>(reference.m_DoorMoveSound->Clone())); }
+		if (reference.m_DoorDirectionChangeSound) { m_DoorDirectionChangeSound.reset(dynamic_cast<SoundContainer*>(reference.m_DoorDirectionChangeSound->Clone())); }
+		if (reference.m_DoorMoveEndSound) { m_DoorMoveEndSound.reset(dynamic_cast<SoundContainer*>(reference.m_DoorMoveEndSound->Clone())); }
 
 		return 0;
 	}
@@ -131,17 +131,13 @@ namespace RTE {
 		} else if (propName == "DrawMaterialLayerWhenClosed") {
 			reader >> m_DrawMaterialLayerWhenClosed;
 		} else if (propName == "DoorMoveStartSound") {
-			m_DoorMoveStartSound = new SoundContainer;
-			reader >> m_DoorMoveStartSound;
+			m_DoorMoveStartSound.reset(dynamic_cast<SoundContainer *>(g_PresetMan.ReadReflectedPreset(reader)));
 		} else if (propName == "DoorMoveSound") {
-			m_DoorMoveSound = new SoundContainer;
-			reader >> m_DoorMoveSound;
+			m_DoorMoveSound.reset(dynamic_cast<SoundContainer *>(g_PresetMan.ReadReflectedPreset(reader)));
 		} else if (propName == "DoorDirectionChangeSound") {
-			m_DoorDirectionChangeSound = new SoundContainer;
-			reader >> m_DoorDirectionChangeSound;
+			m_DoorDirectionChangeSound.reset(dynamic_cast<SoundContainer *>(g_PresetMan.ReadReflectedPreset(reader)));
 		} else if (propName == "DoorMoveEndSound") {
-			m_DoorMoveEndSound = new SoundContainer;
-			reader >> m_DoorMoveEndSound;
+			m_DoorMoveEndSound.reset(dynamic_cast<SoundContainer *>(g_PresetMan.ReadReflectedPreset(reader)));
 		} else {
 			return Actor::ReadProperty(propName, reader);
 		}
@@ -180,13 +176,13 @@ namespace RTE {
 		writer.NewProperty("DrawMaterialLayerWhenClosed");
 		writer << m_DrawMaterialLayerWhenClosed;
 		writer.NewProperty("DoorMoveStartSound");
-		writer << m_DoorMoveStartSound;
+		writer << m_DoorMoveStartSound.get();
 		writer.NewProperty("DoorMoveSound");
-		writer << m_DoorMoveSound;
+		writer << m_DoorMoveSound.get();
 		writer.NewProperty("DoorDirectionChangeSound");
-		writer << m_DoorDirectionChangeSound;
+		writer << m_DoorDirectionChangeSound.get();
 		writer.NewProperty("DoorMoveEndSound");
-		writer << m_DoorMoveEndSound;
+		writer << m_DoorMoveEndSound.get();
 
 		return 0;
 	}
@@ -200,11 +196,6 @@ namespace RTE {
 		if (m_DoorMoveEndSound) { m_DoorMoveEndSound->Stop(); }
 		if (!notInherited) { Actor::Destroy(); }
 
-		delete m_DoorMoveStartSound;
-		delete m_DoorMoveSound;
-		delete m_DoorDirectionChangeSound;
-		delete m_DoorMoveEndSound;
-
 		for (ADSensor &sensor : m_Sensors) {
 			sensor.Destroy();
 		}
@@ -249,8 +240,8 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool ADoor::EraseDoorMaterial(bool updateMaterialArea, bool keepMaterialDrawnFlag) {
-		if (!keepMaterialDrawnFlag) { m_DoorMaterialDrawn = false; }
+	bool ADoor::EraseDoorMaterial(bool updateMaterialArea) {
+		m_DoorMaterialDrawn = false;
 
 		if (!g_SceneMan.GetTerrain() || !g_SceneMan.GetTerrain()->GetMaterialBitmap()) {
 			return false;
@@ -270,22 +261,21 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void ADoor::MaterialDrawOverride(bool enable) {
+	void ADoor::TempEraseOrRedrawDoorMaterial(bool erase) {
 		if (!g_SceneMan.GetTerrain() || !g_SceneMan.GetTerrain()->GetMaterialBitmap()) {
 			return;
 		}
 
-		if (enable) {
-			// Erase the material temporarily if we have drawn it and the override isn't already in effect
-			if (m_DoorMaterialDrawn && m_DoorMaterialTempErased != enable) { EraseDoorMaterial(true, true); }
-		} else {
-			// Draw the door back if we were indeed temporarily suppressing it before
-			if (m_DoorMaterialDrawn && m_DoorMaterialTempErased != enable) {
-				m_Door->Draw(g_SceneMan.GetTerrain()->GetMaterialBitmap(), Vector(), g_DrawDoor, true);
-				g_SceneMan.GetTerrain()->AddUpdatedMaterialArea(m_Door->GetBoundingBox());
-			}
+		bool doorMaterialDrawnState = m_DoorMaterialDrawn;
+		if (erase && m_DoorMaterialDrawn && !m_DoorMaterialTempErased) {
+			EraseDoorMaterial(true);
+			m_DoorMaterialDrawn = doorMaterialDrawnState;
+		} else if (!erase && m_DoorMaterialDrawn && m_DoorMaterialTempErased) {
+			DrawDoorMaterial(true);
+			m_DoorMaterialDrawn = doorMaterialDrawnState;
 		}
-		m_DoorMaterialTempErased = enable;
+
+		m_DoorMaterialTempErased = erase;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -370,7 +360,6 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void ADoor::Update() {
-
 		if (m_Door) {
 			if (m_DoorState != STOPPED && m_SensorTimer.IsPastSimMS(m_SensorInterval)) { UpdateSensors(); }
 			UpdateDoorAttachableActions();
@@ -383,11 +372,8 @@ namespace RTE {
 
 		Actor::Update();
 
-		if (!m_Door) {
-			EraseDoorMaterial();
-			// Start the spinning out of control animation for the motor, start it slow
-			m_SpriteAnimDuration *= 4;
-		}
+		// Start the spinning out of control animation for the motor, start it slow
+		if (!m_Door) { m_SpriteAnimDuration *= 4; }
 
 		if (m_SpriteAnimMode == LOOPWHENOPENCLOSE && m_FrameCount > 1 && (m_DoorState == OPENING || m_DoorState == CLOSING) && m_SpriteAnimTimer.IsPastSimMS(m_SpriteAnimDuration)) {
 			m_Frame = (m_Frame + 1) % m_FrameCount;
@@ -397,11 +383,11 @@ namespace RTE {
 		// Lose health when door is lost, spinning out of control until grinds to halt
 		if (!m_Door && m_Status != DYING && m_Status != DEAD) {
 			m_SpriteAnimMode = ALWAYSLOOP;
-			m_SpriteAnimDuration = LERP(0, m_MaxHealth, 10, m_InitialSpriteAnimDuration, m_Health);
+			m_SpriteAnimDuration = static_cast<int>(LERP(0, m_MaxHealth, 10.0F, static_cast<float>(m_InitialSpriteAnimDuration), m_Health));
 
 			if (m_DoorMoveSound) {
 				if (!m_DoorMoveSound->IsBeingPlayed()) { m_DoorMoveSound->Play(m_Pos); }
-				m_DoorMoveSound->SetPitch(LERP(10, m_InitialSpriteAnimDuration, 2, 1, m_SpriteAnimDuration));
+				m_DoorMoveSound->SetPitch(LERP(10.0F, static_cast<float>(m_InitialSpriteAnimDuration), 2.0F, 1.0F, static_cast<float>(m_SpriteAnimDuration)));
 			}
 
 			m_Health -= 0.4F;
@@ -412,7 +398,7 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void ADoor::UpdateSensors() {		
-		const Actor *foundActor = 0;
+		const Actor *foundActor = nullptr;
 		bool anySensorInput = false;
 
 		for (ADSensor &sensor : m_Sensors) {
@@ -423,7 +409,7 @@ namespace RTE {
 				if (m_Team == Activity::NoTeam) {
 					OpenDoor();
 					break;
-				// If a sensor has found an enemy Actor, close the door and break so we don't accidentally open it for a friendly Actor.
+				// If a sensor has found an enemy Actor, close the door and stop looking, so we don't accidentally open it for a friendly Actor.
 				} else if (foundActor->GetTeam() != m_Team) {
 					CloseDoor();
 					break;
@@ -501,7 +487,7 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void ADoor::DrawHUD(BITMAP *targetBitmap, const Vector &targetPos, int whichScreen, bool playerControlled) {
-		m_HUDStack = -m_CharHeight / 2;
+		m_HUDStack = -static_cast<int>(m_CharHeight) / 2;
 
 		if (!m_HUDVisible) {
 			return;

Entities/ADoor.h

@@ -101,49 +101,49 @@ namespace RTE {
 		/// Gets this ADoor's door move start sound. Ownership is NOT transferred!
 		/// </summary>
 		/// <returns>The SoundContainer for this ADoor's door move start sound.</returns>
-		SoundContainer * GetDoorMoveStartSound() const { return m_DoorMoveStartSound; }
+		SoundContainer * GetDoorMoveStartSound() const { return m_DoorMoveStartSound.get(); }
 
 		/// <summary>
 		/// Sets this ADoor's door move start sound. Ownership IS transferred!
 		/// </summary>
 		/// <param name="newSound">The new SoundContainer for this ADoor's door move start sound.</param>
-		void SetDoorMoveStartSound(SoundContainer *newSound) { m_DoorMoveStartSound = newSound; }
+		void SetDoorMoveStartSound(SoundContainer *newSound) { m_DoorMoveStartSound.reset(newSound); }
 
 		/// <summary>
 		/// Gets this ADoor's door move sound. Ownership is NOT transferred!
 		/// </summary>
 		/// <returns>The SoundContainer for this ADoor's door move sound.</returns>
-		SoundContainer * GetDoorMoveSound() const { return m_DoorMoveSound; }
+		SoundContainer * GetDoorMoveSound() const { return m_DoorMoveSound.get(); }
 
 		/// <summary>
 		/// Sets this ADoor's door move sound. Ownership IS transferred!
 		/// </summary>
 		/// <param name="newSound">The new SoundContainer for this ADoor's door move sound.</param>
-		void SetDoorMoveSound(SoundContainer *newSound) { m_DoorMoveSound = newSound; }
+		void SetDoorMoveSound(SoundContainer *newSound) { m_DoorMoveSound.reset(newSound); }
 
 		/// <summary>
 		/// Gets this ADoor's door direction change sound. Ownership is NOT transferred!
 		/// </summary>
 		/// <returns>The SoundContainer for this ADoor's door direction change sound.</returns>
-		SoundContainer * GetDoorDirectionChangeSound() const { return m_DoorDirectionChangeSound; }
+		SoundContainer * GetDoorDirectionChangeSound() const { return m_DoorDirectionChangeSound.get(); }
 
 		/// <summary>
 		/// Sets this ADoor's door direction change sound. Ownership IS transferred!
 		/// </summary>
 		/// <param name="newSound">The new SoundContainer for this ADoor's door direction change sound.</param>
-		void SetDoorDirectionChangeSound(SoundContainer *newSound) { m_DoorDirectionChangeSound = newSound; }
+		void SetDoorDirectionChangeSound(SoundContainer *newSound) { m_DoorDirectionChangeSound.reset(newSound); }
 
 		/// <summary>
 		/// Gets this ADoor's door move end sound. Ownership is NOT transferred!
 		/// </summary>
 		/// <returns>The SoundContainer for this ADoor's door move end sound.</returns>
-		SoundContainer * GetDoorMoveEndSound() const { return m_DoorMoveEndSound; }
+		SoundContainer * GetDoorMoveEndSound() const { return m_DoorMoveEndSound.get(); }
 
 		/// <summary>
 		/// Sets this ADoor's door move end sound. Ownership IS transferred!
 		/// </summary>
 		/// <param name="newSound">The new SoundContainer for this ADoor's door move end sound.</param>
-		void SetDoorMoveEndSound(SoundContainer *newSound) { m_DoorMoveEndSound = newSound; }
+		void SetDoorMoveEndSound(SoundContainer *newSound) { m_DoorMoveEndSound.reset(newSound); }
 #pragma endregion
 
 #pragma region Concrete Methods
@@ -163,10 +163,10 @@ namespace RTE {
 		void StopDoor();
 
 		/// <summary>
-		/// Used to temporarily remove or add back the material drawing of this in the scene. Used for making pathfinding work through doors.
+		/// Used to temporarily remove or add back the material drawing of this in the Scene. Used for making pathfinding work through doors.
 		/// </summary>
-		/// <param name="enable">Whether to enable the override or not.</param>
-		void MaterialDrawOverride(bool enable);
+		/// <param name="erase">Whether to erase door material (true) or draw it (false).</param>
+		void TempEraseOrRedrawDoorMaterial(bool erase);
 #pragma endregion
 
 #pragma region Virtual Override Methods
@@ -235,10 +235,10 @@ namespace RTE {
 		bool m_DoorMaterialTempErased; //!< Whether the drawing override is enabled and the door material is erased to allow better pathfinding.
 		Vector m_LastDoorMaterialPos; //!< The position the door attachable had when its material was drawn to the material bitmap. This is used to erase the previous material representation.
 
-		SoundContainer *m_DoorMoveStartSound; //!< Sound played when the door starts moving from fully open/closed position towards the opposite end.
-		SoundContainer *m_DoorMoveSound; //!< Sound played while the door is moving between open/closed position.
-		SoundContainer *m_DoorDirectionChangeSound; //!< Sound played when the door is interrupted while moving and changes directions. 
-		SoundContainer *m_DoorMoveEndSound; //!< Sound played when the door stops moving and is at fully open/closed position.
+		std::unique_ptr<SoundContainer> m_DoorMoveStartSound; //!< Sound played when the door starts moving from fully open/closed position towards the opposite end.
+		std::unique_ptr<SoundContainer> m_DoorMoveSound; //!< Sound played while the door is moving between open/closed position.
+		std::unique_ptr<SoundContainer> m_DoorDirectionChangeSound; //!< Sound played when the door is interrupted while moving and changes directions. 
+		std::unique_ptr<SoundContainer> m_DoorMoveEndSound; //!< Sound played when the door stops moving and is at fully open/closed position.
 
 	private:
 
@@ -270,9 +270,8 @@ namespace RTE {
 		/// This is to get rid of the material footprint made with DrawDoorMaterial when the door part starts to move.
 		/// </summary>
 		/// <param name="updateMaterialArea">Whether to update the MaterialArea after erasing or not. Used for DrawDoorMaterial().</param>
-		/// <param name="keepMaterialDrawnFlag">Whether to keep the DoorMaterialDrawn flag or not. Used for MaterialDrawOverride().</param>
 		/// <returns>Whether the fill erasure was successful (if the same material as the door was found and erased).</returns>
-		bool EraseDoorMaterial(bool updateMaterialArea = true, bool keepMaterialDrawnFlag = false);
+		bool EraseDoorMaterial(bool updateMaterialArea = true);
 
 		/// <summary>
 		/// Clears all the member variables of this ADoor, effectively resetting the members of this abstraction level only.

Entities/AHuman.cpp

@@ -3703,52 +3703,44 @@ void AHuman::Update()
                 m_Paths[FGROUND][WALK].Terminate();
                 m_Paths[BGROUND][WALK].Terminate();
             }
-        }
-        // CRAWLING
-        else if (m_MoveState == CRAWL)
-        {
-            // LEG Crawls
-            float FGLegProg = m_Paths[FGROUND][CRAWL].GetRegularProgress();
-            float BGLegProg = m_Paths[BGROUND][CRAWL].GetRegularProgress();
+		} else if (m_MoveState == CRAWL) {
+			// Start crawling only once we are fully prone.
+			if (m_ProneState == PRONE) {
 
-            // FG Leg crawl
-            if (m_pFGLeg && (!m_pBGLeg || (!(m_Paths[FGROUND][CRAWL].PathEnded() && BGLegProg < 0.5) || m_StrideStart)))
-            {
-//                m_StrideStart = false;
-                // Reset the stride timer if the path is about to restart
-				if (m_Paths[FGROUND][CRAWL].PathEnded() || m_Paths[FGROUND][CRAWL].PathIsAtStart()) { m_StrideTimer.Reset(); }
-				m_pFGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pFGLeg->GetParentOffset()), m_Vel, m_Rotation, m_Paths[FGROUND][CRAWL], deltaTime);
-            }
-            else
-                m_Paths[FGROUND][CRAWL].Terminate();
+				float FGLegProg = m_Paths[FGROUND][CRAWL].GetRegularProgress();
+				float BGLegProg = m_Paths[BGROUND][CRAWL].GetRegularProgress();
 
-            // BG Leg crawl
-            if (m_pBGLeg && (!m_pFGLeg || !(m_Paths[BGROUND][CRAWL].PathEnded() && FGLegProg < 0.5)))
-            {
-                m_StrideStart = false;
-                // Reset the stride timer if the path is about to restart
-				if (m_Paths[BGROUND][CRAWL].PathEnded() || m_Paths[BGROUND][CRAWL].PathIsAtStart()) { m_StrideTimer.Reset(); }
-				m_pBGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pBGLeg->GetParentOffset()), m_Vel, m_Rotation, m_Paths[BGROUND][CRAWL], deltaTime);
-            }
-            else
-                m_Paths[BGROUND][CRAWL].Terminate();
+				if (m_pFGLeg && (!m_pBGLeg || (!(m_Paths[FGROUND][CRAWL].PathEnded() && BGLegProg < 0.5F) || m_StrideStart))) {
+					if (m_Paths[FGROUND][CRAWL].PathEnded() || m_Paths[FGROUND][CRAWL].PathIsAtStart()) { m_StrideTimer.Reset(); }
+					m_pFGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pFGLeg->GetParentOffset()), m_Vel, m_Rotation, m_Paths[FGROUND][CRAWL], deltaTime);
+				} else {
+					m_Paths[FGROUND][CRAWL].Terminate();
+				}
+				if (m_pBGLeg && (!m_pFGLeg || !(m_Paths[BGROUND][CRAWL].PathEnded() && FGLegProg < 0.5F))) {
+					m_StrideStart = false;
+					if (m_Paths[BGROUND][CRAWL].PathEnded() || m_Paths[BGROUND][CRAWL].PathIsAtStart()) { m_StrideTimer.Reset(); }
+					m_pBGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pBGLeg->GetParentOffset()), m_Vel, m_Rotation, m_Paths[BGROUND][CRAWL], deltaTime);
+				} else {
+					m_Paths[BGROUND][CRAWL].Terminate();
+				}
+				if (m_pBGArm) {
+					m_ArmClimbing[BGROUND] = true;
+					m_pBGHandGroup->PushAsLimb(m_Pos + RotateOffset(Vector(0, m_pBGArm->GetParentOffset().m_Y)), m_Vel, m_Rotation, m_Paths[BGROUND][ARMCRAWL], deltaTime);
+				} else if (m_pFGArm && !m_pFGArm->HoldsSomething()) {
+					m_ArmClimbing[FGROUND] = true;
+					m_pFGHandGroup->PushAsLimb(m_Pos + RotateOffset(Vector(0, m_pFGArm->GetParentOffset().m_Y)), m_Vel, m_Rotation, m_Paths[FGROUND][ARMCRAWL], deltaTime);
+				}
+				// Restart the stride if the current one seems to be taking too long.
+				if (m_StrideTimer.IsPastSimMS(m_Paths[FGROUND][CRAWL].GetTotalPathTime())) {
+					m_StrideStart = true;
+					m_Paths[FGROUND][CRAWL].Terminate();
+					m_Paths[BGROUND][CRAWL].Terminate();
+				}
+			} else {
+				if (m_pFGLeg) { m_pFGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pFGLeg->GetParentOffset()), m_pFGLeg->GetMaxLength(), m_PrevVel, m_AngularVel, m_pFGLeg->GetMass(), deltaTime); }
 
-            // ARMS using rotated path to help crawl
-			if (m_pBGArm) {
-				m_ArmClimbing[BGROUND] = true;
-				m_pBGHandGroup->PushAsLimb(m_Pos + RotateOffset(Vector(0, m_pBGArm->GetParentOffset().m_Y)), m_Vel, m_Rotation, m_Paths[BGROUND][ARMCRAWL], deltaTime);
-			} else if (m_pFGArm && !m_pFGArm->HoldsSomething()) {
-				m_ArmClimbing[FGROUND] = true;
-				m_pFGHandGroup->PushAsLimb(m_Pos + RotateOffset(Vector(0, m_pFGArm->GetParentOffset().m_Y)), m_Vel, m_Rotation, m_Paths[FGROUND][ARMCRAWL], deltaTime);
+				if (m_pBGLeg) { m_pBGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pBGLeg->GetParentOffset()), m_pBGLeg->GetMaxLength(), m_PrevVel, m_AngularVel, m_pBGLeg->GetMass(), deltaTime); }
 			}
-
-            // Restart the stride if the current one seems to be taking too long
-            if (m_StrideTimer.IsPastSimMS(m_Paths[FGROUND][CRAWL].GetTotalPathTime()))
-            {
-                m_StrideStart = true;
-                m_Paths[FGROUND][CRAWL].Terminate();
-                m_Paths[BGROUND][CRAWL].Terminate();
-            }
 		} else if (m_pFGLeg || m_pBGLeg) {
 			if (m_MoveState == JUMP) {
 				// TODO: Utilize jump paths in an intuitive way!