Вопрос Плиз не могу понять почему код не работает(уже советовался даже с chat gpt)

Lapyshkaa · Воскресенье в 11:37

C++:

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdint>
#include <thread>
#include <chrono>
#include <random>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <X11/Xlib.h>
#include <X11/extensions/XTest.h>
#include <X11/keysym.h>
#include <sys/uio.h>

class MemoryReader {
private:
    pid_t pid;
public:
    MemoryReader(pid_t target_pid) : pid(target_pid) {}

    template<typename T>
    T read_memory(uint64_t address) {
        T value;
        struct iovec local_iov[] = { {&value, sizeof(T)} };
        struct iovec remote_iov[] = { {reinterpret_cast<void*>(address), sizeof(T)} };

        ssize_t bytes_read = process_vm_readv(pid, local_iov, 1, remote_iov, 1, 0);
        if (bytes_read != sizeof(T)) {
            throw std::runtime_error("Failed to read memory at address " + std::to_string(address));
        }
        return value;
    }
    
    bool is_valid_address(uint64_t address) {
        return (address != 0) && (address >= 0x10000) && (address < 0x7FFFFFFFFFFF);
    }
    
};
uint64_t find_lib_base_address(pid_t pid, const std::string& lib_name) {
    std::string maps_path = "/proc/" + std::to_string(pid) + "/maps";
    std::ifstream maps_file(maps_path);
    std::string line;
    
    while (std::getline(maps_file, line)) {
        if (line.find(lib_name) != std::string::npos && line.find("r-xp") != std::string::npos) {
            size_t dash_pos = line.find('-');
            if (dash_pos != std::string::npos) {
                return std::stoul(line.substr(0, dash_pos), nullptr, 16);
            }
        }
    }
    throw std::runtime_error("Library " + lib_name + " not found in process " + std::to_string(pid));
}

pid_t get_cs2_pid() {
    FILE* pipe = popen("pidof cs2", "r");
    if (!pipe) {
        throw std::runtime_error("Failed to run pidof command");
    }
    
    char buffer[128];
    if (!fgets(buffer, sizeof(buffer), pipe)) {
        pclose(pipe);
        throw std::runtime_error("CS2 not running");
    }
    
    pclose(pipe);
    return static_cast<pid_t>(std::stoi(buffer));
}

class MouseController {
private:
    Display* display;
    
public:
    MouseController() {
        display = XOpenDisplay(nullptr);
        if (!display) {
            throw std::runtime_error("Cannot open X display");
        }
    }
    
    ~MouseController() {
        if (display) {
            XCloseDisplay(display);
        }
    }
    
    void click_left() {
        XTestFakeButtonEvent(display, 1, True, CurrentTime);
        XFlush(display);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        XTestFakeButtonEvent(display, 1, False, CurrentTime);
        XFlush(display);
    }
};

class KeyboardMonitor {
private:
    Display* display;
    KeyCode caps_lock_keycode;
    KeyCode f8_keycode;
    
public:
    KeyboardMonitor() {
        display = XOpenDisplay(nullptr);
        if (!display) {
            throw std::runtime_error("Cannot open X display");
        }
        caps_lock_keycode = XKeysymToKeycode(display, XK_Caps_Lock);
        f8_keycode = XKeysymToKeycode(display, XK_F8);
    }
    
    ~KeyboardMonitor() {
        if (display) {
            XCloseDisplay(display);
        }
    }
    
    bool is_caps_lock_pressed() {
        char keys[32];
        XQueryKeymap(display, keys);
        return (keys[caps_lock_keycode / 8] & (1 << (caps_lock_keycode % 8))) != 0;
    }
    
    bool is_f8_pressed() {
        char keys[32];
        XQueryKeymap(display, keys);
        return (keys[f8_keycode / 8] & (1 << (f8_keycode % 8))) != 0;
    }
};

class TriggerBot {
private:
    MemoryReader& memory;
    uint64_t libclient_base;
    
    struct Offsets {
        uint64_t dwLocalPlayerPawn = 0x1BF1FA0;
        uint64_t m_iIDEntIndex = 0x3EDC;
        uint64_t dwEntityList = 0x1D16758;
        uint64_t m_iHealth = 0x34C;           
        uint64_t m_iTeamNum = 0x3EB;         
    } offsets;
    
public:
    TriggerBot(MemoryReader& mem, uint64_t base) : memory(mem), libclient_base(base) {}
    
