Вопрос Проверьте код

vasargg · 4 Май 2025

Попросил claude 3.7 сделать esp чит на кс 2
Кто шарит посмотрите его и скажите будет ли он работать

C++:

#include <Windows.h>
#include <iostream>
#include <vector>
#include <TlHelp32.h>
#include <d3d9.h>
#include <d3dx9.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

// CS2 актуальные оффсеты (для обучения и офлайн-игры)
namespace Offsets {
    // Базовые оффсеты
    constexpr auto dwEntityList = 0x17C1950;      // EntityList
    constexpr auto dwLocalPlayerController = 0x1883958; // Локальный игрок
    constexpr auto dwViewMatrix = 0x1880950;      // Матрица вида
    constexpr auto dwGameSceneNode = 0x310;       // Game Scene Node
    
    // Оффсеты игрока
    namespace Player {
        constexpr auto m_pGameSceneNode = 0x310;
        constexpr auto m_vecOrigin = 0x80;        // Позиция игрока
        constexpr auto m_iTeamNum = 0x3BF;        // Команда
        constexpr auto m_iHealth = 0x32C;         // Здоровье
        constexpr auto m_bSpottedByMask = 0x1628; // Видимость
        constexpr auto m_bDormant = 0xED;         // Активность
    }
}

// Структуры
struct Vec3 {
    float x, y, z;
};

struct Vec4 {
    float x, y, z, w;
};

struct Matrix4x4 {
    float m[4][4];
};

// Функции получения процесса и памяти
DWORD GetProcessId(const char* processName) {
    DWORD processId = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    
    if (snapshot != INVALID_HANDLE_VALUE) {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);
        
        if (Process32First(snapshot, &processEntry)) {
            do {
                if (!strcmp(processEntry.szExeFile, processName)) {
                    processId = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(snapshot, &processEntry));
        }
        CloseHandle(snapshot);
    }
    return processId;
}

DWORD GetModuleBaseAddress(DWORD processId, const char* moduleName) {
    DWORD moduleBaseAddress = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, processId);
    
    if (snapshot != INVALID_HANDLE_VALUE) {
        MODULEENTRY32 moduleEntry;
        moduleEntry.dwSize = sizeof(MODULEENTRY32);
        
        if (Module32First(snapshot, &moduleEntry)) {
            do {
                if (!strcmp(moduleEntry.szModule, moduleName)) {
                    moduleBaseAddress = (DWORD)moduleEntry.modBaseAddr;
                    break;
                }
            } while (Module32Next(snapshot, &moduleEntry));
        }
        CloseHandle(snapshot);
    }
    return moduleBaseAddress;
}

// Класс чтения/записи в память
class MemoryManager {
private:
    HANDLE processHandle;
    DWORD processId;
    DWORD clientBaseAddress;

public:
    MemoryManager(const char* processName, const char* moduleName) {
        processId = GetProcessId(processName);
        if (processId) {
            processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
            clientBaseAddress = GetModuleBaseAddress(processId, moduleName);
        }
    }

    ~MemoryManager() {
        if (processHandle) {
            CloseHandle(processHandle);
        }
    }

    template<typename T>
    T Read(DWORD address) {
        T value = T();
        ReadProcessMemory(processHandle, (LPCVOID)address, &value, sizeof(T), NULL);
        return value;
    }

    template<typename T>
    void Write(DWORD address, T value) {
        WriteProcessMemory(processHandle, (LPVOID)address, &value, sizeof(T), NULL);
    }

    DWORD GetClientBaseAddress() const {
        return clientBaseAddress;
    }

    HANDLE GetProcessHandle() const {
        return processHandle;
    }
};

