Вопрос Не работает чит на Standleo

[SpleIII]

Я написал простой вх с помощью чата лгпт под StandLeo 3.3F3 (0.37.1) (это пк билд)
вот такой код он выдал (чит написан на c++):

#pragma once
#include <Windows.h>
#include <TlHelp32.h>
#include <vector>
#include <string>

class Memory {
private:
    HANDLE hProcess;
    DWORD pid;
    uintptr_t baseAddress;

public:
    Memory(const wchar_t* processName) {
        hProcess = nullptr;
        pid = 0;
        baseAddress = 0;

        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32 entry;
        entry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(snapshot, &entry)) {
            do {
                if (wcscmp(entry.szExeFile, processName) == 0) {
                    pid = entry.th32ProcessID;
                    hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);

                    HANDLE moduleSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
                    MODULEENTRY32 moduleEntry;
                    moduleEntry.dwSize = sizeof(MODULEENTRY32);

                    if (Module32First(moduleSnapshot, &moduleEntry)) {
                        baseAddress = (uintptr_t)moduleEntry.modBaseAddr;
                    }
                    CloseHandle(moduleSnapshot);
                    break;
                }
            } while (Process32Next(snapshot, &entry));
        }
        CloseHandle(snapshot);
    }

    ~Memory() {
        if (hProcess) CloseHandle(hProcess);
    }

    bool IsValid() {
        return hProcess != nullptr && baseAddress != 0;
    }

    template<typename T>
    T Read(uintptr_t address) {
        T buffer;
        ReadProcessMemory(hProcess, (LPCVOID)address, &buffer, sizeof(T), nullptr);
        return buffer;
    }

    template<typename T>
    bool ReadArray(uintptr_t address, T* buffer, size_t count) {
        return ReadProcessMemory(hProcess, (LPCVOID)address, buffer, count * sizeof(T), nullptr) != 0;
    }

    std::string ReadString(uintptr_t address, int maxLength = 64) {
        char buffer[64] = { 0 };
        ReadProcessMemory(hProcess, (LPCVOID)address, buffer, maxLength, nullptr);
        return std::string(buffer);
    }

    std::wstring ReadWString(uintptr_t address, int maxLength = 64) {
        wchar_t buffer[64] = { 0 };
        ReadProcessMemory(hProcess, (LPCVOID)address, buffer, maxLength * 2, nullptr);
        return std::wstring(buffer);
    }

    template<typename T>
    void Write(uintptr_t address, T value) {
        WriteProcessMemory(hProcess, (LPVOID)address, &value, sizeof(T), nullptr);
    }

    uintptr_t GetBaseAddress() { return baseAddress; }

    // Поиск сигнатуры в памяти
    uintptr_t FindPattern(const std::vector<byte>& pattern, const std::string& mask = "") {
        std::string realMask = mask.empty() ? std::string(pattern.size(), 'x') : mask;

        MEMORY_BASIC_INFORMATION mbi;
        uintptr_t addr = baseAddress;

        while (VirtualQueryEx(hProcess, (LPCVOID)addr, &mbi, sizeof(mbi))) {
            if (mbi.State == MEM_COMMIT &&
                (mbi.Protect == PAGE_READONLY || mbi.Protect == PAGE_READWRITE ||
                    mbi.Protect == PAGE_EXECUTE_READ || mbi.Protect == PAGE_EXECUTE_READWRITE)) {

                std::vector<byte> buffer(mbi.RegionSize);
                SIZE_T bytesRead;

                if (ReadProcessMemory(hProcess, mbi.BaseAddress, buffer.data(), mbi.RegionSize, &bytesRead)) {
                    for (size_t i = 0; i <= bytesRead - pattern.size(); i++) {
                        bool found = true;
                        for (size_t j = 0; j < pattern.size(); j++) {
                            if (realMask[j] == 'x' && buffer[i + j] != pattern[j]) {
                                found = false;
                                break;
                            }
                        }
                        if (found) {
                            return (uintptr_t)mbi.BaseAddress + i;
                        }
                    }
                }
            }
            addr += mbi.RegionSize;
        }
        return 0;
    }

    // Поиск строки в памяти (ASCII)
    uintptr_t FindString(const std::string& str) {
        std::vector<byte> pattern(str.begin(), str.end());
        return FindPattern(pattern);
    }

    // Поиск строки в памяти (Unicode)
    uintptr_t FindString(const std::wstring& str) {
        std::vector<byte> pattern;
        for (wchar_t c : str) {
            pattern.push_back(c & 0xFF);
            pattern.push_back((c >> 8) & 0xFF);
        }
        pattern.push_back(0); // Null terminator
        pattern.push_back(0);
        return FindPattern(pattern);
    }
};

