YimMenuV2

https://github.com/yimmenu/yimmenuv2
Admin
YimMenuV2 is an experimental menu for GTA 5: Enhanced that provides enhanced gameplay features and...
Tokens:9,805
Snippets:68
Trust Score:8.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Implement a Toggleable Command in C++

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Extend `BoolCommand` for features with an enabled/disabled state. Override `OnEnable()` and `OnDisable()` for setup and teardown logic. The state is persisted across sessions.

```cpp
#include "core/commands/BoolCommand.hpp"
#include "game/backend/Self.hpp"

namespace YimMenu::Features
{
    class Invisibility : public BoolCommand
    {
        using BoolCommand::BoolCommand;

        virtual void OnEnable() override
        {
            if (auto ped = Self::GetPed())
                ped.SetVisible(false);
        }

        virtual void OnDisable() override
        {
            if (auto ped = Self::GetPed())
                ped.SetVisible(true);
        }
    };

    static Invisibility _Invis{"invis", "Invisibility", "Makes your character invisible"};
}

// Toggle from code:
// auto cmd = Commands::GetCommand<BoolCommand>(JOAAT("invis"));
// cmd->SetState(true);   // enable
// cmd->SetState(false);  // disable
// bool on = cmd->GetState();
```

--------------------------------

### Persistent File and Folder Management with FileMgr

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Initialize FileMgr to manage persistent storage under a specified data folder. Use GetProjectFile and GetProjectFolder to obtain handles for files and directories, which are created automatically if they don't exist.

```cpp
#include "core/filemgr/FileMgr.hpp"
#include <nlohmann/json.hpp>
#include <fstream>

// Initialization (called once at startup)
FileMgr::Init(std::filesystem::path("C:/Users/User/Documents/YimMenuV2"));

// Get a file handle (creates parent directories automatically)
auto configFile = FileMgr::GetProjectFile("settings/commands.json");

// Write JSON config
nlohmann::json j = {{"godmode", true}, {"superrun", false}};
std::ofstream out(configFile.GetPath());
out << j.dump(4);

// Read back
std::ifstream in(configFile.GetPath());
nlohmann::json loaded;
in >> loaded;
bool godmodeEnabled = loaded.value("godmode", false);

// Get a folder handle
auto logsFolder = FileMgr::GetProjectFolder("logs");
// logsFolder.GetPath() → .../YimMenuV2/logs/
```

--------------------------------

### Manage ImGui Overlays with UIManager

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Owns the collection of Submenu pages rendered each frame. Supports multiple visual themes and drives the draw loop.

```cpp
#include "core/frontend/manager/UIManager.hpp"
#include "core/frontend/manager/Submenu.hpp"
#include "core/frontend/manager/Category.hpp"

// Build a submenu with categories at initialization time:
auto selfMenu = std::make_shared<Submenu>("Self", ""); // name, icon

auto generalCat = std::make_shared<Category>("General");
// Add UIItems (command toggles, sliders, buttons) to category...
selfMenu->AddCategory(std::move(generalCat));

UIManager::AddSubmenu(std::move(selfMenu));

// In render loop:
UIManager::Draw(); // renders the active submenu + all notifications

// Navigate programmatically:
auto submenus = UIManager::GetSubmenus();
UIManager::SetActiveSubmenu(submenus[0]);
auto activeCategory = UIManager::GetActiveCategory();
```

--------------------------------

### FileMgr API

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Provides persistent file and folder management, rooting all storage under YimMenuV2's data folder.

```APIDOC
## FileMgr API

### Description
Provides persistent file and folder management, rooting all storage under YimMenuV2's data folder (e.g., `Documents/YimMenuV2/`), offering `File` and `Folder` handles for JSON config, logs, and saved data.

### Methods
- `Init(const std::filesystem::path& rootPath)`: Initializes the file manager with a root path.
- `GetProjectFile(const std::filesystem::path& relativePath)`: Gets a handle to a project file, creating parent directories if necessary.
- `GetProjectFolder(const std::filesystem::path& relativePath)`: Gets a handle to a project folder.

### Example Usage
```cpp
#include "core/filemgr/FileMgr.hpp"
#include <nlohmann/json.hpp>
#include <fstream>

// Initialization (called once at startup)
FileMgr::Init(std::filesystem::path("C:/Users/User/Documents/YimMenuV2"));

// Get a file handle (creates parent directories automatically)
auto configFile = FileMgr::GetProjectFile("settings/commands.json");