// ESP функциональность
class ESP {
private:
    MemoryManager* memoryManager;
    LPDIRECT3D9 d3d;
    LPDIRECT3DDEVICE9 device;
    LPD3DXFONT font;
    D3DXVECTOR2 screenSize;

public:
    ESP(MemoryManager* mm) : memoryManager(mm) {
        // Инициализация DirectX
        d3d = Direct3DCreate9(D3D_SDK_VERSION);
        
        D3DPRESENT_PARAMETERS params;
        ZeroMemory(&params, sizeof(params));
        
        params.Windowed = TRUE;
        params.SwapEffect = D3DSWAPEFFECT_DISCARD;
        params.hDeviceWindow = GetForegroundWindow();
        
        RECT rect;
        GetClientRect(params.hDeviceWindow, &rect);
        screenSize.x = (float)(rect.right - rect.left);
        screenSize.y = (float)(rect.bottom - rect.top);
        
        d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, params.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &params, &device);
        
        // Создание шрифта
        D3DXCreateFont(device, 14, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial", &font);
    }
    
    ~ESP() {
        if (font)
            font->Release();
        if (device)
            device->Release();
        if (d3d)
            d3d->Release();
    }
    
    bool WorldToScreen(const Vec3& pos, Vec2& screen, const Matrix4x4& matrix) {
        Vec4 clipCoords;
        clipCoords.x = pos.x * matrix.m[0][0] + pos.y * matrix.m[0][1] + pos.z * matrix.m[0][2] + matrix.m[0][3];
        clipCoords.y = pos.x * matrix.m[1][0] + pos.y * matrix.m[1][1] + pos.z * matrix.m[1][2] + matrix.m[1][3];
        clipCoords.z = pos.x * matrix.m[2][0] + pos.y * matrix.m[2][1] + pos.z * matrix.m[2][2] + matrix.m[2][3];
        clipCoords.w = pos.x * matrix.m[3][0] + pos.y * matrix.m[3][1] + pos.z * matrix.m[3][2] + matrix.m[3][3];
        
        if (clipCoords.w < 0.1f)
            return false;
        
        Vec3 NDC;
        NDC.x = clipCoords.x / clipCoords.w;
        NDC.y = clipCoords.y / clipCoords.w;
        NDC.z = clipCoords.z / clipCoords.w;
        
        screen.x = (screenSize.x / 2 * NDC.x) + (NDC.x + screenSize.x / 2);
        screen.y = -(screenSize.y / 2 * NDC.y) + (NDC.y + screenSize.y / 2);
        
        return true;
    }
    
    void DrawBox(float x, float y, float width, float height, D3DCOLOR color) {
        D3DRECT rect = { x, y, x + width, y + height };
        device->Clear(1, &rect, D3DCLEAR_TARGET, color, 0, 0);
    }
    
    void DrawText(const char* text, float x, float y, D3DCOLOR color) {
        RECT rect = { x, y, x + 120, y + 20 };
        font->DrawTextA(NULL, text, -1, &rect, DT_LEFT | DT_NOCLIP, color);
    }
    
    void Render() {
        // Получаем адрес списка сущностей
        DWORD entityListPtr = memoryManager->GetClientBaseAddress() + Offsets::dwEntityList;
        
        // Получаем локального игрока
        DWORD localPlayerPtr = memoryManager->Read<DWORD>(memoryManager->GetClientBaseAddress() + Offsets::dwLocalPlayerController);
        int localTeam = memoryManager->Read<int>(localPlayerPtr + Offsets::Player::m_iTeamNum);
        
        // Получаем матрицу просмотра
        Matrix4x4 viewMatrix = memoryManager->Read<Matrix4x4>(memoryManager->GetClientBaseAddress() + Offsets::dwViewMatrix);
        
        // Перебираем всех игроков
        for (int i = 0; i < 64; i++) {
            DWORD entityPtr = memoryManager->Read<DWORD>(entityListPtr + i * 0x8);
            
            if (!entityPtr)
                continue;
                
            int health = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iHealth);
            int team = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iTeamNum);
            bool dormant = memoryManager->Read<bool>(entityPtr + Offsets::Player::m_bDormant);
            
            // Пропускаем мертвых игроков и спящих сущности
            if (health <= 0 || dormant)
                continue;
                