#pragma once
#include <cmath>

struct Vector3 {
    float x, y, z;

    Vector3() : x(0), y(0), z(0) {}
    Vector3(float fx, float fy, float fz) : x(fx), y(fy), z(fz) {}

    float Distance(const Vector3& other) const {
        float dx = x - other.x;
        float dy = y - other.y;
        float dz = z - other.z;
        return sqrt(dx * dx + dy * dy + dz * dz);
    }
};

#pragma once
#include <Windows.h>
#include <d2d1.h>
#include <dwrite.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "dwrite.lib")

class Overlay {
private:
    HWND hwnd;
    HWND gameHwnd;
    ID2D1Factory* d2dFactory;
    ID2D1HwndRenderTarget* renderTarget;
    ID2D1SolidColorBrush* whiteBrush;
    ID2D1SolidColorBrush* redBrush;
    ID2D1SolidColorBrush* greenBrush;
    ID2D1SolidColorBrush* blueBrush;
    IDWriteFactory* writeFactory;
    IDWriteTextFormat* textFormat;
    int windowWidth, windowHeight;
    bool isVisible;

    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
        if (msg == WM_DESTROY) {
            PostQuitMessage(0);
            return 0;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }

public:
    Overlay() : hwnd(nullptr), gameHwnd(nullptr), d2dFactory(nullptr),
        renderTarget(nullptr), whiteBrush(nullptr), redBrush(nullptr),
        greenBrush(nullptr), blueBrush(nullptr), writeFactory(nullptr),
        textFormat(nullptr), windowWidth(0), windowHeight(0), isVisible(false) {
    }

    ~Overlay() {
        if (textFormat) textFormat->Release();
        if (writeFactory) writeFactory->Release();
        if (whiteBrush) whiteBrush->Release();
        if (redBrush) redBrush->Release();
        if (greenBrush) greenBrush->Release();
        if (blueBrush) blueBrush->Release();
        if (renderTarget) renderTarget->Release();
        if (d2dFactory) d2dFactory->Release();
        if (hwnd) DestroyWindow(hwnd);
    }

    bool Create(HWND targetGameWindow) {
        gameHwnd = targetGameWindow;
        if (!gameHwnd) return false;

        RECT gameRect;
        GetWindowRect(gameHwnd, &gameRect);
        windowWidth = gameRect.right - gameRect.left;
        windowHeight = gameRect.bottom - gameRect.top;

        WNDCLASSEX wc = {};
        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = WindowProc;
        wc.hInstance = GetModuleHandle(nullptr);
        wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(0, 0, 0));
        wc.lpszClassName = L"ESPOverlay";
        RegisterClassEx(&wc);

        hwnd = CreateWindowEx(
            WS_EX_TOPMOST | WS_EX_TRANSPARENT | WS_EX_LAYERED | WS_EX_TOOLWINDOW,
            L"ESPOverlay", L"ESP", WS_POPUP,
            gameRect.left, gameRect.top, windowWidth, windowHeight,
            nullptr, nullptr, wc.hInstance, nullptr
        );

        if (!hwnd) return false;

        SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), 0, LWA_COLORKEY);

        D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);

        d2dFactory->CreateHwndRenderTarget(
            D2D1::RenderTargetProperties(
                D2D1_RENDER_TARGET_TYPE_DEFAULT,
                D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED)
            ),
            D2D1::HwndRenderTargetProperties(hwnd, D2D1::SizeU(windowWidth, windowHeight)),
            &renderTarget
        );

        renderTarget->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f), &whiteBrush);
        renderTarget->CreateSolidColorBrush(D2D1::ColorF(1.0f, 0.0f, 0.0f), &redBrush);
        renderTarget->CreateSolidColorBrush(D2D1::ColorF(0.0f, 1.0f, 0.0f), &greenBrush);
        renderTarget->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 1.0f), &blueBrush);

        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
            (IUnknown**)&writeFactory);
        writeFactory->CreateTextFormat(L"Arial", nullptr, DWRITE_FONT_WEIGHT_NORMAL,
            DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL,
            14.0f, L"en-us", &textFormat);

        ShowWindow(hwnd, SW_SHOW);
        return true;
    }

    void Update() {
        if (!gameHwnd || !hwnd) return;

        isVisible = IsWindowVisible(gameHwnd) && !IsIconic(gameHwnd);

        if (isVisible) {
            RECT gameRect;
            GetWindowRect(gameHwnd, &gameRect);

            SetWindowPos(hwnd, HWND_TOPMOST,
                gameRect.left, gameRect.top,
                gameRect.right - gameRect.left,
                gameRect.bottom - gameRect.top,
                SWP_SHOWWINDOW);

            ShowWindow(hwnd, SW_SHOW);
        }
        else {
            ShowWindow(hwnd, SW_HIDE);
        }
    }

    void BeginDraw() {
        if (!isVisible || !renderTarget) return;
        renderTarget->BeginDraw();
        renderTarget->Clear(D2D1::ColorF(0, 0, 0, 0));
    }

    void EndDraw() {
        if (!isVisible || !renderTarget) return;
        renderTarget->EndDraw();
    }

    void DrawBox(float x, float y, float w, float h, D2D1::ColorF color, float thickness = 2.0f) {
        if (!isVisible || !renderTarget) return;

        ID2D1SolidColorBrush* brush;
        renderTarget->CreateSolidColorBrush(color, &brush);

        renderTarget->DrawLine(D2D1::Point2F(x, y), D2D1::Point2F(x + w, y), brush, thickness);
        renderTarget->DrawLine(D2D1::Point2F(x + w, y), D2D1::Point2F(x + w, y + h), brush, thickness);
        renderTarget->DrawLine(D2D1::Point2F(x + w, y + h), D2D1::Point2F(x, y + h), brush, thickness);
        renderTarget->DrawLine(D2D1::Point2F(x, y + h), D2D1::Point2F(x, y), brush, thickness);

        brush->Release();
    }

    void DrawLine(float x1, float y1, float x2, float y2, D2D1::ColorF color, float thickness = 1.0f) {
        if (!isVisible || !renderTarget) return;

        ID2D1SolidColorBrush* brush;
        renderTarget->CreateSolidColorBrush(color, &brush);
        renderTarget->DrawLine(D2D1::Point2F(x1, y1), D2D1::Point2F(x2, y2), brush, thickness);
        brush->Release();
    }

    void DrawString(const wchar_t* text, float x, float y, D2D1::ColorF color) {
        if (!isVisible || !renderTarget) return;

        ID2D1SolidColorBrush* brush;
        renderTarget->CreateSolidColorBrush(color, &brush);
        renderTarget->DrawText(text, (UINT32)wcslen(text), textFormat,
            D2D1::RectF(x, y, x + 400, y + 20), brush);
        brush->Release();
    }

    HWND GetWindow() { return hwnd; }
    bool IsVisible() { return isVisible; }
    int GetWidth() { return windowWidth; }
    int GetHeight() { return windowHeight; }
};

#define _CRT_SECURE_NO_WARNINGS
#define _CRT_NON_CONFORMING_SWPRINTFS

#include <Windows.h>
#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <algorithm>
#include "Memory.h"
#include "Vector3.h"
#include "Overlay.h"

Memory* g_Mem = nullptr;
Overlay* g_Overlay = nullptr;

// Структура для тестирования смещений
struct OffsetTest {
    int healthOffset;
    int teamOffset;
    int nameOffset;
    int posOffset;
    const char* description;
};

