[Gamepad]: Replaced Dvar_FindVar on actual dvars objects.

src/Components/Modules/Dvars.cpp

@@ -41,7 +41,32 @@ namespace Dvars
 	Game::dvar_s* M_RawInput = nullptr;
 
 	// Gamepad
+	Game::dvar_s* gpad_enabled = nullptr;
+	Game::dvar_s* gpad_debug = nullptr;
+	Game::dvar_s* gpad_present = nullptr;
+	Game::dvar_s* gpad_in_use = nullptr;
+	Game::dvar_s* gpad_style = nullptr;
+	Game::dvar_s* gpad_sticksConfig = nullptr;
+	Game::dvar_s* gpad_buttonConfig = nullptr;
+	Game::dvar_s* gpad_menu_scroll_delay_first = nullptr;
+	Game::dvar_s* gpad_menu_scroll_delay_rest = nullptr;
+	Game::dvar_s* gpad_stick_pressed_hysteresis = nullptr;
+	Game::dvar_s* gpad_stick_pressed = nullptr;
+	Game::dvar_s* gpad_stick_deadzone_min = nullptr;
+	Game::dvar_s* gpad_stick_deadzone_max = nullptr;
+	Game::dvar_s* gpad_button_deadzone = nullptr;
+	Game::dvar_s* gpad_button_lstick_deflect_max = nullptr;
+	Game::dvar_s* gpad_button_rstick_deflect_max = nullptr;
 	Game::dvar_s* gpad_use_hold_time = nullptr;
+	Game::dvar_s* gpad_lockon_enabled = nullptr;
+	Game::dvar_s* gpad_slowdown_enabled = nullptr;
+	Game::dvar_s* gpad_autoaim_enabled = nullptr;
+	Game::dvar_s* gpad_aimassist = nullptr;
+	Game::dvar_s* input_viewSensitivity = nullptr;
+	Game::dvar_s* input_invertPitch = nullptr;
+	Game::dvar_s* aim_aimAssistRangeScale = nullptr;
+	Game::dvar_s* aim_autoAimRangeScale = nullptr;
+	Game::dvar_s* aim_lockon_pitch_strength = nullptr;
 
 	namespace Functions
 	{
@@ -81,6 +106,36 @@ namespace Dvars
 				call	Dvar_Reset_func;
 			}
 		}
+
+		void SetRaw(const char* dvarName, bool value)
+		{
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
+			{
+				dvar->current.enabled = value;
+				dvar->latched.enabled = value;
+	}
+		}
+
+		void SetRaw(Game::dvar_s* dvar, bool value)
+		{
+			dvar->current.enabled = value;
+			dvar->latched.enabled = value;
+		}
+
+		void SetRaw(const char* dvarName, const char* value)
+		{
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
+			{
+				dvar->current.enabled = value;
+				dvar->latched.enabled = value;
+			}
+		}
+
+		void SetRaw(Game::dvar_s* dvar, const char* value)
+		{
+			dvar->current.enabled = value;
+			dvar->latched.enabled = value;
+		}
 	}
 
 	namespace Register
@@ -92,41 +147,39 @@ namespace Dvars
 	{
 		void DvarBoolOverride(const char* dvarName, const bool value, Game::dvar_flags flags)
 		{
-			auto dvar = Dvars::Functions::Dvar_FindVar(dvarName);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
-
-			if (!dvar)
 			{
-				return;
-			}
-
 			dvar->current.enabled = value;
 			dvar->latched.enabled = value;
 			dvar->flags = flags;
 			dvar->modified = false;
 		}
+		}
 
 		void DvarBoolOverride(const char* dvarName, Game::dvar_flags flags)
 		{
-			auto dvar = Dvars::Functions::Dvar_FindVar(dvarName);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
-
-			if (!dvar)
 			{
-				return;
-			}
-
 				dvar->flags = flags;
 				dvar->modified = false;
 			}
+		}
+
+		void DvarIntOverride(const char* dvarName, const int value, Game::dvar_flags flags)
+		{
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
+			{
+				dvar->current.integer = value;
+				dvar->latched.integer = value;
+			dvar->flags = flags;
+			dvar->modified = false;
+		}
+		}
 
 		void DvarVec4Override(const char* dvarName, const float* dvar_value)
 		{
-			auto dvar = Dvars::Functions::Dvar_FindVar(dvarName);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
-
-			if (!dvar)
 			{
-				return;
-			}
-
 			for (auto i = 0; i < 4; i++)
 			{
 				dvar->current.vector[i] = dvar_value[i];
@@ -134,16 +187,12 @@ namespace Dvars
 				dvar->modified = false;
 			}
 		}
+		}
 
 		void DvarVec4OverrideDefaultValue(const char* dvarName, const float* dvar_value)
 		{
-			auto dvar = Dvars::Functions::Dvar_FindVar(dvarName);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvarName); dvar)
-
-			if (!dvar)
 			{
-				return;
-			}
-
 			for (auto i = 0; i < 4; i++)
 			{
 				dvar->reset.vector[i] = dvar_value[i];
@@ -152,3 +201,4 @@ namespace Dvars
 		}
 	}
 }
+}

src/Components/Modules/Dvars.hpp

@@ -41,7 +41,32 @@ namespace Dvars
 	extern Game::dvar_s* M_RawInput;
 
 	// Gamepad
+	extern Game::dvar_s* gpad_enabled;
+	extern Game::dvar_s* gpad_debug;
+	extern Game::dvar_s* gpad_present;
+	extern Game::dvar_s* gpad_in_use;
+	extern Game::dvar_s* gpad_style;
+	extern Game::dvar_s* gpad_sticksConfig;
+	extern Game::dvar_s* gpad_buttonConfig;
+	extern Game::dvar_s* gpad_menu_scroll_delay_first;
+	extern Game::dvar_s* gpad_menu_scroll_delay_rest;
+	extern Game::dvar_s* gpad_stick_pressed_hysteresis;
+	extern Game::dvar_s* gpad_stick_pressed;
+	extern Game::dvar_s* gpad_stick_deadzone_min;
+	extern Game::dvar_s* gpad_stick_deadzone_max;
+	extern Game::dvar_s* gpad_button_deadzone;
+	extern Game::dvar_s* gpad_button_lstick_deflect_max;
+	extern Game::dvar_s* gpad_button_rstick_deflect_max;
 	extern Game::dvar_s* gpad_use_hold_time;
