crash fix

Author: Xenius97

Client/mods/deathmatch/logic/CClientGame.cpp

@@ -426,6 +426,11 @@ CClientGame::~CClientGame()
     // ...and restore the buffer size too
     g_pGame->GetStreaming()->SetStreamingBufferSize(g_pClientGame->GetManager()->GetIMGManager()->GetLargestFileSizeBlocks());
 
+    // Reset streamer limits
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerLimits();
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerMaxSwaps();
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerFurthestInLimit();
+
     // Reset camera shaking
     g_pGame->GetCamera()->SetShakeForce(0.0f);
 

Client/mods/deathmatch/logic/CClientStreamer.cpp

@@ -256,9 +256,6 @@ void CClientStreamer::SetDimension(unsigned short usDimension)
     std::vector<CClientStreamElement*> elementsToHide;
     std::vector<CClientStreamElement*> elementsToShow;
 
-    elementsToHide.reserve(100);
-    elementsToShow.reserve(100);
-
     // Collect elements from sectors that need to be hidden
     auto collectFromRows = [this, &elementsToHide](std::list<CClientStreamSectorRow*>& rowList)
     {
@@ -487,6 +484,11 @@ void CClientStreamer::RemoveElementFromSectors(CClientStreamElement* pElement)
         return;
 
     OnElementEnterSector(pElement, nullptr);
+
+    // Clear row and sector
+    pElement->SetStreamRow(nullptr);
+
+    // Remove from active elements
     m_ToStreamOut.remove(pElement);
 }
 
@@ -957,7 +959,12 @@ void CClientStreamer::OnElementEnterSector(CClientStreamElement* pElement, CClie
         m_ActiveElements.remove(pElement);
     }
 
+    // Update the element's sector pointer
     pElement->SetStreamSector(pSector);
+
+    // If the element no longer has a sector, clear the row pointer too
+    if (!pSector)
+        pElement->SetStreamRow(nullptr);
 }
 
 void CClientStreamer::OnElementForceStreamIn(CClientStreamElement* pElement)
@@ -1010,6 +1017,9 @@ void CClientStreamer::OnElementDimension(CClientStreamElement* pElement)
         // Stream out if needed
         if (pElement->IsStreamedIn())
             m_ToStreamOut.push_back(pElement);
+
+        // Clear row pointer
+        pElement->SetStreamRow(nullptr);
     }
 }
 

Client/mods/deathmatch/logic/luadefs/CLuaEngineDefs.cpp

@@ -152,6 +152,13 @@ void CLuaEngineDefs::LoadFunctions()
         {"enginePreloadWorldArea", ArgumentParser<EnginePreloadWorldArea>},
         {"engineRestreamModel", ArgumentParser<EngineRestreamModel>},
         {"engineRestream", ArgumentParser<EngineRestream>},
+        {"engineStreamingSetLimits", ArgumentParser<EngineStreamingSetLimits>},
+        {"engineStreamingGetLimits", ArgumentParser<EngineStreamingGetLimits>},
+        {"engineStreamingResetLimits", ArgumentParser<EngineStreamingResetLimits>},
+        {"engineStreamingSetMaxSwaps", ArgumentParser<EngineStreamingSetMaxSwaps>},
+        {"engineStreamingResetMaxSwaps", ArgumentParser<EngineStreamingResetMaxSwaps>},
+        {"engineStreamingSetFurthestInLimit", ArgumentParser<EngineStreamingSetFurthestInLimit>},
+        {"engineStreamingResetFurthestInLimit", ArgumentParser<EngineStreamingResetFurthestInLimit>},
 
 
         // CLuaCFunctions::AddFunction ( "engineReplaceMatchingAtomics", EngineReplaceMatchingAtomics );
@@ -216,6 +223,13 @@ void CLuaEngineDefs::AddClass(lua_State* luaVM)
         lua_classfunction(luaVM, "getBufferSize", "engineStreamingGetBufferSize");
         lua_classfunction(luaVM, "setBufferSize", "engineStreamingSetBufferSize");
         lua_classfunction(luaVM, "restoreBufferSize", "engineStreamingRestoreBufferSize");