// Поиск всех игроков в памяти с авто-подбором смещений
std::vector<uintptr_t> FindAllPlayers() {
    std::vector<uintptr_t> players;

    printf("\n=== Scanning for players ===\n");

    // Пробуем разные комбинации смещений (из dump.cs)
    std::vector<OffsetTest> tests = {
        {0x120, 0x124, 0x134, 0x128, "Current guess"},
        {0x12C, 0x130, 0x140, 0x134, "Variant 1"},
        {0x110, 0x114, 0x124, 0x118, "Variant 2"},
        {0x100, 0x104, 0x114, 0x108, "Variant 3"},
        {0x140, 0x144, 0x154, 0x148, "Variant 4"},
        {0x150, 0x154, 0x164, 0x158, "Variant 5"},
        {0x118, 0x11C, 0x12C, 0x120, "Variant 6"},
        {0x128, 0x12C, 0x13C, 0x130, "Variant 7"},
        {0x130, 0x134, 0x144, 0x138, "Variant 8"},
    };

    uintptr_t scanStart = g_Mem->GetBaseAddress();
    uintptr_t scanEnd = scanStart + 0x20000000; // 512 MB

    for (const auto& test : tests) {
        printf("\n[Testing] %s: HP+0x%X, Team+0x%X, Name+0x%X, Pos+0x%X\n",
            test.description, test.healthOffset, test.teamOffset,
            test.nameOffset, test.posOffset);

        int foundForThisTest = 0;

        for (uintptr_t addr = scanStart; addr < scanEnd; addr += 0x1000) {
            // Читаем потенциальный указатель
            uintptr_t candidate = g_Mem->Read<uintptr_t>(addr);
            if (candidate < 0x10000 || candidate > 0x7FFFFFFFFFFF) continue;

            // Проверяем имя
            std::wstring name = g_Mem->ReadWString(candidate + test.nameOffset, 32);
            if (name.length() < 2 || name.length() > 20) continue;

            // Проверяем, что имя состоит из печатных символов
            bool validName = true;
            for (wchar_t c : name) {
                if (c < 32 || c > 126) {
                    validName = false;
                    break;
                }
            }
            if (!validName) continue;

            // Проверяем здоровье
            int health = g_Mem->Read<int>(candidate + test.healthOffset);
            if (health < 1 || health > 200) continue;

            // Проверяем команду
            int team = g_Mem->Read<int>(candidate + test.teamOffset);
            if (team < 0 || team > 1) continue;

            // Проверяем координаты
            float x = g_Mem->Read<float>(candidate + test.posOffset);
            float y = g_Mem->Read<float>(candidate + test.posOffset + 4);
            float z = g_Mem->Read<float>(candidate + test.posOffset + 8);
            if (abs(x) > 10000 || abs(y) > 10000 || abs(z) > 10000) continue;

            // Нашли игрока!
            players.push_back(candidate);
            foundForThisTest++;

            printf("  [%d] Player at 0x%llX\n", foundForThisTest, candidate);
            printf("    Name: %ls\n", name.c_str());
            printf("    HP: %d, Team: %d\n", health, team);
            printf("    Pos: %.1f %.1f %.1f\n", x, y, z);
        }

        if (foundForThisTest > 0) {
            printf("  >>> FOUND %d players with offsets: HP+0x%X, Team+0x%X, Name+0x%X, Pos+0x%X <<<\n",
                foundForThisTest, test.healthOffset, test.teamOffset,
                test.nameOffset, test.posOffset);
        }
    }

    // Убираем дубликаты
    std::sort(players.begin(), players.end());
    players.erase(std::unique(players.begin(), players.end()), players.end());

    printf("\n=== Total unique players found: %zu ===\n\n", players.size());
    return players;
}

