fixes

.gitmodules

@@ -29,6 +29,9 @@
 [submodule "deps/udis86"]
 	path = deps/udis86
 	url = https://github.com/vmt/udis86.git
+[submodule "deps/WinToast"]
+	path = deps/WinToast
+	url = https://github.com/mohabouje/WinToast.git
 [submodule "deps/zlib"]
 	path = deps/zlib
 	url = https://github.com/madler/zlib.git

deps/premake/wintoast.lua

@@ -0,0 +1,32 @@
+wintoast = {
+	source = path.join(dependencies.basePath, "WinToast"),
+}
+
+function wintoast.import()
+	links { "WinToast" }
+	wintoast.includes()
+end
+
+function wintoast.includes()
+	includedirs {
+		path.join(wintoast.source, "include"),
+	}
+end
+
+function wintoast.project()
+	project "WinToast"
+		language "C++"
+
+		wintoast.includes()
+		rapidjson.import();
+
+		files {
+			path.join(wintoast.source, "include/wintoastlib.h"),
+			path.join(wintoast.source, "src/wintoastlib.cpp"),
+		}
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, wintoast)

premake5.lua

@@ -259,7 +259,7 @@ filter "configurations:Release"
 	buildoptions {"/GL"}
 	linkoptions {"/IGNORE:4702", "/LTCG"}
 	defines {"NDEBUG"}
-	fatalwarnings {"All"}
+	flags {"FatalCompileWarnings"}
 filter {}
 
 filter "configurations:Debug"

src/client/component/assets/weapons.cpp

@@ -1,61 +0,0 @@
-#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 this game seems pretty high
-			std::array<game::WeaponCompleteDef*, 2048> 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(0x1403101D0, 4);
-			utils::hook::set<std::uint8_t>(0x1403101D0, 0xC3);
-
-			// Load weapons from the DB
-			utils::hook::call(0x1402F6EF4, g_setup_level_weapon_def_stub);
-			utils::hook::call(0x140307401, g_setup_level_weapon_def_stub);
-		}
-	};
-}
-
-REGISTER_COMPONENT(weapons::component)

src/client/component/binding.cpp

@@ -30,7 +30,8 @@ namespace binding
 
 				if (value && value < get_num_keys())
 				{
-					const auto len = game::Com_sprintf(&buffer[bytes_used], (buffer_size_align - bytes_used), "bind %s \"%s\"\n", key_button, game::command_whitelist[value]);
+					const auto len = sprintf_s(&buffer[bytes_used], (buffer_size_align - bytes_used),
+					                           "bind %s \"%s\"\n", key_button, game::command_whitelist[value]);
 
 					if (len < 0)
 					{
@@ -44,7 +45,8 @@ namespace binding
 					value -= get_num_keys();
 					if (static_cast<size_t>(value) < custom_binds.size() && !custom_binds[value].empty())
 					{
-						const auto len = game::Com_sprintf(&buffer[bytes_used], (buffer_size_align - bytes_used), "bind %s \"%s\"\n", key_button, custom_binds[value].data());
+						const auto len = sprintf_s(&buffer[bytes_used], (buffer_size_align - bytes_used),
+						                           "bind %s \"%s\"\n", key_button, custom_binds[value].data());
 
 						if (len < 0)
 						{

src/client/component/bots.cpp

@@ -13,8 +13,6 @@
 #include <utils/hook.hpp>
 #include <utils/string.hpp>
 
-#define ALLOW_CUSTOM_BOT_NAMES
-
 namespace bots
 {
 	namespace
@@ -64,6 +62,7 @@ namespace bots
 				return;
 			}
 
+			// SV_BotGetRandomName
 			const auto* const bot_name = game::SV_BotGetRandomName();
 			const auto* bot_ent = game::SV_AddBot(bot_name);
 			if (bot_ent)

src/client/component/command.cpp

@@ -1,13 +1,14 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
+
 #include "game/game.hpp"
-#include "game/engine/sv_game.hpp"
 #include "game/dvars.hpp"
 
 #include "command.hpp"
 #include "console.hpp"
-#include "fastfiles.hpp"
 #include "game_console.hpp"
+#include "scheduler.hpp"
+#include "fastfiles.hpp"
 
 #include <utils/hook.hpp>
 #include <utils/string.hpp>
@@ -235,13 +236,15 @@ namespace command
 	{
 		if (!dvars::sv_cheats->current.enabled)
 		{
-			game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, "f \"Cheats are not enabled on this server\"");
+			game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+				"f \"Cheats are not enabled on this server\"");
 			return false;
 		}
 
 		if (ent->health < 1)
 		{
-			game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, "f \"You must be alive to use this command\"");
+			game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+				"f \"You must be alive to use this command\"");
 			return false;
 		}
 
@@ -579,7 +582,8 @@ namespace command
 
 				ent->flags ^= game::FL_GODMODE;
 
-				game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, utils::string::va("f \"godmode %s\"", (ent->flags & game::FL_GODMODE) ? "^2on" : "^1off"));
+				game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+					utils::string::va("f \"godmode %s\"", (ent->flags & game::FL_GODMODE) ? "^2on" : "^1off"));
 			});
 
 			add_sv("demigod", [](game::mp::gentity_s* ent, const params_sv&)
@@ -589,7 +593,8 @@ namespace command
 
 				ent->flags ^= game::FL_DEMI_GODMODE;
 
-				game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, utils::string::va("f \"demigod mode %s\"", (ent->flags & game::FL_DEMI_GODMODE) ? "^2on" : "^1off"));
+				game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+					utils::string::va("f \"demigod mode %s\"", (ent->flags & game::FL_DEMI_GODMODE) ? "^2on" : "^1off"));
 			});
 
 			add_sv("notarget", [](game::mp::gentity_s* ent, const params_sv&)
@@ -599,7 +604,8 @@ namespace command
 
 				ent->flags ^= game::FL_NOTARGET;
 
-				game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, utils::string::va("f \"notarget %s\"", (ent->flags & game::FL_NOTARGET) ? "^2on" : "^1off"));
+				game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+					utils::string::va("f \"notarget %s\"", (ent->flags & game::FL_NOTARGET) ? "^2on" : "^1off"));
 			});
 
 			add_sv("noclip", [](game::mp::gentity_s* ent, const params_sv&)
@@ -609,7 +615,8 @@ namespace command
 
 				ent->client->flags ^= 1;
 
-				game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, utils::string::va("f \"noclip %s\"", ent->client->flags & 1 ? "^2on" : "^1off"));
+				game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+					utils::string::va("f \"noclip %s\"", ent->client->flags & 1 ? "^2on" : "^1off"));
 			});
 
 			add_sv("ufo", [](game::mp::gentity_s* ent, const params_sv&)
@@ -619,7 +626,8 @@ namespace command
 
 				ent->client->flags ^= 2;
 
-				game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, utils::string::va("f \"ufo %s\"", ent->client->flags & 2 ? "^2on" : "^1off"));
+				game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+					utils::string::va("f \"ufo %s\"", ent->client->flags & 2 ? "^2on" : "^1off"));
 			});
 
 			add_sv("give", [](game::mp::gentity_s* ent, const params_sv& params)
@@ -629,7 +637,8 @@ namespace command
 
 				if (params.size() < 2)
 				{
-					game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
+					game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+						"f \"You did not specify a weapon name\"");
 					return;
 				}
 
@@ -652,7 +661,8 @@ namespace command
 
 				if (params.size() < 2)
 				{
-					game::engine::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE, "f \"You did not specify a weapon name\"");
+					game::SV_GameSendServerCommand(ent->s.number, game::SV_CMD_RELIABLE,
+						"f \"You did not specify a weapon name\"");
 					return;
 				}
 

src/client/component/console.cpp

@@ -42,7 +42,7 @@ namespace console
 		{
 			static thread_local char buffer[0x1000];
 
-			const auto count = vsnprintf(buffer, sizeof(buffer), message, *ap);
+			const auto count = vsnprintf_s(buffer, _TRUNCATE, message, *ap);
 
 			if (count < 0) return {};
 			return {buffer, static_cast<size_t>(count)};
@@ -84,14 +84,15 @@ namespace console
 
 		void print_stub(const char* fmt, ...)
 		{
-			char buffer[4096]{};
-
 			va_list ap;
 			va_start(ap, fmt);
-			[[maybe_unused]] const auto res = vsnprintf(buffer, sizeof(buffer), fmt, ap);
-			va_end(ap);
 
+			char buffer[4096]{};
+			const auto res = vsnprintf_s(buffer, _TRUNCATE, fmt, ap);
+			(void)res;
 			print_message(buffer);
+
+			va_end(ap);
 		}
 
 		void append_text(const char* text)

src/client/component/dedicated.cpp

@@ -1,16 +1,13 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
-#include "game/engine/sv_game.hpp"
 
-#include "command.hpp"
 #include "console.hpp"
-#include "dvars.hpp"
-#include "network.hpp"
 #include "scheduler.hpp"
 #include "server_list.hpp"
-
-#include "component/gsc/script_extension.hpp"
+#include "network.hpp"
+#include "command.hpp"
+#include "dvars.hpp"
 
 #include <utils/hook.hpp>
 #include <utils/string.hpp>
@@ -19,6 +16,9 @@ namespace dedicated
 {
 	namespace
 	{
+		utils::hook::detour gscr_set_dynamic_dvar_hook;
+		utils::hook::detour com_quit_f_hook;
+
 		const game::dvar_t* sv_lanOnly;
 
 		void init_dedicated_server()
@@ -99,7 +99,8 @@ namespace dedicated
 
 			for (const auto& command : queue)
 			{
-				command::execute(command);
+				game::Cbuf_AddText(0, command.data());
+				game::Cbuf_AddText(0, "\n");
 			}
 		}
 
@@ -108,53 +109,49 @@ namespace dedicated
 			std::this_thread::sleep_for(1ms);
 		}
 
-		void sv_kill_server_f()
+		void gscr_set_dynamic_dvar()
 		{
-			game::Com_Shutdown("EXE_SERVERKILLED");
+			auto s = game::Scr_GetString(0);
+			auto* dvar = game::Dvar_FindVar(s);
+			if (dvar && !std::strncmp("scr_", dvar->name, 4))
+			{
+				return;
+			}
+
+			gscr_set_dynamic_dvar_hook.invoke<void>();
 		}
 
-		void start_map(const std::string& map_name)
+		void kill_server()
 		{
-			if (game::Live_SyncOnlineDataFlags(0) > 32)
+			for (auto i = 0; i < *game::mp::svs_numclients; ++i)
 			{
-				scheduler::once([map_name]()
+				if (game::mp::svs_clients[i].header.state >= 3)
 				{
-					command::execute(std::format("map {}", map_name), false);
-				}, scheduler::pipeline::main, 1s);
-
-				return;
+					game::SV_GameSendServerCommand(i, game::SV_CMD_CAN_IGNORE,
+					                               utils::string::va("r \"%s\"", "EXE_ENDOFGAME"));
+				}
 			}
 
-			if (!game::SV_MapExists(map_name.c_str()))
-			{
-				console::info("Map '%s' doesn't exist.\n", map_name.c_str());
-				return;
-			}
-
-			auto* current_mapname = game::Dvar_FindVar("mapname");
-			if (current_mapname && utils::string::to_lower(current_mapname->current.string) == utils::string::to_lower(map_name) && (game::SV_Loaded() && !game::VirtualLobby_Loaded()))
-			{
-				console::info("Restarting map: %s\n", map_name.c_str());
-				command::execute("map_restart", false);
-				return;
-			}
-
-			console::info("Starting map: %s\n", map_name.c_str());
-
-			auto* gametype = game::Dvar_FindVar("g_gametype");
-			if (gametype && gametype->current.string)
-			{
-				command::execute(utils::string::va("ui_gametype %s", gametype->current.string), true);
-			}
-
-			command::execute(utils::string::va("ui_mapname %s", map_name.c_str()), true);
-
-			game::SV_StartMapForParty(0, map_name.c_str(), false, false);
+			com_quit_f_hook.invoke<void>();
 		}
 
-		void gscr_is_using_match_rules_data_stub()
+		void sys_error_stub(const char* msg, ...)
 		{
-			game::Scr_AddInt(0);
+			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::main, 3s);
+
+			game::Com_Error(game::ERR_DROP, "%s", buffer);
 		}
 	}
 
@@ -193,12 +190,12 @@ namespace dedicated
 			// Don't allow sv_hostname to be changed by the game
 			dvars::disable::set_string("sv_hostname");
 
+			// Stop crashing from sys_errors
+			utils::hook::jump(0x1404D6260, sys_error_stub);
+
 			// Hook R_SyncGpu
 			utils::hook::jump(0x1405A7630, sync_gpu_stub);
 
-			// Make GScr_IsUsingMatchRulesData return 0 so the game doesn't override the cfg
-			gsc::override_function("isusingmatchrulesdata", gscr_is_using_match_rules_data_stub);
-
 			utils::hook::jump(0x14020C6B0, init_dedicated_server);
 
 			// delay startup commands until the initialization is done
@@ -208,6 +205,9 @@ namespace dedicated
 			utils::hook::call(0x1403CEC35, execute_console_command);
 			utils::hook::nop(0x1403CEC4B, 5);
 
+			// patch GScr_SetDynamicDvar to behave better
+			gscr_set_dynamic_dvar_hook.create(0x140312D00, &gscr_set_dynamic_dvar);
+
 			utils::hook::nop(0x1404AE6AE, 5); // don't load config file
 			utils::hook::nop(0x1403AF719, 5); // ^
 			utils::hook::set<uint8_t>(0x1403D2490, 0xC3); // don't save config file
