maint: update Premake5

fix: remove _s poison
fix noob team
2025-04-11 11:10:05 +02:00 · 2025-02-06 12:34:59 +01:00 · 2025-02-03 20:02:50 +01:00 · 2025-01-30 13:14:21 +01:00 · 2025-01-29 13:25:42 +01:00 · 2025-01-29 08:21:56 +00:00
48 changed files with 931 additions and 285 deletions
--- a/deps/GSL
+++ b/deps/GSL
@ -1 +1 @@
-Subproject commit 272463043ef3e442f6c80a530d3dd38ee6781381
+Subproject commit 3325bbd33d24d1f8f5a0f69e782c92ad5a39a68e
--- a/deps/asmjit
+++ b/deps/asmjit
@ -1 +1 @@
-Subproject commit cfc9f813cc6ccda63cad872edb32b38e0662bedb
+Subproject commit e8c8e2e48a1a38154c8e8864eb3bc61db80a1e31
--- a/deps/gsc-tool
+++ b/deps/gsc-tool
@ -1 +1 @@
-Subproject commit 9ff3b871ef59b14eb8b32d258bf18347e14a3e18
+Subproject commit 2d9781ce0ce9e8551eaf040d7761fd986f33cfdc
--- a/deps/libtomcrypt
+++ b/deps/libtomcrypt
@ -1 +1 @@
-Subproject commit c900951dab1bb94bab803fc57688dac18e3b71f9
+Subproject commit a6b9aff7aab857fe1b491710a5c5b9e2be49cb08
--- a/deps/libtommath
+++ b/deps/libtommath
@ -1 +1 @@
-Subproject commit 5809141a3a6ec1bf3443c927c02b955e19224016
+Subproject commit e823b0c34cea291bdb94d672731e1c1f08525557
--- a/deps/minhook
+++ b/deps/minhook
@ -1 +1 @@
-Subproject commit c1a7c3843bd1a5fe3eb779b64c0d823bca3dc339
+Subproject commit c3fcafdc10146beb5919319d0683e44e3c30d537
--- a/deps/rapidjson
+++ b/deps/rapidjson
@ -1 +1 @@
-Subproject commit d621dc9e9c77f81e5c8a35b8dcc16dcd63351321
+Subproject commit 24b5e7a8b27f42fa16b96fc70aade9106cf7102f
--- a/deps/zlib
+++ b/deps/zlib
@ -1 +1 @@
-Subproject commit ef24c4c7502169f016dcd2a26923dbaf3216748c
+Subproject commit 5a82f71ed1dfc0bec044d9702463dbdf84ea3b71
--- a/premake5.lua
+++ b/premake5.lua
@ -268,7 +268,7 @@ filter "configurations:Release"
 	buildoptions {"/GL"}
 	linkoptions {"/IGNORE:4702", "/LTCG"}
 	defines {"NDEBUG"}
-	flags {"FatalCompileWarnings"}
+	fatalwarnings {"All"}
 filter {}

 filter "configurations:Debug"
--- a/src/client/component/assets/weapons.cpp
+++ b/src/client/component/assets/weapons.cpp
@ -0,0 +1,61 @@
+#include <std_include.hpp>
+#include "loader/component_loader.hpp"
+#include "game/game.hpp"
+
+#include "component/console.hpp"
+
+#include <utils/hook.hpp>
+
+namespace weapons
+{
+	namespace
+	{
+		void g_setup_level_weapon_def_stub()
+		{
+			game::G_SetupLevelWeaponDef();
+
+			// The count on most maps is well below 200
+			std::array<game::WeaponCompleteDef*, 256> weapons{};
+			const auto count = game::DB_GetAllXAssetOfType_FastFile(game::ASSET_TYPE_WEAPON, (void**)weapons.data(), static_cast<int>(weapons.max_size()));
+
+			std::sort(weapons.begin(), weapons.begin() + count, [](game::WeaponCompleteDef* weapon1, game::WeaponCompleteDef* weapon2)
+			{
+				assert(weapon1->szInternalName);
+				assert(weapon2->szInternalName);
+
+				return std::strcmp(weapon1->szInternalName, weapon2->szInternalName) < 0;
+			});
+
+#ifdef _DEBUG
+			console::info("Found %i weapons to precache\n", count);
+#endif
+
+			for (auto i = 0; i < count; ++i)
+			{
+#ifdef _DEBUG
+				console::info("Precaching weapon \"%s\"\n", weapons[i]->szInternalName);
+#endif
+				(void)game::G_GetWeaponForName(weapons[i]->szInternalName);
+			}
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			if (game::environment::is_sp()) return;
+
+			// Kill Scr_PrecacheItem (We are going to do this from code)
+			utils::hook::nop(0x1403BDB10, 4);
+			utils::hook::set<std::uint8_t>(0x1403BDB10, 0xC3);
+
+			// Load weapons from the DB
+			utils::hook::call(0x14039F382, g_setup_level_weapon_def_stub);
+			utils::hook::call(0x1403AE31A, g_setup_level_weapon_def_stub);
+		}
+	};
+}
+
+REGISTER_COMPONENT(weapons::component)
--- a/src/client/component/auth.cpp
+++ b/src/client/component/auth.cpp
@ -36,11 +36,8 @@ namespace auth
 			auto hw_profile_path = (utils::properties::get_appdata_path() / "iw6-guid.dat").generic_string();
 			if (utils::io::file_exists(hw_profile_path))
 			{
-				std::string hw_profile_info;
-				if (utils::io::read_file(hw_profile_path, &hw_profile_info) && !hw_profile_info.empty())
-				{
-					return hw_profile_info;
-				}
+				// Migration
+				utils::io::remove_file(hw_profile_path);
 			}

 			HW_PROFILE_INFO info;
@ -50,8 +47,6 @@ namespace auth
 			}

 			auto hw_profile_info = std::string{ info.szHwProfileGuid, sizeof(info.szHwProfileGuid) };
-			utils::io::write_file(hw_profile_path, hw_profile_info);
-
 			return hw_profile_info;
 		}

@ -67,7 +62,7 @@ namespace auth
 				return {};
 			}

-			const auto size = std::min(data_out.cbData, 52ul);
+			const auto size = std::min<DWORD>(data_out.cbData, 52);
 			std::string result{ reinterpret_cast<char*>(data_out.pbData), size };
 			LocalFree(data_out.pbData);

@ -91,9 +86,72 @@ namespace auth
 			return entropy;
 		}

-		utils::cryptography::ecc::key& get_key()
+		bool load_key(utils::cryptography::ecc::key& key)
 		{
-			static auto key = utils::cryptography::ecc::generate_key(512, get_key_entropy());
+			std::string data{};
+
+			auto key_path = (utils::properties::get_appdata_path() / "iw6-private.key").generic_string();
+			if (!utils::io::read_file(key_path, &data))
+			{
+				return false;
+			}
+
+			key.deserialize(data);
+			if (!key.is_valid())
+			{
+				console::error("Loaded key is invalid!\n");
+				return false;
+			}
+
+			return true;
+		}
+
+		utils::cryptography::ecc::key generate_key()
+		{
+			auto key = utils::cryptography::ecc::generate_key(512, get_key_entropy());
+			if (!key.is_valid())
+			{
+				throw std::runtime_error("Failed to generate cryptographic key!");
+			}
+
+			auto key_path = (utils::properties::get_appdata_path() / "iw6-private.key").generic_string();
+			if (!utils::io::write_file(key_path, key.serialize()))
+			{
+				console::error("Failed to write cryptographic key!\n");
+			}
+
+			console::info("Generated cryptographic key: %llX\n", key.get_hash());
+			return key;
+		}
+
+		utils::cryptography::ecc::key load_or_generate_key()
+		{
+			utils::cryptography::ecc::key key{};
+			if (load_key(key))
+			{
+				console::info("Loaded cryptographic key: %llX\n", key.get_hash());
+				return key;
+			}
+
+			return generate_key();
+		}
+
+		utils::cryptography::ecc::key get_key_internal()
+		{
+			auto key = load_or_generate_key();
+
+			auto key_path = (utils::properties::get_appdata_path() / "iw6-public.key").generic_string();
+			if (!utils::io::write_file(key_path, key.get_public_key()))
+			{
+				console::error("Failed to write public key!\n");
+			}
+
+			return key;
+		}
+
+		const utils::cryptography::ecc::key& get_key()
+		{
+			static auto key = get_key_internal();
 			return key;
 		}