   void print_debug_info() {
    try {
        uint64_t local_player = memory.read_memory<uint64_t>(libclient_base + offsets.dwLocalPlayerPawn);
        
        if (!memory.is_valid_address(local_player)) {
            std::cout << "❌ Local player not found" << std::endl;
            return;
        }
            
       int entity_id = memory.read_memory<int32_t>(local_player + offsets.m_iIDEntIndex);
        std::cout << "🎯 Entity ID in crosshair: " << entity_id << std::endl;
            
            if (entity_id <= 0 || entity_id > 64) {
                std::cout << "❌ No valid target in crosshair" << std::endl;
                return;
            }
            
            // Получаем команду локального игрока
            int local_team = memory.read_memory<int32_t>(local_player + offsets.m_iTeamNum);
            std::cout << "👤 Local player team: " << local_team << std::endl;
            
            // Получаем entity из entity list
            uint64_t entity_list = memory.read_memory<uint64_t>(libclient_base + offsets.dwEntityList);
            if (!memory.is_valid_address(entity_list)) {
                std::cout << "❌ Entity list not found" << std::endl;
                return;
            }
            
            uint64_t list_entry = memory.read_memory<uint64_t>(entity_list + 0x8 * ((entity_id & 0x7FFF) >> 9) + 0x10);
            if (!memory.is_valid_address(list_entry)) {
                std::cout << "❌ List entry not found" << std::endl;
                return;
            }
            
            uint64_t entity = memory.read_memory<uint64_t>(list_entry + 120 * (entity_id & 0x1FF));
            if (!memory.is_valid_address(entity)) {
                std::cout << "❌ Entity not found" << std::endl;
                return;
            }
            
            // Получаем информацию о entity
            int entity_health = memory.read_memory<int32_t>(entity + offsets.m_iHealth);
            int entity_team = memory.read_memory<int32_t>(entity + offsets.m_iTeamNum);
            
            std::cout << "🔍 Target info - Health: " << entity_health << ", Team: " << entity_team << std::endl;
            
            // Проверяем условия для выстрела
            if (entity_health > 0 && entity_team > 0 && local_team > 0 && entity_team != local_team) {
                std::cout << "✅ VALID TARGET - Enemy spotted! Ready to fire!" << std::endl;
            } else if (entity_team == local_team) {
                std::cout << "🚫 INVALID TARGET - Friendly player" << std::endl;
            } else if (entity_health <= 0) {
                std::cout << "💀 INVALID TARGET - Target is dead" << std::endl;
            } else {
                std::cout << "❓ UNKNOWN TARGET - Cannot determine target type" << std::endl;
            }
            
      } catch (const std::exception& e) {
        std::cout << "💥 Error reading memory: " << e.what() << std::endl;
    }
    }
    
    bool should_trigger() {
        try {
   uint64_t local_player_addr = libclient_base + offsets.dwLocalPlayerPawn;
std::cout << "DEBUG: Local player address: 0x" << std::hex << local_player_addr << std::dec << std::endl;
uint64_t local_player = memory.read_memory<uint64_t>(local_player_addr);
            
            int entity_id = memory.read_memory<int32_t>(local_player + offsets.m_iIDEntIndex);
            
            if (entity_id <= 0 || entity_id > 64) {
                return false;
            }
            
            int local_team = memory.read_memory<int32_t>(local_player + offsets.m_iTeamNum);
            
            uint64_t entity_list = memory.read_memory<uint64_t>(libclient_base + offsets.dwEntityList);
            if (!memory.is_valid_address(entity_list)) {
                return false;
            }
            
            uint64_t list_entry = memory.read_memory<uint64_t>(entity_list + 0x8 * ((entity_id & 0x7FFF) >> 9) + 0x10);
            if (!memory.is_valid_address(list_entry)) {
                return false;
            }
            
            uint64_t entity = memory.read_memory<uint64_t>(list_entry + 120 * (entity_id & 0x1FF));
            if (!memory.is_valid_address(entity)) {
                return false;
            }
            
    
            int entity_health = memory.read_memory<int32_t>(entity + offsets.m_iHealth);
            int entity_team = memory.read_memory<int32_t>(entity + offsets.m_iTeamNum);
            
            return (entity_health > 0 && entity_team > 0 && local_team > 0 && entity_team != local_team);
            
        } catch (const std::exception& e) {
            return false;
        }
    }
};

int main() {
    try {
        pid_t pid = get_cs2_pid();
        std::cout << "🎮 CS2 PID: " << pid << std::endl;
        MemoryReader memory(pid);
        uint64_t libclient = find_lib_base_address(pid, "libclient.so");
        std::cout << "📍 libclient.so base: 0x" << std::hex << libclient << std::dec << std::endl;
        
        MouseController mouse;
        KeyboardMonitor keyboard;
        TriggerBot trigger_bot(memory, libclient);
        
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> delay(0.02, 0.04);
        
        std::cout << "🚀 Trigger bot started!" << std::endl;
        std::cout << "💡 Controls: CapsLock = Trigger, F8 = Exit" << std::endl;
        std::cout << "🔍 Debug mode: Press any key to see crosshair target info" << std::endl;
        
        bool was_caps_lock_pressed = false;
        auto last_debug_time = std::chrono::steady_clock::now();
        
        while (true) {
            // Выход по F8
            if (keyboard.is_f8_pressed()) {
                std::cout << "👋 Exiting..." << std::endl;
                break;
            }
            
            bool is_caps_lock_pressed = keyboard.is_caps_lock_pressed();
            
            auto now = std::chrono::steady_clock::now();
            if (std::chrono::duration_cast<std::chrono::seconds>(now - last_debug_time).count() >= 2) {
                std::cout << "\n=== DEBUG INFO ===" << std::endl;
                trigger_bot.print_debug_info();
                std::cout << "==================" << std::endl;
                last_debug_time = now;
            }
            
            if (is_caps_lock_pressed && !was_caps_lock_pressed) {
                if (trigger_bot.should_trigger()) {
                    std::cout << "🔥 FIRING at enemy!" << std::endl;
                    std::this_thread::sleep_for(std::chrono::duration<double>(delay(gen)));
                    mouse.click_left();
                }
            }
            
            was_caps_lock_pressed = is_caps_lock_pressed;
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
        
    } catch (const std::exception& e) {
        std::cerr << "💥 Error: " << e.what() << std::endl;
        return 1;
        
    }
    
    return 0;
}

Pozdnyakovski · Вторник в 02:19

Проблема в юникод, компилятор не распознает вот это(эмодзи):

Убери их и все.
Вообще, если ты изучил плюсы, у тебя есть база, не нужно все через нейросеть делать.

Он тебе дает код, а твоя задача сделать вот что:
1) Разбираешь его архитектурно(код)
2) Спрашиваешь то, чего не можешь понять в коде

