Merge branch 'master' into fix/burn_explosions

Author: Xenius97

Client/core/CSettings.cpp

@@ -540,8 +540,8 @@ void CSettings::CreateGUI()
             return;
         CVector2D buttonSize;
         button->GetSize(buttonSize);
-        const float bottomPadding = 12.0f;
-        const float buttonY = std::max(0.0f, tabPanelSize.fY - buttonSize.fY - bottomPadding);
+        const float bottomPadding = 32.0f;
+        const float buttonY = std::max(0.0f, tabPanelSize.fY - buttonSize.fY - bottomPadding - 4.0f);
         button->SetPosition(CVector2D(std::max(0.0f, tabPanelSize.fX - buttonSize.fX - bottomPadding), buttonY));
     };
 
@@ -1586,7 +1586,7 @@ void CSettings::CreateGUI()
     m_pGridBrowserBlacklist->SetPosition(CVector2D(vecTemp.fX, vecTemp.fY + 32.0f));
     m_pGridBrowserBlacklist->GetPosition(vecTemp);
     const CVector2D blacklistGridPos = vecTemp;
-    const float browserBottomPadding = 12.0f;
+    const float browserBottomPadding = 32.0f;
     const float browserButtonSpacing = 5.0f;
     const CVector2D blacklistRemoveSize(140.0f, 22.0f);
     const float blacklistHeightAvailable = tabPanelSize.fY - blacklistGridPos.fY - blacklistRemoveSize.fY - browserButtonSpacing - browserBottomPadding;

Client/game_sa/CColStoreSA.cpp

@@ -10,6 +10,9 @@
 
 #include "StdInc.h"
 #include "CColStoreSA.h"