@ -101,7 +159,7 @@ namespace auth
 		{
 			std::string connect_string(format, len);
 			game::SV_Cmd_TokenizeString(connect_string.data());
-			const auto _ = gsl::finally([]()
+			const auto _0 = gsl::finally([]()
 			{
 				game::SV_Cmd_EndTokenizedString();
 			});
@ -124,7 +182,7 @@ namespace auth

 			proto::network::connect_info info;
 			info.set_publickey(get_key().get_public_key());
-			info.set_signature(sign_message(get_key(), challenge));
+			info.set_signature(utils::cryptography::ecc::sign_message(get_key(), challenge));
 			info.set_infostring(connect_string);

 			network::send(*adr, "connect", info.SerializeAsString());
@ -165,14 +223,14 @@ namespace auth
 			utils::cryptography::ecc::key key;
 			key.set(info.publickey());

-			const auto xuid = strtoull(steam_id.data(), nullptr, 16);
+			const auto xuid = std::strtoull(steam_id.data(), nullptr, 16);
 			if (xuid != key.get_hash())
 			{
 				network::send(*from, "error", "XUID doesn't match the certificate!", '\n');
 				return;
 			}

-			if (!key.is_valid() || !verify_message(key, challenge, info.signature()))
+			if (!key.is_valid() || !utils::cryptography::ecc::verify_message(key, challenge, info.signature()))
 			{
 				network::send(*from, "error", "Challenge signature was invalid!", '\n');
 				return;
@ -232,7 +290,7 @@ namespace auth
 				utils::hook::call(0x1402C4F8E, send_connect_data_stub);
 			}

-			command::add("guid", []
+			command::add("guid", []() -> void
 			{
 				console::info("Your guid: %llX\n", steam::SteamUser()->GetSteamID().bits);
 			});
--- a/src/client/component/binding.cpp
+++ b/src/client/component/binding.cpp
@ -25,9 +25,7 @@ namespace binding

 				if (value && value < 100)
 				{
-					const auto len = sprintf_s(&buffer[bytes_used], (buffer_size_align - bytes_used),
-					                           "bind %s \"%s\"\n", key_button, game::command_whitelist[value]);
-
+					const auto len = game::Com_sprintf(&buffer[bytes_used], (buffer_size_align - bytes_used), "bind %s \"%s\"\n", key_button, game::command_whitelist[value]);
 					if (len < 0)
 					{
 						return bytes_used;
@ -40,9 +38,7 @@ namespace binding
 					value -= 100;
 					if (static_cast<size_t>(value) < custom_binds.size() && !custom_binds[value].empty())
 					{
-						const auto len = sprintf_s(&buffer[bytes_used], (buffer_size_align - bytes_used),
-						                           "bind %s \"%s\"\n", key_button, custom_binds[value].data());
-
+						const auto len = game::Com_sprintf(&buffer[bytes_used], (buffer_size_align - bytes_used), "bind %s \"%s\"\n", key_button, custom_binds[value].data());
 						if (len < 0)
 						{
 							return bytes_used;
--- a/src/client/component/colors.cpp
+++ b/src/client/component/colors.cpp
@ -76,7 +76,16 @@ namespace colors

 		void com_clean_name_stub(const char* in, char* out, const int out_size)
 		{
-			strncpy_s(out, out_size, in, _TRUNCATE);
+			// Check that the name is at least 3 char without colors
+			char name[16]{};
+
+			game::I_strncpyz(out, in, std::min<int>(out_size, sizeof(name)));
+
+			utils::string::strip(out, name, std::strlen(out) + 1);
+			if (std::strlen(name) < 3)
+			{
+				game::I_strncpyz(out, "UnnamedPlayer", std::min<int>(out_size, sizeof(name)));
+			}
 		}

 		char* i_clean_str_stub(char* string)
@ -86,18 +95,31 @@ namespace colors
 			return string;
 		}

-		size_t get_client_name_stub(const int local_client_num, const int index, char* buf, const int size,
-		                            const size_t unk, const size_t unk2)
+		int cl_get_client_name_and_clan_tag_stub(const int local_client_num, const int index, char* name_buf, const int name_size, char* clan_tag_buf, int clan_tag_size)
 		{
-			// CL_GetClientName (CL_GetClientNameAndClantag?)
-			const auto result = reinterpret_cast<size_t(*)(int, int, char*, int, size_t, size_t)>(0x1402CF790)(
-				local_client_num, index, buf, size, unk, unk2);
+			// CL_GetClientNameAndClanTag -> CL_GetClientNameAndClanTagColorize
+			const auto result = utils::hook::invoke<int>(0x1402CF790, local_client_num, index, name_buf, name_size, clan_tag_buf, clan_tag_size);

-			utils::string::strip(buf, buf, size);
+			utils::string::strip(name_buf, name_buf, name_size);

 			return result;
 		}

+		int com_sprintf_stub(char* dest, int size, const char* fmt, const char* name)
+		{
+			const auto len = game::Com_sprintf(dest, size, fmt, name);
+			if (len < 0)
+			{
+				game::I_strncpyz(dest, "UnnamedAgent", size);
+				return len;
+			}
+
+			// This should inherit the name of the owner (a player) which already passed the length check in Com_CleanName
+			utils::string::strip(dest, dest, len + 1);
+
+			return len;
+		}
+
 		void rb_lookup_color_stub(const char index, DWORD* color)
 		{
 			*color = RGB(255, 255, 255);
@ -138,10 +160,15 @@ namespace colors
 			if (!game::environment::is_sp())
 			{
 				// allows colored name in-game
-				utils::hook::jump(0x1404F5FC0, com_clean_name_stub);
+				utils::hook::call(0x1403881CF, com_clean_name_stub);
+				utils::hook::call(0x140388224, com_clean_name_stub);

 				// don't apply colors to overhead names
-				utils::hook::call(0x14025CE79, get_client_name_stub);
+				utils::hook::call(0x14025CE79, cl_get_client_name_and_clan_tag_stub);
+
+				// don't apply colors to overhead names of agents (like dogs or juggernauts)
+				// hook Com_sprintf in CL_GetAgentName
+				utils::hook::call(0x1402CF760, com_sprintf_stub);

 				// patch I_CleanStr
 				utils::hook::jump(0x1404F63C0, i_clean_str_stub);
--- a/src/client/component/command.cpp
+++ b/src/client/component/command.cpp
@ -2,6 +2,7 @@
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
 #include "game/dvars.hpp"
+#include "game/engine/sv_game.hpp"

 #include "command.hpp"
 #include "console.hpp"
@ -459,10 +460,7 @@ namespace command
 				}

 				game::sp::g_entities[0].flags ^= game::FL_GODMODE;
-				game::CG_GameMessage(0, utils::string::va("godmode %s",
-				                                          game::sp::g_entities[0].flags & game::FL_GODMODE
-					                                          ? "^2on"
-					                                          : "^1off"));
+				game::CG_GameMessage(0, utils::string::va("godmode %s", game::sp::g_entities[0].flags & game::FL_GODMODE ? "^2on" : "^1off"));
 			});

 			add("notarget", []
@ -473,10 +471,7 @@ namespace command
 				}

 				game::sp::g_entities[0].flags ^= game::FL_NOTARGET;
-				game::CG_GameMessage(0, utils::string::va("notarget %s",
-				                                          game::sp::g_entities[0].flags & game::FL_NOTARGET
-					                                          ? "^2on"
-					                                          : "^1off"));
+				game::CG_GameMessage(0, utils::string::va("notarget %s", game::sp::g_entities[0].flags & game::FL_NOTARGET ? "^2on" : "^1off"));
 			});
 			
 			add("noclip", []
@ -487,10 +482,7 @@ namespace command
 				}

 				game::sp::g_entities[0].client->flags ^= 1;
-				game::CG_GameMessage(0, utils::string::va("noclip %s",
-				                                          game::sp::g_entities[0].client->flags & 1
-					                                          ? "^2on"
-					                                          : "^1off"));
+				game::CG_GameMessage(0, utils::string::va("noclip %s", game::sp::g_entities[0].client->flags & 1 ? "^2on" : "^1off"));
 			});

 			add("ufo", []
@ -501,10 +493,7 @@ namespace command
 				}

 				game::sp::g_entities[0].client->flags ^= 2;
-				game::CG_GameMessage(0, utils::string::va("ufo %s", 
-				                                          game::sp::g_entities[0].client->flags & 2 
-					                                          ? "^2on" 
-					                                          : "^1off"));
+				game::CG_GameMessage(0, utils::string::va("ufo %s", game::sp::g_entities[0].client->flags & 2 ? "^2on" : "^1off"));
 			});

 			add("give", [](const params& params)
@ -556,78 +545,65 @@ namespace command
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				game::mp::g_entities[client_num].flags ^= game::FL_GODMODE;
-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-				                               utils::string::va("f \"godmode %s\"",
-				                                                 game::mp::g_entities[client_num].flags & game::FL_GODMODE
-					                                                 ? "^2on"
-					                                                 : "^1off"));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, utils::string::va("f \"godmode %s\"", game::mp::g_entities[client_num].flags & game::FL_GODMODE ? "^2on" : "^1off"));
 			});

 			add_sv("notarget", [](const int client_num, const params_sv&)
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				game::mp::g_entities[client_num].flags ^= game::FL_NOTARGET;
-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-				                               utils::string::va("f \"notarget %s\"",
-				     	                                         game::mp::g_entities[client_num].flags & game::FL_NOTARGET 
-					                    	                         ? "^2on" 
-				                    		                         : "^1off"));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
+				                                       utils::string::va("f \"notarget %s\"", game::mp::g_entities[client_num].flags & game::FL_NOTARGET ? "^2on" : "^1off"));
 			});

 			add_sv("noclip", [](const int client_num, const params_sv&)
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				game::mp::g_entities[client_num].client->flags ^= 1;
-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-				                               utils::string::va("f \"noclip %s\"",
-				                                                 game::mp::g_entities[client_num].client->flags & 1
-					                                                 ? "^2on"
-					                                                 : "^1off"));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
+				                                       utils::string::va("f \"noclip %s\"", game::mp::g_entities[client_num].client->flags & 1 ? "^2on" : "^1off"));
 			});

 			add_sv("ufo", [](const int client_num, const params_sv&)
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				game::mp::g_entities[client_num].client->flags ^= 2;
-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-				                               utils::string::va("f \"ufo %s\"",
-				                                                 game::mp::g_entities[client_num].client->flags & 2
-					                                                 ? "^2on"
-					                                                 : "^1off"));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
+				                                       utils::string::va("f \"ufo %s\"", game::mp::g_entities[client_num].client->flags & 2 ? "^2on" : "^1off"));
 			});

 			add_sv("setviewpos", [](const int client_num, const params_sv& params)
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				if (params.size() < 4)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-					                               "f \"You did not specify the correct number of coordinates\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
+					                                       "f \"You did not specify the correct number of coordinates\"");
 					return;
 				}

@ -640,14 +616,14 @@ namespace command
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				if (params.size() < 4)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
-					                               "f \"You did not specify the correct number of coordinates\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE,
+					                                       "f \"You did not specify the correct number of coordinates\"");
 					return;
 				}

@ -660,13 +636,13 @@ namespace command
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				if (params.size() < 2)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
 					return;
 				}

@ -683,13 +659,13 @@ namespace command
 			{
 				if (!dvars::sv_cheats->current.enabled)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
 					return;
 				}

 				if (params.size() < 2)
 				{
-					game::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
+					game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
 					return;
 				}

--- a/src/client/component/console.cpp
+++ b/src/client/component/console.cpp
@ -84,15 +84,14 @@ namespace console

 		void print_stub(const char* fmt, ...)
 		{
+			char buffer[4096]{};
+
 			va_list ap;
 			va_start(ap, fmt);
-
-			char buffer[4096]{};
-			const auto res = vsnprintf_s(buffer, _TRUNCATE, fmt, ap);
-			(void)res;
-			print_message(buffer);
-
+			[[maybe_unused]] const auto len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
 			va_end(ap);
+
+			print_message(buffer);			
 		}

 		void append_text(const char* text)
--- a/src/client/component/dedicated.cpp
+++ b/src/client/component/dedicated.cpp
@ -198,25 +198,6 @@ namespace dedicated
 			return hwnd;
 		}