@@ -306,7 +306,7 @@ namespace dedicated
 				console::info("==================================\n");
 
 				// remove disconnect command
-				game::Cmd_RemoveCommand(751);
+				game::Cmd_RemoveCommand(reinterpret_cast<const char*>(751));
 
 				execute_startup_command_queue();
 				execute_console_command_queue();
@@ -317,38 +317,8 @@ namespace dedicated
 				command::add("heartbeat", send_heartbeat);
 			}, scheduler::pipeline::main, 1s);
 
-			command::add("killserver", sv_kill_server_f);
-
-			command::add("map", [](const command::params& argument)
-			{
-				if (argument.size() != 2)
-				{
-					return;
-				}
-
-				start_map(argument[1]);
-			});
-
-			command::add("map_restart", []()
-			{
-				if (!game::SV_Loaded() || game::VirtualLobby_Loaded())
-				{
-					return;
-				}
-
-				*reinterpret_cast<int*>(0x1488692B0) = 1; // sv_map_restart
-				*reinterpret_cast<int*>(0x1488692B4) = 1; // sv_loadScripts
-				*reinterpret_cast<int*>(0x1488692B8) = 0; // sv_migrate
-				reinterpret_cast<void(*)(int)>(0x140437460)(0); // SV_CheckLoadGame
-			});
-
-			command::add("fast_restart", []()
-			{
-				if (game::SV_Loaded() && !game::VirtualLobby_Loaded())
-				{
-					game::SV_FastRestart(0);
-				}
-			});
+			command::add("killserver", kill_server);
+			com_quit_f_hook.create(0x1403D08C0, &kill_server);
 		}
 	};
 }

src/client/component/demonware.cpp

@@ -348,14 +348,15 @@ namespace demonware
 				return;
 			}
 
-			char buffer[2048]{};
+			char buffer[2048];
 
 			va_list ap;
 			va_start(ap, msg);
-			vsnprintf(buffer, sizeof(buffer), msg, ap);
-			va_end(ap);
 
+			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
 			printf("%s: %s\n", function, buffer);
+
+			va_end(ap);
 		}
 
 		void startup_dw()

src/client/component/dvar_cheats.cpp

@@ -1,7 +1,7 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
+
 #include "game/game.hpp"
-#include "game/engine/sv_game.hpp"
 #include "game/dvars.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::DvarValue* value)
+	void apply_sv_cheats(const game::dvar_t* dvar, const game::DvarSetSource source, game::dvar_value* value)
 	{
 		if (dvar && dvar->name == "sv_cheats"s)
 		{
@@ -130,7 +130,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::engine::SV_GameSendServerCommand(static_cast<char>(entity_num), game::SV_CMD_RELIABLE, command);
+		game::SV_GameSendServerCommand(entity_num, game::SV_CMD_RELIABLE, command);
 	}
 
 	const auto player_cmd_set_client_dvar = utils::hook::assemble([](utils::hook::assembler& a)

src/client/component/fastfiles.cpp

@@ -2,38 +2,65 @@
 #include "loader/component_loader.hpp"
 #include "game/dvars.hpp"
 
-#include "fastfiles.hpp"
 #include "command.hpp"
 #include "console.hpp"
+#include "fastfiles.hpp"
 
+#include <utils/concurrency.hpp>
 #include <utils/hook.hpp>
 #include <utils/io.hpp>
-#include <utils/concurrency.hpp>
+#include <utils/string.hpp>
 
 namespace fastfiles
 {
 	static utils::concurrency::container<std::string> current_fastfile;
 
+	namespace
+	{
+		template <typename T>
+		inline void merge(std::vector<T>* target, T* source, size_t length)
+		{
+			if (source)
+			{
+				for (size_t i = 0; i < length; ++i)
+				{
+					target->push_back(source[i]);
+				}
+			}
+		}
+
+		template <typename T>
+		inline void merge(std::vector<T>* target, std::vector<T> source)
+		{
+			for (auto& entry : source)
+			{
+				target->push_back(entry);
+			}
+		}
+	}
+
 	namespace
 	{
 		utils::hook::detour db_try_load_x_file_internal_hook;
 		utils::hook::detour db_find_x_asset_header_hook;
-		utils::hook::detour db_read_stream_file_hook;
-
-		int db_read_stream_file_stub(int allow_abort, int finish)
-		{
-			// always use lz4 compressor type when reading stream files
-			*game::g_compressor = game::DB_COMPRESSOR_LZX;
-			return db_read_stream_file_hook.invoke<int>(allow_abort, finish);
-		}
 
 		void db_try_load_x_file_internal(const char* zone_name, const int flags)
 		{
+			static std::unordered_map<std::string, std::string> zone_overrides = {};
+
+			auto override_zone_name = zone_overrides.find(zone_name);
+			if (override_zone_name != zone_overrides.end())
+			{
+				console::info("Overriding fastfile %s with %s\n", zone_name, override_zone_name->second.c_str());
+				zone_name = override_zone_name->second.c_str();
+			}
+
 			console::info("Loading fastfile %s\n", zone_name);
 			current_fastfile.access([&](std::string& fastfile)
 			{
 				fastfile = zone_name;
 			});
+
 			return db_try_load_x_file_internal_hook.invoke<void>(zone_name, flags);
 		}
 
@@ -64,10 +91,12 @@ namespace fastfiles
 			const auto result = db_find_x_asset_header_hook.invoke<game::XAssetHeader>(type, name, allow_create_default);
 			const auto diff = game::Sys_Milliseconds() - start;
 
+#ifdef DEBUG
 			if (type == game::ASSET_TYPE_SCRIPTFILE)
 			{
 				dump_gsc_script(name, result);
 			}
+#endif
 
 			if (diff > 100)
 			{
@@ -81,6 +110,223 @@ namespace fastfiles
 
 			return result;
 		}
+
+		utils::hook::detour db_link_xasset_entry1_hook;
+		game::XAssetEntry* db_link_xasset_entry1(game::XAssetType type, game::XAssetHeader* header)
+		{
+			if (type == game::ASSET_TYPE_SCRIPTFILE)
+			{
+				dump_gsc_script(header->scriptfile->name, *header);
+			}
+
+			return db_link_xasset_entry1_hook.invoke<game::XAssetEntry*>(type, header);
+		}
+
+		namespace mp
+		{
+			void skip_extra_zones_stub(utils::hook::assembler& a)
+			{
+				const auto skip = a.newLabel();
+				const auto original = a.newLabel();
+
+				a.pushad64();
+				a.test(esi, game::DB_ZONE_CUSTOM); // allocFlags
+				a.jnz(skip);
+
+				a.bind(original);
+				a.popad64();
+				a.mov(rdx, 0x140809D40);
+				a.mov(rcx, rbp);
+				a.call(0x1406FE120);
+				a.jmp(0x140271B63);
+
+				a.bind(skip);
+				a.popad64();
+				a.mov(r13d, game::DB_ZONE_CUSTOM);
+				a.not_(r13d);
+				a.and_(esi, r13d);
+				a.jmp(0x140271D02);
+			}
+		}
+
+		namespace sp
+		{
+			void skip_extra_zones_stub(utils::hook::assembler& a)
+			{
+				const auto skip = a.newLabel();
+				const auto original = a.newLabel();
+
+				a.pushad64();
+				a.test(edi, game::DB_ZONE_CUSTOM); // allocFlags
+				a.jnz(skip);
+
+				a.bind(original);
+				a.popad64();
+				a.call(0x140379360);
+				a.xor_(ecx, ecx);
+				a.test(eax, eax);
+				a.setz(cl);
+				a.jmp(0x1401802D6);
+
+				a.bind(skip);
+				a.popad64();
+				a.mov(r13d, game::DB_ZONE_CUSTOM);
+				a.not_(r13d);
+				a.and_(edi, r13d);
+				a.jmp(0x1401803EF);
+			}
+		}
+
+		utils::hook::detour db_read_stream_file_hook;
+		void db_read_stream_file_stub(int a1, int a2)
+		{
+			// always use lz4 compressor type when reading stream files
+			*game::g_compressor = 4;
+			return db_read_stream_file_hook.invoke<void>(a1, a2);
+		}
+
+		utils::hook::detour sys_createfile_hook;
+		HANDLE sys_create_file(game::Sys_Folder folder, const char* base_filename)
+		{
+			const auto* fs_basepath = game::Dvar_FindVar("fs_basepath");
+			const auto* fs_game = game::Dvar_FindVar("fs_game");
+
+			const std::string dir = fs_basepath ? fs_basepath->current.string : "";
+			const std::string mod_dir = fs_game ? fs_game->current.string : "";
+			const std::string name = base_filename;
+
+			if (name == "mod.ff")
+			{
+				if (!mod_dir.empty())
+				{
+					const auto path = utils::string::va("%s\\%s\\%s",
+						dir.data(), mod_dir.data(), base_filename);
+
+					if (utils::io::file_exists(path))
+					{
+						return CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
+							FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, nullptr);
+					}
+				}
+
+				return INVALID_HANDLE_VALUE;
+			}
+
+			return sys_createfile_hook.invoke<HANDLE>(folder, base_filename);
+		}
+
+		HANDLE sys_create_file_stub(game::Sys_Folder folder, const char* base_filename)
+		{
+			return sys_create_file(folder, base_filename);
+		}
+
+		bool try_load_zone(std::string name, bool localized, bool game = false)
+		{
+			if (localized)
+			{
+				const auto language = game::SEH_GetCurrentLanguageCode();
+				try_load_zone(language + "_"s + name, false);
+				if (game::environment::is_mp())
+				{
+					try_load_zone(language + "_"s + name + "_mp"s, false);
+				}
+			}
+
+			if (!fastfiles::exists(name))
+			{
+				return false;
+			}
+
+			game::XZoneInfo info{};
+			info.name = name.data();
+			info.allocFlags = (game ? game::DB_ZONE_GAME : game::DB_ZONE_COMMON) | game::DB_ZONE_CUSTOM;
+			info.freeFlags = 0;
+			game::DB_LoadXAssets(&info, 1u, game::DBSyncMode::DB_LOAD_ASYNC);
+			return true;
+		}
+
+		void load_pre_gfx_zones(game::XZoneInfo* zoneInfo, unsigned int zoneCount, game::DBSyncMode syncMode)
+		{
+			//imagefiles::close_custom_handles();
+
+			std::vector<game::XZoneInfo> data;
+			merge(&data, zoneInfo, zoneCount);
+
+			// code_pre_gfx
+
+			//weapon::clear_modifed_enums();
+			try_load_zone("mod_pre_gfx", true);
+			try_load_zone("s1_mod_pre_gfx", true);
+
+			game::DB_LoadXAssets(data.data(), static_cast<std::uint32_t>(data.size()), syncMode);
+		}
+
+		void load_post_gfx_and_ui_and_common_zones(game::XZoneInfo* zoneInfo, unsigned int zoneCount, game::DBSyncMode syncMode)
+		{
+			std::vector<game::XZoneInfo> data;
+			merge(&data, zoneInfo, zoneCount);
+
+			// code_post_gfx
+			// ui
+			// common
+
+			try_load_zone("s1_mod_common", true);
+
+			game::DB_LoadXAssets(data.data(), static_cast<std::uint32_t>(data.size()), syncMode);
+
+			try_load_zone("mod_common", true);
+		}
+
+		void load_ui_zones(game::XZoneInfo* zoneInfo, unsigned int zoneCount, game::DBSyncMode syncMode)
+		{
+			std::vector<game::XZoneInfo> data;
+			merge(&data, zoneInfo, zoneCount);
+
+			// ui
+
+			game::DB_LoadXAssets(data.data(), static_cast<std::uint32_t>(data.size()), syncMode);
+		}
+
+		void load_lua_file_asset_stub(void* a1)
+		{
+			const auto fastfile = fastfiles::get_current_fastfile();
+			if (fastfile == "mod")
+			{
+				console::error("Mod tried to load a lua file!\n");
+				return;
+			}
+
+			// TODO: add usermap LUI loading checks
+			/*
+			const auto usermap = fastfiles::get_current_usermap();
+			if (usermap.has_value())
+			{
+				const auto& usermap_value = usermap.value();
+				const auto usermap_load = usermap_value + "_load";
+
+				if (fastfile == usermap_value || fastfile == usermap_load)
+				{
+					console::error("Usermap tried to load a lua file!\n");
+					return;
+				}
+			}
+			*/
+
+			utils::hook::invoke<void>(0x140276480, a1);
+		}
+
+		utils::hook::detour db_level_load_add_zone_hook;
+		void db_level_load_add_zone_stub(void* load, const char* name, const unsigned int alloc_flags,
+			const size_t size_est)
+		{
+			if (!strcmp(name, "mp_terminal_cls"))
+			{
+				db_level_load_add_zone_hook.invoke<void>(load, name, alloc_flags | game::DB_ZONE_CUSTOM, size_est);
+				return;
+			}
+
+			db_level_load_add_zone_hook.invoke<void>(load, name, alloc_flags, size_est);
+;		}
 	}
 
 	std::string get_current_fastfile()
@@ -93,37 +339,35 @@ namespace fastfiles
 		return fastfile_copy;
 	}
 
-	constexpr int get_asset_type_size(const game::XAssetType type)
+	bool exists(const std::string& zone)
 	{
-		constexpr int asset_type_sizes[] =
-		{
-			96, 88, 128, 56, 40, 216, 56, 680,
-			480, 32, 32, 32, 32, 32, 352, 1456,
-			104, 32, 24, 152, 152, 152, 16, 64,
-			640, 40, 16, 408, 24, 288, 176, 2800,
-			48, -1, 40, 24, 200, 88, 16, 120,
-			3560, 32, 64, 16, 16, -1, -1, -1,
-			-1, 24, 40, 24, 40, 24, 128, 2256,
-			136, 32, 72, 24, 64, 88, 48, 32,
-			96, 152, 64, 32,
-		};
+		const auto is_localized = game::DB_IsLocalized(zone.data());
+		const auto handle = sys_create_file((is_localized ? game::SF_ZONE_LOC : game::SF_ZONE),
+			utils::string::va("%s.ff", zone.data()));
 
-		return asset_type_sizes[type];
+		if (handle != INVALID_HANDLE_VALUE)
+		{
+			CloseHandle(handle);
+			return true;
+		}
+
+		return false;
 	}
 
-	template <game::XAssetType Type, size_t Size>
-	char* reallocate_asset_pool()
+	void reallocate_asset_pool(game::XAssetType Type, size_t Size)
 	{
-		constexpr auto element_size = get_asset_type_size(Type);
-		static char new_pool[element_size * Size] = {0};
-		assert(get_asset_type_size(Type) == game::DB_GetXAssetTypeSize(Type));
-
+		const size_t element_size = game::DB_GetXAssetTypeSize(Type);
+		auto* new_pool = utils::memory::get_allocator()->allocate(Size * element_size);
 		std::memmove(new_pool, game::DB_XAssetPool[Type], game::g_poolSize[Type] * element_size);
 
 		game::DB_XAssetPool[Type] = new_pool;
-		game::g_poolSize[Type] = Size;
+		game::g_poolSize[Type] = static_cast<int>(Size);
+	}
 
-		return new_pool;
+	template <game::XAssetType Type, size_t Multiplier>
+	void reallocate_asset_pool_multiplier()
+	{
+		reallocate_asset_pool(Type, Multiplier * game::g_poolSize[Type]);
 	}
 
 	void enum_assets(const game::XAssetType type, const std::function<void(game::XAssetHeader)>& callback, const bool include_override)
@@ -135,6 +379,75 @@ namespace fastfiles
 		}), &callback, include_override);
 	}
 
