Merge branch 'develop' of https://github.com/iw4x/iw4x-client into develop

deps/iw4-open-formats/include/api.hpp

@@ -4,6 +4,7 @@
 #include "iw4_native_asset.hpp"
 #include <functional>
 #include <filesystem>
+#include <unordered_set>
 
 namespace iw4of
 {

deps/iw4-open-formats/src/iw4-of/assets/asset_interface.hpp

@@ -39,6 +39,11 @@ namespace iw4of
             this->assets = assets;
         }
 
+        bool writes_single_file()
+        {
+            return writes_single_file_internal();
+        }
+
         std::filesystem::path get_work_path(const native::XAssetHeader& header) const;
 
         virtual ~asset_interface() {}
@@ -58,6 +63,11 @@ namespace iw4of
 			return {};
 		};
 
+		virtual bool writes_single_file_internal()
+        {
+            return false;
+        }
+
         std::filesystem::path get_work_path(const std::string& asset_name) const;
 
         std::filesystem::path get_work_path(const std::filesystem::path& file_path) const;

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iclipmap.cpp

@@ -1114,7 +1114,7 @@ namespace iw4of::interfaces
             /*typename SourceEncoding*/ rapidjson::UTF8<>,
             /*typename TargetEncoding*/ rapidjson::UTF8<>,
             /*typename StackAllocator*/ rapidjson::CrtAllocator,
-            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
+            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
             writer(buff);
         writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
         output.Accept(writer);

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/ifx.cpp

@@ -306,7 +306,13 @@ namespace iw4of::interfaces
         output.AddMember("elemDefs", elemTable, allocator);
 
         rapidjson::StringBuffer buff;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
+        rapidjson::PrettyWriter<
+            /*typename OutputStream  */ rapidjson::StringBuffer,
+            /*typename SourceEncoding*/ rapidjson::UTF8<>,
+            /*typename TargetEncoding*/ rapidjson::UTF8<>,
+            /*typename StackAllocator*/ rapidjson::CrtAllocator,
+            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
+            writer(buff);
         output.Accept(writer);
 
         return utils::io::write_file(get_work_path(header).string(), buff.GetString());

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/igfxworld.cpp

@@ -636,11 +636,11 @@ namespace iw4of::interfaces
                     if (clip)
                     {
                         assert(clip->planeCount == asset->planeCount);
-                        for (size_t i = 0; i < clip->planeCount; i++)
+                        //for (size_t i = 0; i < clip->planeCount; i++)
-                        {
+                        //{
-                            assert(0 ==
+                        //    assert(0 ==
-                                   memcmp(&clip->planes[i], &asset->dpvsPlanes.planes[i], sizeof(native::cplane_s) - sizeof(native::cplane_s::pad)));
+                        //           memcmp(&clip->planes[i], &asset->dpvsPlanes.planes[i], sizeof(native::cplane_s) - sizeof(native::cplane_s::pad)));
-                        }
+                        //}
 
                         asset->dpvsPlanes.planes = clip->planes;
                     }

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/imaterial.cpp

@@ -209,8 +209,17 @@ namespace iw4of::interfaces
             output.AddMember("stateBitsTable", statebits_to_json_array(asset->stateBitsTable, asset->stateBitsCount, allocator), allocator);
         }
 
+        // Write to disk
         rapidjson::StringBuffer buff;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
+        rapidjson::PrettyWriter<
+            /*typename OutputStream  */ rapidjson::StringBuffer,
+            /*typename SourceEncoding*/ rapidjson::UTF8<>,
+            /*typename TargetEncoding*/ rapidjson::UTF8<>,
+            /*typename StackAllocator*/ rapidjson::CrtAllocator,
+            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
+            writer(buff);
+        writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
+
         output.Accept(writer);
 
         utils::io::write_file(get_work_path(header).string(), buff.GetString());

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iphyscollmap.cpp

@@ -0,0 +1,125 @@
+#include <std_include.hpp>
+
+#include "assets/assets.hpp"
+#include "iphyscollmap.hpp"
+
+#include <utils/io.hpp>
+#include <utils/string.hpp>
+
+#include <utils/json.hpp>
+#include <rapidjson/prettywriter.h>
+
+#define IW4X_PHYS_COLLMAP_VERSION 1
+
+namespace iw4of::interfaces
+{
+    bool iphyscollmap::write_internal(const native::XAssetHeader& header) const
+    {
+        rapidjson::Document output(rapidjson::kObjectType);
+        auto& allocator = output.GetAllocator();
+
+        auto asset = header.physCollmap;
+        assert(asset);
+
+        output.AddMember("version", IW4X_PHYS_COLLMAP_VERSION, allocator);
+        output.AddMember("name", RAPIDJSON_STR(asset->name), allocator);
+
+        rapidjson::Value geoms(rapidjson::kArrayType);
+        for (size_t i = 0; i < asset->count; i++)
+        {
+            rapidjson::Value geom_info(rapidjson::kObjectType);
+            const auto geom = &asset->geoms[i];
+
+            {
+                rapidjson::Value json_brush_wrapper(rapidjson::kObjectType);
+                const auto brush_wrapper = geom->brushWrapper;
+
+                json_brush_wrapper.AddMember("bounds", utils::json::to_json(brush_wrapper->bounds, allocator), allocator);
+                json_brush_wrapper.AddMember("planes", utils::json::to_json(brush_wrapper->planes, brush_wrapper->brush.numsides, allocator), allocator);
+
+				geom_info.AddMember("brushwrapper", json_brush_wrapper, allocator);
+			}
+
+            rapidjson::Value orientation(rapidjson::kArrayType);
+            for (size_t j = 0; j < 3; j++)
+            {
+                orientation.PushBack(utils::json::make_json_array(geom->orientation[j], 3, allocator), allocator);
+            }
+
+            geom_info.AddMember("type", static_cast<int>(geom->type), allocator);
+            geom_info.AddMember("orientation", orientation, allocator);
+            geom_info.AddMember("bounds", utils::json::to_json(geom->bounds, allocator), allocator);
+        }
+
+        rapidjson::StringBuffer buff;
+        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
+        output.Accept(writer);
+
+        const auto& dump = buff.GetString();
+
+        return utils::io::write_file(get_work_path(header).string(), dump);
+    }
+
+    void* iphyscollmap::read_internal(const std::string& name) const
+    {
+        const auto& path = get_work_path(name).string();
+
+        if (utils::io::file_exists(path))
+        {
+            auto asset = local_allocator.allocate<native::PhysPreset>();
+            rapidjson::Document physPresetJson;
+
+            try
+            {
+                const auto& content = utils::io::read_file(path);
+                physPresetJson.Parse(content.data());
+            }
+            catch (const std::exception& e)
+            {
+                print_error("Invalid JSON for physpreset {}! {}", name, e.what());
+                return nullptr;
+            }
+
+            try
+            {
+                // Must NOT be null!
+                assert(!physPresetJson["sndAliasPrefix"].IsNull());
+
+                asset->name = local_allocator.duplicate_string(physPresetJson["name"].GetString());
+                asset->type = physPresetJson["type"].Get<int32_t>();
+                asset->bounce = physPresetJson["bounce"].Get<float>();
+                asset->mass = physPresetJson["mass"].Get<float>();
+                asset->friction = physPresetJson["friction"].Get<float>();
+                asset->bulletForceScale = physPresetJson["bulletForceScale"].Get<float>();
+                asset->explosiveForceScale = physPresetJson["explosiveForceScale"].Get<float>();
+                asset->sndAliasPrefix = local_allocator.duplicate_string(physPresetJson["sndAliasPrefix"].GetString());
+                asset->piecesSpreadFraction = physPresetJson["piecesSpreadFraction"].Get<float>();
+                asset->piecesUpwardVelocity = physPresetJson["piecesUpwardVelocity"].Get<float>();
+                asset->tempDefaultToCylinder = physPresetJson["tempDefaultToCylinder"].Get<bool>();
+                asset->perSurfaceSndAlias = physPresetJson["perSurfaceSndAlias"].Get<bool>();
+
+                assert(asset->mass > FLT_EPSILON);
+            }
+            catch (const std::exception& e)
+            {
+                print_error("Malformed JSON for physpreset {}! {}", name, e.what());
+                return nullptr;
+            }
+
+            return asset;
+        }
+
+        return nullptr;
+    }
+
+    std::filesystem::path iphyscollmap::get_file_name(const std::string& basename) const
+    {
+        return std::format("{}.iw4x.json", basename);
+    }
+
+    std::filesystem::path iphyscollmap::get_folder_name() const
+    {
+        return "physcollmap";
+    }
+
+} // namespace iw4of::interfaces

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iphyscollmap.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <utils/stream.hpp>
+#include "assets/asset_interface.hpp"
+
+namespace iw4of::interfaces
+{
+    struct iphyscollmap : asset_interface
+    {
+       public:
+        iphyscollmap(const iw4of::assets* assets)
+            : asset_interface(assets)
+        {
+        }
+
+       protected:
+        bool write_internal(const native::XAssetHeader& header) const override;
+        void* read_internal(const std::string& name) const override;
+        std::filesystem::path get_file_name(const std::string& basename) const override;
+        std::filesystem::path get_folder_name() const override;
+
+       private:
+        void write(const native::XSurfaceCollisionTree* entry, utils::stream* buffer) const;
+        void write(const native::XSurface* surf, utils::stream* buffer) const;
+        void write(const native::XModelSurfs* asset, utils::stream* buffer) const;
+        void read(native::XSurfaceCollisionTree* entry, utils::stream::reader* reader) const;
+        void read(native::XSurface* asset, utils::stream::reader* reader) const;
+        void read(native::XModelSurfs* asset, utils::stream::reader* reader) const;
+    };
+} // namespace iw4of::interfaces

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/irawfile.cpp

