Merge

.gitignore

@@ -1,2 +1,3 @@
 build/
+.cache
 .vs

CMakeLists.txt

@@ -33,9 +33,8 @@ message(STATUS "Setting up include directories.")
 target_include_directories(${PROJECT_NAME} PRIVATE
     "${SRC_DIR}"
     "${imgui_SOURCE_DIR}"
-    "${minhook_SOURCE_DIR}/include"    
-    "${minhook_SOURCE_DIR}/src/hde"    
-    "${gtav_classes_SOURCE_DIR}"
+    "${minhook_SOURCE_DIR}/include"
+    "${minhook_SOURCE_DIR}/src/hde"
 )
 
 message(STATUS "Setting up linked libraries")

cmake/cross-compile.cmake

@@ -8,11 +8,8 @@ if(USE_GCC OR USE_CLANG)
     set(TOOLCHAIN_PREFIX "x86_64-w64-mingw32" CACHE STRING "Set toolchain. Default: x86_64-w64-mingw32")
     message(STATUS "Using ${TOOLCHAIN_PREFIX} toolchain")
     set(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32)
-    set(CMAKE_SYSTEM_NAME "Windows")
     set(CMAKE_ASM_MASM_COMPILER "uasm")
 
-    set(CMAKE_C_COMPILER_TARGET x86_64-windows-gnu)
-    set(CMAKE_CXX_COMPILER_TARGET x86_64-windows-gnu)
     set(CMAKE_Fortran_COMPILER ${TOOLCHAIN_PREFIX}-gfortran)
     set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
 
@@ -30,16 +27,20 @@ if(USE_GCC OR USE_CLANG)
         add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-fpermissive;-fno-rtti${CXX_FLAGS}>")
         set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
         set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+        set(CMAKE_C_COMPILER_TARGET x86_64-windows-gnu)
+        set(CMAKE_CXX_COMPILER_TARGET x86_64-windows-gnu)
     endif()
 
     if(USE_CLANG)
         message(STATUS "Using clang compiler.")
         set(CMAKE_C_COMPILER clang)
         set(CMAKE_CXX_COMPILER clang++)
+        set(CMAKE_C_COMPILER_TARGET x86_64-windows-msvc)
+        set(CMAKE_CXX_COMPILER_TARGET x86_64-windows-msvc)
 
         # Disable RTTI to work around libstdc++ issue https://stackoverflow.com/a/77025827
-        add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-fuse-ld=lld;-femulated-tls;-fno-rtti${CXX_FLAGS}>")
-        add_link_options(-fuse-ld=lld -femulated-tls -fno-rtti)
+        add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-fuse-ld=lld;-fno-rtti${CXX_FLAGS}>")
+        add_link_options(-fuse-ld=lld -fno-rtti)
     endif()
 
 endif() 

cmake/json.cmake

@@ -1,6 +1,6 @@
 include(FetchContent)
 
 message(STATUS "Setting up nlohmann::json")
-FetchContent_Declare(json GIT_REPOSITORY "https://github.com/nlohmann/json/" GIT_TAG v3.11.2 GIT_SHALLOW TRUE)
+FetchContent_Declare(json GIT_REPOSITORY "https://github.com/nlohmann/json/" GIT_TAG v3.12.0 GIT_SHALLOW TRUE)
 option(JSON_MultipleHeaders "Disable nlohmann JSON multi header default." OFF)
 FetchContent_MakeAvailable(json)

cmake/minhook.cmake

@@ -6,7 +6,7 @@ message(STATUS "Setting up ${LIB_NAME}")
 FetchContent_Declare(
     ${LIB_NAME}
     GIT_REPOSITORY https://github.com/TsudaKageyu/minhook.git
-    GIT_TAG        98b74f1fc12d00313d91f10450e5b3e0036175e3
+    GIT_TAG        2b003bb063d66f016cc1aef7d63951350ce60f35
 	GIT_PROGRESS TRUE
 )
 FetchContent_MakeAvailable(${LIB_NAME})

src/core/hooking/CallHook.hpp

@@ -57,7 +57,7 @@ namespace YimMenu
 			template<typename T>
 			T GetOriginal()
 			{
-				return static_cast<T>(m_OriginalFunction);
+				return reinterpret_cast<T>(m_OriginalFunction);
 			}
 		};
 

src/core/hooking/Hooking.cpp

@@ -35,6 +35,8 @@ namespace YimMenu
 		BaseHook::Add<Hooks::Spoofing::WriteNetArrayData>(new DetourHook("WriteNetArrayData", Pointers.WriteNetArrayData, Hooks::Spoofing::WriteNetArrayData));
 		BaseHook::Add<Hooks::Spoofing::WriteNodeData>(new DetourHook("WriteNodeData", Pointers.WriteNodeData, Hooks::Spoofing::WriteNodeData));
 		BaseHook::Add<Hooks::Spoofing::WriteSyncTree>(new DetourHook("WriteSyncTree", Pointers.WriteSyncTree, Hooks::Spoofing::WriteSyncTree));
+
+		BaseHook::Add<Hooks::Features::OpenPauseMenu>(new DetourHook("OpenPauseMenu", Pointers.OpenPauseMenu, Hooks::Features::OpenPauseMenu));
 	}
 
 	Hooking::~Hooking()

src/game/backend/AnticheatBypass.cpp

@@ -6,6 +6,11 @@
 #include "game/backend/NativeHooks.hpp"
 #include "game/gta/Natives.hpp"
 
+
+using FnGetVersion = int(*)();
+using FnLocalSaves = bool(*)();
+using FnBattlEyeBypass = bool(*)();
+
 namespace YimMenu
 {
 	static bool CheckForFSL()
@@ -43,6 +48,32 @@ namespace YimMenu
 	
 		LOGF(VERBOSE, "Anticheat bypass mode: {}", mode);
 
+		if (m_IsFSLLoaded)
+		{
+			HMODULE hFSL = GetModuleHandleA("WINMM.dll");
+			if (hFSL)
+			{
+				auto LawnchairGetVersion = reinterpret_cast<FnGetVersion>(GetProcAddress(hFSL, "LawnchairGetVersion"));
+				auto LawnchairIsProvidingLocalSaves = reinterpret_cast<FnLocalSaves>(GetProcAddress(hFSL, "LawnchairIsProvidingLocalSaves"));
+				auto LawnchairIsProvidingBattlEyeBypass = reinterpret_cast<FnBattlEyeBypass>(GetProcAddress(hFSL, "LawnchairIsProvidingBattlEyeBypass"));
+
+				if (LawnchairGetVersion && LawnchairIsProvidingLocalSaves && LawnchairIsProvidingBattlEyeBypass)
+				{
+					m_FSLVersion         = LawnchairGetVersion();
+					m_ProvidesLocalSaves = LawnchairIsProvidingLocalSaves();
+					m_ProvidesBEBYPASS   = LawnchairIsProvidingBattlEyeBypass();
+
+					LOGF(VERBOSE, "FSL Version: {}", m_FSLVersion);
+					LOGF(VERBOSE, "FSL Local Saves: {}", m_ProvidesLocalSaves ? "Enabled" : "Disabled");
+					LOGF(VERBOSE, "FSL BE Bypass: {}", m_ProvidesBEBYPASS ? "Enabled" : "Disabled");
+				}
+				else
+				{
+					LOGF(WARNING, "FSL detected but required exports were missing.");
+				}
+			}
+		}
+
 		if (m_BattlEyeRunning)
 			LOGF(WARNING, "If you are not running an actual BattlEye bypass, exit the game immediately and ensure that BE is properly disabled");
 

src/game/backend/AnticheatBypass.hpp

@@ -15,6 +15,9 @@ namespace YimMenu
 
 		bool m_IsFSLLoaded = false;
 		bool m_BattlEyeRunning = false;
+		int m_FSLVersion          = -1;
+		bool m_ProvidesLocalSaves = false;
+		bool m_ProvidesBEBYPASS   = false;
 
 	public:
 		static void RunScript()
@@ -32,5 +35,20 @@ namespace YimMenu
 		{
 			return GetInstance().m_BattlEyeRunning;
 		}
+
+		static int GetFSLVersion()
+		{
+			return GetInstance().m_FSLVersion;
+		}
+
+		static bool ProvidesLocalSaves()
+		{
+			return GetInstance().m_ProvidesLocalSaves;
+		}
+
+		static bool ProvidesBattlEyeBypass()
+		{
+			return GetInstance().m_ProvidesBEBYPASS;
+		}
 	};
 }