+	const char* get_zone_name(const unsigned int index)
+	{
+		if (game::environment::is_sp())
+		{
+			return "";
+		}
+		else
+		{
+			return game::g_zones[index].name;
+		}
+	}
+
+	void reallocate_asset_pools()
+	{
+		reallocate_asset_pool(game::ASSET_TYPE_FONT, 48);
+
+		if (!game::environment::is_sp())
+		{
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_LUA_FILE, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_WEAPON, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_LOCALIZE_ENTRY, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_XANIMPARTS, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_ATTACHMENT, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_FONT, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_SNDDRIVER_GLOBALS, 4>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_EQUIPMENT_SND_TABLE, 4>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_SOUND, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_LOADED_SOUND, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_LEADERBOARD, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_VERTEXDECL, 6>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_COMPUTESHADER, 4>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_REVERB_PRESET, 2>();
+			reallocate_asset_pool_multiplier<game::ASSET_TYPE_IMPACT_FX, 10>();
+		}
+	}
+
+	void enum_asset_entries(const game::XAssetType type, const std::function<void(game::XAssetEntry*)>& callback, bool include_override)
+	{
+		constexpr auto max_asset_count = 0x1D8A8;
+		auto hash = &game::db_hashTable[0];
+		for (auto c = 0; c < max_asset_count; c++)
+		{
+			for (auto i = *hash; i; )
+			{
+				const auto entry = &game::g_assetEntryPool[i];
+
+				if (entry->asset.type == type)
+				{
+					callback(entry);
+
+					if (include_override && entry->nextOverride)
+					{
+						auto next_ovveride = entry->nextOverride;
+						while (next_ovveride)
+						{
+							const auto override = &game::g_assetEntryPool[next_ovveride];
+							callback(override);
+							next_ovveride = override->nextOverride;
+						}
+					}
+				}
+
+				i = entry->nextHash;
+			}
+
+			++hash;
+		}
+	}
+
 	class component final : public component_interface
 	{
 	public:
@@ -143,8 +456,24 @@ namespace fastfiles
 			db_try_load_x_file_internal_hook.create(SELECT_VALUE(0x1401816F0, 0x1402741C0), &db_try_load_x_file_internal);
 
 			db_find_x_asset_header_hook.create(game::DB_FindXAssetHeader, db_find_x_asset_header_stub);
+			db_link_xasset_entry1_hook.create(SELECT_VALUE(0x14017F390, 0x1402708F0), db_link_xasset_entry1);
 			dvars::g_dump_scripts = game::Dvar_RegisterBool("g_dumpScripts", false, game::DVAR_FLAG_NONE);
 
+			command::add("loadzone", [](const command::params& params)
+			{
+				if (params.size() < 2)
+				{
+					console::info("usage: loadzone <zone>\n");
+					return;
+				}
+
+				game::XZoneInfo info{};
+				info.name = params.get(1);
+				info.allocFlags = game::DB_ZONE_COMMON | game::DB_ZONE_CUSTOM;
+				info.freeFlags = 0;
+				game::DB_LoadXAssets(&info, 1u, game::DBSyncMode::DB_LOAD_SYNC);
+			});
+
 			command::add("g_poolSizes", []()
 			{
 				for (auto i = 0; i < game::ASSET_TYPE_COUNT; i++)
@@ -153,22 +482,50 @@ namespace fastfiles
 				}
 			});
 
+#ifdef DEBUG
+			//reallocate_asset_pools();
+#endif
+
+			// Allow loading of unsigned fastfiles
+			if (!game::environment::is_sp())
+			{
+				utils::hook::nop(0x1402427A5, 2); // DB_InflateInit
+			}
+
+			// Don't load extra zones with loadzone
+			if (game::environment::is_sp())
+			{
+				utils::hook::nop(0x1401802CA, 12);
+				utils::hook::jump(0x1401802CA, utils::hook::assemble(sp::skip_extra_zones_stub), true);
+			}
+			else
+			{
+				utils::hook::nop(0x140271B54, 15);
+				utils::hook::jump(0x140271B54, utils::hook::assemble(mp::skip_extra_zones_stub), true);
+
+				// dont load localized zone for custom maps (proper patch for this is here: https://github.com/auroramod/h1-mod/blob/develop/src/client/component/fastfiles.cpp#L442)
+				db_level_load_add_zone_hook.create(0x1402705C0, db_level_load_add_zone_stub);
+			}
+
 			// Allow loading of mixed compressor types
 			utils::hook::nop(SELECT_VALUE(0x1401536D7, 0x140242DF7), 2);
 
-			reallocate_asset_pool<game::ASSET_TYPE_FONT, 48>();
+			// Fix compressor type on streamed file load
+			db_read_stream_file_hook.create(SELECT_VALUE(0x140187450, 0x14027AA70), db_read_stream_file_stub);
 
-			if (!game::environment::is_sp())
+			// Add custom zone paths
+			sys_createfile_hook.create(game::Sys_CreateFile, sys_create_file_stub);
+
+			// load our custom ui and common zones
+			utils::hook::call(SELECT_VALUE(0x140487CF8, 0x1405A562A), load_post_gfx_and_ui_and_common_zones);
+
+			// load our custom ui zones
+			utils::hook::call(SELECT_VALUE(0x1402F91D4, 0x1403D06FC), load_ui_zones);
+
+			// prevent mod.ff from loading lua files
+			if (game::environment::is_mp())
 			{
-				const auto* xmodel_pool = reallocate_asset_pool<game::ASSET_TYPE_XMODEL, 8832>();
-				utils::hook::inject(0x14026FD63, xmodel_pool + 8);
-				utils::hook::inject(0x14026FDB3, xmodel_pool + 8);
-				utils::hook::inject(0x14026FFAC, xmodel_pool + 8);
-				utils::hook::inject(0x14027463C, xmodel_pool + 8);
-				utils::hook::inject(0x140274689, xmodel_pool + 8);
-
-				// Fix compressor type on streamed file load
-				db_read_stream_file_hook.create(0x14027AA70, db_read_stream_file_stub);
+				utils::hook::call(0x14024F1B4, load_lua_file_asset_stub);
 			}
 		}
 	};

src/client/component/fastfiles.hpp

@@ -6,5 +6,11 @@ namespace fastfiles
 {
 	std::string get_current_fastfile();
 
+	bool exists(const std::string& zone);
+
 	void enum_assets(game::XAssetType type, const std::function<void(game::XAssetHeader)>& callback, bool include_override);
+
+	const char* get_zone_name(const unsigned int index);
+
+	void enum_asset_entries(const game::XAssetType type, const std::function<void(game::XAssetEntry*)>& callback, bool include_override);
 }

src/client/component/filesystem.cpp

@@ -64,22 +64,20 @@ namespace filesystem
 
 		void startup()
 		{
-			const auto base = std::filesystem::current_path();
-
-			register_path(base / "s1");
+			register_path("s1");
 			register_path(get_binary_directory() + "\\data");
 
-			if (get_binary_directory() != base)
+			if (get_binary_directory() != std::filesystem::current_path())
 			{
-				register_path(base / "data");
+				register_path(std::filesystem::current_path() / "data");
 			}
 
 			// game's search paths
-			register_path(base / "devraw");
-			register_path(base / "devraw_shared");
-			register_path(base / "raw_shared");
-			register_path(base / "raw");
-			register_path(base / "main");
+			register_path("devraw");
+			register_path("devraw_shared");
+			register_path("raw_shared");
+			register_path("raw");
+			register_path("main");
 		}
 
 		void check_for_startup()

src/client/component/game_console.cpp

@@ -63,7 +63,7 @@ namespace game_console
 
 		void clear()
 		{
-			game::I_strncpyz(con.buffer, "", sizeof(con.buffer));
+			strncpy_s(con.buffer, "", sizeof(con.buffer));
 			con.cursor = 0;
 
 			fixed_input = "";
@@ -249,7 +249,7 @@ namespace game_console
 					               dvars::con_inputDvarInactiveValueColor->current.vector, offset);
 				}
 
-				game::I_strncpyz(con.globals.auto_complete_choice, matches[0].data(), 64);
+				strncpy_s(con.globals.auto_complete_choice, matches[0].data(), 64);
 				con.globals.may_auto_complete = true;
 			}
 			else if (matches.size() > 1)
@@ -274,7 +274,7 @@ namespace game_console
 					}
 				}
 
-				game::I_strncpyz(con.globals.auto_complete_choice, matches[0].data(), 64);
+				strncpy_s(con.globals.auto_complete_choice, matches[0].data(), 64);
 				con.globals.may_auto_complete = true;
 			}
 		}
@@ -365,11 +365,11 @@ namespace game_console
 
 	void print_internal(const char* fmt, ...)
 	{
-		char va_buffer[1024]{};
+		char va_buffer[0x200]{};
 
 		va_list ap;
 		va_start(ap, fmt);
-		vsnprintf(va_buffer, sizeof(va_buffer), fmt, ap);
+		vsprintf_s(va_buffer, fmt, ap);
 		va_end(ap);
 
 		const auto formatted = std::string(va_buffer);
@@ -425,7 +425,7 @@ namespace game_console
 						con.buffer[1] = '\0';
 					}
 
-					game::I_strncat(con.buffer, sizeof(con.buffer), con.globals.auto_complete_choice);
+					strncat_s(con.buffer, con.globals.auto_complete_choice, 64);
 					con.cursor = static_cast<int>(std::string(con.buffer).length());
 
 					if (con.cursor != 254)
