### Game State Management using C++

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code snippet demonstrates the central coordination of game state, including the game world, players, loot, and extraction points. It initializes the game state by finding the game world, accesses registered players, loot lists, and extraction controllers. The code also includes functions for quick player updates and full player allocation updates, along with an example of reading custom memory addresses.

```cpp
#include "Game/EFT.h"
#include "Game/Classes/CLocalGameWorld/CLocalGameWorld.h"

DMA_Connection* conn = DMA_Connection::GetInstance();

// Initialize game state (finds game world through GOM)
if (!EFT::Initialize(conn)) {
    std::println("Failed to initialize game state");
    return;
}

// Access game world
std::unique_ptr<CLocalGameWorld>& gameWorld = EFT::pGameWorld;

// Get registered players in raid
CRegisteredPlayers& players = EFT::GetRegisteredPlayers();

// Get loot list
CLootList& loot = EFT::GetLootList();

// Get extraction controller
CExfilController& exfils = EFT::GetExfilController();

// Quick update player positions and rotations (25ms cycle)
EFT::QuickUpdatePlayers(conn);

// Full player allocation update (5 second cycle)
EFT::HandlePlayerAllocations(conn);

// Access process for custom reads
const Process& proc = EFT::GetProcess();
uintptr_t customAddress = 0x12345678;
int32_t value = proc.ReadMem<int32_t>(conn, customAddress);

```

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

### 3D ESP Rendering with DirectX 11 and World-to-Screen Projection

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

Implements a 3D ESP overlay using DirectX 11, featuring World-to-Screen projection for rendering players, loot, and exfils. It includes configuration options, main render calls, settings UI rendering, and examples for drawing player skeletons and loot information. Dependencies include GUI/Fuser headers and game-specific data structures.

```cpp
#include "GUI/Fuser/Fuser.h"
#include "GUI/Fuser/Draw/Players.h"
#include "GUI/Fuser/Draw/Loot.h"
#include "GUI/Fuser/Draw/Exfils.h"

// Configuration
Fuser::bMasterToggle = true;             // Enable ESP
Fuser::bSettings = true;                 // Show settings window
Fuser::m_ScreenSize = ImVec2(1920.0f, 1080.0f);

// Main render call (called every frame)
Fuser::Render();

// Render settings UI
Fuser::RenderSettings();

// Get screen center for calculations
ImVec2 center = Fuser::GetCenterScreen();

// Individual component rendering (internal)
// Players.cpp example:
// for (auto& player : EFT::GetRegisteredPlayers()) {
//     Vector3 headPos = player->GetBonePosition(EBoneIndex::HumanHead);
//     ImVec2 screenPos;
//     if (WorldToScreen(headPos, screenPos)) {
//         ImColor color = player->GetFuserColor();
//         drawList->AddCircle(screenPos, 5.0f, color);
//
//         // Draw skeleton
//         for (int i = 0; i < BoneConnections.size(); i++) {
//             Vector3 bone1 = player->GetBonePosition(BoneConnections[i].first);
//             Vector3 bone2 = player->GetBonePosition(BoneConnections[i].second);
//             ImVec2 screen1, screen2;
//             if (WorldToScreen(bone1, screen1) && WorldToScreen(bone2, screen2))
//                 drawList->AddLine(screen1, screen2, color, 1.5f);
//         }
//
//         // Draw weapon name
//         if (player->m_pHands) {
//             std::string text = player->m_pHands->GetItemName();
//             drawList->AddText(screenPos, color, text.c_str());
//         }
//     }
// }
//
// Loot.cpp example:
// for (auto& loot : EFT::GetLootList()) {
//     if (loot->GetPrice() < minPrice) continue;
//     ImVec2 screenPos;
//     if (WorldToScreen(loot->GetPosition(), screenPos)) {
//         std::string name = TarkovItemData::GetShortNameOfItem(loot->GetBSGId());
//         int price = loot->GetPrice();
//         std::string text = std::format("{} ({}k)", name, price / 1000);
//         drawList->AddText(screenPos, ImColor(255, 255, 0), text.c_str());
//     }
// }
```

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

