Move FlashWhite from Actor to MOSRotating

Author: fourZK

CHANGELOG.md

@@ -859,6 +859,8 @@ This can be accessed via the new Lua (R/W) `SettingsMan` property `AIUpdateInter
 
 - Changed `LuaMan:FileOpen` access modes so it only allows `"r", "r+", "w", "w+", "a", "a+"`, i.e. specifying type (text, binary) is not supported. See [this reference page](https://cplusplus.com/reference/cstdio/fopen) for details on the access modes.
 
+- Moved `FlashWhite` function from `Actor` to `MOSRotating`.
+
 </details>
 
 <details><summary><b>Fixed</b></summary>

Entities/AHuman.cpp

@@ -4048,7 +4048,7 @@ void AHuman::DrawThrowingReticle(BITMAP *targetBitmap, const Vector &targetPos,
 void AHuman::Draw(BITMAP *pTargetBitmap, const Vector &targetPos, DrawMode mode, bool onlyPhysical) const {
     Actor::Draw(pTargetBitmap, targetPos, mode, onlyPhysical);
 
-    DrawMode realMode = (mode == g_DrawColor && m_FlashWhiteMS) ? g_DrawWhite : mode;
+    DrawMode realMode = (mode == g_DrawColor && !m_FlashWhiteTimer.IsPastRealTimeLimit()) ? g_DrawWhite : mode;
     // Note: For some reason the ordering of the attachables list can get messed up. The most important thing here is that the FGArm is on top of everything else.
     if (m_pHead && m_pHead->IsDrawnAfterParent()) { m_pHead->Draw(pTargetBitmap, targetPos, realMode, onlyPhysical); }
     if (m_pFGArm) { m_pFGArm->Draw(pTargetBitmap, targetPos, realMode, onlyPhysical); }

Entities/Actor.cpp

@@ -109,8 +109,6 @@ void Actor::Clear() {
 	m_MaxInventoryMass = -1.0F;
 	m_pItemInReach = nullptr;
     m_HUDStack = 0;
-    m_FlashWhiteMS = 0;
-    m_WhiteFlashTimer.Reset();
 	m_DeploymentID = 0;
     m_PassengerSlots = 1;
 
@@ -1588,15 +1586,6 @@ void Actor::Update()
         g_MovableMan.SortTeamRoster(m_Team);
     }
 
-    // Reduce the remaining white flash time
-    if (m_FlashWhiteMS)
-    {
-        m_FlashWhiteMS -= m_WhiteFlashTimer.GetElapsedRealTimeMS();
-        m_WhiteFlashTimer.Reset();
-        if (m_FlashWhiteMS < 0)
-            m_FlashWhiteMS = 0;
-    }
-
 	int brainOfPlayer = g_ActivityMan.GetActivity()->IsBrainOfWhichPlayer(this);
 	if (brainOfPlayer != Players::NoPlayer && g_ActivityMan.GetActivity()->PlayerHuman(brainOfPlayer)) {
 		if (m_PrevHealth - m_Health > 1.5F) {
@@ -1631,22 +1620,6 @@ void Actor::Update()
 }
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  Draw
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Draws this Actor's current graphical representation to a
-//                  BITMAP of choice.
-
-void Actor::Draw(BITMAP *pTargetBitmap,
-                 const Vector &targetPos,
-                 DrawMode mode,
-                 bool onlyPhysical) const
-{
-    // Make it draw white if is going to be drawn as color
-    MOSRotating::Draw(pTargetBitmap, targetPos, mode == g_DrawColor && m_FlashWhiteMS ? g_DrawWhite : mode, onlyPhysical);
-}
-
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  DrawHUD
 //////////////////////////////////////////////////////////////////////////////////////////

Entities/Actor.h

@@ -1003,17 +1003,6 @@ ClassInfoGetters;
 	void SetAimRange(float range) { m_AimRange = range; }
 
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Method:          FlashWhite
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Tells to make this and all children get drawn as completely white, but
-//                  only for a specified amount of time.
-// Arguments:       For how long to flash the whiteness, in MS.
-// Return value:    None.
-
-    void FlashWhite(int howLongMS = 32) { m_FlashWhiteMS = howLongMS; m_WhiteFlashTimer.Reset(); }
-
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Method:          DrawWaypoints
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1212,20 +1201,6 @@ ClassInfoGetters;
 
 	void SetSightDistance(float newValue) { m_SightDistance = newValue; }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  Draw
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Draws this Actor's current graphical representation to a
-//                  BITMAP of choice.
-// Arguments:       A pointer to a BITMAP to draw on.
-//                  The absolute position of the target bitmap's upper left corner in the Scene.
-//                  In which mode to draw in. See the DrawMode enumeration for the modes.
-//                  Whether to not draw any extra 'ghost' items of this MovableObject,
-//                  indicator arrows or hovering HUD text and so on.
-// Return value:    None.
-
-    void Draw(BITMAP *pTargetBitmap, const Vector &targetPos = Vector(), DrawMode mode = g_DrawColor, bool onlyPhysical = false) const override;
-
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  DrawHUD
@@ -1524,10 +1499,6 @@ ClassInfoGetters;
     HeldDevice *m_pItemInReach;
     // HUD positioning aid
     int m_HUDStack;
-    // For how much longer to draw this as white. 0 means don't draw as white
-    int m_FlashWhiteMS;
-    // The timer that measures and deducts past time from the remaining white flash time
-    Timer m_WhiteFlashTimer;
 	// ID of deployment which spawned this actor
 	unsigned int m_DeploymentID;
     // How many passenger slots this actor will take in a craft

Entities/MOSRotating.cpp

@@ -89,6 +89,8 @@ void MOSRotating::Clear()
     m_LoudnessOnGib = 1;
 	m_DamageMultiplier = 0;
     m_NoSetDamageMultiplier = true;
+	m_FlashWhiteTimer.Reset();
+	m_FlashWhiteTimer.SetRealTimeLimitMS(0);
     m_StringValueMap.clear();
     m_NumberValueMap.clear();
     m_ObjectValueMap.clear();
@@ -1822,6 +1824,8 @@ void MOSRotating::Draw(BITMAP *pTargetBitmap, const Vector &targetPos, DrawMode
         return;
     }
 
+	if (mode == g_DrawColor && !m_FlashWhiteTimer.IsPastRealTimeLimit()) { mode = g_DrawWhite; }
+
     // Draw all the attached wound emitters, and only if the mode is g_DrawColor and not onlyphysical
     // Only draw attachables and emitters which are not drawn after parent, so we draw them before
     if (mode == g_DrawColor || (!onlyPhysical && mode == g_DrawMaterial)) {

Entities/MOSRotating.h

@@ -900,6 +900,12 @@ ClassInfoGetters;
 	/// <param name="newValue">New scalar value.</param>
 	void SetOrientToVel(float newValue) { m_OrientToVel = newValue; }
 
+	/// <summary>
+	/// Sets this MOSRotating and all its children to drawn white for a specified amount of time.
+	/// </summary>
+	/// <param name="durationMS">Duration of flash in real time MS.</param>
+	void FlashWhite(int durationMS = 32) { m_FlashWhiteTimer.SetRealTimeLimitMS(durationMS); m_FlashWhiteTimer.Reset(); }
+
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Method:          GetTravelImpulse
@@ -1046,6 +1052,8 @@ ClassInfoGetters;
 	float m_DamageMultiplier; //!< Damage multiplier for this MOSRotating.
     bool m_NoSetDamageMultiplier; //!< Whether or not the damage multiplier for this MOSRotating was set.
 
+	Timer m_FlashWhiteTimer; //!< The timer for timing white draw mode duration.
+
     // Intermediary drawing bitmap used to flip rotating bitmaps. Owned!
     BITMAP *m_pFlipBitmap;
     BITMAP *m_pFlipBitmapS;

Lua/LuaBindingsEntities.cpp

@@ -287,7 +287,6 @@ namespace RTE {
 		.def("DropAllInventory", &Actor::DropAllInventory)
 		.def("DropAllGold", &Actor::DropAllGold)
 		.def("IsInventoryEmpty", &Actor::IsInventoryEmpty)
-		.def("FlashWhite", &Actor::FlashWhite)
 		.def("DrawWaypoints", &Actor::DrawWaypoints)
 		.def("SetMovePathToUpdate", &Actor::SetMovePathToUpdate)
 		.def("UpdateMovePath", &Actor::UpdateMovePath)
@@ -926,6 +925,7 @@ namespace RTE {
 		.def("ForceDeepCheck", &MOSRotating::ForceDeepCheck)
 		.def("GibThis", &MOSRotating::GibThis)
 		.def("MoveOutOfTerrain", &MOSRotating::MoveOutOfTerrain)
+		.def("FlashWhite", &MOSRotating::FlashWhite)
 		.def("GetGibWoundLimit", (int (MOSRotating:: *)() const) &MOSRotating::GetGibWoundLimit)
 		.def("GetGibWoundLimit", (int (MOSRotating:: *)(bool positiveDamage, bool negativeDamage, bool noDamage) const) &MOSRotating::GetGibWoundLimit)
 		.def("GetWoundCount", (int (MOSRotating:: *)() const) &MOSRotating::GetWoundCount)

System/Timer.h

@@ -169,7 +169,7 @@ namespace RTE {
 		/// Returns true if the elapsed real time is past a certain amount of time after the start previously set by SetRealTimeLimit.
 		/// </summary>
 		/// <returns>A bool only yielding true if the elapsed real time is greater than the set limit value. If no limit has been set, this returns false.</returns>
-		bool IsPastRealTimeLimit() { return (m_RealTimeLimit == 0) ? true : (m_RealTimeLimit > 0 && (g_TimerMan.GetRealTickCount() - m_StartRealTime) > m_RealTimeLimit); }
+		bool IsPastRealTimeLimit() const { return (m_RealTimeLimit == 0) ? true : (m_RealTimeLimit > 0 && (g_TimerMan.GetRealTickCount() - m_StartRealTime) > m_RealTimeLimit); }
 
 		/// <summary>
 		/// Returns how much progress has been made toward the set time limit previously set by SetRealTimeLimitMS.