Fixed a crash that could happen during door MaterialDrawOverride

Also renamed MaterialDrawOverride and cleaned up a bunch of stuff in Door.cpp while I was here:
Swapped soundcontainers to unique ptrs, cleaned up some logic, onelined some things, added some missing static_casts

Author: garethyr

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,10 +372,8 @@ namespace RTE {
 
 		Actor::Update();
 
-		if (!m_Door) {
-			// 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;
@@ -396,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;
@@ -411,7 +398,7 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void ADoor::UpdateSensors() {		
-		const Actor *foundActor = 0;
+		const Actor *foundActor = nullptr;
 		bool anySensorInput = false;
 
 		for (ADSensor &sensor : m_Sensors) {
@@ -422,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;
@@ -500,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.

Managers/MovableMan.cpp

@@ -1550,7 +1550,7 @@ void MovableMan::OverrideMaterialDoors(bool enable, int team)
         {
             // Update first so the door attachable piece is in the right position and doesn't take out a werid chunk of the terrain
             pDoor->Update();
-            pDoor->MaterialDrawOverride(enable);
+            pDoor->TempEraseOrRedrawDoorMaterial(enable);
         }
     }
     // Also check all doors added this frame
@@ -1561,7 +1561,7 @@ void MovableMan::OverrideMaterialDoors(bool enable, int team)
         {
             // Update first so the door attachable piece is in the right position and doesn't take out a werid chunk of the terrain
             pDoor->Update();
-            pDoor->MaterialDrawOverride(enable);
+            pDoor->TempEraseOrRedrawDoorMaterial(enable);
         }
     }
 }