// Write JSON config
nlohmann::json j = {{"godmode", true}, {"superrun", false}};
std::ofstream out(configFile.GetPath());
out << j.dump(4);

// Read back
std::ifstream in(configFile.GetPath());
nlohmann::json loaded;
in >> loaded;
bool godmodeEnabled = loaded.value("godmode", false);

// Get a folder handle
auto logsFolder = FileMgr::GetProjectFolder("logs");
// logsFolder.GetPath() → .../YimMenuV2/logs/
```
```

--------------------------------

### UIManager - ImGui Overlay Management

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Manages the collection of Submenu pages rendered each frame, supporting multiple visual themes and driving the draw loop.

```APIDOC
## UIManager — ImGui overlay management

`UIManager` owns the collection of `Submenu` pages rendered each frame. It supports multiple visual themes (Classic, Modern, ModernVertical, Modular) and drives the draw loop from the `Renderer`.

### Usage

```cpp
#include "core/frontend/manager/UIManager.hpp"
#include "core/frontend/manager/Submenu.hpp"
#include "core/frontend/manager/Category.hpp"

// Build a submenu with categories at initialization time:
auto selfMenu = std::make_shared<Submenu>("Self", ""); // name, icon

auto generalCat = std::make_shared<Category>("General");
// Add UIItems (command toggles, sliders, buttons) to category...
selfMenu->AddCategory(std::move(generalCat));

UIManager::AddSubmenu(std::move(selfMenu));

// In render loop:
UIManager::Draw(); // renders the active submenu + all notifications

// Navigate programmatically:
auto submenus = UIManager::GetSubmenus();
UIManager::SetActiveSubmenu(submenus[0]);
auto activeCategory = UIManager::GetActiveCategory();
```
```

--------------------------------

### Commands Registry for Command Management

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Manages command registration, lookup, execution, and persistence. Retrieve commands by hash or type, iterate through all registered commands, or run script commands.

```cpp
#include "core/commands/Commands.hpp"
#include "core/commands/BoolCommand.hpp"

// Retrieve a command by JOAAT hash and call it
if (auto* cmd = Commands::GetCommand(JOAAT("godmode")))
    cmd->Call();

// Retrieve a typed command
if (auto* boolCmd = Commands::GetCommand<BoolCommand>(JOAAT("godmode")))
{
    boolCmd->SetState(true);    // enable godmode
    bool active = boolCmd->GetState();
}

// Iterate all registered commands
for (auto& [hash, cmd] : Commands::GetCommands())
    LOG(INFO) << cmd->GetName() << ": " << cmd->GetLabel();

// ScriptMgr calls this in a game fiber loop:
// Commands::RunScript();  // runs EnableBoolCommands + RunLoopedCommands in a while(g_Running) loop
```

--------------------------------

### Implement a One-Shot Action Command in C++

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Derive from `Command` and override `OnCall()` to implement one-shot actions. Commands are registered by name and can be called by their hash.

```cpp
#include "core/commands/Command.hpp"
#include "game/backend/Self.hpp"

namespace YimMenu::Features
{
    class Heal : public Command
    {
        using Command::Command;

        virtual void OnCall() override
        {
            // Restore player health to maximum
            if (auto ped = Self::GetPed())
            {
                ped.SetHealth(ped.GetMaxHealth());
                ped.SetArmour(100);
            }
        }
    };

    // Registers as "heal" with label "Heal" and given description
    static Heal _Heal{"heal", "Heal", "Restores health and armour to maximum"};
}

// Calling a command by hash from anywhere in the codebase:
// Commands::GetCommand(JOAAT("heal"))->Call();
```

--------------------------------

### Show In-Game Toast Notifications

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Push overlay notifications from any thread. Notifications animate in/out and support an optional action button.

```cpp
#include "core/frontend/Notifications.hpp"

// Basic info notification (5 seconds)
Notifications::Show("Teleport", "Teleported to waypoint", NotificationType::Info);

// Success for 3 seconds
Notifications::Show("Vehicles", "Spawned Adder successfully",
    NotificationType::Success, 3000);

// Warning with an action callback button
auto notif = Notifications::Show(
    "Network", "Suspicious player detected: Player123",
    NotificationType::Warning,
    8000,
    []() {
        // Called when user clicks the action button
        Commands::GetCommand(JOAAT("kickplayer"))->Call();
    },
    "Kick" // button label
);

// Dismiss programmatically
Notifications::Erase(notif);
```