src/game/features/network/PauseGame.cpp

@@ -0,0 +1,35 @@
+#include "core/commands/BoolCommand.hpp"
+#include "core/hooking/DetourHook.hpp"
+#include "game/hooks/Hooks.hpp"
+#include "game/pointers/Pointers.hpp"
+
+namespace YimMenu::Features
+{
+	class PauseGame : public BoolCommand
+	{
+		using BoolCommand::BoolCommand;
+
+		virtual void OnEnable() override
+		{
+			Pointers.AllowPausingInSessionPatch->Apply();
+		}
+
+		virtual void OnDisable() override
+		{
+			Pointers.AllowPausingInSessionPatch->Restore();
+		}
+	};
+
+	static PauseGame _PauseGame{"pausegame", "Pause Game", "Allows you to pause the game in online (local only)."};
+}
+
+namespace YimMenu::Hooks
+{
+	void Features::OpenPauseMenu(uint32_t menuHash, bool pause, uint32_t unk1, bool unk2)
+	{
+		if (YimMenu::Features::_PauseGame.GetState() && menuHash == 0xBA33ADB3)
+			pause = true;
+
+		BaseHook::Get<Features::OpenPauseMenu, DetourHook<decltype(&Features::OpenPauseMenu)>>()->Original()(menuHash, pause, unk1, unk2);
+	}
+}

src/game/features/players/kick/HostKick.cpp

@@ -0,0 +1,18 @@
+#include "game/commands/PlayerCommand.hpp"
+#include "game/backend/NativeHooks.hpp"
+#include "game/gta/Natives.hpp"
+
+namespace YimMenu::Features
+{
+	class HostKick : public PlayerCommand
+	{
+		using PlayerCommand::PlayerCommand;
+		virtual void OnCall(Player player) override
+		{
+			NETWORK::NETWORK_SESSION_KICK_PLAYER(player.GetId());
+		}
+
+	};
+
+	static HostKick _HostKick{"HKick", "Host Kick", "Only available as host and the target is unblockable"};
+}

src/game/features/recovery/Heist/CayoPericoHeist.cpp

@@ -43,8 +43,8 @@ namespace YimMenu::Features
 
 				*base.At(0, 27).At(8).At(0).As<int*>() = 1;
 				*base.At(1, 27).At(8).At(1).As<int*>() = 1;
-                *base.At(2, 27).At(8).At(2).As<int*>() = 1;
-                *base.At(3, 27).At(8).At(3).As<int*>() = 1;
+				*base.At(2, 27).At(8).At(2).As<int*>() = 1;
+				*base.At(3, 27).At(8).At(3).As<int*>() = 1;
 			}
 		};
 
@@ -80,46 +80,46 @@ namespace YimMenu::Features
 			virtual void OnCall() override
 			{
 				Stats::SetInt("MPX_H4CNF_TARGET", _CayoPericoHeistPrimaryTarget.GetState()); // Primary target
-                Stats::SetInt("MPX_H4LOOT_CASH_I", 2359448);
-                Stats::SetInt("MPX_H4LOOT_CASH_I_SCOPED", 2359448);
-                Stats::SetInt("MPX_H4LOOT_CASH_C", 0);
-                Stats::SetInt("MPX_H4LOOT_CASH_C_SCOPED", 0);
-                Stats::SetInt("MPX_H4LOOT_COKE_I", 4901222);
-                Stats::SetInt("MPX_H4LOOT_COKE_I_SCOPED", 4901222);
-                Stats::SetInt("MPX_H4LOOT_COKE_C", 0);
-                Stats::SetInt("MPX_H4LOOT_COKE_C_SCOPED", 0);
-                Stats::SetInt("MPX_H4LOOT_GOLD_I", 0);
-                Stats::SetInt("MPX_H4LOOT_GOLD_I_SCOPED", 0);
-                Stats::SetInt("MPX_H4LOOT_GOLD_C", 255);
-                Stats::SetInt("MPX_H4LOOT_GOLD_C_SCOPED", 255);
-                Stats::SetInt("MPX_H4LOOT_WEED_I", 0);
-                Stats::SetInt("MPX_H4LOOT_WEED_I_SCOPED", 0);
-                Stats::SetInt("MPX_H4LOOT_WEED_C", 0);
-                Stats::SetInt("MPX_H4LOOT_WEED_C_SCOPED", 0);
-                Stats::SetInt("MPX_H4LOOT_PAINT", 127);
-                Stats::SetInt("MPX_H4LOOT_PAINT_SCOPED", 127);
-                Stats::SetInt("MPX_H4LOOT_CASH_V", 599431);
-                Stats::SetInt("MPX_H4LOOT_COKE_V", 1198863);
-                Stats::SetInt("MPX_H4LOOT_GOLD_V", 1598484);
-                Stats::SetInt("MPX_H4LOOT_PAINT_V", 1198863);
-				Stats::SetInt("MPX_H4LOOT_WEED_V", 0);
+				Stats::SetInt("MPX_H4LOOT_CASH_I", 16711680);
+				Stats::SetInt("MPX_H4LOOT_CASH_I_SCOPED", 16711680);
+				Stats::SetInt("MPX_H4LOOT_CASH_C", 0);
+				Stats::SetInt("MPX_H4LOOT_CASH_C_SCOPED", 0);
+				Stats::SetInt("MPX_H4LOOT_COKE_I", 255);
+				Stats::SetInt("MPX_H4LOOT_COKE_I_SCOPED", 255);
+				Stats::SetInt("MPX_H4LOOT_COKE_C", 0);
+				Stats::SetInt("MPX_H4LOOT_COKE_C_SCOPED", 0);
+				Stats::SetInt("MPX_H4LOOT_GOLD_I", 0);
+				Stats::SetInt("MPX_H4LOOT_GOLD_I_SCOPED", 0);
+				Stats::SetInt("MPX_H4LOOT_GOLD_C", 255);
+				Stats::SetInt("MPX_H4LOOT_GOLD_C_SCOPED", 255);
+				Stats::SetInt("MPX_H4LOOT_WEED_I", 65280);
+				Stats::SetInt("MPX_H4LOOT_WEED_I_SCOPED", 65280);
+				Stats::SetInt("MPX_H4LOOT_WEED_C", 0);
+				Stats::SetInt("MPX_H4LOOT_WEED_C_SCOPED", 0);
+				Stats::SetInt("MPX_H4LOOT_PAINT", 127);
+				Stats::SetInt("MPX_H4LOOT_PAINT_SCOPED", 127);
+				Stats::SetInt("MPX_H4LOOT_CASH_V", 83250);
+				Stats::SetInt("MPX_H4LOOT_COKE_V", 202500);
+				Stats::SetInt("MPX_H4LOOT_GOLD_V", 333333);
+				Stats::SetInt("MPX_H4LOOT_WEED_V", 135000);
+				Stats::SetInt("MPX_H4LOOT_PAINT_V", 180000);
 				Stats::SetInt("MPX_H4_PROGRESS", _CayoPericoHeistDifficulty.GetState()); // Difficulty
-                Stats::SetInt("MPX_H4CNF_BS_GEN", 262143);
-                Stats::SetInt("MPX_H4CNF_BS_ENTR", 63);
-                Stats::SetInt("MPX_H4CNF_BS_ABIL", 63);
-                Stats::SetInt("MPX_H4CNF_WEP_DISRP", 3);
-                Stats::SetInt("MPX_H4CNF_ARM_DISRP", 3);
-                Stats::SetInt("MPX_H4CNF_HEL_DISRP", 3);
-                Stats::SetInt("MPX_H4CNF_APPROACH", -1);
-                Stats::SetInt("MPX_H4CNF_BOLTCUT", 4424);
-                Stats::SetInt("MPX_H4CNF_UNIFORM", 5256);
-                Stats::SetInt("MPX_H4CNF_GRAPPEL", 5156);
-                Stats::SetInt("MPX_H4_MISSIONS", -1);
+				Stats::SetInt("MPX_H4CNF_BS_GEN", 262143);
+				Stats::SetInt("MPX_H4CNF_BS_ENTR", 63);
+				Stats::SetInt("MPX_H4CNF_BS_ABIL", 63);
+				Stats::SetInt("MPX_H4CNF_WEP_DISRP", 3);
+				Stats::SetInt("MPX_H4CNF_ARM_DISRP", 3);
+				Stats::SetInt("MPX_H4CNF_HEL_DISRP", 3);
+				Stats::SetInt("MPX_H4CNF_APPROACH", -1);
+				Stats::SetInt("MPX_H4CNF_BOLTCUT", 4424);
+				Stats::SetInt("MPX_H4CNF_UNIFORM", 5256);
+				Stats::SetInt("MPX_H4CNF_GRAPPEL", 5156);
+				Stats::SetInt("MPX_H4_MISSIONS", -1);
 				Stats::SetInt("MPX_H4CNF_WEAPONS", _CayoPericoHeistWeapon.GetState()); // Weapon
-                Stats::SetInt("MPX_H4CNF_TROJAN", 5);
+				Stats::SetInt("MPX_H4CNF_TROJAN", 5);
 				Stats::SetInt("MPX_H4_PLAYTHROUGH_STATUS", 100);
 
-                ScriptMgr::Yield(500ms);
+				ScriptMgr::Yield(500ms);
 
 				*ScriptLocal("heist_island_planning"_J, 1566).As<int*>() = 2;
 			}