@@ -222,6 +222,7 @@ namespace iw4of::interfaces
                 }
                 else
                 {
+                    print_error("Could not find animtree {}\n", animtree_name);
                     assert(false);
                 }
             }

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/isndalias.cpp

@@ -427,8 +427,16 @@ namespace iw4of::interfaces
         output.AddMember("count", ents->count, allocator);
         output.AddMember("head", head, allocator);
 
+        // Write to disk
         rapidjson::StringBuffer buff;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
+        rapidjson::PrettyWriter<
+            /*typename OutputStream  */ rapidjson::StringBuffer,
+            /*typename SourceEncoding*/ rapidjson::UTF8<>,
+            /*typename TargetEncoding*/ rapidjson::UTF8<>,
+            /*typename StackAllocator*/ rapidjson::CrtAllocator,
+            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
+            writer(buff);
+        writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
         output.Accept(writer);
 
         const auto& dump = buff.GetString();

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/isndcurve.cpp

@@ -90,8 +90,15 @@ namespace iw4of::interfaces
 
         output.AddMember("knots", knots_array, allocator);
 
+        // Write to disk
         rapidjson::StringBuffer buff;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
+        rapidjson::PrettyWriter<
+            /*typename OutputStream  */ rapidjson::StringBuffer,
+            /*typename SourceEncoding*/ rapidjson::UTF8<>,
+            /*typename TargetEncoding*/ rapidjson::UTF8<>,
+            /*typename StackAllocator*/ rapidjson::CrtAllocator,
+            /*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
+            writer(buff);
         writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
 
         output.Accept(writer);

deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/itechniqueset.cpp

@@ -114,7 +114,7 @@ namespace iw4of::interfaces
 					/*typename SourceEncoding*/ rapidjson::UTF8<>,
 					/*typename TargetEncoding*/ rapidjson::UTF8<>,
 					/*typename StackAllocator*/ rapidjson::CrtAllocator,
-					/*unsigned writeFlags*/     rapidjson::kWriteNanAndInfFlag 
+					/*unsigned writeFlags*/     rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag 
 			>
 			writer(buff);
 
@@ -461,7 +461,7 @@ namespace iw4of::interfaces
 					/*typename SourceEncoding*/ rapidjson::UTF8<>,
 					/*typename TargetEncoding*/ rapidjson::UTF8<>,
 					/*typename StackAllocator*/ rapidjson::CrtAllocator,
-					/*unsigned writeFlags*/     rapidjson::kWriteNanAndInfFlag 
+					/*unsigned writeFlags*/     rapidjson::kWriteNanAndInfNullFlag 
 			>
 			writer(buff);
 

deps/iw4-open-formats/src/iw4-of/assets/assets.hpp

@@ -24,7 +24,16 @@ namespace iw4of
             if (check_type_is_supported(iw4_int_type))
             {
                 const auto& path = asset_interfaces[iw4_int_type]->get_work_path({header});
-                if (can_write(path))
+                const bool writes_in_single_file = asset_interfaces[iw4_int_type]->writes_single_file();
+
+				if (writes_in_single_file && !written_assets.contains(path.string()))
+				{
+					// We have never written this file but it exists on disk, so we destroy it because
+					//	we will be appending to it in the future
+                    std::filesystem::remove(path);
+				}
+
+                if (writes_in_single_file || can_write(path))
                 {
                     bool written = asset_interfaces[iw4_int_type]->write<T>(header);
 

src/Components/Modules/Friends.cpp

@@ -315,7 +315,10 @@ namespace Components
 		Friends::LoggedOn = (Steam::Proxy::SteamUser_ && Steam::Proxy::SteamUser_->LoggedOn());
 		if (!Steam::Proxy::SteamFriends) return;
 
-		Game::UI_UpdateArenas();
+		if (Game::Sys_IsMainThread())
+		{
+			Game::UI_UpdateArenas();
+		}
 
 		int count = Steam::Proxy::SteamFriends->GetFriendCount(4);
 

src/Components/Modules/Logger.cpp

@@ -38,32 +38,32 @@ namespace Components
 	void Logger::MessagePrint(const int channel, const std::string& msg)
 	{
 		static const auto shouldPrint = []() -> bool
-		{
+			{
-			return Flags::HasFlag("stdout") || Loader::IsPerformingUnitTests();
+				return Flags::HasFlag("stdout") || Loader::IsPerformingUnitTests();
-		}();
+			}();
 
-		if (shouldPrint)
+			if (shouldPrint)
-		{
+			{
-			(void)std::fputs(msg.data(), stdout);
+				(void)std::fputs(msg.data(), stdout);
-			(void)std::fflush(stdout);
+				(void)std::fflush(stdout);
-			return;
+				return;
-		}
+			}
 
 #ifdef _DEBUG
-		if (!IsConsoleReady())
+			if (!IsConsoleReady())
-		{
+			{
-			OutputDebugStringA(msg.data());
+				OutputDebugStringA(msg.data());
-		}
+			}
 #endif
 
-		if (!Game::Sys_IsMainThread())
+			if (!Game::Sys_IsMainThread())
-		{
+			{
-			EnqueueMessage(msg);
+				EnqueueMessage(msg);
-		}
+			}
-		else
+			else
-		{
+			{
-			Game::Com_PrintMessage(channel, msg.data(), 0);
+				Game::Com_PrintMessage(channel, msg.data(), 0);
-		}
+			}
 	}
 
 	void Logger::DebugInternal(const std::string_view& fmt, std::format_args&& args, [[maybe_unused]] const std::source_location& loc)
@@ -120,33 +120,33 @@ namespace Components
 	void Logger::PrintFail2BanInternal(const std::string_view& fmt, std::format_args&& args)
 	{
 		static const auto shouldPrint = []() -> bool
-		{
+			{
-			return Flags::HasFlag("fail2ban");
+				return Flags::HasFlag("fail2ban");
-		}();
+			}();
 
-		if (!shouldPrint)
+			if (!shouldPrint)
-		{
+			{
-			return;
+				return;
-		}
+			}
 
-		auto msg = std::vformat(fmt, args);
+			auto msg = std::vformat(fmt, args);
 
-		static auto log_next_time_stamp = true;
+			static auto log_next_time_stamp = true;
-		if (log_next_time_stamp)
+			if (log_next_time_stamp)
-		{
+			{
-			auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+				auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-			// Convert to local time
+				// Convert to local time
-			std::tm timeInfo = *std::localtime(&now);
+				std::tm timeInfo = *std::localtime(&now);
 
-			std::ostringstream ss;
+				std::ostringstream ss;
-			ss << std::put_time(&timeInfo, "%Y-%m-%d %H:%M:%S ");
+				ss << std::put_time(&timeInfo, "%Y-%m-%d %H:%M:%S ");
 
-			msg.insert(0, ss.str());
+				msg.insert(0, ss.str());
-		}
+			}
 
-		log_next_time_stamp = (msg.find('\n') != std::string::npos);
+			log_next_time_stamp = (msg.find('\n') != std::string::npos);
 
-		Utils::IO::WriteFile(IW4x_fail2ban_location.get<std::string>(), msg, true);
+			Utils::IO::WriteFile(IW4x_fail2ban_location.get<std::string>(), msg, true);
 	}
 
 	void Logger::Frame()
@@ -227,28 +227,28 @@ namespace Components
 
 			pushad
 
-			push [esp + 28h]
+			push[esp + 28h]
 			call PrintMessagePipe
 			add esp, 4h
 
 			popad
 			ret
 
-		returnPrint:
+			returnPrint :
 			pushad
 
-			push 0 // gLog
+				push 0 // gLog
-			push [esp + 2Ch] // data
+				push[esp + 2Ch] // data
-			call NetworkLog
+				call NetworkLog
-			add esp, 8h
+				add esp, 8h
 
-			popad
+				popad
 
-			push esi
+				push esi
-			mov esi, [esp + 0Ch]
+				mov esi, [esp + 0Ch]
 
-			push 4AA835h
+				push 4AA835h
-			ret
+				ret
 		}
 	}
 