// Включаем метки для всех игроков (упрощенная версия)
void EnableMarkersForAllPlayers() {
    printf("\n=== Enabling player markers (direct search) ===\n");

    uintptr_t scanStart = g_Mem->GetBaseAddress();
    uintptr_t scanEnd = scanStart + 0x20000000; // 512 MB

    int totalEnabled = 0;
    int markersFound = 0;

    printf("Scanning for objects containing PlayerController pointers...\n");

    for (uintptr_t addr = scanStart; addr < scanEnd; addr += 0x1000) {
        uintptr_t candidate = g_Mem->Read<uintptr_t>(addr);
        if (candidate < 0x10000 || candidate > 0x7FFFFFFFFFFF) continue;

        // Проверяем, есть ли по этому адресу указатель на PlayerController
        // Пробуем разные смещения (от 0x80 до 0x100)
        for (int offset = 0x80; offset < 0x100; offset += 4) {
            uintptr_t playerPtr = g_Mem->Read<uintptr_t>(candidate + offset);
            if (playerPtr < 0x10000 || playerPtr > 0x7FFFFFFFFFFF) continue;

            // Проверяем, есть ли у этого игрока имя (пробуем разные смещения)
            std::wstring name;
            for (int nameOffset : {0x120, 0x124, 0x128, 0x12C, 0x130, 0x134, 0x138, 0x140}) {
                name = g_Mem->ReadWString(playerPtr + nameOffset, 32);
                if (name.length() >= 2 && name.length() <= 20) break;
            }

            if (name.empty()) continue;

            // Нашли объект, содержащий PlayerController!
            markersFound++;
            printf("\n[%d] Found object at 0x%llX\n", markersFound, candidate);
            printf("  Contains PlayerController at 0x%llX (offset +0x%X)\n", playerPtr, offset);
            printf("  Player name: %ls\n", name.c_str());

            // ВКЛЮЧАЕМ ВСЕ ВОЗМОЖНЫЕ ФЛАГИ В ДИАПАЗОНЕ 0xE0-0x100
            int enabledForThis = 0;
            for (int flagOffset = 0xE0; flagOffset < 0x100; flagOffset++) {
                bool current = g_Mem->Read<bool>(candidate + flagOffset);
                if (!current) {
                    g_Mem->Write<bool>(candidate + flagOffset, true);
                    enabledForThis++;
                }
            }

            // Также пробуем записать true во все байты рядом
            for (int byteOffset = 0xD0; byteOffset < 0x110; byteOffset++) {
                byte current = g_Mem->Read<byte>(candidate + byteOffset);
                if (current == 0) {
                    g_Mem->Write<byte>(candidate + byteOffset, 1);
                }
            }

            totalEnabled += enabledForThis;
            printf("  Enabled %d flags at +0xE0-0x100\n", enabledForThis);
        }
    }

    printf("\n=== Final Results ===\n");
    printf("Potential marker objects found: %d\n", markersFound);
    printf("Total flags enabled: %d\n", totalEnabled);

    if (markersFound == 0) {
        printf("\nNo markers found. Searching for any objects with player names...\n");

        // Альтернативный метод: ищем по имени игрока
        for (uintptr_t addr = scanStart; addr < scanEnd; addr += 0x100) {
            std::wstring name = g_Mem->ReadWString(addr, 32);
            if (name.length() >= 2 && name.length() <= 20) {
                // Нашли имя игрока
                printf("\nFound player name '%ls' at 0x%llX\n", name.c_str(), addr);

                // Ищем указатели на это имя
                for (int i = -0x100; i < 0x100; i += 8) {
                    uintptr_t ptr = g_Mem->Read<uintptr_t>(addr + i);
                    if (ptr == addr) {
                        printf("  Pointer to name at offset +0x%X\n", i);

                        // Возможно, это PlayerController
                        for (int flagOffset = 0xE0; flagOffset < 0x100; flagOffset++) {
                            g_Mem->Write<bool>(ptr - i + flagOffset, true);
                        }
                    }
                }
            }
        }
    }
}