src/game/features/recovery/Heist/DiamondCasinoHeist.cpp

@@ -42,8 +42,8 @@ namespace YimMenu::Features
 
 				*base.At(0, 68).At(8).At(0).As<int*>() = 1;
 				*base.At(1, 68).At(8).At(1).As<int*>() = 1;
-                *base.At(2, 68).At(8).At(2).As<int*>() = 1; 
-                *base.At(3, 68).At(8).At(3).As<int*>() = 1;
+				*base.At(2, 68).At(8).At(2).As<int*>() = 1; 
+				*base.At(3, 68).At(8).At(3).As<int*>() = 1;
 			}
 		};
 
@@ -66,9 +66,9 @@ namespace YimMenu::Features
 
 		static std::vector<std::vector<std::vector<std::pair<int, const char*>>>> diamondCasinoHeistWeapon = {
 			{
-		        {{0, "MK II Shotgun Loadout"}, {1, "MK II Rifle Loadout"}},
-		        {{0, "MK II SMG Loadout"}, {1, "MK II Rifle Loadout"}},
-		        {{0, "MK II Shotgun Loadout"}, {1, "MK II Rifle Loadout"}}
+				{{0, "MK II Shotgun Loadout"}, {1, "MK II Rifle Loadout"}},
+				{{0, "MK II SMG Loadout"}, {1, "MK II Rifle Loadout"}},
+				{{0, "MK II Shotgun Loadout"}, {1, "MK II Rifle Loadout"}}
 			},
 			{
 				{{0, "Rifle Loadout"}, {1, "Shotgun Loadout"}},
@@ -81,17 +81,17 @@ namespace YimMenu::Features
 				{{0, "Shotgun Loadout"}, {1, "Combat MG Loadout"}}
 			},
 			{
-		        {{0, "SMG Loadout"}, {1, "Shotgun Loadout"}},
-		        {{0, "Machine Pistol Loadout"}, {1, "Shotgun Loadout"}},
-		        {{0, "SMG Loadout"}, {1, "Shotgun Loadout"}}
+				{{0, "SMG Loadout"}, {1, "Shotgun Loadout"}},
+				{{0, "Machine Pistol Loadout"}, {1, "Shotgun Loadout"}},
+				{{0, "SMG Loadout"}, {1, "Shotgun Loadout"}}
 			},
 			{
-		        {{0, "Micro SMG Loadout"}, {1, "Machine Pistol Loadout"}},
-		        {{0, "Micro SMG Loadout"}, {1, "Shotgun Loadout"}},
+				{{0, "Micro SMG Loadout"}, {1, "Machine Pistol Loadout"}},
+				{{0, "Micro SMG Loadout"}, {1, "Shotgun Loadout"}},
 				{{0, "Shotgun Loadout"}, {1, "Revolver Loadout"}}
 			},
 			{
-		        {{0, "                                        "}, {1, ""}},
+				{{0, "                                        "}, {1, ""}},
 				{{0, ""}, {1, ""}},
 				{{0, ""}, {1, ""}}
 			}
@@ -152,7 +152,7 @@ namespace YimMenu::Features
 			{{0, "Retinue MK II"}, {1, "Drifty Yosemite"}, {2, "Sugoi"}, {3, "Jugular"}},
 			{{0, "Manchez"}, {1, "Stryder"}, {2, "Defiler"}, {3, "Lectro"}},
 			{{0, "Issi Classic"}, {1, "Asbo"}, {2, "Kanjo"}, {3, "Sentinel Classic"}},
-		    {{0, "                           "}, {1, ""}, {2, ""}, {3, ""}}
+			{{0, "                           "}, {1, ""}, {2, ""}, {3, ""}}
 		};
 		static ListCommand _DiamondCasinoHeistVehicle{"diamondcasinoheistvehicle", "Vehicle", "Vehicle", diamondCasinoHeistVehicle[5], 0};
 
@@ -179,11 +179,11 @@ namespace YimMenu::Features
 
 		static std::vector<std::pair<int, const char*>> diamondCasinoHeistHacker = {
 			{4, "Avi Schwartzman"},
-		    {5, "Paige Harris"},
-		    {2, "Christian Feltz"},
-		    {3, "Yohan Blair"},
-		    {1, "Rickie Lukens"},
-		    {6, "Remove Hacker"}
+			{5, "Paige Harris"},
+			{2, "Christian Feltz"},
+			{3, "Yohan Blair"},
+			{1, "Rickie Lukens"},
+			{6, "Remove Hacker"}
 		};
 		static ListCommand _DiamondCasinoHeistHacker{"diamondcasinoheisthacker", "Hacker", "Hacker", diamondCasinoHeistHacker, 6};
 
@@ -242,7 +242,7 @@ namespace YimMenu::Features
 				Stats::SetInt("MPX_H3OPT_BITSET0", rand() % (INT_MAX)); // Refresh board
 				Stats::SetInt("MPX_H3OPT_BITSET1", rand() % (INT_MAX)); // Refresh board
 
-                ScriptMgr::Yield(500ms);
+				ScriptMgr::Yield(500ms);
 
 				Stats::SetInt("MPX_H3OPT_BITSET0", -1); // Refresh board
 				Stats::SetInt("MPX_H3OPT_BITSET1", -1); // Refresh board

src/game/features/recovery/Heist/DoomsdayHeist.cpp