@@ -262,13 +262,16 @@ namespace Components
 	{
 		const auto* g_log = (*Game::g_log) ? (*Game::g_log)->current.string : "";
 
-		if (std::strcmp(g_log, file) == 0)
+		if (g_log) // This can be null - has happened before
 		{
-			if (std::strcmp(folder, "userraw") != 0)
+			if (std::strcmp(g_log, file) == 0)
 			{
-				if (IW4x_one_log.get<bool>())
+				if (std::strcmp(folder, "userraw") != 0)
 				{
-					strncpy_s(folder, 256, "userraw", _TRUNCATE);
+					if (IW4x_one_log.get<bool>())
+					{
+						strncpy_s(folder, 256, "userraw", _TRUNCATE);
+					}
 				}
 			}
 		}
@@ -280,8 +283,8 @@ namespace Components
 		{
 			pushad
 
-			push [esp + 20h + 8h]
+			push[esp + 20h + 8h]
-			push [esp + 20h + 10h]
+			push[esp + 20h + 10h]
 			call RedirectOSPath
 			add esp, 8h
 
@@ -310,117 +313,140 @@ namespace Components
 	void Logger::AddServerCommands()
 	{
 		Command::AddSV("log_add", [](const Command::Params* params)
-		{
-			if (params->size() < 2) return;
-
-			std::unique_lock lock(LoggingMutex);
-
-			Network::Address addr(params->get(1));
-			if (std::ranges::find(LoggingAddresses[0], addr) == LoggingAddresses[0].end())
 			{
-				LoggingAddresses[0].push_back(addr);
+				if (params->size() < 2) return;
-			}
+
-		});
+				std::unique_lock lock(LoggingMutex);
+
+				Network::Address addr(params->get(1));
+				if (std::ranges::find(LoggingAddresses[0], addr) == LoggingAddresses[0].end())
+				{
+					LoggingAddresses[0].push_back(addr);
+				}
+			});
 
 		Command::AddSV("log_del", [](const Command::Params* params)
-		{
-			if (params->size() < 2) return;
-
-			std::unique_lock lock(LoggingMutex);
-
-			const auto num = std::atoi(params->get(1));
-			if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[0].size())
 			{
-				auto addr = Logger::LoggingAddresses[0].begin() + num;
+				if (params->size() < 2) return;
-				Print("Address {} removed\n", addr->getString());
-				LoggingAddresses[0].erase(addr);
-			}
-			else
-			{
-				Network::Address addr(params->get(1));
 
-				if (const auto i = std::ranges::find(LoggingAddresses[0], addr); i != LoggingAddresses[0].end())
+				std::unique_lock lock(LoggingMutex);
+
+				const auto num = std::atoi(params->get(1));
+				if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[0].size())
 				{
-					LoggingAddresses[0].erase(i);
+					auto addr = Logger::LoggingAddresses[0].begin() + num;
-					Print("Address {} removed\n", addr.getString());
+					Print("Address {} removed\n", addr->getString());
+					LoggingAddresses[0].erase(addr);
 				}
 				else
 				{
-					Print("Address {} not found!\n", addr.getString());
+					Network::Address addr(params->get(1));
+
+					if (const auto i = std::ranges::find(LoggingAddresses[0], addr); i != LoggingAddresses[0].end())
+					{
+						LoggingAddresses[0].erase(i);
+						Print("Address {} removed\n", addr.getString());
+					}
+					else
+					{
+						Print("Address {} not found!\n", addr.getString());
+					}
 				}
-			}
+			});
-		});
 
 		Command::AddSV("log_list", []([[maybe_unused]] const Command::Params* params)
-		{
-			Print("# ID: Address\n");
-			Print("-------------\n");
-
-			std::unique_lock lock(LoggingMutex);
-
-			for (unsigned int i = 0; i < LoggingAddresses[0].size(); ++i)
 			{
-				Print("#{:03d}: {}\n", i, LoggingAddresses[0][i].getString());
+				Print("# ID: Address\n");
-			}
+				Print("-------------\n");
-		});
+
+				std::unique_lock lock(LoggingMutex);
+
+				for (unsigned int i = 0; i < LoggingAddresses[0].size(); ++i)
+				{
+					Print("#{:03d}: {}\n", i, LoggingAddresses[0][i].getString());
+				}
+			});
 
 		Command::AddSV("g_log_add", [](const Command::Params* params)
-		{
-			if (params->size() < 2) return;
-
-			std::unique_lock lock(LoggingMutex);
-
-			const Network::Address addr(params->get(1));
-			if (std::ranges::find(LoggingAddresses[1], addr) == LoggingAddresses[1].end())
 			{
-				LoggingAddresses[1].push_back(addr);
+				if (params->size() < 2) return;
-			}
+
-		});
+				std::unique_lock lock(LoggingMutex);
+
+				const Network::Address addr(params->get(1));
+				if (std::ranges::find(LoggingAddresses[1], addr) == LoggingAddresses[1].end())
+				{
+					LoggingAddresses[1].push_back(addr);
+				}
+			});
 
 		Command::AddSV("g_log_del", [](const Command::Params* params)
-		{
-			if (params->size() < 2) return;
-
-			std::unique_lock lock(LoggingMutex);
-
-			const auto num = std::atoi(params->get(1));
-			if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[1].size())
 			{
-				const auto addr = LoggingAddresses[1].begin() + num;
+				if (params->size() < 2) return;
-				Print("Address {} removed\n", addr->getString());
+
-				LoggingAddresses[1].erase(addr);
+				std::unique_lock lock(LoggingMutex);
-			}
+
-			else
+				const auto num = std::atoi(params->get(1));
-			{
+				if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[1].size())
-				const Network::Address addr(params->get(1));
-				const auto i = std::ranges::find(LoggingAddresses[1].begin(), LoggingAddresses[1].end(), addr);
-				if (i != LoggingAddresses[1].end())
 				{
-					LoggingAddresses[1].erase(i);
+					const auto addr = LoggingAddresses[1].begin() + num;
-					Print("Address {} removed\n", addr.getString());
+					Print("Address {} removed\n", addr->getString());
+					LoggingAddresses[1].erase(addr);
 				}
 				else
 				{
-					Print("Address {} not found!\n", addr.getString());
+					const Network::Address addr(params->get(1));
+					const auto i = std::ranges::find(LoggingAddresses[1].begin(), LoggingAddresses[1].end(), addr);
+					if (i != LoggingAddresses[1].end())
+					{
+						LoggingAddresses[1].erase(i);
+						Print("Address {} removed\n", addr.getString());
+					}
+					else
+					{
+						Print("Address {} not found!\n", addr.getString());
+					}
 				}
-			}
+			});
-		});
 
 		Command::AddSV("g_log_list", []([[maybe_unused]] const Command::Params* params)
-		{
-			Print("# ID: Address\n");
-			Print("-------------\n");
-
-			std::unique_lock lock(LoggingMutex);
-			for (std::size_t i = 0; i < LoggingAddresses[1].size(); ++i)
 			{
-				Print("#{:03d}: {}\n", i, LoggingAddresses[1][i].getString());
+				Print("# ID: Address\n");
+				Print("-------------\n");
+
+				std::unique_lock lock(LoggingMutex);
+				for (std::size_t i = 0; i < LoggingAddresses[1].size(); ++i)
+				{
+					Print("#{:03d}: {}\n", i, LoggingAddresses[1][i].getString());
+				}
+			});
+	}
+
+	void PrintAliasError(Game::conChannel_t channel, const char* originalMsg, const char* soundName, const char* lastErrorStr)
+	{
+		// We add a bit more info and we clear the sound stream when it happens
+		// to avoid spamming the error
+		const auto newMsg = std::format("{}Make sure you have the 'miles' folder in your game directory! Otherwise MP3 and other codecs will be unavailable.\n", originalMsg);
+		Game::Com_PrintError(channel, newMsg.c_str(), soundName, lastErrorStr);
+
+		for (size_t i = 0; i < ARRAYSIZE(Game::milesGlobal->streamReadInfo); i++)
+		{
+			if (0 == std::strncmp(Game::milesGlobal->streamReadInfo[i].path, soundName, ARRAYSIZE(Game::milesGlobal->streamReadInfo[i].path)))
+			{
+				Game::milesGlobal->streamReadInfo[i].path[0] = '\x00'; // This kills it and make sure it doesn't get played again for now
+				break;
 			}
-		});
+		}
 	}
 
 	Logger::Logger()
 	{
+		// Print sound aliases errors
+		if (!Dedicated::IsEnabled())
+		{
+			Utils::Hook(0x64BA67, PrintAliasError, HOOK_CALL).install()->quick();
+		}
+
 		Utils::Hook(0x642139, BuildOSPath_Stub, HOOK_JUMP).install()->quick();
 
 		Scheduler::Loop(Frame, Scheduler::Pipeline::SERVER);
@@ -438,10 +464,10 @@ namespace Components
 
 		Events::OnSVInit(AddServerCommands);
 		Events::OnDvarInit([]
-		{
+			{
-			IW4x_one_log = Dvar::Register<bool>("iw4x_onelog", false, Game::DVAR_LATCH, "Only write the game log to the 'userraw' OS folder");
+				IW4x_one_log = Dvar::Register<bool>("iw4x_onelog", false, Game::DVAR_LATCH, "Only write the game log to the 'userraw' OS folder");
-			IW4x_fail2ban_location = Dvar::Register<const char*>("iw4x_fail2ban_location", "/var/log/iw4x.log", Game::DVAR_NONE, "Fail2Ban logfile location");
+				IW4x_fail2ban_location = Dvar::Register<const char*>("iw4x_fail2ban_location", "/var/log/iw4x.log", Game::DVAR_NONE, "Fail2Ban logfile location");
-		});
+			});
 	}
 
 	Logger::~Logger()