            // Получаем позицию игрока
            DWORD gameSceneNode = memoryManager->Read<DWORD>(entityPtr + Offsets::Player::m_pGameSceneNode);
            Vec3 position = memoryManager->Read<Vec3>(gameSceneNode + Offsets::Player::m_vecOrigin);
            
            // Переводим 3D координаты в 2D для отображения
            Vec2 screenPos;
            if (WorldToScreen(position, screenPos, viewMatrix)) {
                char healthInfo[32];
                sprintf_s(healthInfo, "HP: %d", health);
                
                // Рисуем ESP
                D3DCOLOR espColor = (team == localTeam) ? D3DCOLOR_ARGB(255, 0, 255, 0) : D3DCOLOR_ARGB(255, 255, 0, 0);
                DrawBox(screenPos.x - 20, screenPos.y - 30, 40, 60, espColor);
                DrawText(healthInfo, screenPos.x - 10, screenPos.y - 45, D3DCOLOR_ARGB(255, 255, 255, 255));
            }
        }
    }
    
    void StartESP() {
        device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
        device->BeginScene();
        
        Render();
        
        device->EndScene();
        device->Present(NULL, NULL, NULL, NULL);
    }
};

int main() {
    std::cout << "CS2 ESP Mod для офлайн-режима\n";
    std::cout << "Ожидание запуска CS2...\n";
    
    MemoryManager memoryManager("cs2.exe", "client.dll");
    
    if (memoryManager.GetClientBaseAddress() == 0) {
        std::cout << "Не удалось найти CS2. Убедитесь, что игра запущена.\n";
        system("pause");
        return 1;
    }
    
    std::cout << "CS2 найден! Запуск ESP...\n";
    
    ESP esp(&memoryManager);
    
    while (true) {
        esp.StartESP();
        Sleep(10); // Небольшая задержка для снижения нагрузки на CPU
        
        // Выход по нажатию END
        if (GetAsyncKeyState(VK_END) & 1) {
            break;
        }
    }
    
    std::cout << "ESP остановлен\n";
    system("pause");
    return 0;
}

frnxx · 5 Май 2025

как минимум не правильные оффсеты и еще смущяет рендер через direct9 а не 11 d в целом пойдет

Ozelotick · 5 Май 2025

Скорее всего нет, потому что:
Вроде КС2 64-битная и адрес может в DWORD не влезть, но это не самое главное здесь.
В EntityList с 0 по 64 лежат контроллеры игроков, а не павны, и сам EntityList используется неправильно.
Нужно сначала получить указатель на список:
ListPtr = read(ClientBase + dwEntityList + 16)
Смещение тоже указано неверно:
controllerPtr = read(ListPtr + i * 120)
Потом читаем хендл на павна из контроллера:
pawnHandle = read(controllerPtr + m_hPlayerPawn)
Преобразуем его в индекс
listIndex = (pawnHandle & 0x1FF)
И читаем павн по этому индексу из EntityList так же, как до этого контроллер, получаем уже entityPtr и дальше с ним работаем,
Возможно есть метод проще (кроме самого очевидного), если знаете напишите мне тоже

Ещё m_bDormant находится в GameSceneNode, а не у игрока, и как я понял, там игроки никогда состояние dormant не принимают, как раньше.
m_iTeamNum типа uint8_t, а m_iHealth - int32_t

И я не вижу создание окна, он получается и рендерить не будет никуда?

shineus · 5 Май 2025

Ozelotick написал(а):
И я не вижу создание окна, он получается и рендерить не будет никуда?

транслирует в мозг прямиком

r3z · 5 Май 2025

vasargg написал(а):

Попросил claude 3.7 сделать esp чит на кс 2
Кто шарит посмотрите его и скажите будет ли он работать

C++:

#include <Windows.h>
#include <iostream>
#include <vector>
#include <TlHelp32.h>
#include <d3d9.h>
#include <d3dx9.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