@@ -40,7 +40,7 @@ namespace YimMenu::Features
 
 				*base.At(0, 149).At(43).At(0).At(4).At(8).As<int*>() = 1;
 				*base.At(1, 149).At(43).At(1).At(4).At(8).As<int*>() = 1;
-                *base.At(2, 149).At(43).At(2).At(4).At(8).As<int*>() = 1;
+				*base.At(2, 149).At(43).At(2).At(4).At(8).As<int*>() = 1;
 				*base.At(3, 149).At(43).At(3).At(4).At(8).As<int*>() = 1;
 			}
 		};

src/game/features/self/Aimbot.cpp

@@ -20,5 +20,37 @@ namespace YimMenu::Features
 		}
 	};
 
+	class AimbotAimForHead : BoolCommand
+	{
+		using BoolCommand::BoolCommand;
+
+		virtual void OnEnable() override
+		{
+			Pointers.GetLockOnPosPatch->Apply();
+		}
+
+		virtual void OnDisable() override
+		{
+			Pointers.GetLockOnPosPatch->Restore();
+		}
+	};
+
+	class AimbotTargetDrivers : BoolCommand
+	{
+		using BoolCommand::BoolCommand;
+
+		virtual void OnEnable() override
+		{
+			Pointers.ShouldAllowDriverLockOnPatch->Apply();
+		}
+
+		virtual void OnDisable() override
+		{
+			Pointers.ShouldAllowDriverLockOnPatch->Restore();
+		}
+	};
+
 	static Aimbot _Aimbot{"aimbot", "Aimbot", "Locks on to enemies and other players"};
+	static AimbotAimForHead _AimbotAimForHead{"aimbotaimforhead", "Aim For Head", "Targets the head when locking on to enemies and other players"};
+	static AimbotTargetDrivers _AimbotTargetDrivers{"aimbottargetdrivers", "Target Drivers", "Allows aimbot to lock on to enemies and other players in vehicles"};
 }

src/game/features/self/ExplosiveAmmo.cpp

@@ -0,0 +1,21 @@
+#include "core/commands/LoopedCommand.hpp"
+#include "game/backend/Self.hpp"
+#include "game/gta/Pools.hpp"
+
+#include <game/gta/Natives.hpp>
+
+namespace YimMenu::Features
+{
+	class ExplosiveAmmo : public LoopedCommand
+	{
+		using LoopedCommand::LoopedCommand;
+		virtual void OnTick() override
+		{
+			MISC::SET_EXPLOSIVE_AMMO_THIS_FRAME(Self::GetPlayer().GetId());
+		
+		}
+	};
+
+	static ExplosiveAmmo _ExplosiveAmmo{"ExplosiveAmmo", "Explosive Ammo", "Every bullet you shoot explodes."};
+
+}

src/game/features/self/FormatMoney.cpp