src/Components/Modules/Logger.hpp

@@ -23,12 +23,12 @@ namespace Components
 
 		static void Print(const std::string_view& fmt)
 		{
-			PrintInternal(Game::CON_CHANNEL_DONT_FILTER, fmt, std::make_format_args(0));
+			PrintInternal(Game::CON_CHANNEL_DONT_FILTER, fmt, std::make_format_args());
 		}
 
 		static void Print(Game::conChannel_t channel, const std::string_view& fmt)
 		{
-			PrintInternal(channel, fmt, std::make_format_args(0));
+			PrintInternal(channel, fmt, std::make_format_args());
 		}
 
 		template <typename... Args>
@@ -47,7 +47,7 @@ namespace Components
 
 		static void Error(Game::errorParm_t error, const std::string_view& fmt)
 		{
-			ErrorInternal(error, fmt, std::make_format_args(0));
+			ErrorInternal(error, fmt, std::make_format_args());
 		}
 
 		template <typename... Args>
@@ -59,7 +59,7 @@ namespace Components
 
 		static void Warning(Game::conChannel_t channel, const std::string_view& fmt)
 		{
-			WarningInternal(channel, fmt, std::make_format_args(0));
+			WarningInternal(channel, fmt, std::make_format_args());
 		}
 
 		template <typename... Args>
@@ -71,7 +71,7 @@ namespace Components
 
 		static void PrintError(Game::conChannel_t channel, const std::string_view& fmt)
 		{
-			PrintErrorInternal(channel, fmt, std::make_format_args(0));
+			PrintErrorInternal(channel, fmt, std::make_format_args());
 		}
 
 		template <typename... Args>
@@ -83,7 +83,7 @@ namespace Components
 
 		static void PrintFail2Ban(const std::string_view& fmt)
 		{
-			PrintFail2BanInternal(fmt, std::make_format_args(0));
+			PrintFail2BanInternal(fmt, std::make_format_args());
 		}
 
 		template <typename... Args>

src/Components/Modules/Maps.cpp

@@ -103,9 +103,9 @@ namespace Components
 
 	const char* Maps::LoadArenaFileStub(const char* name, char* buffer, int size)
 	{
-		std::string data = RawFiles::ReadRawFile(name, buffer, size);
+		std::string  data;
 
- 		if (Maps::UserMap.isValid())
+		if (Maps::UserMap.isValid())
 		{
 			const auto mapname = Maps::UserMap.getName();
 			const auto arena = GetArenaPath(mapname);
@@ -116,6 +116,10 @@ namespace Components
 				data = Utils::IO::ReadFile(arena);
 			}
 		}
+		else
+		{
+			data = RawFiles::ReadRawFile(name, buffer, size);
+		}
 
 		strncpy_s(buffer, size, data.data(), _TRUNCATE);
 		return buffer;
@@ -141,11 +145,11 @@ namespace Components
 		Maps::CurrentDependencies.clear();
 
 		auto dependencies = GetDependenciesForMap(zoneInfo->name);
-		
+
 		std::vector<Game::XZoneInfo> data;
 		Utils::Merge(&data, zoneInfo, zoneCount);
 		Utils::Memory::Allocator allocator;
-		
+
 		if (dependencies.requiresTeamZones)
 		{
 			auto teams = dependencies.requiredTeams;
@@ -177,7 +181,7 @@ namespace Components
 		auto patchZone = std::format("patch_{}", zoneInfo->name);
 		if (FastFiles::Exists(patchZone))
 		{
-			data.push_back({patchZone.data(), zoneInfo->allocFlags, zoneInfo->freeFlags});
+			data.push_back({ patchZone.data(), zoneInfo->allocFlags, zoneInfo->freeFlags });
 		}
 
 		return FastFiles::LoadLocalizeZones(data.data(), data.size(), sync);
@@ -185,18 +189,18 @@ namespace Components
 
 	void Maps::OverrideMapEnts(Game::MapEnts* ents)
 	{
-		auto callback = [] (Game::XAssetHeader header, void* ents)
+		auto callback = [](Game::XAssetHeader header, void* ents)
-		{
-			Game::MapEnts* mapEnts = reinterpret_cast<Game::MapEnts*>(ents);
-			Game::clipMap_t* clipMap = header.clipMap;
-
-			if (clipMap && mapEnts && !_stricmp(mapEnts->name, clipMap->name))
 			{
-				clipMap->mapEnts = mapEnts;
+				Game::MapEnts* mapEnts = reinterpret_cast<Game::MapEnts*>(ents);
-				//*Game::marMapEntsPtr = mapEnts;
+				Game::clipMap_t* clipMap = header.clipMap;
-				//Game::G_SpawnEntitiesFromString();
+
-			}
+				if (clipMap && mapEnts && !_stricmp(mapEnts->name, clipMap->name))
-		};
+				{
+					clipMap->mapEnts = mapEnts;
+					//*Game::marMapEntsPtr = mapEnts;
+					//Game::G_SpawnEntitiesFromString();
+				}
+			};
 
 		// Internal doesn't lock the thread, as locking is impossible, due to executing this in the thread that holds the current lock
 		Game::DB_EnumXAssets_Internal(Game::XAssetType::ASSET_TYPE_CLIPMAP_MP, callback, ents, true);
@@ -276,7 +280,7 @@ namespace Components
 		Logger::Print("Waiting for database...\n");
 		while (!Game::Sys_IsDatabaseReady()) std::this_thread::sleep_for(10ms);
 
-		if (!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp || !Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->name || 
+		if (!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp || !Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->name ||
 			!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->g_glassData || Maps::SPMap)
 		{
 			return Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_SP].gameWorldSp->g_glassData;
@@ -294,7 +298,7 @@ namespace Components
 
 			call Maps::GetWorldData
 
-			mov [esp + 20h], eax
+			mov[esp + 20h], eax
 			popad
 			pop eax
 
@@ -314,6 +318,28 @@ namespace Components
 		}
 	}
 
+	void Maps::ForceRefreshArenas()
+	{
+		if (Game::Sys_IsMainThread())
+		{
+			if (*Game::g_quitRequested)
+			{
+				// No need to refresh if we're exiting the game
+				return;
+			}
+
+			Game::sharedUiInfo_t* uiInfo = reinterpret_cast<Game::sharedUiInfo_t*>(0x62E4B78);
+			uiInfo->updateArenas = 1;
+			Game::UI_UpdateArenas();
+		}
+		else
+		{
+			// Dangerous!!
+			assert(false && "Arenas refreshed from wrong thread??");
+			Logger::Print("Tried to refresh arenas from a thread that is NOT the main thread!! This could have lead to a crash. Please report this bug and how you got it!");
+		}
+	}
+
 	// TODO : Remove hook entirely?
 	void Maps::GetBSPName(char* buffer, size_t size, const char* format, const char* mapname)
 	{
@@ -459,7 +485,7 @@ namespace Components
 		char hashBuf[100] = { 0 };
 		unsigned int hash = atoi(Game::MSG_ReadStringLine(msg, hashBuf, sizeof hashBuf));
 
-		if(!Maps::CheckMapInstalled(mapname, false, true) || hash && hash != Maps::GetUsermapHash(mapname))
+		if (!Maps::CheckMapInstalled(mapname, false, true) || hash && hash != Maps::GetUsermapHash(mapname))
 		{
 			// Reconnecting forces the client to download the new map
 			Command::Execute("disconnect", false);
@@ -480,12 +506,12 @@ namespace Components
 			push eax
 			pushad
 
-			push [esp + 28h]
+			push[esp + 28h]
 			push ebp
 			call Maps::TriggerReconnectForMap
 			add esp, 8h
 
-			mov [esp + 20h], eax
+			mov[esp + 20h], eax
 
 			popad
 			pop eax
@@ -495,7 +521,7 @@ namespace Components
 
 			push 487C50h // Rotate map
 
-		skipRotation:
+			skipRotation :
 			retn
 		}
 	}