void RunESP() {
    printf("=== StandLeo ESP (Auto Scan Mode) ===\n");
    printf("F9 - Scan for players\n");
    printf("F10 - Enable markers for all players\n");
    printf("F8 - Exit\n\n");

    // Find game window
    printf("[1/4] Looking for game window...\n");
    HWND gameHwnd = nullptr;
    int attempts = 0;

    while (!gameHwnd && attempts < 30) {
        gameHwnd = FindWindow(nullptr, L"STANDLEO");
        if (!gameHwnd) gameHwnd = FindWindow(nullptr, L"Standoff 2");
        if (!gameHwnd) {
            printf(".");
            Sleep(1000);
            attempts++;
        }
    }

    if (!gameHwnd) {
        printf("\n[ERROR] Game window not found!\n");
        system("pause");
        return;
    }
    printf(" [OK] HWND: 0x%p\n", gameHwnd);

    // Connect to process
    printf("[2/4] Connecting to game process...\n");
    g_Mem = new Memory(L"STANDLEO.exe");
    if (!g_Mem->IsValid()) {
        printf("[ERROR] Could not connect to process!\n");
        system("pause");
        return;
    }
    printf(" [OK] Base address: 0x%llX\n", g_Mem->GetBaseAddress());

    // Create overlay
    printf("[3/4] Creating overlay...\n");
    g_Overlay = new Overlay();
    if (!g_Overlay->Create(gameHwnd)) {
        printf("[ERROR] Failed to create overlay!\n");
        system("pause");
        return;
    }
    printf(" [OK] Overlay created\n");

    printf("[4/4] Starting ESP loop...\n");
    printf("\n=== ESP Running ===\n\n");

    SetForegroundWindow(gameHwnd);

    MSG msg = {};
    int frameCount = 0;
    std::vector<uintptr_t> players;
    auto lastScan = std::chrono::steady_clock::now();

    while (true) {
        // Check for exit
        if (GetAsyncKeyState(VK_F8) & 1) {
            printf("F8 pressed, exiting...\n");
            break;
        }

        // Manual scan on F9
        if (GetAsyncKeyState(VK_F9) & 1) {
            printf("\nF9 pressed - manual scan\n");
            players = FindAllPlayers();
        }

        // Enable markers on F10
        if (GetAsyncKeyState(VK_F10) & 1) {
            printf("\nF10 pressed - enabling markers\n");
            EnableMarkersForAllPlayers();
        }

        // Auto scan every 30 seconds
        auto now = std::chrono::steady_clock::now();
        if (std::chrono::duration_cast<std::chrono::seconds>(now - lastScan).count() > 30) {
            players = FindAllPlayers();
            lastScan = now;
        }

        // Update overlay position
        g_Overlay->Update();

        // Process messages
        while (PeekMessage(&msg, g_Overlay->GetWindow(), 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        if (msg.message == WM_QUIT) break;

        // Draw ESP
        g_Overlay->BeginDraw();

        if (g_Overlay->IsVisible()) {
            frameCount++;

            // Draw header
            wchar_t header[256];
            swprintf_s(header, L"ESP Active - Players: %zu | F9=Scan | F10=Markers | F8=Exit", players.size());
            g_Overlay->DrawString(header, 50, 20, D2D1::ColorF(1, 1, 0));

            // Draw players list
            int y = 50;
            for (size_t i = 0; i < players.size() && i < 20; i++) {
                uintptr_t p = players[i];

                // Читаем имя игрока (пробуем разные смещения)
                std::wstring name;
                for (int offset : {0x134, 0x140, 0x12C, 0x124}) {
                    name = g_Mem->ReadWString(p + offset, 32);
                    if (name.length() >= 2 && name.length() <= 20) break;
                }

                // Читаем здоровье
                int health = 0;
                for (int offset : {0x120, 0x12C, 0x110, 0x100}) {
                    health = g_Mem->Read<int>(p + offset);
                    if (health > 0 && health <= 200) break;
                }

                // Читаем команду
                int team = -1;
                for (int offset : {0x124, 0x130, 0x114, 0x104}) {
                    team = g_Mem->Read<int>(p + offset);
                    if (team == 0 || team == 1) break;
                }

                wchar_t info[256];
                if (health > 0 && team >= 0) {
                    swprintf_s(info, L"[%zu] %ls | HP:%d | Team:%s",
                        i, name.c_str(), health, team == 0 ? L"CT" : L"TR");
                }
                else {
                    swprintf_s(info, L"[%zu] Player at 0x%llX", i, p);
                }

                D2D1::ColorF color = (team == 0) ? D2D1::ColorF(0, 1, 0) : D2D1::ColorF(1, 0, 0);
                g_Overlay->DrawString(info, 50, y + i * 20, color);
            }
        }

        g_Overlay->EndDraw();
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }

    delete g_Overlay;
    delete g_Mem;
}

int main() {
    RunESP();
    return 0;
}

так же для работы я использовал дамп стендофа 0.37.0 из этого поста
после всего этого при запуске всё работает но почему то не отображается чит (кроме оверлея) никак (сперва хотел сделать есп, но так же не работало, после как сейчас в коде, я решился сделать вечное отображение меток над игроками)

 

[truesense]

у тебя дамп старый