// CS2 актуальные оффсеты (для обучения и офлайн-игры)
namespace Offsets {
    // Базовые оффсеты
    constexpr auto dwEntityList = 0x17C1950;      // EntityList
    constexpr auto dwLocalPlayerController = 0x1883958; // Локальный игрок
    constexpr auto dwViewMatrix = 0x1880950;      // Матрица вида
    constexpr auto dwGameSceneNode = 0x310;       // Game Scene Node
    
    // Оффсеты игрока
    namespace Player {
        constexpr auto m_pGameSceneNode = 0x310;
        constexpr auto m_vecOrigin = 0x80;        // Позиция игрока
        constexpr auto m_iTeamNum = 0x3BF;        // Команда
        constexpr auto m_iHealth = 0x32C;         // Здоровье
        constexpr auto m_bSpottedByMask = 0x1628; // Видимость
        constexpr auto m_bDormant = 0xED;         // Активность
    }
}

// Структуры
struct Vec3 {
    float x, y, z;
};

struct Vec4 {
    float x, y, z, w;
};

struct Matrix4x4 {
    float m[4][4];
};

// Функции получения процесса и памяти
DWORD GetProcessId(const char* processName) {
    DWORD processId = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    
    if (snapshot != INVALID_HANDLE_VALUE) {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);
        
        if (Process32First(snapshot, &processEntry)) {
            do {
                if (!strcmp(processEntry.szExeFile, processName)) {
                    processId = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(snapshot, &processEntry));
        }
        CloseHandle(snapshot);
    }
    return processId;
}

DWORD GetModuleBaseAddress(DWORD processId, const char* moduleName) {
    DWORD moduleBaseAddress = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, processId);
    
    if (snapshot != INVALID_HANDLE_VALUE) {
        MODULEENTRY32 moduleEntry;
        moduleEntry.dwSize = sizeof(MODULEENTRY32);
        
        if (Module32First(snapshot, &moduleEntry)) {
            do {
                if (!strcmp(moduleEntry.szModule, moduleName)) {
                    moduleBaseAddress = (DWORD)moduleEntry.modBaseAddr;
                    break;
                }
            } while (Module32Next(snapshot, &moduleEntry));
        }
        CloseHandle(snapshot);
    }
    return moduleBaseAddress;
}

// Класс чтения/записи в память
class MemoryManager {
private:
    HANDLE processHandle;
    DWORD processId;
    DWORD clientBaseAddress;

public:
    MemoryManager(const char* processName, const char* moduleName) {
        processId = GetProcessId(processName);
        if (processId) {
            processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
            clientBaseAddress = GetModuleBaseAddress(processId, moduleName);
        }
    }

    ~MemoryManager() {
        if (processHandle) {
            CloseHandle(processHandle);
        }
    }

    template<typename T>
    T Read(DWORD address) {
        T value = T();
        ReadProcessMemory(processHandle, (LPCVOID)address, &value, sizeof(T), NULL);
        return value;
    }

    template<typename T>
    void Write(DWORD address, T value) {
        WriteProcessMemory(processHandle, (LPVOID)address, &value, sizeof(T), NULL);
    }

    DWORD GetClientBaseAddress() const {
        return clientBaseAddress;
    }

    HANDLE GetProcessHandle() const {
        return processHandle;
    }
};

// ESP функциональность
class ESP {
private:
    MemoryManager* memoryManager;
    LPDIRECT3D9 d3d;
    LPDIRECT3DDEVICE9 device;
    LPD3DXFONT font;
    D3DXVECTOR2 screenSize;

public:
    ESP(MemoryManager* mm) : memoryManager(mm) {
        // Инициализация DirectX
        d3d = Direct3DCreate9(D3D_SDK_VERSION);
        
        D3DPRESENT_PARAMETERS params;
        ZeroMemory(&params, sizeof(params));
        
        params.Windowed = TRUE;
        params.SwapEffect = D3DSWAPEFFECT_DISCARD;
        params.hDeviceWindow = GetForegroundWindow();
        
        RECT rect;
        GetClientRect(params.hDeviceWindow, &rect);
        screenSize.x = (float)(rect.right - rect.left);
        screenSize.y = (float)(rect.bottom - rect.top);
        
        d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, params.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &params, &device);
        