+	extern Game::dvar_s* gpad_lockon_enabled;
+	extern Game::dvar_s* gpad_slowdown_enabled;
+	extern Game::dvar_s* gpad_autoaim_enabled;
+	extern Game::dvar_s* gpad_aimassist;
+	extern Game::dvar_s* input_viewSensitivity;
+	extern Game::dvar_s* input_invertPitch;
+	extern Game::dvar_s* aim_aimAssistRangeScale;
+	extern Game::dvar_s* aim_autoAimRangeScale;
+	extern Game::dvar_s* aim_lockon_pitch_strength;
 
 	namespace Functions
 	{
@@ -51,10 +76,17 @@ namespace Dvars
 		void Dvar_SetStringByName(const char* dvarName, const char* value);
 		void Dvar_SetIntByName(const char* dvarName, int value);
 		void Dvar_Reset(int value/*eax*/, Game::dvar_s* dvar/*ecx*/);
+
+		// Sets
+		void SetRaw(const char* dvarName, bool value);
+		void SetRaw(Game::dvar_s* dvar, bool value);
+		void SetRaw(const char* dvarName, const char* value);
+		void SetRaw(Game::dvar_s* dvar, const char* value);
 	}
 
 	namespace Register
 	{
+		// INTEGER
 		static Utils::function<Game::dvar_s* (const char* dvarName, Game::dvar_type typeInt, std::uint16_t flags, const char* description, std::int32_t defaultValue, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t minValue, std::int32_t maxValue)>
 			Dvar_RegisterInt_r = 0x588750;
 
@@ -63,22 +95,41 @@ namespace Dvars
 			return Dvar_RegisterInt_r(dvar_name, Game::dvar_type::integer, flags, description, default_value, 0, 0, 0, min_value, max_value);
 		}
 
+		// BOOL
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_bool, std::uint16_t flags, const char* description, std::int32_t default_value, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t null4, std::int32_t null5)>
-			Dvar_RegisterBool_r = 0x588750;
+			Dvar_RegisterNewBool = 0x588750;
+		static Utils::function<void(Game::dvar_s* dvar, const char* dvar_name, Game::dvar_type type_bool, std::uint16_t flags, const char* description, std::int32_t default_value, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t null4, std::int32_t null5)>
+			Dvar_ReregisterBool = 0x588610;
 
 		inline Game::dvar_s* Dvar_RegisterBool(const char* dvar_name, const char* description, std::int32_t default_value, std::uint16_t flags)
 		{
-			return Dvar_RegisterBool_r(dvar_name, Game::dvar_type::boolean, flags, description, default_value, 0, 0, 0, 0, 0);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvar_name); dvar)
+			{
+				Dvar_ReregisterBool(dvar, dvar_name, Game::dvar_type::boolean, flags, description, default_value, 0, 0, 0, 0, 0);
+				return dvar;
+		}
+			else
+				return Dvar_RegisterNewBool(dvar_name, Game::dvar_type::boolean, flags, description, default_value, 0, 0, 0, 0, 0);
 		}
 
+		// ENUM
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_enum, std::uint16_t flags, const char* description, std::int32_t default_index, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t enumSize, const char** enum_data)>
-			Dvar_RegisterEnum_r = 0x588750;
+			Dvar_RegisterNewEnum = 0x588750;
+		static Utils::function<void(Game::dvar_s* dvar, const char* dvar_name, Game::dvar_type type_enum, std::uint16_t flags, const char* description, std::int32_t default_value, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t enumSize, const char** enum_data)>
+			Dvar_ReregisterEnum = 0x588610;
 
 		inline Game::dvar_s* Dvar_RegisterEnum(const char* dvar_name, const char* description, std::int32_t default_value, std::int32_t enum_size, const char** enum_data, std::uint16_t flags)
 		{
-			return Dvar_RegisterEnum_r(dvar_name, Game::dvar_type::enumeration, flags, description, default_value, 0, 0, 0, enum_size, enum_data);
+			if (const auto& dvar = Functions::Dvar_FindVar(dvar_name); dvar)
+			{
+				Dvar_ReregisterEnum(dvar, dvar_name, Game::dvar_type::enumeration, flags, description, default_value, 0, 0, 0, enum_size, enum_data);
+				return dvar;
+		}
+			else
+				return Dvar_RegisterNewEnum(dvar_name, Game::dvar_type::enumeration, flags, description, default_value, 0, 0, 0, enum_size, enum_data);
 		}
 
+		// STRING
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_string, std::uint16_t flags, const char* description, const char* default_value, std::int32_t null1, std::int32_t null2, std::int32_t null3, std::int32_t null4, std::int32_t null5)>
 			Dvar_RegisterString_r = 0x588750;
 
@@ -93,6 +144,7 @@ namespace Dvars
 			return dvar;
 		}
 
+		// VEC2
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_float2, std::uint16_t flags, const char* description, float x, float y, std::int32_t null1, std::int32_t null2, float min, float max)>
 			Dvar_RegisterVec2_r = 0x588750;
 
@@ -100,6 +152,7 @@ namespace Dvars
 			return Dvar_RegisterVec2_r(dvar_name, Game::dvar_type::vec2, flags, description, x, y, 0, 0, min_value, max_value);
 		}
 
+		// VEC3
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_float3, std::uint16_t flags, const char* description, float x, float y, float z, std::int32_t null, float min, float max)>
 			Dvar_RegisterVec3_r = 0x588750;
 