--------------------------------

### Player Network Wrapper

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Access player information such as name, network stats, rank, money, wanted level, and perform teleportation.

```APIDOC
## Player Network Wrapper

Wraps a `CNetGamePlayer` handle to expose player name, network stats, stats (rank/RP/money), wanted level, and teleportation via migration exploit.

### Usage

```cpp
#include "game/gta/Player.hpp"
#include "game/backend/Players.hpp"

// Local player
Player local = Self::GetPlayer();
LOG(INFO) << "Name: "   << local.GetName();
LOG(INFO) << "Rank: "   << local.GetRank();
LOG(INFO) << "Money: $" << local.GetMoney();
LOG(INFO) << "Latency: "<< local.GetAverageLatency() << " ms";

// Iterate all players in session
for (auto& [id, data] : Players::GetPlayers())
{
    Player p(id);
    if (!p || p.IsLocal()) continue;

    LOG(INFO) << p.GetName()
              << " | RID: " << p.GetRID()
              << " | Loss: " << p.GetAveragePacketLoss();

    // Teleport remote player via migration exploit
    p.TeleportTo({100.0f, 100.0f, 25.0f});
}
```
```

--------------------------------

### Compile-time Byte Pattern Scanning

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Define and scan for byte patterns at compile time. Supports wildcard characters and disk caching. Requires including pattern-related headers and initializing the scanner with a module.

```cpp
#include "core/memory/Pattern.hpp"
#include "core/memory/PatternScanner.hpp"
#include "core/memory/ModuleMgr.hpp"

// Declare a compile-time pattern (IDA-style, ?? = wildcard)
static constexpr Pattern<"48 8B 05 ?? ?? ?? ?? 48 8B 48 08 48 85 C9"> g_WorldPattern("CWorld");

// Scan the main game module
const Module* gtaModule = ModuleMgr::Find("GTA5_Enhanced.exe");
PatternScanner scanner(gtaModule);

void* g_WorldPtr = nullptr;

scanner.Add(g_WorldPattern, [](PointerCalculator ptr) {
    // Resolve RIP-relative address 3 bytes into the match, dereference
    g_WorldPtr = ptr.Add(3).Rip().As<void*>();
    LOG(INFO) << "Found CWorld at: " << HEX(g_WorldPtr);
});

if (!scanner.Scan())
    LOG(FATAL) << "Failed to find required patterns!";
```

--------------------------------

### Implement a Per-Frame Looped Command in C++

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Inherit from `LoopedCommand` for features that require continuous execution. Implement `OnTick()` to run logic every game frame while the command is enabled. `OnDisable()` handles cleanup.

```cpp
#include "core/commands/LoopedCommand.hpp"
#include "game/backend/Self.hpp"

namespace YimMenu::Features
{
    class Godmode : public LoopedCommand
    {
        using LoopedCommand::LoopedCommand;

        virtual void OnTick() override
        {
            if (!Self::GetPed())
                return;

            if (Self::GetPed().IsDead())
                Self::GetPed().SetInvincible(false);
            else
                Self::GetPed().SetInvincible(true);
        }

        virtual void OnDisable() override
        {
            if (!Self::GetPed())
                return;
            Self::GetPed().SetInvincible(false);
        }
    };

    static Godmode _Godmode{"godmode", "God Mode", "Blocks all incoming damage"};
}
```

--------------------------------

### DetourHook for Inline Function Hooking

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Wraps MinHook for inline function detours. Automatically resolves JMP chains. Use Enable()/Disable() for queued operations or EnableNow()/DisableNow() for immediate effect.

```cpp
#include "core/hooking/DetourHook.hpp"

// Define the original function signature type
using tWndProc = LRESULT(CALLBACK*)(HWND, UINT, WPARAM, LPARAM);

// Detour handler
static LRESULT CALLBACK HookedWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_KEYDOWN && wParam == VK_INSERT)
    {
        // Toggle menu visibility
        return 0;
    }
    // Forward to original
    return g_WndProcHook->Original()(hwnd, msg, wParam, lParam);
}

// In Hooking::InitImpl():
void* targetAddr = /* resolved address of WndProc */;
auto g_WndProcHook = std::make_unique<DetourHook<tWndProc>>(
    "WndProc",       // debug name
    targetAddr,      // target function address
    HookedWndProc    // our detour
);
g_WndProcHook->Enable();   // queue enable
MH_ApplyQueued();           // apply all queued hooks

// Retrieve original:
// g_WndProcHook->Original()(hwnd, msg, wParam, lParam);
```