@@ -550,7 +550,7 @@ namespace game_console
 
 					if (history_index != -1)
 					{
-						game::I_strncpyz(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
+						strncpy_s(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
 						con.cursor = static_cast<int>(strlen(con.buffer));
 					}
 				}
@@ -565,7 +565,7 @@ namespace game_console
 
 					if (history_index != -1)
 					{
-						game::I_strncpyz(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
+						strncpy_s(con.buffer, history.at(history_index).c_str(), sizeof(con.buffer));
 						con.cursor = static_cast<int>(strlen(con.buffer));
 					}
 				}
@@ -720,7 +720,7 @@ namespace game_console
 			con.output_visible = false;
 			con.display_line_offset = 0;
 			con.line_count = 0;
-			game::I_strncpyz(con.buffer, "", sizeof(con.buffer));
+			strncpy_s(con.buffer, "", sizeof(con.buffer));
 
 			con.globals.x = 0.0f;
 			con.globals.y = 0.0f;
@@ -728,7 +728,7 @@ namespace game_console
 			con.globals.font_height = 0.0f;
 			con.globals.may_auto_complete = false;
 			con.globals.info_line_count = 0;
-			game::I_strncpyz(con.globals.auto_complete_choice, "", 64);
+			strncpy_s(con.globals.auto_complete_choice, "", 64);
 
 			// add clear command
 			command::add("clear", [&]()

src/client/component/game_log.cpp

@@ -10,6 +10,7 @@
 
 #include "gsc/script_extension.hpp"
 
+#include <utils/hook.hpp>
 #include <utils/io.hpp>
 #include <utils/string.hpp>
 
@@ -22,7 +23,7 @@ namespace game_log
 			char buf[1024]{};
 			std::size_t out_chars = 0;
 
-			for (std::uint32_t i = 0; i < game::Scr_GetNumParam(); ++i)
+			for (auto i = 0u; i < game::Scr_GetNumParam(); ++i)
 			{
 				const auto* value = game::Scr_GetString(i);
 				const auto len = std::strlen(value);
@@ -33,7 +34,7 @@ namespace game_log
 					break;
 				}
 
-				game::I_strncat(buf, sizeof(buf), value);
+				strncat_s(buf, value, _TRUNCATE);
 			}
 
 			g_log_printf("%s", buf);
@@ -52,11 +53,18 @@ namespace game_log
 
 		va_list ap;
 		va_start(ap, fmt);
-		vsnprintf(buffer, sizeof(buffer), fmt, ap);
+
+		vsnprintf_s(buffer, _TRUNCATE, 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

src/client/component/gsc/script_loading.cpp

@@ -357,12 +357,12 @@ namespace gsc
 				build = static_cast<xsk::gsc::build>(static_cast<unsigned int>(build) | static_cast<unsigned int>(xsk::gsc::build::dev_maps));
 			}
 
-			if (dvars::com_developer_script && dvars::com_developer_script->current.integer > 0)
+			if (dvars::com_developer_script && dvars::com_developer_script->current.enabled)
 			{
 				build = static_cast<xsk::gsc::build>(static_cast<unsigned int>(build) | static_cast<unsigned int>(xsk::gsc::build::dev_blocks));
 			}
 
-			gsc_ctx->init(build, []([[maybe_unused]] const auto* ctx, const auto& included_path) -> std::pair<xsk::gsc::buffer, std::vector<std::uint8_t>>
+			gsc_ctx->init(build, []([[maybe_unused]] auto const* ctx, const auto& included_path) -> std::pair<xsk::gsc::buffer, std::vector<std::uint8_t>>
 			{
 				const auto script_name = std::filesystem::path(included_path).replace_extension().string();
 
@@ -419,7 +419,7 @@ namespace gsc
 	public:
 		void post_load() override
 		{
-			gsc_ctx = std::make_unique<xsk::gsc::s1_pc::context>(xsk::gsc::instance::server);
+			gsc_ctx = std::make_unique<xsk::gsc::s1_pc::context>();
 		}
 
 		void post_unpack() override
@@ -434,11 +434,8 @@ namespace gsc
 			utils::hook::call(SELECT_VALUE(0x14031AB47, 0x1403F7317), find_script);
 			utils::hook::call(SELECT_VALUE(0x14031AB57, 0x1403F7327), db_is_x_asset_default);
 
-			// Enable development options
 			dvars::com_developer = game::Dvar_RegisterInt("developer", 0, 0, 2, game::DVAR_FLAG_NONE);
-			// Enable developer script comments: 0 disabled, 1 full developer script, 2 only dev scripts required by art/lighting tweaks.
-			// gsc-tool will only have one mode which supports both 1 and 2 dev blocks in the code simultaneously.
-			dvars::com_developer_script = game::Dvar_RegisterInt("developer_script", 0, 0, 2, game::DVAR_FLAG_NONE);
+			dvars::com_developer_script = game::Dvar_RegisterBool("developer_script", false, game::DVAR_FLAG_NONE);
 
 			if (game::environment::is_sp())
 			{

src/client/component/imagefiles.cpp

@@ -0,0 +1,239 @@
+#include <std_include.hpp>
+#include "loader/component_loader.hpp"
+
+#include "console.hpp"
+#include "filesystem.hpp"
+#include "fastfiles.hpp"
+#include "scheduler.hpp"
+#include "imagefiles.hpp"
+
+#include "game/game.hpp"
+
+#include <utils/hook.hpp>
+#include <utils/string.hpp>
+#include <utils/io.hpp>
+#include <utils/concurrency.hpp>
+
+#define CUSTOM_IMAGE_FILE_INDEX 96
+
+namespace imagefiles
+{
+	namespace
+	{
+		utils::memory::allocator image_file_allocator;
+		std::unordered_map<std::string, HANDLE> image_file_handles;
+
+		std::string get_image_file_name()
+		{
+			return fastfiles::get_current_fastfile();
+		}
+		
+		namespace mp
+		{
+			struct image_file_unk
+			{
+				char __pad0[112]; // 120 in H1
+			};
+
+			std::unordered_map<std::string, image_file_unk*> image_file_unk_map;
+
+			void* get_image_file_unk_mp(unsigned int index)
+			{
+				if (index != CUSTOM_IMAGE_FILE_INDEX)
+				{
+					return &reinterpret_cast<image_file_unk*>(
+						SELECT_VALUE(0x0, 0x143DC4E90))[index];
+				}
+
+				const auto name = get_image_file_name();
+				if (image_file_unk_map.find(name) == image_file_unk_map.end())
+				{
+					const auto unk = image_file_allocator.allocate<image_file_unk>();
+					image_file_unk_map[name] = unk;
+					return unk;
+				}
+
+				return image_file_unk_map[name];
+			}
+		}
+
+		/*
+		namespace sp
+		{
+			struct image_file_unk
+			{
+				char __pad0[96];
+			};
+
+			std::unordered_map<std::string, image_file_unk*> image_file_unk_map;
+
+			void* get_image_file_unk_mp(unsigned int index)
+			{
+				if (index != CUSTOM_IMAGE_FILE_INDEX)
+				{
+					return &reinterpret_cast<image_file_unk*>(
+						SELECT_VALUE(0x0, 0x143DC4E90))[index];
+				}
+
+				const auto name = get_image_file_name();
+				if (image_file_unk_map.find(name) == image_file_unk_map.end())
+				{
+					const auto unk = image_file_allocator.allocate<image_file_unk>();
+					image_file_unk_map[name] = unk;
+					return unk;
+				}
+
+				return image_file_unk_map[name];
+			}
+		}
+		*/
+
+		HANDLE get_image_file_handle(unsigned int index)
+		{
+			if (index != CUSTOM_IMAGE_FILE_INDEX)
+			{
+				return reinterpret_cast<HANDLE*>(
+					SELECT_VALUE(0x0, 0x143B74E80))[index];
+			}
+
+			const auto name = get_image_file_name();
+			return image_file_handles[name];
+		}
+
+		void db_create_gfx_image_stream_stub(utils::hook::assembler& a)
+		{
+			const auto handle_is_open = a.newLabel();
+
+			a.movzx(eax, cx);
+			a.mov(esi, eax);
+			a.imul(rsi, 0x70);
+			a.add(rsi, r15);
+
+			a.push(rax);
+			a.push(rax);
+			a.pushad64();
+			a.mov(rcx, rax);
+			a.call_aligned(mp::get_image_file_unk_mp);
+			a.mov(qword_ptr(rsp, 0x80), rax);
+			a.popad64();
+			a.pop(rax);
+			a.mov(rsi, rax);
+			a.pop(rax);
+
+			a.push(rax);
+			a.push(rax);
+			a.pushad64();
+			a.mov(rcx, rax);
+			a.call_aligned(get_image_file_handle);
+			a.mov(qword_ptr(rsp, 0x80), rax);
+			a.popad64();
+			a.pop(rax);
+			a.mov(r12, rax);
+			a.pop(rax);
+
+			a.cmp(r12, r13);
+			a.jnz(handle_is_open);
+			a.jmp(SELECT_VALUE(0x0, 0x140279C8B));
+
+			a.bind(handle_is_open);
+			a.jmp(SELECT_VALUE(0x0, 0x140279CDB));
+		}
+
+		void* pakfile_open_stub(void* /*handles*/, unsigned int count, int is_imagefile, 
+			unsigned int index, short is_localized)
+		{
+#ifdef DEBUG
+			console::info("Opening %s%d.pak (localized:%d)\n", is_imagefile ? "imagefile" : "soundfile", index, is_localized);
+#endif
+
+			if (index != CUSTOM_IMAGE_FILE_INDEX)
+			{
+				return utils::hook::invoke<void*>(
+					SELECT_VALUE(0x0, 0x1404CC180),
+					SELECT_VALUE(0x0, 0x143B74E80), 
+					count, is_imagefile, index, is_localized
+				);
+			}
+
+			const auto name = get_image_file_name();
+			const auto handle = game::Sys_CreateFile(is_localized ? game::SF_PAKFILE_LOC : game::SF_PAKFILE, utils::string::va("%s.pak", name.data()));
+			if (handle != nullptr)
+			{
+				image_file_handles[name] = handle;
+			}
+			return handle;
+		}
+
+		int com_sprintf_stub(char* buffer, const int len, const char* fmt, unsigned int index)
+		{
+			if (index != CUSTOM_IMAGE_FILE_INDEX)
+			{
+				return game::Com_sprintf(buffer, len, fmt, index);
+			}
+
+			const auto name = get_image_file_name();
+			return game::Com_sprintf(buffer, len, "%s.pak", name.data());
+		}
+	}
+
+	void close_custom_handles()
+	{
+		for (const auto& handle : image_file_handles)
+		{
+			if (handle.second != nullptr)
+			{
+				utils::hook::invoke<void>(0x140608A20, handle.second); // Sys_CloseFile
+			}
+		}
+
+		image_file_handles.clear();
+		//sp::image_file_unk_map.clear();
+		mp::image_file_unk_map.clear();
+		image_file_allocator.clear();
+	}
+
+	void close_handle(const std::string& fastfile)
+	{
+		if (!image_file_handles.contains(fastfile))
+		{
+			return;
+		}
+
+		const auto handle = image_file_handles[fastfile];
+		if (handle != nullptr)
+		{
+			utils::hook::invoke<void>(0x140608A20, handle);
+		}
+
+		image_file_handles.erase(fastfile);
+		if (game::environment::is_sp())
+		{
+			//image_file_allocator.free(sp::image_file_unk_map[fastfile]);
+			//sp::image_file_unk_map.erase(fastfile);
+		}
+		else
+		{
+			image_file_allocator.free(mp::image_file_unk_map[fastfile]);
+			mp::image_file_unk_map.erase(fastfile);
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			if (!game::environment::is_mp())
+			{
+				return;
+			}
+
+			utils::hook::jump(SELECT_VALUE(0x0, 0x140279C79),
+				utils::hook::assemble(db_create_gfx_image_stream_stub), true);
+			utils::hook::call(SELECT_VALUE(0x0, 0x140279CBD), pakfile_open_stub);
+			utils::hook::call(SELECT_VALUE(0x0, 0x140279C9F), com_sprintf_stub);
+		}
+	};
+}
+
+REGISTER_COMPONENT(imagefiles::component)

src/client/component/imagefiles.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace imagefiles
+{
+	void close_custom_handles();
+	void close_handle(const std::string& fastfile);
+}

src/client/component/logger.cpp

@@ -2,6 +2,7 @@
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
 
+#include "party.hpp"
 #include "console.hpp"
 
 #include <utils/hook.hpp>
@@ -10,15 +11,57 @@ namespace logger
 {
 	namespace
 	{
+		utils::hook::detour com_error_hook;
+
 		game::dvar_t* logger_dev = nullptr;
 
+		void print_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("%s", buffer);
+		}
+
+		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);
+
+			party::clear_sv_motd(); // clear sv_motd on error if it exists
+
+			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(buffer, sizeof(buffer), msg, ap);
+			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
 			va_end(ap);
 
 			console::warn("%s", buffer);
@@ -30,7 +73,7 @@ namespace logger
 			va_list ap;
 
 			va_start(ap, msg);
-			vsnprintf(buffer, sizeof(buffer), msg, ap);
+			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
 			va_end(ap);
 
 			console::info("%s", buffer);
@@ -47,7 +90,7 @@ namespace logger
 			va_list ap;
 
 			va_start(ap, msg);
-			vsnprintf(buffer, sizeof(buffer), msg, ap);
+			vsnprintf_s(buffer, _TRUNCATE, msg, ap);
 			va_end(ap);
 
 			console::info("%s", buffer);
@@ -114,6 +157,13 @@ namespace logger
 				utils::hook::jump(0x140701A1C, print);
 			}
 
+			if (!game::environment::is_sp())
+			{
+				utils::hook::call(0x1404D8543, print_com_error);
+			}
+
+			com_error_hook.create(game::Com_Error, com_error_stub);
+
 			logger_dev = game::Dvar_RegisterBool("logger_dev", false, game::DVAR_FLAG_SAVED);
 		}
 	};

src/client/component/lui.cpp

@@ -29,7 +29,7 @@ namespace lui
 			{
 				if (params.size() <= 1)
 				{
-					console::info("USAGE: %s <name>\n", params.get(0));
+					console::info("usage: lui_open <name>\n");
 					return;
 				}
 
@@ -40,7 +40,7 @@ namespace lui
 			{
 				if (params.size() <= 1)
 				{
-					console::info("USAGE: %s <name>\n", params.get(0));
+					console::info("usage: lui_open_popup <name>\n");
 					return;
 				}
 

src/client/component/mapents.cpp

@@ -0,0 +1,212 @@
+#include <std_include.hpp>
+#include "loader/component_loader.hpp"
+
+#include "game/game.hpp"
+#include "console.hpp"
+#include "filesystem.hpp"
+
+#include <utils/hook.hpp>
+#include <utils/string.hpp>
+
+#include "gsc/script_loading.hpp"
+
+namespace mapents
+{
+	namespace
+	{
+		std::optional<std::string> parse_mapents(const std::string& source)
+		{
+			std::string out_buffer{};
+
+			const auto lines = utils::string::split(source, '\n');
+			auto in_map_ent = false;
+			auto empty = false;
+			auto in_comment = false;
+
+			for (auto i = 0; i < lines.size(); i++)
+			{
+				auto line_num = i+1;
+				auto line = lines[i];
+				if (line.ends_with('\r'))
+				{
+					line.pop_back();
+				}
+
+				if (line.starts_with("/*"))
+				{
+					in_comment = true;
+					continue;
+				}
+
+				if (line.ends_with("*/"))
+				{
+					in_comment = false;
+					continue;
+				}
+
+				if (in_comment)
+				{
+					continue;
+				}
+
+				if (line.starts_with("//"))
+				{
+					continue;
+				}
+
+				if (line[0] == '{' && !in_map_ent)
+				{
+					in_map_ent = true;
+					out_buffer.append("{\n");
+					continue;
+				}
+
+				if (line[0] == '{' && in_map_ent)
+				{
+					console::error("[map_ents parser] Unexpected '{' on line %i\n", line_num);
+					return {};
+				}
+
+				if (line[0] == '}' && in_map_ent)
+				{
+					if (empty)
+					{
+						out_buffer.append("\n}\n");
+					}
+					else if (i < static_cast<int>(lines.size()) - 1)
+					{
+						out_buffer.append("}\n");
+					}
+					else
+					{
+						out_buffer.append("}\0");
+					}
+
+					in_map_ent = false;
+					continue;
+				}
+
+				if (line[0] == '}' && !in_map_ent)
+				{
+					console::error("[map_ents parser] Unexpected '}' on line %i\n", line_num);
+					return {};
+				}
+
+				std::regex expr(R"~((.+) "(.*)")~");
+				std::smatch match{};
+				if (!std::regex_search(line, match, expr) && !line.empty())
+				{
+					console::warn("[map_ents parser] Failed to parse line %i (%s)\n", line_num, line.data());
+					continue;
+				}
+
+				auto key = utils::string::to_lower(match[1].str());
+				const auto value = match[2].str();
+
+				if (key.size() <= 0)
+				{
+					console::warn("[map_ents parser] Invalid key ('%s') on line %i (%s)\n", key.data(), line_num, line.data());
+					continue;
+				}
+
+				if (value.size() <= 0)
+				{
+					continue;
+				}
+
+				empty = false;
+
+				if (utils::string::is_numeric(key) || key.size() < 3 || !key.starts_with("\"") || !key.ends_with("\""))
+				{
+					out_buffer.append(line);
+					out_buffer.append("\n");
+					continue;
+				}
+
+				const auto key_ = key.substr(1, key.size() - 2);
+				const auto id = gsc::gsc_ctx->token_id(key_);
+				if (id == 0)
+				{
+					console::warn("[map_ents parser] Key '%s' not found, on line %i (%s)\n", key_.data(), line_num, line.data());
+					continue;
+				}
+
+				out_buffer.append(utils::string::va("%i \"%s\"\n", id, value.data()));
+			}
+
+			return {out_buffer};
+		}
+
+		std::string raw_ents;
+		bool load_raw_mapents()
+		{
+			auto mapents_name = utils::string::va("%s.ents", **reinterpret_cast<const char***>(SELECT_VALUE(0x0, 0x1479E6940)));
+			if (filesystem::exists(mapents_name))
+			{
+				try
+				{
+					console::info("Reading raw ents file \"%s\"\n", mapents_name);
+					raw_ents = filesystem::read_file(mapents_name);
+					if (!raw_ents.empty())
+					{
+						return true;
+					}
+				}
+				catch (const std::exception& ex)
+				{
+					console::error("Failed to read raw ents file \"%s\"\n%s\n", mapents_name, ex.what());
+				}
+			}
+			return false;
+		}
+
+		std::string entity_string;
+		const char* cm_entity_string_stub()
+		{
+			const char* ents = nullptr;
+			if (load_raw_mapents())
+			{
+				ents = raw_ents.data();
+			}
+			else
+			{
+				if (!entity_string.empty())
+				{
+					return entity_string.data();
+				}
+
+				ents = utils::hook::invoke<const char*>(SELECT_VALUE(0x0, 0x1403A1F30));
+			}
+
+			const auto parsed = parse_mapents(ents);
+			if (parsed.has_value())
+			{
+				entity_string = parsed.value();
+				return entity_string.data();
+			}
+			else
+			{
+				return ents;
+			}
+		}
+
+		void cm_unload_stub(void* clip_map)
+		{
+			entity_string.clear();
+			raw_ents.clear();
+			utils::hook::invoke<void>(SELECT_VALUE(0x0, 0x1403A1ED0), clip_map);
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			utils::hook::call(SELECT_VALUE(0x0, 0x1402F5A54), cm_entity_string_stub);
+			utils::hook::call(SELECT_VALUE(0x0, 0x14026BF54), cm_unload_stub);
+		}
+	};
+}
+
+REGISTER_COMPONENT(mapents::component)

src/client/component/mods.cpp

@@ -1,236 +0,0 @@
-#include <std_include.hpp>
-#include "loader/component_loader.hpp"
-#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
-{
-	namespace
-	{
-		utils::hook::detour sys_create_file_hook;
-
-		void db_build_os_path_from_source(const char* zone_name, const game::FF_DIR source, const int size, char* filename)
-		{
-			char user_map[MAX_PATH]{};
-
-			switch (source)
-			{
-			case game::FFD_DEFAULT:
-				(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)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:
-				game::I_strncpyz(user_map, zone_name, sizeof(user_map));
-
-				(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");
-				break;
-			}
-		}
-
-		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;
-		}
-
-		const auto skip_extra_zones_stub = utils::hook::assemble([](utils::hook::assembler& a) -> void
-		{
-			const auto skip = a.newLabel();
-			const auto original = a.newLabel();
-
-			a.pushad64();
-			a.test(esi, game::DB_ZONE_CUSTOM); // allocFlags
-			a.jnz(skip);
-
-			a.bind(original);
-			a.popad64();
-			a.mov(rdx, 0x140809D40);
-			a.mov(rcx, rbp);
-			a.call(0x1406FE120);
-			a.jmp(0x140271B63);
-
-			a.bind(skip);
-			a.popad64();
-			a.mov(r13d, game::DB_ZONE_CUSTOM);
-			a.not_(r13d);
-			a.and_(esi, r13d);
-			a.jmp(0x140271D02);
-		});
-
-		game::Sys_File sys_create_file_stub(game::Sys_Folder folder, const char* base_filename)
-		{
-			auto result = sys_create_file_hook.invoke<game::Sys_File>(folder, base_filename);
-
-			if (result.handle != INVALID_HANDLE_VALUE)
-			{
-				return result;
-			}
-
-			if (!is_using_mods())
-			{
-				return result;
-			}
-
-			// .ff extension was added previously
-			if (!std::strcmp(base_filename, "mod.ff") && mods::db_mod_file_exists())
-			{
-				char file_path[MAX_PATH]{};
-				db_build_os_path_from_source("mod", game::FFD_MOD_DIR, sizeof(file_path), file_path);
-				result.handle = game::Sys_OpenFileReliable(file_path);
-			}
-
-			return result;
-		}
-
-		void db_load_x_assets_stub(game::XZoneInfo* zone_info, unsigned int zone_count, game::DBSyncMode sync_mode)
-		{
-			std::vector<game::XZoneInfo> zones(zone_info, zone_info + zone_count);
-
-			if (db_mod_file_exists())
-			{
-				zones.emplace_back("mod", game::DB_ZONE_COMMON | game::DB_ZONE_CUSTOM, 0);
-			}
-
-			game::DB_LoadXAssets(zones.data(), static_cast<unsigned int>(zones.size()), sync_mode);
-		}
-	}
-
-	bool is_using_mods()
-	{
-		return (*dvars::fs_gameDirVar) && *(*dvars::fs_gameDirVar)->current.string;
-	}
-
-	bool db_mod_file_exists()
-	{
-		if (!*(*dvars::fs_gameDirVar)->current.string)
-		{
-			return false;
-		}
-
-		char filename[MAX_PATH]{};
-		db_build_os_path_from_source("mod", game::FFD_MOD_DIR, sizeof(filename), filename);
-
-		if (auto zone_file = game::Sys_OpenFileReliable(filename); zone_file != INVALID_HANDLE_VALUE)
-		{
-			::CloseHandle(zone_file);
-			return true;
-		}
-
-		return false;
-	}
-
-	class component final : public component_interface
-	{
-	public:
-		static_assert(sizeof(game::Sys_File) == 8);
-
-		void post_unpack() override
-		{
-			dvars::fs_gameDirVar = reinterpret_cast<game::dvar_t**>(SELECT_VALUE(0x14A6A7D98, 0x14B20EB48));
-
-			// Remove DVAR_INIT from fs_game
-			utils::hook::set<std::uint32_t>(SELECT_VALUE(0x14036137F + 2, 0x1404AE4CB + 2), SELECT_VALUE(game::DVAR_FLAG_NONE, game::DVAR_FLAG_SERVERINFO));
-
-			utils::hook::inject(SELECT_VALUE(0x140361391 + 3, 0x1404AE4D6 + 3), &fs_game_dir_domain_func);
-
-			if (game::environment::is_sp())
-			{
-				return;
-			}
-
-			utils::hook::nop(0x140271B54, 15);
-			utils::hook::jump(0x140271B54, skip_extra_zones_stub, true);
-
-			// Add custom zone paths
-			sys_create_file_hook.create(game::Sys_CreateFile, sys_create_file_stub);
-
-			// Load mod.ff
-			utils::hook::call(0x1405A562A, db_load_x_assets_stub); // R_LoadGraphicsAssets According to myself but I don't remember where I got it from
-
-			// Allow loading of unsigned fastfiles
-			utils::hook::nop(0x1402427A5, 2); // DB_InflateInit
-
-			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.insert(0, "mods/");
-				}
-
-				// 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", []([[maybe_unused]] 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
-		}
-	};
-}
-
-REGISTER_COMPONENT(mods::component)

src/client/component/mods.hpp

@@ -1,7 +0,0 @@
-#pragma once
-
-namespace mods
-{
-	bool is_using_mods();
-	bool db_mod_file_exists();
-}

src/client/component/party.cpp

@@ -1,7 +1,6 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
-#include "game/engine/sv_game.hpp"
 #include "game/dvars.hpp"
 
 #include "party.hpp"
@@ -160,7 +159,7 @@ namespace party
 			if (game::mp::g_entities[i].client)
 			{
 				char client_name[16] = {0};
-				game::I_strncpyz(client_name, game::mp::g_entities[i].client->name, sizeof(client_name));
+				strncpy_s(client_name, game::mp::g_entities[i].client->name, sizeof(client_name));
 				game::I_CleanStr(client_name);
 
 				if (client_name == name)
@@ -227,6 +226,64 @@ namespace party
 		network::send(target, "getInfo", connect_state.challenge);
 	}
 
+	void start_map(const std::string& mapname)
+	{
+		if (game::Live_SyncOnlineDataFlags(0) > 32)
+		{
+			scheduler::once([=]()
+			{
+				command::execute("map " + mapname, false);
+			}, scheduler::pipeline::main, 1s);
+		}
+		else
+		{
+			if (!game::SV_MapExists(mapname.data()))
+			{
+				console::info("Map '%s' doesn't exist.\n", mapname.data());
+				return;
+			}
+
+			auto* current_mapname = game::Dvar_FindVar("mapname");
+			if (current_mapname && utils::string::to_lower(current_mapname->current.string) ==
+				utils::string::to_lower(mapname) && (game::SV_Loaded() && !game::VirtualLobby_Loaded()))
+			{
+				console::info("Restarting map: %s\n", mapname.data());
+				command::execute("map_restart", false);
+				return;
+			}
+
+			if (!game::environment::is_dedi())
+			{
+				if (game::SV_Loaded())
+				{
+					const auto* args = "Leave";
+					game::UI_RunMenuScript(0, &args);
+				}
+
+				perform_game_initialization();
+			}
+
+			console::info("Starting map: %s\n", mapname.data());
+
+			auto* gametype = game::Dvar_FindVar("g_gametype");
+			if (gametype && gametype->current.string)
+			{
+				command::execute(utils::string::va("ui_gametype %s", gametype->current.string), true);
+			}
+			command::execute(utils::string::va("ui_mapname %s", mapname.data()), true);
+
+			/*auto* maxclients = game::Dvar_FindVar("sv_maxclients");
+			if (maxclients)
+			{
+				command::execute(utils::string::va("ui_maxclients %i", maxclients->current.integer), true);
+				command::execute(utils::string::va("party_maxplayers %i", maxclients->current.integer), true);
+			}*/
+
+			const auto* args = "StartServer";
+			game::UI_RunMenuScript(0, &args);
+		}
+	}
+
 	int server_client_count()
 	{
 		return sv_maxclients;
@@ -257,6 +314,36 @@ namespace party
 			// enable custom kick reason in GScr_KickPlayer
 			utils::hook::set<uint8_t>(0x14032ED80, 0xEB);
 
+			command::add("map", [](const command::params& argument)
+			{
+				if (argument.size() != 2)
+				{
+					return;
+				}
+
+				start_map(argument[1]);
+			});
+
+			command::add("map_restart", []()
+			{
+				if (!game::SV_Loaded() || game::VirtualLobby_Loaded())
+				{
+					return;
+				}
+				*reinterpret_cast<int*>(0x1488692B0) = 1; // sv_map_restart
+				*reinterpret_cast<int*>(0x1488692B4) = 1; // sv_loadScripts
+				*reinterpret_cast<int*>(0x1488692B8) = 0; // sv_migrate
+				reinterpret_cast<void(*)(int)>(0x140437460)(0); // SV_CheckLoadGame
+			});
+
+			command::add("fast_restart", []()
+			{
+				if (game::SV_Loaded() && !game::VirtualLobby_Loaded())
+				{
+					game::SV_FastRestart(0);
+				}
+			});
+
 			command::add("reconnect", [](const command::params& argument)
 			{
 				if (!connect_state.hostDefined)
@@ -355,7 +442,7 @@ namespace party
 					{
 						scheduler::once([i, reason]
 						{
-							game::SV_KickClientNum(i, reason.c_str());
+							game::SV_KickClientNum(i, reason.data());
 						}, scheduler::pipeline::server);
 					}
 					return;
@@ -369,7 +456,7 @@ namespace party
 
 				scheduler::once([client_num, reason]()
 				{
-					game::SV_KickClientNum(client_num, reason.c_str());
+					game::SV_KickClientNum(client_num, reason.data());
 				}, scheduler::pipeline::server);
 			});
 
@@ -389,8 +476,9 @@ namespace party
 				const auto message = params.join(2);
 				const auto* const name = game::Dvar_FindVar("sv_sayName")->current.string;
 
-				game::engine::SV_GameSendServerCommand(static_cast<char>(client_num), game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.c_str()));
-				printf("%s -> %i: %s\n", name, client_num, message.c_str());
+				game::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE,
+				                               utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
+				printf("%s -> %i: %s\n", name, client_num, message.data());
 			});
 
 			command::add("tellraw", [](const command::params& params)
@@ -403,8 +491,9 @@ namespace party
 				const auto client_num = atoi(params.get(1));
 				const auto message = params.join(2);
 
-				game::engine::SV_GameSendServerCommand(static_cast<char>(client_num), game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.c_str()));
-				printf("%i: %s\n", client_num, message.c_str());
+				game::SV_GameSendServerCommand(client_num, game::SV_CMD_CAN_IGNORE,
+				                               utils::string::va("%c \"%s\"", 84, message.data()));
+				printf("%i: %s\n", client_num, message.data());
 			});
 
 			command::add("say", [](const command::params& params)
@@ -417,8 +506,9 @@ namespace party
 				const auto message = params.join(1);
 				const auto* const name = game::Dvar_FindVar("sv_sayName")->current.string;
 
-				game::engine::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.c_str()));
-				printf("%s: %s\n", name, message.c_str());
+				game::SV_GameSendServerCommand(
+					-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s: %s\"", 84, name, message.data()));
+				printf("%s: %s\n", name, message.data());
 			});
 
 			command::add("sayraw", [](const command::params& params)
@@ -430,7 +520,8 @@ namespace party
 
 				const auto message = params.join(1);
 
-				game::engine::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE, utils::string::va("%c \"%s\"", 84, message.c_str()));
+				game::SV_GameSendServerCommand(-1, game::SV_CMD_CAN_IGNORE,
+				                               utils::string::va("%c \"%s\"", 84, message.data()));
 				printf("%s\n", message.data());
 			});
 