А потом по мышечной памяти пытаешься переписать этот же код, пытаясь вспомнить как реализовать ту или иную функцию.
Для тренировки мышечной памяти говоришь нейронке: Разложи написание какой-то задачи, ну, для примера инжектор, на план(без кода)

Твоя задача строго по плану писать код, пытаться что-то сделать(даже если ты сделал 10 процентов из 90, это уже поднимет тебе мотивацию), типа:
Тебе нейронка говорит: Подключи библиотеку для работы с Windows(я знаю что у тебя линукс, это пример, я хз прост как архитектура линукса устроена)

include:

#include <windows.h>

Ты подключаешь, 5 процентов выполнено, окей, дальше
Нейронка тебе говорит: Создай переменную типа DWORD, которая используя апи функцию FindProcessId находит определённый процесс, для примера notepad. Ты реализовываешь:

C:

    DWORD pid = FindProcessId(L"notepad.exe");
    if (pid == 0) {
        printf("[ERROR] Блокнот не найден");
        printf("[INFO] Пожалуйста откройте блокнот\n");
        return 1;
    }

И так далее, тренируешь мышечную память, тем самым в будущем сам не заметишь, как ты уже спокойно пишешь инжекторы/проги какие-то/софты без помощи нейросети или каких-то посторонних людей

Lapyshkaa · Вторник в 08:19

Пожалуйста, зарегистрируйтесь или авторизуйтесь, чтобы увидеть содержимое.

Pozdnyakovski написал(а):
Проблема в юникод, компилятор не распознает вот это(эмодзи):
Посмотреть вложение 317174
Убери их и все.
Вообще, если ты изучил плюсы, у тебя есть база, не нужно все через нейросеть делать.

Он тебе дает код, а твоя задача сделать вот что:
1) Разбираешь его архитектурно(код)
2) Спрашиваешь то, чего не можешь понять в коде

А потом по мышечной памяти пытаешься переписать этот же код, пытаясь вспомнить как реализовать ту или иную функцию.
Для тренировки мышечной памяти говоришь нейронке: Разложи написание какой-то задачи, ну, для примера инжектор, на план(без кода)

Твоя задача строго по плану писать код, пытаться что-то сделать(даже если ты сделал 10 процентов из 90, это уже поднимет тебе мотивацию), типа:
Тебе нейронка говорит: Подключи библиотеку для работы с Windows(я знаю что у тебя линукс, это пример, я хз прост как архитектура линукса устроена)

include:

#include <windows.h>

Ты подключаешь, 5 процентов выполнено, окей, дальше
Нейронка тебе говорит: Создай переменную типа DWORD, которая используя апи функцию FindProcessId находит определённый процесс, для примера notepad. Ты реализовываешь:

C:

DWORD pid = FindProcessId(L"notepad.exe"); if (pid == 0) { printf("[ERROR] Блокнот не найден"); printf("[INFO] Пожалуйста откройте блокнот\n"); return 1; }

И так далее, тренируешь мышечную память, тем самым в будущем сам не заметишь, как ты уже спокойно пишешь инжекторы/проги какие-то/софты без помощи нейросети или каких-то посторонних людей

Я не могу юзать windows.h, т.к я на linux. Нейронку юзал от без исходности

colby57 · Вторник в 13:00

Pozdnyakovski написал(а):
Проблема в юникод, компилятор не распознает вот это(эмодзи):

я сомневаюсь, что убрав эмодзи из логгирования, у него что-то поменяется и чит магическим чудом заработает.............

Pozdnyakovski · Вторник в 13:15

colby57 написал(а):
я сомневаюсь, что убрав эмодзи из логгирования, у него что-то поменяется и чит магическим чудом заработает.............

хз, я не углублялся в код + он не показал код ошибки

Lapyshkaa написал(а):
Скрытое содержимое

Я не могу юзать windows.h, т.к я на linux. Нейронку юзал от без исходности

не легче не мучать себя и не винду перейти?

Faiz1337 · Вторник в 14:14

что именно у тебя не работает?

Вопрос Плиз не могу понять почему код не работает(уже советовался даже с chat gpt)

Похожие темы