--------------------------------

### Notifications::Show

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Push overlay notifications from any thread. Notifications animate in/out over the configured duration and support an optional action button.

```APIDOC
### Notifications::Show — In-game toast notifications

Push overlay notifications from any thread. Notifications animate in/out over the configured duration and support an optional action button.

### Usage

```cpp
#include "core/frontend/Notifications.hpp"

// Basic info notification (5 seconds)
Notifications::Show("Teleport", "Teleported to waypoint", NotificationType::Info);

// Success for 3 seconds
Notifications::Show("Vehicles", "Spawned Adder successfully",
    NotificationType::Success, 3000);

// Warning with an action callback button
auto notif = Notifications::Show(
    "Network", "Suspicious player detected: Player123",
    NotificationType::Warning,
    8000,
    []() {
        // Called when user clicks the action button
        Commands::GetCommand(JOAAT("kickplayer"))->Call();
    },
    "Kick" // button label
);

// Dismiss programmatically
Notifications::Erase(notif);
```
```

--------------------------------

### Entity

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

The base class for all in-game objects. It wraps a GTA script handle and its native memory pointer, providing access to position, health, visibility, networking, and explosion functionalities.

```APIDOC
## Entity

### Description
Wraps a GTA script handle and its native memory pointer, providing safe access to position, health, visibility, networking, and explosion APIs.

### Methods
- **IsPed()**: Checks if the entity is a Ped.
- **IsVehicle()**: Checks if the entity is a Vehicle.
- **GetPosition()**: Returns the entity's position.
- **SetPosition(fvector3 pos)**: Sets the entity's position.
- **GetMaxHealth()**: Returns the entity's maximum health.
- **SetHealth(int health)**: Sets the entity's health.
- **SetInvincible(bool invincible)**: Sets the entity's invincibility status.
- **HasControl()**: Checks if the entity has network control.
- **RequestControl(int timeout)**: Requests network control for the entity.
- **Delete()**: Deletes the entity (local and network).
- **Explode(ExplosionType type, float damageScale, bool isAudible, bool isImportant, float radius)**: Causes the entity to explode.

### Request Example
```cpp
#include "game/gta/Entity.hpp"
#include "game/gta/Ped.hpp"
#include "game/gta/Vehicle.hpp"
#include "game/backend/Self.hpp"

Entity myEntity = /* some entity */;

// Type checks
if (myEntity.IsPed()) { /* ... */ }
if (myEntity.IsVehicle()) { /* ... */ }

// Position
rage::fvector3 pos = myEntity.GetPosition();
myEntity.SetPosition({pos.x + 5.0f, pos.y, pos.z});

// Health
myEntity.SetHealth(myEntity.GetMaxHealth());
myEntity.SetInvincible(true);

// Network control
if (!myEntity.HasControl())
    myEntity.RequestControl(200); // wait up to 200 ticks

// Delete (local and network)
myEntity.Delete();
// Entity::DeleteNetwork(myEntity.GetNetworkObjectId());

// Explosion
myEntity.Explode(ExplosionType::GRENADE, 2.0f, true, true, 1.0f);
```
```

--------------------------------

### GTA Entity Base Class Operations

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Wrap GTA script handles and native pointers for safe access to entity properties and functions. Supports type checking, position manipulation, health management, network control, deletion, and explosions.

```cpp
#include "game/gta/Entity.hpp"
#include "game/gta/Ped.hpp"
#include "game/gta/Vehicle.hpp"
#include "game/backend/Self.hpp"

Entity myEntity = /* some entity */;

// Type checks
if (myEntity.IsPed()) { /* ... */ }
if (myEntity.IsVehicle()) { /* ... */ }

// Position
rage::fvector3 pos = myEntity.GetPosition();
myEntity.SetPosition({pos.x + 5.0f, pos.y, pos.z});

// Health
myEntity.SetHealth(myEntity.GetMaxHealth());
myEntity.SetInvincible(true);

// Network control
if (!myEntity.HasControl())
    myEntity.RequestControl(200); // wait up to 200 ticks

// Delete (local and network)
myEntity.Delete();
// Entity::DeleteNetwork(myEntity.GetNetworkObjectId());

// Explosion
myEntity.Explode(ExplosionType::GRENADE, 2.0f, true, true, 1.0f);
```

--------------------------------

### Access Player Data and Teleport

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Wraps CNetGamePlayer to access player name, stats, and teleportation. Iterates through all players in a session.