@@ -19,12 +19,12 @@ namespace YimMenu::Features
 		{
 			if (!formatIntCaller1Hook)
 			{
-				formatIntCaller1Hook = CallSiteHook::AddHook(Pointers.FormatIntCaller1, FormatIntHook);
+				formatIntCaller1Hook = CallSiteHook::AddHook(Pointers.FormatIntCaller1, reinterpret_cast<void*>(FormatIntHook));
 			}
 			formatIntCaller1Hook->Enable();
 			if (!formatIntCaller2Hook)
 			{
-				formatIntCaller2Hook = CallSiteHook::AddHook(Pointers.FormatIntCaller2, FormatIntHook);
+				formatIntCaller2Hook = CallSiteHook::AddHook(Pointers.FormatIntCaller2, reinterpret_cast<void*>(FormatIntHook));
 			}
 			formatIntCaller2Hook->Enable();
 			NativeHooks::AddHook("shop_controller"_J, NativeIndex::SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT, &ScaleformAddIntHook);

src/game/features/self/KeepPlayerClean.cpp

@@ -0,0 +1,20 @@
+#include "core/commands/LoopedCommand.hpp"
+#include "game/backend/Self.hpp"
+
+namespace YimMenu::Features
+{
+	class KeepPlayerClean : public LoopedCommand
+	{
+		using LoopedCommand::LoopedCommand;
+
+		virtual void OnTick() override
+		{
+			if (!Self::GetPed())
+				return;
+
+			Self::GetPed().ClearDamage();
+		}
+	};
+
+	static KeepPlayerClean _KeepPlayerClean{"keepplayerclean", "Keep Player Clean", "Keeps the player clean from any blood, dirt, water."};
+}

src/game/features/self/SkipConversation.cpp

@@ -0,0 +1,18 @@
+#include "core/commands/Command.hpp"
+#include "game/backend/Self.hpp"
+#include <game/gta/Natives.hpp>
+
+namespace YimMenu::Features
+{
+	class SkipConversation : Command
+	{
+		using Command::Command;
+
+		virtual void OnCall() override
+		{
+			AUDIO::SKIP_TO_NEXT_SCRIPTED_CONVERSATION_LINE();
+		}
+	};
+
+	static SkipConversation _SkipConversation{"skipconversation", "Skip Conversation", "Skips current conversation in the phone."};
+}

src/game/features/world/CopsDispatch.cpp

@@ -0,0 +1,25 @@
+#include "core/commands/LoopedCommand.hpp"
+#include "game/backend/Self.hpp"
+#include "game/gta/Pools.hpp"
+
+#include <game/gta/Natives.hpp>
+
+namespace YimMenu::Features
+{
+	class CopsDispatch : public LoopedCommand
+	{
+		using LoopedCommand::LoopedCommand;
+		virtual void OnTick() override
+		{
+			PLAYER::SET_DISPATCH_COPS_FOR_PLAYER(Self::GetPlayer().GetId(), FALSE);
+		}
+
+		virtual void OnDisable() override
+		{
+			PLAYER::SET_DISPATCH_COPS_FOR_PLAYER(Self::GetPlayer().GetId(), TRUE);
+		}
+	};
+
+	static CopsDispatch _CopsDispatch{"CopsDispatch", "Cops Dispatch", "When you are wanted, no police will be spawned."};
+
+}

src/game/features/world/Pedsignore.cpp

@@ -0,0 +1,30 @@
+#include "core/commands/LoopedCommand.hpp"
+#include "game/gta/Pools.hpp"
+#include "game/backend/Self.hpp"
+#include <game/gta/Natives.hpp>
+
+namespace YimMenu::Features
+{
+	class PedIgnore : public LoopedCommand
+	{
+		using LoopedCommand::LoopedCommand;
+		virtual void OnTick() override
+		{
+			PLAYER::SET_EVERYONE_IGNORE_PLAYER(Self::GetPlayer().GetId(), TRUE);
+			PLAYER::SET_POLICE_IGNORE_PLAYER(Self::GetPlayer().GetId(), TRUE);
+			PED::SET_BLOCKING_OF_NON_TEMPORARY_EVENTS_FOR_AMBIENT_PEDS_THIS_FRAME(TRUE);
+			PED::SET_PED_RESET_FLAG(Self::GetPed().GetHandle(), 124, true);
+
+		}
+
+		virtual void OnDisable() override
+		{
+			PLAYER::SET_EVERYONE_IGNORE_PLAYER(Self::GetPlayer().GetId(), FALSE);
+			PLAYER::SET_POLICE_IGNORE_PLAYER(Self::GetPlayer().GetId(), FALSE);
+
+		}
+	};
+
+	static PedIgnore _PedIgnore{"pedsignore", "Peds Ignore", "Nearby peds will ignore you and become oblivious to your actions."};
+
+}

src/game/features/world/RiotMode.cpp

@@ -0,0 +1,25 @@
+#include "core/commands/LoopedCommand.hpp"
+#include "game/backend/Self.hpp"
+#include "game/gta/Pools.hpp"
+
+#include <game/gta/Natives.hpp>
+
+namespace YimMenu::Features
+{
+	class PedRiotMode : public LoopedCommand
+	{
+		using LoopedCommand::LoopedCommand;
+		virtual void OnTick() override
+		{
+			MISC::SET_RIOT_MODE_ENABLED(TRUE);
+		}
+
+		virtual void OnDisable() override
+		{
+			MISC::SET_RIOT_MODE_ENABLED(FALSE);
+		}
+	};
+
+	static PedRiotMode _PedRiotMode{"PedRiotMode", "Riot Mode", "All PEDs attack each other."};
+
+}

src/game/frontend/submenus/Network.cpp

@@ -4,7 +4,7 @@
 #include "game/frontend/items/Items.hpp"
 #include "game/frontend/submenus/Network/SavedPlayers.hpp"
 #include "game/gta/Network.hpp"
-#include "game/frontend/submenus/Network/RandomEvents.hpp"
+#include "game/frontend/submenus/network/RandomEvents.hpp"
 
 namespace YimMenu::Submenus
 {
@@ -79,6 +79,7 @@ namespace YimMenu::Submenus
 		enhancements->AddItem(std::make_shared<BoolCommandItem>("despawnbypass"_J)); // move this somewhere else?
 		enhancements->AddItem(std::make_shared<BoolCommandItem>("bypasscasinogeoblock"_J));
 		enhancements->AddItem(std::make_shared<BoolCommandItem>("forcescripthost"_J));
+		enhancements->AddItem(std::make_shared<BoolCommandItem>("pausegame"_J));
 	
 		session->AddItem(joinGroup);
 		session->AddItem(bountyGroup);

src/game/frontend/submenus/OutfitEditor.cpp

@@ -0,0 +1,232 @@
+#include "OutfitEditor.hpp"
+
+#include "core/frontend/manager/UIManager.hpp"
+#include "game/backend/Self.hpp"
+#include "game/frontend/items/Items.hpp"
+#include "game/gta/Natives.hpp"
+#include "imgui.h"
+
+#include <format>
+#include <random>
+
+namespace YimMenu
+{
+	int GetMaxDrawable(int slot)
+	{
+		auto ped = Self::GetPed();
+		return PED::GET_NUMBER_OF_PED_DRAWABLE_VARIATIONS(static_cast<int>(ped.GetHandle()), slot);
+	}
+
+	int GetMaxTexture(int slot, int drawable)
+	{
+		auto ped = Self::GetPed();
+		return PED::GET_NUMBER_OF_PED_TEXTURE_VARIATIONS(static_cast<int>(ped.GetHandle()), slot, drawable);
+	}
+
+	int GetMaxPropDrawable(int slot)
+	{
+		auto ped = Self::GetPed();
+		return PED::GET_NUMBER_OF_PED_PROP_DRAWABLE_VARIATIONS(static_cast<int>(ped.GetHandle()), slot);
+	}
+
+	int GetMaxPropTexture(int slot, int drawable)
+	{
+		auto ped = Self::GetPed();
+		return PED::GET_NUMBER_OF_PED_PROP_TEXTURE_VARIATIONS(static_cast<int>(ped.GetHandle()), slot, drawable);
+	}
+
+	void GetOutfitSlot(int slot, int& drawable, int& texture)
+	{
+		auto ped = Self::GetPed();
+		drawable = PED::GET_PED_DRAWABLE_VARIATION(static_cast<int>(ped.GetHandle()), slot);
+		texture  = PED::GET_PED_TEXTURE_VARIATION(static_cast<int>(ped.GetHandle()), slot);
+	}
+
+	void GetPropSlot(int slot, int& drawable, int& texture)
+	{
+		auto ped = Self::GetPed();
+		drawable = PED::GET_PED_PROP_INDEX(static_cast<int>(ped.GetHandle()), slot, 0);
+		if (drawable == -1)
+		{
+			drawable = 0;
+			texture  = 0;
+			return;
+		}
+		texture = PED::GET_PED_PROP_TEXTURE_INDEX(static_cast<int>(ped.GetHandle()), slot);
+	}
+
+	void SetOutfitSlot(int slot, int drawable, int texture)
+	{
+		auto ped = Self::GetPed();
+		if (!ENTITY::DOES_ENTITY_EXIST(static_cast<int>(ped.GetHandle())))
+			return;
+
+		int maxDrawable = GetMaxDrawable(slot);
+		int maxTexture  = GetMaxTexture(slot, drawable);
+
+		if (drawable < 0 || drawable >= maxDrawable || texture < 0 || texture >= maxTexture)
+			return;
+
+		PED::SET_PED_COMPONENT_VARIATION(static_cast<int>(ped.GetHandle()), slot, drawable, texture, 0);
+	}
+
+	void SetPropSlot(int slot, int drawable, int texture)
+	{
+		auto ped = Self::GetPed();
+		if (!ENTITY::DOES_ENTITY_EXIST(static_cast<int>(ped.GetHandle())))
+			return;
+
+		int maxDrawable = GetMaxPropDrawable(slot);
+		int maxTexture  = GetMaxPropTexture(slot, drawable);
+
+		if (drawable < 0 || drawable >= maxDrawable || texture < 0 || texture >= maxTexture)
+			return;
+
+		PED::SET_PED_PROP_INDEX(static_cast<int>(ped.GetHandle()), slot, drawable, texture, true, 0);
+	}
+
+	// Helper function for underlined text
+	static void TextUnderlined(const char* text)
+	{
+		ImGui::Text("%s", text);
+		ImVec2 min = ImGui::GetItemRectMin();
+		ImVec2 max = ImGui::GetItemRectMax();
+		min.y      = max.y;
+		ImGui::GetWindowDrawList()->AddLine(min, max, ImGui::GetColorU32(ImGui::GetStyle().Colors[ImGuiCol_Text]));
+	}
+
+	std::shared_ptr<Category> CreateOutfitsMenu()
+	{
+		auto category = std::make_shared<Category>("Outfit Editor");
+
+		category->AddItem(std::make_shared<ImGuiItem>([] {
+			auto ped = Self::GetPed();
+			if (!ENTITY::DOES_ENTITY_EXIST(static_cast<int>(ped.GetHandle())))
+			{
+				ImGui::TextDisabled("Error: Player not found");
+				return;
+			}
+
+			if (ImGui::Button("Randomize Outfit"))
+			{
+				std::random_device rd;
+				std::mt19937 gen(rd());
+
+				// Randomize components
+				for (int i = 0; i < 12; ++i)
+				{
+					int maxDrawable = GetMaxDrawable(i);
+					if (maxDrawable > 0)
+					{
+						int drawable   = std::uniform_int_distribution<>(0, maxDrawable - 1)(gen);
+						int maxTexture = GetMaxTexture(i, drawable);
+						int texture    = maxTexture > 0 ? std::uniform_int_distribution<>(0, maxTexture - 1)(gen) : 0;
+						SetOutfitSlot(i, drawable, texture);
+					}
+				}
+
+				// Randomize props
+				for (int i : {0, 1, 2, 6, 7})
+				{
+					int maxDrawable = GetMaxPropDrawable(i);
+					if (maxDrawable > 0)
+					{
+						int drawable   = std::uniform_int_distribution<>(0, maxDrawable - 1)(gen);
+						int maxTexture = GetMaxPropTexture(i, drawable);
+						int texture    = maxTexture > 0 ? std::uniform_int_distribution<>(0, maxTexture - 1)(gen) : 0;
+						SetPropSlot(i, drawable, texture);
+					}
+				}
+			}
+
+			// Create two columns layout
+			const float windowWidth = ImGui::GetContentRegionAvail().x;
+			const float columnWidth = windowWidth * 0.5f;
+			const float inputWidth  = 80.0f; // Minimal width for number input
+
+			ImGui::Columns(2, "OutfitColumns", false);
+			ImGui::SetColumnWidth(0, columnWidth);
+
+			// Components section (Left column)
+			TextUnderlined("Components");
+			ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 1.0f)); // White text color
+
+			const struct
+			{
+				const char* name;
+				int slot;
+			} componentSlots[] = {{"Top", 11}, {"Undershirt", 8}, {"Legs", 4}, {"Feet", 6}, {"Accessories", 7}, {"Bags", 5}, {"Mask", 1}, {"Gloves", 3}, {"Decals", 10}, {"Armor", 9}};
+
+			for (const auto& component : componentSlots)
+			{
+				int drawable, texture;
+				GetOutfitSlot(component.slot, drawable, texture);
+
+				ImGui::Text("%s", component.name);
+				ImGui::SameLine();
+
+				ImGui::SetCursorPosX(columnWidth - inputWidth * 2 - 10);
+
+				ImGui::PushItemWidth(inputWidth);
+				if (ImGui::InputInt(std::format("##{}Drawable", component.name).c_str(), &drawable, 0, 0))
+				{
+					drawable = std::clamp(drawable, 0, GetMaxDrawable(component.slot) - 1);
+					SetOutfitSlot(component.slot, drawable, texture);
+				}
+				ImGui::SameLine();
+
+				ImGui::PushItemWidth(inputWidth);
+				if (ImGui::InputInt(std::format("##{}Texture", component.name).c_str(), &texture, 0, 0))
+				{
+					texture = std::clamp(texture, 0, GetMaxTexture(component.slot, drawable) - 1);
+					SetOutfitSlot(component.slot, drawable, texture);
+				}
+				ImGui::PopItemWidth();
+				ImGui::PopItemWidth();
+			}
+
+			// Props section (Right column)
+			ImGui::NextColumn();
+			TextUnderlined("Props");
+
+			const struct
+			{
+				const char* name;
+				int slot;
+			} propSlots[] = {{"Hats", 0}, {"Glasses", 1}, {"Ears", 2}, {"Watches", 6}};
+
+			for (const auto& prop : propSlots)
+			{
+				int drawable, texture;
+				GetPropSlot(prop.slot, drawable, texture);
+
+				ImGui::Text("%s", prop.name);
+				ImGui::SameLine();
+
+				ImGui::SetCursorPosX(columnWidth + (columnWidth - inputWidth * 2 - 10));
+
+				ImGui::PushItemWidth(inputWidth);
+				if (ImGui::InputInt(std::format("##{}Drawable", prop.name).c_str(), &drawable, 0, 0))
+				{
+					drawable = std::clamp(drawable, 0, GetMaxPropDrawable(prop.slot) - 1);
+					SetPropSlot(prop.slot, drawable, texture);
+				}
+				ImGui::SameLine();
+
+				ImGui::PushItemWidth(inputWidth);
+				if (ImGui::InputInt(std::format("##{}Texture", prop.name).c_str(), &texture, 0, 0))
+				{
+					texture = std::clamp(texture, 0, GetMaxPropTexture(prop.slot, drawable) - 1);
+					SetPropSlot(prop.slot, drawable, texture);
+				}
+				ImGui::PopItemWidth();
+				ImGui::PopItemWidth();
+			}
+
+			ImGui::PopStyleColor();
+			ImGui::Columns(1);
+		}));
+
+		return category;
+	}
+}