@@ -506,7 +532,7 @@ namespace Components
 		{
 			pushad
 
-			push [esp + 24h]
+			push[esp + 24h]
 			call Maps::PrepareUsermap
 			pop eax
 
@@ -523,7 +549,7 @@ namespace Components
 		{
 			pushad
 
-			push [esp + 24h]
+			push[esp + 24h]
 			call Maps::PrepareUsermap
 			pop eax
 
@@ -668,7 +694,7 @@ namespace Components
 			Logger::Error(Game::ERR_DISCONNECT,
 				"Missing map file {}.\nYou may have a damaged installation or are attempting to load a non-existent map.", mapname);
 		}
-		
+
 		return false;
 	}
 
@@ -706,7 +732,7 @@ namespace Components
 
 	void Maps::G_SpawnTurretHook(Game::gentity_s* ent, int unk, int unk2)
 	{
-		if (Maps::CurrentMainZone == "mp_backlot_sh"s || Maps::CurrentMainZone == "mp_con_spring"s || 
+		if (Maps::CurrentMainZone == "mp_backlot_sh"s || Maps::CurrentMainZone == "mp_con_spring"s ||
 			Maps::CurrentMainZone == "mp_mogadishu_sh"s || Maps::CurrentMainZone == "mp_nightshift_sh"s)
 		{
 			return;
@@ -736,7 +762,7 @@ namespace Components
 				Logger::Error(Game::errorParm_t::ERR_DROP, "Invalid trigger index ({}) in entities exceeds the maximum trigger count ({}) defined in the clipmap. Check your map ents, or your clipmap!", triggerIndex, ents->trigger.count);
 				return 0;
 			}
-			else 
+			else
 			{
 				return Utils::Hook::Call<unsigned short(int, Game::Bounds*)>(0x4416C0)(triggerIndex, bounds);
 			}
@@ -744,29 +770,29 @@ namespace Components
 
 		return 0;
 	}
-	
+
 	Maps::Maps()
 	{
 		Scheduler::Once([]
-		{
-			Dvar::Register<bool>("isDlcInstalled_All", false, Game::DVAR_EXTERNAL | Game::DVAR_INIT, "");
-			Maps::RListSModels = Dvar::Register<bool>("r_listSModels", false, Game::DVAR_NONE, "Display a list of visible SModels");
-
-			Maps::AddDlc({ 1, "Stimulus Pack", {"mp_complex", "mp_compact", "mp_storm", "mp_overgrown", "mp_crash"} });
-			Maps::AddDlc({ 2, "Resurgence Pack", {"mp_abandon", "mp_vacant", "mp_trailerpark", "mp_strike", "mp_fuel2"} });
-			Maps::AddDlc({ 3, "IW4x Classics", {"mp_nuked", "mp_cross_fire", "mp_cargoship", "mp_bloc", "mp_killhouse", "mp_bog_sh", "mp_cargoship_sh", "mp_shipment", "mp_shipment_long", "mp_rust_long", "mp_firingrange", "mp_bloc_sh", "mp_crash_tropical", "mp_estate_tropical", "mp_fav_tropical", "mp_storm_spring"} });
-			Maps::AddDlc({ 4, "Call Of Duty 4 Pack", {"mp_farm", "mp_backlot", "mp_pipeline", "mp_countdown", "mp_crash_snow", "mp_carentan", "mp_broadcast", "mp_showdown", "mp_convoy", "mp_citystreets"} });
-			Maps::AddDlc({ 5, "Modern Warfare 3 Pack", {"mp_dome", "mp_hardhat", "mp_paris", "mp_seatown", "mp_bravo", "mp_underground", "mp_plaza2", "mp_village", "mp_alpha"}});
-
-			Maps::UpdateDlcStatus();
-
-			UIScript::Add("downloadDLC", []([[maybe_unused]] const UIScript::Token& token, [[maybe_unused]] const Game::uiInfo_s* info)
 			{
-				const auto dlc = token.get<int>();
+				Dvar::Register<bool>("isDlcInstalled_All", false, Game::DVAR_EXTERNAL | Game::DVAR_INIT, "");
+				Maps::RListSModels = Dvar::Register<bool>("r_listSModels", false, Game::DVAR_NONE, "Display a list of visible SModels");
 
-				Game::ShowMessageBox(Utils::String::VA("DLC %d does not exist!", dlc), "ERROR");
+				Maps::AddDlc({ 1, "Stimulus Pack", {"mp_complex", "mp_compact", "mp_storm", "mp_overgrown", "mp_crash"} });
-			});
+				Maps::AddDlc({ 2, "Resurgence Pack", {"mp_abandon", "mp_vacant", "mp_trailerpark", "mp_strike", "mp_fuel2"} });
-		}, Scheduler::Pipeline::MAIN);
+				Maps::AddDlc({ 3, "IW4x Classics", {"mp_nuked", "mp_cross_fire", "mp_cargoship", "mp_bloc", "mp_killhouse", "mp_bog_sh", "mp_cargoship_sh", "mp_shipment", "mp_shipment_long", "mp_rust_long", "mp_firingrange", "mp_bloc_sh", "mp_crash_tropical", "mp_estate_tropical", "mp_fav_tropical", "mp_storm_spring"} });
+				Maps::AddDlc({ 4, "Call Of Duty 4 Pack", {"mp_farm", "mp_backlot", "mp_pipeline", "mp_countdown", "mp_crash_snow", "mp_carentan", "mp_broadcast", "mp_showdown", "mp_convoy", "mp_citystreets"} });
+				Maps::AddDlc({ 5, "Modern Warfare 3 Pack", {"mp_dome", "mp_hardhat", "mp_paris", "mp_seatown", "mp_bravo", "mp_underground", "mp_plaza2", "mp_village", "mp_alpha"} });
+
+				Maps::UpdateDlcStatus();
+
+				UIScript::Add("downloadDLC", []([[maybe_unused]] const UIScript::Token& token, [[maybe_unused]] const Game::uiInfo_s* info)
+					{
+						const auto dlc = token.get<int>();
+
+						Game::ShowMessageBox(Utils::String::VA("DLC %d does not exist!", dlc), "ERROR");
+					});
+			}, Scheduler::Pipeline::MAIN);
 
 		// disable turrets on CoD:OL 448+ maps for now
 		Utils::Hook(0x5EE577, Maps::G_SpawnTurretHook, HOOK_CALL).install()->quick();
@@ -782,7 +808,7 @@ namespace Components
 #endif
 
 		// 
-		
+
 //#define SORT_SMODELS
 #if !defined(DEBUG) || !defined(SORT_SMODELS)
 		// Don't sort static models