        // Создание шрифта
        D3DXCreateFont(device, 14, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial", &font);
    }
    
    ~ESP() {
        if (font)
            font->Release();
        if (device)
            device->Release();
        if (d3d)
            d3d->Release();
    }
    
    bool WorldToScreen(const Vec3& pos, Vec2& screen, const Matrix4x4& matrix) {
        Vec4 clipCoords;
        clipCoords.x = pos.x * matrix.m[0][0] + pos.y * matrix.m[0][1] + pos.z * matrix.m[0][2] + matrix.m[0][3];
        clipCoords.y = pos.x * matrix.m[1][0] + pos.y * matrix.m[1][1] + pos.z * matrix.m[1][2] + matrix.m[1][3];
        clipCoords.z = pos.x * matrix.m[2][0] + pos.y * matrix.m[2][1] + pos.z * matrix.m[2][2] + matrix.m[2][3];
        clipCoords.w = pos.x * matrix.m[3][0] + pos.y * matrix.m[3][1] + pos.z * matrix.m[3][2] + matrix.m[3][3];
        
        if (clipCoords.w < 0.1f)
            return false;
        
        Vec3 NDC;
        NDC.x = clipCoords.x / clipCoords.w;
        NDC.y = clipCoords.y / clipCoords.w;
        NDC.z = clipCoords.z / clipCoords.w;
        
        screen.x = (screenSize.x / 2 * NDC.x) + (NDC.x + screenSize.x / 2);
        screen.y = -(screenSize.y / 2 * NDC.y) + (NDC.y + screenSize.y / 2);
        
        return true;
    }
    
    void DrawBox(float x, float y, float width, float height, D3DCOLOR color) {
        D3DRECT rect = { x, y, x + width, y + height };
        device->Clear(1, &rect, D3DCLEAR_TARGET, color, 0, 0);
    }
    
    void DrawText(const char* text, float x, float y, D3DCOLOR color) {
        RECT rect = { x, y, x + 120, y + 20 };
        font->DrawTextA(NULL, text, -1, &rect, DT_LEFT | DT_NOCLIP, color);
    }
    
    void Render() {
        // Получаем адрес списка сущностей
        DWORD entityListPtr = memoryManager->GetClientBaseAddress() + Offsets::dwEntityList;
        
        // Получаем локального игрока
        DWORD localPlayerPtr = memoryManager->Read<DWORD>(memoryManager->GetClientBaseAddress() + Offsets::dwLocalPlayerController);
        int localTeam = memoryManager->Read<int>(localPlayerPtr + Offsets::Player::m_iTeamNum);
        
        // Получаем матрицу просмотра
        Matrix4x4 viewMatrix = memoryManager->Read<Matrix4x4>(memoryManager->GetClientBaseAddress() + Offsets::dwViewMatrix);
        
        // Перебираем всех игроков
        for (int i = 0; i < 64; i++) {
            DWORD entityPtr = memoryManager->Read<DWORD>(entityListPtr + i * 0x8);
            
            if (!entityPtr)
                continue;
                
            int health = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iHealth);
            int team = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iTeamNum);
            bool dormant = memoryManager->Read<bool>(entityPtr + Offsets::Player::m_bDormant);
            
            // Пропускаем мертвых игроков и спящих сущности
            if (health <= 0 || dormant)
                continue;
                
            // Получаем позицию игрока
            DWORD gameSceneNode = memoryManager->Read<DWORD>(entityPtr + Offsets::Player::m_pGameSceneNode);
            Vec3 position = memoryManager->Read<Vec3>(gameSceneNode + Offsets::Player::m_vecOrigin);
            