src/game/frontend/submenus/OutfitEditor.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include "core/frontend/manager/Category.hpp"
+
+namespace YimMenu
+{   
+    std::shared_ptr<Category> CreateOutfitsMenu();
+}

src/game/frontend/submenus/Player/Kick.cpp

@@ -7,6 +7,7 @@ namespace YimMenu::Submenus
 		auto menu = std::make_shared<Category>("Kick");
 
 		auto kicks = std::make_shared<Group>("Kicks");
+		kicks->AddItem(std::make_shared<PlayerCommandItem>("hkick"_J));
 		kicks->AddItem(std::make_shared<PlayerCommandItem>("shkick"_J));
 		kicks->AddItem(std::make_shared<PlayerCommandItem>("endkick"_J));
 		kicks->AddItem(std::make_shared<PlayerCommandItem>("nfkick"_J));

src/game/frontend/submenus/Recovery/Heist/CayoPericoHeist.cpp

@@ -27,12 +27,12 @@ namespace YimMenu::Submenus
 		loots->AddItem(std::make_shared<ImGuiItem>([] {
 			ImGui::SameLine();
 		}));
-		loots->AddItem(std::make_shared<CommandItem>("cayopericoheistsetprimarytargetvalue"_J));
+		loots->AddItem(std::make_shared<CommandItem>("cayopericoheistsetprimarytargetvalue"_J, "Set##primarytargetvalue"));
 		loots->AddItem(std::make_shared<IntCommandItem>("cayopericoheistsecondarytakevalue"_J));
 		loots->AddItem(std::make_shared<ImGuiItem>([] {
 			ImGui::SameLine();
 		}));
-		loots->AddItem(std::make_shared<CommandItem>("cayopericoheistsetsecondarytakevalue"_J));
+		loots->AddItem(std::make_shared<CommandItem>("cayopericoheistsetsecondarytakevalue"_J, "Set##secondarytakevalue"));
 
 		misc->AddItem(std::make_shared<CommandItem>("cayopericoheistskiphacking"_J));
 		misc->AddItem(std::make_shared<CommandItem>("cayopericoheistcutsewer"_J));

src/game/frontend/submenus/Recovery/Heist/DiamondCasinoHeist.cpp

@@ -39,12 +39,12 @@ namespace YimMenu::Submenus
 		loots->AddItem(std::make_shared<ImGuiItem>([] {
 			ImGui::SameLine();
 		}));
-		loots->AddItem(std::make_shared<CommandItem>("diamondcasinoheistsetpotentialtake"_J));
+		loots->AddItem(std::make_shared<CommandItem>("diamondcasinoheistsetpotentialtake"_J, "Set##potentialtake"));
 		loots->AddItem(std::make_shared<IntCommandItem>("diamondcasinoheistactualtake"_J));
 		loots->AddItem(std::make_shared<ImGuiItem>([] {
 			ImGui::SameLine();
 		}));
-		loots->AddItem(std::make_shared<CommandItem>("diamondcasinoheistsetactualtake"_J));
+		loots->AddItem(std::make_shared<CommandItem>("diamondcasinoheistsetactualtake"_J, "Set##actualtake"));
 
 		misc->AddItem(std::make_shared<CommandItem>("diamondcasinoheistskiphacking"_J));
 		misc->AddItem(std::make_shared<CommandItem>("diamondcasinoheistskipdrilling"_J));

src/game/frontend/submenus/Self.cpp

@@ -2,6 +2,7 @@
 
 #include "core/util/Joaat.hpp"
 #include "game/frontend/items/Items.hpp"