### Main Application Entry Point and Initialization

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

The main entry point of the application handles the initialization sequence, including setting up background processing threads, loading configurations, and initializing the user interface. It features a main loop that checks for an exit key and cleans up resources upon termination.

```cpp
#include "GUI/Main Window/Main Window.h"
#include "GUI/Config/Config.h"
#include "DMA/DMA Thread.h"
#include "Makcu/MyMakcu.h"
#include "Database/Database.h"

std::atomic<bool> bRunning{ true };

int main()
{
    std::println("Hello, EFT_DMA!");

    // Initialize SQLite database (downloads if not present)
    Database::Initialize();

    // Load user configuration from JSON
    Config::LoadConfig("default");

    // Initialize hardware mouse device
    MyMakcu::Initialize();

    // Start background DMA processing thread
    std::thread DMAThread(DMA_Thread_Main);

    // Initialize DirectX 11 window
    MainWindow::Initialize();

    // Main loop - END key to exit
    while (bRunning)
    {
        if (GetAsyncKeyState(VK_END) & 1)
            bRunning = false;

        MainWindow::OnFrame();
    }

    DMAThread.join();
    MainWindow::Cleanup();

    return 0;
}

```

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

### Configuration System Management with JSON

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code implements a flexible configuration management system using JSON files. It allows users to load, save, and modify configuration settings, including keybinds. The system provides functions to serialize and deserialize configuration data to and from JSON format. Configuration files are stored in a specific directory within the user's AppData folder. The UI for configuration is rendered using ImGui.

```cpp
#include "GUI/Config/Config.h"
#include <json.hpp>

// Load configuration by name (default: "default")
bool success = Config::LoadConfig("default");
if (!success) {
    std::println("Failed to load config, using defaults");
}

// Save current configuration
Config::SaveConfig("my_config");

// Render configuration UI (ImGui)
Config::Render();

// Configuration file location: %APPDATA%/EFT_DMA/configs/ 
// File format: JSON
// Example structure:
// {
//   "aimbot": {
//     "enabled": true,
//     "fov": 75.0,
//     "dampen": 0.95,
//     "deadzone": 2.0
//   },
//   "esp": {
//     "enabled": true,
//     "players": true,
//     "loot": true,
//     "containers": false
//   },
//   "colors": {
//     "pmc": [1.0, 0.0, 0.0, 1.0],
//     "scav": [0.0, 1.0, 0.0, 1.0],
//     "boss": [1.0, 1.0, 0.0, 1.0]
//   },
//   "keybinds": {
//     "aimbot_toggle": "VK_XBUTTON1",
//     "esp_toggle": "VK_INSERT"
//   }
// }

// Internal serialization
using json = nlohmann::json;
json j = Config::SerializeConfig();
std::string jsonStr = j.dump(4);

// Internal deserialization
json loaded = json::parse(jsonStr);
Config::DeserializeConfig(loaded);

// Keybind handling
Config::DeserializeKeybinds(loaded["keybinds"]);
json keybindJson = Config::SerializeKeybinds(j);

```

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

### Tarkov Aimbot System Configuration and Rendering in C++

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code snippet outlines the configuration and rendering aspects of a hardware-level aimbot system for Tarkov. It utilizes the Makcu device and includes settings for master toggle, FOV display, FOV radius, aim smoothing, and a deadzone. It shows how to render the settings UI and FOV circle, and details the internal flow for target acquisition and mouse movement. Dependencies include 'GUI/Aimbot/Aimbot.h', 'Makcu/MyMakcu.h', and ImGui.

