Merge pull request #522 from cortex-command-community/4zk-content-source

5.2 additions v2: Electric Boogaloo

Author: garethyr

CHANGELOG.md

@@ -601,8 +601,6 @@ This can be accessed via the new Lua (R/W) `SettingsMan` property `AIUpdateInter
 
 - New `MovableObject` Lua (R) property `DistanceTravelled` which returns the amount of pixels the object has travelled since its creation.
 
-- Added `Activity` Lua function `ForceSetTeamAsActive(team)`, which forcefully sets a team as active. Necessary for `Activity`s that don't want to define/show all used teams, but still want `Actor`s of hidden teams to work properly.
-
 - Added `GameActivity` INI property `DefaultGoldMaxDifficulty`, which lets you specify the default gold when the difficulty slider is maxed out.
 
 - Added `HDFirearm` Lua (R/W) property `BaseReloadTime` that lets you get and set the `HDFirearm`'s base reload time (i.e. the reload time before it's adjusted for one-handed reloads where appropriate).
@@ -637,6 +635,8 @@ This can be accessed via the new Lua (R/W) `SettingsMan` property `AIUpdateInter
 
 - Added `Activity` Lua function `GetPlayerController`, which gets you the `Controller` used for GUI stuff and when there's no `Actor` selected in an `Activity`. Be aware, it's very likely possible to cause problems by doing dumb things with this.
 
+- Added `Leg` Lua (R/W) property `MoveSpeed`, which lets you get and set the `Leg`'s `MoveSpeed` scalar, similar to `Arm`s. 1 means instant movement and 0 means no movement.
+
 - Added `LuaMan` Lua function `FileExists`, which lets you check whether a specified file exists. Like with `FileOpen`, the file must be inside a folder ending in `.rte`.
 
 </details>
@@ -861,6 +861,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/ACrab.cpp

@@ -2447,8 +2447,15 @@ void ACrab::Update()
 
 			// Reset the right-side walking stride if it's taking longer than it should.
 			if (m_StrideTimer[RIGHTSIDE].IsPastSimMS(static_cast<double>(m_Paths[RIGHTSIDE][FGROUND][WALK].GetTotalPathTime() * 1.1F))) { m_StrideStart[RIGHTSIDE] = true; }
-
-			if (restarted && m_StrideSound) { m_StrideSound->Play(m_Pos); }
+            
+			if (m_StrideSound) {
+				m_StrideSound->SetPosition(m_Pos);
+				if (m_StrideSound->GetLoopSetting() < 0) {
+					if (!m_StrideSound->IsBeingPlayed()) { m_StrideSound->Play(); }
+				} else if (restarted) {
+					m_StrideSound->Play();
+				}
+			}
 		} else if (m_pLFGLeg || m_pLBGLeg || m_pRFGLeg || m_pRBGLeg) {
 			if (m_MoveState == JUMP) {
 				// TODO: Utilize jump paths in an intuitive way?
@@ -2498,6 +2505,9 @@ void ACrab::Update()
 
 		if (m_pRBGLeg) { m_pRBGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pRBGLeg->GetParentOffset()), m_pRBGLeg->GetMaxLength(), m_PrevVel * m_pRBGLeg->GetJointStiffness(), m_AngularVel, m_pRBGLeg->GetMass(), deltaTime); }
 	}
+    if (m_MoveState != WALK && m_StrideSound && m_StrideSound->GetLoopSetting() < 0) {
+        m_StrideSound->Stop();
+    }
 
     /////////////////////////////////
     // Manage Attachable:s

Entities/ACraft.cpp