+#include "OutfitEditor.hpp"
 
 namespace YimMenu::Submenus
 {
@@ -11,7 +12,7 @@ namespace YimMenu::Submenus
 		auto main          = std::make_shared<Category>("Main");
 		auto globalsGroup  = std::make_shared<Group>("Globals");
 		auto movementGroup = std::make_shared<Group>("Movement");
-		auto toolsGroup    = std::make_shared<Group>("Tools", 1);
+		auto toolsGroup    = std::make_shared<Group>("Tools", 2);
 		auto wantedGroup   = std::make_shared<Group>("Wanted");
 
 		globalsGroup->AddItem(std::make_shared<BoolCommandItem>("godmode"_J));
@@ -23,8 +24,10 @@ namespace YimMenu::Submenus
 		globalsGroup->AddItem(std::make_shared<BoolCommandItem>("unlimitedoxygen"_J));
 		globalsGroup->AddItem(std::make_shared<BoolCommandItem>("formatmoney"_J));
 		globalsGroup->AddItem(std::make_shared<BoolCommandItem>("mobileradio"_J));
+		globalsGroup->AddItem(std::make_shared<BoolCommandItem>("keepplayerclean"_J));
 
 		toolsGroup->AddItem(std::make_shared<CommandItem>("skipcutscene"_J));
+		toolsGroup->AddItem(std::make_shared<CommandItem>("skipconversation"_J));
 		toolsGroup->AddItem(std::make_shared<CommandItem>("suicide"_J));
 		toolsGroup->AddItem(std::make_shared<CommandItem>("heal"_J));
 		toolsGroup->AddItem(std::make_shared<CommandItem>("cleardamage"_J));
@@ -58,15 +61,21 @@ namespace YimMenu::Submenus
 
 		auto weapons             = std::make_shared<Category>("Weapons");
 		auto weaponsGlobalsGroup = std::make_shared<Group>("Globals");
+		auto weaponsAimbotGroup  = std::make_shared<Group>("Aimbot", 1);
 
 		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("infiniteammo"_J));
 		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("infiniteclip"_J));
 		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("rapidfire"_J));
-		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("aimbot"_J));
 		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("infiniteparachutes"_J));
+		weaponsGlobalsGroup->AddItem(std::make_shared<BoolCommandItem>("ExplosiveAmmo"_J));
 		weaponsGlobalsGroup->AddItem(std::make_shared<CommandItem>("giveallweapons"_J));
 
+		weaponsAimbotGroup->AddItem(std::make_shared<BoolCommandItem>("aimbot"_J));
+		weaponsAimbotGroup->AddItem(std::make_shared<ConditionalItem>("aimbot"_J, std::make_shared<BoolCommandItem>("aimbotaimforhead"_J)));
+		weaponsAimbotGroup->AddItem(std::make_shared<ConditionalItem>("aimbot"_J, std::make_shared<BoolCommandItem>("aimbottargetdrivers"_J)));
+
 		weapons->AddItem(weaponsGlobalsGroup);
+		weapons->AddItem(weaponsAimbotGroup);
 		AddCategory(std::move(weapons));
 
 		auto vehicle = std::make_shared<Category>("Vehicle");
@@ -88,5 +97,8 @@ namespace YimMenu::Submenus
 		vehicle->AddItem(vehicleGlobalsGroup);
 		vehicle->AddItem(vehicleMiscGroup);
 		AddCategory(std::move(vehicle));
+
+		auto outfitEditorCategory = YimMenu::CreateOutfitsMenu();
+		AddCategory(std::move(outfitEditorCategory));
 	}
 }

src/game/frontend/submenus/World.cpp

@@ -27,10 +27,16 @@ namespace YimMenu::Submenus
 		weatherOpts->AddItem(std::make_shared<ConditionalItem>("forceweather"_J, std::make_shared<CommandItem>("setweather"_J), true));
 		weatherOpts->AddItem(std::make_shared<BoolCommandItem>("forceweather"_J));
 
+		auto otherOpts = std::make_shared<Group>("Other", 1);
+		otherOpts->AddItem(std::make_shared<BoolCommandItem>("pedsignore"_J));
+		otherOpts->AddItem(std::make_shared<BoolCommandItem>("PedRiotMode"_J));
+		otherOpts->AddItem(std::make_shared<BoolCommandItem>("CopsDispatch"_J));
+
 		main->AddItem(std::move(killPeds));
 		main->AddItem(std::move(deleteOpts));
 		main->AddItem(std::move(bringOpts));
 		main->AddItem(std::move(weatherOpts));
+		main->AddItem(std::move(otherOpts));
 
 		auto spawnGroup = std::make_shared<Group>("Vehicle");
 		auto modsGroup  = std::make_shared<Group>("Modifications");	
@@ -52,6 +58,9 @@ namespace YimMenu::Submenus
 		iplsGroup->AddItem(std::make_shared<CommandItem>("unloadipl"_J));
 		iplsGroup->AddItem(std::make_shared<CommandItem>("ipltp"_J));
 
+
+
+
 		AddCategory(std::move(main));
 		AddCategory(std::move(spawnersGroup));
 		AddCategory(std::move(iplsGroup));

src/game/gta/Ped.cpp

@@ -159,7 +159,7 @@ namespace YimMenu
 		ENTITY_ASSERT_VALID();
 		ENTITY_ASSERT_CONTROL();
 
-		WEAPON::SET_PED_INFINITE_AMMO(GetHandle(), infinite, NULL);
+		WEAPON::SET_PED_INFINITE_AMMO(GetHandle(), infinite, 0);
 	}
 
 	void Ped::SetInfiniteClip(bool infinite)

src/game/gta/ScriptLocal.hpp

@@ -3,7 +3,7 @@
 #include <type_traits>
 #include <types/script/scrThread.hpp>
 #include <core/util/Joaat.hpp>
-#include <src/game/gta/Scripts.hpp>
+#include <game/gta/Scripts.hpp>
 
 namespace YimMenu
 {

src/game/hooks/Anticheat/QueueDependency.cpp

@@ -54,7 +54,6 @@ namespace YimMenu::Hooks
 
 		if (arx_score >= 2)
 		{
-			auto from_offset = *reinterpret_cast<std::uint64_t*>(_AddressOfReturnAddress()) - ModuleMgr.Get("GTA5_Enhanced.exe"_J)->Base();
 			return;
 		}
 

src/game/hooks/Hooks.hpp

@@ -73,4 +73,9 @@ namespace YimMenu::Hooks
 	{
 		extern LRESULT WndProc(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam);
 	}
+
+	namespace Features
+	{
+		extern void OpenPauseMenu(uint32_t menuHash, bool pause, uint32_t unk1, bool unk2);
+	}
 }

src/game/pointers/Pointers.cpp

@@ -184,7 +184,7 @@ namespace YimMenu
 
 		constexpr auto worldModelSpawnBypassPtrn = Pattern<"4C 8B 2C 01 4D 85 ED 0F 84 ? ? ? ?">("WorldModelSpawnBypass");
 		scanner.Add(worldModelSpawnBypassPtrn, [this](PointerCalculator ptr) {
-			WorldModelSpawnBypass = BytePatches::Add(ptr.Add(4).As<void*>(), std::vector<std::uint8_t>{0xEB, 0x12, 0x90});
+			WorldModelSpawnBypass = BytePatches::Add(ptr.Add(4).As<void*>(), std::to_array<std::uint8_t>({0xEB, 0x12, 0x90}));
 		});
 
 		constexpr auto receiveNetMessagePtrn = Pattern<"48 81 C1 00 03 00 00 4C 89 E2">("ReceiveNetMessage");
@@ -239,7 +239,7 @@ namespace YimMenu
 
 		constexpr auto netArrayCachedDataPatchPtrn = Pattern<"0F 84 64 FE FF FF FF">("NetArrayCachedDataPatch");
 		scanner.Add(netArrayCachedDataPatchPtrn, [this](PointerCalculator ptr) {
-			NetArrayCachedDataPatch = BytePatches::Add(ptr.As<void*>(), std::vector<std::uint8_t>{0xE9, 0x65, 0xFE, 0xFF, 0xFF, 0x90});
+			NetArrayCachedDataPatch = BytePatches::Add(ptr.As<void*>(), std::to_array<std::uint8_t>({0xE9, 0x65, 0xFE, 0xFF, 0xFF, 0x90}));
 		});
 
 		constexpr auto statsMgrPtrn = Pattern<"89 6C 24 28 48 8D 0D ? ? ? ? 48 8D">("CStatsMgr");