@@ -825,13 +851,13 @@ namespace Components
 		Utils::Hook(0x5B34DD, Maps::LoadMapLoadscreenStub, HOOK_CALL).install()->quick();
 
 		Command::Add("delayReconnect", []()
-		{
-			Scheduler::Once([]
 			{
-				Command::Execute("closemenu popup_reconnectingtoparty", false);
+				Scheduler::Once([]
-				Command::Execute("reconnect", false);
+					{
-			}, Scheduler::Pipeline::CLIENT, 10s);
+						Command::Execute("closemenu popup_reconnectingtoparty", false);
-		});
+						Command::Execute("reconnect", false);
+					}, Scheduler::Pipeline::CLIENT, 10s);
+			});
 
 		if (Dedicated::IsEnabled())
 		{
@@ -845,12 +871,6 @@ namespace Components
 		// Load usermap arena file
 		Utils::Hook(0x630A88, Maps::LoadArenaFileStub, HOOK_CALL).install()->quick();
 
-		// Always refresh arena when loading or unloading a zone
-		Utils::Hook::Nop(0x485017, 2);
-		Utils::Hook::Nop(0x4BDFB7, 2); // Unknown
-		Utils::Hook::Nop(0x45ED6F, 2); // loadGameInfo
-		Utils::Hook::Nop(0x4A5888, 2); // UI_InitOnceForAllClients
-
 		// Allow hiding specific smodels
 		Utils::Hook(0x50E67C, Maps::HideModelStub, HOOK_CALL).install()->quick();
 
@@ -861,33 +881,33 @@ namespace Components
 
 		// Client only
 		Scheduler::Loop([]
-		{
-			auto*& gameWorld = *reinterpret_cast<Game::GfxWorld**>(0x66DEE94);
-			if (!Game::CL_IsCgameInitialized() || !gameWorld || !Maps::RListSModels.get<bool>()) return;
-
-			std::map<std::string, int> models;
-			for (unsigned int i = 0; i < gameWorld->dpvs.smodelCount; ++i)
 			{
-				if (gameWorld->dpvs.smodelVisData[0][i])
+				auto*& gameWorld = *reinterpret_cast<Game::GfxWorld**>(0x66DEE94);
+				if (!Game::CL_IsCgameInitialized() || !gameWorld || !Maps::RListSModels.get<bool>()) return;
+
+				std::map<std::string, int> models;
+				for (unsigned int i = 0; i < gameWorld->dpvs.smodelCount; ++i)
 				{
-					std::string name = gameWorld->dpvs.smodelDrawInsts[i].model->name;
+					if (gameWorld->dpvs.smodelVisData[0][i])
+					{
+						std::string name = gameWorld->dpvs.smodelDrawInsts[i].model->name;
 
-					if (!models.contains(name)) models[name] = 1;
+						if (!models.contains(name)) models[name] = 1;
-					else models[name]++;
+						else models[name]++;
+					}
 				}
-			}
 
-			Game::Font_s* font = Game::R_RegisterFont("fonts/smallFont", 0);
+				Game::Font_s* font = Game::R_RegisterFont("fonts/smallFont", 0);
-			auto height = Game::R_TextHeight(font);
+				auto height = Game::R_TextHeight(font);
-			auto scale = 0.75f;
+				auto scale = 0.75f;
-			float color[4] = {0.0f, 1.0f, 0.0f, 1.0f};
+				float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
 
-			unsigned int i = 0;
+				unsigned int i = 0;
-			for (auto& model : models)
+				for (auto& model : models)
-			{
+				{
-				Game::R_AddCmdDrawText(Utils::String::VA("%d %s", model.second, model.first.data()), std::numeric_limits<int>::max(), font, 15.0f, (height * scale + 1) * (i++ + 1) + 15.0f, scale, scale, 0.0f, color, Game::ITEM_TEXTSTYLE_NORMAL);
+					Game::R_AddCmdDrawText(Utils::String::VA("%d %s", model.second, model.first.data()), std::numeric_limits<int>::max(), font, 15.0f, (height * scale + 1) * (i++ + 1) + 15.0f, scale, scale, 0.0f, color, Game::ITEM_TEXTSTYLE_NORMAL);
-			}
+				}
-		}, Scheduler::Pipeline::RENDERER);
+			}, Scheduler::Pipeline::RENDERER);
 	}
 
 	Maps::~Maps()

src/Components/Modules/Maps.hpp

@@ -13,7 +13,7 @@ namespace Components
 			{
 				ZeroMemory(&this->searchPath, sizeof this->searchPath);
 				this->hash = Maps::GetUsermapHash(this->mapname);
-				Game::UI_UpdateArenas();
+				Maps::ForceRefreshArenas();
 			}
 
 			~UserMapContainer()
@@ -29,7 +29,10 @@ namespace Components
 			{
 				bool wasValid = this->isValid();
 				this->mapname.clear();
-				if (wasValid) Game::UI_UpdateArenas();
+				if (wasValid)
+				{
+					Maps::ForceRefreshArenas();
+				}
 			}
 
 			void loadIwd();
@@ -95,6 +98,8 @@ namespace Components
 
 		static Dvar::Var RListSModels;
 
+		static void ForceRefreshArenas();
+
 		static void GetBSPName(char* buffer, size_t size, const char* format, const char* mapname);
 		static void LoadAssetRestrict(Game::XAssetType type, Game::XAssetHeader asset, const std::string& name, bool* restrict);
 		static void LoadMapZones(Game::XZoneInfo *zoneInfo, unsigned int zoneCount, int sync);

src/Components/Modules/StructuredData.cpp