@@ -800,37 +800,6 @@ float ACraft::GetCollectedInventoryMass() const {
 	return inventoryMass;
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnMOHit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Defines what should happen when this MovableObject hits another MO.
-//                  This is called by the owned Atom/AtomGroup of this MovableObject during
-//                  travel.
-
-bool ACraft::OnMOHit(MovableObject *pOtherMO)
-{
-/* Obviously don't put craft into craft
-    // See if we hit any craft with open doors to get sucked into
-    ACraft *pCraft = dynamic_cast<ACraft *>(pOtherMO);
-
-    // Don't let things of wrong teams get sucked into other team's craft
-    if (!IsSetToDelete() && pCraft && m_Team == pCraft->GetTeam() && (pCraft->GetHatchState() == ACraft::OPEN || pCraft->GetHatchState() == ACraft::OPENING))
-    {
-        // Add (copy) to the ship's inventory
-        pCraft->AddInventoryItem(dynamic_cast<MovableObject *>(this->Clone()));
-        // Delete the original from scene - this is safer than 'removing' or handing over ownership halfway through MovableMan's update
-        this->SetToDelete();
-        // Terminate; we got sucked into the craft; so communicate this out
-        return true;
-    }
-*/
-    // Don't terminate, continue travel
-    return false;
-}
-
-
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void ACraft::GibThis(const Vector &impactImpulse, MovableObject *movableObjectToIgnore) {

Entities/ACraft.h

@@ -461,19 +461,6 @@ enum Side
 	/// </summary>
 	void ResetAllTimers() override;
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnMOHit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Defines what should happen when this MovableObject hits another MO.
-//                  This is called by the owned Atom/AtomGroup of this MovableObject during
-//                  travel.
-// Arguments:       The other MO hit. Ownership is not transferred.
-// Return value:    Wheter the MovableObject should immediately halt any travel going on
-//                  after this hit.
-
-	bool OnMOHit(MovableObject *pOtherMO) override;
-
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  Update
 //////////////////////////////////////////////////////////////////////////////////////////

Entities/AHuman.cpp

@@ -3582,13 +3582,20 @@ void AHuman::Update()
 			}
 			bool climbing = m_ArmClimbing[FGROUND] || m_ArmClimbing[BGROUND];
 
+			if (m_StrideSound) {
+				m_StrideSound->SetPosition(m_Pos);
+				if (m_StrideSound->GetLoopSetting() < 0) {
+					if (!m_StrideSound->IsBeingPlayed()) { m_StrideSound->Play(); }
+				} else if (restarted && !climbing) {
+					m_StrideSound->Play();
+				}
+			}
 			if (restarted) {
-				if (!climbing) {
-					if (m_StrideSound) { m_StrideSound->Play(m_Pos); }
-					RunScriptedFunctionInAppropriateScripts("OnStride");
-				} else {
+				if (climbing) {
 					m_WalkAngle[FGROUND] = Matrix();
 					m_WalkAngle[BGROUND] = Matrix();
+				} else {
+					RunScriptedFunctionInAppropriateScripts("OnStride");
 				}
 			}
 
@@ -3732,6 +3739,9 @@ void AHuman::Update()
 
         if (m_pBGLeg) { m_pBGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pBGLeg->GetParentOffset()), m_pBGLeg->GetMaxLength(), m_PrevVel * m_pBGLeg->GetJointStiffness(), m_AngularVel, m_pBGLeg->GetMass(), deltaTime); }
 	}
+    if (m_MoveState != WALK && m_StrideSound && m_StrideSound->GetLoopSetting() < 0) {
+        m_StrideSound->Stop();
+    }
 
     /////////////////////////////////
     // Manage Attachables
@@ -4048,7 +4058,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/Activity.cpp

