Merge branch 'development'

Author: garethyr

CHANGELOG.md

@@ -851,6 +851,8 @@ This can be accessed via the new Lua (R/W) `SettingsMan` property `AIUpdateInter
 
 - New `Activity` Lua function `activity:SetPlayerHadBrain(player, whetherOrNotPlayerHadBrain)`, which sets whether or not the given player had a brain. Probably mostly useful for dealing with loading a game with multiple players, where one player is dead and you have to sort out brain assignment.
 
+- 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.
+
 </details>
 
 <details><summary><b>Fixed</b></summary>

Entities/AHuman.cpp

@@ -1298,7 +1298,7 @@ bool AHuman::UnequipBGArm() {
 	if (m_pBGArm) {
 		if (HeldDevice *heldDevice = m_pBGArm->GetHeldDevice()) {
 			heldDevice->Deactivate();
-			AddToInventoryBack(m_pBGArm->RemoveAttachable(heldDevice));
+			AddToInventoryFront(m_pBGArm->RemoveAttachable(heldDevice));
 			m_pBGArm->SetHandPos(m_Pos + RotateOffset(m_HolsterOffset));
 			return true;
 		}
@@ -3151,7 +3151,10 @@ void AHuman::Update()
             }
         }
         // Disengage the prone state as soon as crouch is released.
-        if (!crouching) { m_ProneState = NOTPRONE; }
+        if (!crouching && m_ProneState != NOTPRONE) { 
+			EquipShieldInBGArm();
+			m_ProneState = NOTPRONE; 
+		}
     }
 
 	////////////////////////////////////
@@ -3303,6 +3306,8 @@ void AHuman::Update()
 							if (deviceAsFirearm->FiredOnce()) {
 								m_CanActivateBGItem = true;
 								m_TriggerPulled = true;
+							} else {
+								m_CanActivateBGItem = !deviceAsFirearm->CanFire();
 							}
 						}
 					}
@@ -3399,6 +3404,8 @@ void AHuman::Update()
 					if (deviceAsFirearm->FiredOnce()) {
 						m_CanActivateBGItem = false;
 						m_TriggerPulled = true;
+					} else {
+						m_CanActivateBGItem = deviceAsFirearm->CanFire();
 					}
 				}
 			} else {
@@ -3448,27 +3455,31 @@ void AHuman::Update()
     // Item dropping logic
 
 	if (m_Controller.IsState(WEAPON_DROP) && m_Status != INACTIVE) {
-		bool anyDropped = false;
+		Arm *dropperArm = nullptr;
 		for (Arm *arm : { m_pFGArm, m_pBGArm }) {
-			if (!anyDropped && arm && arm->GetHeldDevice()) {
+			if (arm && arm->GetHeldDevice()) {
 				HeldDevice *heldDevice = arm->GetHeldDevice();
 				arm->RemoveAttachable(heldDevice, true, false);
+				if (dropperArm) {
+					if (heldDevice) {
+						dropperArm->SetHeldDevice(heldDevice);
+						arm->SetHandPos(dropperArm->GetPos());
+					}
+				} else {
+					heldDevice->SetPos(arm->GetJointPos() + Vector(arm->GetMaxLength() * GetFlipFactor(), 0).RadRotate(adjustedAimAngle));
+					Vector tossVec(1.0F + std::sqrt(std::abs(arm->GetThrowStrength()) / std::sqrt(std::abs(heldDevice->GetMass()) + 1.0F)), RandomNormalNum());
+					heldDevice->SetVel(heldDevice->GetVel() * 0.5F + tossVec.RadRotate(m_AimAngle).GetXFlipped(m_HFlipped));
+					heldDevice->SetAngularVel(heldDevice->GetAngularVel() + m_AngularVel * 0.5F + 3.0F * RandomNormalNum());
 
-				heldDevice->SetPos(arm->GetJointPos() + Vector(arm->GetMaxLength() * GetFlipFactor(), 0).RadRotate(adjustedAimAngle));
-				Vector tossVec(1.0F + std::sqrt(std::abs(arm->GetThrowStrength()) / std::sqrt(std::abs(heldDevice->GetMass()) + 1.0F)), RandomNormalNum());
-				heldDevice->SetVel(heldDevice->GetVel() * 0.5F + tossVec.RadRotate(m_AimAngle).GetXFlipped(m_HFlipped));
-				heldDevice->SetAngularVel(heldDevice->GetAngularVel() + m_AngularVel * 0.5F + 3.0F * RandomNormalNum());
-
-				arm->SetHandPos(heldDevice->GetPos());
-				if (!m_Inventory.empty()) {
-					arm->SetHeldDevice(dynamic_cast<HeldDevice *>(SwapNextInventory()));
-					arm->SetHandPos(m_Pos + RotateOffset(m_HolsterOffset));
+					arm->SetHandPos(heldDevice->GetPos());
 				}
-				anyDropped = true;
-				break;
+				dropperArm = arm;
+			} else if (dropperArm && !m_Inventory.empty()) {
+				dropperArm->SetHeldDevice(dynamic_cast<HeldDevice*>(SwapNextInventory()));
+				dropperArm->SetHandPos(m_Pos + RotateOffset(m_HolsterOffset));
 			}
 		}
-		if (!anyDropped && !m_Inventory.empty() && !m_pFGArm) {
+		if (!dropperArm && !m_Inventory.empty() && !m_pFGArm) {
 			DropAllInventory();
 			if (m_pBGArm) {
 				m_pBGArm->SetHandPos(m_Pos + RotateOffset(m_HolsterOffset));

Entities/Actor.cpp

@@ -1087,7 +1087,7 @@ void Actor::GibThis(const Vector &impactImpulse, MovableObject *movableObjectToI
     m_Inventory.clear();
 
     // If this is the actual brain of any player, flash that player's screen when he's now dead
-	if (g_SettingsMan.FlashOnBrainDamage())
+	if (g_SettingsMan.FlashOnBrainDamage() && g_ActivityMan.IsInActivity())
 	{
 		int brainOfPlayer = g_ActivityMan.GetActivity()->IsBrainOfWhichPlayer(this);
 		// Only flash if player is human (AI players don't have screens!)
@@ -1221,6 +1221,9 @@ MOID Actor::GetAIMOWaypointID() const
 
 bool Actor::UpdateMovePath()
 {
+	if (g_SceneMan.GetScene() == nullptr) {
+		return false;
+	}
     // TODO: Do throttling of calls for this function over time??
 
     // Estimate how much material this actor can dig through
@@ -1537,7 +1540,7 @@ void Actor::Update()
     ////////////////////////////////
     // Death logic
 
-	if (m_Status != DYING && m_Status != DEAD && std::round(m_Health) <= 0) {
+	if (m_Status != DYING && m_Status != DEAD && m_Health <= 0) {
 		if (m_DeathSound) { m_DeathSound->Play(m_Pos); }
 		m_Controller.SetDisabled(true);
         DropAllInventory();
@@ -1800,7 +1803,7 @@ void Actor::DrawHUD(BITMAP *pTargetBitmap, const Vector &targetPos, int whichScr
                 pSymbolFont->DrawAligned(&bitmapInt, drawPos.m_X - 11, drawPos.m_Y + m_HUDStack, str, GUIFont::Left);
             }
 */
-            std::snprintf(str, sizeof(str), "%.0f", m_Health);
+			std::snprintf(str, sizeof(str), "%.0f", std::ceil(m_Health));
             pSymbolFont->DrawAligned(&bitmapInt, drawPos.m_X - 0, drawPos.m_Y + m_HUDStack, str, GUIFont::Left);
 
             m_HUDStack += -12;

Entities/HDFirearm.cpp

@@ -1172,14 +1172,12 @@ void HDFirearm::DrawHUD(BITMAP *pTargetBitmap, const Vector &targetPos, int whic
 	}
 
 	float sharpLength = std::max(m_MaxSharpLength * m_SharpAim, 20.0F);
-	int glowStrength;
+	int glowStrength = RandomNum(95, 159);
 	int pointCount;
 	if (playerControlled && sharpLength > 20.0F) {
 		pointCount = m_SharpAim > 0.5F ? 4 : 3;
-		glowStrength = RandomNum(127, 255);
 	} else {
 		pointCount = 2;
-		glowStrength = RandomNum(63, 127);
 	}
 	int pointSpacing = 10 - pointCount;
 	sharpLength -= static_cast<float>(pointSpacing * pointCount) * 0.5F;

Entities/HDFirearm.h

@@ -821,7 +821,7 @@ AddScriptFunctionNames(HeldDevice, "OnFire", "OnReload");
 	/// Gets whether this HDFirearm is ready to be fired.
 	/// </summary>
 	/// <returns>Whether this HDFirearm is ready to pop another Round.</returns>
-	bool CanFire() const { return m_ActivationTimer.IsPastSimMS(GetMSPerRound()); }
+	bool CanFire() const { return m_LastFireTmr.IsPastSimMS(GetMSPerRound()); }
 
 	/// <summary>
 	/// Gets whether this HDFirearm is halfway to be fired. Used for evenly spacing out dual-wielded fire.

Main.cpp

@@ -59,10 +59,10 @@ namespace RTE {
 		g_NetworkServer.Initialize();
 		g_NetworkClient.Initialize();
 		g_TimerMan.Initialize();
-		g_PerformanceMan.Initialize();
 		g_WindowMan.Initialize();
 		g_FrameMan.Initialize();
 		g_PostProcessMan.Initialize();
+		g_PerformanceMan.Initialize();
 
 		if (g_AudioMan.Initialize()) { g_GUISound.Initialize(); }
 
@@ -95,6 +95,7 @@ namespace RTE {
 		g_AudioMan.Destroy();
 		g_PresetMan.Destroy();
 		g_UInputMan.Destroy();
+		g_PostProcessMan.Destroy();
 		g_FrameMan.Destroy();
 		g_TimerMan.Destroy();
 		g_LuaMan.Destroy();

Managers/AudioMan.cpp

@@ -233,11 +233,10 @@ namespace RTE {
 			FMOD::Sound *musicSound;
 			result = (result == FMOD_OK) ? musicChannel->getCurrentSound(&musicSound) : result;
 
-			unsigned int musicLength;
+			unsigned int musicLength = 0;
 			result = (result == FMOD_OK) ? musicSound->getLength(&musicLength, FMOD_TIMEUNIT_MS) : result;
 
-			position = std::clamp(position, 0.0F, static_cast<float>(musicLength)) / 1000.0F;
-			result = (result == FMOD_OK) ? musicChannel->setPosition(static_cast<unsigned int>(position), FMOD_TIMEUNIT_MS) : result;
+			result = (result == FMOD_OK) ? musicChannel->setPosition(std::clamp(static_cast<unsigned int>(position * 1000.0F), 0U, musicLength), FMOD_TIMEUNIT_MS) : result;
 
 			if (result != FMOD_OK) { g_ConsoleMan.PrintString("ERROR: Could not set music position: " + std::string(FMOD_ErrorString(result))); }
 		}

Managers/FrameMan.cpp

@@ -62,9 +62,9 @@ namespace RTE {
 		m_BlackColor = 245;
 		m_AlmostBlackColor = 245;
 		m_ColorTablePruneTimer.Reset();
-		m_GUIScreen = nullptr;
-		m_LargeFont = nullptr;
-		m_SmallFont = nullptr;
+		m_GUIScreens.fill(nullptr);
+		m_LargeFonts.fill(nullptr);
+		m_SmallFonts.fill(nullptr);
 		m_TextBlinkTimer.Reset();
 
 		for (int screenCount = 0; screenCount < c_MaxScreenCount; ++screenCount) {
@@ -89,7 +89,7 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int FrameMan::Initialize() {
-		set_color_depth(m_BPP);
+		set_color_depth(c_BPP);
 		// Sets the allowed color conversions when loading bitmaps from files
 		set_color_conversion(COLORCONV_MOST);
 
@@ -122,10 +122,10 @@ namespace RTE {
 		ClearBackBuffer8();
 
 		// Create the post-processing buffer, it'll be used for glow effects etc
-		m_BackBuffer32 = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(32, resX, resY));
+		m_BackBuffer32 = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(c_BPP, resX, resY));
 		ClearBackBuffer32();
 
-		m_OverlayBitmap32 = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(32, resX, resY));
+		m_OverlayBitmap32 = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(c_BPP, resX, resY));
 		clear_to_color(m_OverlayBitmap32.get(), 0);
 
 		// Create all the network 8bpp back buffers
@@ -187,10 +187,15 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void FrameMan::Destroy() {
-		delete m_GUIScreen;
-		delete m_LargeFont;
-		delete m_SmallFont;
-
+		for (const GUIScreen *guiScreen : m_GUIScreens) {
+			delete guiScreen;
+		}
+		for (const GUIFont *guiFont : m_LargeFonts) {
+			delete guiFont;
+		}
+		for (const GUIFont *guiFont : m_SmallFonts) {
+			delete guiFont;
+		}
 		Clear();
 	}
 
@@ -326,7 +331,7 @@ namespace RTE {
 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	std::string FrameMan::SplitStringToFitWidth(const std::string &stringToSplit, int widthLimit, bool useSmallFont) {
-		GUIFont *fontToUse = GetFont(useSmallFont);
+		GUIFont *fontToUse = GetFont(useSmallFont, false);
 		auto SplitSingleLineAsNeeded = [this, &widthLimit, &fontToUse](std::string &lineToSplitAsNeeded) {
 			int numberOfScreenWidthsForText = static_cast<int>(std::ceil(static_cast<float>(fontToUse->CalculateWidth(lineToSplitAsNeeded)) / static_cast<float>(widthLimit)));
 			if (numberOfScreenWidthsForText > 1) {
@@ -550,12 +555,12 @@ namespace RTE {
 			case ScenePreviewDump:
 			case WorldDump:
 				if (!m_WorldDumpBuffer || (m_WorldDumpBuffer->w != g_SceneMan.GetSceneWidth() || m_WorldDumpBuffer->h != g_SceneMan.GetSceneHeight())) {
-					m_WorldDumpBuffer = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(32, g_SceneMan.GetSceneWidth(), g_SceneMan.GetSceneHeight()));
+					m_WorldDumpBuffer = std::unique_ptr<BITMAP, BitmapDeleter>(create_bitmap_ex(c_BPP, g_SceneMan.GetSceneWidth(), g_SceneMan.GetSceneHeight()));
 				}
 				if (modeToSave == ScenePreviewDump) {
 					DrawWorldDump(true);
 
-					BITMAP *scenePreviewDumpBuffer = create_bitmap_ex(32, c_ScenePreviewWidth, c_ScenePreviewHeight);
+					BITMAP *scenePreviewDumpBuffer = create_bitmap_ex(c_BPP, c_ScenePreviewWidth, c_ScenePreviewHeight);
 					blit(m_ScenePreviewDumpGradient.get(), scenePreviewDumpBuffer, 0, 0, 0, 0, scenePreviewDumpBuffer->w, scenePreviewDumpBuffer->h);
 					masked_stretch_blit(m_WorldDumpBuffer.get(), scenePreviewDumpBuffer, 0, 0, m_WorldDumpBuffer->w, m_WorldDumpBuffer->h, 0, 0, scenePreviewDumpBuffer->w, scenePreviewDumpBuffer->h);
 
@@ -714,21 +719,39 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	GUIFont * FrameMan::GetFont(bool isSmall) {
-		if (!m_GUIScreen) { m_GUIScreen = new AllegroScreen(m_BackBuffer8.get()); }
+	GUIFont * FrameMan::GetFont(bool isSmall, bool trueColor) {
+		size_t colorIndex = trueColor ? 1 : 0;
+
+		if (!m_GUIScreens[colorIndex]) {
+			m_GUIScreens[colorIndex] = new AllegroScreen(trueColor ? m_BackBuffer32.get() : m_BackBuffer8.get());
+		}
 
 		if (isSmall) {
-			if (!m_SmallFont) {
-				m_SmallFont = new GUIFont("SmallFont");
-				m_SmallFont->Load(m_GUIScreen, "Base.rte/GUIs/Skins/FontSmall.png");
+			if (!m_SmallFonts[colorIndex]) {
+				std::string fontName = "SmallFont";
+				std::string fontPath = "Base.rte/GUIs/Skins/FontSmall.png";
+
+				if (trueColor) {
+					fontName = "SmallFont32";
+					fontPath = "Base.rte/GUIs/Skins/Menus/FontSmall.png";
+				}
+				m_SmallFonts[colorIndex] = new GUIFont(fontName);
+				m_SmallFonts[colorIndex]->Load(m_GUIScreens[colorIndex], fontPath);
 			}
-			return m_SmallFont;
+			return m_SmallFonts[colorIndex];
 		}
-		if (!m_LargeFont) {
-			m_LargeFont = new GUIFont("FatFont");
-			m_LargeFont->Load(m_GUIScreen, "Base.rte/GUIs/Skins/FontLarge.png");
+		if (!m_LargeFonts[colorIndex]) {
+			std::string fontName = "FatFont";
+			std::string fontPath = "Base.rte/GUIs/Skins/FontLarge.png";
+
+			if (trueColor) {
+				fontName = "FatFont32";
+				fontPath = "Base.rte/GUIs/Skins/Menus/FontLarge.png";
+			}
+			m_LargeFonts[colorIndex] = new GUIFont(fontName);
+			m_LargeFonts[colorIndex]->Load(m_GUIScreens[colorIndex], fontPath);
 		}
-		return m_LargeFont;
+		return m_LargeFonts[colorIndex];
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Managers/FrameMan.h

@@ -27,6 +27,8 @@ namespace RTE {
 
 	public:
 
+		static constexpr int c_BPP = 32; //!< Color depth (bits per pixel).
+
 		Vector SLOffset[c_MaxScreenCount][c_MaxLayersStoredForNetwork]; //!< SceneLayer offsets for each screen in online multiplayer.
 
 #pragma region Creation
@@ -174,14 +176,16 @@ namespace RTE {
 		/// <summary>
 		/// Gets the small font from the GUI engine's current skin. Ownership is NOT transferred!
 		/// </summary>
+		/// <param name="trueColor">Whether to get the 32bpp color version of the font.</param>
 		/// <returns>A pointer to the requested font, or 0 if no small font was found.</returns>
-		GUIFont * GetSmallFont() { return GetFont(true); }
+		GUIFont * GetSmallFont(bool trueColor = false) { return GetFont(true, trueColor); }
 
 		/// <summary>
 		/// Gets the large font from the GUI engine's current skin. Ownership is NOT transferred!
 		/// </summary>
+		/// <param name="trueColor">Whether to get the 32bpp color version of the font.</param>
 		/// <returns>A pointer to the requested font, or 0 if no large font was found.</returns>
-		GUIFont * GetLargeFont() { return GetFont(false); }
+		GUIFont * GetLargeFont(bool trueColor = false) { return GetFont(false, trueColor); }
 
 		/// <summary>
 		/// Calculates the width of a text string using the given font size.
@@ -466,8 +470,6 @@ namespace RTE {
 		/// </summary>
 		enum SaveBitmapMode { SingleBitmap, ScreenDump, WorldDump, ScenePreviewDump };
 
-		static constexpr int m_BPP = 32; //!< Color depth (bits per pixel).
-
 		static const std::array<std::function<void(int r, int g, int b, int a)>, DrawBlendMode::BlendModeCount> c_BlenderSetterFunctions; //!< Array of function references to Allegro blender setters for convenient access when creating new color tables.
 
 		bool m_HSplit; //!< Whether the screen is split horizontally across the screen, ie as two splitscreens one above the other.
@@ -493,9 +495,9 @@ namespace RTE {
 		int m_PlayerScreenWidth; //!< Width of the screen of each player. Will be smaller than resolution only if the screen is split.
 		int m_PlayerScreenHeight; //!< Height of the screen of each player. Will be smaller than resolution only if the screen is split.
 
-		AllegroScreen *m_GUIScreen; //!< GUI screen object kept and owned just for the fonts.
-		GUIFont *m_SmallFont; //!< Pointer to the standard small font for quick access.
-		GUIFont *m_LargeFont; //!< Pointer to the standard large font for quick access.
+		std::array<AllegroScreen *, 2> m_GUIScreens; //!< GUI screen objects kept and owned just for the fonts.
+		std::array<GUIFont *, 2> m_SmallFonts; //!< Pointers to the standard small font for quick access.
+		std::array<GUIFont *, 2> m_LargeFonts; //!< Pointers to the standard large font for quick access.
 
 		std::string m_ScreenText[c_MaxScreenCount]; //!< The text to be displayed on each player's screen.
 		bool m_TextCentered[c_MaxScreenCount]; //!< Whether screen text is centered vertically.
@@ -626,8 +628,9 @@ namespace RTE {
 		/// Gets the requested font from the GUI engine's current skin. Ownership is NOT transferred!
 		/// </summary>
 		/// <param name="isSmall">Size of font to get. True for small font, false for large font.</param>
+		/// <param name="trueColor">Whether to get the 32bpp color version of the font.</param>
 		/// <returns>A pointer to the requested font, or 0 if no font was found.</returns>
-		GUIFont * GetFont(bool isSmall);
+		GUIFont * GetFont(bool isSmall, bool trueColor);
 
 		/// <summary>
 		/// Clears all the member variables of this FrameMan, effectively resetting the members of this abstraction level only.

Managers/LuaMan.cpp

@@ -542,7 +542,7 @@ namespace RTE {
 			return -1;
 		}
 
-		std::string fullPath = System::GetWorkingDirectory() + fileName;
+		std::string fullPath = System::GetWorkingDirectory() + g_PresetMan.GetFullModulePath(fileName);
 		if ((fullPath.find("..") == std::string::npos) && (fullPath.find(System::GetModulePackageExtension()) != std::string::npos)) {
 
 #ifdef _WIN32