            // Переводим 3D координаты в 2D для отображения
            Vec2 screenPos;
            if (WorldToScreen(position, screenPos, viewMatrix)) {
                char healthInfo[32];
                sprintf_s(healthInfo, "HP: %d", health);
                
                // Рисуем ESP
                D3DCOLOR espColor = (team == localTeam) ? D3DCOLOR_ARGB(255, 0, 255, 0) : D3DCOLOR_ARGB(255, 255, 0, 0);
                DrawBox(screenPos.x - 20, screenPos.y - 30, 40, 60, espColor);
                DrawText(healthInfo, screenPos.x - 10, screenPos.y - 45, D3DCOLOR_ARGB(255, 255, 255, 255));
            }
        }
    }
    
    void StartESP() {
        device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
        device->BeginScene();
        
        Render();
        
        device->EndScene();
        device->Present(NULL, NULL, NULL, NULL);
    }
};

int main() {
    std::cout << "CS2 ESP Mod для офлайн-режима\n";
    std::cout << "Ожидание запуска CS2...\n";
    
    MemoryManager memoryManager("cs2.exe", "client.dll");
    
    if (memoryManager.GetClientBaseAddress() == 0) {
        std::cout << "Не удалось найти CS2. Убедитесь, что игра запущена.\n";
        system("pause");
        return 1;
    }
    
    std::cout << "CS2 найден! Запуск ESP...\n";
    
    ESP esp(&memoryManager);
    
    while (true) {
        esp.StartESP();
        Sleep(10); // Небольшая задержка для снижения нагрузки на CPU
        
        // Выход по нажатию END
        if (GetAsyncKeyState(VK_END) & 1) {
            break;
        }
    }
    
    std::cout << "ESP остановлен\n";
    system("pause");
    return 0;
}

дай промпт, у меня клауд тупой

Angelwingsov · 5 Май 2025

vasargg написал(а):

Попросил claude 3.7 сделать esp чит на кс 2
Кто шарит посмотрите его и скажите будет ли он работать

C++:

#include <Windows.h>
#include <iostream>
#include <vector>
#include <TlHelp32.h>
#include <d3d9.h>
#include <d3dx9.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

// CS2 актуальные оффсеты (для обучения и офлайн-игры)
namespace Offsets {
    // Базовые оффсеты
    constexpr auto dwEntityList = 0x17C1950;      // EntityList
    constexpr auto dwLocalPlayerController = 0x1883958; // Локальный игрок
    constexpr auto dwViewMatrix = 0x1880950;      // Матрица вида
    constexpr auto dwGameSceneNode = 0x310;       // Game Scene Node
   
    // Оффсеты игрока
    namespace Player {
        constexpr auto m_pGameSceneNode = 0x310;
        constexpr auto m_vecOrigin = 0x80;        // Позиция игрока
        constexpr auto m_iTeamNum = 0x3BF;        // Команда
        constexpr auto m_iHealth = 0x32C;         // Здоровье
        constexpr auto m_bSpottedByMask = 0x1628; // Видимость
        constexpr auto m_bDormant = 0xED;         // Активность
    }
}

// Структуры
struct Vec3 {
    float x, y, z;
};

struct Vec4 {
    float x, y, z, w;
};

struct Matrix4x4 {
    float m[4][4];
};

// Функции получения процесса и памяти
DWORD GetProcessId(const char* processName) {
    DWORD processId = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
   
    if (snapshot != INVALID_HANDLE_VALUE) {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);
       
        if (Process32First(snapshot, &processEntry)) {
            do {
                if (!strcmp(processEntry.szExeFile, processName)) {
                    processId = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(snapshot, &processEntry));
        }
        CloseHandle(snapshot);
    }
    return processId;
}