```cpp
#include "GUI/Aimbot/Aimbot.h"
#include "Makcu/MyMakcu.h"

// Configuration
Aimbot::bMasterToggle = true;       // Enable aimbot
Aimbot::bDrawFOV = true;            // Show FOV circle
Aimbot::fPixelFOV = 75.0f;          // FOV radius in pixels
Aimbot::fDampen = 0.95f;            // Aim smoothing (0.0-1.0)
Aimbot::fDeadzoneFov = 2.0f;        // Center deadzone radius

// Render settings UI
Aimbot::RenderSettings();

// Render FOV circle overlay
ImVec2 windowPos = ImGui::GetWindowPos();
ImDrawList* drawList = ImGui::GetWindowDrawList();
Aimbot::RenderFOVCircle(windowPos, drawList);

// Process aimbot on DMA thread (called every frame)
DMA_Connection* conn = DMA_Connection::GetInstance();
Aimbot::OnDMAFrame(conn);

// Internal flow:
// 1. FindBestTarget() - scans all players, finds closest to crosshair within FOV
// 2. GetAimDeltaToTarget() - calculates pixel delta to target head position
// 3. Applies damping to delta
// 4. Sends mouse movement to Makcu hardware device if outside deadzone
//
// Example internal logic:
// ImVec2 delta = GetAimDeltaToTarget(targetAddress);
// delta.x *= (1.0f - fDampen);
// delta.y *= (1.0f - fDampen);
// if (length(delta) > fDeadzoneFov)
//     MyMakcu::m_Device.move(static_cast<int>(delta.x), static_cast<int>(delta.y));

```

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

### Initialize DMA Connection with MemProcFS

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

Establishes a singleton DMA hardware connection using the MemProcFS library and an FPGA device interface. It includes functions for refreshing the Translation Lookaside Buffer (TLB) cache and obtaining a VMM handle for scatter reads. The connection is automatically cleaned up on program exit.

```cpp
#include "DMA/DMA.h"

// Initialize DMA connection (automatic in singleton)
DMA_Connection* conn = DMA_Connection::GetInstance();

// Refresh TLB cache (called every 5 seconds)
conn->LightRefresh();

// Full cache refresh when needed
conn->FullRefresh();

// Get VMM handle for scatter reads
VMM_HANDLE handle = conn->GetHandle();

// Cleanup (automatic on program exit)
conn->EndConnection();

// Internal initialization (happens automatically on first GetInstance call)
// Constructor parameters: device FPGA, norefresh mode
// LPCSTR args[] = { "", "-device", "FPGA", "-norefresh"};
// m_VMMHandle = VMMDLL_Initialize(4, args);

```

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

### Flea Market Bot Configuration and Automation

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code configures and controls an automated bot for purchasing items on a game's flea market. It includes settings for bot activation, purchase modes, item limits, and delays. The bot intercepts network responses to identify and buy items within a defined price list. It relies on a DMA (Direct Memory Access) thread for response detection and an input thread for simulating mouse clicks to purchase items.

```cpp
#include "GUI/Flea Bot/Flea Bot.h"

// Configuration
FleaBot::bMasterToggle = true;                           // Enable bot
FleaBot::bLimitBuy = false;                              // Limit mode: buy once
FleaBot::bCycleBuy = true;                               // Cycle mode: continuous
FleaBot::m_ItemCount = 10;                               // Items to display
FleaBot::TimeoutDuration = std::chrono::milliseconds(1500);
FleaBot::CycleDelay = std::chrono::milliseconds(200);
FleaBot::SuperCycleDelay = std::chrono::milliseconds(500);

// Price list (BSG ID -> max price in roubles)
// Default items: thermometer, bolts, hose, tape, etc.
std::unordered_map<std::string, uint32_t> prices = {
    {"5d1b32c186f774252167a530", 22000},  // Analog thermometer
    {"57347c5b245977448d35f6e1", 14000},  // Bolts
    {"59e35cbb86f7741778269d83", 35000},  // Corrugated hose
    {"57347c1124597737fb1379e3", 9000},   // Duct Tape
    {"5734795124597738002c6176", 9000},   // Insulating tape
    {"5e2af29386f7746d4159f077", 15000},  // Kektape
    {"61bf7b6302b3924be92fa8c3", 27000},  // Metal spare parts
    {"619cbf476b8a1b37a54eebf8", 33000},  // Military tube
    {"590c31c586f774245e3141b2", 9000},   // Pack of nails
    {"59e35ef086f7741777737012", 6000},   // Pack of screws
};

// Render UI and price list editor
FleaBot::Render();

// Called when new network response detected (25ms cycle)
FleaBot::OnNewResponse();

// Start input thread for automated clicks
FleaBot::pInputThread = std::make_unique<std::thread>(FleaBot::InputThread);

// Internal flow:
// 1. OnNewResponse() called on DMA thread when JSON response detected
// 2. IdentifyResponse() checks if response is flea market offers
// 3. DoesOfferPassPriceListCheck() validates offer price against price list
// 4. If valid, sets bRequestedBuy flag
// 5. InputThread() detects flag, uses Makcu device to click buy button
// 6. BuyFirstItemStack() performs mouse movements and clicks
// 7. ReturnToMainMenuAndWait() resets for next cycle
//
// JSON structure:
// {
//   "offers": [{
//     "itemId": "5d1b32c186f774252167a530",
//     "requirementsCost": 21000,
//     "count": 1
//   }]
// }

```

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