src/client/component/party.hpp

@@ -5,6 +5,7 @@ namespace party
 	void reset_connect_state();
 
 	void connect(const game::netadr_s& target);
+	void start_map(const std::string& mapname);
 
 	void clear_sv_motd();
 	int server_client_count();

src/client/component/patches.cpp

@@ -1,7 +1,6 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
-#include "game/engine/sv_game.hpp"
 #include "game/dvars.hpp"
 
 #include "command.hpp"
@@ -20,8 +19,6 @@ namespace patches
 {
 	namespace
 	{
-		utils::hook::detour com_quit_f_hook;
-		utils::hook::detour sv_shutdown_hook;
 		utils::hook::detour live_get_local_client_name_hook;
 
 		const char* live_get_local_client_name()
@@ -118,7 +115,7 @@ namespace patches
 		char* db_read_raw_file_stub(const char* filename, char* buf, const int size)
 		{
 			std::string file_name = filename;
-			if (!file_name.ends_with(".cfg"))
+			if (file_name.find(".cfg") == std::string::npos)
 			{
 				file_name.append(".cfg");
 			}
@@ -127,7 +124,6 @@ namespace patches
 			if (file.exists())
 			{
 				snprintf(buf, size, "%s\n", file.get_buffer().data());
-				buf[size - 1] = '\0';
 				return buf;
 			}
 
@@ -163,6 +159,17 @@ namespace patches
 			}
 		}
 
+		void set_client_dvar_from_server_stub(void* a1, void* a2, const char* dvar, const char* value)
+		{
+			if (utils::string::to_lower(dvar) == "cg_fov")
+			{
+				return;
+			}
+
+			// CG_SetClientDvarFromServer
+			reinterpret_cast<void(*)(void*, void*, const char*, const char*)>(0x1401BF0A0)(a1, a2, dvar, value);
+		}
+
 		utils::hook::detour cmd_lui_notify_server_hook;
 		void cmd_lui_notify_server_stub(game::mp::gentity_s* ent)
 		{
@@ -171,27 +178,13 @@ namespace patches
 			const auto client = &game::mp::svs_clients[ent->s.number];
 
 			// 22 => "end_game"
-			if (menu_id == 22 && client->header.netchan.remoteAddress.type != game::NA_LOOPBACK)
+			if (menu_id == 22 && client->header.remoteAddress.type != game::NA_LOOPBACK)
 			{
 				return;
 			}
 
 			cmd_lui_notify_server_hook.invoke<void>(ent);
 		}
-
-		void sv_shutdown_stub(const char* finalmsg)
-		{
-			console::info("----- Server Shutdown -----\n");
-
-			sv_shutdown_hook.invoke<void>(finalmsg);
-		}
-
-		void com_quit_f_stub()
-		{
-			console::info("quitting...\n");
-
-			com_quit_f_hook.invoke<void>();
-		}
 	}
 
 	class component final : public component_interface