-		void sys_error_stub(const char* msg, ...)
-		{
-			char buffer[2048]{};
-
-			va_list ap;
-			va_start(ap, msg);
-
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
-
-			va_end(ap);
-
-			scheduler::once([]()
-			{
-				command::execute("map_rotate");
-			}, scheduler::pipeline::main, 3s);
-
-			game::Com_Error(game::ERR_DROP, "%s", buffer);
-		}
-
 		void add_commands()
 		{
 			command::add("map", [](const command::params& params)
@ -364,9 +345,6 @@ namespace dedicated
 			utils::hook::nop(0x1404F8BE1, 2); // ^
 			utils::hook::set<uint8_t>(0x140328660, 0xC3); // Disable image pak file loading

-			// Stop crashing from sys_errors
-			utils::hook::jump(0x1404FF510, sys_error_stub);
-
 			// Reduce min required memory
 			utils::hook::set<uint64_t>(0x1404FA6BD, 0x80000000);
 			utils::hook::set<uint64_t>(0x1404FA76F, 0x80000000);
--- a/src/client/component/dedicated_info.cpp
+++ b/src/client/component/dedicated_info.cpp
@ -56,8 +56,7 @@ namespace dedicated_info

 				std::string cleaned_hostname = sv_hostname->current.string;

-				utils::string::strip(sv_hostname->current.string, cleaned_hostname.data(),
-					cleaned_hostname.size() + 1);
+				utils::string::strip(sv_hostname->current.string, cleaned_hostname.data(), cleaned_hostname.size() + 1);

 				console::set_title(utils::string::va("%s on %s [%d/%d] (%d)", cleaned_hostname.data(),
 				                                     mapname->current.string, client_count,
--- a/src/client/component/demonware.cpp
+++ b/src/client/component/demonware.cpp
@ -222,7 +222,7 @@ namespace demonware
 			va_list ap;
 			va_start(ap, msg);

-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
+			vsnprintf(buffer, sizeof(buffer), msg, ap);
 			printf("%s: %s\n", function, buffer);

 			va_end(ap);
--- a/src/client/component/dvar_cheats.cpp
+++ b/src/client/component/dvar_cheats.cpp
@ -1,8 +1,8 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
-
 #include "game/game.hpp"
 #include "game/dvars.hpp"
+#include "game/engine/sv_game.hpp"

 #include "console.hpp"

@ -11,7 +11,7 @@

 namespace dvar_cheats
 {
-	void apply_sv_cheats(const game::dvar_t* dvar, const game::DvarSetSource source, game::dvar_value* value)
+	void apply_sv_cheats(const game::dvar_t* dvar, const game::DvarSetSource source, game::DvarValue* value)
 	{
 		if (dvar && dvar->name == "sv_cheats"s)
 		{
@ -136,7 +136,7 @@ namespace dvar_cheats
 		const auto* dvar = game::Scr_GetString(0); // grab the original dvar again since it's never stored on stack
 		const auto* command = utils::string::va("q %s \"%s\"", dvar, value);

-		game::SV_GameSendServerCommand(entity_num, game::SV_CMD_RELIABLE, command);
+		game::engine::SV_GameSendServerCommand(entity_num, game::SV_CMD_RELIABLE, command);
 	}

 	const auto player_cmd_set_client_dvar = utils::hook::assemble([](utils::hook::assembler& a)
--- a/src/client/component/fastfiles.cpp
+++ b/src/client/component/fastfiles.cpp
@ -7,10 +7,10 @@
 #include "console.hpp"
 #include "fastfiles.hpp"

-
 #include <utils/hook.hpp>
-#include <utils/memory.hpp>
 #include <utils/io.hpp>
+#include <utils/memory.hpp>
+#include <utils/string.hpp>

 namespace fastfiles
 {
@ -32,6 +32,12 @@ namespace fastfiles
 				return;
 			}

+			const auto out_name = std::format("gsc_dump/{}.gscbin", name);
+			if (utils::io::file_exists(out_name))
+			{
+				return;
+			}
+
 			std::string buffer;
 			buffer.append(header.scriptfile->name, std::strlen(header.scriptfile->name) + 1);
 			buffer.append(reinterpret_cast<char*>(&header.scriptfile->compressedLen), 4);
@ -40,12 +46,38 @@ namespace fastfiles
 			buffer.append(header.scriptfile->buffer, header.scriptfile->compressedLen);
 			buffer.append(reinterpret_cast<char*>(header.scriptfile->bytecode), header.scriptfile->bytecodeLen);

-			const auto out_name = std::format("gsc_dump/{}.gscbin", name);
 			utils::io::write_file(out_name, buffer);

-			console::info("Dumped %s\n", out_name.data());
+			console::info("Dumped %s\n", out_name.c_str());
 		}

+		void dump_csv_table(const std::string& name, game::XAssetHeader header)
+		{
+			if (!dvars::g_dump_string_tables->current.enabled)
+			{
+				return;
+			}
+
+			const auto out_name = std::format("csv_dump/{}.csv", name);
+			if (utils::io::file_exists(out_name))
+			{
+				return;
+			}
+
+			std::string buffer;
+
+			for (auto row = 0; row < header.stringTable->rowCount; row++)
+			{
+				for (auto column = 0; column < header.stringTable->columnCount; column++)
+				{
+					const auto* string = header.stringTable->values[(row * header.stringTable->columnCount) + column].string;
+					buffer.append(utils::string::va("%s%s", string ? string : "", (column == header.stringTable->columnCount - 1) ? "\n" : ","));
+				}
+			}
+
+			utils::io::write_file(out_name, buffer);
+			console::info("Dumped %s\n", out_name.c_str());
+		}

 		game::XAssetHeader db_find_x_asset_header_stub(game::XAssetType type, const char* name, int allow_create_default)
 		{
@ -58,6 +90,11 @@ namespace fastfiles
 				dump_gsc_script(name, result);
 			}

+			if (type == game::ASSET_TYPE_STRINGTABLE)
+			{
+				dump_csv_table(name, result);
+			}
+
 			if (diff > 100)
 			{
 				console::print(
@ -110,14 +147,11 @@ namespace fastfiles

 			db_find_x_asset_header_hook.create(game::DB_FindXAssetHeader, db_find_x_asset_header_stub);
 			dvars::g_dump_scripts = game::Dvar_RegisterBool("g_dumpScripts", false, game::DVAR_FLAG_NONE, "Dump GSC scripts to binary format");
+			dvars::g_dump_string_tables = game::Dvar_RegisterBool("g_dumpStringTables", false, game::DVAR_FLAG_NONE, "Dump CSV files");

 			utils::hook::call(SELECT_VALUE(0x1402752DF, 0x140156350), p_mem_free_stub);
 			utils::hook::call(SELECT_VALUE(0x140276004, 0x140324259), p_mem_free_stub);

-			// Allow loading of unsigned fastfiles
-			utils::hook::set<uint8_t>(0x1402FBF23, 0xEB); // DB_LoadXFile
-			utils::hook::nop(0x1402FC445, 2); // DB_SetFileLoadCompressor
-
 			command::add("materiallist", [](const command::params& params)
 			{
 				game::DB_EnumXAssets_FastFile(game::ASSET_TYPE_MATERIAL, [](const game::XAssetHeader header, void*)
@ -132,6 +166,10 @@ namespace fastfiles
 			if (!game::environment::is_sp())
 			{
 				reallocate_asset_pool(game::ASSET_TYPE_WEAPON, 320);
+
+				// Allow loading of unsigned fastfiles
+				utils::hook::set<uint8_t>(0x1402FBF23, 0xEB); // DB_LoadXFile
+				utils::hook::nop(0x1402FC445, 2); // DB_SetFileLoadCompressor
 			}
 		}
 	};
--- a/src/client/component/filesystem.cpp
+++ b/src/client/component/filesystem.cpp
@ -83,20 +83,22 @@ namespace filesystem

 		void startup()
 		{
-			register_path("iw6");
+			const auto base = std::filesystem::current_path();
+
+			register_path(base / "iw6");
 			register_path(get_binary_directory() + "\\data");

-			if (get_binary_directory() != std::filesystem::current_path())
+			if (get_binary_directory() != base)
 			{
-				register_path(std::filesystem::current_path() / "data");
+				register_path(base / "data");
 			}

 			// game's search paths
-			register_path("devraw");
-			register_path("devraw_shared");
-			register_path("raw_shared");
-			register_path("raw");
-			register_path("main");
+			register_path(base / "devraw");
+			register_path(base / "devraw_shared");
+			register_path(base / "raw_shared");
+			register_path(base / "raw");
+			register_path(base / "main");
 		}

 		void check_for_startup()
--- a/src/client/component/game_console.cpp
+++ b/src/client/component/game_console.cpp
@ -63,7 +63,7 @@ namespace game_console

 		void clear()
 		{
-			strncpy_s(con.buffer, "", sizeof(con.buffer));
+			game::I_strncpyz(con.buffer, "", sizeof(con.buffer));
 			con.cursor = 0;

 			fixed_input = "";
@ -249,7 +249,7 @@ namespace game_console
 					               dvars::con_inputDvarInactiveValueColor->current.vector, offset);
 				}

-				strncpy_s(con.globals.auto_complete_choice, matches[0].data(), sizeof(con.globals.auto_complete_choice));
+				game::I_strncpyz(con.globals.auto_complete_choice, matches[0].data(), sizeof(con.globals.auto_complete_choice));
 				con.globals.may_auto_complete = true;
 			}
 			else if (matches.size() > 1)
@ -274,7 +274,7 @@ namespace game_console
 					}
 				}

-				strncpy_s(con.globals.auto_complete_choice, matches[0].data(), sizeof(con.globals.auto_complete_choice));
+				game::I_strncpyz(con.globals.auto_complete_choice, matches[0].data(), sizeof(con.globals.auto_complete_choice));
 				con.globals.may_auto_complete = true;
 			}
 		}
@ -364,11 +364,11 @@ namespace game_console

 	void print_internal(const char* fmt, ...)
 	{
-		char va_buffer[0x200] = { 0 };
+		char va_buffer[1024]{};

 		va_list ap;
 		va_start(ap, fmt);
-		vsprintf_s(va_buffer, fmt, ap);
+		vsnprintf(va_buffer, sizeof(va_buffer), fmt, ap);
 		va_end(ap);

 		const auto formatted = std::string(va_buffer);
@ -424,7 +424,7 @@ namespace game_console
 						con.buffer[1] = '\0';
 					}

-					strncat_s(con.buffer, con.globals.auto_complete_choice, 64);
+					game::I_strncat(con.buffer, sizeof(con.buffer), con.globals.auto_complete_choice);
 					con.cursor = static_cast<int>(std::string(con.buffer).length());

 					if (con.cursor != 254)
@ -549,7 +549,7 @@ namespace game_console

 					if (history_index != -1)
 					{
-						strncpy_s(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
+						game::I_strncpyz(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
 						con.cursor = static_cast<int>(strlen(con.buffer));
 					}
 				}
@ -564,7 +564,7 @@ namespace game_console

 					if (history_index != -1)
 					{
-						strncpy_s(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
+						game::I_strncpyz(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
 						con.cursor = static_cast<int>(strlen(con.buffer));
 					}
 				}
@ -721,7 +721,7 @@ namespace game_console
 			con.output_visible = false;
 			con.display_line_offset = 0;
 			con.line_count = 0;
-			strncpy_s(con.buffer, "", sizeof(con.buffer));
+			game::I_strncpyz(con.buffer, "", sizeof(con.buffer));

 			con.globals.x = 0.0f;
 			con.globals.y = 0.0f;
@ -729,7 +729,7 @@ namespace game_console
 			con.globals.font_height = 0.0f;
 			con.globals.may_auto_complete = false;
 			con.globals.info_line_count = 0;
-			strncpy_s(con.globals.auto_complete_choice, "", sizeof(con.globals.auto_complete_choice));
+			game::I_strncpyz(con.globals.auto_complete_choice, "", sizeof(con.globals.auto_complete_choice));

 			// add clear command
 			command::add("clear", [&]()
--- a/src/client/component/game_log.cpp
+++ b/src/client/component/game_log.cpp
@ -3,12 +3,10 @@
 #include "game/game.hpp"
 #include "game/dvars.hpp"

-#include "scheduler.hpp"
-#include "scripting.hpp"
 #include "console.hpp"
 #include "game_log.hpp"
-
-#include "gsc/script_extension.hpp"
+#include "scheduler.hpp"
+#include "scripting.hpp"

 #include <utils/hook.hpp>
 #include <utils/io.hpp>
@ -23,7 +21,7 @@ namespace game_log
 			char buf[1024]{};
 			std::size_t out_chars = 0;

-			for (auto i = 0u; i < game::Scr_GetNumParam(); ++i)
+			for (std::uint32_t i = 0; i < game::Scr_GetNumParam(); ++i)
 			{
 				const auto* value = game::Scr_GetString(i);
 				const auto len = std::strlen(value);
@ -34,7 +32,7 @@ namespace game_log
 					break;
 				}

-				strncat_s(buf, value, _TRUNCATE);
+				game::I_strncat(buf, sizeof(buf), value);
 			}

 			g_log_printf("%s", buf);
@ -49,22 +47,15 @@ namespace game_log
 			return;
 		}

-		char buffer[0x400]{};
+		char buffer[1024]{};

 		va_list ap;
 		va_start(ap, fmt);
-
-		vsprintf_s(buffer, fmt, ap);
-
+		vsnprintf(buffer, sizeof(buffer), fmt, ap);
 		va_end(ap);

 		const auto time = *game::level_time / 1000;
-		utils::io::write_file(log, utils::string::va("%3i:%i%i %s",
-			time / 60,
-			time % 60 / 10,
-			time % 60 % 10,
-			buffer
-		), true);
+		utils::io::write_file(log, utils::string::va("%3i:%i%i %s", time / 60, time % 60 / 10, time % 60 % 10, buffer), true);
 	}

 	class component final : public component_interface
--- a/src/client/component/gsc/script_extension.cpp
+++ b/src/client/component/gsc/script_extension.cpp
@ -293,6 +293,17 @@ namespace gsc
 			game::Scr_AddInt(game::environment::is_dedi());
 		}

+		void scr_bot_auto_connect_enabled()
+		{
+			if (game::environment::is_dedi() && dvars::sv_botsAutoJoin->current.enabled)
+			{
+				game::Scr_AddInt(1); // 2 seems to be unused (incomplete GSC/game mode)
+				return;
+			}
+
+			game::Scr_AddInt(game::BG_BotsConnectType());
+		}
+
 		const char* get_code_pos(const int index)
 		{
 			if (static_cast<unsigned int>(index) >= game::scr_VmPub->outparamcount)
@ -391,6 +402,9 @@ namespace gsc
 			utils::hook::set<game::BuiltinFunction>(0x1409E6E20, assert_cmd);

 			utils::hook::set<game::BuiltinFunction>(0x1409E94D0, scr_cmd_is_dedicated_server);
+
+			dvars::sv_botsAutoJoin = game::Dvar_RegisterBool("sv_botsAutoJoin", false, game::DVAR_FLAG_NONE, "");
+			utils::hook::set<game::BuiltinFunction>(0x1409E92F0, scr_bot_auto_connect_enabled);
 		}
 	};
 }