### Tarkov Database Operations with C++ SQLite Wrapper

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code snippet demonstrates how to interact with a SQLite database for Tarkov item, container, and ammunition data. It includes initializing the database, querying item prices and names, container names, ammo names, and executing custom SQL queries. Ensure the SQLite3 library is linked and the 'Database.h' header is available.

```cpp
#include "Database/Database.h"

// Initialize database (downloads from remote if not on disk)
Database::Initialize();

// Get database handle
sqlite3* db = Database::GetTarkovDB();

// Check if database exists locally
bool exists = Database::IsDBOnFile();

// Query item price by BSG ID
std::string thermometerId = "5d1b32c186f774252167a530";
int price = TarkovItemData::GetPriceOfItem(thermometerId);
std::println("Thermometer price: {}", price);  // Output: 22000

// Get item short name
std::string boltId = "57347c5b245977448d35f6e1";
std::string name = TarkovItemData::GetShortNameOfItem(boltId);
std::println("Item name: {}", name);  // Output: "Bolts"

// Query container name
std::string containerId = "578f8778245977358849a9b5";
std::string containerName = TarkovContainerData::GetNameOfContainer(containerId);

// Query ammo name
std::string ammoId = "5e023e53d4353e3302577c4c";
std::string ammoName = TarkovAmmoData::GetNameOfAmmo(ammoId);

// Custom SQL queries
const char* query = "SELECT short_name, trader_price FROM item_data WHERE trader_price > ?;";
sqlite3_stmt* stmt;
tsqlite3_prepare_v2(db, query, -1, &stmt, nullptr);
tsqlite3_bind_int(stmt, 1, 20000);

while (sqlite3_step(stmt) == SQLITE_ROW) {
    const unsigned char* name = sqlite3_column_text(stmt, 0);
    int price = sqlite3_column_int(stmt, 1);
    std::println("{}: {}", reinterpret_cast<const char*>(name), price);
}

sqlite3_finalize(stmt);

```

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

### Player Entity Reading with C++ Scatter Read

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

This C++ code illustrates a multi-stage scatter read pattern for efficiently extracting player data, including skeleton and equipment information. It initializes a player entity, prepares for and executes scatter reads across multiple stages for optimal DMA batching, and then finalizes the read process. The snippet also shows how to access various player attributes like side, spawn type, orientation, and status (AI, PMC, Boss, Local Player), as well as retrieve bone positions, weapon details, and ESP/radar colors.

