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"));
 

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)

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
+				discord_presence.partySize = game::mp::cg->snap != nullptr
-					? game::mp::cgArray->snap->numClients
+					? 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;

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

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

@@ -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 &&
+			if (game::mp::svs->clients[i].header.state >= game::CS_CONNECTED &&
-				game::mp::svs_clients[i].testClient != game::TC_NONE)
+				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);
 

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)

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

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];
+				auto* client = &game::mp::svs->clients[i];
-				client->nextSnapshotTime = *game::mp::serverTime - 1;
+				client->nextSnapshotTime = game::mp::svs->time - 1;
 			}
 		}
 	}

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;
+		const char* data;
-		char* splitData;
+		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
+		static_assert(sizeof(playerState_t) == 0x3328);
-		{
+#pragma pack(pop)
-			unsigned int modelIndex[3];
-		};
 
 		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
 	{

src/client/game/symbols.hpp

@@ -311,19 +311,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<centity_t> centities{0, 0x141887350};
-		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<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