+        lua_classfunction(luaVM, "setLimits", "engineStreamingSetLimits");
+        lua_classfunction(luaVM, "getLimits", "engineStreamingGetLimits");
+        lua_classfunction(luaVM, "resetLimits", "engineStreamingResetLimits");
+        lua_classfunction(luaVM, "setMaxSwaps", "engineStreamingSetMaxSwaps");
+        lua_classfunction(luaVM, "resetMaxSwaps", "engineStreamingResetMaxSwaps");
+        lua_classfunction(luaVM, "setFurthestInLimit", "engineStreamingSetFurthestInLimit");
+        lua_classfunction(luaVM, "resetFurthestInLimit", "engineStreamingResetFurthestInLimit");
 
         lua_classvariable(luaVM, "memorySize", "engineStreamingSetMemorySize", "engineStreamingGetMemorySize");
         lua_classvariable(luaVM, "bufferSize", "engineStreamingSetBufferSize", "engineStreamingGetBufferSize");
@@ -2615,3 +2629,68 @@ void CLuaEngineDefs::EngineRestream(std::optional<RestreamOption> option)
 {
     g_pClientGame->Restream(option);
 }
+
+void CLuaEngineDefs::EngineStreamingSetLimits(int normalIn, int normalOut, int farIn, int farOut)
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->SetStreamerLimits(normalIn, normalOut, farIn, farOut);
+}
+
+int CLuaEngineDefs::EngineStreamingGetLimits(lua_State* luaVM)
+{
+    auto* pStreamer = g_pClientGame->GetManager()->GetObjectStreamer();
+    int normalIn, normalOut, farIn, farOut, maxSwaps, furthestInLimit;
+    pStreamer->GetStreamingLimits(normalIn, normalOut, farIn, farOut, maxSwaps, furthestInLimit);
+    
+    lua_newtable(luaVM);
+    
+    lua_pushstring(luaVM, "normalIn");
+    lua_pushnumber(luaVM, normalIn);
+    lua_settable(luaVM, -3);
+    
+    lua_pushstring(luaVM, "normalOut");
+    lua_pushnumber(luaVM, normalOut);
+    lua_settable(luaVM, -3);
+    
+    lua_pushstring(luaVM, "farIn");
+    lua_pushnumber(luaVM, farIn);
+    lua_settable(luaVM, -3);
+    
+    lua_pushstring(luaVM, "farOut");
+    lua_pushnumber(luaVM, farOut);
+    lua_settable(luaVM, -3);
+    
+    lua_pushstring(luaVM, "maxSwaps");
+    lua_pushnumber(luaVM, maxSwaps);
+    lua_settable(luaVM, -3);
+    
+    lua_pushstring(luaVM, "furthestInLimit");
+    lua_pushnumber(luaVM, furthestInLimit);
+    lua_settable(luaVM, -3);
+    
+    return 1;
+}
+
+void CLuaEngineDefs::EngineStreamingResetLimits()
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerLimits();
+}
+
+void CLuaEngineDefs::EngineStreamingSetMaxSwaps(int maxSwaps)
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->SetStreamerMaxSwaps(maxSwaps);
+}
+
+void CLuaEngineDefs::EngineStreamingResetMaxSwaps()
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerMaxSwaps();
+}
+
+void CLuaEngineDefs::EngineStreamingSetFurthestInLimit(int limit)
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->SetStreamerFurthestInLimit(limit);
+}
+
+void CLuaEngineDefs::EngineStreamingResetFurthestInLimit()
+{
+    g_pClientGame->GetManager()->GetObjectStreamer()->ResetStreamerFurthestInLimit();
+}

Client/mods/deathmatch/logic/luadefs/CLuaEngineDefs.h

@@ -99,6 +99,14 @@ class CLuaEngineDefs : public CLuaDefs
     static bool EngineRestreamModel(std::uint16_t modelId);
     static void EngineRestream(std::optional<RestreamOption> option);
 
+    static void EngineStreamingSetLimits(int normalIn, int normalOut, int farIn, int farOut);
+    static int EngineStreamingGetLimits(lua_State* luaVM);
+    static void EngineStreamingResetLimits();
+    static void EngineStreamingSetMaxSwaps(int maxSwaps);
+    static void EngineStreamingResetMaxSwaps();
+    static void EngineStreamingSetFurthestInLimit(int limit);
+    static void EngineStreamingResetFurthestInLimit();
+
 private:
     static void AddEngineColClass(lua_State* luaVM);
     static void AddEngineTxdClass(lua_State* luaVM);