```cpp
#include "Game/Classes/Players/CBaseEFTPlayer/CBaseEFTPlayer.h"
#include "Game/Enums/EPlayerSide.h"
#include "Game/Enums/ESpawnType.h"

// Create player entity
uintptr_t playerEntityAddress = 0x7FF12345000;
CBaseEFTPlayer player(playerEntityAddress);

// Multi-stage scatter read (10 stages for optimal DMA batching)
VMMDLL_SCATTER_HANDLE vmsh = VMMDLL_Scatter_Initialize(
    conn->GetHandle(),
    proc.GetPID(),
    VMMDLL_FLAG_NOCACHE
);

player.PrepareRead_1(vmsh, EPlayerType::Player);
VMMDLL_Scatter_Execute(vmsh);
player.PrepareRead_2(vmsh);
VMMDLL_Scatter_Execute(vmsh);
// ... stages 3-10
player.PrepareRead_10(vmsh);
VMMDLL_Scatter_Execute(vmsh);
player.Finalize();

VMMDLL_Scatter_CloseHandle(vmsh);

// Access player data
EPlayerSide side = player.m_Side;              // USEC/BEAR/SCAV
ESpawnType spawn = player.m_SpawnType;         // UNKNOWN/REGULAR/BOSS
float yaw = player.m_Yaw;                      // View direction
bool isAi = player.IsAi();
bool isPMC = player.IsPMC();
bool isBoss = player.IsBoss();
bool isLocalPlayer = player.IsLocalPlayer();

// Skeleton data
if (player.m_pSkeleton) {
    Vector3 headPos = player.GetBonePosition(EBoneIndex::HumanHead);
    Vector3 chestPos = player.GetBonePosition(EBoneIndex::HumanSpine2);
}

// Held weapon data
if (player.m_pHands) {
    std::string weaponName = player.m_pHands->GetItemName();
    int32_t ammoCount = player.m_pHands->GetAmmoCount();
}

// Get color for ESP rendering
ImColor fuserColor = player.GetFuserColor();
ImColor radarColor = player.GetRadarColor();

```

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

### DMA Thread Main Loop using C++

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

Implements the main loop for the DMA thread, handling timer-based background processing for various game state components. It initializes DMA connections, attaches to the game process, and sets up periodic callbacks for refreshing game data, updating player information, and managing keybinds. The loop continues as long as the 'bRunning' flag is true.

```cpp
#include "DMA/DMA Thread.h"
#include "DMA/Input Manager.h"
#include "Game/EFT.h"
#include "Game/Response Data/Response Data.h"
#include "Game/Camera List/Camera List.h"
#include "GUI/Keybinds/Keybinds.h"

extern std::atomic<bool> bRunning;

void DMA_Thread_Main()
{
    std::println("[DMA Thread] DMA Thread started.");

    DMA_Connection* Conn = DMA_Connection::GetInstance();

    // Initialize keyboard state reading
    c_keys::InitKeyboard(Conn);

    // Find and attach to game process
    if (!EFT::Initialize(Conn))
    {
        std::println("[DMA Thread] EFT Initialization failed, requesting exit.");
        bRunning = false;
        return;
    }

    // Setup timer callbacks with different frequencies
    CTimer LightRefresh(std::chrono::seconds(5),
        [&Conn]() { Conn->LightRefresh(); });

    CTimer ResponseData(std::chrono::milliseconds(25),
        [&Conn]() { ResponseData::OnDMAFrame(Conn); });

    CTimer Player_Quick(std::chrono::milliseconds(25),
        [&Conn]() { EFT::QuickUpdatePlayers(Conn); });

    CTimer Player_Allocations(std::chrono::seconds(5),
        [&Conn]() { EFT::HandlePlayerAllocations(Conn); });

    CTimer Camera_UpdateViewMatrix(std::chrono::milliseconds(2),
        [&Conn]() { CameraList::QuickUpdateNecessaryCameras(Conn); });

    CTimer Keybinds(std::chrono::milliseconds(50),
        [&Conn]() { Keybinds::OnDMAFrame(Conn); });

    // Main processing loop
    while (bRunning)
    {
        auto TimeNow = std::chrono::high_resolution_clock::now();
        LightRefresh.Tick(TimeNow);
        ResponseData.Tick(TimeNow);
        Player_Quick.Tick(TimeNow);
        Player_Allocations.Tick(TimeNow);
        Camera_UpdateViewMatrix.Tick(TimeNow);
        Keybinds.Tick(TimeNow);
    }

    Conn->EndConnection();
}

```

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

### Escape From Tarkov Memory Offsets with Signatures

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