```cpp
#include "game/gta/Player.hpp"
#include "game/backend/Players.hpp"

// Local player
Player local = Self::GetPlayer();
LOG(INFO) << "Name: "   << local.GetName();
LOG(INFO) << "Rank: "   << local.GetRank();
LOG(INFO) << "Money: $" << local.GetMoney();
LOG(INFO) << "Latency: "<< local.GetAverageLatency() << " ms";

// Iterate all players in session
for (auto& [id, data] : Players::GetPlayers())
{
    Player p(id);
    if (!p || p.IsLocal()) continue;

    LOG(INFO) << p.GetName()
              << " | RID: " << p.GetRID()
              << " | Loss: " << p.GetAveragePacketLoss();

    // Teleport remote player via migration exploit
    p.TeleportTo({100.0f, 100.0f, 25.0f});
}
```

--------------------------------

### FloatCommand for Move Rate Override

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Defines a FloatCommand to control the player's movement speed multiplier. Override OnChange to react to value updates. Values are clamped to the defined min/max range.

```cpp
#include "core/commands/FloatCommand.hpp"
#include "core/commands/LoopedCommand.hpp"
#include "game/backend/Self.hpp"
#include "game/gta/Natives.hpp"

namespace YimMenu::Features
{
    // Declare slider parameters: name, label, description, min, max, default
    static FloatCommand _MoveRate{"moverateoverride", "Move Rate Override",
        "Multiplier for base run/sprint speed", 0.0f, 10.0f, 2.0f};

    class SuperRun : public LoopedCommand
    {
        using LoopedCommand::LoopedCommand;

        virtual void OnTick() override
        {
            if (auto ped = Self::GetPed())
                PED::SET_PED_MOVE_RATE_OVERRIDE(ped.GetHandle(), _MoveRate.GetState());
        }

        virtual void OnDisable() override
        {
            if (auto player = Self::GetPlayer())
                PLAYER::SET_RUN_SPRINT_MULTIPLIER_FOR_PLAYER(player.GetId(), 1.0f);
        }
    };

    static SuperRun _SuperRun{"superrun", "Super Run", "Run faster than normal"};
}

// Read/write slider value programmatically:
// float val = _MoveRate.GetState();     // current value
// _MoveRate.SetState(3.5f);             // update value (clamped to [min, max])
```

--------------------------------

### Fluent Pointer Arithmetic with PointerCalculator

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Perform safe and expressive pointer arithmetic, including RIP-relative resolution. Chain operations to navigate memory addresses and cast results to desired types. Use the object directly in boolean contexts for validity checks.

```cpp
#include "core/memory/PointerCalculator.hpp"

void* rawAddr = /* result of pattern scan */;
PointerCalculator ptr(rawAddr);

// Chain arithmetic to navigate to a field
auto targetField = ptr
    .Add(3)          // skip 3 bytes (e.g., opcode prefix)
    .Rip()           // resolve RIP-relative: ptr += *(int32*)ptr + 4
    .Add(0x10);      // offset into the struct

// Cast to various types
void*        asVoidPtr   = targetField.As<void*>();
uint8_t*     asBytePtr   = targetField.As<uint8_t*>();
uintptr_t    asInt       = targetField.As<uintptr_t>();
uint32_t&    asRef       = targetField.As<uint32_t&>();  // reference to value in memory

// Validity check
if (targetField)
    LOG(INFO) << "Resolved to: " << HEX(targetField.As<uintptr_t>());
```

--------------------------------

### Manage Fiber-Based Scripts with ScriptMgr

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Manages game-fiber scripts that run cooperatively on GTA's script thread. Yield suspends execution for one frame, essential for calling GTA natives.

```cpp
#include "core/backend/ScriptMgr.hpp"

// Register a new fiber script (done once at init)
ScriptMgr::AddScript(std::make_unique<Script>([]() {
    // This runs on a GTA game fiber — natives are safe to call here
    while (g_Running)
    {
        // Do per-frame work
        Commands::RunLoopedCommands();

        // Yield for one game frame (required to avoid deadlock)
        ScriptMgr::Yield();
    }
}));

// Yield with a delay (sleep for ~500 ms game time)
ScriptMgr::Yield(500ms);

// FiberPool: push a one-shot fiber job (runs next game frame)
FiberPool::Push([]() {
    // Safe to call natives here
    PLAYER::SET_PLAYER_WANTED_LEVEL(Self::GetPlayer().GetId(), 0, false);
    PLAYER::SET_PLAYER_WANTED_LEVEL_NOW(Self::GetPlayer().GetId(), false);
});
```