--- a/src/client/component/gsc/script_loading.cpp
+++ b/src/client/component/gsc/script_loading.cpp
@ -403,7 +403,7 @@ namespace gsc
 	public:
 		loading()
 		{
-			gsc_ctx = std::make_unique<xsk::gsc::iw6_pc::context>();
+			gsc_ctx = std::make_unique<xsk::gsc::iw6_pc::context>(xsk::gsc::instance::server);
 		}

 		void post_unpack() override
--- a/src/client/component/logger.cpp
+++ b/src/client/component/logger.cpp
@ -10,43 +10,15 @@ namespace logger
 {
 	namespace
 	{
-		utils::hook::detour com_error_hook;
-
 		const game::dvar_t* logger_dev = nullptr;

-		void print_com_error(int, const char* msg, ...)
-		{
-			char buffer[2048]{};
-			va_list ap;
-
-			va_start(ap, msg);
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
-			va_end(ap);
-
-			console::error("%s", buffer);
-		}
-
-		void com_error_stub(const int error, const char* msg, ...)
-		{
-			char buffer[2048]{};
-			va_list ap;
-
-			va_start(ap, msg);
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
-			va_end(ap);
-
-			console::error("Error: %s\n", buffer);
-
-			com_error_hook.invoke<void>(error, "%s", buffer);
-		}
-
 		void print_warning(const char* msg, ...)
 		{
 			char buffer[2048]{};
 			va_list ap;

 			va_start(ap, msg);
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
+			vsnprintf(buffer, sizeof(buffer), msg, ap);
 			va_end(ap);

 			console::warn("%s", buffer);
@ -58,7 +30,7 @@ namespace logger
 			va_list ap;

 			va_start(ap, msg);
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
+			vsnprintf(buffer, sizeof(buffer), msg, ap);
 			va_end(ap);

 			console::info("%s", buffer);
@ -75,7 +47,7 @@ namespace logger
 			va_list ap;

 			va_start(ap, msg);
-			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
+			vsnprintf(buffer, sizeof(buffer), msg, ap);
 			va_end(ap);

 			console::info("%s", buffer);
@ -141,13 +113,6 @@ namespace logger
 				sub_1401DAA40();
 			}

-			if (!game::environment::is_sp())
-			{
-				utils::hook::call(0x140501AE3, print_com_error);
-			}
-
-			com_error_hook.create(game::Com_Error, com_error_stub);
-
 			// Make havok script's print function actually print
 			utils::hook::jump(SELECT_VALUE(0x1406283A4, 0x140732184), print);

--- a/src/client/component/map_rotation.cpp
+++ b/src/client/component/map_rotation.cpp
@ -99,7 +99,7 @@ namespace map_rotation
 				console::error("%s: %s contains invalid data!\n", ex.what(), sv_map_rotation->name);
 			}
 #ifdef _DEBUG
-			console::info("dedicated_rotation size after parsing is '%llu'", dedicated_rotation.get_entries_size());
+			console::info("dedicated_rotation size after parsing is '%llu'\n", dedicated_rotation.get_entries_size());
 #endif
 		}

--- a/src/client/component/mods.cpp
+++ b/src/client/component/mods.cpp
@ -3,9 +3,12 @@
 #include "game/game.hpp"
 #include "game/dvars.hpp"

+#include "command.hpp"
+#include "console.hpp"
 #include "mods.hpp"

 #include <utils/hook.hpp>
+#include <utils/string.hpp>

 namespace mods
 {
@ -13,24 +16,24 @@ namespace mods
 	{
 		utils::hook::detour sys_create_file_hook;

-		void db_build_os_path_from_source(const char* zone_name, game::FF_DIR source, unsigned int size, char* filename)
+		void db_build_os_path_from_source(const char* zone_name, game::FF_DIR source, int size, char* filename)
 		{
 			char user_map[MAX_PATH]{};

 			switch (source)
 			{
 			case game::FFD_DEFAULT:
-				(void)sprintf_s(filename, size, "%s\\%s.ff", std::filesystem::current_path().string().c_str(), zone_name);
+				(void)game::Com_sprintf(filename, size, "%s\\%s.ff", std::filesystem::current_path().string().c_str(), zone_name);
 				break;
 			case game::FFD_MOD_DIR:
 				assert(mods::is_using_mods());

-				(void)sprintf_s(filename, size, "%s\\%s\\%s.ff", std::filesystem::current_path().string().c_str(), (*dvars::fs_gameDirVar)->current.string, zone_name);
+				(void)game::Com_sprintf(filename, size, "%s\\%s\\%s.ff", std::filesystem::current_path().string().c_str(), (*dvars::fs_gameDirVar)->current.string, zone_name);
 				break;
 			case game::FFD_USER_MAP:
-				strncpy_s(user_map, zone_name, _TRUNCATE);
+				game::I_strncpyz(user_map, zone_name, sizeof(user_map));

-				(void)sprintf_s(filename, size, "%s\\%s\\%s\\%s.ff", std::filesystem::current_path().string().c_str(), "usermaps", user_map, zone_name);
+				(void)game::Com_sprintf(filename, size, "%s\\%s\\%s\\%s.ff", std::filesystem::current_path().string().c_str(), "usermaps", user_map, zone_name);
 				break;
 			default:
 				assert(false && "inconceivable");
@ -98,6 +101,40 @@ namespace mods
 			a.and_(ebp, r15d);
 			a.jmp(0x1403217F6);
 		});
+
+		bool fs_game_dir_domain_func(game::dvar_t* dvar, game::DvarValue new_value)
+		{
+			if (*new_value.string == '\0')
+			{
+				return true;
+			}
+
+			if (game::I_strnicmp(new_value.string, "mods", 4) != 0)
+			{
+				game::LiveStorage_StatsWriteNotNeeded(game::CONTROLLER_INDEX_0);
+				console::error("ERROR: Invalid server value '%s' for '%s'\n", new_value.string, dvar->name);
+				return false;
+			}
+
+			if (5 < std::strlen(new_value.string) && (new_value.string[4] == '\\' || new_value.string[4] == '/'))
+			{
+				const auto* s1 = std::strstr(new_value.string, "..");
+				const auto* s2 = std::strstr(new_value.string, "::");
+				if (s1 == nullptr && s2 == nullptr)
+				{
+					return true;
+				}
+
+				game::LiveStorage_StatsWriteNotNeeded(game::CONTROLLER_INDEX_0);
+				console::error("ERROR: Invalid server value '%s' for '%s'\n", new_value.string, dvar->name);
+				return false;
+			}
+
+			// Invalid path specified
+			game::LiveStorage_StatsWriteNotNeeded(game::CONTROLLER_INDEX_0);
+			console::error("ERROR: Invalid server value '%s' for '%s'\n", new_value.string, dvar->name);
+			return false;
+		}
 	}

 	bool is_using_mods()
@ -136,6 +173,8 @@ namespace mods
 			// Remove DVAR_INIT from fs_game
 			utils::hook::set<std::uint32_t>(SELECT_VALUE(0x14041C085 + 2, 0x1404DDA45 + 2), SELECT_VALUE(game::DVAR_FLAG_NONE, game::DVAR_FLAG_SERVERINFO));

+			utils::hook::inject(SELECT_VALUE(0x14041C097 + 3, 0x1404DDA57 + 3), &fs_game_dir_domain_func);
+
 			if (game::environment::is_sp())
 			{
 				return;
@ -150,6 +189,44 @@ namespace mods

 			// Load mod.ff
 			utils::hook::call(0x1405E7113, db_load_x_assets_stub); // R_LoadGraphicsAssets According to myself but I don't remember where I got it from
+
+			command::add("loadmod", [](const command::params& params) -> void
+			{
+				if (params.size() != 2)
+				{
+					console::info("USAGE: %s \"mods/<mod name>\"", params.get(0));
+					return;
+				}
+
+				std::string mod_name = utils::string::to_lower(params.get(1));
+
+				if (!mod_name.empty() && !mod_name.starts_with("mods/"))
+				{
+					mod_name = "mods/" + mod_name;
+				}
+
+				// change fs_game if needed
+				if (mod_name != (*dvars::fs_gameDirVar)->current.string)
+				{
+					game::Dvar_SetString((*dvars::fs_gameDirVar), mod_name.c_str());
+					command::execute("vid_restart\n");
+				}
+			});
+
+			command::add("unloadmod", [](const command::params& params) -> void
+			{
+				if (*dvars::fs_gameDirVar == nullptr || *(*dvars::fs_gameDirVar)->current.string == '\0')
+				{
+					return;
+				}
+
+				game::Dvar_SetString(*dvars::fs_gameDirVar, "");
+				command::execute("vid_restart\n");
+			});
+
+			// TODO: without a way to monitor all the ways fs_game can be changed there is no way to detect when we
+			// should unregister the path from the internal filesystem we use
+			// HINT: It could be done in fs_game_dir_domain_func, but I haven't tested if that's the best place to monitor for changes and register/unregister the mods folder
 		}
 	};
 }
--- a/src/client/component/party.cpp
+++ b/src/client/component/party.cpp
@ -2,6 +2,7 @@
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
 #include "game/dvars.hpp"
+#include "game/engine/sv_game.hpp"

 #include "command.hpp"
 #include "console.hpp"
@ -180,18 +181,21 @@ namespace party
 	{
 		for (auto i = 0; !name.empty() && i < *game::mp::svs_clientCount; ++i)
 		{
-			if (game::mp::g_entities[i].client)
+			if (!game::mp::g_entities[i].client)
 			{
-				char client_name[16] = {0};
-				strncpy_s(client_name, game::mp::g_entities[i].client->sess.cs.name, sizeof(client_name));
-				game::I_CleanStr(client_name);
+				continue;
+			}

-				if (client_name == name)
-				{
-					return i;
-				}
+			char client_name[16]{};
+			game::I_strncpyz(client_name, game::mp::g_entities[i].client->sess.cs.name, sizeof(client_name));
+			game::I_CleanStr(client_name);
+
+			if (client_name == name)
+			{
+				return i;
 			}
 		}
+
 		return -1;
 	}

@ -380,7 +384,7 @@ namespace party
 				const auto message = params.join(2);
 				const auto* const name = game::Dvar_FindVar("sv_sayName")->current.string;

-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
 				console::info("%s -> %i: %s\n", name, client_num, message.data());
 			});

@ -394,7 +398,7 @@ namespace party
 				const auto client_num = atoi(params.get(1));
 				const auto message = params.join(2);

-				game::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.data()));
+				game::engine::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.data()));
 				console::info("%i: %s\n", client_num, message.data());
 			});