DWORD GetModuleBaseAddress(DWORD processId, const char* moduleName) {
    DWORD moduleBaseAddress = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, processId);
   
    if (snapshot != INVALID_HANDLE_VALUE) {
        MODULEENTRY32 moduleEntry;
        moduleEntry.dwSize = sizeof(MODULEENTRY32);
       
        if (Module32First(snapshot, &moduleEntry)) {
            do {
                if (!strcmp(moduleEntry.szModule, moduleName)) {
                    moduleBaseAddress = (DWORD)moduleEntry.modBaseAddr;
                    break;
                }
            } while (Module32Next(snapshot, &moduleEntry));
        }
        CloseHandle(snapshot);
    }
    return moduleBaseAddress;
}

// Класс чтения/записи в память
class MemoryManager {
private:
    HANDLE processHandle;
    DWORD processId;
    DWORD clientBaseAddress;

public:
    MemoryManager(const char* processName, const char* moduleName) {
        processId = GetProcessId(processName);
        if (processId) {
            processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
            clientBaseAddress = GetModuleBaseAddress(processId, moduleName);
        }
    }

    ~MemoryManager() {
        if (processHandle) {
            CloseHandle(processHandle);
        }
    }

    template<typename T>
    T Read(DWORD address) {
        T value = T();
        ReadProcessMemory(processHandle, (LPCVOID)address, &value, sizeof(T), NULL);
        return value;
    }

    template<typename T>
    void Write(DWORD address, T value) {
        WriteProcessMemory(processHandle, (LPVOID)address, &value, sizeof(T), NULL);
    }

    DWORD GetClientBaseAddress() const {
        return clientBaseAddress;
    }

    HANDLE GetProcessHandle() const {
        return processHandle;
    }
};

// ESP функциональность
class ESP {
private:
    MemoryManager* memoryManager;
    LPDIRECT3D9 d3d;
    LPDIRECT3DDEVICE9 device;
    LPD3DXFONT font;
    D3DXVECTOR2 screenSize;

public:
    ESP(MemoryManager* mm) : memoryManager(mm) {
        // Инициализация DirectX
        d3d = Direct3DCreate9(D3D_SDK_VERSION);
       
        D3DPRESENT_PARAMETERS params;
        ZeroMemory(&params, sizeof(params));
       
        params.Windowed = TRUE;
        params.SwapEffect = D3DSWAPEFFECT_DISCARD;
        params.hDeviceWindow = GetForegroundWindow();
       
        RECT rect;
        GetClientRect(params.hDeviceWindow, &rect);
        screenSize.x = (float)(rect.right - rect.left);
        screenSize.y = (float)(rect.bottom - rect.top);
       
        d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, params.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &params, &device);
       
        // Создание шрифта
        D3DXCreateFont(device, 14, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial", &font);
    }
   
    ~ESP() {
        if (font)
            font->Release();
        if (device)
            device->Release();
        if (d3d)
            d3d->Release();
    }
   
    bool WorldToScreen(const Vec3& pos, Vec2& screen, const Matrix4x4& matrix) {
        Vec4 clipCoords;
        clipCoords.x = pos.x * matrix.m[0][0] + pos.y * matrix.m[0][1] + pos.z * matrix.m[0][2] + matrix.m[0][3];
        clipCoords.y = pos.x * matrix.m[1][0] + pos.y * matrix.m[1][1] + pos.z * matrix.m[1][2] + matrix.m[1][3];
        clipCoords.z = pos.x * matrix.m[2][0] + pos.y * matrix.m[2][1] + pos.z * matrix.m[2][2] + matrix.m[2][3];
        clipCoords.w = pos.x * matrix.m[3][0] + pos.y * matrix.m[3][1] + pos.z * matrix.m[3][2] + matrix.m[3][3];
       
        if (clipCoords.w < 0.1f)
            return false;
       
        Vec3 NDC;
        NDC.x = clipCoords.x / clipCoords.w;
        NDC.y = clipCoords.y / clipCoords.w;
        NDC.z = clipCoords.z / clipCoords.w;
       
        screen.x = (screenSize.x / 2 * NDC.x) + (NDC.x + screenSize.x / 2);
        screen.y = -(screenSize.y / 2 * NDC.y) + (NDC.y + screenSize.y / 2);
       
        return true;
    }
   