--------------------------------

### VMTHook for Virtual Method Table Hooking

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Replaces a vtable entry for a specific object instance to intercept virtual function calls. Hooks are activated by swapping the vtable pointer and can be individually enabled/disabled.

```cpp
#include "core/hooking/VMTHook.hpp"

// Suppose we want to hook virtual index 3 of some game object
struct ISomeInterface { virtual ~ISomeInterface() = default; /* ... */ };
ISomeInterface* pTarget = /* pointer to game object */;

// Create VMT hook with 10 vtable entries
VMTHook vmtHook("SomeInterface", pTarget, 10);

// Replace vtable entry at index 3
vmtHook.Hook(3, reinterpret_cast<void*>(&MyHookedFunction));
vmtHook.Enable();   // activates the hook by swapping the vtable pointer

// Retrieve and call original at index 3
auto original = vmtHook.Original<void(*)()>(3);
original();

vmtHook.Disable();  // restores the original vtable
vmtHook.UnHook(3);  // remove hook from specific slot
```

--------------------------------

### Script Variable Access

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Provides direct read/write access to GTA's Rage scripting engine global and local variable tables by index.

```APIDOC
## ScriptGlobal / ScriptLocal — GTA script variable access

Provides direct read/write access to GTA's Rage scripting engine global and local variable tables by index with fluent struct/array navigation.

### Usage

```cpp
#include "game/gta/ScriptGlobal.hpp"
#include "game/gta/ScriptLocal.hpp"

// Read a global variable (e.g., MPPLY_CHAR_0_* stat area at global 1894646)
ScriptGlobal base(1894646);

if (base.CanAccess())
{
    // Navigate struct: base[0] = base, +1 offset into struct, stride of 89 per element
    int& wallet = base.At(0, 89).At(2).As<int&>();
    wallet = 99999; // write directly to script memory

    float& stamina = base.At(0, 89).At(15).As<float&>();
    stamina = 100.0f;
}

// Script locals are per-script-thread: ScriptLocal(thread, index)
// auto& localVar = ScriptLocal(scriptThread, 5).As<int&>();
```
```

--------------------------------

### Access GTA Script Variables

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Provides direct read/write access to GTA's script global and local variables by index. Supports fluent struct/array navigation.

```cpp
#include "game/gta/ScriptGlobal.hpp"
#include "game/gta/ScriptLocal.hpp"

// Read a global variable (e.g., MPPLY_CHAR_0_* stat area at global 1894646)
ScriptGlobal base(1894646);

if (base.CanAccess())
{
    // Navigate struct: base[0] = base, +1 offset into struct, stride of 89 per element
    int& wallet = base.At(0, 89).At(2).As<int&>();
    wallet = 99999; // write directly to script memory

    float& stamina = base.At(0, 89).At(15).As<float&>();
    stamina = 100.0f;
}

// Script locals are per-script-thread: ScriptLocal(thread, index)
// auto& localVar = ScriptLocal(scriptThread, 5).As<int&>();
```

--------------------------------

### Read and Write GTA Online Character Stats

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Use the Stats API to read and write integer, boolean, and float character stats by name. Packed stats can also be manipulated using their index.

```cpp
#include "game/gta/Stats.hpp"

// Read stats
int  rank    = Stats::GetInt("MPPLY_CHAR_0_RANK");
bool hasDlc  = Stats::GetBool("MPPLY_CHAR_0_CHAR_IS_FEMALE");
float stamina = Stats::GetFloat("MPPLY_CHAR_0_STAMINA");

// Write stats
Stats::SetInt("MPPLY_CHAR_0_RANK",    500);
Stats::SetFloat("MPPLY_CHAR_0_STAMINA", 100.0f);

// Packed stats (bit-packed arrays)
Stats::SetPackedBool(72, true);   // unlock specific item flag
int packed = Stats::GetPackedInt(5);
```

--------------------------------

### ScriptMgr / Script - Fiber-based script execution

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Manages game-fiber scripts that run cooperatively on GTA's script thread. ScriptMgr::Yield() suspends execution for one frame (or a duration).

```APIDOC
## ScriptMgr / Script — Fiber-based script execution

`ScriptMgr` manages game-fiber scripts that run cooperatively on GTA's script thread. `ScriptMgr::Yield()` suspends execution for one frame (or a duration), essential for any code that calls GTA natives.

### Usage

```cpp
#include "core/backend/ScriptMgr.hpp"