@@ -246,10 +239,6 @@ namespace patches
 
 		static void patch_mp()
 		{
-			// Bypass Arxan function
-			utils::hook::nop(0x14043E120, 9);
-			utils::hook::jump(0x14043E120, game::engine::SV_GameSendServerCommand);
-
 			// Use name dvar
 			live_get_local_client_name_hook.create(0x1404D47F0, &live_get_local_client_name);
 
@@ -287,8 +276,9 @@ namespace patches
 			utils::hook::inject(0x1404398B2, VERSION);
 
 			// prevent servers overriding our fov
+			utils::hook::call(0x1401BB782, set_client_dvar_from_server_stub);
 			utils::hook::nop(0x1403D1195, 5);
-			utils::hook::nop(0x1400FAE36, 5); // Dvar_SetFloat inside LUI_CoD_LuaCall_StopFollow (function doesn't exist on dev builds)
+			utils::hook::nop(0x1400FAE36, 5);
 			utils::hook::set<uint8_t>(0x14019B9B9, 0xEB);
 
 			// some anti tamper thing that kills performance
@@ -316,14 +306,8 @@ namespace patches
 
 			game::Dvar_RegisterInt("scr_game_spectatetype", 1, 0, 99, game::DVAR_FLAG_REPLICATED);
 
-			// Disable Com_Error in NET_SendPacket
-			utils::hook::nop(0x1404D8543, 5);
-
 			// Prevent clients from ending the game as non host by sending 'end_game' lui notification
 			cmd_lui_notify_server_hook.create(0x1402E9390, cmd_lui_notify_server_stub);
-
-			com_quit_f_hook.create(0x1403D08C0, com_quit_f_stub);
-			sv_shutdown_hook.create(0x140440170, sv_shutdown_stub);
 		}
 
 		static void patch_sp()

src/client/component/rcon.cpp

@@ -86,7 +86,7 @@ namespace rcon
 				}
 
 				char clean_name[32]{};
-				game::I_strncpyz(clean_name, client->name, sizeof(clean_name));
+				strncpy_s(clean_name, client->name, _TRUNCATE);
 				game::I_CleanStr(clean_name);
 
 				buffer.append(utils::string::va("%3i %5i %3s %s %32s %16s %21s %5i\n",
@@ -96,8 +96,8 @@ namespace rcon
 				                                (client->header.state == 2) ? "CNCT" : (client->header.state == 1) ? "ZMBI" : utils::string::va("%4i", game::SV_GetClientPing(i)),
 				                                game::SV_GetGuid(i),
 				                                clean_name,
-				                                network::net_adr_to_string(client->header.netchan.remoteAddress),
-				                                client->header.netchan.remoteAddress.port)
+				                                network::net_adr_to_string(client->header.remoteAddress),
+				                                client->header.remoteAddress.port)
 				);
 			}
 

src/client/component/security.cpp

@@ -84,36 +84,6 @@ namespace security
 
 			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);
-
-			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);
-
-			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);
-
-			return len;
-		}
 	}
 
 	class component final : public component_interface
@@ -121,18 +91,11 @@ namespace security
 	public:
 		void post_unpack() override
 		{
-			// sprinf
-			utils::hook::call(SELECT_VALUE(0x1402203DF, 0x1402F0BAF), hud_elem_set_enum_string_stub);
-
 			if (game::environment::is_sp()) return;
 
 			// Patch vulnerability in PlayerCards_SetCachedPlayerData
 			utils::hook::call(0x1401BB909, set_cached_playerdata_stub);
 
-			// sprinf
-			utils::hook::call(0x140439075, sv_add_bot_stub);
-			utils::hook::call(0x14043932A, sv_add_test_client_stub);
-
 			// Patch entity overflow
 			utils::hook::jump(0x14044DE3A, assemble(remap_cached_entities_stub), true);
 

src/client/component/steam_proxy.cpp

@@ -26,8 +26,6 @@ namespace steam_proxy
 		ownership_state state_;
 
 		utils::binary_resource runner_file(RUNNER, "s1-mod-runner.exe");
-
-		bool is_disabled() { return true; }
 	}
 
 	class component final : public component_interface
@@ -35,7 +33,7 @@ namespace steam_proxy
 	public:
 		void post_load() override
 		{
-			if (game::environment::is_dedi() || is_disabled())
+			if (game::environment::is_dedi())
 			{
 				return;
 			}

src/client/component/ui_scripting.cpp

@@ -206,27 +206,6 @@ namespace ui_scripting
 			setup_functions();
 
 			lua["print"] = function(reinterpret_cast<game::hks::lua_function>(0x14007CB70));
-
-			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;
 

src/client/component/weapon.cpp

@@ -0,0 +1,113 @@
+#include <std_include.hpp>
+#include "loader/component_loader.hpp"
+
+#include "console.hpp"
+#include "fastfiles.hpp"
+
+#include "game/game.hpp"
+#include "game/dvars.hpp"
+
+#include <utils/hook.hpp>
+#include <utils/memory.hpp>
+
+namespace weapon
+{
+	namespace
+	{
+		utils::hook::detour g_setup_level_weapon_def_hook;
+		void g_setup_level_weapon_def_stub()
+		{
+			// precache level weapons first
+			g_setup_level_weapon_def_hook.invoke<void>();
+
+			std::vector<game::WeaponDef*> weapons;
+
+			// find all weapons in asset pools
+			fastfiles::enum_assets(game::ASSET_TYPE_WEAPON, [&weapons](game::XAssetHeader header)
+			{
+				weapons.push_back(reinterpret_cast<game::WeaponDef*>(header.data));
+			}, false);
+
+			// sort weapons
+			std::sort(weapons.begin(), weapons.end(), [](game::WeaponDef* weapon1, game::WeaponDef* weapon2)
+			{
+				return std::string_view(weapon1->name) <
+					std::string_view(weapon2->name);
+			});
+
+			// precache items
+			for (std::size_t i = 0; i < weapons.size(); i++)
+			{
+				//console::info("precaching weapon \"%s\"\n", weapons[i]->name);
+				game::G_GetWeaponForName(weapons[i]->name);
+			}
+		}
+
+		utils::hook::detour xmodel_get_bone_index_hook;
+		int xmodel_get_bone_index_stub(game::XModel* model, game::scr_string_t name, unsigned int offset, char* index)
+		{
+			auto result = xmodel_get_bone_index_hook.invoke<int>(model, name, offset, index);
+			if (result)
+			{
+				return result;
+			}
+
+			const auto original_index = *index;
+			const auto original_result = result;
+
+			if (name == game::SL_FindString("tag_weapon_right") ||
+				name == game::SL_FindString("tag_knife_attach"))
+			{
+				const auto tag_weapon = game::SL_FindString("tag_weapon");
+				result = xmodel_get_bone_index_hook.invoke<int>(model, tag_weapon, offset, index);
+				if (result)
+				{
+					console::info("using tag_weapon instead of %s (%s, %d, %d)\n", game::SL_ConvertToString(name), model->name, offset, *index);
+					return result;
+				}
+			}
+
+			*index = original_index;
+			result = original_result;
+
+			return result;
+		}
+
+		void cw_mismatch_error_stub(int, const char* msg, ...)
+		{
+			char buffer[0x100];
+
+			va_list ap;
+			va_start(ap, msg);
+
+			vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, msg, ap);
+
+			va_end(ap);
+
+			console::error(buffer);
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			if (!game::environment::is_mp())
+			{
+				return;
+			}
+
+			// precache all weapons that are loaded in zones
+			g_setup_level_weapon_def_hook.create(0x140340DE0, g_setup_level_weapon_def_stub);
+
+			// use tag_weapon if tag_weapon_right or tag_knife_attach are not found on model
+			xmodel_get_bone_index_hook.create(0x1404E2A50, xmodel_get_bone_index_stub);
+
+			// make custom weapon index mismatch not drop in CG_SetupCustomWeapon
+			utils::hook::call(0x1401E973D, cw_mismatch_error_stub);
+		}
+	};
+}
+
+REGISTER_COMPONENT(weapon::component)

src/client/game/dvars.cpp

@@ -36,13 +36,13 @@ namespace dvars
 
 	game::dvar_t* r_fullbright = nullptr;
 
+	game::dvar_t* cg_legacyCrashHandling = nullptr;
+
 	game::dvar_t* sv_cheats = nullptr;
 
 	game::dvar_t* com_developer = nullptr;
 	game::dvar_t* com_developer_script = nullptr;
 