@@ -325,13 +325,32 @@ namespace YimMenu
 
 		constexpr auto shouldTargetEntityPatchPtrn = Pattern<"F6 80 A9 14 00 00 01">("ShouldNotTargetEntityPatch");
 		scanner.Add(shouldTargetEntityPatchPtrn, [this](PointerCalculator ptr) {
-			ShouldNotTargetEntityPatch = BytePatches::Add(ptr.Sub(0x53).As<void*>(), std::vector<std::uint8_t>{0xB0, 0x00, 0xC3});
+			ShouldNotTargetEntityPatch = BytePatches::Add(ptr.Sub(0x53).As<void*>(), std::to_array<std::uint8_t>({0xB0, 0x00, 0xC3}));
 		});
 
-		// TODO: this has been inlined a lot in Enhanced
-		constexpr auto getAssistedAimTypePatchPtrn = Pattern<"48 85 C0 74 15 8B 80 ? ? ? ? BE 03">("GetAssistedAimTypePatch");
+		constexpr auto getAssistedAimTypePatchPtrn = Pattern<"FF E0 48 8D 86">("GetAssistedAimTypePatch");
 		scanner.Add(getAssistedAimTypePatchPtrn, [this](PointerCalculator ptr) {
-			GetAssistedAimTypePatch = BytePatches::Add(ptr.Sub(0xE).As<void*>(), std::vector<std::uint8_t>{0xB0, 0x01, 0xC3});
+			GetAssistedAimTypePatch = BytePatches::Add(ptr.Sub(0x15).As<void*>(), std::to_array<std::uint8_t>({0xBD, 0x01, 0x00, 0x00, 0x00}));
+		});
+
+		constexpr auto getLockOnPosPatchPtrn = Pattern<"0F 29 74 24 ? 48 89 D6 48 89 CF 48 8B 05">("GetLockOnPosPatch");
+		scanner.Add(getLockOnPosPatchPtrn, [this](PointerCalculator ptr) {
+			GetLockOnPosPatch = BytePatches::Add(ptr.Add(0x22).As<std::uint8_t*>(), 0xEB);
+		});
+
+		constexpr auto shouldAllowDriverLockOnPatchPtrn = Pattern<"75 ? 45 89 C7 49 89 CE">("ShouldAllowDriverLockOnPatch");
+		scanner.Add(shouldAllowDriverLockOnPatchPtrn, [this](PointerCalculator ptr) {
+			ShouldAllowDriverLockOnPatch = BytePatches::Add(ptr.Sub(0x2C).As<std::uint8_t*>(), std::to_array<std::uint8_t>({0xB0, 0x01, 0xC3}));
+		});
+
+		constexpr auto allowPausingInSessionPatchPtrn = Pattern<"80 88 ? ? ? ? ? EB ? E8">("AllowPausingInSessionPatch");
+		scanner.Add(allowPausingInSessionPatchPtrn, [this](PointerCalculator ptr) {
+			AllowPausingInSessionPatch = BytePatches::Add(ptr.Sub(0x1E).As<std::uint8_t*>(), 0xEB);
+		});
+
+		constexpr auto openPauseMenuPtrn = Pattern<"E9 ? ? ? ? B9 30 09 09 21">("OpenPauseMenu");
+		scanner.Add(openPauseMenuPtrn, [this](PointerCalculator ptr) {
+			OpenPauseMenu = ptr.Add(1).Rip().As<PVOID>();
 		});
 
 		if (!scanner.Scan())
@@ -375,12 +394,12 @@ namespace YimMenu
 
 		constexpr auto readAttributePatchPtrn = Pattern<"75 70 EB 23">("ReadAttributesPatch");
 		scanner.Add(readAttributePatchPtrn, [this](PointerCalculator ptr) {
-			BytePatches::Add(ptr.As<void*>(), std::vector<std::uint8_t>{0x90, 0x90})->Apply();
+			BytePatches::Add(ptr.As<void*>(), std::to_array<std::uint8_t>({0x90, 0x90}))->Apply();
 		});
 
 		constexpr auto readAttributePatch2Ptrn = Pattern<"32 C0 EB ? C7 83">("ReadAttributesPatch2");
 		scanner.Add(readAttributePatch2Ptrn, [this](PointerCalculator ptr) {
-			BytePatches::Add(ptr.As<void*>(), std::vector<std::uint8_t>{0xB0, 0x01})->Apply(); 
+			BytePatches::Add(ptr.As<void*>(), std::to_array<std::uint8_t>({0xB0, 0x01}))->Apply(); 
 		});
 
 		constexpr auto getAvatarsPtrn = Pattern<"89 4E 7C 48 8B CE E8 ? ? ? ? 84 C0">("GetAvatars");

src/game/pointers/Pointers.hpp

@@ -140,6 +140,10 @@ namespace YimMenu
 		PVOID FormatIntCaller2;
 		BytePatch ShouldNotTargetEntityPatch;
 		BytePatch GetAssistedAimTypePatch;
+		BytePatch GetLockOnPosPatch;
+		BytePatch ShouldAllowDriverLockOnPatch;
+		BytePatch AllowPausingInSessionPatch;
+		PVOID OpenPauseMenu;
 	};
 
 	struct Pointers : PointerData

src/types/network/netEvent.hpp

@@ -28,6 +28,7 @@ namespace rage
 		std::uint32_t m_CxnId;                 // 0x0044
 		rage::netEvent* m_This;                // 0x0048
 		uint32_t m_PeerId;                     // 0x0050
+		char pad_0084[4];                      // 0x0054
 	};
 	static_assert(sizeof(rage::netEvent) == 0x58);
 

src/types/network/netGameEvent.hpp

@@ -248,8 +248,10 @@ class CExplosionEvent : public rage::netGameEvent
 public:
 	void Deserialize(rage::datBitBuffer& buffer);
 
+#if !__GNUC__
 	struct
 	{
+#endif
 		ExplosionType m_ExplosionType; // 0x30
 		rage::fvector3 m_Position;     // 0x40
 		uint64_t m_0x50;               // 0x50
@@ -282,7 +284,9 @@ public:
 		bool m_Expected;               // 0xC2 -- for telemetry
 		uint32_t m_ScriptHash;         // 0xC4 -- for telemetry
 		uint32_t m_ProgramCounter;     // 0xC8 -- for telemetry
+#if !__GNUC__
 	};
+#endif
 	uint16_t m_TargetEntity;      // 0xD0
 	uint16_t m_TargetEnt2;        // 0xD2
 	uint16_t m_OwnerNetId;        // 0xD4

src/types/rage/RTTI.hpp

@@ -10,4 +10,4 @@ private:                                 \
 	virtual bool _0x28(void**)      = 0; \
 	virtual void destructor()       = 0; \
                                          \
-public:
+public:

src/types/rage/datBitBuffer.hpp

@@ -42,7 +42,7 @@ namespace rage
 				v11 = 8;
 				if (size > 8)
 				{
-					v12 = 1i64;
+					v12 = 1;
 					do
 					{
 						if (v12 > v9)

src/types/rage/tlsContext.hpp

@@ -8,7 +8,7 @@ namespace rage
 	class tlsContext
 	{
 	public:
-		char m_Pad1[0x7A0];
+		char m_Pad1[0x7A8];
 		rage::scrThread* m_CurrentScriptThread;
 		bool m_ScriptThreadActive;
 
@@ -18,5 +18,5 @@ namespace rage
 			return *reinterpret_cast<tlsContext**>(__readgsqword(0x58) + TlsIndex);
 		}
 	};
-	static_assert(sizeof(tlsContext) == 0x7B0);
+	static_assert(sizeof(tlsContext) == 0x7B8);
 }