Provides memory offsets for Escape From Tarkov, including structures for UnityPlayer.dll and GameAssembly.dll. It uses signature patterns to locate pointers for Game Object Manager, Camera list, and ZLib decompression object. Includes offsets for the local game world, such as loot lists and registered players.

```cpp
#include "Game/Offsets/Offsets.h"

// UnityPlayer.dll offsets
namespace Offsets {
    // Game Object Manager pointer
    // Signature: 48 89 05 ? ? ? ? 48 83 C4 ? C3 33 C9
    constexpr std::ptrdiff_t pGOM = 0x1A233A0;

    // Camera list pointer
    // Signature: 4C 8B 05 ? ? ? ? 33 D2 49 8B 48
    constexpr std::ptrdiff_t pCameras = 0x19F3080;

    // GameAssembly.dll offsets
    // ZLib decompression object
    // Signature: 48 8B 0D ? ? ? ? 8B F0 48 8B 91 ? ? ? ? 48 8B 4A
    constexpr std::ptrdiff_t ZLibObject = 0x58102F8;
}

// Game Object Manager structure
namespace Offsets::CGameObjectManager {
    constexpr std::ptrdiff_t pActiveNodes = 0x20;
    constexpr std::ptrdiff_t pLastActiveNode = 0x28;
}

// Local game world offsets (EFT::GameWorld class)
namespace Offsets::CLocalGameWorld {
    constexpr std::ptrdiff_t pExfiltrationController = 0x50;
    constexpr std::ptrdiff_t pMapName = 0xC8;
    constexpr std::ptrdiff_t pLootList = 0x190;
    constexpr std::ptrdiff_t pRegisteredPlayers = 0x1B0;
    constexpr std::ptrdiff_t pMainPlayer = 0x208;
}

// Usage example:
uintptr_t unityBase = proc.GetUnityAddress();
uintptr_t gomAddress = proc.ReadMem<uintptr_t>(conn, unityBase + Offsets::pGOM);
uintptr_t activeNodes = proc.ReadMem<uintptr_t>(
    conn,
    gomAddress + Offsets::CGameObjectManager::pActiveNodes
);

uintptr_t gameWorldAddress = /* found through GOM traversal */;
uintptr_t playerListAddress = proc.ReadMem<uintptr_t>(
    conn,
    gameWorldAddress + Offsets::CLocalGameWorld::pRegisteredPlayers
);

```

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

### Perform Memory Read Operations with Scatter Read Optimization

Source: https://context7.com/bk-end-testing-marsh/fork-remove/llms.txt

Provides template-based memory reading capabilities with scatter read optimization for efficient DMA operations. It allows reading single typed values, vectors of values, following pointer chains, and reading raw memory buffers. It also includes functions to retrieve process information and module base addresses.

```cpp
#include "DMA/Process.h"
#include "DMA/DMA.h"

Process proc;
DMA_Connection* conn = DMA_Connection::GetInstance();

// Get process information for EscapeFromTarkov.exe
if (!proc.GetProcessInfo(conn)) {
    std::println("Failed to attach to game process");
    return false;
}

// Read single typed value
uintptr_t playerAddress = 0x7FF12345000;
float health = proc.ReadMem<float>(conn, playerAddress + 0x100);

// Read vector of values
std::vector<uintptr_t> playerList = proc.ReadVec<uintptr_t>(conn, listAddress, 10);

// Follow pointer chain: base -> offset1 -> offset2 -> final value
std::vector<std::ptrdiff_t> offsets = {0x28, 0x10, 0x18};
uintptr_t finalAddress = proc.ReadChain(conn, baseAddress, offsets);

// Read raw buffer
BYTE buffer[256];
bool success = proc.ReadBuffer(conn, address, buffer, sizeof(buffer));

// Get module addresses
uintptr_t unityBase = proc.GetUnityAddress();      // UnityPlayer.dll
uintptr_t assemblyBase = proc.GetAssemblyBase();   // GameAssembly.dll
DWORD pid = proc.GetPID();

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.