@@ -107,13 +160,24 @@ namespace Dvars
 			return Dvar_RegisterVec3_r(dvar_name, Game::dvar_type::vec3, flags, description, x, y, z, 0, min_value, max_value);
 		}
 
+		// VEC4
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_float4, std::uint16_t flags, const char* description, float x, float y, float z, float w, float min, float max)>
-			Dvar_RegisterVec4_r = 0x588750;
+			Dvar_RegisterNewVec4 = 0x588750;
+		static Utils::function<void(Game::dvar_s* dvar, const char* dvar_name, Game::dvar_type type_float4, std::uint16_t flags, const char* description, float x, float y, float z, float w, float min, float max)>
+			Dvar_ReregisterVec4 = 0x588610;
 
-		inline Game::dvar_s* Dvar_RegisterVec4(const char* dvar_name, const char* description, float x, float y, float z, float w, float min_value, float max_value, std::uint16_t flags) {
+		inline Game::dvar_s* Dvar_RegisterVec4(const char* dvar_name, const char* description, float x, float y, float z, float w, float min_value, float max_value, std::uint16_t flags) 
-			return Dvar_RegisterVec4_r(dvar_name, Game::dvar_type::vec4, flags, description, x, y, z, w, min_value, max_value);
+		{
+			if (const auto& dvar = Functions::Dvar_FindVar(dvar_name); dvar)
+			{
+				Dvar_ReregisterVec4(dvar, dvar_name, Game::dvar_type::vec4, flags, description, x, y, z, w, min_value, max_value);
+				return dvar;
+			}
+			else
+				return Dvar_RegisterNewVec4(dvar_name, Game::dvar_type::vec4, flags, description, x, y, z, w, min_value, max_value);
 		}
 
+		// FLOAT
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type_float2, std::uint16_t flags, const char* description, float x, float y, std::int32_t null1, std::int32_t null2, float min, float max)>
 			Dvar_RegisterFloat_r = 0x588750;
 
@@ -121,6 +185,7 @@ namespace Dvars
 			return Dvar_RegisterFloat_r(dvar_name, Game::dvar_type::value, flags, description, default_value, 0, 0, 0, min_value, max_value);
 		}
 
+		//REMOVE THIS CODE!!!
 		static Utils::function<Game::dvar_s* (const char* dvar_name, Game::dvar_type type, std::uint16_t flags, const char* description, int x, int y, int z, int w, int min, int max)>
 			Dvar_RegisterNew = 0x588750;
 	}

src/Components/Modules/Gamepad.cpp

@@ -291,7 +291,7 @@ namespace Components
 
 	bool Gamepad::AimAssist_IsSlowdownActive(const Game::AimInput* input)
 	{
-		if (!Dvars::Functions::Dvar_FindVar("aim_slowdown_enabled")->current.enabled || !Dvars::Functions::Dvar_FindVar("gpad_slowdown_enabled")->current.enabled)
+		if (!Dvars::Functions::Dvar_FindVar("aim_slowdown_enabled")->current.enabled || !Dvars::gpad_slowdown_enabled->current.enabled)
 		{
 			return false;
 		}
@@ -338,7 +338,7 @@ namespace Components
 		}
 
 		const auto* weaponDef = Game::bg_weaponDefs[input->ps->weapon];
-		const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * Dvars::Functions::Dvar_FindVar("aim_aimAssistRangeScale")->current.value;
+		const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * Dvars::aim_aimAssistRangeScale->current.value;
 		const auto screenTarget = AimAssist_GetBestTarget(&aaGlob, aimAssistRange, aaGlob.tweakables.slowdownRegionWidth, aaGlob.tweakables.slowdownRegionHeight);
 
 		if (screenTarget)
@@ -380,7 +380,7 @@ namespace Components
 			AimAssist_CalcSlowdown(input, &slowdownPitchScale, &slowdownYawScale);
 		}
 
-		const auto sensitivity = Dvars::Functions::Dvar_FindVar("input_viewSensitivity")->current.value;
+		const auto sensitivity = Dvars::input_viewSensitivity->current.value;
 		auto pitchTurnRate = AimAssist_Lerp(Dvars::Functions::Dvar_FindVar("aim_turnrate_pitch")->current.value, Dvars::Functions::Dvar_FindVar("aim_turnrate_pitch_ads")->current.value, aaGlob.adsLerp);
 		pitchTurnRate = slowdownPitchScale * aaGlob.fovTurnRateScale * sensitivity * pitchTurnRate;
 		auto yawTurnRate = AimAssist_Lerp(Dvars::Functions::Dvar_FindVar("aim_turnrate_yaw")->current.value, Dvars::Functions::Dvar_FindVar("aim_turnrate_yaw_ads")->current.value, aaGlob.adsLerp);
@@ -448,7 +448,7 @@ namespace Components
 	{
 		AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
 
-		if (!Dvars::Functions::Dvar_FindVar("aim_lockon_enabled")->current.enabled || !Dvars::Functions::Dvar_FindVar("gpad_lockon_enabled")->current.enabled)
+		if (!Dvars::Functions::Dvar_FindVar("aim_lockon_enabled")->current.enabled || !Dvars::gpad_lockon_enabled->current.enabled)
 		{
 			return false;
 		}
@@ -548,7 +548,7 @@ namespace Components
 			return;
 		}
 
-		const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * Dvars::Functions::Dvar_FindVar("aim_aimAssistRangeScale")->current.value;
+		const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * Dvars::aim_aimAssistRangeScale->current.value;
 		const auto screenTarget = AimAssist_GetPrevOrBestTarget(&aaGlob, aimAssistRange, aaGlob.tweakables.lockOnRegionWidth, aaGlob.tweakables.lockOnRegionHeight, prevTargetEnt);
 
 		if (screenTarget && screenTarget->distSqr > 0.0f)