// Register a new fiber script (done once at init)
ScriptMgr::AddScript(std::make_unique<Script>([]() {
    // This runs on a GTA game fiber — natives are safe to call here
    while (g_Running)
    {
        // Do per-frame work
        Commands::RunLoopedCommands();

        // Yield for one game frame (required to avoid deadlock)
        ScriptMgr::Yield();
    }
}));

// Yield with a delay (sleep for ~500 ms game time)
ScriptMgr::Yield(500ms);

// FiberPool: push a one-shot fiber job (runs next game frame)
FiberPool::Push([]() {
    // Safe to call natives here
    PLAYER::SET_PLAYER_WANTED_LEVEL(Self::GetPlayer().GetId(), 0, false);
    PLAYER::SET_PLAYER_WANTED_LEVEL_NOW(Self::GetPlayer().GetId(), false);
});
```
```

--------------------------------

### Stats API

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Provides a typed API for reading and writing GTA Online character stats by name, automatically prepending the correct character prefix.

```APIDOC
## Stats API

### Description
Provides a typed API for reading and writing GTA Online character stats by name, automatically prepending the correct character prefix.

### Methods
- `GetInt(const char* key)`: Reads an integer stat.
- `GetBool(const char* key)`: Reads a boolean stat.
- `GetFloat(const char* key)`: Reads a float stat.
- `SetInt(const char* key, int value)`: Writes an integer stat.
- `SetFloat(const char* key, float value)`: Writes a float stat.
- `SetPackedBool(int index, bool value)`: Sets a packed boolean stat.
- `GetPackedInt(int index)`: Reads a packed integer stat.

### Example Usage
```cpp
// Read stats
int  rank    = Stats::GetInt("MPPLY_CHAR_0_RANK");
bool hasDlc  = Stats::GetBool("MPPLY_CHAR_0_CHAR_IS_FEMALE");
float stamina = Stats::GetFloat("MPPLY_CHAR_0_STAMINA");

// Write stats
Stats::SetInt("MPPLY_CHAR_0_RANK",    500);
Stats::SetFloat("MPPLY_CHAR_0_STAMINA", 100.0f);

// Packed stats (bit-packed arrays)
Stats::SetPackedBool(72, true);   // unlock specific item flag
int packed = Stats::GetPackedInt(5);
```
```

--------------------------------

### Vehicle

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Extends the Entity class with vehicle-specific operations, including repair, speed, modifications, license plates, rocket boost, and spawning.

```APIDOC
## Vehicle

### Description
Extends `Entity` with vehicle-specific operations: repair, speed, mods, plate, rocket boost, and spawning.

### Methods
- **Fix()**: Repairs the vehicle.
- **Upgrade()**: Applies all performance upgrades to the vehicle.
- **SetPlateText(const std::string& text)**: Sets the vehicle's license plate text.
- **GetPlateText()**: Returns the vehicle's license plate text.
- **SupportsBoost()**: Checks if the vehicle supports rocket boost.
- **SetBoostCharge(int charge)**: Sets the vehicle's rocket boost charge.
- **GetFullName()**: Returns the full name of the vehicle.
- **GetSpeed()**: Returns the current speed of the vehicle.
- **GetMaxSpeed()**: Returns the maximum speed of the vehicle.
- **Create(uint32_t modelHash, fvector3 coords, float heading, bool onGround)**: Spawns a new vehicle.

### Request Example
```cpp
#include "game/gta/Vehicle.hpp"
#include "game/backend/Self.hpp"

Vehicle veh = Self::GetVehicle();
if (!veh) return;

// Repair and upgrade
veh.Fix();
veh.Upgrade(); // apply all performance upgrades

// Plate
veh.SetPlateText("YIMMENU");
std::string plate = veh.GetPlateText();

// Rocket boost
if (veh.SupportsBoost())
    veh.SetBoostCharge(100);

// Info
std::string name = veh.GetFullName();
float speed    = veh.GetSpeed();
float maxSpeed = veh.GetMaxSpeed();

// Spawn a vehicle near the player
Vehicle spawned = Vehicle::Create(
    JOAAT("adder"),
    Self::GetPed().GetPosition(),
    Self::GetPed().GetHeading(),
    true  // set on ground properly
);
```
```

--------------------------------