@ -408,7 +412,7 @@ namespace party
 				const auto message = params.join(1);
 				const auto* const name = game::Dvar_FindVar("sv_sayName")->current.string;

-				game::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
+				game::engine::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
 				console::info("%s: %s\n", name, message.data());
 			});

@ -421,7 +425,7 @@ namespace party

 				const auto message = params.join(1);

-				game::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.data()));
+				game::engine::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.data()));
 				console::info("%s\n", message.data());
 			});

--- a/src/client/component/patches.cpp
+++ b/src/client/component/patches.cpp
@ -2,6 +2,7 @@
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
 #include "game/dvars.hpp"
+#include "game/engine/sv_game.hpp"

 #include "command.hpp"
 #include "console.hpp"
@ -72,8 +73,10 @@ namespace patches
 			if (exec_params.size() == 2)
 			{
 				std::string file_name = exec_params.get(1);
-				if (file_name.find(".cfg") == std::string::npos)
+				if (!file_name.ends_with(".cfg"))
+				{
 					file_name.append(".cfg");
+				}

 				const auto file = filesystem::file(file_name);
 				if (file.exists())
@ -290,6 +293,12 @@ namespace patches

 		static void patch_mp()
 		{
+			// Bypass Arxan function
+			utils::hook::nop(0x1404758C0, 16);
+			utils::hook::jump(0x1404758C0, game::engine::SV_GameSendServerCommand, true);
+
+			utils::hook::call(0x140477399, game::engine::SV_SendServerCommand);
+
 			// Register dvars
 			com_register_dvars_hook.create(0x140413A90, &com_register_dvars_stub);

@ -326,6 +335,10 @@ namespace patches
 			dvars::override::register_int("igs_s1", 1, 0, 1, 0);
 			dvars::override::register_int("igs_crossgame", 1, 0, 1, 0);

+			// Required by UI scripts. Missing when joining a dedi and causes crashes
+			game::Dvar_RegisterInt("scr_gun_winlimit", 1, 0, 10, game::DVAR_FLAG_REPLICATED, "Win limit for Gun Game");
+			game::Dvar_RegisterInt("scr_gun_scorelimit", 18, 1, 1000, game::DVAR_FLAG_REPLICATED, "Score limit for Gun Game");
+
 			// Patch game chat on resolutions higher than 1080p to use the right font
 			utils::hook::call(0x14025C825, get_chat_font_handle);
 			utils::hook::call(0x1402BC42F, get_chat_font_handle);
@ -357,6 +370,9 @@ namespace patches
 			utils::hook::nop(0x1403A1A0F, 1);
 			// ^^
 			utils::hook::nop(0x1403A072F, 5); // LiveStorage_RecordMovementInMatchdata
+
+			// Disable Com_Error in NET_SendPacket
+			utils::hook::nop(0x140501AE3, 5);
 		}

 		static void patch_sp()
--- a/src/client/component/rcon.cpp
+++ b/src/client/component/rcon.cpp
@ -53,23 +53,25 @@ namespace rcon
 				const auto client = &game::mp::svs_clients[i];
 				auto self = &game::mp::g_entities[i];

+				if (client->header.state == game::CS_FREE || !self || !self->client)
+				{
+					continue;
+				}
+
 				char clean_name[32]{};
-				strncpy_s(clean_name, self->client->sess.cs.name, sizeof(clean_name));
+				game::I_strncpyz(clean_name, self->client->sess.cs.name, sizeof(clean_name));
 				game::I_CleanStr(clean_name);
 				
-				if (client->header.state > game::CS_FREE && self && self->client)
-				{
-					buffer.append(utils::string::va("%3i %5i %3s %s %32s %16s %21s %5i\n",
-					                                i,
-					                                self->client->sess.scores.score,
-					                                game::SV_BotIsBot(i) ? "Yes" : "No",
-					                                (client->header.state == game::CS_RECONNECTING) ? "CNCT" : (client->header.state == game::CS_ZOMBIE) ? "ZMBI" : utils::string::va("%4i", client->ping),
-					                                game::SV_GetGuid(i),
-					                                clean_name,
-					                                network::net_adr_to_string(client->header.netchan.remoteAddress),
-					                                client->header.netchan.remoteAddress.port)
-					);
-				}
+				buffer.append(utils::string::va("%3i %5i %3s %s %32s %16s %21s %5i\n",
+				                                i,
+				                                self->client->sess.scores.score,
+				                                game::SV_BotIsBot(i) ? "Yes" : "No",
+				                                (client->header.state == game::CS_RECONNECTING) ? "CNCT" : (client->header.state == game::CS_ZOMBIE) ? "ZMBI" : utils::string::va("%4i", client->ping),
+				                                game::SV_GetGuid(i),
+				                                clean_name,
+				                                network::net_adr_to_string(client->header.netchan.remoteAddress),
+				                                client->header.netchan.remoteAddress.port)
+				);
 			}

 			return buffer;
--- a/src/client/component/security.cpp
+++ b/src/client/component/security.cpp
@ -10,6 +10,8 @@ namespace security
 {
 	namespace
 	{
+		utils::hook::detour ui_replace_directive_hook;
+
 		void set_cached_playerdata_stub(const int localclient, const int index1, const int index2)
 		{
 			if (index1 >= 0 && index1 < 18 && index2 >= 0 && index2 < 42)
@ -30,6 +32,71 @@ namespace security

 			utils::hook::invoke<void>(0x140472500, client, msg);
 		}
+
+		void ui_replace_directive_stub(const int local_client_num, const char* src_string, char* dst_string, const int dst_buffer_size)
+		{
+			assert(src_string);
+			if (!src_string)
+			{
+				return;
+			}
+
+			assert(dst_string);
+			if (!dst_string)
+			{
+				return;
+			}
+
+			assert(dst_buffer_size > 0);
+			if (dst_buffer_size <= 0)
+			{
+				return;
+			}
+
+			constexpr std::size_t MAX_HUDELEM_TEXT_LEN = 0x100;
+			if (std::strlen(src_string) > MAX_HUDELEM_TEXT_LEN)
+			{
+				return;
+			}
+
+			ui_replace_directive_hook.invoke<void>(local_client_num, src_string, dst_string, dst_buffer_size);
+		}
+
+		int hud_elem_set_enum_string_stub(char* string, const char* format, ...)
+		{
+			va_list ap;
+			va_start(ap, format);
+			const auto len = vsnprintf(string, 0x800, format, ap);
+			va_end(ap);
+
+			string[0x800 - 1] = '\0';
+
+			return len;
+		}
+
+		int sv_add_bot_stub(char* string, const char* format, ...)
+		{
+			va_list ap;
+			va_start(ap, format);
+			const auto len = vsnprintf(string, 0x400, format, ap);
+			va_end(ap);
+
+			string[0x400 - 1] = '\0';
+
+			return len;
+		}
+
+		int sv_add_test_client_stub(char* string, const char* format, ...)
+		{
+			va_list ap;
+			va_start(ap, format);
+			const auto len = vsnprintf(string, 0x400, format, ap);
+			va_end(ap);
+
+			string[0x400 - 1] = '\0';
+
+			return len;
+		}
 	}

 	class component final : public component_interface
@ -37,13 +104,22 @@ namespace security
 	public:
 		void post_unpack() override
 		{
+			// sprinf
+			utils::hook::call(SELECT_VALUE(0x140310D0F, 0x140399B0F), hud_elem_set_enum_string_stub);
+
 			if (game::environment::is_sp()) return;

 			// Patch vulnerability in PlayerCards_SetCachedPlayerData
 			utils::hook::call(0x140287C5C, set_cached_playerdata_stub);

+			// sprinf
+			utils::hook::call(0x140470A88, sv_add_bot_stub);
+			utils::hook::call(0x140470F68, sv_add_test_client_stub);
+
 			// It is possible to make the server hang if left unchecked
 			utils::hook::call(0x14047A29A, sv_execute_client_message_stub);
+
+			ui_replace_directive_hook.create(0x1404D8A00, ui_replace_directive_stub);
 		}
 	};
 }
--- a/src/client/component/steam_proxy.cpp
+++ b/src/client/component/steam_proxy.cpp
@ -26,6 +26,8 @@ namespace steam_proxy
 		ownership_state state_;

 		utils::binary_resource runner_file(RUNNER, "runner.exe");
+
+		bool is_disabled() { return true; }
 	}

 	class component final : public component_interface
@ -33,7 +35,7 @@ namespace steam_proxy
 	public:
 		void post_load() override
 		{
-			if (game::environment::is_dedi())
+			if (game::environment::is_dedi() || is_disabled())
 			{
 				return;
 			}
--- a/src/client/component/ui_scripting.cpp
+++ b/src/client/component/ui_scripting.cpp
@ -195,6 +195,27 @@ namespace ui_scripting
 			setup_functions();

 			lua["print"] = function(reinterpret_cast<game::hks::lua_function>(0x14017B120)); // hks::base_print
+
+			lua["directoryexists"] = [](const std::string& string)
+			{
+				return utils::io::directory_exists(string);
+			};
+
+			lua["listfiles"] = [](const std::string& string)
+			{
+				return utils::io::list_files(string);
+			};
+
+			lua["directoryisempty"] = [](const std::string& string)
+			{
+				return utils::io::directory_is_empty(string);
+			};
+
+			lua["fileexists"] = [](const std::string& string)
+			{
+				return utils::io::file_exists(string);
+			};
+
 			lua["table"]["unpack"] = lua["unpack"];
 			lua["luiglobals"] = lua;

--- a/src/client/game/demonware/data_types.hpp
+++ b/src/client/game/demonware/data_types.hpp
@ -30,7 +30,7 @@ namespace demonware
 		uint64_t file_id;
 		uint32_t create_time;
 		uint32_t modified_time;
-		bool priv;
+		bool visibility;
 		uint64_t owner_id;
 		std::string filename;
 		uint32_t file_size;
@ -41,7 +41,7 @@ namespace demonware
 			buffer->write_uint64(this->file_id);
 			buffer->write_uint32(this->create_time);
 			buffer->write_uint32(this->modified_time);
-			buffer->write_bool(this->priv);
+			buffer->write_bool(this->visibility);
 			buffer->write_uint64(this->owner_id);
 			buffer->write_string(this->filename);
 		}
@ -52,7 +52,7 @@ namespace demonware
 			buffer->read_uint64(&this->file_id);
 			buffer->read_uint32(&this->create_time);
 			buffer->read_uint32(&this->modified_time);
-			buffer->read_bool(&this->priv);
+			buffer->read_bool(&this->visibility);
 			buffer->read_uint64(&this->owner_id);
 			buffer->read_string(&this->filename);
 		}
--- a/src/client/game/demonware/services/bdGroup.cpp
+++ b/src/client/game/demonware/services/bdGroup.cpp
@ -10,19 +10,35 @@ namespace demonware
 		this->register_service(4, &bdGroup::get_groups);
 	}

