src/client/component/auth.cpp

@@ -82,7 +82,7 @@ namespace auth
 			return key;
 		}
 
-		int send_connect_data_stub(game::netsrc_t sock, game::netadr_s* adr, const char* format, const int len)
+		int send_connect_data_stub(game::netsrc_t sock, game::netadr_t* adr, const char* format, const int len)
 		{
 			std::string connect_string(format, len);
 			game::SV_Cmd_TokenizeString(connect_string.data());
@@ -116,7 +116,7 @@ namespace auth
 			return true;
 		}
 
-		void direct_connect(game::netadr_s* from, game::msg_t* msg)
+		void direct_connect(game::netadr_t* from, game::msg_t* msg)
 		{
 			const auto offset = sizeof("connect") + 4;
 

src/client/component/bots.cpp

@@ -21,7 +21,7 @@ namespace bots
 
 		bool can_add()
 		{
-			return party::get_client_count() < *game::mp::svs_clientCount;
+			return party::get_client_count() < game::mp::svs->clientCount;
 		}
 
 		void bot_team_join(const int entity_num)
@@ -29,14 +29,14 @@ namespace bots
 			// schedule the select team call
 			scheduler::once([entity_num]()
 			{
-				game::SV_ExecuteClientCommand(&game::mp::svs_clients[entity_num],
+				game::SV_ExecuteClientCommand(&game::mp::svs->clients[entity_num],
 				                              utils::string::va("lui 68 2 %i", *game::mp::sv_serverId_value),
 				                              false);
 
 				// scheduler the select class call
 				scheduler::once([entity_num]()
 				{
-					game::SV_ExecuteClientCommand(&game::mp::svs_clients[entity_num],
+					game::SV_ExecuteClientCommand(&game::mp::svs->clients[entity_num],
 					                              utils::string::va("lui 5 %i %i", (rand() % 5) + 10,
 					                                                *game::mp::sv_serverId_value), false);
 				}, scheduler::pipeline::server, 1s);
@@ -144,7 +144,7 @@ namespace bots
 		{
 			bot_names_received = false;
 
-			game::netadr_s master{};
+			game::netadr_t master{};
 			if (server_list::get_master_server(master))
 			{
 				console::info("Getting bots...\n");
@@ -175,7 +175,7 @@ namespace bots
 					num_bots = std::strtoul(params.get(1), nullptr, 10);
 				}
 
-				num_bots = std::min(num_bots, static_cast<std::size_t>(*game::mp::svs_clientCount));
+				num_bots = std::min(num_bots, static_cast<std::size_t>(game::mp::svs->clientCount));
 
 				console::info("Spawning %zu %s\n", num_bots, (num_bots == 1 ? "bot" : "bots"));
 
@@ -198,9 +198,9 @@ namespace bots
 				parse_bot_names_from_file();
 			}
 
-			network::on("getbotsResponse", [](const game::netadr_s& target, const std::string& data)
+			network::on("getbotsResponse", [](const game::netadr_t& target, const std::string& data)
 			{
-				game::netadr_s master{};
+				game::netadr_t master{};
 				if (server_list::get_master_server(master) && !bot_names_received && target == master)
 				{
 					bot_names = utils::string::split(data, '\n');

src/client/component/branding.cpp

@@ -41,8 +41,7 @@ namespace branding
 			localized_strings::override("LUA_MENU_LEGAL_COPYRIGHT", "iw6-mod: " VERSION " by AlterWare.\n");
 
 			utils::hook::call(SELECT_VALUE(0x1403BDABA, 0x140414424), dvar_set_string_stub);
-			ui_get_formatted_build_number_hook.create(
-				SELECT_VALUE(0x140415FD0, 0x1404D7C00), ui_get_formatted_build_number_stub);
+			ui_get_formatted_build_number_hook.create(game::LiveStorage_FetchFFotD, ui_get_formatted_build_number_stub);
 
 			scheduler::loop([]()
 			{

src/client/component/colors.cpp

@@ -86,18 +86,28 @@ namespace colors
 			return string;
 		}
 
-		size_t get_client_name_stub(const int local_client_num, const int index, char* buf, const int size,
-		                            const size_t unk, const size_t unk2)
+		size_t get_client_name_stub(const int local_client_num, const int index, char* name_buf, 
+									const int max_name_size, char* clan_buf, const int max_clan_size)
 		{
-			// CL_GetClientName (CL_GetClientNameAndClantag?)
-			const auto result = reinterpret_cast<size_t(*)(int, int, char*, int, size_t, size_t)>(0x1402CF790)(
-				local_client_num, index, buf, size, unk, unk2);
+			// CL_GetClientNameAndClanTag (wrapper for CL_GetClientNameAndClanTagColorize)
+			const auto result = reinterpret_cast<size_t(*)(int, int, char*, int, char*, int)>(0x1402CF790)(
+				local_client_num, index, name_buf, max_name_size, clan_buf, max_clan_size);
 
-			utils::string::strip(buf, buf, size);
+			utils::string::strip(name_buf, name_buf, static_cast<size_t>(max_name_size));
 
 			return result;
 		}
 
+		int clean_agent_name_stub(char* out, int max_size, const char* fmt, const char* in)
+		{
+			// format agent overhead name like [%s]
+			const auto length = sprintf_s(out, max_size, fmt, in);
+
+			utils::string::strip(in, out, std::min(static_cast<size_t>(length), static_cast<size_t>(max_size)));
+
+			return length;
+		}
+
 		void rb_lookup_color_stub(const char index, DWORD* color)
 		{
 			*color = RGB(255, 255, 255);
@@ -143,6 +153,9 @@ namespace colors
 				// don't apply colors to overhead names
 				utils::hook::call(0x14025CE79, get_client_name_stub);
 
+				// don't apply colors to overhead names of agents (like dogs or juggernauts)
+				utils::hook::call(0x1402CF760, clean_agent_name_stub);
+
 				// patch I_CleanStr
 				utils::hook::jump(0x1404F63C0, i_clean_str_stub);
 			}

src/client/component/command.cpp

@@ -194,7 +194,7 @@ namespace command
 
 	void add_raw(const char* name, void (*callback)())
 	{
-		game::Cmd_AddCommandInternal(name, callback, utils::memory::get_allocator()->allocate<game::cmd_function_s>());
+		game::Cmd_AddCommandInternal(name, callback, utils::memory::get_allocator()->allocate<game::cmd_function_t>());
 	}
 
 	void add(const char* name, const std::function<void(const params&)>& callback)
@@ -318,7 +318,7 @@ namespace command
 				}
 
 				console::info("================================ COMMAND DUMP =====================================\n");
-				game::cmd_function_s* cmd = *game::cmd_functions;
+				game::cmd_function_t* cmd = *game::cmd_functions;
 				auto i = 0;
 				while (cmd)
 				{

src/client/component/dedicated.cpp

@@ -110,7 +110,7 @@ namespace dedicated
 				return;
 			}
 
-			game::netadr_s target{};
+			game::netadr_t target{};
 			if (server_list::get_master_server(target))
 			{
 				network::send(target, "heartbeat", "IW6");

src/client/component/dedicated_info.cpp

@@ -41,7 +41,7 @@ namespace dedicated_info
 
 				for (auto i = 0; i < sv_maxclients->current.integer; i++)
 				{
-					auto* client = &game::mp::svs_clients[i];
+					auto* client = &game::mp::svs->clients[i];
 					auto* self = &game::mp::g_entities[i];
 
 					if (client->header.state > game::CS_FREE && self && self->client)
@@ -59,7 +59,7 @@ namespace dedicated_info
 				utils::string::strip(sv_hostname->current.string, cleaned_hostname.data(),
 					cleaned_hostname.size() + 1);
 
-				console::set_title(utils::string::va("%s on %s [%d/%d] (%d)", cleaned_hostname.data(),
+				console::set_title(utils::string::va("%s on %s [%d/%d] (%d)", cleaned_hostname.c_str(),
 				                                     mapname->current.string, client_count,
 				                                     sv_maxclients->current.integer, bot_count));
 			}, scheduler::pipeline::main, 1s);

src/client/component/discord.cpp

@@ -54,8 +54,8 @@ namespace discord
 
 				discord_presence.details = utils::string::va("%s on %s", gametype, map);
 
-				discord_presence.partySize = game::mp::cgArray->snap != nullptr
-					? game::mp::cgArray->snap->numClients
+				discord_presence.partySize = game::mp::cg->snap != nullptr
+					? game::mp::cg->snap->numClients
 					: 1;
 
 				if (game::Dvar_GetBool("xblive_privatematch"))
@@ -65,13 +65,13 @@ namespace discord
 				}
 				else
 				{
-					auto* host_name = reinterpret_cast<char*>(0x14187EBC4);
+					auto* host_name = game::mp::cgs->szHostName;
 					utils::string::strip(host_name, host_name, std::strlen(host_name) + 1);
 
 					discord_presence.state = host_name;
 					discord_presence.partyMax = party::server_client_count();
 
-					std::hash<game::netadr_s> hash_fn;
+					std::hash<game::netadr_t> hash_fn;
 					static const auto nonce = utils::cryptography::random::get_integer();
 
 					const auto& address = party::get_target();

src/client/component/dvar_cheats.cpp

@@ -5,6 +5,7 @@
 #include "game/dvars.hpp"
 
 #include "console.hpp"
+#include "demo_playback.hpp"
 
 #include <utils/hook.hpp>
 #include <utils/string.hpp>
@@ -13,6 +14,12 @@ namespace dvar_cheats
 {
 	void apply_sv_cheats(const game::dvar_t* dvar, const game::DvarSetSource source, game::dvar_value* value)
 	{
+		// return early because sv_cheats is enabled when playing back demos
+		if (demo_playback::playing())
+		{
+			return;
+		}
+
 		if (dvar && dvar->name == "sv_cheats"s)
 		{
 			// if dedi, do not allow internal to change value so servers can allow cheats if they want to
@@ -110,7 +117,7 @@ namespace dvar_cheats
 		a.jmp(0x1404F0D74);
 	});
 
-	void cg_set_client_dvar_from_server(const int local_client_num, game::mp::cg_s* cg, const char* dvar_id, const char* value)
+	void cg_set_client_dvar_from_server(const int local_client_num, game::mp::cg_t* cg, const char* dvar_id, const char* value)
 	{
 		if (dvar_id == "cg_fov"s || dvar_id == "com_maxfps"s)
 		{

src/client/component/fps.cpp

@@ -1,5 +1,6 @@
 #include <std_include.hpp>
 #include "loader/component_loader.hpp"
+#include "fps.hpp"
 #include "scheduler.hpp"
 
 #include "game/game.hpp"
@@ -74,6 +75,23 @@ namespace fps
 			++data->index;
 		}
 
+		void enforce_fps_limit()
+		{
+			const auto* maxfps = game::Dvar_FindVar("com_maxfps");
+			const auto max = (maxfps) ? std::min(2 * maxfps->current.integer, maxfps->domain.integer.max + 250) : 1250;
+			const auto fps = static_cast<std::int32_t>(static_cast<float>(1000.0f /
+				static_cast<float>(cg_perf.average)) + 9.313225746154785e-10);
+
+			if (fps > max)
+			{
+				// workaround to limit fps
+				scheduler::once([]()
+				{
+					std::this_thread::sleep_for(std::chrono::milliseconds(5));
+				}, scheduler::pipeline::renderer);
+			}
+		}
+
 		void perf_update()
 		{
 			cg_perf.count = 32;
@@ -84,6 +102,7 @@ namespace fps
 			cg_perf.previous_ms = cg_perf.current_ms;
 
 			perf_calc_fps(&cg_perf, cg_perf.frame_ms);
+			enforce_fps_limit();
 
 			utils::hook::invoke<void>(SELECT_VALUE(0x1405806E0, 0x140658E30));
 		}
@@ -155,6 +174,11 @@ namespace fps
 		}
 	}
 
+	float get_avg_fps()
+	{
+		return 1000.0f / (cg_perf.average + std::numeric_limits<float>::epsilon());
+	}
+
 	class component final : public component_interface
 	{
 	public:

src/client/component/fps.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace fps
+{
+	[[nodiscard]] float get_avg_fps();
+}

src/client/component/game_console.cpp

@@ -505,7 +505,7 @@ namespace game_console
 	{
 		if (key == game::keyNum_t::K_F10)
 		{
-			if(game::mp::svs_clients[localClientNum].header.state > game::CS_FREE)
+			if(game::mp::svs->clients[localClientNum].header.state > game::CS_FREE)
 			{
 				return false;
 			}
@@ -674,7 +674,7 @@ namespace game_console
 			}
 		}
 
-		game::cmd_function_s* cmd = (*game::cmd_functions);
+		game::cmd_function_t* cmd = (*game::cmd_functions);
 		while (cmd)
 		{
 			if (cmd->name)

src/client/component/gameplay.cpp

@@ -133,7 +133,7 @@ namespace gameplay
 			return jump_height;
 		}
 
-		void jump_apply_slowdown_stub(game::mp::playerState_s* ps)
+		void jump_apply_slowdown_stub(game::mp::playerState_t* ps)
 		{
 			assert(ps->pm_flags & game::PMF_JUMPING);
 
@@ -163,7 +163,7 @@ namespace gameplay
 			}
 		}
 
-		float jump_get_slowdown_friction(game::mp::playerState_s* ps)
+		float jump_get_slowdown_friction(game::mp::playerState_t* ps)
 		{
 			assert(ps->pm_flags & game::PMF_JUMPING);
 			assert(ps->pm_time <= game::JUMP_LAND_SLOWDOWN_TIME);
@@ -181,7 +181,7 @@ namespace gameplay
 			return 2.5f;
 		}
 
-		float jump_reduce_friction_stub(game::mp::playerState_s* ps)
+		float jump_reduce_friction_stub(game::mp::playerState_t* ps)
 		{
 			float control;
 
@@ -199,7 +199,7 @@ namespace gameplay
 			return control;
 		}
 
-		float jump_get_land_factor(game::mp::playerState_s* ps)
+		float jump_get_land_factor(game::mp::playerState_t* ps)
 		{
 			assert(ps->pm_flags & game::PMF_JUMPING);
 			assert(ps->pm_time <= game::JUMP_LAND_SLOWDOWN_TIME);
@@ -219,9 +219,9 @@ namespace gameplay
 
 		void jump_start_stub(game::pmove_t* pm, game::pml_t* pml, float height)
 		{
-			static_assert(offsetof(game::mp::playerState_s, groundEntityNum) == 0x70);
-			static_assert(offsetof(game::mp::playerState_s, pm_time) == 0x8);
-			static_assert(offsetof(game::mp::playerState_s, sprintState.sprintButtonUpRequired) == 0x240);
+			static_assert(offsetof(game::mp::playerState_t, groundEntityNum) == 0x70);
+			static_assert(offsetof(game::mp::playerState_t, pm_time) == 0x8);
+			static_assert(offsetof(game::mp::playerState_t, sprintState.sprintButtonUpRequired) == 0x240);
 			static_assert(offsetof(game::pml_t, frametime) == 0x24);
 			static_assert(offsetof(game::pml_t, walking) == 0x2C);
 			static_assert(offsetof(game::pml_t, groundPlane) == 0x30);
@@ -229,9 +229,9 @@ namespace gameplay
 
 			float factor;
 			float velocity_sqrd;
-			game::mp::playerState_s* ps;
+			game::mp::playerState_t* ps;
 
-			ps = static_cast<game::mp::playerState_s*>(pm->ps);
+			ps = static_cast<game::mp::playerState_t*>(pm->ps);
 
 			assert(ps);
 
@@ -295,7 +295,7 @@ namespace gameplay
 			}
 		}
 
-		void pm_weapon_use_ammo_stub(game::playerState_s* ps, game::Weapon weapon,
+		void pm_weapon_use_ammo_stub(game::playerState_t* ps, game::Weapon weapon,
 			bool is_alternate, int amount, game::PlayerHandIndex hand)
 		{
 			if (!dvars::player_sustainAmmo->current.enabled)
@@ -304,10 +304,10 @@ namespace gameplay
 			}
 		}
 
-		game::mp::gentity_s* weapon_rocket_launcher_fire_stub(game::mp::gentity_s* ent, game::Weapon weapon, float spread, game::weaponParms* wp,
+		game::mp::gentity_t* weapon_rocket_launcher_fire_stub(game::mp::gentity_t* ent, game::Weapon weapon, float spread, game::weaponParms* wp,
 			const float* gun_vel, game::mp::missileFireParms* fire_parms, bool magic_bullet)
 		{
-			auto* result = utils::hook::invoke<game::mp::gentity_s*>(0x1403DB8A0, ent, weapon, spread, wp, gun_vel, fire_parms, magic_bullet);
+			auto* result = utils::hook::invoke<game::mp::gentity_t*>(0x1403DB8A0, ent, weapon, spread, wp, gun_vel, fire_parms, magic_bullet);
 
 			if (ent->client != nullptr && wp->weapDef->inventoryType != game::WEAPINVENTORY_EXCLUSIVE)
 			{

src/client/component/input.cpp

@@ -50,8 +50,8 @@ namespace input
 				return;
 			}
 
-			cl_char_event_hook.create(SELECT_VALUE(0x14023CE50, 0x1402C2AE0), cl_char_event_stub);
-			cl_key_event_hook.create(SELECT_VALUE(0x14023D070, 0x1402C2CE0), cl_key_event_stub);
+			cl_char_event_hook.create(game::CL_CharEvent, cl_char_event_stub);
+			cl_key_event_hook.create(game::CL_KeyEvent, cl_key_event_stub);
 		}
 	};
 }

src/client/component/network.cpp

@@ -20,7 +20,7 @@ namespace network
 			return callbacks;
 		}
 
-		bool handle_command(game::netadr_s* address, const char* command, game::msg_t* message)
+		bool handle_command(game::netadr_t* address, const char* command, game::msg_t* message)
 		{
 			const auto cmd_string = utils::string::to_lower(command);
 			auto& callbacks = get_callbacks();
@@ -61,7 +61,7 @@ namespace network
 			a.jmp(0x1402C64EE);
 		}
 
-		int net_compare_base_address(const game::netadr_s* a1, const game::netadr_s* a2)
+		int net_compare_base_address(const game::netadr_t* a1, const game::netadr_t* a2)
 		{
 			if (a1->type == a2->type)
 			{
@@ -83,12 +83,12 @@ namespace network
 			return false;
 		}
 
-		int net_compare_address(const game::netadr_s* a1, const game::netadr_s* a2)
+		int net_compare_address(const game::netadr_t* a1, const game::netadr_t* a2)
 		{
 			return net_compare_base_address(a1, a2) && a1->port == a2->port;
 		}
 
-		void reconnect_migrated_client(game::mp::client_t*, game::netadr_s* from, const int, const int, const char*, const char*, bool)
+		void reconnect_migrated_client(game::mp::client_t*, game::netadr_t* from, const int, const int, const char*, const char*, bool)
 		{
 			// This happens when a client tries to rejoin after being recently disconnected, OR by a duplicated guid
 			// We don't want this to do anything. It decides to crash seemingly randomly
@@ -107,14 +107,14 @@ namespace network
 		get_callbacks()[utils::string::to_lower(command)] = callback;
 	}
 
-	int dw_send_to_stub(const int size, const char* src, game::netadr_s* addr)
+	int dw_send_to_stub(const int size, const char* src, game::netadr_t* addr)
 	{
 		sockaddr s = {};
 		game::NetadrToSockadr(addr, &s);
 		return sendto(*game::query_socket, src, size, 0, &s, 16) >= 0;
 	}
 
-	void send(const game::netadr_s& address, const std::string& command, const std::string& data, const char separator)
+	void send(const game::netadr_t& address, const std::string& command, const std::string& data, const char separator)
 	{
 		std::string packet = "\xFF\xFF\xFF\xFF";
 		packet.append(command);
@@ -124,7 +124,7 @@ namespace network
 		send_data(address, packet);
 	}
 
-	void send_data(const game::netadr_s& address, const std::string& data)
+	void send_data(const game::netadr_t& address, const std::string& data)
 	{
 		if (address.type == game::NA_LOOPBACK)
 		{
@@ -136,12 +136,12 @@ namespace network
 		}
 	}
 
-	bool are_addresses_equal(const game::netadr_s& a, const game::netadr_s& b)
+	bool are_addresses_equal(const game::netadr_t& a, const game::netadr_t& b)
 	{
 		return net_compare_address(&a, &b);
 	}
 
-	const char* net_adr_to_string(const game::netadr_s& a)
+	const char* net_adr_to_string(const game::netadr_t& a)
 	{
 		if (a.type == game::NA_LOOPBACK)
 		{
@@ -286,7 +286,7 @@ namespace network
 				if (!game::environment::is_dedi())
 				{
 					// we need this on the client for RCon
-					on("print", [](const game::netadr_s& address, const std::string& message)
+					on("print", [](const game::netadr_t& address, const std::string& message)
 					{
 						if (address != party::get_target())
 						{

src/client/component/network.hpp

@@ -2,23 +2,23 @@
 
 namespace network
 {
-	using callback = std::function<void(const game::netadr_s&, const std::string&)>;
+	using callback = std::function<void(const game::netadr_t&, const std::string&)>;
 
 	void on(const std::string& command, const callback& callback);
-	void send(const game::netadr_s& address, const std::string& command, const std::string& data = {}, char separator = ' ');
-	void send_data(const game::netadr_s& address, const std::string& data);
+	void send(const game::netadr_t& address, const std::string& command, const std::string& data = {}, char separator = ' ');
+	void send_data(const game::netadr_t& address, const std::string& data);
 
-	bool are_addresses_equal(const game::netadr_s& a, const game::netadr_s& b);
+	bool are_addresses_equal(const game::netadr_t& a, const game::netadr_t& b);
 
-	const char* net_adr_to_string(const game::netadr_s& a);
+	const char* net_adr_to_string(const game::netadr_t& a);
 }
 
-inline bool operator==(const game::netadr_s& a, const game::netadr_s& b)
+inline bool operator==(const game::netadr_t& a, const game::netadr_t& b)
 {
 	return network::are_addresses_equal(a, b); //
 }
 
-inline bool operator!=(const game::netadr_s& a, const game::netadr_s& b)
+inline bool operator!=(const game::netadr_t& a, const game::netadr_t& b)
 {
 	return !(a == b); //
 }
@@ -26,20 +26,20 @@ inline bool operator!=(const game::netadr_s& a, const game::netadr_s& b)
 namespace std
 {
 	template <>
-	struct equal_to<game::netadr_s>
+	struct equal_to<game::netadr_t>
 	{
 		using result_type = bool;
 
-		bool operator()(const game::netadr_s& lhs, const game::netadr_s& rhs) const
+		bool operator()(const game::netadr_t& lhs, const game::netadr_t& rhs) const
 		{
 			return network::are_addresses_equal(lhs, rhs);
 		}
 	};
 
 	template <>
-	struct hash<game::netadr_s>
+	struct hash<game::netadr_t>
 	{
-		size_t operator()(const game::netadr_s& x) const noexcept
+		size_t operator()(const game::netadr_t& x) const noexcept
 		{
 			return hash<uint32_t>()(*reinterpret_cast<const uint32_t*>(&x.ip[0])) ^ hash<uint16_t>()(x.port);
 		}

src/client/component/notifies.cpp

@@ -61,7 +61,7 @@ namespace notifies
 				scheduler::once([params, message, client_num]
 				{
 					const auto* guid = game::SV_GetGuid(client_num);
-					const auto* name = game::mp::svs_clients[client_num].name;
+					const auto* name = game::mp::svs->clients[client_num].name;
 
 					game_log::g_log_printf("%s;%s;%i;%s;%s\n",
 						params.get(0),

src/client/component/party.cpp

@@ -26,7 +26,7 @@ namespace party
 	{
 		struct
 		{
-			game::netadr_s host{};
+			game::netadr_t host{};
 			std::string challenge{};
 			bool hostDefined{false};
 		} connect_state;
@@ -37,7 +37,7 @@ namespace party
 
 		int sv_maxclients;
 
-		void connect_to_party(const game::netadr_s& target, const std::string& mapname, const std::string& gametype)
+		void connect_to_party(const game::netadr_t& target, const std::string& mapname, const std::string& gametype)
 		{
 			if (game::environment::is_sp())
 			{
@@ -58,7 +58,7 @@ namespace party
 
 			// CL_ConnectFromParty
 			char session_info[0x100] = {};
-			reinterpret_cast<void(*)(int, char*, const game::netadr_s*, const char*, const char*)>(0x1402C5700)(
+			reinterpret_cast<void(*)(int, char*, const game::netadr_t*, const char*, const char*)>(0x1402C5700)(
 				0, session_info, &target, mapname.data(), gametype.data());
 		}
 
@@ -83,6 +83,12 @@ namespace party
 		});
 	}
 
+	void connect_to_dummy_party(const std::string& mapname, const std::string& gametype)
+	{
+		const game::netadr_t dummy_target{};
+		connect_to_party(dummy_target, mapname, gametype);
+	}
+
 	void switch_gamemode_if_necessary(const std::string& gametype)
 	{
 		const auto target_mode = gametype == "aliens" ? game::CODPLAYMODE_ALIENS : game::CODPLAYMODE_CORE;
@@ -120,9 +126,9 @@ namespace party
 	int get_client_count()
 	{
 		auto count = 0;
-		for (auto i = 0; i < *game::mp::svs_clientCount; ++i)
+		for (auto i = 0; i < game::mp::svs->clientCount; ++i)
 		{
-			if (game::mp::svs_clients[i].header.state >= game::CS_CONNECTED)
+			if (game::mp::svs->clients[i].header.state >= game::CS_CONNECTED)
 			{
 				++count;
 			}
@@ -134,10 +140,10 @@ namespace party
 	int get_bot_count()
 	{
 		auto count = 0;
-		for (auto i = 0; i < *game::mp::svs_clientCount; ++i)
+		for (auto i = 0; i < game::mp::svs->clientCount; ++i)
 		{
-			if (game::mp::svs_clients[i].header.state >= game::CS_CONNECTED &&
-				game::mp::svs_clients[i].testClient != game::TC_NONE)
+			if (game::mp::svs->clients[i].header.state >= game::CS_CONNECTED &&
+				game::mp::svs->clients[i].testClient != game::TC_NONE)
 			{
 				++count;
 			}
@@ -146,7 +152,7 @@ namespace party
 		return count;
 	}
 
-	game::netadr_s& get_target()
+	game::netadr_t& get_target()
 	{
 		return connect_state.host;
 	}
@@ -158,7 +164,7 @@ namespace party
 
 	int get_client_num_from_name(const std::string& name)
 	{
-		for (auto i = 0; !name.empty() && i < *game::mp::svs_clientCount; ++i)
+		for (auto i = 0; !name.empty() && i < game::mp::svs->clientCount; ++i)
 		{
 			if (game::mp::g_entities[i].client)
 			{
@@ -175,7 +181,7 @@ namespace party
 		return -1;
 	}
 
-	void connect(const game::netadr_s& target)
+	void connect(const game::netadr_t& target)
 	{
 		if (game::environment::is_sp())
 		{
@@ -252,7 +258,7 @@ namespace party
 					return;
 				}
 
-				game::netadr_s target{};
+				game::netadr_t target{};
 				if (game::NET_StringToAdr(params[1], &target))
 				{
 					connect(target);
@@ -283,7 +289,7 @@ namespace party
 				}
 
 				const auto client_num = atoi(params.get(1));
-				if (client_num < 0 || client_num >= *game::mp::svs_clientCount)
+				if (client_num < 0 || client_num >= game::mp::svs->clientCount)
 				{
 					return;
 				}
@@ -320,7 +326,7 @@ namespace party
 				const std::string name = params.get(1);
 				if (name == "all"s)
 				{
-					for (auto i = 0; i < *game::mp::svs_clientCount; ++i)
+					for (auto i = 0; i < game::mp::svs->clientCount; ++i)
 					{
 						scheduler::once([i, reason]
 						{
@@ -331,7 +337,7 @@ namespace party
 				}
 
 				const auto client_num = get_client_num_from_name(name);
-				if (client_num < 0 || client_num >= *game::mp::svs_clientCount)
+				if (client_num < 0 || client_num >= game::mp::svs->clientCount)
 				{
 					return;
 				}
@@ -405,7 +411,7 @@ namespace party
 				console::info("%s\n", message.data());
 			});
 
-			network::on("getInfo", [](const game::netadr_s& target, const std::string& data)
+			network::on("getInfo", [](const game::netadr_t& target, const std::string& data)
 			{
 				utils::info_string info;
 				info.set("challenge", data);
@@ -418,7 +424,7 @@ namespace party
 				info.set("isPrivate", dvars::get_string("g_password").empty() ? "0" : "1");
 				info.set("clients", std::to_string(get_client_count()));
 				info.set("bots", std::to_string(get_bot_count()));
-				info.set("sv_maxclients", std::to_string(*game::mp::svs_clientCount));
+				info.set("sv_maxclients", std::to_string(game::mp::svs->clientCount));
 				info.set("protocol", std::to_string(PROTOCOL));
 				info.set("shortversion", SHORTVERSION);
 
@@ -430,7 +436,7 @@ namespace party
 				return;
 			}
 
-			network::on("infoResponse", [](const game::netadr_s& target, const std::string& data)
+			network::on("infoResponse", [](const game::netadr_t& target, const std::string& data)
 			{
 				const utils::info_string info(data);
 				server_list::handle_info_response(target, info);

src/client/component/party.hpp

@@ -2,12 +2,14 @@
 
 namespace party
 {
+	void connect_to_dummy_party(const std::string& mapname, const std::string& gametype);
+
 	void switch_gamemode_if_necessary(const std::string& gametype);
 	void perform_game_initialization();
 
 	void reset_connect_state();
 
-	void connect(const game::netadr_s& target);
+	void connect(const game::netadr_t& target);
 	void map_restart();
 
 	[[nodiscard]] int server_client_count();
@@ -15,5 +17,5 @@ namespace party
 	[[nodiscard]] int get_client_count();
 	[[nodiscard]] int get_bot_count();
 
-	[[nodiscard]] game::netadr_s& get_target();
+	[[nodiscard]] game::netadr_t& get_target();
 }

src/client/component/patches.cpp

@@ -150,7 +150,7 @@ namespace patches
 			return 0;
 		}
 
-		game::Font_s* get_chat_font_handle()
+		game::Font_t* get_chat_font_handle()
 		{
 			return game::R_RegisterFont("fonts/bigFont");
 		}
@@ -187,11 +187,11 @@ namespace patches
 		}
 
 		utils::hook::detour cmd_lui_notify_server_hook;
-		void cmd_lui_notify_server_stub(game::mp::gentity_s* ent)
+		void cmd_lui_notify_server_stub(game::mp::gentity_t* ent)
 		{
 			command::params_sv params{};
 			const auto menu_id = atoi(params.get(1));
-			const auto client = &game::mp::svs_clients[ent->s.clientNum];
+			const auto client = &game::mp::svs->clients[ent->s.clientNum];
 
 			// 9 => "end_game"
 			if (menu_id == 9 && client->header.netchan.remoteAddress.type != game::NA_LOOPBACK)

src/client/component/rcon.cpp

@@ -14,11 +14,11 @@ namespace rcon
 	namespace
 	{
 		bool is_redirecting_ = false;
-		game::netadr_s redirect_target_ = {};
+		game::netadr_t redirect_target_ = {};
 		std::string redirect_buffer = {};
 		std::recursive_mutex redirect_lock;
 
-		void setup_redirect(const game::netadr_s& target)
+		void setup_redirect(const game::netadr_t& target)
 		{
 			std::lock_guard<std::recursive_mutex> $(redirect_lock);
 
@@ -50,7 +50,7 @@ namespace rcon
 
 			for (int i = 0; i < sv_maxclients->current.integer; i++)
 			{
-				const auto client = &game::mp::svs_clients[i];
+				const auto client = &game::mp::svs->clients[i];
 				auto self = &game::mp::g_entities[i];
 
 				char clean_name[32]{};
@@ -92,7 +92,7 @@ namespace rcon
 
 			if (*reinterpret_cast<std::int32_t*>(0x1419E1AE0) >= 5) //clientUIActive.connectionState >= CA_CONNECTED
 			{
-				const auto target = *reinterpret_cast<game::netadr_s*>(0x141CB535C);
+				const auto target = *reinterpret_cast<game::netadr_t*>(0x141CB535C);
 				const auto buffer = password + " " + data;
 				network::send(target, "rcon", buffer);
 			}
@@ -170,7 +170,7 @@ namespace rcon
 			}
 			else
 			{
-				network::on("rcon", [](const game::netadr_s& addr, const std::string& data)
+				network::on("rcon", [](const game::netadr_t& addr, const std::string& data)
 				{
 					const auto pos = data.find_first_of(" ");
 					if (pos == std::string::npos)

src/client/component/server_list.cpp

@@ -33,14 +33,14 @@ namespace server_list
 			std::string map_name;
 			std::string game_type;
 			char in_game;
-			game::netadr_s address;
+			game::netadr_t address;
 		};
 
 		struct
 		{
-			game::netadr_s address{};
+			game::netadr_t address{};
 			volatile bool requesting = false;
-			std::unordered_map<game::netadr_s, int> queued_servers{};
+			std::unordered_map<game::netadr_t, int> queued_servers{};
 		} master_state;
 
 		volatile bool update_server_list = false;
@@ -307,12 +307,12 @@ namespace server_list
 		}
 	}
 
-	bool get_master_server(game::netadr_s& address)
+	bool get_master_server(game::netadr_t& address)
 	{
 		return game::NET_StringToAdr("server.alterware.dev:20810", &address);
 	}
 
-	void handle_info_response(const game::netadr_s& address, const utils::info_string& info)
+	void handle_info_response(const game::netadr_t& address, const utils::info_string& info)
 	{
 		int start_time{};
 		const auto now = game::Sys_Milliseconds();
@@ -436,7 +436,7 @@ namespace server_list
 
 			scheduler::loop(do_frame_work, scheduler::pipeline::main);
 
-			network::on("getServersResponse", [](const game::netadr_s& target, const std::string& data)
+			network::on("getServersResponse", [](const game::netadr_t& target, const std::string& data)
 			{
 				{
 					std::lock_guard<std::mutex> _(mutex);
@@ -469,7 +469,7 @@ namespace server_list
 							break;
 						}
 
-						game::netadr_s address{};
+						game::netadr_t address{};
 						address.type = game::NA_IP;
 						address.localNetID = game::NS_CLIENT1;
 						std::memcpy(&address.ip[0], data.data() + i + 0, 4);

src/client/component/server_list.hpp

@@ -3,8 +3,8 @@
 
 namespace server_list
 {
-	bool get_master_server(game::netadr_s& address);
-	void handle_info_response(const game::netadr_s& address, const utils::info_string& info);
+	bool get_master_server(game::netadr_t& address);
+	void handle_info_response(const game::netadr_t& address, const utils::info_string& info);
 
 	bool sl_key_event(int key, int down);
 }

src/client/component/slowmotion.cpp

@@ -50,8 +50,8 @@ namespace slowmotion
 
 			for (auto i = 0; i < game::Dvar_FindVar("sv_maxclients")->current.integer; i++)
 			{
-				auto* client = &game::mp::svs_clients[i];
-				client->nextSnapshotTime = *game::mp::serverTime - 1;
+				auto* client = &game::mp::svs->clients[i];
+				client->nextSnapshotTime = game::mp::svs->time - 1;
 			}
 		}
 	}
@@ -66,7 +66,7 @@ namespace slowmotion
 			utils::hook::jump(0x1403B4A10, scr_cmd_set_slow_motion);
 
 			// Detour used here instead of call hook because Com_TimeScaleMsec is called from arxan encrypted function
-			com_timescale_msec_hook.create(0x140415D50, com_timescale_msec);
+			com_timescale_msec_hook.create(game::Com_TimeScaleMsec, com_timescale_msec);
 		}
 	};
 }

src/client/game/structs.hpp

@@ -181,7 +181,7 @@ namespace game
 
 	static_assert(sizeof(db_internal_state) == 0x20);
 
-	struct db_z_stream_s
+	struct db_z_stream_t
 	{
 		unsigned char* next_in;
 		unsigned int avail_in;
@@ -216,7 +216,7 @@ namespace game
 		unsigned char* start_in;
 		_OVERLAPPED overlapped;
 		unsigned int readError;
-		db_z_stream_s stream;
+		db_z_stream_t stream;
 		int readingResident;
 	};
 
@@ -792,6 +792,22 @@ namespace game
 
 	enum ConfigString
 	{
+		CS_TIMESCALE = 0xA,
+
+		CS_VISIONSET_NORMAL = 0x49C,
+		CS_VISIONSET_NIGHT = 0x49D,
+		CS_VISIONSET_MISSILECAM = 0x49E,
+		CS_VISIONSET_THERMAL = 0x49F,
+		CS_VISIONSET_PAIN = 0x4A0,
+		CS_VISIONSET_POST_APPLY = 0x4A1,
+
+		CS_VISIONSET_FIRST = CS_VISIONSET_NORMAL,
+		CS_VISIONSET_LAST = CS_VISIONSET_POST_APPLY,
+		CS_VISIONSET_COUNT = CS_VISIONSET_POST_APPLY - CS_VISIONSET_NORMAL + 1
+
+		// many of the indices below are incorrect
+
+		/*
 		CS_FIRST = 0x0,
 		CS_SERVERINFO = 0x0,
 		CS_SYSTEMINFO = 0x1,
@@ -863,7 +879,8 @@ namespace game
 		CS_MP_ANIMS_LAST = 0xD21,
 		CS_ITEMS = 0xD22,
 		CS_LEADERBOARDS = 0xD23,
-		MAX_CONFIGSTRINGS = 0xD24,
+		MAX_CONFIGSTRINGS = 0xD24
+		*/
 	};
 
 	enum LiveClientDropType
@@ -1064,7 +1081,7 @@ namespace game
 		float t1;
 	};
 
-	struct Font_s
+	struct Font_t
 	{
 		const char* fontName;
 		int pixelHeight;
@@ -1182,9 +1199,9 @@ namespace game
 		const char** argv[8];
 	};
 
-	struct cmd_function_s
+	struct cmd_function_t
 	{
-		cmd_function_s* next;
+		cmd_function_t* next;
 		const char* name;
 		void (__cdecl* function)();
 	};
@@ -1235,7 +1252,7 @@ namespace game
 		WEAPON_HAND_DEFAULT = 0x0,
 	};
 
-	struct usercmd_s
+	struct usercmd_t
 	{
 		int serverTime;
 		unsigned int buttons;
@@ -1289,6 +1306,16 @@ namespace game
 		vec2_t corridorSpeeds;
 	};
 
+	struct ClientArchiveData
+	{
+		int serverTime;
+		vec3_t origin;
+		vec3_t velocity;
+		int bobCycle;
+		int movementDir;
+		PlayerVehicleState playerVehStateClientArchive;
+	};
+
 	struct PlayerActiveWeaponState
 	{
 		int weapAnim;
@@ -1311,7 +1338,7 @@ namespace game
 		bool hybridScope;
 	};
 
-	struct compressedAnimData_s
+	struct compressedAnimData_t
 	{
 		int flags;
 		int animRate;
@@ -1330,7 +1357,7 @@ namespace game
 		int flags;
 		int startTime;
 		float startPosition[3];
-		compressedAnimData_s compressedAnimData;
+		compressedAnimData_t compressedAnimData;
 	};
 
 	struct SlideState
@@ -1339,7 +1366,7 @@ namespace game
 		int noFricTime;
 	};
 
-	struct SprintState_s
+	struct SprintState_t
 	{
 		int sprintButtonUpRequired;
 		int sprintDelay;
@@ -1398,7 +1425,7 @@ namespace game
 		NS_INVALID_NETSRC = 0x4,
 	};
 
-	struct netadr_s
+	struct netadr_t
 	{
 		netadrtype_t type;
 		unsigned char ip[4];
@@ -1411,18 +1438,26 @@ namespace game
 	{
 		int overflowed;
 		int readOnly;
-		char* data;
-		char* splitData;
+		const char* data;
+		const char* splitData;
 		int maxsize;
 		int cursize;
 		int splitSize;
 		int readcount;
 		int bit;
 		int lastEntityRef;
-		netsrc_t targetLocalNetID;
 		int useZlib;
 	};
 
+	struct gameState_t
+	{
+		int stringOffsets[3524];
+		char stringData[131'072];
+		int dataCount;
+	};
+
+	static_assert(sizeof(game::gameState_t) == 145'172);
+
 	struct HsvColor
 	{
 		unsigned char h;
@@ -1463,7 +1498,7 @@ namespace game
 		unsigned int rgba;
 	};
 
-	struct hudelem_s
+	struct hudelem_t
 	{
 		he_type_t type;
 		float x;
@@ -1509,9 +1544,9 @@ namespace game
 		int flags;
 	};
 
-	struct game_hudelem_s
+	struct game_hudelem_t
 	{
-		hudelem_s elem;
+		hudelem_t elem;
 		int clientNum;
 		int team;
 		int archived;
@@ -1939,7 +1974,7 @@ namespace game
 		FxWorld *fxWorld;
 		GfxWorld *gfxWorld;
 		GfxLightDef *lightDef;*/
-		Font_s* font;
+		Font_t* font;
 		/*MenuList *menuList;
 		menuDef_t *menu;
 		AnimationClass *animClass;
@@ -2018,21 +2053,21 @@ namespace game
 	namespace sp
 	{
 		// very shit structures for the moment cuz i cba mapping the whole thing out right now...
-		struct gclient_s
+		struct gclient_t
 		{
 			char __0x00[0xB6DC];
 			int flags;
 		};
 
-		struct gentity_s
+		struct gentity_t
 		{
 			char __0x00[0x110];
-			gclient_s* client;
+			gclient_t* client;
 			char __0x118[0x4C];
 			int flags;
 		};
 
-		struct playerState_s
+		struct playerState_t
 		{
 		};
 
@@ -2049,7 +2084,7 @@ namespace game
 	namespace mp
 	{
 #pragma pack(push, 4)
-		struct playerState_s
+		struct playerState_t
 		{
 			int commandTime;
 			int pm_type;
@@ -2099,9 +2134,11 @@ namespace game
 			int clientNum;
 			int viewmodelIndex;
 			vec3_t viewangles;
-			char _0x190[0xAC];
+			char _0x190[0x58];
+			int viewlocked_entNum;
+			char _0x1EC[0x50];
 			int locationSelectionInfo;
-			SprintState_s sprintState;
+			SprintState_t sprintState;
 			float holdBreathScale;
 			int holdBreathTimer;
 			float moveSpeedScaleMultiplier;
@@ -2131,14 +2168,11 @@ namespace game
 			vec3_t weapLockedPos;
 			int weaponIdleTime;
 			int lastStowedWeapon;
-			char __0x638[0x2CE8];
+			char __0x638[0x2CEC];
 		};
-#pragma pack(pop)
 
-		struct ClientCustomizationInfo
-		{
-			unsigned int modelIndex[3];
-		};
+		static_assert(sizeof(playerState_t) == 0x3328);
+#pragma pack(pop)
 
 		struct ScoreInfo
 		{
@@ -2154,6 +2188,140 @@ namespace game
 			unsigned short adrenaline;
 		};
 
+		struct ScoreboardInfo
+		{
+			int teamScores[2];
+			ScoreInfo clientScores[18];
+		};
+
+		struct clSnapshot_t
+		{
+			mp::playerState_t ps;
+			ScoreboardInfo scores;
+			int valid;
+			int snapFlags;
+			int serverTime;
+			int messageNum;
+			int deltaNum;
+			int ping;
+			int cmdNum;
+			int numEntities;
+			int numClients;
+			int parseEntitiesIndex;
+			int parseClientsIndex;
+			int parseOmnvarsIdx;
+			int numAgents;
+			int parseAgentsIndex;
+			int scriptablesParseCount;
+			int scriptablesParseIndex;
+			int serverCommandNum;
+		};
+
+		static_assert(sizeof(clSnapshot_t) == 0x34B8);
+
+		struct clientActive_t
+		{
+			char usingAds;
+			char padding1[3];
+			int timeoutcount;
+			clSnapshot_t snap;
+			int oldSnapServerTime;
+			int oldServerTime;
+			int extrapolatedSnapshot;
+			char alwaysFalse;
+			char padding2[3];
+			int serverTime;
+			int oldFrameServerTime;
+			int serverTimeDelta;
+			int newSnapshots;
+			int serverId;
+			char mapname[64];
+			int mapcrc;
+			int parseEntitiesIndex;
+			int parseClientsIndex;
+			int parseOmnvarsIdx;
+			int mouseDx[2];
+			int mouseDy[2];
+			int mouseIndex;
+			char stanceHeld;
+			char padding3[3];
+			int stance;
+			int stancePosition;
+			int stanceTime;
+			char wasSprinting;
+			char padding4[3];
+			int cgameUserCmdWeapon;
+			int cgameUserCmdOffHand;
+			int cgameUserCmdAlternate;
+			float cgameFOVSensitivityScale;
+			float cgameMaxPitchSpeed;
+			float cgameMaxYawSpeed;
+			vec3_t cgameKickAngles;
+			vec3_t cgameOrigin;
+			vec3_t cgameVelocity;
+			PlayerVehicleState cgamePlayerVehState;
+			int cgameBobCycle;
+			int cgameMovementDir;
+			int cgameExtraButtons;
+			int cgamePredictedDataServerTime;
+			vec3_t clViewangles;
+			char _361C[12];
+			usercmd_t cmds[128];
+			int cmdNumber;
+			ClientArchiveData clientArchive[256];
+			int clientArchiveIndex;
+			int packetBackupCount;
+			int packetBackupMask;
+			int parseEntitiesCount;
+			int parseClientsCount;
+			int parseOmnvarsCount;
+			// missing fields
+		};
+
+		struct clientStatic_t
+		{
+			int quit;
+			int hunkUsersStarted;
+			char servername[256];
+			int rendererStarted;
+			int soundStarted;
+			int inUpdateSound;
+			int uiStarted;
+			int frametime;
+			int frametime_base;
+			int realtime;
+			char _0x124[0x80DBC];
+			gameState_t gameState;
+			// missing fields
+		};
+
+		struct clientConnection_t
+		{
+			int qport;
+			int clientNum;
+			netadr_t serverAddress;
+			int connectLastSendTime;
+			int connectPacketCount;
+			char serverMessage[256];
+			int challenge;
+			int checksumFeed;
+			int reliableSequence;
+			int reliableAcknowledge;
+			char reliableCommands[128][1024];
+			int serverMessageSequence;
+			int serverCommandSequence;
+			int lastExecutedServerCommand;
+			char serverCommands[128][1024];
+			char isServerRestarting;
+			char padding[3];
+			// missing fields
+		};
+
+		struct ClientCustomizationInfo
+		{
+			unsigned int modelIndex[3];
+		};
+
 		union OmnvarValue
 		{
 			bool enabled;
@@ -2179,51 +2347,58 @@ namespace game
 			TEAM_NUM_TEAMS = 0x4,
 		};
 
-		struct clientState_s
+		struct clientState_t
 		{
 			int clientIndex;
 			team_t team;
 			int modelindex;
 			int dualWielding;
 			char _0x10[0x30];
-			char name[0x10];
+			char name[16];
 			int rank;
 			int prestige;
-			char _0x00[0x10];
 			int nameplateFriendlyIndex;
 			int nameplateEnemyIndex;
 			unsigned int perks[2];
-			char _0x78[0x80];
+			char _0x68[0x40];
+			char clanAbbrev[8];
+			char _0xB0[0x28];
 		};
 
+		static_assert(sizeof(clientState_t) == 0xD8);
+
 		struct clientSession_t
 		{
 			int sessionState;
 			int forceSpectatorClient;
 			int killCamEntity;
 			int isInKillcam;
-			char __0x332C[0x14];
-			usercmd_s cmd;
-			usercmd_s oldcmd;
+			char _0x10[0x10];
+			usercmd_t cmd;
+			usercmd_t oldcmd;
 			int localClient;
-			char __0x33C4[0x24];
+			char _0x9C[0x34];
 			float moveSpeedScaleMultiplier;
 			int viewmodelIndex;
 			int noSpectate;
-			clientState_s cs;
+			clientState_t cs;
 			ScoreInfo scores;
-			char __pad[0x1B0];
+			char _0x1E6[0x1C0];
 		};
 
-		struct gclient_s
+		static_assert(sizeof(clientSession_t) == 0x388);
+
+		struct gclient_t
 		{
-			playerState_s ps;
+			playerState_t ps;
 			clientSession_t sess;
 			int flags;
 			int spectatorClient;
-			char __0x36B4[0x3B0];
+			char _0x36B8[0x3B0];
 		};
 
+		static_assert(sizeof(gclient_t) == 0x3A68);
+
 		struct LerpEntityState
 		{
 			int entFlags;
@@ -2258,6 +2433,8 @@ namespace game
 			char _0xD8[0x30];
 		};
 
+		static_assert(sizeof(EntityState) == 0x108);
+
 		struct EntityShared
 		{
 			char _0x108[0x38];
@@ -2266,11 +2443,18 @@ namespace game
 			char _0x14C[0xC];
 		};
 
-		struct gentity_s
+		struct centity_t
+		{
+			char _0x0[0x238];
+		};
+
+		static_assert(sizeof(centity_t) == 0x238);
+
+		struct gentity_t
 		{
 			EntityState s;
 			EntityShared r;
-			gclient_s* client;
+			gclient_t* client;
 			char _0x170[0x50];
 			int flags;
 			char _0x1C4[0x18];
@@ -2279,21 +2463,232 @@ namespace game
 			char _0x1E4[0x10C];
 		};
 
-		struct snapshot_s
+		struct snapshot_t
 		{
-			char _0x0[0x3C78];
+			playerState_t ps;
+			ScoreboardInfo scores;
+			OmnvarData omnvars[256];
+			int snapFlags;
 			int ping;
 			int serverTime;
 			int numEntities;
 			int numClients;
+			// missing fields
 		};
 
-		struct cg_s
+		enum DemoType
 		{
-			playerState_s ps;
-			char _0x3324[0x64];
-			snapshot_s* snap;
-			snapshot_s* nextSnap; // theres alot after this cba rn
+			DEMO_TYPE_NONE = 0x0,
+			DEMO_TYPE_CLIENT = 0x1,
+			DEMO_TYPE_SERVER = 0x2
+		};
+
+		struct characterInfo_t
+		{
+			char _0x0[0x5D8];
+		};
+
+		static_assert(sizeof(characterInfo_t) == 0x5D8);
+
+		struct clientInfo_t
+		{
+			char _0x0[0x70];
+		};
+
+		static_assert(sizeof(clientInfo_t) == 0x70);
+
+		struct bgs_t
+		{
+			char _0x0[0x459F0];
+			characterInfo_t characterinfo[42];
+			clientInfo_t clientinfo[18];
+		};
+
+		static_assert(sizeof(bgs_t) == 0x55740);
+
+		struct visionSetVarsBase_t
+		{
+			int filmEnable;
+			float filmBrightness;
+			float filmContrast;
+			float filmDesaturation;
+			float filmDesaturationDark;
+			float filmInvert;
+			vec3_t filmLightTint;
+			vec3_t filmMediumTint;
+			vec3_t filmDarkTint;
+			int charPrimaryUseTweaks;
+			float charPrimaryDiffuseScale;
+			float charPrimarySpecularScale;
+			vec3_t charLightAmbient;
+			int viewModelPrimaryUseTweaks;
+			float viewModelPrimaryDiffuseScale;
+			float viewModelPrimarySpecularScale;
+			vec3_t viewModelLightAmbient;
+			float primaryLightOverride;
+			int materialBloomHQEnable;
+			float materialBloomHQHaziness;
+			float materialBloomHQGamma;
+			float materialBloomHQDesaturation;
+			float materialBloomIntensity;
+			float materialBloomRadius;
+			float materialBloomPinch;
+			float materialBloomLuminanceCutoff;
+			float materialBloomDesaturation;
+			int volumeLightScatter;
+			float volumeLightScatterLinearAtten;
+			float volumeLightScatterQuadraticAtten;
+			float volumeLightScatterAngularAtten;
+			float volumeLightScatterDepthAttenNear;
+			float volumeLightScatterDepthAttenFar;
+			float volumeLightScatterBackgroundDistance;
+			vec3_t volumeLightScatterColor;
+			float ssaoStrength;
+			float ssaoPower;
+			float ssaoBlurRadius;
+			int glareEnable;
+			float glareNormalStart;
+			float glareNormalEnd;
+			float glareNormalPower;
+			float glareNormalAmount;
+			float glareMirrorStart;
+			float glareMirrorEnd;
+			float glareMirrorPower;
+			float glareMirrorAmount;
+			float rimLightPitch;
+			float rimLightHeading;
+			float rimLightDiffuseIntensity;
+			float rimLightSpecIntensity;
+			float rimLightBias;
+			float rimLightPower;
+			vec3_t rimLightColor;
+			int overrideExistingMask;
+			float unlitSurfaceHDRScalar;
+			float litSurfaceHDRScalar;
+			float hdrSkyIntensity;
+			vec3_t hdrSkyColorTint;
+		};
+
+		static_assert(sizeof(visionSetVarsBase_t) == 0x12C);
+
+		struct visionSetVars_t
+		{
+			visionSetVarsBase_t baseclass_0;
+			void* _0x12C[3];
+		};
+
+		static_assert(sizeof(visionSetVars_t) == 0x148);
+
+		struct interpolationVisionSetVars_t
+		{
+			visionSetVarsBase_t baseclass_0;
+			void* _0x12C[0x2F];
+		};
+
+		static_assert(sizeof(interpolationVisionSetVars_t) == 0x2A8);
+
+		struct visionSetLerpData_t
+		{
+			int timeStart;
+			int timeDuration;
+			int style;
+		};
+
+		struct GfxFog
+		{
+			char _0x0[0x38];
+			int startTime;
+			int finishTime;
+			int color;
+			float density;
+			int sunColor;
+		};
+
+		struct ClientVisionSetData
+		{
+			visionSetVars_t visionSetPreLoaded[4];
+			char visionSetPreLoadedName[4][64];
+			int visionSetPreLoadedUsedTime[4];
+			interpolationVisionSetVars_t visionSetFrom[6];
+			interpolationVisionSetVars_t visionSetTo[6];
+			interpolationVisionSetVars_t visionSetCurrent[6];
+			interpolationVisionSetVars_t visionSetPrevious;
+			visionSetLerpData_t visionSetLerpData[6];
+			char visionName[6][64];
+			char visionBlendActive[6];
+			char thermalVisionActive;
+			char remoteMissileCam;
+			char painVisionActive;
+			float painVisionLerp;
+			int postApplyLerpTimeStart;
+			int postApplyLerpTimeDuration;
+			float postApplyLerpStart;
+			float postApplyLerpDest;
+			float postApplyLerpCurrent;
+			GfxFog lastClientFog;
+			int scriptFogActive;
+			int scriptFogLerpStartTime;
+			int scriptFogLerpEndTime;
+		};
+
+		static_assert(sizeof(ClientVisionSetData) == 0x3AF0);
+
+		struct cpose_t
+		{
+			char _0x0[0x90];
+		};
+
+		static_assert(sizeof(cpose_t) == 0x90);
+
+		struct cg_t
+		{
+			playerState_t ps;
+			char _0x3324[0x38];
+			int clientNum;
+			int localClientNum;
+			DemoType demoType;
+			char _0x336C[0x1C];
+			snapshot_t* snap;
+			snapshot_t* nextSnap;
+			char _0x3398[0xA66F8];
+			vec3_t refdefViewAngles;
+			char _0xA9A9C[0x8CC4];
+			int clientSideVisionSetsEnabled;
+			int voiceTime;
+			Weapon weaponSelect;
+			char _0xB276C[0x2C10];
+			int inKillCam;
+			char _0xB5380[0x148];
+			bgs_t bgs;
+			cpose_t viewModelPose;
+			cpose_t viewModelPoseLeftHand;
+			ClientVisionSetData cvsData;
+			int stagedVisionStateTo;
+			int stagedVisionStateFrom;
+			int stagedVisionStateEndTime;
+			int stagedVisionStateStartTime;
+			// missing fields
+		};
+
+		struct cgs_t
+		{
+			int viewX;
+			int viewY;
+			int viewWidth;
+			int viewHeight;
+			float viewAspect;
+			float _0x14;
+			int serverCommandSequence;
+			int processedSnapshotNum;
+			int localServer;
+			char gametype[32];
+			char szHostName[256];
+			int hardcore;
+			int maxclients;
+			int privateClients;
+			char mapname[64];
+			int gameEndTime;
+			// missing fields
 		};
 
 		struct netProfilePacket_t
@@ -2328,7 +2723,7 @@ namespace game
 			netsrc_t sock;
 			int dropped;
 			int incomingSequence;
-			netadr_s remoteAddress;
+			netadr_t remoteAddress;
 			int fragmentSequence;
 			int fragmentLength;
 			char* fragmentBuffer;
@@ -2343,7 +2738,7 @@ namespace game
 
 		struct __declspec(align(8)) clientHeader_t
 		{
-			int state;
+			clientstate_t state;
 			int sendAsActive;
 			int deltaMessage;
 			int rateDelayed;
@@ -2377,8 +2772,11 @@ namespace game
 			int reliableAcknowledge;
 			int reliableSent;
 			int messageAcknowledge;
-			char _0xC30[0x41238];
-			gentity_s* gentity;
+			int largeCommandSequence;
+			int gamestateMessageNum;
+			int challenge;
+			char _0xC3C[0x4122C];
+			gentity_t* gentity;
 			char name[16];
 			int lastPacketTime;
 			int lastConnectTime;
@@ -2400,6 +2798,8 @@ namespace game
 			char _0x41E94[0x416A0];
 		};
 
+		static_assert(sizeof(client_t) == 0x83570);
+
 		struct XZone
 		{
 			char name[64];
@@ -2411,7 +2811,7 @@ namespace game
 
 		struct missileFireParms
 		{
-			gentity_s* target;
+			gentity_t* target;
 			float targetPosOrOffset[3];
 			float autoDetonateTime;
 			bool lockon;
@@ -2419,14 +2819,23 @@ namespace game
 		};
 
 		static_assert(sizeof(missileFireParms) == 0x20);
+
+		struct serverStatic_t
+		{
+			char _0x0[0x1681D00];
+			int time;
+			int loopbackProcessStopTime;
+			int snapFlagServerBit;
+			int clientCount;
+			client_t clients[18];
+			// missing fields
+		};
 	}
 
-	static_assert(sizeof(mp::client_t) == 0x83570);
-
-	union playerState_s
+	union playerState_t
 	{
-		sp::playerState_s* sp;
-		mp::playerState_s* mp;
+		sp::playerState_t* sp;
+		mp::playerState_t* mp;
 	};
 
 	enum GfxDrawSceneMethod
@@ -2457,7 +2866,7 @@ namespace game
 		TECHNIQUE_NONE = 0x137,
 	};
 
-	struct GfxDrawMethod_s
+	struct GfxDrawMethod_t
 	{
 		int drawScene;
 		int baseTechType;
@@ -2509,8 +2918,8 @@ namespace game
 	struct pmove_t
 	{
 		void* ps;
-		usercmd_s cmd;
-		usercmd_s oldcmd;
+		usercmd_t cmd;
+		usercmd_t oldcmd;
 		int tracemask;
 		int numtouch;
 		int touchents[32];

src/client/game/symbols.hpp

@@ -36,15 +36,31 @@ namespace game
 	WEAK symbol<void(int localClientNum, const char* text)> Cbuf_AddText{0x1403B3050, 0x1403F6B50};
 	WEAK symbol<void(int localClientNum, int controllerIndex, const char* buffer, void (int, int, const char*))> Cbuf_ExecuteBufferInternal{0x1403B3160, 0x1403F6C60};
 
-	WEAK symbol<bool()> CL_IsCgameInitialized{0x140234DA0, 0x1402B9A70};
-
+	WEAK symbol<void(int localClientNum, int latestSequence)> CG_ExecuteNewServerCommands{0, 0x140288500};
 	WEAK symbol<void(int localClientNum, const char* message)> CG_GameMessage{0x1401F2E20, 0x140271320};
-	WEAK symbol<void(int localClientNum, mp::cg_s* cg, const char* dvar, const char* value)> CG_SetClientDvarFromServer{0x0, 0x14028A2C0};
+	WEAK symbol<void*(const mp::playerState_t* ps)> CG_GetVehicleDef{0, 0x140229760};
+	WEAK symbol<void(int localClientNum, const mp::centity_t* cent, unsigned int event, unsigned int eventParm, bool isPlayerView)> CG_HandleTurretFire{0, 0x140269DF0};
+	WEAK symbol<void(int localClientNum, mp::cg_t* cg, const char* dvar, const char* value)> CG_SetClientDvarFromServer{0, 0x14028A2C0};
+	WEAK symbol<void(int localClientNum, const mp::snapshot_t* oldSnap, const mp::snapshot_t* newSnap)> CG_UpdateOmnvars{0, 0x14028E770};
 
-	WEAK symbol<void(const char* cmdName, void (), cmd_function_s* allocedCmd)> Cmd_AddCommandInternal{0x1403B3570, 0x1403F7070};
+	WEAK symbol<void(int localClientNum, int key)> CL_CharEvent{0x14023CE50, 0x1402C2AE0};
+	WEAK symbol<bool(int localClientNum, int clientNum, char* buffer, int length)> CL_GetClientNameColorize{0, 0x1402CFA60};
+	WEAK symbol<bool(const mp::clientActive_t* cl, const int serverTime, 
+					 mp::playerState_t* to)> CL_GetPredictedPlayerInformationForServerTime{0, 0x1402CC710};
+	WEAK symbol<bool(const mp::clientActive_t* cl, const int serverTime, 
+					 PlayerVehicleState* predictedPlayerVehState)> CL_GetPredictedVehicleForServerTime{0, 0x1402CC7F0};
+	WEAK symbol<bool()> CL_IsCgameInitialized{0x140234DA0, 0x1402B9A70};
+	WEAK symbol<void(int localClientNum, int key, int down, unsigned int time)> CL_KeyEvent{0x14023D070, 0x1402C2CE0};
+	WEAK symbol<void(int localClientNum, msg_t*)> CL_ParseServerMessage{0, 0x1402CDFC0};
+	WEAK symbol<bool(int localClientNum, int weapon, int useAltMode)> CG_SelectWeapon{0, 0x1402AB310};
+	WEAK symbol<void(int localClientNum)> CL_SetCGameTime{0, 0x1402B9D80};
+	WEAK symbol<void(int localClientNum)> CL_WritePacket{0, 0x1402C1E70};
+
+	WEAK symbol<void(const char* cmdName, void (), cmd_function_t* allocedCmd)> Cmd_AddCommandInternal{0x1403B3570, 0x1403F7070};
 	WEAK symbol<void(int localClientNum, int controllerIndex, const char* text)> Cmd_ExecuteSingleCommand{0x1403B3B10, 0x1403F7680};
+	WEAK symbol<int(int msec)> Com_TimeScaleMsec{0, 0x140415D50};
 
-	WEAK symbol<void (XAssetType type, void (__cdecl *func)(XAssetHeader, void*), void* inData, bool includeOverride)> DB_EnumXAssets_FastFile{0x140271F50, 0x14031EF90};
+	WEAK symbol<void(XAssetType type, void (__cdecl *func)(XAssetHeader, void*), void* inData, bool includeOverride)> DB_EnumXAssets_FastFile{0x140271F50, 0x14031EF90};
 	WEAK symbol<void(XAssetType type, void(__cdecl* func)(XAssetHeader, void*), const void* inData, bool includeOverride)> DB_EnumXAssets_Internal{0x140271FC0, 0x14031F000};
 	WEAK symbol<XAssetEntry*(XAssetType type, const char* name)> DB_FindXAssetEntry{0x140272230, 0x14031F2D0};
 	WEAK symbol<const char* (const XAsset* asset)> DB_GetXAssetName{0x14024FB10, 0x1402FB160};
@@ -54,11 +70,11 @@ namespace game
 	WEAK symbol<XAssetHeader(XAssetType type, const char* name, int allowCreateDefault)> DB_FindXAssetHeader{0x140272300, 0x14031F3A0};
 	WEAK symbol<int(XAssetType type, const char* name)> DB_XAssetExists{0x140276200, 0x1403245E0};
 	WEAK symbol<int(XAssetType type, const char* name)> DB_IsXAssetDefault{0x140273480 , 0x1403204D0};
-	WEAK symbol<int(const RawFile* rawfile)> DB_GetRawFileLen{0x0140272E80, 0x14031FF80};
+	WEAK symbol<int(const RawFile* rawfile)> DB_GetRawFileLen{0x140272E80, 0x14031FF80};
 	WEAK symbol<void(const RawFile* rawfile, char* buf, int size)> DB_GetRawBuffer{0x140272D50, 0x14031FE50};
 	WEAK symbol<int(const char* zoneName)> DB_IsLocalized{0x140273210, 0x140320360};
 
-	WEAK symbol<void*(unsigned int size, unsigned int alignment, unsigned int type, PMem_Source source)> PMem_AllocFromSource_NoDebug{0x0140430B80, 0x001404F46C0};
+	WEAK symbol<void*(unsigned int size, unsigned int alignment, unsigned int type, PMem_Source source)> PMem_AllocFromSource_NoDebug{0x140430B80, 0x001404F46C0};
 	WEAK symbol<void(const char* name, PMem_Direction allocDir)> PMem_Free{0x140430EC0 , 0x1404F4A30};
 
 	WEAK symbol<void*(unsigned int size)> Hunk_AllocateTempMemoryHighInternal{0x140423C70, 0x1404E4E20};
@@ -93,18 +109,20 @@ namespace game
 	WEAK symbol<void(const char *path, const char *dir, int bLanguageDirectory, int iLanguage)> FS_AddGameDirectory{0x14041A120, 0x1404DC570};
 	WEAK symbol<void(const char *path, const char *dir)> FS_AddLocalizedGameDirectory{0x14041A2F0, 0x1404DC760};
 
+	WEAK symbol<bool(int localClientNum)> GetRemoteEyeValues{0, 0x1402A0190};
+
 	WEAK symbol<Weapon(const char* pickupName, int model)> G_FindItem{0x140462490, 0x14021B7E0};
-	WEAK symbol<int(playerState_s* ps, Weapon weapon, int dualWield, int startInAltMode, int usedBefore)> G_GivePlayerWeapon{0x140359E20, 0x1403DA5E0};
+	WEAK symbol<int(playerState_t* ps, Weapon weapon, int dualWield, int startInAltMode, int usedBefore)> G_GivePlayerWeapon{0x140359E20, 0x1403DA5E0};
 	WEAK symbol<Weapon(const char* name)> G_GetWeaponForName{0x140359890, 0x1403DA060};
 	WEAK symbol<void()> G_Glass_Update{0x14030E680, 0x140397450};
-	WEAK symbol<void (playerState_s* ps, Weapon weapon, int hadWeapon)> G_InitializeAmmo{0x140311F00, 0x14039AEA0};
+	WEAK symbol<void (playerState_t* ps, Weapon weapon, int hadWeapon)> G_InitializeAmmo{0x140311F00, 0x14039AEA0};
 	WEAK symbol<void(int clientNum, Weapon weapon)> G_SelectWeapon{0x14035A200, 0x1403DA880};
-	WEAK symbol<int(playerState_s* ps, Weapon weapon)> G_TakePlayerWeapon{0x14035A350, 0x1403DA9C0};
+	WEAK symbol<int(playerState_t* ps, Weapon weapon)> G_TakePlayerWeapon{0x14035A350, 0x1403DA9C0};
 	WEAK symbol<unsigned int (const char* name, /*ConfigString*/ unsigned int start, unsigned int max, int create,
-	                          const char* errormsg)> G_FindConfigstringIndex{0x0, 0x140161F90};
-	WEAK symbol<int(int server_time)> G_RunFrame{0x0, 0x1403A05E0};
+	                          const char* errormsg)> G_FindConfigstringIndex{0, 0x140161F90};
+	WEAK symbol<int(int server_time)> G_RunFrame{0, 0x1403A05E0};
 
-	WEAK symbol<game_hudelem_s*(int clientNum, int teamNum)> HudElem_Alloc{0x0, 0x1403997E0};
+	WEAK symbol<game_hudelem_t*(int clientNum, int teamNum)> HudElem_Alloc{0, 0x1403997E0};
 
 	WEAK symbol<char*(char* string)> I_CleanStr{0x140432460, 0x1404F63C0};
 
@@ -116,6 +134,7 @@ namespace game
 
 	WEAK symbol<unsigned int (int)> Live_SyncOnlineDataFlags{0, 0x1405ABF70};
 
+	WEAK symbol<const char*()> LiveStorage_FetchFFotD{0x140415FD0, 0x1404D7C00};
 	WEAK symbol<bool(int controllerIndex, unsigned int name, int value, StatsGroup statsGroup)> LiveStorage_PlayerDataSetIntByName{0x1403B8C20, 0x140404730};
 	WEAK symbol<bool(std::uint8_t* persistentData, const char* lookupString, int value, std::uint8_t* modifiedFlags, StatsGroup statsGroup)> LiveStorage_PlayerDataSetReservedInt{0x1403B8D00, 0x140404820};
 	WEAK symbol<std::int64_t(std::uint8_t* persistentData, const char* lookupString, const StatsGroup statsGroup)> LiveStorage_PlayerDataGetReservedInt{0x1403B84F0, 0x140403CF0};
@@ -135,27 +154,33 @@ namespace game
 	WEAK symbol<const char*(const StringTable* table, const int row, const int column)> StringTable_GetColumnValueForRow{0, 0x1404E61A0};
 	WEAK symbol<int(const StringTable* table, const int comparisonColumn, const char* value)> StringTable_LookupRowNumForValue{0, 0x1404E6260};
 
+	WEAK symbol<bool(int localClientNum, void* lua_vm)> LUI_IntermissionBegan{0, 0x1401CEB40};
 	WEAK symbol<void(int localClientNum, const char* menuName, int isPopup, int isModal, unsigned int isExclusive)> LUI_OpenMenu{0x1403FD460, 0x1404B3610};
 	// Made up name, replaced by ScopedCriticalSection on Black Ops 3
 	WEAK symbol<void()> LUI_EnterCriticalSection{0x1401AE940, 0x1401CD040};
 	WEAK symbol<void()> LUI_LeaveCriticalSection{0x1401B0AA0, 0x1401CF1A0};
 
-	WEAK symbol<bool(int localClientNum, const char* menuName)> Menu_IsMenuOpenAndVisible{0x0, 0x1404B38A0};
+	WEAK symbol<bool(int localClientNum, const char* menuName)> Menu_IsMenuOpenAndVisible{0, 0x1404B38A0};
 
 	WEAK symbol<Material*(const char* material)> Material_RegisterHandle{0x140523D90, 0x1405F0E20};
 
-	WEAK symbol<void(netsrc_t, netadr_s*, const char*)> NET_OutOfBandPrint{0, 0x14041D5C0};
-	WEAK symbol<void(netsrc_t sock, int length, const void* data, const netadr_s* to)> NET_SendLoopPacket{0, 0x14041D780};
-	WEAK symbol<bool(const char* s, netadr_s* a)> NET_StringToAdr{0, 0x14041D870};
-	WEAK symbol<void(netadr_s*, sockaddr*)> NetadrToSockadr{0, 0x1404E53D0};
+	WEAK symbol<int(msg_t*)> MSG_ReadLong{0, 0x1404181C0};
+	WEAK symbol<void(msg_t*, int, unsigned int)> MSG_WriteBits{0, 0x140418740};
+
+	WEAK symbol<void(netsrc_t, netadr_t*, const char*)> NET_OutOfBandPrint{0, 0x14041D5C0};
+	WEAK symbol<void(netsrc_t sock, int length, const void* data, const netadr_t* to)> NET_SendLoopPacket{0, 0x14041D780};
+	WEAK symbol<bool(const char* s, netadr_t* a)> NET_StringToAdr{0, 0x14041D870};
+	WEAK symbol<void(netadr_t*, sockaddr*)> NetadrToSockadr{0, 0x1404E53D0};
+
+	WEAK symbol<void*(int)> Omnvar_GetDef{0, 0x1404F3E80};
 
 	WEAK symbol<void(float x, float y, float width, float height, float s0, float t0, float s1, float t1,
 	                  float* color, Material* material)> R_AddCmdDrawStretchPic{0x140234460, 0x140600BE0};
-	WEAK symbol<void(const char*, int, Font_s*, float, float, float, float, float, float*, int)> R_AddCmdDrawText{0x140533E40, 0x140601070};
-	WEAK symbol<void(const char*, int, Font_s*, float, float, float, float, float, const float*, int, int, char)> R_AddCmdDrawTextWithCursor{0x140534170, 0x1406013A0};
-	WEAK symbol<Font_s*(const char* font)> R_RegisterFont{0x1405130B0, 0x1405DFAC0};
+	WEAK symbol<void(const char*, int, const Font_t*, float, float, float, float, float, const float*, int)> R_AddCmdDrawText{0x140533E40, 0x140601070};
+	WEAK symbol<void(const char*, int, const Font_t*, float, float, float, float, float, const float*, int, int, char)> R_AddCmdDrawTextWithCursor{0x140534170, 0x1406013A0};
+	WEAK symbol<Font_t*(const char* font)> R_RegisterFont{0x1405130B0, 0x1405DFAC0};
 	WEAK symbol<void()> R_SyncRenderThread{0x140535AF0, 0x140602D30};
-	WEAK symbol<int(const char* text, int maxChars, Font_s* font)> R_TextWidth{0x140513390, 0x1405DFDB0};
+	WEAK symbol<int(const char* text, int maxChars, Font_t* font)> R_TextWidth{0x140513390, 0x1405DFDB0};
 
 	WEAK symbol<ScreenPlacement*()> ScrPlace_GetViewPlacement{0x14024D150, 0x1402F6D40};
 
@@ -166,27 +191,27 @@ namespace game
 	WEAK symbol<void (VariableValue* result, unsigned int classnum, int entnum, int offset)> GetEntityFieldValue{0x1403DC810, 0x140437860};
 	WEAK symbol<const float*(const float* v)> Scr_AllocVector{0x1403D9AF0, 0x140434A10};
 	WEAK symbol<const char*(unsigned int index)> Scr_GetString{0, 0x140439160};
-	WEAK symbol<void(int value)> Scr_AddInt{0x0, 0x140437E70};
-	WEAK symbol<void(const char* value)> Scr_AddString{0x0, 0x1404381D0};
-	WEAK symbol<int(unsigned int index)> Scr_GetInt{0x0, 0x140438E10};
+	WEAK symbol<void(int value)> Scr_AddInt{0, 0x140437E70};
+	WEAK symbol<void(const char* value)> Scr_AddString{0, 0x1404381D0};
+	WEAK symbol<int(unsigned int index)> Scr_GetInt{0, 0x140438E10};
 	WEAK symbol<float(unsigned int index)> Scr_GetFloat{0, 0x140438D60};
 	WEAK symbol<unsigned int()> Scr_GetNumParam{0x1403DDF60, 0x140438EC0};
 	WEAK symbol<void()> Scr_ClearOutParams{0x1403DD500, 0x140438600};
 	WEAK symbol<scr_entref_t(unsigned int entId)> Scr_GetEntityIdRef{0x1403DBDC0, 0x140436E10};
-	WEAK symbol<void(int entnum, unsigned int classnum)> Scr_AddEntityNum{0x0, 0x140437F60};
+	WEAK symbol<void(int entnum, unsigned int classnum)> Scr_AddEntityNum{0, 0x140437F60};
 	WEAK symbol<int(unsigned int classnum, int entnum, int offset)> Scr_SetObjectField{0x140350E70, 0x1403D3FE0};
 	WEAK symbol<void(unsigned int id, unsigned int stringValue, unsigned int paramcount)> Scr_NotifyId{0x1403DE730, 0x140439700};
-	WEAK symbol<void(unsigned int stringValue, unsigned int paramcount)> Scr_NotifyLevel{0x0, 0x1404397D0};
-	WEAK symbol<unsigned int(int entnum, unsigned int classnum)> Scr_GetEntityId{0x0, 0x140436D60};
-	WEAK symbol<bool(VariableValue* value)> Scr_CastString{0x0, 0x140434AC0};
+	WEAK symbol<void(unsigned int stringValue, unsigned int paramcount)> Scr_NotifyLevel{0, 0x1404397D0};
+	WEAK symbol<unsigned int(int entnum, unsigned int classnum)> Scr_GetEntityId{0, 0x140436D60};
+	WEAK symbol<bool(VariableValue* value)> Scr_CastString{0, 0x140434AC0};
 
 	WEAK symbol<unsigned __int16(int handle, unsigned int paramcount)> Scr_ExecThread{0x1403DD600, 0x1404386E0};
 	WEAK symbol<unsigned int(const char* name)> Scr_LoadScript{0x1403D3C50, 0x14042EAA0};
 	WEAK symbol<unsigned int(const char* script, unsigned int name)> Scr_GetFunctionHandle{0x1403D3AD0 , 0x14042E920};
 	WEAK symbol<unsigned int(void* func, int type, unsigned int name)> Scr_RegisterFunction{0x1403D3530, 0x14042E330};
-	WEAK symbol<void()> Scr_ErrorInternal{0x0, 0x140438660};
+	WEAK symbol<void()> Scr_ErrorInternal{0, 0x140438660};
 
-	WEAK symbol<int(unsigned int)> GetObjectType{0x0, 0x140433CF0};
+	WEAK symbol<int(unsigned int)> GetObjectType{0, 0x140433CF0};
 
 	WEAK symbol<unsigned int(unsigned int localId, const char* pos, unsigned int paramcount)> VM_Execute{0, 0x14043A280};
 
@@ -201,31 +226,32 @@ namespace game
 	WEAK symbol<void(int arg, char* buffer, int bufferLength)> SV_Cmd_ArgvBuffer{0x1403B4560, 0x1403F80D0};
 	WEAK symbol<void(const char* text_in)> SV_Cmd_TokenizeString{0, 0x1403F8150};
 	WEAK symbol<void()> SV_Cmd_EndTokenizedString{0, 0x1403F8110};
-	WEAK symbol<void()> SV_MatchEnd{0x0, 0x14047A090};
+	WEAK symbol<void()> SV_MatchEnd{0, 0x14047A090};
 
-	WEAK symbol<void(netadr_s* from)> SV_DirectConnect{0, 0x140471390};
+	WEAK symbol<void(netadr_t* from)> SV_DirectConnect{0, 0x140471390};
 	WEAK symbol<void(int, int, const char*)> SV_GameSendServerCommand{0x140490F40, 0x1404758C0};
 	WEAK symbol<bool()> SV_Loaded{0x140491820, 0x1404770C0};
 	WEAK symbol<void(int localClientNum, const char* map, bool mapIsPreloaded)> SV_StartMap{0, 0x140470170};
 	WEAK symbol<void(int localClientNum, const char* map, bool mapIsPreloaded, bool migrate)> SV_StartMapForParty{0, 0x1404702F0};
 
-	WEAK symbol<mp::gentity_s*(const char*, unsigned int, unsigned int, unsigned int)> SV_AddBot{0, 0x140470920};
+	WEAK symbol<mp::gentity_t*(const char*, unsigned int, unsigned int, unsigned int)> SV_AddBot{0, 0x140470920};
 	WEAK symbol<bool(int clientNum)> SV_BotIsBot{0, 0x140461340};
 	WEAK symbol<const char*()> SV_BotGetRandomName{0, 0x140460B80};
-	WEAK symbol<void(mp::gentity_s*)> SV_SpawnTestClient{0, 0x1404740A0};
+	WEAK symbol<void(mp::gentity_t*)> SV_SpawnTestClient{0, 0x1404740A0};
 
 	WEAK symbol<void(mp::client_t*, const char*, int)> SV_ExecuteClientCommand{0, 0x140472430};
 	WEAK symbol<void()> SV_FastRestart{0x14048B890, 0x14046F440};
-	WEAK symbol<playerState_s*(int num)> SV_GetPlayerstateForClientNum{0x140490F80, 0x140475A10};
+	WEAK symbol<playerState_t*(int num)> SV_GetPlayerstateForClientNum{0x140490F80, 0x140475A10};
 	WEAK symbol<const char*(int clientNum)> SV_GetGuid{0, 0x140475990};
 	WEAK symbol<void(int clientNum, const char* reason)> SV_KickClientNum{0, 0x14046F730};
+	WEAK symbol<bool(mp::client_t*, const char*, int)> SV_Netchan_Transmit{0, 0x14047CC60};
 	WEAK symbol<void(int index, const char* string)> SV_SetConfigstring{0, 0x140477450};
 
 	WEAK symbol<void(const char* error, ...)> Sys_Error{0x14043AC20, 0x1404FF510};
 	WEAK symbol<bool()> Sys_IsDatabaseReady2{0x1403C2D40, 0x140423920};
 	WEAK symbol<int()> Sys_Milliseconds{0x14043D2A0, 0x140501CA0};
 	WEAK symbol<void()> Sys_ShowConsole{0x14043E650, 0x140503130};
-	WEAK symbol<bool(int, void const*, const netadr_s*)> Sys_SendPacket{0x14043D000, 0x140501A00};
+	WEAK symbol<bool(int, void const*, const netadr_t*)> Sys_SendPacket{0x14043D000, 0x140501A00};
 	WEAK symbol<void*(int valueIndex)> Sys_GetValue{0x1403C2C30, 0x1404237D0};
 	WEAK symbol<bool()> Sys_IsMainThread{0x1478FC470, 0x140423950};
 	WEAK symbol<HANDLE(Sys_Folder folder, const char* baseFilename)> Sys_CreateFile{0x140434B10, 0x1404F8FD0};
@@ -237,6 +263,9 @@ namespace game
 	WEAK symbol<const char*(const char*)> UI_LocalizeMapname{0, 0x1404B96D0};
 	WEAK symbol<const char*(const char*)> UI_LocalizeGametype{0, 0x1404B90F0};
 
+	WEAK symbol<void(int localClientNum, mp::cg_t* cg, vec3_t* outViewOrigin, 
+					 vec3_t* outViewAngles)> VehicleCam_UpdatePlayerControlCam{0, 0x140568CA0};
+
 	WEAK symbol<DWOnlineStatus(int)> dwGetLogOnStatus{0, 0x140589490};
 
 	WEAK symbol<void(pmove_t* move, trace_t*, const float*, const float*,
@@ -244,7 +273,7 @@ namespace game
 	WEAK symbol<void(const pmove_t* move, trace_t* trace, const float*,
 		const float*, const Bounds*, int, int)> PM_trace{0, 0x140225DB0};
 
-	WEAK symbol<void(void* ps)> Jump_ClearState{0x0, 0x140213120};
+	WEAK symbol<void(void* ps)> Jump_ClearState{0, 0x140213120};
 
 	WEAK symbol<void*(jmp_buf* Buf, int Value)> longjmp{0x14062E030, 0x140738060};
 	WEAK symbol<int (jmp_buf* Buf)> _setjmp{0x14062F030, 0x140739060};
@@ -257,7 +286,7 @@ namespace game
 
 	WEAK symbol<CmdArgs> cmd_args{0x144CE7F70, 0x144518480};
 	WEAK symbol<CmdArgs> sv_cmd_args{0x144CE8020, 0x144518530};
-	WEAK symbol<cmd_function_s*> cmd_functions{0x144CE80C8, 0x1445185D8};
+	WEAK symbol<cmd_function_t*> cmd_functions{0x144CE80C8, 0x1445185D8};
 
 	WEAK symbol<int> dvarCount{0x1458CBA3C, 0x1478EADF4};
 	WEAK symbol<dvar_t*> sortedDvars{0x1458CBA60, 0x1478EAE10};
@@ -294,36 +323,37 @@ namespace game
 	WEAK symbol<function_stack_t> scr_function_stack{0x1455BE708, 0x144D57808};
 	WEAK symbol<unsigned int> scr_levelEntityId{0x1452A9F30, 0x144A43020};
 
-	WEAK symbol<int> level_time{0x0, 0x1443F4B6C};
-	WEAK symbol<int> level_finished{0x0, 0x1443F6FAC};
-	WEAK symbol<int> level_savepersist{0x0, 0x1443F5710};
+	WEAK symbol<int> level_time{0, 0x1443F4B6C};
+	WEAK symbol<int> level_finished{0, 0x1443F6FAC};
+	WEAK symbol<int> level_savepersist{0, 0x1443F5710};
 
 	WEAK symbol<DWORD> threadIds{0x144DE6640, 0x1446B4960};
 
-	WEAK symbol<GfxDrawMethod_s> gfxDrawMethod{0x145F525A8, 0x1480350D8};
+	WEAK symbol<GfxDrawMethod_t> gfxDrawMethod{0x145F525A8, 0x1480350D8};
 
 	namespace sp
 	{
-		WEAK symbol<gentity_s> g_entities{0x143C91600, 0};
+		WEAK symbol<gentity_t> g_entities{0x143C91600, 0};
 
 		WEAK symbol<XZone> g_zones_0{0x1434892D8, 0};
 	}
 
 	namespace mp
 	{
-		WEAK symbol<cg_s> cgArray{0, 0x14176EC00};
+		WEAK symbol<cg_t> cg{0, 0x14176EC00};
+		WEAK symbol<cgs_t> cgs{0, 0x14187EB80};
+		WEAK symbol<clientActive_t> cl{0, 0x1419E1C70};
+		WEAK symbol<clientConnection_t> clc{0, 0x141CB5350};
+		WEAK symbol<clientStatic_t> cls{0, 0x141D1AB60};
+		WEAK symbol<serverStatic_t> svs{0, 0x144DF9580};
 
-		WEAK symbol<gentity_s> g_entities{0, 0x14427A0E0};
-
-		WEAK symbol<int> svs_clientCount{0, 0x14647B28C};
-		WEAK symbol<client_t> svs_clients{0, 0x14647B290};
-
-		WEAK symbol<std::uint32_t> sv_serverId_value{0, 0x144DF9478};
-
-		WEAK symbol<int> gameTime{0, 0x1443F4B6C};
-		WEAK symbol<int> serverTime{0, 0x14647B280};
+		WEAK symbol<gentity_t> g_entities{0, 0x14427A0E0};
+		WEAK symbol<centity_t> centities{0, 0x141887350};
 
 		WEAK symbol<XZone> g_zones_0{0, 0x143A46498};
+		WEAK symbol<connstate_t> connstate{0, 0x1419E1AE0};
+		WEAK symbol<int> gameTime{0, 0x1443F4B6C};
+		WEAK symbol<std::uint32_t> sv_serverId_value{0, 0x144DF9478};
 	}
 
 	namespace hks

src/client/main.cpp

@@ -4,6 +4,7 @@
 #include "loader/component_loader.hpp"
 #include "game/game.hpp"
 
+#include "utils/command_line.hpp"
 #include <utils/flags.hpp>
 #include <utils/io.hpp>
 #include <utils/string.hpp>
@@ -165,11 +166,26 @@ FARPROC load_binary(const launcher::mode mode)
 	}
 
 	std::string data;
+	if (!utils::io::read_file(binary, &data))
+	{
+		// Check the first argument to see if the current directory needs to changed
+		// Required when the game is used to open a file (like a demo file)
+		const auto& args = utils::command_line::get_args();
+		if (!args.empty())
+		{
+			const auto& binary_dir = args.front();
+			if (binary_dir.filename().string().ends_with("iw6-mod.exe"))
+			{
+				std::filesystem::current_path(binary_dir.parent_path());
+			}
+		}
+
 		if (!utils::io::read_file(binary, &data))
 		{
 			throw std::runtime_error(
 				"Failed to read game binary! Please select the correct path in the launcher settings.");
 		}
+	}
 
 #ifdef INJECT_HOST_AS_LIB
 	return loader.load_library(binary);

src/client/std_include.hpp

@@ -46,7 +46,10 @@
 #undef min
 #endif
 
+#include <algorithm>
+#include <array>
 #include <atomic>
+#include <cassert>
 #include <chrono>
 #include <filesystem>
 #include <format>
@@ -54,6 +57,7 @@
 #include <functional>
 #include <map>
 #include <mutex>
+#include <numeric>
 #include <optional>
 #include <queue>
 #include <random>

src/common/utils/command_line.cpp

@@ -0,0 +1,35 @@
+#include "command_line.hpp"
+#include "nt.hpp"
+
+#include <shellapi.h>
+#include <winrt/Windows.Foundation.h>
+
+namespace utils::command_line
+{
+	template <typename type, typename deleter>
+	constexpr std::unique_ptr<type, deleter> make_unique_ptr(type* ptr, deleter&& del)
+	{
+		return std::unique_ptr<type, deleter&&>(ptr, std::forward<deleter>(del));
+	}
+
+	const std::vector<std::filesystem::path>& get_args()
+	{
+		static const auto args = []()
+		{
+			auto argc = 0;
+			const auto cmd_line = winrt::check_pointer(::GetCommandLineW());
+			const auto up = make_unique_ptr(winrt::check_pointer(::CommandLineToArgvW(cmd_line, &argc)), ::LocalFree);
+			const auto argv = up.get();
+
+			std::vector<std::filesystem::path> vec(argc);
+			std::transform(argv, argv + argc, vec.begin(), [](const auto* path)
+			{
+				return std::filesystem::path(path);
+			});
+
+			return vec;
+		}();
+
+		return args;
+	}
+}

src/common/utils/command_line.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <filesystem>
+#include <vector>
+
+namespace utils::command_line
+{
+	[[nodiscard]] const std::vector<std::filesystem::path>& get_args();
+}

src/common/utils/compression.cpp

@@ -109,6 +109,86 @@ namespace utils::compression
 			result.resize(length);
 			return result;
 		}
+
+		std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> input, std::size_t exp_output_size, double growth_rate)
+		{
+			auto decompress_internal = [](std::uint8_t* output, uLong* output_size, const std::uint8_t* input, uLong* input_size)
+			{
+				return uncompress2(
+					reinterpret_cast<Bytef*>(output), output_size,
+					reinterpret_cast<const Bytef*>(input), input_size
+				);
+			};
+
+			auto output_size = static_cast<uLong>(std::max(exp_output_size, std::size_t(256)));
+			std::vector<std::uint8_t> output(output_size);
+
+			auto input_size = static_cast<uLong>(input.size());
+			auto status = decompress_internal(output.data(), &output_size, input.data(), &input_size);
+
+			if (status == Z_BUF_ERROR)
+			{
+				const auto decompression_ratio = (input_size / static_cast<double>(output.size())) - 0.04;
+				output_size = static_cast<uLong>(std::max(input.size() / decompression_ratio, static_cast<double>(output_size)));
+				output.resize(output_size);
+
+				input_size = static_cast<uLong>(input.size());
+				status = decompress_internal(output.data(), &output_size, input.data(), &input_size);
+			}
+
+			for (growth_rate = std::max(growth_rate, 1.0); status == Z_BUF_ERROR;)
+			{
+				output_size = 4 + static_cast<uLong>(growth_rate * output.size());
+				output.resize(output_size);
+
+				input_size = static_cast<uLong>(input.size());
+				status = decompress_internal(output.data(), &output_size, input.data(), &input_size);
+			}
+
+			if (status != Z_OK)
+			{
+				output.clear();
+				return output;
+			}
+
+			output.resize(output_size);
+			return output;
+		}
+
+		std::vector<std::uint8_t> compress(std::span<const std::uint8_t> input, std::size_t exp_output_size, double growth_rate)
+		{
+			auto compress_internal = [](std::uint8_t* output, uLong* output_size, const std::uint8_t* input, uLong input_size)
+			{
+				return compress2(
+					reinterpret_cast<Bytef*>(output), output_size,
+					reinterpret_cast<const Bytef*>(input), input_size,
+					Z_BEST_COMPRESSION
+				);
+			};
+
+			auto output_size = static_cast<uLong>(std::max(exp_output_size, std::size_t(256)));
+			std::vector<std::uint8_t> output(output_size);
+
+			const auto input_size = static_cast<uLong>(input.size());
+			auto status = compress_internal(output.data(), &output_size, input.data(), input_size);
+
+			for (growth_rate = std::max(growth_rate, 1.0); status == Z_BUF_ERROR;)
+			{
+				output_size = 4 + static_cast<uLong>(growth_rate * output.size());
+				output.resize(output_size);
+
+				status = compress_internal(output.data(), &output_size, input.data(), input_size);
+			}
+
+			if (status != Z_OK)
+			{
+				output.clear();
+				return output;
+			}
+
+			output.resize(output_size);
+			return output;
+		}
 	}
 
 	namespace zip

src/common/utils/compression.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
+#include <span>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 #define CHUNK 16384u
 
@@ -11,6 +13,9 @@ namespace utils::compression
 	{
 		std::string compress(const std::string& data);
 		std::string decompress(const std::string& data);
+
+		std::vector<std::uint8_t> compress(std::span<const std::uint8_t> input, std::size_t exp_output_size, double growth_rate = 2.0);
+		std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> input, std::size_t exp_output_size, double growth_rate = 2.0);
 	}
 
 	namespace zip

src/common/utils/hook.cpp

@@ -2,6 +2,7 @@
 #include "string.hpp"
 
 #include <MinHook.h>
+#include <cassert>
 
 namespace utils::hook
 {
@@ -279,6 +280,7 @@ namespace utils::hook
 		void* result = nullptr;
 		runtime.add(&result, &code);
 
+		assert(result);
 		return result;
 	}
 

src/common/utils/string.cpp

@@ -115,13 +115,13 @@ namespace utils::string
 
 	void strip(const char* in, char* out, size_t max)
 	{
-		if (!in || !out) return;
+		if (!in || !out || !max) return;
 
 		max--;
 		auto current = 0u;
 		while (*in != 0 && current < max)
 		{
-			const auto color_index = (*(in + 1) - 48) >= 0xC ? 7 : (*(in + 1) - 48);
+			const auto color_index = (static_cast<size_t>(*(in + 1) - 48)) >= 0xC ? 7 : (*(in + 1) - 48);
 
 			if (*in == '^' && (color_index != 7 || *(in + 1) == '7'))
 			{
@@ -140,6 +140,32 @@ namespace utils::string
 		*out = '\0';
 	}
 
+	std::string strip(std::string_view sv, bool strip_default_color)
+	{
+		std::string in(sv);
+
+		for (std::size_t i = 0; i + 1 < in.size();)
+		{
+			if (in[i] == '^' && static_cast<std::size_t>(in[i + 1] - '0') < 0xC)
+			{
+				if (in[i + 1] != '7' || strip_default_color)
+				{
+					in.erase(in.begin() + i, in.begin() + i + 2);
+				}
+				else
+				{
+					i += 2;
+				}
+			}
+			else
+			{
+				i += 1;
+			}
+		}
+
+		return in;
+	}
+
 	std::string convert(const std::wstring& wstr)
 	{
 		std::string result;

src/common/utils/string.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include "memory.hpp"
 #include <cstdint>
+#include <span>
 
 template <class Type, size_t n>
 constexpr auto ARRAY_COUNT(Type(&)[n]) { return n; }
@@ -91,6 +92,7 @@ namespace utils::string
 	std::string get_clipboard_data();
 
 	void strip(const char* in, char* out, size_t max);
+	std::string strip(std::string_view sv, bool strip_default_color = false);
 
 	std::string convert(const std::wstring& wstr);
 	std::wstring convert(const std::string& str);