### Ped

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Extends the Entity class with ped-specific operations, including weapons, vehicles, ragdoll, armor, combat attributes, and teleportation.

```APIDOC
## Ped

### Description
Extends `Entity` with ped-specific operations: weapons, vehicles, ragdoll, armour, combat attributes, and teleportation.

### Methods
- **GiveWeapon(uint32_t weaponHash, bool equip)**: Gives the ped a weapon.
- **SetInfiniteAmmo(bool infinite)**: Sets infinite ammo for the ped.
- **SetInfiniteClip(bool infinite)**: Sets infinite clip for the ped.
- **SetMaxAmmoForWeapon(uint32_t weaponHash)**: Sets the maximum ammo for a specific weapon.
- **TeleportTo(fvector3 coords)**: Teleports the ped to the specified coordinates.
- **SetRagdoll(bool ragdoll)**: Enables or disables ragdoll for the ped.
- **SetArmour(int armour)**: Sets the ped's armor level.
- **Create(uint32_t modelHash, fvector3 coords, float heading)**: Spawns a new ped.
- **StartScenario(const char* scenarioName, int p1, bool p2)**: Starts a scenario for the ped.

### Request Example
```cpp
#include "game/gta/Ped.hpp"
#include "game/backend/Self.hpp"

Ped ped = Self::GetPed();

if (!ped) return; // validity check via operator bool()

// Weapons
ped.GiveWeapon(JOAAT("WEAPON_RPG"), /*equip=*/true);
ped.SetInfiniteAmmo(true);
ped.SetInfiniteClip(true);
ped.SetMaxAmmoForWeapon(JOAAT("WEAPON_RPG"));

// Movement
ped.TeleportTo({-75.0f, -818.0f, 326.0f}); // handles vehicle correctly

// Ragdoll
ped.SetRagdoll(false); // no ragdoll on impact

// Armour
ped.SetArmour(100);

// Spawn a ped
Ped npc = Ped::Create(JOAAT("a_m_y_beach_01"), {0.0f, 0.0f, 72.0f}, 90.0f);
pc.StartScenario("WORLD_HUMAN_SUNBATHE", -1, true);
```
```

--------------------------------

### GTA Ped Character Operations

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Extend `Entity` with ped-specific functionalities including weapon management, movement, ragdoll control, armor settings, and spawning new peds. Includes validity checks via `operator bool()`.

```cpp
#include "game/gta/Ped.hpp"
#include "game/backend/Self.hpp"

Ped ped = Self::GetPed();

if (!ped) return; // validity check via operator bool()

// Weapons
ped.GiveWeapon(JOAAT("WEAPON_RPG"), /*equip=*/true);
ped.SetInfiniteAmmo(true);
ped.SetInfiniteClip(true);
ped.SetMaxAmmoForWeapon(JOAAT("WEAPON_RPG"));

// Movement
ped.TeleportTo({-75.0f, -818.0f, 326.0f}); // handles vehicle correctly

// Ragdoll
ped.SetRagdoll(false); // no ragdoll on impact

// Armour
ped.SetArmour(100);

// Spawn a ped
Ped npc = Ped::Create(JOAAT("a_m_y_beach_01"), {0.0f, 0.0f, 72.0f}, 90.0f);
pc.StartScenario("WORLD_HUMAN_SUNBATHE", -1, true);
```

--------------------------------

### GTA Vehicle Entity Operations

Source: https://context7.com/yimmenu/yimmenuv2/llms.txt

Enhance `Entity` with vehicle-specific features such as repair, upgrades, plate customization, rocket boost management, and spawning. Provides access to vehicle names, speed, and max speed.

```cpp
#include "game/gta/Vehicle.hpp"
#include "game/backend/Self.hpp"

Vehicle veh = Self::GetVehicle();
if (!veh) return;

// Repair and upgrade
veh.Fix();
veh.Upgrade(); // apply all performance upgrades

// Plate
veh.SetPlateText("YIMMENU");
std::string plate = veh.GetPlateText();

// Rocket boost
if (veh.SupportsBoost())
    veh.SetBoostCharge(100);

// Info
std::string name = veh.GetFullName();
float speed    = veh.GetSpeed();
float maxSpeed = veh.GetMaxSpeed();

// Spawn a vehicle near the player
Vehicle spawned = Vehicle::Create(
    JOAAT("adder"),
    Self::GetPed().GetPosition(),
    Self::GetPed().GetHeading(),
    true  // set on ground properly
);
```
Tokens:
Raw