-	void bdGroup::set_groups(i_server* server, byte_buffer* /*buffer*/) const
+	void bdGroup::set_groups(i_server* server, byte_buffer* buffer)
 	{
-		//uint32_t groupCount;
-		// TODO: Implement array reading
+		uint32_t entries_count{};
+		buffer->read_array_header(game::BD_BB_UNSIGNED_INTEGER32_TYPE, &entries_count);

 		auto reply = server->create_reply(this->get_sub_type());
+
+		buffer->set_use_data_types(false);
+
+		for (uint32_t i = 0; i < entries_count; ++i)
+		{
+			uint32_t group_id{};
+			buffer->read_uint32(&group_id);
+
+			if (group_id < ARRAYSIZE(this->groups))
+			{
+				this->groups[group_id] = 999;
+			}
+		}
+
+		buffer->set_use_data_types(true);
+
 		reply->send();
 	}

 	void bdGroup::get_groups(i_server* server, byte_buffer* buffer)
 	{
 		uint32_t group_count;
-		buffer->read_array_header(8, &group_count);
+		buffer->read_array_header(game::BD_BB_UNSIGNED_INTEGER32_TYPE, &group_count);

 		auto reply = server->create_reply(this->get_sub_type());

--- a/src/client/game/demonware/services/bdGroup.hpp
+++ b/src/client/game/demonware/services/bdGroup.hpp
@ -9,7 +9,7 @@ namespace demonware
 		bdGroup();

 	private:
-		void set_groups(i_server* server, byte_buffer* buffer) const;
+		void set_groups(i_server* server, byte_buffer* buffer);
 		void get_groups(i_server* server, byte_buffer* buffer);

 		uint32_t groups[512]{};
--- a/src/client/game/demonware/services/bdStorage.cpp
+++ b/src/client/game/demonware/services/bdStorage.cpp
@ -119,11 +119,11 @@ namespace demonware

 	void bdStorage::set_legacy_user_file(i_server* server, byte_buffer* buffer) const
 	{
-		bool priv;
+		bool visibility;
 		std::string filename, data;

 		buffer->read_string(&filename);
-		buffer->read_bool(&priv);
+		buffer->read_bool(&visibility);
 		buffer->read_blob(&data);

 		const auto id = *reinterpret_cast<const uint64_t*>(utils::cryptography::sha1::compute(filename).data());
@ -139,11 +139,11 @@ namespace demonware

 		info->file_id = id;
 		info->filename = filename;
-		info->create_time = uint32_t(time(nullptr));
+		info->create_time = static_cast<uint32_t>(std::time(nullptr));
 		info->modified_time = info->create_time;
-		info->file_size = uint32_t(data.size());
+		info->file_size = static_cast<uint32_t>(data.size());
 		info->owner_id = 0;
-		info->priv = priv;
+		info->visibility = visibility;

 		auto reply = server->create_reply(this->get_sub_type());
 		reply->add(info);
@ -170,11 +170,11 @@ namespace demonware

 		info->file_id = id;
 		info->filename = "<>";
-		info->create_time = uint32_t(time(nullptr));
+		info->create_time = static_cast<uint32_t>(std::time(nullptr));
 		info->modified_time = info->create_time;
-		info->file_size = uint32_t(data.size());
+		info->file_size = static_cast<uint32_t>(data.size());
 		info->owner_id = 0;
-		info->priv = false;
+		info->visibility = false;

 		auto reply = server->create_reply(this->get_sub_type());
 		reply->add(info);
@ -207,12 +207,12 @@ namespace demonware

 	void bdStorage::list_legacy_user_files(i_server* server, byte_buffer* buffer) const
 	{
-		uint64_t unk;
+		uint64_t owner;
 		uint32_t date;
 		uint16_t num_results, offset;
 		std::string filename, data;

-		buffer->read_uint64(&unk);
+		buffer->read_uint64(&owner);
 		buffer->read_uint32(&date);
 		buffer->read_uint16(&num_results);
 		buffer->read_uint16(&offset);
@ -229,9 +229,9 @@ namespace demonware
 			info->filename = filename;
 			info->create_time = 0;
 			info->modified_time = info->create_time;
-			info->file_size = uint32_t(data.size());
-			info->owner_id = 0;
-			info->priv = false;
+			info->file_size = static_cast<uint32_t>(data.size());
+			info->owner_id = owner;
+			info->visibility = false;

 			reply->add(info);
 		}
@ -260,9 +260,9 @@ namespace demonware
 			info->filename = filename;
 			info->create_time = 0;
 			info->modified_time = info->create_time;
-			info->file_size = uint32_t(data.size());
+			info->file_size = static_cast<uint32_t>(data.size());
 			info->owner_id = 0;
-			info->priv = false;
+			info->visibility = false;

 			reply->add(info);
 		}
@ -312,13 +312,13 @@ namespace demonware

 	void bdStorage::set_user_file(i_server* server, byte_buffer* buffer) const
 	{
-		bool priv;
+		bool visibility;
 		uint64_t owner;
 		std::string game, filename, data;

 		buffer->read_string(&game);
 		buffer->read_string(&filename);
-		buffer->read_bool(&priv);
+		buffer->read_bool(&visibility);
 		buffer->read_blob(&data);
 		buffer->read_uint64(&owner);

@ -329,11 +329,11 @@ namespace demonware

 		info->file_id = *reinterpret_cast<const uint64_t*>(utils::cryptography::sha1::compute(filename).data());
 		info->filename = filename;
-		info->create_time = uint32_t(time(nullptr));
+		info->create_time = static_cast<uint32_t>(std::time(nullptr));
 		info->modified_time = info->create_time;
-		info->file_size = uint32_t(data.size());
+		info->file_size = static_cast<uint32_t>(data.size());
 		info->owner_id = owner;
-		info->priv = priv;
+		info->visibility = visibility;

 		auto reply = server->create_reply(this->get_sub_type());
 		reply->add(info);
--- a/src/client/game/dvars.cpp
+++ b/src/client/game/dvars.cpp
@ -16,6 +16,7 @@ namespace dvars
 	game::dvar_t* con_inputCmdMatchColor = nullptr;

 	game::dvar_t* sv_cheats = nullptr;
+	game::dvar_t* sv_botsAutoJoin = nullptr;

 	game::dvar_t* g_playerEjection = nullptr;
 	game::dvar_t* g_playerCollision = nullptr;
@ -24,6 +25,7 @@ namespace dvars
 	game::dvar_t* g_rocketPushbackScale = nullptr;
 	game::dvar_t* g_enableElevators = nullptr;
 	game::dvar_t* g_dump_scripts = nullptr;
+	game::dvar_t* g_dump_string_tables = nullptr;
 	game::dvar_t* g_log = nullptr;

 	game::dvar_t* bg_surfacePenetration = nullptr;
--- a/src/client/game/dvars.hpp
+++ b/src/client/game/dvars.hpp
@ -15,6 +15,7 @@ namespace dvars
 	extern game::dvar_t* con_inputCmdMatchColor;

 	extern game::dvar_t* sv_cheats;
+	extern game::dvar_t* sv_botsAutoJoin;

 	extern game::dvar_t* g_playerCollision;
 	extern game::dvar_t* g_playerEjection;
@ -23,6 +24,7 @@ namespace dvars
 	extern game::dvar_t* g_rocketPushbackScale;
 	extern game::dvar_t* g_enableElevators;
 	extern game::dvar_t* g_dump_scripts;
+	extern game::dvar_t* g_dump_string_tables;
 	extern game::dvar_t* g_log;

 	extern game::dvar_t* bg_surfacePenetration;
--- a/src/client/game/engine/sv_game.cpp
+++ b/src/client/game/engine/sv_game.cpp
@ -0,0 +1,206 @@
+#include <std_include.hpp>
+#include <game/game.hpp>
+
+#include "sv_game.hpp"
+
+#include <component/console.hpp>
+
+#include <utils/string.hpp>
+
+namespace game::engine
+{
+	char* SV_ExpandNewlines(char* in)
+	{
+		static char string[1024];
+
+		unsigned int l = 0;
+		while (*in && l < sizeof(string) - 3)
+		{
+			if (*in == '\n')
+			{
+				string[l++] = '\\';
+				string[l++] = 'n';
+			}
+			else
+			{
+				if (*in != '\x14' && *in != '\x15')
+				{
+					string[l++] = *in;
+				}
+			}
+
+			++in;
+		}
+
+		string[l] = '\0';
+		return string;
+	}
+
+	void SV_CullIgnorableServerCommands(mp::client_t* client)
+	{
+		int to = client->reliableSent + 1;
+		for (int from = to; from <= client->reliableSequence; ++from)
+		{
+			int from_index = from & 0x7F;
+			assert(client->netBuf.reliableCommandInfo[from_index].time >= 0);
+			if (client->netBuf.reliableCommandInfo[from_index].type)
+			{
+				int to_index = to & 0x7F;
+				if (to_index != from_index)
+				{
+					client->netBuf.reliableCommandInfo[to_index] = client->netBuf.reliableCommandInfo[from_index];
+				}
+
+				++to;
+			}
+		}
+
+		client->reliableSequence = to - 1;
+	}
+
+	void SV_DelayDropClient(mp::client_t* drop, const char* reason)
+	{
+		assert(drop);
+		assert(reason);
+		assert(drop->header.state != CS_FREE);
+		if (drop->header.state == CS_ZOMBIE)
+		{
+#ifdef _DEBUG
+			console::info("(drop->dropReason) = %s", drop->dropReason);
+#endif
+		}
+		else if (!drop->dropReason)
+		{
+			drop->dropReason = reason;
+		}
+	}
+
+	void SV_AddServerCommand(mp::client_t* client, svscmd_type type, const char* cmd)
+	{
+		static_assert(offsetof(mp::client_t, netBuf.reliableCommandInfo[0].cmd) == 0xC44);
+
+		if (client->testClient == TC_BOT)
+		{
+			return;
+		}
+
+		if (client->reliableSequence - client->reliableAcknowledge < 64 && client->header.state == CS_ACTIVE || (SV_CullIgnorableServerCommands(client), type))
+		{
+			int len = static_cast<int>(std::strlen(cmd)) + 1;
+			int to = SV_CanReplaceServerCommand(client, reinterpret_cast<const unsigned char*>(cmd), len);
+			if (to < 0)
+			{
+				++client->reliableSequence;
+			}
+			else
+			{
+				int from = to + 1;
+				while (from <= client->reliableSequence)
+				{
+					client->netBuf.reliableCommandInfo[to & 0x7F] = client->netBuf.reliableCommandInfo[from & 0x7F];
+					++from;
+					++to;
+				}
+			}
+
+			if (client->reliableSequence - client->reliableAcknowledge == 129)
+			{
+#ifdef _DEBUG
+				console::info("===== pending server commands =====\n");
+				int i = 0;
+				for (i = client->reliableAcknowledge + 1; i <= client->reliableSequence; ++i)
+				{
+					console::info("cmd %5d: %8d: %s\n", i, client->netBuf.reliableCommandInfo[i & 0x7F].time, client->netBuf.reliableCommandInfo[i & 0x7F].cmd);
+				}
+				console::info("cmd %5d: %8d: %s\n", i, *game::mp::serverTime, cmd);
+#endif
+				NET_OutOfBandPrint(NS_SERVER, &client->header.netchan.remoteAddress, "disconnect");
+				SV_DelayDropClient(client, "EXE_SERVERCOMMANDOVERFLOW");
+				type = SV_CMD_RELIABLE;
+				cmd = utils::string::va("%c \"EXE_SERVERCOMMANDOVERFLOW\"", 'r');
+			}
+
+			int index = client->reliableSequence & 0x7F;
+			MSG_WriteReliableCommandToBuffer(cmd, client->netBuf.reliableCommandInfo[index].cmd, sizeof(client->netBuf.reliableCommandInfo[index].cmd));
+			client->netBuf.reliableCommandInfo[index].time = *game::mp::serverTime;
+			client->netBuf.reliableCommandInfo[index].type = type;
+		}
+	}
+
+	void SV_SendServerCommand(mp::client_t* cl, svscmd_type type, const char* fmt, ...)
+	{
+		mp::client_t* client;
+		int j, len;
+		va_list va;
+
+		const auto server_command_buf_large = std::make_unique<char[]>(0x20000);
+
+		va_start(va, fmt);
+		len = vsnprintf(server_command_buf_large.get(), 0x20000, fmt, va);
+		va_end(va);
+
+		assert(len >= 0);
+
+		if (cl)
+		{
+			SV_AddServerCommand(cl, type, server_command_buf_large.get());
+			return;
+		}
+
+		if (environment::is_dedi() && !std::strncmp(server_command_buf_large.get(), "print", 5))
+		{
+			console::info("broadcast: %s\n", SV_ExpandNewlines(server_command_buf_large.get()));
+		}
+
+		const auto* sv_maxclients = Dvar_FindVar("sv_maxclients");
+		for (j = 0, client = mp::svs_clients; j < sv_maxclients->current.integer; j++, client++)
+		{
+			if (client->header.state < CS_CLIENTLOADING)
+			{
+				continue;
+			}
+
+			SV_AddServerCommand(client, type, server_command_buf_large.get());
+		}
+	}
+
+	void SV_GameSendServerCommand(int clientNum, svscmd_type type, const char* text)
+	{
+		[[maybe_unused]] const auto* sv_maxclients = Dvar_FindVar("sv_maxclients");
+
+		if (clientNum == -1)
+		{
+			SV_SendServerCommand(nullptr, type, "%s", text);
+			return;
+		}
+
+		assert(sv_maxclients->current.integer >= 1 && sv_maxclients->current.integer <= 18);
+		assert(static_cast<unsigned>(clientNum) < sv_maxclients->current.unsignedInt);
+		SV_SendServerCommand(&mp::svs_clients[clientNum], type, "%s", text);
+	}
+
+	void SV_ReconnectClients(int savepersist)
+	{
+		const auto* sv_maxclients = Dvar_FindVar("sv_maxclients");
+		for (int i = 0; i < sv_maxclients->current.integer; ++i)
+		{
+			mp::client_t* client = &mp::svs_clients[i];
+			if (client->header.state < CS_CONNECTED)
+			{
+				continue;
+			}
+
+			SV_AddServerCommand(client, SV_CMD_RELIABLE, utils::string::va("%c", savepersist != 0 ? 107 : 118));
+			const char* denied = ClientConnect(i, client->scriptId);
+			if (denied)
+			{
+				SV_DropClient(client, denied, true);
+				console::info("SV_MapRestart_f: dropped client %i - denied!\n", i);
+			}
+			else if (client->header.state == CS_ACTIVE)
+			{
+				SV_ClientEnterWorld(client, &client->lastUsercmd);
+			}
+		}
+	}
+}
--- a/src/client/game/engine/sv_game.hpp
+++ b/src/client/game/engine/sv_game.hpp
@ -0,0 +1,8 @@
+#pragma once
+
+namespace game::engine
+{
+	void SV_SendServerCommand(mp::client_t* cl, svscmd_type type, const char* fmt, ...);
+	void SV_GameSendServerCommand(int clientNum, svscmd_type type, const char* text);
+	void SV_ReconnectClients(int savepersist);
+}
--- a/src/client/game/structs.hpp
+++ b/src/client/game/structs.hpp
@ -10,6 +10,14 @@ namespace game
 	typedef vec_t vec3_t[3];
 	typedef vec_t vec4_t[4];

+	enum ControllerIndex_t
+	{
+		INVALID_CONTROLLER_PORT = -1,
+		CONTROLLER_INDEX_0 = 0x0,
+		CONTROLLER_INDEX_FIRST = 0x0,
+		CONTROLLER_INDEX_COUNT = 0x1,
+	};
+
 	enum
 	{
 		FL_GODMODE = 0x1,
@ -641,6 +649,33 @@ namespace game
 		BD_MAX_ERROR_CODE = 0x27E2,
 	};

+	enum bdBitBufferDataType
+	{
+		BD_BB_NO_TYPE = 0x0,
+		BD_BB_BOOL_TYPE = 0x1,
+		BD_BB_SIGNED_CHAR8_TYPE = 0x2,
+		BD_BB_UNSIGNED_CHAR8_TYPE = 0x3,
+		BD_BB_WCHAR16_TYPE = 0x4,
+		BD_BB_SIGNED_INTEGER16_TYPE = 0x5,
+		BD_BB_UNSIGNED_INTEGER16_TYPE = 0x6,
+		BD_BB_SIGNED_INTEGER32_TYPE = 0x7,
+		BD_BB_UNSIGNED_INTEGER32_TYPE = 0x8,
+		BD_BB_SIGNED_INTEGER64_TYPE = 0x9,
+		BD_BB_UNSIGNED_INTEGER64_TYPE = 0xA,
+		BD_BB_RANGED_SIGNED_INTEGER32_TYPE = 0xB,
+		BD_BB_RANGED_UNSIGNED_INTEGER32_TYPE = 0xC,
+		BD_BB_FLOAT32_TYPE = 0xD,
+		BD_BB_FLOAT64_TYPE = 0xE,
+		BD_BB_RANGED_FLOAT32_TYPE = 0xF,
+		BD_BB_SIGNED_CHAR8_STRING_TYPE = 0x10,
+		BD_BB_UNSIGNED_CHAR8_STRING_TYPE = 0x11,
+		BD_BB_MBSTRING_TYPE = 0x12,
+		BD_BB_BLOB_TYPE = 0x13,
+		BD_BB_NAN_TYPE = 0x14,
+		BD_BB_FULL_TYPE = 0x15,
+		BD_BB_MAX_TYPE = 0x20,
+	};
+
 	enum bdNATType : uint8_t
 	{
 		BD_NAT_UNKNOWN = 0x0,
@ -955,6 +990,27 @@ namespace game
 		LOOKUP_ERROR_COUNT = 0x5,
 	};

+	struct ComStreamSyncModel
+	{
+		unsigned __int16 modelIndex;
+		unsigned __int8 alternateIndex;
+	};
+
+	static_assert(sizeof(ComStreamSyncModel) == 4);
+
+	struct ComStreamedSyncModelList
+	{
+		unsigned int modelCount;
+		ComStreamSyncModel models[18];
+	};
+
+	static_assert(sizeof(ComStreamedSyncModelList) == 0x4C);
+
+	struct ComStreamedSyncSwapBuffer
+	{
+		ComStreamedSyncModelList modelLists[2];
+	};
+
 	struct StructuredDataEnumEntry
 	{
 		unsigned int name;
@ -1125,6 +1181,8 @@ namespace game
 		DVAR_FLAG_LATCHED = 0x2,
 		DVAR_FLAG_CHEAT = 0x4,
 		DVAR_FLAG_REPLICATED = 0x8,
+		DVAR_FLAG_INTERNAL = 0x80,
+		DVAR_FLAG_EXTERNAL = 0x100,
 		DVAR_FLAG_SERVERINFO = 0x400,
 		DVAR_FLAG_WRITE = 0x800,
 		DVAR_FLAG_READ = 0x2000,
@ -1144,7 +1202,7 @@ namespace game
 		rgb = 9 // Color without alpha
 	};

-	union dvar_value
+	union DvarValue
 	{
 		bool enabled;
 		int integer;
@ -1187,9 +1245,9 @@ namespace game
 		unsigned int flags; //08
 		dvar_type type; //0C
 		bool modified; //0D
-		dvar_value current; //10
-		dvar_value latched;
-		dvar_value reset;
+		DvarValue current; //10
+		DvarValue latched;
+		DvarValue reset;
 		dvar_limits domain;
 	};

@ -1936,6 +1994,12 @@ namespace game
 		const char* buffer;
 	};

+	struct WeaponCompleteDef
+	{
+		const char* szInternalName;
+		WeaponDef* weapDef;
+	};
+
 	union XAssetHeader
 	{
 		void* data;
@ -1971,9 +2035,9 @@ namespace game
 		menuDef_t *menu;
 		AnimationClass *animClass;
 		LocalizeEntry *localize;
-		WeaponAttachment *attachment;
-		WeaponCompleteDef *weapon;
-		SndDriverGlobals *sndDriverGlobals;
+		WeaponAttachment *attachment;*/
+		WeaponCompleteDef* weapon;
+		/*SndDriverGlobals *sndDriverGlobals;
 		FxEffectDef *fx;
 		FxImpactTable *impactFx;
 		SurfaceFxTable *surfaceFx;*/
@ -2407,6 +2471,24 @@ namespace game
 			int isInKillcam;
 		};

+		struct svscmd_info_t
+		{
+			int time;
+			int type;
+			char cmd[1024];
+		};
+
+		static_assert(sizeof(svscmd_info_t)  == 0x408);
+
+		struct client_net_buffers_t
+		{
+			svscmd_info_t reliableCommandInfo[128];
+			char netchanOutgoingBuffer[131072];
+			char netchanIncomingBuffer[2048];
+		};
+
+		static_assert(sizeof(client_net_buffers_t) == 0x40C00);
+
 		struct client_t
 		{
 			clientHeader_t header;
@ -2416,7 +2498,17 @@ namespace game
 			int reliableAcknowledge;
 			int reliableSent;
 			int messageAcknowledge;
-			char _0xC30[0x41238];
+			int largeCommandSequence;
+			int gamestateMessageNum;
+			int challenge;
+			client_net_buffers_t netBuf;
+			int cumulThinkTime;
+			int beginCmdIndex;
+			int currCmdIndex;
+			usercmd_s lastUsercmd;
+			usercmd_s cmds[8];
+			int lastClientCommand;
+			char lastClientCommandString[1024];
 			gentity_s* gentity;
 			char name[16];
 			int lastPacketTime;
--- a/src/client/game/symbols.hpp
+++ b/src/client/game/symbols.hpp
@ -19,6 +19,8 @@ namespace game
 	WEAK symbol<void(void*, void*)> AimAssist_AddToTargetList{0, 0x140139D80};

 	WEAK symbol<void(unsigned int weapon, bool isAlternate, char* output, unsigned int maxStringLen)> BG_GetWeaponNameComplete{0, 0x140239370};
+	WEAK symbol<void()> BG_ClearWeaponDef{0x0, 0x140238D20};
+	WEAK symbol<bool()> BG_BotsConnectType{0x0, 0x140217080};

 	WEAK symbol<void()> Com_Frame_Try_Block_Function{0x1403BC980, 0x1404131A0};
 	WEAK symbol<const char*(char const**)> Com_Parse{0x1404313E0, 0x1404F50E0};
@ -28,6 +30,8 @@ namespace game
 	WEAK symbol<void(float, float, int)> Com_SetSlowMotion{0, 0x1404158C0};
 	WEAK symbol<void(const char* text_in)> Com_TokenizeString{0x1403B4150, 0x1403F7CC0};
 	WEAK symbol<void()> Com_EndTokenizeString{0x1403B37C0, 0x1403F7330};
+	WEAK symbol<void()> Com_StreamSync_UpdateLaunchData{0x0, 0x140411B50};
+	WEAK symbol<int(char* dest, int size, const char* fmt, ...)> Com_sprintf{0x140432310, 0x1404F6260};

 	WEAK symbol<void(const char* message)> Conbuf_AppendText{0x14043DDE0, 0x1405028C0};

@ -57,6 +61,7 @@ namespace game
 	WEAK symbol<int(const RawFile* rawfile)> DB_GetRawFileLen{0x140272E80, 0x14031FF80};
 	WEAK symbol<void(const RawFile* rawfile, char* buf, int size)> DB_GetRawBuffer{0x140272D50, 0x14031FE50};
 	WEAK symbol<int(const char* zoneName)> DB_IsLocalized{0x140273210, 0x140320360};
+	WEAK symbol<int(XAssetType type, void** assets, int maxCount)> DB_GetAllXAssetOfType_FastFile{0x0, 0x14031FC00};

 	WEAK symbol<void*(unsigned int size, unsigned int alignment, unsigned int type, PMem_Source source)> PMem_AllocFromSource_NoDebug{0x140430B80, 0x1404F46C0};
 	WEAK symbol<void(const char* name, PMem_Direction allocDir)> PMem_Free{0x140430EC0 , 0x1404F4A30};
@ -85,7 +90,7 @@ namespace game
 	WEAK symbol<void(const dvar_t* dvar, const char* string)> Dvar_SetString{0x14042D6E0, 0x1404F08E0};
 	WEAK symbol<void(const char*, const char*, DvarSetSource)> Dvar_SetFromStringByNameFromSource{0x14042D000, 0x1404F00B0};
 	WEAK symbol<void()> Dvar_Sort{0x14042DEF0, 0x1404F1210};
-	WEAK symbol<const char*(dvar_t* dvar, dvar_value value)> Dvar_ValueToString{0x14042E710, 0x1404F1A30};
+	WEAK symbol<const char*(dvar_t* dvar, DvarValue value)> Dvar_ValueToString{0x14042E710, 0x1404F1A30};

 	WEAK symbol<long long (const char* qpath, char** buffer)> FS_ReadFile{0x14041D0B0, 0x1404DE900};
 	WEAK symbol<void(void* buffer)> FS_FreeFile{0x14041D0A0, 0x1404DE8F0};
@ -96,6 +101,7 @@ namespace game
 	WEAK symbol<Weapon(const char* pickupName, int model)> G_FindItem{0x140462490, 0x14021B7E0};
 	WEAK symbol<int(playerState_s* ps, Weapon weapon, int dualWield, int startInAltMode, int usedBefore)> G_GivePlayerWeapon{0x140359E20, 0x1403DA5E0};
 	WEAK symbol<Weapon(const char* name)> G_GetWeaponForName{0x140359890, 0x1403DA060};
+	WEAK symbol<void()> G_SetupLevelWeaponDef{0x0, 0x1403DA910};
 	WEAK symbol<void()> G_Glass_Update{0x14030E680, 0x140397450};
 	WEAK symbol<void (playerState_s* ps, Weapon weapon, int hadWeapon)> G_InitializeAmmo{0x140311F00, 0x14039AEA0};
 	WEAK symbol<void(int clientNum, Weapon weapon)> G_SelectWeapon{0x14035A200, 0x1403DA880};
@ -108,14 +114,16 @@ namespace game
 	WEAK symbol<game_hudelem_s*(int clientNum, int teamNum)> HudElem_Alloc{0x0, 0x1403997E0};

 	WEAK symbol<char*(char* string)> I_CleanStr{0x140432460, 0x1404F63C0};
+	WEAK symbol<void(char* dest, const char* src, int destsize)> I_strncpyz{0x140432810, 0x1404F67A0};
+	WEAK symbol<void(char* dest, int size, const char* src)> I_strncat{0x140432740, 0x1404F66D0};

 	WEAK symbol<char*(GfxImage* image, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipCount, 
-		uint32_t imageFlags, DXGI_FORMAT imageFormat, const char* name, const void* initData)>
-	Image_Setup{0x140517910, 0x1405E4380};
+	                  uint32_t imageFlags, DXGI_FORMAT imageFormat, const char* name, const void* initData)> Image_Setup{0x140517910, 0x1405E4380};

 	WEAK symbol<const char*(int, int, int)> Key_KeynumToString{0x14023D9A0, 0x1402C40E0};

 	WEAK symbol<unsigned int (int)> Live_SyncOnlineDataFlags{0, 0x1405ABF70};
+	WEAK symbol<void(int localControllerIndex)> LiveStorage_StatsWriteNotNeeded{0x1403BA420, 0x140409120};

 	WEAK symbol<bool(int controllerIndex, unsigned int name, int value, StatsGroup statsGroup)> LiveStorage_PlayerDataSetIntByName{0x1403B8C20, 0x140404730};
 	WEAK symbol<bool(std::uint8_t* persistentData, const char* lookupString, int value, std::uint8_t* modifiedFlags, StatsGroup statsGroup)> LiveStorage_PlayerDataSetReservedInt{0x1403B8D00, 0x140404820};
@ -214,6 +222,10 @@ namespace game
 	WEAK symbol<bool()> SV_Loaded{0x140491820, 0x1404770C0};
 	WEAK symbol<void(int localClientNum, const char* map, bool mapIsPreloaded)> SV_StartMap{0, 0x140470170};
 	WEAK symbol<void(int localClientNum, const char* map, bool mapIsPreloaded, bool migrate)> SV_StartMapForParty{0, 0x1404702F0};
+	WEAK symbol<void(mp::client_t* cl, int isReconnectingClient)> SV_StreamSync_ClientConnect{0x0, 0x140488080};
+	WEAK symbol<const char*(int clientNum, unsigned __int16 scriptPersId)> ClientConnect{0x0, 0x140387630};
+	WEAK symbol<void(mp::client_t* client, usercmd_s* cmd)> SV_ClientEnterWorld{0x0, 0x1404710F0};
+	WEAK symbol<void(mp::client_t* drop, const char* reason, bool tellThem)> SV_DropClient{0x0, 0x140472110};

 	WEAK symbol<mp::gentity_s*(const char*, unsigned int, unsigned int, unsigned int)> SV_AddBot{0, 0x140470920};
 	WEAK symbol<bool(int clientNum)> SV_BotIsBot{0, 0x140461340};
@ -226,7 +238,7 @@ namespace game
 	WEAK symbol<const char*(int clientNum)> SV_GetGuid{0, 0x140475990};
 	WEAK symbol<void(int clientNum, const char* reason)> SV_KickClientNum{0, 0x14046F730};
 	WEAK symbol<void(int index, const char* string)> SV_SetConfigstring{0, 0x140477450};
-	WEAK symbol<void(int clientNum, svscmd_type type, const char* text)> SV_GameSendServerCommand{0x140490F40, 0x1404758C0};
+	WEAK symbol<int(mp::client_t* client, const unsigned char* cmd, int cmdSize)> SV_CanReplaceServerCommand{0x0, 0x140478F00};

 	WEAK symbol<void(const char* error, ...)> Sys_Error{0x14043AC20, 0x1404FF510};
 	WEAK symbol<bool()> Sys_IsDatabaseReady2{0x1403C2D40, 0x140423920};
@ -243,6 +255,7 @@ namespace game

 	WEAK symbol<const char*(const char*)> UI_LocalizeMapname{0, 0x1404B96D0};
 	WEAK symbol<const char*(const char*)> UI_LocalizeGametype{0, 0x1404B90F0};
+	WEAK symbol<void(int localClientNum, const char* srcString, char* dstString, int dstBufferSize)> UI_ReplaceDirective{0x0, 0x1404D8A00};

 	WEAK symbol<DWOnlineStatus(int)> dwGetLogOnStatus{0, 0x140589490};

@ -253,8 +266,12 @@ namespace game

 	WEAK symbol<void(void* ps)> Jump_ClearState{0x0, 0x140213120};

+	WEAK symbol<void(const char* pszCommand, char* pszBuffer, int iBufferSize)> MSG_WriteReliableCommandToBuffer{0x0, 0x1404232B0};
+
 	WEAK symbol<void(unsigned __int64 markPos)> LargeLocalResetToMark{0x140423B50, 0x1404E4D00};

+	WEAK symbol<int(const char* s0, const char* s1, int n)> I_strnicmp{0x140432840, 0x1404F67D0};
+
 	WEAK symbol<void*(jmp_buf* Buf, int Value)> longjmp{0x14062E030, 0x140738060};
 	WEAK symbol<int (jmp_buf* Buf)> _setjmp{0x14062F030, 0x140739060};

@ -333,6 +350,8 @@ namespace game
 		WEAK symbol<int> serverTime{0, 0x14647B280};

 		WEAK symbol<XZone> g_zones_0{0, 0x143A46498};
+
+		WEAK symbol<int> s_launchDataAvailable{0x0, 0x1445CE354};
 	}

 	namespace hks