+#include "CGameSA.h"
+
+extern CGameSA* pGame;
 
 void CColStoreSA::Initialise()
 {
@@ -55,6 +58,22 @@ void CColStoreSA::AddCollisionNeededAtPosition(const CVector& position)
 
 void CColStoreSA::EnsureCollisionIsInMemory(const CVector& position)
 {
+    // Wait for GTA to complete initialization before calling collision functions
+    // Race condition: MTA can trigger streaming/collision operations before GTA completes initialization.
+    // GTA calls CTimer::Initialise at 0x53BDE6 during startup, which sets _timerFunction at 0x56189E.
+    // If called before GTA reaches GS_INIT_PLAYING_GAME, the timer isn't initialized > crash at 0x5619E9 (CTimer::Suspend)
+    
+    if (!pGame || pGame->GetSystemState() < SystemState::GS_INIT_PLAYING_GAME)
+        return;  // GTA not ready yet - skip (will retry on next streaming update)
+    
+    // Just in case
+    constexpr auto ADDR_timerFunction = 0xB7CB28;
+    const auto timerFunction = *reinterpret_cast<void* const*>(ADDR_timerFunction);
+    if (!timerFunction)
+        return;  // Timer not initialized yet - skip
+    
+    // SA function signature: void __cdecl CColStore::EnsureCollisionIsInMemory(const CVector2D&)
+    // CVector implicitly converts to CVector2D (uses x, y components only)
     using Signature = void(__cdecl*)(const CVector&);
     const auto function = reinterpret_cast<Signature>(0x410AD0);
     function(position);

Client/game_sa/CGameSA.cpp

@@ -898,12 +898,13 @@ void CGameSA::SetIgnoreFireStateEnabled(bool isEnabled)
 
     if (isEnabled)
     {
-        MemSet((void*)0x6511B9, 0x90, 10);            // CCarEnterExit::IsVehicleStealable
-        MemSet((void*)0x643A95, 0x90, 14);            // CTaskComplexEnterCar::CreateFirstSubTask
-        MemSet((void*)0x6900B5, 0x90, 14);            // CTaskComplexCopInCar::ControlSubTask
-        MemSet((void*)0x64F3DB, 0x90, 14);            // CCarEnterExit::IsPlayerToQuitCarEnter
-
-        MemSet((void*)0x685A7F, 0x90, 14);            // CTaskSimplePlayerOnFoot::ProcessPlayerWeapon
+        // All these patches disable fire state checks (m_pFire != nullptr)
+        // Related crash protection is handled by checks in TaskSA.cpp and CTaskManagementSystemSA.cpp
+        MemSet((void*)0x6511B9, 0x90, 10);            // CCarEnterExit::IsVehicleStealable - fire check
+        MemSet((void*)0x643A95, 0x90, 14);            // CTaskComplexEnterCar::CreateFirstSubTask - fire check
+        MemSet((void*)0x6900B5, 0x90, 14);            // CTaskComplexCopInCar::ControlSubTask - fire check
+        MemSet((void*)0x64F3DB, 0x90, 14);            // CCarEnterExit::IsPlayerToQuitCarEnter - fire check  
+        MemSet((void*)0x685A7F, 0x90, 14);            // CTaskSimplePlayerOnFoot::ProcessPlayerWeapon - fire check
 
         MemSet((void*)0x53A899, 0x90, 5);             // CFire::ProcessFire
         MemSet((void*)0x53A990, 0x90, 5);             // CFire::ProcessFire

Client/game_sa/CRenderWareSA.TextureReplacing.cpp

@@ -12,6 +12,7 @@
 #include "gamesa_renderware.h"
 
 #include <map>
+#include <sstream>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -309,9 +310,16 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
                 continue;
 
             RwTexture* pOriginalTexture = (idx < perTxdInfo.replacedOriginals.size()) ? perTxdInfo.replacedOriginals[idx] : nullptr;
+            
+            if (pOriginalTexture && !SharedUtil::IsReadablePointer(pOriginalTexture, sizeof(RwTexture)))
+                pOriginalTexture = nullptr;
+                
             swapMap[pOldTexture] = pOriginalTexture;
 
-            if (pOriginalTexture && !RwTexDictionaryContainsTexture(pInfo->pTxd, pOriginalTexture))
+            // Only restore original textures early if this is the last replacement set for this TXD
+            // Otherwise, other replacement sets might still be using the TXD
+            bool isLastReplacement = (pInfo->usedByReplacements.size() == 1);
+            if (pOriginalTexture && isLastReplacement && !RwTexDictionaryContainsTexture(pInfo->pTxd, pOriginalTexture))
                 RwTexDictionaryAddTexture(pInfo->pTxd, pOriginalTexture);
         }
 
@@ -346,6 +354,9 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
         {
             if (!pOldTexture)
                 continue;
+            
+            if (!SharedUtil::IsReadablePointer(pOldTexture, sizeof(RwTexture)))
+                continue;
 
             RwTexDictionaryRemoveTexture(pInfo->pTxd, pOldTexture);
             dassert(!RwTexDictionaryContainsTexture(pInfo->pTxd, pOldTexture));
@@ -389,18 +400,85 @@ void CRenderWareSA::ModelInfoTXDRemoveTextures(SReplacementTextures* pReplacemen
         #ifdef MTA_DEBUG
             std::vector<RwTexture*> currentTextures;
             GetTxdTextures(currentTextures, pInfo->pTxd);
-            assert(currentTextures.size() == pInfo->originalTextures.size());
-            for (RwTexture* pOriginalTexture : pInfo->originalTextures)
+            
+            auto formatTextures = [](const std::vector<RwTexture*>& textures) -> std::string {
+                std::ostringstream result;
+                for (size_t i = 0; i < textures.size(); ++i)
+                {
+                    const auto* pTex = textures[i];
+                    const bool isValid = pTex && SharedUtil::IsReadablePointer(pTex, sizeof(RwTexture));
+                    const bool isLast = (i == textures.size() - 1);
+                    
+                    if (isValid)
+                        result << pTex->name << "[0x" << std::hex << pTex << std::dec << "]";
+                    else
+                        result << "INVALID[0x" << std::hex << pTex << std::dec << "]";
+                    
+                    if (!isLast)
+                        result << ", ";
+                }
+                return result.str();
+            };
+            
+            // Allow size mismatch in case texture removal was skipped due to invalid pointers
+            if (currentTextures.size() != pInfo->originalTextures.size())
             {
-                if (!pOriginalTexture)
-                    continue;
-                assert(ListContains(currentTextures, pOriginalTexture));
-                ListRemove(currentTextures, pOriginalTexture);
+                std::ostringstream debugMsg;
+                debugMsg << "TXD " << pInfo->usTxdId << ": texture count mismatch (current=" 
+                         << currentTextures.size() << ", expected=" << pInfo->originalTextures.size() << ")\n";
+                debugMsg << "  Current textures: " << formatTextures(currentTextures);
+                debugMsg << "\n  Expected textures: " << formatTextures(pInfo->originalTextures);
+                debugMsg << "\n";
+                OutputDebugString(debugMsg.str().c_str());
+            }
+            else
+            {
+                // First pass: validate all original textures are present
+                for (const auto* pOriginalTexture : pInfo->originalTextures)
+                {
+                    if (!pOriginalTexture)
+                        continue;
+                    if (!ListContains(currentTextures, pOriginalTexture))
+                    {
+                        const char* texName = SharedUtil::IsReadablePointer(pOriginalTexture, sizeof(RwTexture)) 
+                            ? pOriginalTexture->name : "INVALID";
+                        std::ostringstream oss;
+                        oss << "Original texture not found in TXD " << pInfo->usTxdId 
+                            << " - texture '" << texName << "' [0x" << std::hex << pOriginalTexture << std::dec 
+                            << "] was removed or replaced unexpectedly";
+                        const std::string assertMsg = oss.str();
+                        assert(false && assertMsg.c_str());
+                    }
+                }
+                
+                // Second pass: remove original textures from current list to find extras
+                for (auto* pOriginalTexture : pInfo->originalTextures)
+                {
+                    if (pOriginalTexture)
+                        ListRemove(currentTextures, pOriginalTexture);
+                }
+                
+                // Check for leaked textures
+                if (!currentTextures.empty())
+                {
+                    std::ostringstream oss;
+                    oss << "Extra textures remain in TXD " << pInfo->usTxdId 
+                        << " after removing all originals - indicates texture leak. Remaining: "
+                        << formatTextures(currentTextures);
+                    const std::string assertMsg = oss.str();
+                    assert(false && assertMsg.c_str());
+                }
             }
-            assert(currentTextures.empty());
 
-            int32_t refsCount = CTxdStore_GetNumRefs(pInfo->usTxdId);
-            assert(refsCount > 0 && "Should have at least one TXD reference here");
+            const int32_t refsCount = CTxdStore_GetNumRefs(pInfo->usTxdId);
+            if (refsCount <= 0)
+            {
+                std::ostringstream oss;
+                oss << "TXD " << pInfo->usTxdId << " has invalid ref count " 
+                    << refsCount << " - should be > 0 before cleanup";
+                const std::string assertMsg = oss.str();
+                assert(false && assertMsg.c_str());
+            }
         #endif
             // Clear original textures to prevent dangling pointers after TXD ref removal
             // The textures themselves are owned by the TXD and will be cleaned up when ref count hits zero

Client/game_sa/CRenderWareSA.cpp

@@ -755,9 +755,16 @@ short CRenderWareSA::CTxdStore_GetTxdRefcount(unsigned short usTxdID)
 
 bool CRenderWareSA::RwTexDictionaryContainsTexture(RwTexDictionary* pTXD, RwTexture* pTex)
 {
-    // Avoid crashes with freed/invalid textures
+    // Avoid crashes with freed/invalid textures and TXDs
     if (!pTex || !pTXD)
         return false;
+
+    // Prevent crash when texture/TXD has been freed but pointer still exists
+    if (!SharedUtil::IsReadablePointer(pTex, sizeof(RwTexture)))
+        return false;
+    
+    if (!SharedUtil::IsReadablePointer(pTXD, sizeof(RwTexDictionary)))
+        return false;
 
     return pTex->txd == pTXD;
 }

Client/game_sa/CStreamingSA.cpp

@@ -15,6 +15,7 @@
 #include "CModelInfoSA.h"
 #include "Fileapi.h"
 #include "processthreadsapi.h"
+#include "CGameSA.h"
 
 extern CCoreInterface* g_pCore;
 
@@ -334,6 +335,14 @@ void CStreamingSA::SetStreamingInfo(uint modelid, unsigned char usStreamID, uint
 {
     CStreamingInfo* pItemInfo = GetStreamingInfo(modelid);
 
+    // We remove the existing RwObject because, after switching the archive, the streamer will load a new one.
+    // ReInit doesn't delete all RwObjects unless certain conditions are met.
+    // In this case, we must force-remove the RwObject from memory, because it is no longer used,
+    // and due to the archive change the streamer no longer detects it and therefore won't delete it.
+    // As a result, a memory leak occurs after every call to engineImageLinkDFF.
+    if (CModelInfo* modelInfo = g_pCore->GetGame()->GetModelInfo(modelid); modelInfo->GetRwObject())
+        RemoveModel(modelid);
+
     // Change nextInImg field for prev model
     for (CStreamingInfo& info : ms_aInfoForModel)
     {

Client/game_sa/CTaskManagementSystemSA.cpp

@@ -102,8 +102,21 @@ void CTaskManagementSystemSA::RemoveTask(CTaskSAInterface* pTaskInterface)
 CTaskSA* CTaskManagementSystemSA::GetTask(CTaskSAInterface* pTaskInterface)
 {
     // Return NULL if we got passed NULL
-    if (pTaskInterface == 0)
-        return NULL;
+    if (!pTaskInterface)
+        return nullptr;
+
+    // Check vtable pointer to prevent crash from corrupted task objects
+    TaskVTBL* pVTBL = pTaskInterface->VTBL;
+    if (!pVTBL)
+        return nullptr;
+
+    // Vtable should be in executable memory range (.text/.rdata sections)
+    // GTA SA base is around 0x400000-0x900000 range
+    constexpr DWORD GTA_BASE_MIN = 0x400000;
+    constexpr DWORD GTA_BASE_MAX = 0x900000;
+    DWORD dwVTableAddr = reinterpret_cast<DWORD>(pVTBL);
+    if (dwVTableAddr < GTA_BASE_MIN || dwVTableAddr > GTA_BASE_MAX)
+        return nullptr;
 
     // Find it in our list
     STaskListItem*                       pListItem;
@@ -122,7 +135,7 @@ CTaskSA* CTaskManagementSystemSA::GetTask(CTaskSAInterface* pTaskInterface)
     // its not existed before, lets create the task
     // First, we create a temp task
     int   iTaskType = 9999;
-    DWORD dwFunc = pTaskInterface->VTBL->GetTaskType;
+    DWORD dwFunc = pVTBL->GetTaskType;
     if (dwFunc && dwFunc != 0x82263A)
     {
         __asm