@@ -632,7 +632,7 @@ void Activity::Clear() {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	std::string Activity::GetDifficultyString(int difficulty) {
-		if (difficulty < DifficultySetting::CakeDifficulty) {
+		if (difficulty <= DifficultySetting::CakeDifficulty) {
 			return "Cake";
 		} else if (difficulty <= DifficultySetting::EasyDifficulty) {
 			return "Easy";
@@ -804,24 +804,29 @@ void Activity::Clear() {
 		}
 
 		float totalValue = orbitedCraft->GetTotalValue(0, foreignCostMult, nativeCostMult);
-		std::snprintf(messageString, sizeof(messageString), "Returned Craft + Cargo added %.0f oz to Funds!", totalValue);
 
+		std::string craftText = "Returned craft";
+		if (!orbitedCraft->IsInventoryEmpty()) { 
+			craftText += " + cargo";
+		}
+		if (totalValue > 0.0F) {
+			m_TeamFunds[orbitedCraftTeam] += totalValue;
+			std::snprintf(messageString, sizeof(messageString), "%s added %.0f oz to funds!", craftText.c_str(), totalValue);
+		}
 		for (int player = Players::PlayerOne; player < Players::MaxPlayerCount; ++player) {
 			if (m_IsActive[player]) {
 				if (brainOnBoard && orbitedCraft == GetPlayerBrain(static_cast<Players>(player))) {
 					m_BrainEvacuated[player] = true;
-					std::snprintf(messageString, sizeof(messageString), "YOUR BRAIN HAS BEEN EVACUATED BACK INTO ORBIT!");
-				}
-
-				if (m_Team[player] == orbitedCraftTeam) {
-					g_FrameMan.ClearScreenText(ScreenOfPlayer(ScreenOfPlayer(static_cast<Players>(player))));
+					g_FrameMan.ClearScreenText(ScreenOfPlayer(static_cast<Players>(player)));
+					g_FrameMan.SetScreenText("YOUR BRAIN HAS BEEN EVACUATED BACK INTO ORBIT!", ScreenOfPlayer(static_cast<Players>(player)), 0, 3500);
+				} else if (m_Team[player] == orbitedCraftTeam && totalValue > 0.0F) {
+					g_FrameMan.ClearScreenText(ScreenOfPlayer(static_cast<Players>(player)));
 					g_FrameMan.SetScreenText(messageString, ScreenOfPlayer(static_cast<Players>(player)), 0, 3500);
 					m_MessageTimer[player].Reset();
 				}
 			}
 		}
 
-		m_TeamFunds[orbitedCraftTeam] += totalValue;
 		orbitedCraft->SetGoldCarried(0);
 		orbitedCraft->SetHealth(orbitedCraft->GetMaxHealth());
 

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;
 
@@ -610,7 +608,7 @@ bool Actor::HasObjectInGroup(std::string groupName) const
 
 void Actor::SetTeam(int team)
 {
-    SceneObject::SetTeam(team);
+	MovableObject::SetTeam(team);
 
     // Change the Team Icon to display
     m_pTeamIcon = 0;
@@ -1153,40 +1151,6 @@ bool Actor::ParticlePenetration(HitData &hd) {
     return penetrated;
 }
 
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnMOHit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Defines what should happen when this MovableObject hits another MO.
-//                  This is called by the owned Atom/AtomGroup of this MovableObject during
-//                  travel.
-
-bool Actor::OnMOHit(MovableObject *pOtherMO)
-{
-/* The ACraft now actively suck things in with cast rays instead
-    // See if we hit any craft with open doors to get sucked into
-    ACraft *pCraft = dynamic_cast<ACraft *>(pOtherMO);
-
-    // Don't let things of wrong teams get sucked into other team's craft
-    if (!IsSetToDelete() && pCraft && m_Team == pCraft->GetTeam() && (pCraft->GetHatchState() == ACraft::OPEN || pCraft->GetHatchState() == ACraft::OPENING))
-    {
-        // Switch control to the craft we just entered, if this is currently player controlled
-        // Set AI controller of this one going into the ship
-        if (g_ActivityMan.GetActivity() && this->GetController()->IsPlayerControlled())
-            g_ActivityMan.GetActivity()->SwitchToActor(pCraft, this->GetController()->GetPlayer(), this->GetTeam());
-        // Add (copy) to the ship's inventory
-        pCraft->AddInventoryItem(dynamic_cast<MovableObject *>(this->Clone()));
-        // Delete the original from scene - this is safer than 'removing' or handing over ownership halfway through MovableMan's update
-        this->SetToDelete();
-        // Terminate; we got sucked into the craft; so communicate this out
-        return true;
-    }
-*/
-    // Don't terminate, continue travel
-    return false;
-}
-
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  GetAIModeIcon
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1588,15 +1552,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 +1586,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
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1063,20 +1052,6 @@ ClassInfoGetters;
 
 	bool ParticlePenetration(HitData &hd) override;
 
-
-//////////////////////////////////////////////////////////////////////////////////////////
-// Virtual method:  OnMOHit
-//////////////////////////////////////////////////////////////////////////////////////////
-// Description:     Defines what should happen when this MovableObject hits another MO.
-//                  This is called by the owned Atom/AtomGroup of this MovableObject during
-//                  travel.
-// Arguments:       The other MO hit. Ownership is not transferred.
-// Return value:    Wheter the MovableObject should immediately halt any travel going on
-//                  after this hit.
-
-	bool OnMOHit(MovableObject *pOtherMO) override;
-
-
 //////////////////////////////////////////////////////////////////////////////////////////
 // Virtual method:  PreTravel
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1212,20 +1187,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 +1485,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/AtomGroup.cpp

@@ -1465,12 +1465,6 @@ namespace RTE {
 		if (!intersectedMO) {
 			return false;
 		}
-		if (m_OwnerMOSR->OnMOHit(intersectedMO)) {
-			return false;
-		}
-		if (intersectedMO->OnMOHit(m_OwnerMOSR->GetRootParent())) {
-			return false;
-		}
 
 		std::list<Atom *> intersectingAtoms;
 

Entities/HDFirearm.cpp

@@ -655,7 +655,7 @@ void HDFirearm::Activate() {
 
     if (!IsReloading()) {
 		if (m_DeactivationSound && m_DeactivationSound->IsBeingPlayed()) { m_DeactivationSound->FadeOut(); }
-        if (m_ActiveSound && !m_ActiveSound->IsBeingPlayed()) { m_ActiveSound->Play(this->m_Pos); }
+        if (m_ActiveSound && !m_ActiveSound->IsBeingPlayed() && (m_ActiveSound->GetLoopSetting() == -1 || !wasActivated)) { m_ActiveSound->Play(this->m_Pos); }
         if (m_PreFireSound && !wasActivated && !m_PreFireSound->IsBeingPlayed()) { m_PreFireSound->Play(this->m_Pos); }
     }
 }