Merge branch 'master' into feature/additional-weapon-customization

Author: DeValdi

Client/cefweb/CWebApp.cpp

@@ -101,10 +101,13 @@ namespace
         if (disableGpu)
         {
             commandLine->AppendSwitch("disable-gpu");
-            // Also disable GPU compositing when GPU is disabled
-            commandLine->AppendSwitch("disable-gpu-compositing");
         }
 
+        // Disable GPU compositing in all cases.
+        // This keeps Chromium's compositor on the software path even when GPU
+        // rendering stays enabled for other browser pipelines.
+        commandLine->AppendSwitch("disable-gpu-compositing");
+
         // Hardware video decoding - enable when GPU is enabled and video acceleration is requested
         if (!disableGpu && enableVideoAccel)
         {

Client/core/CClientVariables.cpp

@@ -258,6 +258,8 @@ void CClientVariables::ValidateValues()
     ClampValue("chat_text_alignment", Chat::Text::Align::LEFT, Chat::Text::Align::RIGHT);
     ClampValue("text_scale", 0.8f, 3.0f);
     ClampValue("mastervolume", 0.0f, 1.0f);
+    ClampValue("radiovolume", 0.0f, 1.0f);
+    ClampValue("sfxvolume", 0.0f, 1.0f);
     ClampValue("mtavolume", 0.0f, 1.0f);
     ClampValue("voicevolume", 0.0f, 1.0f);
     ClampValue("mapalpha", 0, 255);
@@ -326,6 +328,8 @@ void CClientVariables::LoadDefaults()
     DEFAULT("steer_with_mouse", false);                                     // steering with mouse controls
     DEFAULT("classic_controls", false);                                     // classic/standard controls
     DEFAULT("mastervolume", 1.0f);                                          // master volume
+    DEFAULT("radiovolume", 1.0f);                                           // radio volume (unscaled)
+    DEFAULT("sfxvolume", 1.0f);                                             // sfx volume (unscaled)
     DEFAULT("mtavolume", 1.0f);                                             // custom sound's volume
     DEFAULT("voicevolume", 1.0f);                                           // voice chat output volume
     DEFAULT("mapalpha", 155);                                               // player map alpha

Client/core/CCore.cpp

@@ -40,20 +40,8 @@ namespace fs = std::filesystem;
 
 // Set to true to enable the freeze watchdog (monitors main thread responsiveness)
 // Do NOT enable it unless you run a QA testing cycle (see commit desc: 3e54dcb2742bccf0319b9552b2ed5a2c0a012425)
-constexpr bool bFreezeWatchdogEnabled = false;
-
-// Watchdog active in debug builds
-// In debug builds, the contributor should get an early heads up if their changes are this level of blocking (it can't make it in).
-// If you freeze beyond 20 secs in a debug build, not due to a bug in your code changes but due to your local server assets, you have 2 options:
-// 1. Disable the watchdog
-// 2. Fix your mess (imagine what that would do to players in release builds)
-#ifdef MTA_DEBUG
-constexpr bool  bFreezeWatchdogEnabledInCurrentBuild = true;
-constexpr DWORD uiFreezeWatchdogTimeoutSeconds = 20;  // Already unacceptable. Strikes a balance: you'll still be able to a load heavy asseted local server
-#else
-constexpr bool  bFreezeWatchdogEnabledInCurrentBuild = bFreezeWatchdogEnabled;
-constexpr DWORD uiFreezeWatchdogTimeoutSeconds = 40;  // Player won't be patient beyond this; we get no info
-#endif
+constexpr bool  bFreezeWatchdogEnabled = false;
+constexpr DWORD uiFreezeWatchdogTimeoutSeconds = 30;  // Player won't be patient beyond this; we get no info
 
 static float fTest = 1;
 
@@ -200,7 +188,7 @@ CCore::~CCore()
 {
     WriteDebugEvent("CCore::~CCore");
 
-    if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
+    if constexpr (bFreezeWatchdogEnabled)
         StopWatchdogThread();
 
     // Reset Discord rich presence
@@ -1317,7 +1305,7 @@ void CCore::DoPreFramePulse()
 {
     TIMING_CHECKPOINT("+CorePreFrame");
 
-    if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
+    if constexpr (bFreezeWatchdogEnabled)
         UpdateWatchdogHeartbeat();
 
     m_pKeyBinds->DoPreFramePulse();
@@ -1377,7 +1365,7 @@ void CCore::DoPostFramePulse()
             WatchDogCompletedSection("L3");  // No hang on startup
 
             // Start watchdog thread now that initial loading is complete
-            if constexpr (bFreezeWatchdogEnabledInCurrentBuild)
+            if constexpr (bFreezeWatchdogEnabled)
             {
                 if (!StartWatchdogThread(GetCurrentThreadId(), uiFreezeWatchdogTimeoutSeconds))
                 {

Client/core/CSettings.cpp

@@ -104,6 +104,13 @@ namespace
         return width;
     }
 
+    int QuantizeVolumePercent(float& value)
+    {
+        const int iPercent = std::clamp(static_cast<int>(value * 100.0f + 0.5f), 0, 100);
+        value = iPercent / 100.0f;
+        return iPercent;
+    }
+
     void FinalizeSliderRow(float tabWidth, CGUIScrollBar* slider, CGUILabel* valueLabel, float preferredWidth, float labelSpacing = kSliderLabelSpacing,
                            CGUILabel* textLabel = nullptr)
     {
@@ -430,9 +437,48 @@ CSettings::CSettings()
 {
     ResetGuiPointers();
 
-    CGameSettings* gameSettings = CCore::GetSingleton().GetGame()->GetSettings();
-    m_fRadioVolume = (float)gameSettings->GetRadioVolume() / 64.0f;
-    m_fSFXVolume = (float)gameSettings->GetSFXVolume() / 64.0f;
+    CClientVariables& clientVars = CClientVariables::GetSingleton();
+    CGameSettings*    gameSettings = CCore::GetSingleton().GetGame()->GetSettings();
+
+    float fRadioVolume = 0.0f;
+    float fSFXVolume = 0.0f;
+
+    // Keep exact slider values in CVARs. Fall back to reconstructed values for
+    // one-time migration when those keys do not exist yet.
+    if (clientVars.Exists("radiovolume") && clientVars.Exists("sfxvolume"))
+    {
+        CVARS_GET("radiovolume", fRadioVolume);
+        CVARS_GET("sfxvolume", fSFXVolume);
+    }
+    else
+    {
+        // GTA stores radio/SFX as values already multiplied by master volume.
+        // The UI sliders represent the unscaled channel volumes, so recover them
+        // by dividing by the persisted master value during startup.
+        const float fMasterVolume = std::max(0.0f, std::min(CVARS_GET_VALUE<float>("mastervolume"), 1.0f));
+        const float fStoredRadioVolume = (float)gameSettings->GetRadioVolume() / 64.0f;
+        const float fStoredSFXVolume = (float)gameSettings->GetSFXVolume() / 64.0f;
+
+        if (fMasterVolume > 0.0001f)
+        {
+            fRadioVolume = fStoredRadioVolume / fMasterVolume;
+            fSFXVolume = fStoredSFXVolume / fMasterVolume;
+        }
+        else
+        {
+            // If master was zero we cannot recover hidden channel values.
+            fRadioVolume = fStoredRadioVolume;
+            fSFXVolume = fStoredSFXVolume;
+        }
+
+        CVARS_SET("radiovolume", fRadioVolume);
+        CVARS_SET("sfxvolume", fSFXVolume);
+    }
+
+    m_fRadioVolume = std::max(0.0f, std::min(fRadioVolume, 1.0f));
+    m_fSFXVolume = std::max(0.0f, std::min(fSFXVolume, 1.0f));
+    QuantizeVolumePercent(m_fRadioVolume);
+    QuantizeVolumePercent(m_fSFXVolume);
 
     m_iMaxAnisotropic = g_pDeviceState->AdapterState.MaxAnisotropicSetting;
     m_bBrowserListsChanged = false;
@@ -5446,20 +5492,30 @@ bool CSettings::OnMasterVolumeChanged(CGUIElement* pElement)
 
 bool CSettings::OnRadioVolumeChanged(CGUIElement* pElement)
 {
-    int iVolume = m_pAudioRadioVolume->GetScrollPosition() * 100.0f;
+    float fVolume = m_pAudioRadioVolume->GetScrollPosition();
+    int   iVolume = QuantizeVolumePercent(fVolume);
     m_pLabelRadioVolumeValue->SetText(SString("%i%%", iVolume).c_str());
 
-    SetRadioVolume(m_pAudioRadioVolume->GetScrollPosition());
+    if (std::abs(m_pAudioRadioVolume->GetScrollPosition() - fVolume) > 0.0001f)
+        m_pAudioRadioVolume->SetScrollPosition(fVolume);
+
+    CVARS_SET("radiovolume", fVolume);
+    SetRadioVolume(fVolume);
 
     return true;
 }
 
 bool CSettings::OnSFXVolumeChanged(CGUIElement* pElement)
 {
-    int iVolume = m_pAudioSFXVolume->GetScrollPosition() * 100.0f;
+    float fVolume = m_pAudioSFXVolume->GetScrollPosition();
+    int   iVolume = QuantizeVolumePercent(fVolume);
     m_pLabelSFXVolumeValue->SetText(SString("%i%%", iVolume).c_str());
 
-    SetSFXVolume(m_pAudioSFXVolume->GetScrollPosition());
+    if (std::abs(m_pAudioSFXVolume->GetScrollPosition() - fVolume) > 0.0001f)
+        m_pAudioSFXVolume->SetScrollPosition(fVolume);
+
+    CVARS_SET("sfxvolume", fVolume);
+    SetSFXVolume(fVolume);
 
     return true;
 }

Client/game_sa/CHandlingEntrySA.cpp

@@ -83,24 +83,32 @@ void CHandlingEntrySA::SetSuspensionHighSpeedDamping(float fDamping) noexcept
 
 void CHandlingEntrySA::SetSuspensionUpperLimit(float fUpperLimit) noexcept
 {
+    if (!std::isfinite(fUpperLimit)) [[unlikely]]
+        return;
     CheckSuspensionChanges();
     m_Handling.fSuspensionUpperLimit = fUpperLimit;
 }
 
 void CHandlingEntrySA::SetSuspensionLowerLimit(float fLowerLimit) noexcept
 {
+    if (!std::isfinite(fLowerLimit)) [[unlikely]]
+        return;
     CheckSuspensionChanges();
     m_Handling.fSuspensionLowerLimit = fLowerLimit;
 }
 
 void CHandlingEntrySA::SetSuspensionFrontRearBias(float fBias) noexcept
 {
+    if (!std::isfinite(fBias)) [[unlikely]]
+        return;
     CheckSuspensionChanges();
     m_Handling.fSuspensionFrontRearBias = fBias;
 }
 
 void CHandlingEntrySA::SetSuspensionAntiDiveMultiplier(float fAntidive) noexcept
 {
+    if (!std::isfinite(fAntidive)) [[unlikely]]
+        return;
     CheckSuspensionChanges();
     m_Handling.fSuspensionAntiDiveMultiplier = fAntidive;
 }

Client/game_sa/CPhysicalSA.cpp

@@ -22,7 +22,22 @@ CRect* CPhysicalSAInterface::GetBoundRect_(CRect* pRect)
 {
     CVector boundCentre;
     CEntitySAInterface::GetBoundCentre(&boundCentre);
-    float fRadius = CModelInfoSAInterface::GetModelInfo(m_nModelIndex)->pColModel->m_sphere.m_radius;
+
+    // Validate model info and collision model before deref. The streaming
+    // system can strip a model's collision data while leaving pColModel
+    // non-null (dangling), or release the model info entirely when entities
+    // from a recycled sector are re-added via building removal. Dereferencing
+    // without a guard here can write into arbitrary memory.
+    CBaseModelInfoSAInterface* pModelInfo = CModelInfoSAInterface::GetModelInfo(m_nModelIndex);
+    if (!pModelInfo || !pModelInfo->pColModel)
+    {
+        // Always initialize output rect to avoid leaking stale caller data.
+        *pRect = CRect(boundCentre.fX, boundCentre.fY, boundCentre.fX, boundCentre.fY);
+        pRect->FixIncorrectTopLeft();
+        return pRect;
+    }
+
+    float fRadius = pModelInfo->pColModel->m_sphere.m_radius;
     *pRect = CRect(boundCentre.fX - fRadius, boundCentre.fY - fRadius, boundCentre.fX + fRadius, boundCentre.fY + fRadius);
     pRect->FixIncorrectTopLeft();  // Fix #1613: custom map collision crashes in CPhysical class (infinite loop)
     return pRect;

Client/game_sa/CPlaceableSA.h

@@ -7,6 +7,8 @@
  *
  *****************************************************************************/
 
+#pragma once
+
 #include <CMatrix_Pad.h>
 #include <CVector.h>
 

Client/game_sa/CVehicleSA.cpp

@@ -1862,7 +1862,12 @@ void* CVehicleSA::GetPrivateSuspensionLines()
     if (m_pSuspensionLines == NULL)
     {
         CModelInfo* pModelInfo = pGame->GetModelInfo(GetModelIndex());
-        CColDataSA* pColData = pModelInfo->GetInterface()->pColModel->m_data;
+        // Validate the model/collision chain before deref. During streaming
+        // GC races any of these pointers can be transiently null while a
+        // CAutomobile still runs a tick on the entity.
+        CBaseModelInfoSAInterface* pInterface = pModelInfo ? pModelInfo->GetInterface() : nullptr;
+        CColModelSAInterface*      pColModel = pInterface ? pInterface->pColModel : nullptr;
+        CColDataSA*                pColData = pColModel ? pColModel->m_data : nullptr;
         if (pModelInfo->IsMonsterTruck())
         {
             // Monster truck suspension data is 0x90 BYTES rather than 0x80 (some extra stuff I guess)
@@ -1875,8 +1880,11 @@ void* CVehicleSA::GetPrivateSuspensionLines()
         }
         else
         {
-            // CAutomobile allocates wheels * 32 (0x20)
-            m_pSuspensionLines = new BYTE[pColData->m_numSuspensionLines * 0x20];
+            // CAutomobile allocates wheels * 32 (0x20). Fall back to a safe
+            // default count when col data is unavailable so we never allocate
+            // from a garbage size and never deref a null pColData.
+            const std::size_t numLines = pColData ? pColData->m_numSuspensionLines : 4;
+            m_pSuspensionLines = new BYTE[numLines * 0x20];
         }
     }
 
@@ -1886,24 +1894,28 @@ void* CVehicleSA::GetPrivateSuspensionLines()
 void CVehicleSA::CopyGlobalSuspensionLinesToPrivate()
 {
     CModelInfo* pModelInfo = pGame->GetModelInfo(GetModelIndex());
-    CColDataSA* pColData = pModelInfo->GetInterface()->pColModel->m_data;
+    // Same guard as GetPrivateSuspensionLines: the streaming GC can yank
+    // collision data out from under us, leaving dangling pointers here.
+    CBaseModelInfoSAInterface* pInterface = pModelInfo ? pModelInfo->GetInterface() : nullptr;
+    CColModelSAInterface*      pColModel = pInterface ? pInterface->pColModel : nullptr;
+    CColDataSA*                pColData = pColModel ? pColModel->m_data : nullptr;
+    if (!pColData || !pColData->m_suspensionLines)
+        return;
+
     if (pModelInfo->IsMonsterTruck())
     {
         // Monster trucks are 0x90 bytes not 0x80
-        if (pColData->m_suspensionLines)
-            memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, 0x90);
+        memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, 0x90);
     }
     else if (pModelInfo->IsBike())
     {
         // Bikes are 0x80 bytes not 0x40
-        if (pColData->m_suspensionLines)
-            memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, 0x80);
+        memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, 0x80);
     }
     else
     {
         // CAutomobile allocates wheels * 32 (0x20)
-        if (pColData->m_suspensionLines)
-            memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, pColData->m_numSuspensionLines * 0x20);
+        memcpy(GetPrivateSuspensionLines(), pColData->m_suspensionLines, pColData->m_numSuspensionLines * 0x20);
     }
 }
 
@@ -1913,7 +1925,11 @@ void CVehicleSA::RecalculateSuspensionLines()
 
     DWORD       dwModel = GetModelIndex();
     CModelInfo* pModelInfo = pGame->GetModelInfo(dwModel);
-    if (pModelInfo && pModelInfo->IsMonsterTruck() || pModelInfo->IsCar())
+    if (!pModelInfo)
+        return;
+
+    // Only cars and monster trucks use this suspension setup path.
+    if ((pModelInfo->IsMonsterTruck() || pModelInfo->IsCar()))
     {
         // Trains (Their trailers do as well!)
         if (pModelInfo->IsTrain() || dwModel == 571 || dwModel == 570 || dwModel == 569 || dwModel == 590)

Client/mods/deathmatch/logic/CNetAPI.cpp

@@ -381,9 +381,12 @@ void CNetAPI::DoPulse()
             }
 
             // Time to freeze because of lack of return sync?
+            // Only treat missing return-sync as network trouble while the local player is alive.
+            // During expected dead/spectate periods (e.g. race map voting), return-sync can pause
+            // by design and would otherwise show a misleading "NETWORK TROUBLE" warning.
             if (!g_pClientGame->IsDownloadingBigPacket() && (m_bStoredReturnSync) && (m_ulLastPuresyncTime != 0) && (m_ulLastSyncReturnTime != 0) &&
-                (ulCurrentTime <= m_ulLastPuresyncTime + 5000) && (ulCurrentTime >= m_ulLastSyncReturnTime + 10000) &&
-                (!g_pClientGame->GetLocalPlayer()->m_bIsGettingIntoVehicle) && (!m_bIncreaseTimeoutTime))
+                (ulCurrentTime <= m_ulLastPuresyncTime + 5000) && (ulCurrentTime >= m_ulLastSyncReturnTime + 10000) && !pPlayer->IsDead() &&
+                !pPlayer->IsDying() && (!g_pClientGame->GetLocalPlayer()->m_bIsGettingIntoVehicle) && (!m_bIncreaseTimeoutTime))
             {
                 // No vehicle or vehicle in seat 0?
                 if (!pVehicle || pPlayer->GetOccupiedVehicleSeat() == 0)

Client/mods/deathmatch/logic/CVehicleUpgrades.cpp

@@ -610,6 +610,20 @@ void CVehicleUpgrades::ForceAddUpgrade(unsigned short usUpgrade)
         CVehicle* pVehicle = m_pVehicle->GetGameVehicle();
         if (pVehicle)
         {
+            // Spoiler upgrades (slot 2) must not be applied if the vehicle model
+            // doesn't have the "ug_spoiler" frame. Otherwise, SA's AddUpgrade will
+            // call GetFrameFromId and get NULL, triggering the crash-fix fallback
+            // that attaches the spoiler to the wrong frame.
+            if (ucSlot == 2)
+            {
+                CModelInfo* pVehicleModelInfo = g_pGame->GetModelInfo(m_pVehicle->GetModel());
+                if (!pVehicleModelInfo || !pVehicleModelInfo->GetVehicleSupportedUpgrades().m_bSpoiler)
+                {
+                    // Vehicle doesn't support this spoiler upgrade - skip it
+                    return;
+                }
+            }
+
             // Grab the upgrade model
             CModelInfo* pModelInfo = g_pGame->GetModelInfo(usUpgrade);
             if (pModelInfo)