    void DrawBox(float x, float y, float width, float height, D3DCOLOR color) {
        D3DRECT rect = { x, y, x + width, y + height };
        device->Clear(1, &rect, D3DCLEAR_TARGET, color, 0, 0);
    }
   
    void DrawText(const char* text, float x, float y, D3DCOLOR color) {
        RECT rect = { x, y, x + 120, y + 20 };
        font->DrawTextA(NULL, text, -1, &rect, DT_LEFT | DT_NOCLIP, color);
    }
   
    void Render() {
        // Получаем адрес списка сущностей
        DWORD entityListPtr = memoryManager->GetClientBaseAddress() + Offsets::dwEntityList;
       
        // Получаем локального игрока
        DWORD localPlayerPtr = memoryManager->Read<DWORD>(memoryManager->GetClientBaseAddress() + Offsets::dwLocalPlayerController);
        int localTeam = memoryManager->Read<int>(localPlayerPtr + Offsets::Player::m_iTeamNum);
       
        // Получаем матрицу просмотра
        Matrix4x4 viewMatrix = memoryManager->Read<Matrix4x4>(memoryManager->GetClientBaseAddress() + Offsets::dwViewMatrix);
       
        // Перебираем всех игроков
        for (int i = 0; i < 64; i++) {
            DWORD entityPtr = memoryManager->Read<DWORD>(entityListPtr + i * 0x8);
           
            if (!entityPtr)
                continue;
               
            int health = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iHealth);
            int team = memoryManager->Read<int>(entityPtr + Offsets::Player::m_iTeamNum);
            bool dormant = memoryManager->Read<bool>(entityPtr + Offsets::Player::m_bDormant);
           
            // Пропускаем мертвых игроков и спящих сущности
            if (health <= 0 || dormant)
                continue;
               
            // Получаем позицию игрока
            DWORD gameSceneNode = memoryManager->Read<DWORD>(entityPtr + Offsets::Player::m_pGameSceneNode);
            Vec3 position = memoryManager->Read<Vec3>(gameSceneNode + Offsets::Player::m_vecOrigin);
           
            // Переводим 3D координаты в 2D для отображения
            Vec2 screenPos;
            if (WorldToScreen(position, screenPos, viewMatrix)) {
                char healthInfo[32];
                sprintf_s(healthInfo, "HP: %d", health);
               
                // Рисуем ESP
                D3DCOLOR espColor = (team == localTeam) ? D3DCOLOR_ARGB(255, 0, 255, 0) : D3DCOLOR_ARGB(255, 255, 0, 0);
                DrawBox(screenPos.x - 20, screenPos.y - 30, 40, 60, espColor);
                DrawText(healthInfo, screenPos.x - 10, screenPos.y - 45, D3DCOLOR_ARGB(255, 255, 255, 255));
            }
        }
    }
   
    void StartESP() {
        device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
        device->BeginScene();
       
        Render();
       
        device->EndScene();
        device->Present(NULL, NULL, NULL, NULL);
    }
};

int main() {
    std::cout << "CS2 ESP Mod для офлайн-режима\n";
    std::cout << "Ожидание запуска CS2...\n";
   
    MemoryManager memoryManager("cs2.exe", "client.dll");
   
    if (memoryManager.GetClientBaseAddress() == 0) {
        std::cout << "Не удалось найти CS2. Убедитесь, что игра запущена.\n";
        system("pause");
        return 1;
    }
   
    std::cout << "CS2 найден! Запуск ESP...\n";
   
    ESP esp(&memoryManager);
   
    while (true) {
        esp.StartESP();
        Sleep(10); // Небольшая задержка для снижения нагрузки на CPU
       
        // Выход по нажатию END
        if (GetAsyncKeyState(VK_END) & 1) {
            break;
        }
    }
   
    std::cout << "ESP остановлен\n";
    system("pause");
    return 0;
}

Рендер сразу в глаза идет?)

Вопрос Проверьте код

Похожие темы