--- a/src/client/main.cpp
+++ b/src/client/main.cpp
@ -64,9 +64,7 @@ LONG WINAPI exception_handler(PEXCEPTION_POINTERS exception_info)
 		&exception_information, nullptr, nullptr))
 	{
 		char buf[4096]{};
-		sprintf_s(buf, "An exception 0x%08X occurred at location 0x%p\n",
-			exception_info->ExceptionRecord->ExceptionCode,
-			exception_info->ExceptionRecord->ExceptionAddress);
+		sprintf_s(buf, "An exception 0x%08X occurred at location 0x%p\n", exception_info->ExceptionRecord->ExceptionCode, exception_info->ExceptionRecord->ExceptionAddress);
 		game::show_error(buf);
 	}

--- a/src/client/std_include.hpp
+++ b/src/client/std_include.hpp
@ -55,6 +55,7 @@
 #include <fstream>
 #include <functional>
 #include <map>
+#include <memory>
 #include <mutex>
 #include <optional>
 #include <queue>
--- a/src/common/utils/string.cpp
+++ b/src/common/utils/string.cpp
@ -115,13 +115,13 @@ namespace utils::string

 	void strip(const char* in, char* out, size_t max)
 	{
-		if (!in || !out) return;
+		if (!in || !out || !max) return;

 		max--;
 		auto current = 0u;
 		while (*in != 0 && current < max)
 		{
-			const auto color_index = (*(in + 1) - 48) >= 0xC ? 7 : (*(in + 1) - 48);
+			const auto color_index = (static_cast<size_t>(*(in + 1) - 48)) >= 0xC ? 7 : (*(in + 1) - 48);

 			if (*in == '^' && (color_index != 7 || *(in + 1) == '7'))
 			{
--- a/src/common/utils/string.hpp
+++ b/src/common/utils/string.hpp
@ -29,7 +29,7 @@ namespace utils::string

 			while (true)
 			{
-				const int res = vsnprintf_s(entry->buffer, entry->size, _TRUNCATE, format, ap);
+				const int res = vsnprintf(entry->buffer, entry->size, format, ap);
 				if (res > 0) break; // Success
 				if (res == 0) return nullptr; // Error
Author	SHA1	Message	Date
diamante0018	9052daab5c	maint: update Premake5	2025-04-11 11:10:05 +02:00
diamante0018	a299874dd2	fix: remove _s poison	2025-02-06 12:34:59 +01:00
diamante0018	27d5985574	fix noob team	2025-02-03 20:02:50 +01:00
diamante0018	b60692f0d7	feat: more arxan patches	2025-01-30 13:14:21 +01:00
diamante0018	6f2c293970	chore: update deps	2025-01-29 13:25:42 +01:00
6arelyFuture	03b44731a8	fix(gsc): I got one big silly goose in me	2025-01-29 08:21:56 +00:00
diamante0018	ea8d2e483f	fix(gameplay): fix gun game	2025-01-28 10:38:57 +01:00
diamante0018	833e25700c	feat(gsc): make bots join a server automatically	2025-01-28 08:57:47 +01:00
diamante0018	bc0372a249	feat(mods): add LUI menu	2025-01-27 22:28:55 +01:00
diamante0018	3d77a21f3d	assets(weapons): cache weapons from code (Code quaK/H1-Mod probably took from Pluto xD) Co-authored-by: H1-Mod Team <info@auroramod.dev> Co-authored-by: HighTechRedNeck <HTRNModding@outlook.com>	2025-01-24 13:59:57 +01:00
diamante0018	199206ee5a	maint: January Update Co-authored-by: Anomaly <jkohler@treyarch.com>	2025-01-11 10:20:05 +01:00