Added workaround to enforce max fps limit.

Without this workaround my fps occasionally exceeds 1500 or even 2000 fps.
Added a few changes.
2024-12-31 00:23:57 +01:00 · 2024-12-31 00:17:57 +01:00 · 2024-12-31 00:12:38 +01:00 · 2024-12-31 00:01:31 +01:00 · 2024-12-30 23:35:17 +01:00
17 changed files with 570 additions and 92 deletions
--- a/src/client/component/bots.cpp
+++ b/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);
@ -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"));

--- a/src/client/component/branding.cpp
+++ b/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([]()
 			{
--- a/src/client/component/dedicated_info.cpp
+++ b/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);
--- a/src/client/component/discord.cpp
+++ b/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,7 +65,7 @@ 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;
--- a/src/client/component/fps.cpp
+++ b/src/client/component/fps.cpp
@ -74,6 +74,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 +101,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));
 		}
--- a/src/client/component/game_console.cpp
+++ b/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;
 			}
--- a/src/client/component/input.cpp
+++ b/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);
 		}
 	};
 }
--- a/src/client/component/notifies.cpp
+++ b/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),
--- a/src/client/component/party.cpp
+++ b/src/client/component/party.cpp
@ -120,9 +120,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 +134,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;
 			}
@ -158,7 +158,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)
 			{
@ -283,7 +283,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 +320,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 +331,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;
 				}
@ -418,7 +418,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);

--- a/src/client/component/patches.cpp
+++ b/src/client/component/patches.cpp
@ -191,7 +191,7 @@ namespace patches
 		{
 			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)
--- a/src/client/component/rcon.cpp
+++ b/src/client/component/rcon.cpp
@ -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]{};
--- a/src/client/component/slowmotion.cpp
+++ b/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);
 		}
 	};
 }
--- a/src/client/game/structs.hpp
+++ b/src/client/game/structs.hpp
@ -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
@ -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;
@ -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;
@ -2099,7 +2134,9 @@ namespace game
 			int clientNum;
 			int viewmodelIndex;
 			vec3_t viewangles;
-			char _0x190[0xAC];
+			char _0x190[0x58];
+			int viewlocked_entNum;
+			char _0x1EC[0x50];
 			int locationSelectionInfo;
 			SprintState_t sprintState;
 			float holdBreathScale;
@ -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;
@ -2186,44 +2354,51 @@ namespace game
 			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];
+			char _0x10[0x10];
 			usercmd_t cmd;
 			usercmd_t oldcmd;
 			int localClient;
-			char __0x33C4[0x24];
+			char _0x9C[0x34];
 			float moveSpeedScaleMultiplier;
 			int viewmodelIndex;
 			int noSpectate;
 			clientState_t cs;
 			ScoreInfo scores;
-			char __pad[0x1B0];
+			char _0x1E6[0x1C0];
 		};

+		static_assert(sizeof(clientSession_t) == 0x388);
+
 		struct gclient_t
 		{
 			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,6 +2443,13 @@ namespace game
 			char _0x14C[0xC];
 		};

+		struct centity_t
+		{
+			char _0x0[0x238];
+		};
+
+		static_assert(sizeof(centity_t) == 0x238);
+
 		struct gentity_t
 		{
 			EntityState s;
@ -2281,19 +2465,230 @@ namespace game

 		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
 		};

+		enum DemoType
+		{
+			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[0x64];
+			char _0x3324[0x38];
+			int clientNum;
+			int localClientNum;
+			DemoType demoType;
+			char _0x336C[0x1C];
 			snapshot_t* snap;
-			snapshot_t* nextSnap; // theres alot after this cba rn
+			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
@ -2343,7 +2738,7 @@ namespace game

 		struct __declspec(align(8)) clientHeader_t
 		{
-			int state;
+			clientstate_t state;
 			int sendAsActive;
 			int deltaMessage;
 			int rateDelayed;
@ -2377,7 +2772,10 @@ namespace game
 			int reliableAcknowledge;
 			int reliableSent;
 			int messageAcknowledge;
-			char _0xC30[0x41238];
+			int largeCommandSequence;
+			int gamestateMessageNum;
+			int challenge;
+			char _0xC3C[0x4122C];
 			gentity_t* gentity;
 			char name[16];
 			int lastPacketTime;
@ -2400,6 +2798,8 @@ namespace game
 			char _0x41E94[0x416A0];
 		};

+		static_assert(sizeof(client_t) == 0x83570);
+
 		struct XZone
 		{
 			char name[64];
@ -2419,9 +2819,18 @@ namespace game
 		};

 		static_assert(sizeof(missileFireParms) == 0x20);
-	}

-	static_assert(sizeof(mp::client_t) == 0x83570);
+		struct serverStatic_t
+		{
+			char _0x0[0x1681D00];
+			int time;
+			int loopbackProcessStopTime;
+			int snapFlagServerBit;
+			int clientCount;
+			client_t clients[18];
+			// missing fields
+		};
+	}

 	union playerState_t
 	{
--- a/src/client/game/symbols.hpp
+++ b/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_t* 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(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,6 +109,8 @@ 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_t* ps, Weapon weapon, int dualWield, int startInAltMode, int usedBefore)> G_GivePlayerWeapon{0x140359E20, 0x1403DA5E0};
 	WEAK symbol<Weapon(const char* name)> G_GetWeaponForName{0x140359890, 0x1403DA060};
@ -101,10 +119,10 @@ namespace game
 	WEAK symbol<void(int clientNum, Weapon weapon)> G_SelectWeapon{0x14035A200, 0x1403DA880};
 	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_t*(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,24 +154,30 @@ 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<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_t*, float, float, float, float, float, float*, int)> R_AddCmdDrawText{0x140533E40, 0x140601070};
-	WEAK symbol<void(const char*, int, Font_t*, float, float, float, float, float, const float*, int, int, char)> R_AddCmdDrawTextWithCursor{0x140534170, 0x1406013A0};
+	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_t* font)> R_TextWidth{0x140513390, 0x1405DFDB0};
@ -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,7 +226,7 @@ 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_t* from)> SV_DirectConnect{0, 0x140471390};
 	WEAK symbol<void(int, int, const char*)> SV_GameSendServerCommand{0x140490F40, 0x1404758C0};
@ -219,6 +244,7 @@ namespace game
 	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};
@ -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};
@ -294,9 +323,9 @@ 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};

@ -311,19 +340,20 @@ namespace game

 	namespace mp
 	{
-		WEAK symbol<cg_t> 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_t> 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<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
--- a/src/client/main.cpp
+++ b/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>
@ -167,8 +168,23 @@ FARPROC load_binary(const launcher::mode mode)
 	std::string data;
 	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.");
+		// 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
--- a/src/client/std_include.hpp
+++ b/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>
--- a/src/common/utils/hook.cpp
+++ b/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;
 	}
Author	SHA1	Message	Date
Caball	d424dc2c45	Added workaround to enforce max fps limit. Without this workaround my fps occasionally exceeds 1500 or even 2000 fps.	2024-12-31 00:23:57 +01:00
Caball	d26a5fe43f	Added a few changes. Added missing includes to the list of standard headers. Added an assertion to the asmjit assemble function to get an early warning if asmjit fails silently.	2024-12-31 00:17:57 +01:00
Caball	7954966c60	Updated function symbols and references. Replaced all occurrences of 0x0 with 0 for consistency.	2024-12-31 00:12:38 +01:00
Caball	3553cd49ff	Updated game structs, variable symbols and references.	2024-12-31 00:01:31 +01:00
Caball	2516a48fc1	Added fallback logic for current path / working directory.	2024-12-30 23:35:17 +01:00