@@ -559,7 +559,7 @@ namespace Components
 			const auto pitchTurnRate =
 				(screenTarget->velocity[0] * aaGlob.viewAxis[2][0] + screenTarget->velocity[1] * aaGlob.viewAxis[2][1] + screenTarget->velocity[2] * aaGlob.viewAxis[2][2]
 					- (input->ps->velocity[0] * aaGlob.viewAxis[2][0] + input->ps->velocity[1] * aaGlob.viewAxis[2][1] + input->ps->velocity[2] * aaGlob.viewAxis[2][2]))
-				/ arcLength * 180.0f * Dvars::Functions::Dvar_FindVar("aim_lockon_pitch_strength")->current.value;
+				/ arcLength * 180.0f * Dvars::aim_lockon_pitch_strength->current.value;
 
 			const auto yawTurnRate =
 				(screenTarget->velocity[0] * aaGlob.viewAxis[1][0] + screenTarget->velocity[1] * aaGlob.viewAxis[1][1] + screenTarget->velocity[2] * aaGlob.viewAxis[1][2]
@@ -575,7 +575,7 @@ namespace Components
 	{
 		AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
 
-		if (!Dvars::Functions::Dvar_FindVar("aim_autoaim_enabled")->current.enabled || !Dvars::Functions::Dvar_FindVar("gpad_autoaim_enabled")->current.enabled)
+		if (!Dvars::Functions::Dvar_FindVar("aim_autoaim_enabled")->current.enabled || !Dvars::gpad_autoaim_enabled->current.enabled)
 		{
 			return false;
 		}
@@ -654,7 +654,7 @@ namespace Components
 		{
 			if (!aaGlob.autoAimPressed)
 			{
-				const auto screenTarget = AimAssist_GetBestTarget(&aaGlob, weaponDef->autoAimRange * Dvars::Functions::Dvar_FindVar("aim_autoAimRangeScale")->current.value, aaGlob.tweakables.autoAimRegionWidth, aaGlob.tweakables.autoAimRegionHeight);
+				const auto screenTarget = AimAssist_GetBestTarget(&aaGlob, weaponDef->autoAimRange * Dvars::aim_autoAimRangeScale->current.value, aaGlob.tweakables.autoAimRegionWidth, aaGlob.tweakables.autoAimRegionHeight);
 				if (screenTarget)
 					AimAssist_SetAutoAimTarget(&aaGlob, screenTarget);
 				aaGlob.autoAimPressed = 1;
@@ -761,7 +761,7 @@ namespace Components
 		auto& clientActive = Game::clients[0];
 
 		auto pitch = CL_GamepadAxisValue(Game::GPAD_VIRTAXIS_PITCH);
-		if (!Dvars::Functions::Dvar_FindVar("input_invertPitch")->current.enabled)
+		if (!Dvars::input_invertPitch->current.enabled)
 			pitch *= -1;
 
 		auto yaw = -CL_GamepadAxisValue(Game::GPAD_VIRTAXIS_YAW);
@@ -826,7 +826,7 @@ namespace Components
 		{
 			Utils::Hook::Call<void(Game::usercmd_s*)>(0x43FA90)(cmd);
 		}
-		else if (Dvars::Functions::Dvar_FindVar("gpad_enabled")->current.enabled && gamePad.enabled)
+		else if (Dvars::gpad_enabled->current.enabled && gamePad.enabled)
 		{
 			if(!Game::Key_IsCatcherActive(Game::KEYCATCH_CONSOLE)) //disable any actions from gamepad if game console is opened
 				CL_GamepadMove(cmd);
@@ -960,11 +960,7 @@ namespace Components
 	void Gamepad::Key_SetBinding_Hk(const int localClientNum, const int keyNum, const char* binding)
 	{
 		if (Key_IsValidGamePadChar(keyNum))
-		{
+			Dvars::Functions::SetRaw(Dvars::gpad_buttonConfig, "custom");
-			Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->current.string = "custom";
-			Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->latched.string = "custom";
-		}
-
 		Game::Key_SetBinding(localClientNum, keyNum, binding);
 	}
 
@@ -972,8 +968,7 @@ namespace Components
 	{
 		// A keyboard key has been pressed. Mark controller as unused.
 		gamePads[0].inUse = false;
-		Dvars::Functions::Dvar_FindVar("gpad_in_use")->current.enabled = false;
+		Dvars::Functions::SetRaw(Dvars::gpad_in_use, false);
-		Dvars::Functions::Dvar_FindVar("gpad_in_use")->latched.enabled = false;
 
 		// Call original function
 		Utils::Hook::Call<void(int, int, int, unsigned)>(0x443D60)(localClientNum, key, down, time); //CL_KeyEvent
@@ -994,8 +989,7 @@ namespace Components
 		if (dx != 0 || dy != 0)
 		{
 			gamePads[0].inUse = false;
-			Dvars::Functions::Dvar_FindVar("gpad_in_use")->current.enabled = false;
+			Dvars::Functions::SetRaw(Dvars::gpad_in_use, false);
-			Dvars::Functions::Dvar_FindVar("gpad_in_use")->latched.enabled = false;
 		}
 	}
 
@@ -1006,10 +1000,7 @@ namespace Components
 
 	Game::keyname_t* Gamepad::GetLocalizedKeyNameMap()
 	{
-		if(Dvars::Functions::Dvar_FindVar("gpad_style")->current.enabled)
+		return Dvars::gpad_style->current.enabled ? combinedLocalizedKeyNamesPs3 : combinedLocalizedKeyNamesXenon;
-			return combinedLocalizedKeyNamesPs3;
-		else
-			return combinedLocalizedKeyNamesXenon;
 	}
 
 	void __declspec(naked) Gamepad::GetLocalizedKeyName_Stub()
@@ -1137,8 +1128,8 @@ namespace Components
 
 		if (Game::Key_IsCatcherActive(Game::KEYCATCH_UI))
 		{
-			const int scrollDelayFirst = Dvars::Functions::Dvar_FindVar("gpad_menu_scroll_delay_first")->current.integer;
+			const int scrollDelayFirst = Dvars::gpad_menu_scroll_delay_first->current.integer;
-			const int scrollDelayRest = Dvars::Functions::Dvar_FindVar("gpad_menu_scroll_delay_rest")->current.integer;
+			const int scrollDelayRest = Dvars::gpad_menu_scroll_delay_rest->current.integer;
 
 			for (const auto menuScrollButton : menuScrollButtonList)
 			{
@@ -1192,6 +1183,13 @@ namespace Components
 		if (pressedOrUpdated && CL_CheckForIgnoreDueToRepeat(localClientNum, key, keyState.keys[key].repeats, time))
 			return;
 
+
+		if (Game::clientUIActive->connectionState == Game::CA_CINEMATIC || Game::clientUIActive->connectionState == Game::CA_LOGO)
+		{
+			if ((pressed && (key == Game::K_BUTTON_A || key == Game::K_FIRSTGAMEPADBUTTON_RANGE_2)) && Game::Key_IsCatcherActive(Game::KEYCATCH_UI) == 0 || Game::g_currentMenuType == 0)
+				Game::CL_StopLogoOrCinematic(localClientNum);
+		}
+
 		if (Game::Key_IsCatcherActive(Game::KEYCATCH_LOCATION_SELECTION) && pressedOrUpdated)
 		{
 			if (key == Game::K_BUTTON_B || keyState.keys[key].binding && std::strcmp(keyState.keys[key].binding, "+actionslot 4") == 0)
@@ -1252,8 +1250,7 @@ namespace Components
 
 		auto& gamePad = gamePads[localClientNum];
 		gamePad.inUse = true;
-		Dvars::Functions::Dvar_FindVar("gpad_in_use")->current.enabled = true;
+		Dvars::Functions::SetRaw(Dvars::gpad_in_use, true);
-		Dvars::Functions::Dvar_FindVar("gpad_in_use")->latched.enabled = true;
 
 		if (Game::Key_IsCatcherActive(Game::KEYCATCH_UI))
 		{
@@ -1277,14 +1274,14 @@ namespace Components
 		stickVec[0] = static_cast<float>(x) / static_cast<float>(std::numeric_limits<short>::max());
 		stickVec[1] = static_cast<float>(y) / static_cast<float>(std::numeric_limits<short>::max());
 
-		const auto deadZoneTotal = Dvars::Functions::Dvar_FindVar("gpad_stick_deadzone_min")->current.value + Dvars::Functions::Dvar_FindVar("gpad_stick_deadzone_max")->current.value;
+		const auto deadZoneTotal = Dvars::gpad_stick_deadzone_min->current.value + Dvars::gpad_stick_deadzone_max->current.value;
 		auto len = Game::Vec2Normalize(stickVec);
 
-		if (Dvars::Functions::Dvar_FindVar("gpad_stick_deadzone_min")->current.value <= len)
+		if (Dvars::gpad_stick_deadzone_min->current.value <= len)
 		{
-			if (1.0f - Dvars::Functions::Dvar_FindVar("gpad_stick_deadzone_max")->current.value >= len)
+			if (1.0f - Dvars::gpad_stick_deadzone_max->current.value >= len)
 			{
-				len = (len - Dvars::Functions::Dvar_FindVar("gpad_stick_deadzone_min")->current.value) / (1.0f - deadZoneTotal);
+				len = (len - Dvars::gpad_stick_deadzone_min->current.value) / (1.0f - deadZoneTotal);
 			}
 			else
 			{
@@ -1353,7 +1350,7 @@ namespace Components
 			return;
 		}
 
-		const auto scrollDelayFirst = Dvars::Functions::Dvar_FindVar("gpad_menu_scroll_delay_first")->current.integer;
+		const auto scrollDelayFirst = Dvars::gpad_menu_scroll_delay_first->current.integer;
 		for (const auto scrollButton : menuScrollButtonList)
 		{
 			if (key == scrollButton)
@@ -1413,9 +1410,7 @@ namespace Components
 		if (std::fabs(value) > 0.0f)
 		{
 			gamePad.inUse = true;
-
+			Dvars::Functions::SetRaw(Dvars::gpad_in_use, true);
-			Dvars::Functions::Dvar_FindVar("gpad_in_use")->current.enabled = true;
-			Dvars::Functions::Dvar_FindVar("gpad_in_use")->latched.enabled = true;
 		}
 	}
 
@@ -1552,15 +1547,15 @@ namespace Components
 				auto& gamePad = gamePads[localClientNum];
 				gamePad.stickDownLast[stickIndex][dir] = gamePad.stickDown[stickIndex][dir];
 
-				auto threshold = Dvars::Functions::Dvar_FindVar("gpad_stick_pressed")->current.value;
+				auto threshold = Dvars::gpad_stick_pressed->current.value;
 
 				if (gamePad.stickDownLast[stickIndex][dir])
 				{
-					threshold -= Dvars::Functions::Dvar_FindVar("gpad_stick_pressed_hysteresis")->current.value;
+					threshold -= Dvars::gpad_stick_pressed_hysteresis->current.value;
 				}
 				else
 				{
-					threshold += Dvars::Functions::Dvar_FindVar("gpad_stick_pressed_hysteresis")->current.value;
+					threshold += Dvars::gpad_stick_pressed_hysteresis->current.value;
 				}
 
 				if (dir == Game::GPAD_STICK_POS)
@@ -1597,7 +1592,7 @@ namespace Components
 
 		GPad_UpdateSticksDown(localClientNum);
 
-		if (Dvars::Functions::Dvar_FindVar("gpad_debug")->current.enabled)
+		if (Dvars::gpad_debug->current.enabled)
 		{
 			Game::Com_Printf(0, "Left: X: {%f} Y: {%f}\n", lVec[0], lVec[1]);
 			Game::Com_Printf(0, "Right: X: {%f} Y: {%f}\n", rVec[0], rVec[1]);
@@ -1618,23 +1613,21 @@ namespace Components
 		gamePad.lastDigitals = gamePad.digitals;
 		gamePad.digitals = state.wButtons;
 
-		const auto leftDeflect = Dvars::Functions::Dvar_FindVar("gpad_button_lstick_deflect_max")->current.value;
+		const auto leftDeflect = Dvars::gpad_button_lstick_deflect_max->current.value;
 		if (std::fabs(gamePad.sticks[0]) > leftDeflect || std::fabs(gamePad.sticks[1]) > leftDeflect)
 		{
 			gamePad.digitals &= ~static_cast<short>(XINPUT_GAMEPAD_LEFT_THUMB);
 		}
 
-		const auto rightDeflect = Dvars::Functions::Dvar_FindVar("gpad_button_rstick_deflect_max")->current.value;
+		const auto rightDeflect = Dvars::gpad_button_rstick_deflect_max->current.value;
 		if (std::fabs(gamePad.sticks[2]) > leftDeflect || std::fabs(gamePad.sticks[3]) > rightDeflect)
 		{
 			gamePad.digitals &= ~static_cast<short>(XINPUT_GAMEPAD_RIGHT_THUMB);
 		}
 
-		if (Dvars::Functions::Dvar_FindVar("gpad_debug")->current.enabled)
+		if (Dvars::gpad_debug->current.enabled)
-		{
 			Game::Com_Printf(0, "Buttons: {%hu}\n", gamePad.digitals);
 		}
-	}
 
 	void Gamepad::GPad_UpdateAnalogs(const int localClientNum, const XINPUT_GAMEPAD& state)
 	{
@@ -1642,7 +1635,7 @@ namespace Components
 
 		auto& gamePad = gamePads[localClientNum];
 
-		const auto buttonDeadZone = Dvars::Functions::Dvar_FindVar("gpad_button_deadzone")->current.value;
+		const auto buttonDeadZone = Dvars::gpad_button_deadzone->current.value;
 
 		gamePad.lastAnalogs[0] = gamePad.analogs[0];
 		gamePad.analogs[0] = static_cast<float>(state.bLeftTrigger) / static_cast<float>(std::numeric_limits<unsigned char>::max());
@@ -1658,11 +1651,9 @@ namespace Components
 			gamePad.analogs[1] = 0.0f;
 		}
 
-		if (Dvars::Functions::Dvar_FindVar("gpad_debug")->current.enabled)
+		if (Dvars::gpad_debug->current.enabled)
-		{
 			Game::Com_Printf(0, "Triggers: {%f} {%f}\n", gamePad.analogs[0], gamePad.analogs[1]);
 		}
-	}
 
 	void Gamepad::GPad_UpdateAll()
 	{
@@ -1769,6 +1760,7 @@ namespace Components
 	void Gamepad::IN_GamePadsMove()
 	{
 		if (!Dvars::Functions::Dvar_FindVar("gpad_enabled")->current.enabled || Game::Key_IsCatcherActive(Game::KEYCATCH_CONSOLE))
+		if (!Dvars::gpad_enabled->current.enabled || Game::Key_IsCatcherActive(Game::KEYCATCH_CONSOLE))
 			return;
 
 		UpdateGamepadHint();
@@ -1780,9 +1772,7 @@ namespace Components
 		{
 			auto& gamePad = gamePads[localClientNum];
 			if (!gamePad.enabled)
-			{
 				continue;
-			}
 
 			gpadPresent = true;
 			const auto lx = GPad_GetStick(localClientNum, Game::GPAD_LX);
@@ -1792,16 +1782,8 @@ namespace Components
 			const auto leftTrig = GPad_GetButton(localClientNum, Game::GPAD_L_TRIG);
 			const auto rightTrig = GPad_GetButton(localClientNum, Game::GPAD_R_TRIG);
 
-			// only without mods
+			if (!Game::HasLoadedMod())
-			if (strlen(Dvars::Functions::Dvar_FindVar("fs_game")->current.string) == 0)
-			{
 				CL_GamepadCheat();
-			}
-
-			//if (XInputGetBatteryInformation(gamePad.portIndex, BATTERY_DEVTYPE_GAMEPAD, &gamePad.battery_info) == ERROR_SUCCESS)
-			//{
-			//	Game::Com_Printf(0, "Battery Level: %d\n", gamePad.battery_info.BatteryLevel);
-			//}
 
 			CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_LSTICK_X, lx, time);
 			CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_LSTICK_Y, ly, time);
@@ -1827,8 +1809,7 @@ namespace Components
 			}
 		}
 
-		Dvars::Functions::Dvar_FindVar("gpad_present")->current.enabled = gpadPresent;
+		Dvars::Functions::SetRaw(Dvars::gpad_present, gpadPresent);
-		Dvars::Functions::Dvar_FindVar("gpad_present")->latched.enabled = gpadPresent;
 	}
 
 	void Gamepad::IN_Frame_Hk()
@@ -2091,19 +2072,17 @@ namespace Components
 
 	void Gamepad::Bind_GP_SticksConfigs_f()
 	{
-		const auto* stickConfigName = Dvars::Functions::Dvar_FindVar("gpad_sticksConfig")->current.string;
+		Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", Dvars::gpad_sticksConfig->current.string));
-		Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", stickConfigName));
 	}
 
 	void Gamepad::Bind_GP_ButtonsConfigs_f()
 	{
-		const auto* buttonConfigName = Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->current.string;
+		Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", Dvars::gpad_buttonConfig->current.string));
-		Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", buttonConfigName));
 	}
 
 	void Gamepad::SetAimAssist_f()
 	{
-		if (Dvars::Functions::Dvar_FindVar("gpad_aimassist")->current.enabled)
+		if (Dvars::gpad_aimassist->current.enabled)
 		{
 			Command::Execute("set gpad_autoaim_enabled 1", false);
 			Command::Execute("set gpad_lockon_enabled 1", false);
@@ -2117,44 +2096,39 @@ namespace Components
 		}
 	}
 
-	void Gamepad::PauseMenu_Toggle_f()
-	{
-		Command::Execute("pause", false);
-	}
-
 	Gamepad::Gamepad()
 	{
 		CL_GamepadCheatInit();
 
 		Events::OnDvarInit([]
 		{
-			Game::dvar_s* gpad_enabled = Dvars::Register::Dvar_RegisterBool("gpad_enabled", "Game pad enabled", false, Game::saved);
+			Dvars::gpad_enabled = Dvars::Register::Dvar_RegisterBool("gpad_enabled", "Game pad enabled", false, Game::saved);
-			Game::dvar_s* gpad_debug = Dvars::Register::Dvar_RegisterBool("gpad_debug", "Game pad debugging", false, Game::none);
+			Dvars::gpad_debug = Dvars::Register::Dvar_RegisterBool("gpad_debug", "Game pad debugging", false, Game::none);
-			Game::dvar_s* gpad_present = Dvars::Register::Dvar_RegisterBool("gpad_present", "Game pad present", false, Game::none);
+			Dvars::gpad_present = Dvars::Register::Dvar_RegisterBool("gpad_present", "Game pad present", false, Game::none);
-			Game::dvar_s* gpad_in_use = Dvars::Register::Dvar_RegisterBool("gpad_in_use", "A game pad is in use", false, Game::none);
+			Dvars::gpad_in_use = Dvars::Register::Dvar_RegisterBool("gpad_in_use", "A game pad is in use", false, Game::none);
-			Game::dvar_s* gpad_style = Dvars::Register::Dvar_RegisterBool("gpad_style", "Switch between Xbox and PS HUD", false, Game::saved);
+			Dvars::gpad_style = Dvars::Register::Dvar_RegisterBool("gpad_style", "Switch between Xbox and PS HUD", false, Game::saved);
-			Game::dvar_s* gpad_sticksConfig = Dvars::Register::Dvar_RegisterString("gpad_sticksConfig", "Game pad stick configuration", "", Game::saved);
+			Dvars::gpad_sticksConfig = Dvars::Register::Dvar_RegisterString("gpad_sticksConfig", "Game pad stick configuration", "", Game::saved);
-			Game::dvar_s* gpad_buttonConfig = Dvars::Register::Dvar_RegisterString("gpad_buttonConfig", "Game pad button configuration", "", Game::saved);
+			Dvars::gpad_buttonConfig = Dvars::Register::Dvar_RegisterString("gpad_buttonConfig", "Game pad button configuration", "", Game::saved);
-			Game::dvar_s* gpad_menu_scroll_delay_first = Dvars::Register::Dvar_RegisterInt("gpad_menu_scroll_delay_first", "Menu scroll key-repeat delay, for the first repeat, in milliseconds", 420, 0, 1000, Game::none);
+			Dvars::gpad_menu_scroll_delay_first = Dvars::Register::Dvar_RegisterInt("gpad_menu_scroll_delay_first", "Menu scroll key-repeat delay, for the first repeat, in milliseconds", 420, 0, 1000, Game::none);
-			Game::dvar_s* gpad_menu_scroll_delay_rest = Dvars::Register::Dvar_RegisterInt("gpad_menu_scroll_delay_rest", "Menu scroll key-repeat delay, for repeats after the first, in milliseconds", 210, 0, 1000, Game::none);
+			Dvars::gpad_menu_scroll_delay_rest = Dvars::Register::Dvar_RegisterInt("gpad_menu_scroll_delay_rest", "Menu scroll key-repeat delay, for repeats after the first, in milliseconds", 210, 0, 1000, Game::none);
-			Game::dvar_s* gpad_stick_pressed_hysteresis = Dvars::Register::Dvar_RegisterFloat("gpad_stick_pressed_hysteresis", "Game pad stick pressed no-change-zone around gpad_stick_pressed to prevent bouncing", 0.1f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_stick_pressed_hysteresis = Dvars::Register::Dvar_RegisterFloat("gpad_stick_pressed_hysteresis", "Game pad stick pressed no-change-zone around gpad_stick_pressed to prevent bouncing", 0.1f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_stick_pressed = Dvars::Register::Dvar_RegisterFloat("gpad_stick_pressed", "Game pad stick pressed threshhold", 0.4f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_stick_pressed = Dvars::Register::Dvar_RegisterFloat("gpad_stick_pressed", "Game pad stick pressed threshhold", 0.4f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_stick_deadzone_min = Dvars::Register::Dvar_RegisterFloat("gpad_stick_deadzone_min", "Game pad minimum stick deadzone", 0.2f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_stick_deadzone_min = Dvars::Register::Dvar_RegisterFloat("gpad_stick_deadzone_min", "Game pad minimum stick deadzone", 0.2f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_stick_deadzone_max = Dvars::Register::Dvar_RegisterFloat("gpad_stick_deadzone_max", "Game pad maximum stick deadzone", 0.01f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_stick_deadzone_max = Dvars::Register::Dvar_RegisterFloat("gpad_stick_deadzone_max", "Game pad maximum stick deadzone", 0.01f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_button_deadzone = Dvars::Register::Dvar_RegisterFloat("gpad_button_deadzone", "Game pad button deadzone threshhold", 0.13f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_button_deadzone = Dvars::Register::Dvar_RegisterFloat("gpad_button_deadzone", "Game pad button deadzone threshhold", 0.13f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_button_lstick_deflect_max = Dvars::Register::Dvar_RegisterFloat("gpad_button_lstick_deflect_max", "Game pad maximum pad stick pressed value", 1.0f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_button_lstick_deflect_max = Dvars::Register::Dvar_RegisterFloat("gpad_button_lstick_deflect_max", "Game pad maximum pad stick pressed value", 1.0f, 0.0f, 1.0f, Game::none);
-			Game::dvar_s* gpad_button_rstick_deflect_max = Dvars::Register::Dvar_RegisterFloat("gpad_button_rstick_deflect_max", "Game pad maximum pad stick pressed value", 1.0f, 0.0f, 1.0f, Game::none);
+			Dvars::gpad_button_rstick_deflect_max = Dvars::Register::Dvar_RegisterFloat("gpad_button_rstick_deflect_max", "Game pad maximum pad stick pressed value", 1.0f, 0.0f, 1.0f, Game::none);
 			Dvars::gpad_use_hold_time = Dvars::Register::Dvar_RegisterInt("gpad_use_hold_time", "Time to hold the 'use' button on gamepads to activate use", 250, 0, std::numeric_limits<int>::max(), Game::none);
-			Game::dvar_s* gpad_lockon_enabled = Dvars::Register::Dvar_RegisterBool("gpad_lockon_enabled", "Game pad lockon aim assist enabled", true, Game::saved);
+			Dvars::gpad_lockon_enabled = Dvars::Register::Dvar_RegisterBool("gpad_lockon_enabled", "Game pad lockon aim assist enabled", true, Game::saved);
-			Game::dvar_s* gpad_slowdown_enabled = Dvars::Register::Dvar_RegisterBool("gpad_slowdown_enabled", "Game pad slowdown aim assist enabled", true, Game::saved);
+			Dvars::gpad_slowdown_enabled = Dvars::Register::Dvar_RegisterBool("gpad_slowdown_enabled", "Game pad slowdown aim assist enabled", true, Game::saved);
-			Game::dvar_s* gpad_autoaim_enabled = Dvars::Register::Dvar_RegisterBool("gpad_autoaim_enabled", "Gamepad auto aim", true, Game::saved);
+			Dvars::gpad_autoaim_enabled = Dvars::Register::Dvar_RegisterBool("gpad_autoaim_enabled", "Gamepad auto aim", true, Game::saved);
-			Game::dvar_s* gpad_aimassist = Dvars::Register::Dvar_RegisterBool("gpad_aimassist", "Gamepad aim assist", true, Game::saved);
+			Dvars::gpad_aimassist = Dvars::Register::Dvar_RegisterBool("gpad_aimassist", "Gamepad aim assist", true, Game::saved);
 
-			Game::dvar_s* input_viewSensitivity = Dvars::Register::Dvar_RegisterFloat("input_viewSensitivity", "View Sensitivity", 1.0f, 0.0001f, 5.0f, Game::saved);
+			Dvars::input_viewSensitivity = Dvars::Register::Dvar_RegisterFloat("input_viewSensitivity", "View Sensitivity", 1.0f, 0.0001f, 5.0f, Game::saved);
-			Game::dvar_s* input_invertPitch = Dvars::Register::Dvar_RegisterBool("input_invertPitch", "Invert gamepad pitch", false, Game::saved);
+			Dvars::input_invertPitch = Dvars::Register::Dvar_RegisterBool("input_invertPitch", "Invert gamepad pitch", false, Game::saved);
-			Game::dvar_s* aim_aimAssistRangeScale = Dvars::Register::Dvar_RegisterFloat("aim_aimAssistRangeScale", "Scales the weapon'aim_autoAimRangeScales aim assist range", 1.0f, 0.0f, 2.0f, Game::none);
+			Dvars::aim_aimAssistRangeScale = Dvars::Register::Dvar_RegisterFloat("aim_aimAssistRangeScale", "Scales the weapon'aim_autoAimRangeScales aim assist range", 1.0f, 0.0f, 2.0f, Game::none);
-			Game::dvar_s* aim_autoAimRangeScale = Dvars::Register::Dvar_RegisterFloat("aim_autoAimRangeScale", "Scales the weapon's auto aim range", 1.0f, 0.0f, 2.0f, Game::none);
+			Dvars::aim_autoAimRangeScale = Dvars::Register::Dvar_RegisterFloat("aim_autoAimRangeScale", "Scales the weapon's auto aim range", 1.0f, 0.0f, 2.0f, Game::none);
-			Game::dvar_s* aim_lockon_pitch_strength = Dvars::Register::Dvar_RegisterFloat("aim_lockon_pitch_strength", "The amount of aim assistance given by the target lock on (pitch)", 0.6f, 0.0f, 1.0f, Game::none);
+			Dvars::aim_lockon_pitch_strength = Dvars::Register::Dvar_RegisterFloat("aim_lockon_pitch_strength", "The amount of aim assistance given by the target lock on (pitch)", 0.6f, 0.0f, 1.0f, Game::none);
 		});
 
 		// Add hold time to gamepad usereload on hold prompts
@@ -2204,20 +2178,18 @@ namespace Components
 
 		UIScript::Add("gamepadFirstExecIfEnabled", []([[maybe_unused]] const UIScript::Token& token, [[maybe_unused]] const Game::uiInfo_s* info)
 		{			
-			if (Dvars::Functions::Dvar_FindVar("gpad_enabled")->current.enabled)
+			if (Dvars::gpad_enabled->current.enabled)
 			{
-				std::string gpadSticksConfig = Dvars::Functions::Dvar_FindVar("gpad_sticksConfig")->current.string;
+				std::string gpadSticksConfig = Dvars::gpad_sticksConfig->current.string;
-				std::string gpadButtonConfig = Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->current.string;
+				std::string gpadButtonConfig = Dvars::gpad_buttonConfig->current.string;
 				if (gpadSticksConfig == "")
 				{
-					Dvars::Functions::Dvar_FindVar("gpad_sticksConfig")->current.string = "thumbstick_default";
+					Dvars::Functions::SetRaw(Dvars::gpad_sticksConfig, "thumbstick_default");
-					Dvars::Functions::Dvar_FindVar("gpad_sticksConfig")->latched.string = "thumbstick_default";
 					Command::Execute("bindgpsticksconfigs", false);
 				}
 				if (gpadButtonConfig == "")
 				{
-					Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->current.string = "buttons_default";
+					Dvars::Functions::SetRaw(Dvars::gpad_buttonConfig, "buttons_default");
-					Dvars::Functions::Dvar_FindVar("gpad_buttonConfig")->latched.string = "buttons_default";
 					Command::Execute("bindgpbuttonsconfigs", false);
 				}