-	game::dvar_t** fs_gameDirVar = nullptr;
-
 	std::string get_dvar_string(const std::string& dvar)
 	{
 		const auto* dvar_value = game::Dvar_FindVar(dvar.data());

src/client/game/dvars.hpp

@@ -35,13 +35,13 @@ namespace dvars
 
 	extern game::dvar_t* r_fullbright;
 
+	extern game::dvar_t* cg_legacyCrashHandling;
+
 	extern game::dvar_t* sv_cheats;
 
 	extern game::dvar_t* com_developer;
 	extern game::dvar_t* com_developer_script;
 
-	extern game::dvar_t** fs_gameDirVar;
-
 	std::string get_dvar_string(const std::string& dvar);
 	bool get_dvar_bool(const std::string& dvar);
 

src/client/game/engine/sv_game.cpp

@@ -1,181 +0,0 @@
-#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 != mp::CS_FREE);
-		if (drop->header.state == mp::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 == mp::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 < mp::CS_CLIENTLOADING)
-			{
-				continue;
-			}
-
-			SV_AddServerCommand(client, type, server_command_buf_large.get());
-		}
-	}
-
-	void SV_GameSendServerCommand(char 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);
-	}
-}

src/client/game/engine/sv_game.hpp

@@ -1,7 +0,0 @@
-#pragma once
-
-namespace game::engine
-{
-	void SV_SendServerCommand(mp::client_t* cl, svscmd_type type, const char* fmt, ...);
-	void SV_GameSendServerCommand(char clientNum, svscmd_type type, const char* text);
-}

src/client/game/game.cpp

@@ -30,13 +30,6 @@ namespace game
 		return !game::environment::is_sp() && *mp::virtualLobby_loaded == 1;
 	}
 
-	HANDLE Sys_OpenFileReliable(const char* filename)
-	{
-		return ::CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, nullptr,
-		                     OPEN_EXISTING,
-		                     FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, nullptr);
-	}
-
 	namespace environment
 	{
 		launcher::mode mode = launcher::mode::none;

src/client/game/game.hpp

@@ -66,8 +66,6 @@ namespace game
 
 	[[nodiscard]] bool VirtualLobby_Loaded();
 
-	[[nodiscard]] HANDLE Sys_OpenFileReliable(const char* filename);
-
 	[[nodiscard]] bool is_headless();
 	void show_error(const std::string& text, const std::string& title = "Error");
 }

src/client/game/structs.hpp

@@ -25,14 +25,6 @@ namespace game
 	typedef void(*BuiltinMethod)(scr_entref_t);
 	typedef void(*BuiltinFunction)();
 
-	enum ControllerIndex_t
-	{
-		INVALID_CONTROLLER_PORT = -1,
-		CONTROLLER_INDEX_0 = 0x0,
-		CONTROLLER_INDEX_FIRST = 0x0,
-		CONTROLLER_INDEX_COUNT = 0x1,
-	};
-
 	enum
 	{
 		VAR_UNDEFINED = 0x0,
@@ -863,11 +855,10 @@ namespace game
 		int readcount;
 		int bit;
 		int lastEntityRef;
+		netsrc_t targetLocalNetID;
 		int useZlib;
 	};
 
-	static_assert(sizeof(msg_t) == 0x38);
-
 	enum errorParm
 	{
 		ERR_FATAL = 0,
@@ -913,8 +904,6 @@ namespace game
 		DVAR_FLAG_LATCHED = 0x2,
 		DVAR_FLAG_CHEAT = 0x4,
 		DVAR_FLAG_REPLICATED = 0x8,
-		DVAR_FLAG_SCRIPTINFO = 0x10,
-		DVAR_FLAG_SERVERINFO = 0x400,
 		DVAR_FLAG_WRITE = 0x800,
 		DVAR_FLAG_READ = 0x2000,
 	};
@@ -933,7 +922,7 @@ namespace game
 		rgb = 9 // Color without alpha
 	};
 
-	union DvarValue
+	union dvar_value
 	{
 		bool enabled;
 		int integer;
@@ -976,9 +965,9 @@ namespace game
 		unsigned int flags;
 		dvar_type type;
 		bool modified;
-		DvarValue current;
-		DvarValue latched;
-		DvarValue reset;
+		dvar_value current;
+		dvar_value latched;
+		dvar_value reset;
 		dvar_limits domain;
 	};
 
@@ -1329,15 +1318,6 @@ namespace game
 		const char *name;
 	};
 
-	struct WeaponDef
-	{};
-
-	struct WeaponCompleteDef
-	{
-		const char* szInternalName;
-		WeaponDef* weapDef;
-	}; // Incomplete
-
 	union XAssetHeader
 	{
 		void* data;
@@ -1436,78 +1416,8 @@ namespace game
 
 	static_assert(sizeof(pml_t) == 0x130);
 
-	struct netProfilePacket_t
-	{
-		int iTime;
-		int iSize;
-		int bFragment;
-	};
-
-	struct netProfileStream_t
-	{
-		netProfilePacket_t packets[60];
-		int iCurrPacket;
-		int iBytesPerSecond;
-		int iLastBPSCalcTime;
-		int iCountedPackets;
-		int iCountedFragments;
-		int iFragmentPercentage;
-		int iLargestPacket;
-		int iSmallestPacket;
-	};
-
-	struct netProfileInfo_t
-	{
-		netProfileStream_t send;
-		netProfileStream_t recieve;
-	};
-
-	enum
-	{
-		DB_ZONE_COMMON = 0x1,
-		DB_ZONE_UI = 0x2,
-		DB_ZONE_GAME = 0x4,
-		DB_ZONE_LOAD = 0x8,
-		DB_ZONE_DEV = 0x10,
-		DB_ZONE_BASEMAP = 0x20,
-		DB_ZONE_TRANSIENT_POOL = 0x40,
-		DB_ZONE_TRANSIENT_MASK = 0x40,
-		DB_ZONE_CUSTOM = 0x1000,
-	};
-
-	enum FF_DIR
-	{
-		FFD_DEFAULT = 0x0,
-		FFD_MOD_DIR = 0x1,
-		FFD_USER_MAP = 0x2,
-	};
-
-	struct Sys_File
-	{
-		HANDLE handle;
-	};
-
-	enum DB_CompressorType
-	{
-		DB_COMPRESSOR_INVALID = 0x0,
-		DB_COMPRESSOR_ZLIB = 0x1,
-		DB_COMPRESSOR_UNK2 = 0x2,
-		DB_COMPRESSOR_PASSTHROUGH = 0x3,
-		DB_COMPRESSOR_LZX = 0x4,
-	};
-
 	namespace mp
 	{
-		enum
-		{
-			CS_FREE = 0x0,
-			CS_ZOMBIE = 0x1,
-			CS_RECONNECTING = 0x2,
-			CS_CONNECTED = 0x3,
-			CS_CLIENTLOADING = 0x4,
-			CS_ACTIVE = 0x5,
-		};
-
 		struct cachedSnapshot_t
 		{
 			int archivedFrame;
@@ -1560,141 +1470,33 @@ namespace game
 		{
 		};
 
-		struct netchan_t
-		{
-			int outgoingSequence;
-			netsrc_t sock;
-			int dropped;
-			int incomingSequence;
-			netadr_s remoteAddress;
-			int fragmentSequence;
-			int fragmentLength;
-			char* fragmentBuffer;
-			int fragmentBufferSize;
-			int unsentFragments;
-			int unsentFragmentStart;
-			int unsentLength;
-			char* unsentBuffer;
-			int unsentBufferSize;
-			netProfileInfo_t prof;
-		};
-
 		struct clientHeader_t
 		{
 			int state;
-			int sendAsActive;
-			int deltaMessage;
-			int rateDelayed;
-			int hasAckedBaselineData;
-			int hugeSnapshotSent;
-			netchan_t netchan;
-			float predictedOrigin[3];
-			int predictedOriginServerTime;
-			int migrationState;
-			unsigned int predictedVehicleSplineId;
-			int predictedVehicleTargetEntity;
-			float predictedVehicleOrigin[3];
-			int predictedVehicleServerTime;
-			int ackedMessage[32];
-			unsigned int ackedMessageCount;
-			int sentMessage[32];
-			int wasKillcam[32];
-			unsigned int sendMessageCount;
-			bool overrideDeltaMessage;
-			int overrideSequenceNumber;
-			int sequenceResume;
-			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];
-		};
-
-		struct usercmd_s
-		{
-			int serverTime;
-			unsigned int buttons;
-			int angles[3];
-			Weapon weapon;
-			Weapon offHand;
-			char forwardmove;
-			char rightmove;
-			unsigned __int16 airburstMarkDistance;
-			__int16 meleeChargeEnt;
-			unsigned __int8 meleeChargeDist;
-			char selectedLoc[2];
-			unsigned __int8 selectedLocAngle;
-			char remoteControlAngles[2];
-			char remoteControlMove[3];
-			unsigned int sightedClientsMask;
-			unsigned __int16 spawnTraceEntIndex;
-			unsigned int sightedSpawnsMask[2];
-			unsigned int partialSightedSpawnsMask[2];
-		};
-
-		static_assert(sizeof(usercmd_s) == 0x44);
+			char __pad0[36];
+			netadr_s remoteAddress;
+		}; // size = ?
 
 		struct client_t
 		{
 			clientHeader_t header;
-			const char* dropReason;
-			char userinfo[0x400];
+			char __pad0[3044];
 			int reliableSequence;
 			int reliableAcknowledge;
-			int reliableSent;
-			int messageAcknowledge;
-			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 __pad1[265864];
 			gentity_s* gentity; // 268976
-			char name[32];
-			int lastPacketTime;
-			int lastConnectTime;
+			char name[32]; // 268984
+			char __pad2[8];
 			int nextSnapshotTime; // 269024
-			char __pad3[532];
-			int pureAuthentic;
-			unsigned int streamSyncWaitBits;
-			unsigned int streamSyncWaitTimeout;
+			char __pad3[544];
 			LiveClientDropType liveDropRequest; // 269572
 			char __pad4[24];
 			TestClientType testClient; // 269600
 			char __pad5[391700];
 		}; // size = 661304
 
-		static_assert(offsetof(client_t, header.netchan.unsentFragments) == 0x54);
-		static_assert(offsetof(client_t, header.migrationState) == 0x660);
-		static_assert(offsetof(client_t, userinfo) == 0x820);
-		static_assert(offsetof(client_t, reliableSequence) == 0xC20);
-		static_assert(offsetof(client_t, reliableAcknowledge) == 0xC24);
-		static_assert(offsetof(client_t, reliableSent) == 0xC28);
-		static_assert(offsetof(client_t, messageAcknowledge) == 0xC2C);
-		static_assert(offsetof(client_t, largeCommandSequence) == 0xC30);
-		static_assert(offsetof(client_t, lastUsercmd) == 0x41848);
-		static_assert(offsetof(client_t, lastClientCommand) == 0x41AAC);
 		static_assert(offsetof(client_t, gentity) == 0x41AB0);
-		static_assert(offsetof(client_t, name) == 0x41AB8);
-		static_assert(offsetof(client_t, lastPacketTime) == 0x41AD8);
 		static_assert(offsetof(client_t, nextSnapshotTime) == 0x41AE0);
-		static_assert(offsetof(client_t, pureAuthentic) == 0x41CF8);
 		static_assert(offsetof(client_t, liveDropRequest) == 0x41D04);
 		static_assert(offsetof(client_t, testClient) == 0x41D20);
 		static_assert(sizeof(client_t) == 0xA1738);
@@ -1706,9 +1508,7 @@ namespace game
 		{
 			char __pad[56135];
 			int flags; // 56136
-		}; // Incomplete
-
-		static_assert(offsetof(gclient_s, flags) == 56136);
+		};
 
 		struct gentity_s
 		{
@@ -2151,4 +1951,39 @@ namespace game
 			HksError m_error;
 		};
 	}
+
+	enum DBAllocFlags : std::int32_t
+	{
+		DB_ZONE_NONE = 0x0,
+		DB_ZONE_COMMON = 0x1,
+		DB_ZONE_UI = 0x2,
+		DB_ZONE_GAME = 0x4,
+		DB_ZONE_LOAD = 0x8,
+		DB_ZONE_DEV = 0x10,
+		DB_ZONE_BASEMAP = 0x20,
+		DB_ZONE_TRANSIENT_POOL = 0x40,
+		DB_ZONE_TRANSIENT_MASK = 0x40,
+		DB_ZONE_CUSTOM = 0x1000 // added for custom zone loading
+	};
+
+	struct XZone
+	{
+		char name[64];
+		char pad_0040[432];
+	};
+	static_assert(sizeof(XZone) == 496);
+
+	struct WeaponDef
+	{
+		union
+		{
+			const char* szInternalName;
+			const char* name;
+		};
+	};
+
+	struct XModel
+	{
+		const char* name; // 0
+	};
 }

src/client/game/symbols.hpp

@@ -23,14 +23,13 @@ namespace game
 	WEAK symbol<CodPlayMode()> Com_GetCurrentCoDPlayMode{0, 0x1404C9690};
 	WEAK symbol<void(float, float, int)> Com_SetSlowMotion{0, 0x1403D19B0};
 	WEAK symbol<void()> Com_Quit_f{0x1402F9390, 0x1403D08C0};
-	WEAK symbol<void(const char* finalmsg)> Com_Shutdown{0x0, 0x1403D1BF0};
+	WEAK symbol<int(char* dest, int size, const char* fmt, ...)> Com_sprintf{0x0, 0x1404C97B0};
 
 	WEAK symbol<void(const char* cmdName, void (), cmd_function_s* allocedCmd)> Cmd_AddCommandInternal{0x1402EDDB0, 0x1403AF2C0};
 	WEAK symbol<void(int localClientNum, int controllerIndex, const char* text)> Cmd_ExecuteSingleCommand{0x1402EE350, 0x1403AF900};