@@ -3,6 +3,8 @@
 
 namespace Components
 {
+	constexpr auto BASE_PLAYERSTATS_VERSION = 155;
+
 	Utils::Memory::Allocator StructuredData::MemAllocator;
 
 	const char* StructuredData::EnumTranslation[COUNT] =
@@ -26,6 +28,11 @@ namespace Components
 	{
 		if (!data || type >= StructuredData::PlayerDataType::COUNT) return;
 
+		// Reallocate them before patching
+		Game::StructuredDataEnum* newEnums = MemAllocator.allocateArray<Game::StructuredDataEnum>(data->enumCount);
+		std::memcpy(newEnums, data->enums, sizeof(Game::StructuredDataEnum) * data->enumCount);
+		data->enums = newEnums;
+
 		Game::StructuredDataEnum* dataEnum = &data->enums[type];
 
 		// Build index-sorted data vector
@@ -87,23 +94,52 @@ namespace Components
 
 	void StructuredData::PatchCustomClassLimit(Game::StructuredDataDef* data, int count)
 	{
-		const int customClassSize = 64;
+		constexpr auto CLASS_ARRAY = 5;
+		const auto originalClassCount = data->indexedArrays[CLASS_ARRAY].arraySize;
 
-		for (int i = 0; i < data->structs[0].propertyCount; ++i)
+		if (count != originalClassCount)
 		{
-			// 3003 is the offset of the customClasses structure
+			const int customClassSize = 64;
-			if (data->structs[0].properties[i].offset >= 3643)
+
+			// We need to recreate the struct list cause it's used in order definitions
+			auto newStructs = StructuredData::MemAllocator.allocateArray<Game::StructuredDataStruct>(data->structCount);
+			std::memcpy(newStructs, data->structs, data->structCount * sizeof(Game::StructuredDataStruct));
+			data->structs = newStructs;
+
+			constexpr auto structIndex = 0;
 			{
-				// -10 because 10 is the default amount of custom classes.
+				auto strct = &data->structs[structIndex];
-				data->structs[0].properties[i].offset += ((count - 10) * customClassSize);
+				
+				auto newProperties = StructuredData::MemAllocator.allocateArray<Game::StructuredDataStructProperty>(strct->propertyCount);
+				std::memcpy(newProperties, strct->properties, strct->propertyCount * sizeof(Game::StructuredDataStructProperty));
+				strct->properties = newProperties;
+
+				for (int propertyIndex = 0; propertyIndex < strct->propertyCount; ++propertyIndex)
+				{
+					// 3643 is the offset of the customClasses structure
+					if (strct->properties[propertyIndex].offset >= 3643)
+					{
+						// -10 because 10 is the default amount of custom classes.
+						strct->properties[propertyIndex].offset += ((count - originalClassCount) * customClassSize);
+					}
+				}
+			}
+
+			// update structure size
+			data->size += ((count - originalClassCount) * customClassSize);
+
+			// Update amount of custom classes
+			if (data->indexedArrays[CLASS_ARRAY].arraySize != count)
+			{
+				// We need to recreate the whole array - this reference could be reused accross definitions
+				auto newIndexedArray = StructuredData::MemAllocator.allocateArray<Game::StructuredDataIndexedArray>(data->indexedArrayCount);
+				std::memcpy(newIndexedArray, data->indexedArrays, data->indexedArrayCount * sizeof(Game::StructuredDataIndexedArray));
+				data->indexedArrays = newIndexedArray;
+
+				// Add classes
+				data->indexedArrays[CLASS_ARRAY].arraySize = count;
 			}
 		}
-
-		// update structure size
-		data->size += ((count - 10) * customClassSize);
-
-		// Update amount of custom classes
-		data->indexedArrays[5].arraySize = count;
 	}
 
 	void StructuredData::PatchAdditionalData(Game::StructuredDataDef* data, std::unordered_map<std::string, std::string>& patches)
@@ -119,26 +155,44 @@ namespace Components
 
 	bool StructuredData::UpdateVersionOffsets(Game::StructuredDataDefSet* set, Game::StructuredDataBuffer* buffer, Game::StructuredDataDef* whatever)
 	{
-		Game::StructuredDataDef* newDef = &set->defs[0];
+		if (set->defCount > 1)
-		Game::StructuredDataDef* oldDef = &set->defs[0];
-
-		for (unsigned int i = 0; i < set->defCount; ++i)
 		{
-			if (newDef->version < set->defs[i].version)
+			int bufferVersion = *reinterpret_cast<int*>(buffer->data);
+
+			for (size_t i = 0; i < set->defCount; i++)
 			{
-				newDef = &set->defs[i];
+				if (set->defs[i].version == bufferVersion)
+				{
+					if (i == 0)
+					{
+						// No update to conduct
+					}
+					else
+					{
+						Game::StructuredDataDef* newDef = &set->defs[i - 1];
+						Game::StructuredDataDef* oldDef = &set->defs[i];
+
+						if (newDef->version == 159 && oldDef->version <= 158)
+						{
+							// this should move the data 320 bytes infront
+							std::memmove(&buffer->data[3963], &buffer->data[3643], oldDef->size - 3643);
+						}
+						else if (newDef->version > 159 && false)
+						{
+							// 159 cannot be translated upwards and it's hard to say why
+							// Reading it fails in various ways
+							// might be the funky class bump...?
+
+							Command::Execute("setPlayerData prestige 10");
+							Command::Execute("setPlayerData experience 2516000");
+						}
+
+						return Utils::Hook::Call<bool(void*, void*, void*)>(0x456830)(set, buffer, whatever);
+					}
+				}
 			}
 
-			if (set->defs[i].version == *reinterpret_cast<int*>(buffer->data))
+			return Utils::Hook::Call<bool(void*, void*, void*)>(0x456830)(set, buffer, whatever);
-			{
-				oldDef = &set->defs[i];
-			}
-		}
-
-		if (newDef->version >= 159 && oldDef->version <= 158)
-		{
-			// this should move the data 320 bytes infront
-			std::memmove(&buffer->data[3963], &buffer->data[3643], oldDef->size - 3643);
 		}
 
 		// StructuredData_UpdateVersion
@@ -182,7 +236,7 @@ namespace Components
 					return;
 				}
 
-				if (data->defs[0].version != 155)
+				if (data->defs[0].version != BASE_PLAYERSTATS_VERSION)
 				{
 					Logger::Error(Game::ERR_FATAL, "Initial PlayerDataDef is not version 155, patching not possible!");
 					return;
@@ -262,16 +316,10 @@ namespace Components
 				auto* newData = StructuredData::MemAllocator.allocateArray<Game::StructuredDataDef>(data->defCount + patchDefinitions.size());
 				std::memcpy(&newData[patchDefinitions.size()], data->defs, sizeof Game::StructuredDataDef * data->defCount);
 
-				// Prepare the buffers
+				// Set the versions
 				for (unsigned int i = 0; i < patchDefinitions.size(); ++i)
 				{
-					std::memcpy(&newData[i], data->defs, sizeof Game::StructuredDataDef);
+					newData[i].version = (patchDefinitions.size() - i) + BASE_PLAYERSTATS_VERSION;
-					newData[i].version = (patchDefinitions.size() - i) + 155;
-
-					// Reallocate the enum array
-					auto* newEnums = StructuredData::MemAllocator.allocateArray<Game::StructuredDataEnum>(data->defs->enumCount);
-					std::memcpy(newEnums, data->defs->enums, sizeof Game::StructuredDataEnum * data->defs->enumCount);
-					newData[i].enums = newEnums;
 				}
 
 				// Apply new data
@@ -279,10 +327,18 @@ namespace Components
 				data->defCount += patchDefinitions.size();
 
 				// Patch the definition
-				for (unsigned int i = 0; i < data->defCount; ++i)
+				for (int i = data->defCount - 1; i >= 0; --i)
 				{
 					// No need to patch version 155
-					if (newData[i].version == 155) continue;
+					if (newData[i].version == BASE_PLAYERSTATS_VERSION)
+					{
+						continue;
+					}
+
+					// We start from the previous one
+					const auto version = newData[i].version;
+					data->defs[i] = data->defs[i + 1];
+					newData[i].version = version;
 
 					if (patchDefinitions.contains(newData[i].version))
 					{

src/Components/Modules/Vote.cpp

@@ -2,11 +2,14 @@
 #include "ClientCommand.hpp"
 #include "MapRotation.hpp"
 #include "Vote.hpp"
+#include "Events.hpp"
 
 using namespace Utils::String;
 
 namespace Components
 {
+	Dvar::Var Vote::SV_VotesRequired;
+
 	std::unordered_map<std::string, Vote::CommandHandler> Vote::VoteCommands =
 	{
 		{"map_restart", HandleMapRestart},
@@ -37,6 +40,17 @@ namespace Components
 		Game::SV_SetConfigstring(Game::CS_VOTE_NO, VA("%i", Game::level->voteNo));
 	}
 
+	int Vote::VotesRequired()
+	{
+		auto votesRequired = Vote::SV_VotesRequired.get<int>();
+		
+		if (votesRequired > 0)
+		{
+			return votesRequired;
+		}
+		return Game::level->numConnectedClients / 2 + 1;
+	}
+
 	bool Vote::IsInvalidVoteString(const std::string& input)
 	{
 		static const char* separators[] = { "\n", "\r", ";" };
@@ -204,7 +218,7 @@ namespace Components
 			return;
 		}
 
-		if (Game::level->numConnectedClients < 2)
+		if (Game::level->numConnectedClients < VotesRequired())
 		{
 			Game::SV_GameSendServerCommand(ent - Game::g_entities, Game::SV_CMD_CAN_IGNORE, VA("%c \"GAME_VOTINGNOTENOUGHPLAYERS\"", 0x65));
 			return;
@@ -218,7 +232,7 @@ namespace Components
 				return;
 			}
 
-			if (ent->client->sess.voteCount >= 3)
+			if (ent->client->sess.voteCount >= VotesRequired())
 			{
 				Game::SV_GameSendServerCommand(ent - Game::g_entities, Game::SV_CMD_CAN_IGNORE, VA("%c \"GAME_MAXVOTESCALLED\"", 0x65));
 				return;
@@ -321,6 +335,10 @@ namespace Components
 		// Replicate g_allowVote
 		Utils::Hook::Set<std::uint32_t>(0x5E3A4F, Game::DVAR_INTERNAL | Game::DVAR_CODINFO);
 
+		Events::OnDvarInit([]{
+			Vote::SV_VotesRequired = Game::Dvar_RegisterInt("sv_votesRequired", 0, 0, 18, Game::DVAR_NONE, "Set the amount of votes required for a vote to pass.\n0 = (players / 2) + 1");
+		});
+
 		ClientCommand::Add("callvote", Cmd_CallVote_f);
 		ClientCommand::Add("vote", Cmd_Vote_f);
 

src/Components/Modules/Vote.hpp

@@ -11,11 +11,14 @@ namespace Components
 		using CommandHandler = std::function<bool(const Game::gentity_s* ent, const Command::ServerParams* params)>;
 		static std::unordered_map<std::string, CommandHandler> VoteCommands;
 
+		static Dvar::Var SV_VotesRequired;
+
 		static constexpr auto* CallVoteDesc = "%c \"GAME_VOTECOMMANDSARE\x15 map_restart, map_rotate, map <mapname>, g_gametype <typename>, typemap <typename> <mapname>, "
 			"kick <player>, tempBanUser <player>\"";
 
 		static void DisplayVote(const Game::gentity_s* ent);
 		static bool IsInvalidVoteString(const std::string& input);
+		static int VotesRequired();
 
 		static bool HandleMapRestart(const Game::gentity_s* ent, const Command::ServerParams* params);
 		static bool HandleMapRotate(const Game::gentity_s* ent, const Command::ServerParams* params);

src/Game/Game.cpp

@@ -17,10 +17,13 @@ namespace Game
 	G_DebugLineWithDuration_t G_DebugLineWithDuration = G_DebugLineWithDuration_t(0x4C3280);
 
 	gentity_s* g_entities = reinterpret_cast<gentity_s*>(0x18835D8);
+	bool* g_quitRequested = reinterpret_cast<bool*>(0x649FB61);
 
 	NetField* clientStateFields = reinterpret_cast<Game::NetField*>(0x741E40);
 	size_t clientStateFieldsCount = Utils::Hook::Get<size_t>(0x7433C8);
 
+	MssLocal* milesGlobal = reinterpret_cast<MssLocal*>(0x649A1A0);
+
 	const char* origErrorMsg = reinterpret_cast<const char*>(0x79B124);
 
 	XModel* G_GetModel(const int index)

src/Game/Game.hpp

@@ -52,10 +52,13 @@ namespace Game
 	constexpr std::size_t MAX_GENTITIES = 2048;
 	constexpr std::size_t ENTITYNUM_NONE = MAX_GENTITIES - 1;
 	extern gentity_s* g_entities;
+	extern bool* g_quitRequested;
 
 	// This does not belong anywhere else
 	extern NetField* clientStateFields;
 	extern size_t clientStateFieldsCount;
+	extern MssLocal* milesGlobal;
+
 
 	extern const char* origErrorMsg;
 

src/Game/Structs.hpp

@@ -1139,11 +1139,11 @@ namespace Game
 		unsigned __int16 triCount;
 		XSurfaceCollisionTree* collisionTree;
 	};
-	
+
 	struct DObjSkelMat
 	{
-	  float axis[3][4];
+		float axis[3][4];
-	  float origin[4];
+		float origin[4];
 	};
 
 	struct XSurface
@@ -2426,7 +2426,7 @@ namespace Game
 		float scale;
 		unsigned int noScalePartBits[6];
 		unsigned __int16* boneNames;
-		unsigned char *parentList;
+		unsigned char* parentList;
 		short* quats;
 		float* trans;
 		unsigned char* partClassification;
@@ -4021,7 +4021,7 @@ namespace Game
 		GfxSurfaceBounds* surfacesBounds;
 		GfxStaticModelDrawInst* smodelDrawInsts;
 		GfxDrawSurf* surfaceMaterials;
-		unsigned int*  surfaceCastsSunShadow;
+		unsigned int* surfaceCastsSunShadow;
 		volatile int usageCount;
 	};
 
@@ -4032,7 +4032,7 @@ namespace Game
 		unsigned __int16 materialSortedIndex : 12;
 		unsigned __int16 visDataRefCountLessOne : 4;
 	};
-	
+
 	union GfxSModelSurfHeader
 	{
 		GfxSModelSurfHeaderFields fields;
@@ -5519,6 +5519,32 @@ namespace Game
 		StructuredDataEnumEntry* entries;
 	};
 
+	enum LookupResultDataType
+	{
+		LOOKUP_RESULT_INT = 0x0,
+		LOOKUP_RESULT_BOOL = 0x1,
+		LOOKUP_RESULT_STRING = 0x2,
+		LOOKUP_RESULT_FLOAT = 0x3,
+		LOOKUP_RESULT_SHORT = 0x4,
+	};
+
+	enum LookupState
+	{
+		LOOKUP_IN_PROGRESS = 0x0,
+		LOOKUP_FINISHED = 0x1,
+		LOOKUP_ERROR = 0x2,
+	};
+
+	enum LookupError
+	{
+		LOOKUP_ERROR_NONE = 0x0,
+		LOOKUP_ERROR_WRONG_DATA_TYPE = 0x1,
+		LOOKUP_ERROR_INDEX_OUTSIDE_BOUNDS = 0x2,
+		LOOKUP_ERROR_INVALID_STRUCT_PROPERTY = 0x3,
+		LOOKUP_ERROR_INVALID_ENUM_VALUE = 0x4,
+		LOOKUP_ERROR_COUNT = 0x5,
+	};
+
 	enum StructuredDataTypeCategory
 	{
 		DATA_INT = 0x0,
@@ -5594,6 +5620,15 @@ namespace Game
 		unsigned int size;
 	};
 
+
+	struct StructuredDataLookup
+	{
+		StructuredDataDef* def;
+		StructuredDataType* type;
+		unsigned int offset;
+		LookupError error;
+	};
+
 	struct StructuredDataDefSet
 	{
 		const char* name;
@@ -7932,8 +7967,8 @@ namespace Game
 
 	struct GfxCmdBufContext
 	{
-		GfxCmdBufSourceState *source;
+		GfxCmdBufSourceState* source;
-		GfxCmdBufState *state;
+		GfxCmdBufState* state;
 	};
 
 	struct GfxDrawGroupSetupFields
@@ -8385,18 +8420,18 @@ namespace Game
 		int timeStamp;
 		DObjAnimMat* mat;
 	};
-	
+
 	struct bitarray
 	{
-	  int array[6];
+		int array[6];
 	};
 
 	/* 1923 */
 	struct XAnimCalcAnimInfo
 	{
-	  DObjAnimMat rotTransArray[1152];
+		DObjAnimMat rotTransArray[1152];
-	  bitarray animPartBits;
+		bitarray animPartBits;
-	  bitarray ignorePartBits;
+		bitarray ignorePartBits;
 	};
 
 
@@ -11101,6 +11136,159 @@ namespace Game
 		FFD_USER_MAP = 0x2,
 	};
 
+	struct ASISTAGE
+	{
+		int(__stdcall* ASI_stream_open)(unsigned int, int(__stdcall*)(unsigned int, void*, int, int), unsigned int);
+		int(__stdcall* ASI_stream_process)(int, void*, int);
+		int(__stdcall* ASI_stream_seek)(int, int);
+		int(__stdcall* ASI_stream_close)(int);
+		int(__stdcall* ASI_stream_property)(int, unsigned int, void*, const void*, void*);
+		unsigned int INPUT_BIT_RATE;
+		unsigned int INPUT_SAMPLE_RATE;
+		unsigned int INPUT_BITS;
+		unsigned int INPUT_CHANNELS;
+		unsigned int OUTPUT_BIT_RATE;
+		unsigned int OUTPUT_SAMPLE_RATE;
+		unsigned int OUTPUT_BITS;
+		unsigned int OUTPUT_CHANNELS;
+		unsigned int OUTPUT_RESERVOIR;
+		unsigned int POSITION;
+		unsigned int PERCENT_DONE;
+		unsigned int MIN_INPUT_BLOCK_SIZE;
+		unsigned int RAW_RATE;
+		unsigned int RAW_BITS;
+		unsigned int RAW_CHANNELS;
+		unsigned int REQUESTED_RATE;
+		unsigned int REQUESTED_BITS;
+		unsigned int REQUESTED_CHANS;
+		unsigned int STREAM_SEEK_POS;
+		unsigned int DATA_START_OFFSET;
+		unsigned int DATA_LEN;
+		int stream;
+	};
+
+	struct _STREAM
+	{
+		int block_oriented;
+		int using_ASI;
+		ASISTAGE* ASI;
+		void* samp;
+		unsigned int fileh;
+		char* bufs[3];
+		unsigned int bufsizes[3];
+		int reset_ASI[3];
+		int reset_seek_pos[3];
+		int bufstart[3];
+		void* asyncs[3];
+		int loadedbufstart[2];
+		int loadedorder[2];
+		int loadorder;
+		int bufsize;
+		int readsize;
+		unsigned int buf1;
+		int size1;
+		unsigned int buf2;
+		int size2;
+		unsigned int buf3;
+		int size3;
+		unsigned int datarate;
+		int filerate;
+		int filetype;
+		unsigned int fileflags;
+		int totallen;
+		int substart;
+		int sublen;
+		int subpadding;
+		unsigned int blocksize;
+		int padding;
+		int padded;
+		int loadedsome;
+		unsigned int startpos;
+		unsigned int totalread;
+		unsigned int loopsleft;
+		unsigned int error;
+		int preload;
+		unsigned int preloadpos;
+		int noback;
+		int alldone;
+		int primeamount;
+		int readatleast;
+		int playcontrol;
+		void(__stdcall* callback)(_STREAM*);
+		int user_data[8];
+		void* next;
+		int autostreaming;
+		int docallback;
+	};
+
+	enum SND_EQTYPE
+	{
+		SND_EQTYPE_FIRST = 0x0,
+		SND_EQTYPE_LOWPASS = 0x0,
+		SND_EQTYPE_HIGHPASS = 0x1,
+		SND_EQTYPE_LOWSHELF = 0x2,
+		SND_EQTYPE_HIGHSHELF = 0x3,
+		SND_EQTYPE_BELL = 0x4,
+		SND_EQTYPE_LAST = 0x4,
+		SND_EQTYPE_COUNT = 0x5,
+		SND_EQTYPE_INVALID = 0x5,
+	};
+
+	struct __declspec(align(4)) SndEqParams
+	{
+		SND_EQTYPE type;
+		float gain;
+		float freq;
+		float q;
+		bool enabled;
+	};
+
+	struct MssEqInfo
+	{
+		SndEqParams params[3][64];
+	};
+
+	struct MssFileHandle
+	{
+		unsigned int id;
+		MssFileHandle* next;
+		int handle;
+		char fileName[128];
+		unsigned int hashCode;
+		int offset;
+		int fileOffset;
+		int fileLength;
+	};
+
+	struct __declspec(align(4)) MssStreamReadInfo
+	{
+		char path[256];
+		int timeshift;
+		float fraction;
+		int startDelay;
+		_STREAM* handle;
+		bool readError;
+	};
+
+	struct MssLocal
+	{
+		struct _DIG_DRIVER* driver;
+		struct _SAMPLE* handle_sample[40];
+		_STREAM* handle_stream[12];
+		bool voiceEqDisabled[52];
+		MssEqInfo eq[2];
+		float eqLerp;
+		unsigned int eqFilter;
+		int currentRoomtype;
+		MssFileHandle fileHandle[12];
+		MssFileHandle* freeFileHandle;
+		bool isMultiChannel;
+		float realVolume[12];
+		int playbackRate[52];
+		MssStreamReadInfo streamReadInfo[12];
+	};
+
+
 #pragma endregion
 
 #ifndef IDA