-	WEAK symbol<void(int index)> Cmd_RemoveCommand{0x1402EE910, 0x1403AFEF0};
+	WEAK symbol<void(const char*)> Cmd_RemoveCommand{0x1402EE910, 0x1403AFEF0};
 	WEAK symbol<void(const char* text_in)> Cmd_TokenizeString{0x1402EEA30, 0x1403B0020};
 	WEAK symbol<void()> Cmd_EndTokenizeString{0x1402EE000, 0x1403AF5B0};
-	WEAK symbol<int(char* dest, int size, const char* fmt, ...)> Com_sprintf{0x140378E30, 0x1404C97B0};
 
 	WEAK symbol<void(const char* message)> Conbuf_AppendText{0x14038F220, 0x1404D9040};
 
@@ -60,7 +59,7 @@ namespace game
 	WEAK symbol<int(const RawFile* rawfile)> DB_GetRawFileLen{0x14017E890, 0x14026FCC0};
 	WEAK symbol<void(const RawFile* rawfile, char* buf, int size)> DB_GetRawBuffer{0x14017E750, 0x14026FB90};
 	WEAK symbol<char*(const char* filename, char* buf, int size)> DB_ReadRawFile{0x140180E30, 0x140273080};
-	WEAK symbol<int(XAssetType type, void** assets, int maxCount)> DB_GetAllXAssetOfType_FastFile{0x0, 0x14026F970};
+	WEAK symbol<bool(const char* filename)> DB_IsLocalized{0x14017EC80, 0x140270190};
 
 	WEAK symbol<dvar_t*(const char* name)> Dvar_FindVar{0x140370860, 0x1404BF8B0};
 	WEAK symbol<void(const dvar_t* dvar)> Dvar_ClearModified{0x140370700, 0x1404BF690};
@@ -71,7 +70,7 @@ namespace game
 	WEAK symbol<void(const dvar_t* dvar, const char* string)> Dvar_SetString{0x140373DE0, 0x1404C3610};
 	WEAK symbol<void(const dvar_t* dvar, bool value)> Dvar_SetBool{0x0, 0x1404C1F30};
 	WEAK symbol<void(const char*, const char*, DvarSetSource)> Dvar_SetFromStringByNameFromSource{0x1403737D0, 0x1404C2E40};
-	WEAK symbol<const char*(dvar_t* dvar, DvarValue value)> Dvar_ValueToString{0x140374E10, 0x1404C47B0};
+	WEAK symbol<const char*(dvar_t* dvar, dvar_value value)> Dvar_ValueToString{0x140374E10, 0x1404C47B0};
 
 	WEAK symbol<dvar_t*(const char* dvarName, bool value, unsigned int flags)> Dvar_RegisterBool{0x140371850, 0x1404C0BE0};
 	WEAK symbol<dvar_t*(const char* dvarName, const char** valueList, int defaultIndex, unsigned int flags)> Dvar_RegisterEnum{0x140371B30, 0x1404C0EC0};
@@ -99,13 +98,13 @@ namespace game
 	WEAK symbol<unsigned int(unsigned int, unsigned int)> GetVariable{0x0, 0x1403F3730};
 
 	WEAK symbol<void()> G_Glass_Update{0x14021D540, 0x1402EDEE0};
+
 	WEAK symbol<int(int clientNum)> G_GetClientScore{0, 0x1402F6AB0};
 	WEAK symbol<unsigned int(const char* name)> G_GetWeaponForName{0x140274590, 0x14033FF60};
 	WEAK symbol<int(playerState_s* ps, unsigned int weapon, int dualWield, int startInAltMode, int, int, int, char)> G_GivePlayerWeapon{0x1402749B0, 0x140340470};
 	WEAK symbol<void(playerState_s* ps, unsigned int weapon, int hadWeapon)> G_InitializeAmmo{0x1402217F0, 0x1402F22B0};
 	WEAK symbol<void(int clientNum, unsigned int weapon)> G_SelectWeapon{0x140275380, 0x140340D50};
 	WEAK symbol<int(playerState_s* ps, unsigned int weapon)> G_TakePlayerWeapon{0x1402754E0, 0x1403411D0};
-	WEAK symbol<void()> G_SetupLevelWeaponDef{0x0, 0x140340DE0};
 
 	WEAK symbol<char*(char* string)> I_CleanStr{0x140379010, 0x1404C99A0};
 
@@ -114,7 +113,6 @@ namespace game
 	WEAK symbol<const char*(int, int, int)> Key_KeynumToString{0x14013F380, 0x140207C50};
 
 	WEAK symbol<unsigned int(int)> Live_SyncOnlineDataFlags{0x1404459A0, 0x140562830};
-	WEAK symbol<void(int localControllerIndex)> LiveStorage_StatsWriteNotNeeded{0x1402F51F0, 0x1403C3CD0};
 
 	WEAK symbol<void(int localClientNum, const char* menuName, int isPopup, int isModal, unsigned int isExclusive)> LUI_OpenMenu{0, 0x14048E450};
 	WEAK symbol<void()> LUI_EnterCriticalSection{0, 0x1400D2B10};
@@ -188,7 +186,7 @@ namespace game
 	WEAK symbol<void(mp::client_t* client)> SV_DropClient{0, 0x140438A30};
 	WEAK symbol<void(mp::client_t*, const char*, int)> SV_ExecuteClientCommand{0, 0x15121D8E6};
 	WEAK symbol<void(int localClientNum)> SV_FastRestart{0, 0x1404374E0};
-	WEAK symbol<int(mp::client_t* client, const unsigned char* cmd, int cmdSize)> SV_CanReplaceServerCommand{0x0, 0x140441A00};
+	WEAK symbol<void(int clientNum, svscmd_type type, const char* text)> SV_GameSendServerCommand{0x1403F3A70, 0x14043E120};
 	WEAK symbol<const char*(int clientNum)> SV_GetGuid{0, 0x14043E1E0};
 	WEAK symbol<int(int clientNum)> SV_GetClientPing{0, 0x14043E1C0};
 	WEAK symbol<playerState_s*(int num)> SV_GetPlayerstateForClientNum{0x1403F3AB0, 0x14043E260};
@@ -216,6 +214,7 @@ namespace game
 	WEAK symbol<void(unsigned int localClientNum, const char** args)> UI_RunMenuScript{0, 0x140490060};
 	WEAK symbol<int(const char* text, int maxChars, Font_s* font, float scale)> UI_TextWidth{0, 0x140492380};
 
+	WEAK symbol<const char* ()> SEH_GetCurrentLanguageCode{0x140339280, 0x140474560};
 	WEAK symbol<const char*()> SEH_GetCurrentLanguageName{0x140339300, 0x1404745C0};
 
 	WEAK symbol<void*(unsigned int size, unsigned int alignment, unsigned int type, int source)> PMem_AllocFromSource_NoDebug{0x1403775F0, 0x1404C7BA0};
@@ -224,11 +223,6 @@ namespace game
 	WEAK symbol<void(unsigned __int64 markPos)> LargeLocalResetToMark{0x140369C40, 0x1404B6790};
 
 	WEAK symbol<void(char* dest, const char* src, int destsize)> I_strncpyz{0x1403793B0, 0x1404C9E60};
-	WEAK symbol<void(char* dest, int size, const char* src)> I_strncat{0x1403792E0, 0x1404C9D90};
-
-	WEAK symbol<void(const char* pszCommand, char* pszBuffer, int iBufferSize)> MSG_WriteReliableCommandToBuffer{0x0, 0x1403E1090};
-
-	WEAK symbol<int(const char* s0, const char* s1, int n)> I_strnicmp{0x1403793E0, 0x1404C9E90};
 
 	WEAK symbol<void*(jmp_buf* Buf, int Value)> longjmp{0x14059C5C0, 0x1406FD930};
 	WEAK symbol<int(jmp_buf* Buf)> _setjmp{0x14059CD00, 0x1406FE070};
@@ -277,6 +271,9 @@ namespace game
 
 	WEAK symbol<unsigned int> tls_index{0x14F65DAF0, 0x150085C44};
 
+	WEAK symbol<unsigned int> g_zoneCount{0x0, 0x14379DBCC};
+	WEAK symbol<XZone> g_zones{0x0, 0x143B50618};
+
 	namespace mp
 	{
 		WEAK symbol<gentity_s> g_entities{0, 0x144758C70};

src/client/main.cpp

@@ -64,7 +64,9 @@ 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);
 	}
 

src/client/std_include.hpp

@@ -54,7 +54,6 @@
 #include <functional>
 #include <iostream>
 #include <map>
-#include <memory>
 #include <mutex>
 #include <optional>
 #include <queue>

src/common/utils/string.cpp

@@ -176,4 +176,52 @@ namespace utils::string
 
 		return str;
 	}
+
+	bool is_numeric(const std::string& text)
+	{
+		return std::to_string(atoi(text.data())) == text;
+	}
+
+	bool find_lower(const std::string& a, const std::string& b)
+	{
+		return to_lower(a).find(to_lower(b)) != std::string::npos;
+	}
+
+	bool strstr_lower(const char* a, const char* b)
+	{
+		const char* a_ = a;
+		const char* b_ = b;
+
+		while (*a_ != '\0' && *b_ != '\0')
+		{
+			if (*b_ == '*' || std::tolower(*a_) == std::tolower(*b_))
+			{
+				b_++;
+			}
+			else
+			{
+				b_ = b;
+			}
+
+			a_++;
+		}
+
+		return *b_ == '\0';
+	}
+
+	void set_clipboard_data(const std::string& text)
+	{
+		const auto len = text.size() + 1;
+		const auto mem = GlobalAlloc(GMEM_MOVEABLE, len);
+
+		memcpy(GlobalLock(mem), text.data(), len);
+		GlobalUnlock(mem);
+
+		if (OpenClipboard(nullptr))
+		{
+			EmptyClipboard();
+			SetClipboardData(CF_TEXT, mem);
+			CloseClipboard();
+		}
+	}
 }

src/common/utils/string.hpp

@@ -95,4 +95,12 @@ namespace utils::string
 	std::wstring convert(const std::string& str);
 
 	std::string replace(std::string str, const std::string& from, const std::string& to);
+
+	bool is_numeric(const std::string& text);
+
+	bool find_lower(const std::string& a, const std::string& b);
+
+	bool strstr_lower(const char* a, const char* b);
+
+	void set_clipboard_data(const std::string& text);
 }

src/common/utils/toast.cpp

@@ -0,0 +1,109 @@
+#include "toast.hpp"
+#include "string.hpp"
+
+#pragma warning(push)
+#pragma warning(disable: 6387)
+#include <wintoastlib.h>
+#pragma warning(pop)
+
+namespace utils
+{
+	namespace
+	{
+		bool initialize()
+		{
+			static bool initialized = false;
+			static bool success = false;
+			if (initialized)
+			{
+				return success;
+			}
+
+			initialized = true;
+			auto* instance = WinToastLib::WinToast::instance();
+			if (!instance)
+			{
+				success = false;
+				return success;
+			}
+
+			instance->setAppName(L"s1-mod");
+			instance->setAppUserModelId(
+				WinToastLib::WinToast::configureAUMI(L"AlterWare", L"s1-mod", L"", L"20201212"));
+
+			WinToastLib::WinToast::WinToastError error;
+			success = instance->initialize(&error);
+
+			return success;
+		}
+
+		class toast_handler : public WinToastLib::IWinToastHandler
+		{
+		public:
+			void toastActivated() const override
+			{
+			}
+
+			void toastActivated(const int /*actionIndex*/) const override
+			{
+			}
+
+			void toastFailed() const override
+			{
+			}
+
+			void toastDismissed(WinToastDismissalReason /*state*/) const override
+			{
+			}
+		};
+	}
+
+	toast::toast(const int64_t id)
+		: id_(id)
+	{
+	}
+
+	toast::operator bool() const
+	{
+		return this->id_ >= 0;
+	}
+
+	void toast::hide() const
+	{
+		if (this->operator bool())
+		{
+			WinToastLib::WinToast::instance()->hideToast(this->id_);
+		}
+	}
+
+	toast toast::show(const std::string& title, const std::string& text)
+	{
+		if (!initialize())
+		{
+			return toast{-1};
+		}
+
+		WinToastLib::WinToastTemplate toast_template(WinToastLib::WinToastTemplate::Text02);
+		toast_template.setTextField(string::convert(title), WinToastLib::WinToastTemplate::FirstLine);
+		toast_template.setTextField(string::convert(text), WinToastLib::WinToastTemplate::SecondLine);
+		toast_template.setDuration(WinToastLib::WinToastTemplate::Long);
+
+		return toast{WinToastLib::WinToast::instance()->showToast(toast_template, new toast_handler())};
+	}
+
+	toast toast::show(const std::string& title, const std::string& text, const std::string& image)
+	{
+		if (!initialize())
+		{
+			return {-1};
+		}
+
+		WinToastLib::WinToastTemplate toast_template(WinToastLib::WinToastTemplate::ImageAndText02);
+		toast_template.setTextField(string::convert(title), WinToastLib::WinToastTemplate::FirstLine);
+		toast_template.setTextField(string::convert(text), WinToastLib::WinToastTemplate::SecondLine);
+		toast_template.setDuration(WinToastLib::WinToastTemplate::Long);
+		toast_template.setImagePath(string::convert(image));
+
+		return {WinToastLib::WinToast::instance()->showToast(toast_template, new toast_handler())};
+	}
+}

src/common/utils/toast.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <string>
+
+namespace utils
+{
+	class toast
+	{
+	public:
+		static toast show(const std::string& title, const std::string& text);
+		static toast show(const std::string& title, const std::string& text, const std::string& image);
+
+		operator bool() const;
+		void hide() const;
+
+	private:
+		toast(int64_t id);
+		int64_t id_;
+	};
+}