Вопрос HandleBulletPenetration

babibaika · Понедельник в 14:29

Добрый день! Я новичок в разработке читов, и поэтому грешу использованием ИИ в написании проекта. Сейчас у меня есть готовый, GameTrace, но HandleBulletPenetration совершенно не работает. Gemini говорит, что мне нужен vData оружия, но я не понимаю как его получить. Все же у меня есть, хоть и плохая но версия получения Penetration

C++:

       namespace EngineTrace {

            using fnGetSurfaceData = uintptr_t(__fastcall*)(void*);
            static fnGetSurfaceData g_pGetSurfaceData = nullptr;
            uintptr_t addrManager;

            using fnCreateTrace_t = void(__fastcall*)(TraceData_t*, SDK::Dir::Vector3, SDK::Dir::Vector3, const TraceFilter_t&, void*, void*, void*, void*, int);
            inline fnCreateTrace_t fnCreateTrace = nullptr;

            using fnInitTraceInfo_t = void(__fastcall*)(GameTrace_t*);
            inline fnInitTraceInfo_t fnInitTraceInfo = nullptr;

            using fnGetTraceInfo_t = void(__fastcall*)(TraceData_t*, GameTrace_t*, float, void*);
            inline fnGetTraceInfo_t fnGetTraceInfo = nullptr;

            using fnHandleBulletPenetration_t = bool(__fastcall*)(TraceData_t*, handle_bullet_data_t*, update_value_t*, void*, void*, void*, void*, void*, bool);
            inline fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

            using fnGetWeaponEconData_t = uintptr_t(__fastcall*)(void*, int16_t);
            inline fnGetWeaponEconData_t fnGetWeaponEconData = nullptr;

            inline uintptr_t* g_pWeaponSystem = nullptr;
            uintptr_t weaponSystemRef;

            inline void Init() {
                fnTraceShape = reinterpret_cast<fnTraceShape_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57"));
                fnInitFilter = reinterpret_cast<fnInitFilter_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 0F B6 41 ? 33 FF 24"));
                fnCreateTrace = reinterpret_cast<fnCreateTrace_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 40 F2"));
                fnInitTraceInfo = reinterpret_cast<fnInitTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 57 48 83 EC 20 48 8B D9 33 FF 48 8B 0D"));
                fnGetTraceInfo = reinterpret_cast<fnGetTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 60 48 8B E9 0F"));
                fnHandleBulletPenetration = reinterpret_cast<fnHandleBulletPenetration_t>(Utils::FindPattern("client.dll", "48 8B C4 44 89 48 20 55 57 41 55"));

                fnGetWeaponEconData = reinterpret_cast<fnGetWeaponEconData_t>(Utils::FindPattern("client.dll", "48 89 74 24 ? 41 56 48 81 EC ? ? ? ? 4C 8B F2 48 8B F1 41 83 F8"));

           
            }
        }

И так же namespace GameTrace:

C++:

    namespace GameTrace {


        namespace Utils {
            inline uintptr_t FindPattern(const char* moduleName, const char* pattern) {
                uintptr_t moduleBase = (uintptr_t)GetModuleHandleA(moduleName);
                if (!moduleBase) return 0;

                PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)moduleBase;
                PIMAGE_NT_HEADERS ntHeaders = (PIMAGE_NT_HEADERS)(moduleBase + dosHeader->e_lfanew);
                uintptr_t sizeOfImage = (uintptr_t)ntHeaders->OptionalHeader.SizeOfImage;

                std::vector<int> patternBytes = {};
                char* start = const_cast<char*>(pattern);
                char* end = const_cast<char*>(pattern) + strlen(pattern);

                for (char* current = start; current < end; ++current) {
                    if (*current == '?') {
                        ++current;
                        if (*current == '?') ++current;
                        patternBytes.push_back(-1);
                    }
                    else {
                        patternBytes.push_back((int)strtoul(current, &current, 16));
                    }
                }

                uint8_t* scanStart = reinterpret_cast<uint8_t*>(moduleBase);
                size_t n = patternBytes.size();
                int* d = patternBytes.data();

                for (uintptr_t i = 0; i < sizeOfImage - n; ++i) {
                    bool found = true;
                    for (size_t j = 0; j < n; ++j) {
                        if (d[j] != -1 && scanStart[i + j] != d[j]) {
                            found = false;
                            break;
                        }
                    }
                    if (found) return reinterpret_cast<uintptr_t>(&scanStart[i]);
                }
                return 0;
            }
        }

        struct update_value_t {
            float m_previous_length_mod;
            float m_current_length_mod;
            uint8_t pad0[0x8];
            int16_t m_handle_idx;
            uint8_t pad1[0x6];
        };

        struct trace_arr_element_t {
            uint8_t pad[0x30];
        };

        struct TraceData_t {
            int32_t m_uk1;
            float m_uk2 = 52.0f;
            void* m_arr_pointer;
            int32_t m_uk3 = 128;
            int32_t m_uk4 = 0x80000000;
            trace_arr_element_t m_arr[0x80];
            uint8_t pad0[0x8];
            int64_t m_num_update;
            void* m_pointer_update_value;
            uint8_t pad1[0xC8];
            SDK::Dir::Vector3 m_start;
            SDK::Dir::Vector3 m_end;
            uint8_t pad2[0x50];
        };

        struct handle_bullet_data_t {
            float m_dmg;
            float m_pen;
            float m_range_mod;
            float m_range;
            int m_pen_count;
            bool m_failed;
        };

        struct TraceHitboxData_t {
            uint8_t pad[0x38];
            int m_nHitGroup;
            uint8_t pad2[0x4];
            int m_nHitboxId;
        };
        static_assert(sizeof(TraceHitboxData_t) == 0x44);

        struct GameTrace_t {
            void* m_pSurface;           // 0x0
            void* m_pHitEntity;         // 0x8
            TraceHitboxData_t* m_pHitboxData; // 0x10
            uint8_t pad0[0x40 - 0x18];
            uint32_t m_uContents;
            uint8_t  pad1[0x78 - 0x44];
            Dir::Vector3 m_vecStartPos;
            Dir::Vector3 m_vecEndPos;
            Dir::Vector3 m_vecNormal;
            Dir::Vector3 m_vecPosition;
            uint8_t  pad2[0xAC - 0xA8];
            float    m_flFraction;
            uint8_t  pad3[0xB6 - 0xB0];
            bool     m_bAllSolid;
            bool     m_bStartSolid;
            uint8_t  pad4[0x110 - 0xB8];
        };

        struct Ray_t {
            Dir::Vector3 m_Start;
            Dir::Vector3 m_End;
            Dir::Vector3 m_Mins;
            Dir::Vector3 m_Maxs;
            uint8_t pad[0x4];
            std::uint8_t UnkownType = 0x0;

            inline Ray_t() = default;
            inline Ray_t(const Dir::Vector3& start, const Dir::Vector3& end) {
                m_Start = start;
                m_End = end;
                m_Mins = { 0.f, 0.f, 0.f };
                m_Maxs = { 0.f, 0.f, 0.f };
            }
        };

        struct alignas(16) TraceFilter_t {
            std::byte pad[0x100];
            std::int64_t m_uTraceMask;
            std::array<std::int64_t, 2> m_v1;
            std::array<std::int32_t, 4> m_arrSkipHandles;
            std::array<std::int16_t, 2> m_arrCollisions;
            std::int16_t m_v2;
            std::uint8_t m_nLayer;
            std::uint8_t m_v4;
            std::uint8_t m_flags;

            inline TraceFilter_t(uintptr_t pLocalPawn, uint64_t mask = 0x46004003) {
                memset(this, 0, sizeof(TraceFilter_t));
                m_uTraceMask = mask;
                if (pLocalPawn != 0) {
                    uint32_t handle = 0;
                    if (Memory::ReadMemory<uint32_t>(pLocalPawn + 0x10, handle)) {
                        m_arrSkipHandles[0] = handle;
                    }
                }
                m_nLayer = 0;
                m_flags = 0x1;
            }

            inline void Init(uint64_t uMask, void* pSkipPawn, int nLayer);
        };

        using fnTraceShape_t = bool(__fastcall*)(void*, SDK::GameTrace::Ray_t*, const SDK::Dir::Vector3*, const SDK::Dir::Vector3*, SDK::GameTrace::TraceFilter_t*, SDK::GameTrace::GameTrace_t*);
        inline static void* pTraceManager = nullptr;
        inline static fnTraceShape_t fnTraceShape = nullptr;

        using fnInitFilter_t = void(__fastcall*)(SDK::GameTrace::TraceFilter_t*, void*, uint32_t, int, int16_t);
        inline static fnInitFilter_t fnInitFilter = nullptr;

        using fnHandleBulletPenetration_t = bool(__fastcall*)(
            void* pTraceManager,
            void* pWeaponData,
            SDK::GameTrace::GameTrace_t* pTrace,
            SDK::Dir::Vector3* pStart,
            SDK::Dir::Vector3* pEnd,
            float* pDamage,
            int* pPenCount
            );
        inline static fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

        class Trace {
        public:
            using fnTraceShape = bool(__fastcall*)(void*, Ray_t*, const Dir::Vector3*, const Dir::Vector3*, TraceFilter_t*, GameTrace_t*);

            static inline void* g_TraceManager = []() -> void* {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 8B 1D ? ? ? ? 24 ? 0C ?");
                if (!addr) return nullptr;
                int32_t offset = *reinterpret_cast<int32_t*>(addr + 3);
                return *reinterpret_cast<void**>(addr + 7 + offset);
                }();

            static inline fnTraceShape g_fnTraceShape = []() -> fnTraceShape {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57");
                if (!addr) return nullptr;
                return reinterpret_cast<fnTraceShape>(addr);
                }();

            static bool TraceShape(Ray_t& ray, const Dir::Vector3& start, const Dir::Vector3& end, TraceFilter_t& filter, GameTrace_t& trace) {
                if (!g_fnTraceShape || !g_TraceManager) return false;
                return g_fnTraceShape(g_TraceManager, &ray, &start, &end, &filter, &trace);
            }
        };

        inline void TraceFilter_t::Init(uint64_t uMask, void* pSkipPawn, int nLayer) {
            if (!fnInitFilter) return;
            __try {
                fnInitFilter(this, pSkipPawn, static_cast<uint32_t>(uMask), nLayer, 15);
            }
            __except (EXCEPTION_EXECUTE_HANDLER) {}
        }

Кто поможет мне буду ОЧЕНЬ благодарен

aireverser · Понедельник в 14:34

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

Добрый день! Я новичок в разработке читов, и поэтому грешу использованием ИИ в написании проекта. Сейчас у меня есть готовый, GameTrace, но HandleBulletPenetration совершенно не работает. Gemini говорит, что мне нужен vData оружия, но я не понимаю как его получить. Все же у меня есть, хоть и плохая но версия получения Penetration

C++:

       namespace EngineTrace {

            using fnGetSurfaceData = uintptr_t(__fastcall*)(void*);
            static fnGetSurfaceData g_pGetSurfaceData = nullptr;
            uintptr_t addrManager;

            using fnCreateTrace_t = void(__fastcall*)(TraceData_t*, SDK::Dir::Vector3, SDK::Dir::Vector3, const TraceFilter_t&, void*, void*, void*, void*, int);
            inline fnCreateTrace_t fnCreateTrace = nullptr;

            using fnInitTraceInfo_t = void(__fastcall*)(GameTrace_t*);
            inline fnInitTraceInfo_t fnInitTraceInfo = nullptr;

            using fnGetTraceInfo_t = void(__fastcall*)(TraceData_t*, GameTrace_t*, float, void*);
            inline fnGetTraceInfo_t fnGetTraceInfo = nullptr;

            using fnHandleBulletPenetration_t = bool(__fastcall*)(TraceData_t*, handle_bullet_data_t*, update_value_t*, void*, void*, void*, void*, void*, bool);
            inline fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

            using fnGetWeaponEconData_t = uintptr_t(__fastcall*)(void*, int16_t);
            inline fnGetWeaponEconData_t fnGetWeaponEconData = nullptr;

            inline uintptr_t* g_pWeaponSystem = nullptr;
            uintptr_t weaponSystemRef;

            inline void Init() {
                fnTraceShape = reinterpret_cast<fnTraceShape_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57"));
                fnInitFilter = reinterpret_cast<fnInitFilter_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 0F B6 41 ? 33 FF 24"));
                fnCreateTrace = reinterpret_cast<fnCreateTrace_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 40 F2"));
                fnInitTraceInfo = reinterpret_cast<fnInitTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 57 48 83 EC 20 48 8B D9 33 FF 48 8B 0D"));
                fnGetTraceInfo = reinterpret_cast<fnGetTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 60 48 8B E9 0F"));
                fnHandleBulletPenetration = reinterpret_cast<fnHandleBulletPenetration_t>(Utils::FindPattern("client.dll", "48 8B C4 44 89 48 20 55 57 41 55"));

                fnGetWeaponEconData = reinterpret_cast<fnGetWeaponEconData_t>(Utils::FindPattern("client.dll", "48 89 74 24 ? 41 56 48 81 EC ? ? ? ? 4C 8B F2 48 8B F1 41 83 F8"));

          
            }
        }

И так же namespace GameTrace:

C++:

    namespace GameTrace {


        namespace Utils {
            inline uintptr_t FindPattern(const char* moduleName, const char* pattern) {
                uintptr_t moduleBase = (uintptr_t)GetModuleHandleA(moduleName);
                if (!moduleBase) return 0;

                PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)moduleBase;
                PIMAGE_NT_HEADERS ntHeaders = (PIMAGE_NT_HEADERS)(moduleBase + dosHeader->e_lfanew);
                uintptr_t sizeOfImage = (uintptr_t)ntHeaders->OptionalHeader.SizeOfImage;

                std::vector<int> patternBytes = {};
                char* start = const_cast<char*>(pattern);
                char* end = const_cast<char*>(pattern) + strlen(pattern);

                for (char* current = start; current < end; ++current) {
                    if (*current == '?') {
                        ++current;
                        if (*current == '?') ++current;
                        patternBytes.push_back(-1);
                    }
                    else {
                        patternBytes.push_back((int)strtoul(current, &current, 16));
                    }
                }

                uint8_t* scanStart = reinterpret_cast<uint8_t*>(moduleBase);
                size_t n = patternBytes.size();
                int* d = patternBytes.data();

                for (uintptr_t i = 0; i < sizeOfImage - n; ++i) {
                    bool found = true;
                    for (size_t j = 0; j < n; ++j) {
                        if (d[j] != -1 && scanStart[i + j] != d[j]) {
                            found = false;
                            break;
                        }
                    }
                    if (found) return reinterpret_cast<uintptr_t>(&scanStart[i]);
                }
                return 0;
            }
        }

        struct update_value_t {
            float m_previous_length_mod;
            float m_current_length_mod;
            uint8_t pad0[0x8];
            int16_t m_handle_idx;
            uint8_t pad1[0x6];
        };

        struct trace_arr_element_t {
            uint8_t pad[0x30];
        };

        struct TraceData_t {
            int32_t m_uk1;
            float m_uk2 = 52.0f;
            void* m_arr_pointer;
            int32_t m_uk3 = 128;
            int32_t m_uk4 = 0x80000000;
            trace_arr_element_t m_arr[0x80];
            uint8_t pad0[0x8];
            int64_t m_num_update;
            void* m_pointer_update_value;
            uint8_t pad1[0xC8];
            SDK::Dir::Vector3 m_start;
            SDK::Dir::Vector3 m_end;
            uint8_t pad2[0x50];
        };

        struct handle_bullet_data_t {
            float m_dmg;
            float m_pen;
            float m_range_mod;
            float m_range;
            int m_pen_count;
            bool m_failed;
        };

        struct TraceHitboxData_t {
            uint8_t pad[0x38];
            int m_nHitGroup;
            uint8_t pad2[0x4];
            int m_nHitboxId;
        };
        static_assert(sizeof(TraceHitboxData_t) == 0x44);

        struct GameTrace_t {
            void* m_pSurface;           // 0x0
            void* m_pHitEntity;         // 0x8
            TraceHitboxData_t* m_pHitboxData; // 0x10
            uint8_t pad0[0x40 - 0x18];
            uint32_t m_uContents;
            uint8_t  pad1[0x78 - 0x44];
            Dir::Vector3 m_vecStartPos;
            Dir::Vector3 m_vecEndPos;
            Dir::Vector3 m_vecNormal;
            Dir::Vector3 m_vecPosition;
            uint8_t  pad2[0xAC - 0xA8];
            float    m_flFraction;
            uint8_t  pad3[0xB6 - 0xB0];
            bool     m_bAllSolid;
            bool     m_bStartSolid;
            uint8_t  pad4[0x110 - 0xB8];
        };

        struct Ray_t {
            Dir::Vector3 m_Start;
            Dir::Vector3 m_End;
            Dir::Vector3 m_Mins;
            Dir::Vector3 m_Maxs;
            uint8_t pad[0x4];
            std::uint8_t UnkownType = 0x0;

            inline Ray_t() = default;
            inline Ray_t(const Dir::Vector3& start, const Dir::Vector3& end) {
                m_Start = start;
                m_End = end;
                m_Mins = { 0.f, 0.f, 0.f };
                m_Maxs = { 0.f, 0.f, 0.f };
            }
        };

        struct alignas(16) TraceFilter_t {
            std::byte pad[0x100];
            std::int64_t m_uTraceMask;
            std::array<std::int64_t, 2> m_v1;
            std::array<std::int32_t, 4> m_arrSkipHandles;
            std::array<std::int16_t, 2> m_arrCollisions;
            std::int16_t m_v2;
            std::uint8_t m_nLayer;
            std::uint8_t m_v4;
            std::uint8_t m_flags;

            inline TraceFilter_t(uintptr_t pLocalPawn, uint64_t mask = 0x46004003) {
                memset(this, 0, sizeof(TraceFilter_t));
                m_uTraceMask = mask;
                if (pLocalPawn != 0) {
                    uint32_t handle = 0;
                    if (Memory::ReadMemory<uint32_t>(pLocalPawn + 0x10, handle)) {
                        m_arrSkipHandles[0] = handle;
                    }
                }
                m_nLayer = 0;
                m_flags = 0x1;
            }

            inline void Init(uint64_t uMask, void* pSkipPawn, int nLayer);
        };

        using fnTraceShape_t = bool(__fastcall*)(void*, SDK::GameTrace::Ray_t*, const SDK::Dir::Vector3*, const SDK::Dir::Vector3*, SDK::GameTrace::TraceFilter_t*, SDK::GameTrace::GameTrace_t*);
        inline static void* pTraceManager = nullptr;
        inline static fnTraceShape_t fnTraceShape = nullptr;

        using fnInitFilter_t = void(__fastcall*)(SDK::GameTrace::TraceFilter_t*, void*, uint32_t, int, int16_t);
        inline static fnInitFilter_t fnInitFilter = nullptr;

        using fnHandleBulletPenetration_t = bool(__fastcall*)(
            void* pTraceManager,
            void* pWeaponData,
            SDK::GameTrace::GameTrace_t* pTrace,
            SDK::Dir::Vector3* pStart,
            SDK::Dir::Vector3* pEnd,
            float* pDamage,
            int* pPenCount
            );
        inline static fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

        class Trace {
        public:
            using fnTraceShape = bool(__fastcall*)(void*, Ray_t*, const Dir::Vector3*, const Dir::Vector3*, TraceFilter_t*, GameTrace_t*);

            static inline void* g_TraceManager = []() -> void* {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 8B 1D ? ? ? ? 24 ? 0C ?");
                if (!addr) return nullptr;
                int32_t offset = *reinterpret_cast<int32_t*>(addr + 3);
                return *reinterpret_cast<void**>(addr + 7 + offset);
                }();

            static inline fnTraceShape g_fnTraceShape = []() -> fnTraceShape {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57");
                if (!addr) return nullptr;
                return reinterpret_cast<fnTraceShape>(addr);
                }();

            static bool TraceShape(Ray_t& ray, const Dir::Vector3& start, const Dir::Vector3& end, TraceFilter_t& filter, GameTrace_t& trace) {
                if (!g_fnTraceShape || !g_TraceManager) return false;
                return g_fnTraceShape(g_TraceManager, &ray, &start, &end, &filter, &trace);
            }
        };

        inline void TraceFilter_t::Init(uint64_t uMask, void* pSkipPawn, int nLayer) {
            if (!fnInitFilter) return;
            __try {
                fnInitFilter(this, pSkipPawn, static_cast<uint32_t>(uMask), nLayer, 15);
            }
            __except (EXCEPTION_EXECUTE_HANDLER) {}
        }

Кто поможет мне буду ОЧЕНЬ благодарен

Получай VData через pWeapon + 0x30 (EntitySubclass), заполни handle_bullet_data_t и вызывай fnHandleBulletPenetration с VData.

babibaika · Понедельник в 16:49

aireverser написал(а):
Получай VData через pWeapon + 0x30 (EntitySubclass), заполни handle_bullet_data_t и вызывай fnHandleBulletPenetration с VData.

Братан, ты реально легенда, но неподскажешь, откуда 0x30? Типо как ты его получил?

aireverser · Понедельник в 17:14

babibaika написал(а):
Братан, ты реально легенда, но неподскажешь, откуда 0x30? Типо как ты его получил?

из дампа схем C_BaseEntity-&gt -> m_pEntitySubclass (0x30).

babibaika · Понедельник в 17:21

aireverser написал(а):
Получай VData через pWeapon + 0x30 (EntitySubclass), заполни handle_bullet_data_t и вызывай fnHandleBulletPenetration с VData.

А я немного не понял, я вроде получаю vData, но я всеравно не могу прочитать Урон оружия:

C++:

  LocalInfo::wPtr = wPTR;

  Memory::ReadMemory(itemPTR + cs2_dumper::schemas::client_dll::C_EconItemView::m_iItemDefinitionIndex, LocalInfo::WeaponID);
  LocalInfo::WeaponName = GetWeaponIdToString(LocalInfo::WeaponID);

  LocalInfo::vData = LocalInfo::wPtr + 0x30;

  Memory::ReadMemory<ptr_t>(LocalInfo::vData + cs2_dumper::schemas::client_dll::CCSWeaponBaseVData::m_nDamage, LocalInfo::wType);
 
  if (LocalInfo::vData != 0) {
            Memory::ReadMemory<float>(LocalInfo::vData + cs2_dumper::schemas::client_dll::CCSWeaponBaseVData::m_flSpread, LocalInfo::Weapon_Inaccuracy);
            Memory::ReadMemory<int>(LocalInfo::wType + cs2_dumper::schemas::client_dll::CCSWeaponBaseVData::m_nDamage, LocalInfo::WeaponDamage);

  }

vData читается для каждого оружия, но я прописываю условие, и всеравно урон равен 0

aireverser · Понедельник в 17:26

У тебя ошибка: vData = wPtr + 0x30 — это адрес указателя, а не сам VData. Надо разыменовывать:

cpp:

ptr_t vDataPtr = 0;
Memory::ReadMemory<ptr_t>(wPtr + 0x30, vDataPtr); // тут мы читаем указатель
LocalInfo::vData = vDataPtr; // а тут выведится реальный адрес в памяти где лежит VData

И второе: m_nDamage в CCSWeaponBaseVData лежит внутри VData, а ты читаешь его с wType (какого-то левого указателя). Должно быть так:

cpp:

Memory::ReadMemory<int>(LocalInfo::vData + cs2_dumper::schemas::client_dll::CCSWeaponBaseVData::m_nDamage, LocalInfo::WeaponDamage);

fdhdsfhsdfhsdfh · Вчера в 20:40

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

Добрый день! Я новичок в разработке читов, и поэтому грешу использованием ИИ в написании проекта. Сейчас у меня есть готовый, GameTrace, но HandleBulletPenetration совершенно не работает. Gemini говорит, что мне нужен vData оружия, но я не понимаю как его получить. Все же у меня есть, хоть и плохая но версия получения Penetration

C++:

       namespace EngineTrace {

            using fnGetSurfaceData = uintptr_t(__fastcall*)(void*);
            static fnGetSurfaceData g_pGetSurfaceData = nullptr;
            uintptr_t addrManager;

            using fnCreateTrace_t = void(__fastcall*)(TraceData_t*, SDK::Dir::Vector3, SDK::Dir::Vector3, const TraceFilter_t&, void*, void*, void*, void*, int);
            inline fnCreateTrace_t fnCreateTrace = nullptr;

            using fnInitTraceInfo_t = void(__fastcall*)(GameTrace_t*);
            inline fnInitTraceInfo_t fnInitTraceInfo = nullptr;

            using fnGetTraceInfo_t = void(__fastcall*)(TraceData_t*, GameTrace_t*, float, void*);
            inline fnGetTraceInfo_t fnGetTraceInfo = nullptr;

            using fnHandleBulletPenetration_t = bool(__fastcall*)(TraceData_t*, handle_bullet_data_t*, update_value_t*, void*, void*, void*, void*, void*, bool);
            inline fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

            using fnGetWeaponEconData_t = uintptr_t(__fastcall*)(void*, int16_t);
            inline fnGetWeaponEconData_t fnGetWeaponEconData = nullptr;

            inline uintptr_t* g_pWeaponSystem = nullptr;
            uintptr_t weaponSystemRef;

            inline void Init() {
                fnTraceShape = reinterpret_cast<fnTraceShape_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57"));
                fnInitFilter = reinterpret_cast<fnInitFilter_t>(Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 0F B6 41 ? 33 FF 24"));
                fnCreateTrace = reinterpret_cast<fnCreateTrace_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 40 F2"));
                fnInitTraceInfo = reinterpret_cast<fnInitTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 57 48 83 EC 20 48 8B D9 33 FF 48 8B 0D"));
                fnGetTraceInfo = reinterpret_cast<fnGetTraceInfo_t>(Utils::FindPattern("client.dll", "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 60 48 8B E9 0F"));
                fnHandleBulletPenetration = reinterpret_cast<fnHandleBulletPenetration_t>(Utils::FindPattern("client.dll", "48 8B C4 44 89 48 20 55 57 41 55"));

                fnGetWeaponEconData = reinterpret_cast<fnGetWeaponEconData_t>(Utils::FindPattern("client.dll", "48 89 74 24 ? 41 56 48 81 EC ? ? ? ? 4C 8B F2 48 8B F1 41 83 F8"));

          
            }
        }

И так же namespace GameTrace:

C++:

    namespace GameTrace {


        namespace Utils {
            inline uintptr_t FindPattern(const char* moduleName, const char* pattern) {
                uintptr_t moduleBase = (uintptr_t)GetModuleHandleA(moduleName);
                if (!moduleBase) return 0;

                PIMAGE_DOS_HEADER dosHeader = (PIMAGE_DOS_HEADER)moduleBase;
                PIMAGE_NT_HEADERS ntHeaders = (PIMAGE_NT_HEADERS)(moduleBase + dosHeader->e_lfanew);
                uintptr_t sizeOfImage = (uintptr_t)ntHeaders->OptionalHeader.SizeOfImage;

                std::vector<int> patternBytes = {};
                char* start = const_cast<char*>(pattern);
                char* end = const_cast<char*>(pattern) + strlen(pattern);

                for (char* current = start; current < end; ++current) {
                    if (*current == '?') {
                        ++current;
                        if (*current == '?') ++current;
                        patternBytes.push_back(-1);
                    }
                    else {
                        patternBytes.push_back((int)strtoul(current, &current, 16));
                    }
                }

                uint8_t* scanStart = reinterpret_cast<uint8_t*>(moduleBase);
                size_t n = patternBytes.size();
                int* d = patternBytes.data();

                for (uintptr_t i = 0; i < sizeOfImage - n; ++i) {
                    bool found = true;
                    for (size_t j = 0; j < n; ++j) {
                        if (d[j] != -1 && scanStart[i + j] != d[j]) {
                            found = false;
                            break;
                        }
                    }
                    if (found) return reinterpret_cast<uintptr_t>(&scanStart[i]);
                }
                return 0;
            }
        }

        struct update_value_t {
            float m_previous_length_mod;
            float m_current_length_mod;
            uint8_t pad0[0x8];
            int16_t m_handle_idx;
            uint8_t pad1[0x6];
        };

        struct trace_arr_element_t {
            uint8_t pad[0x30];
        };

        struct TraceData_t {
            int32_t m_uk1;
            float m_uk2 = 52.0f;
            void* m_arr_pointer;
            int32_t m_uk3 = 128;
            int32_t m_uk4 = 0x80000000;
            trace_arr_element_t m_arr[0x80];
            uint8_t pad0[0x8];
            int64_t m_num_update;
            void* m_pointer_update_value;
            uint8_t pad1[0xC8];
            SDK::Dir::Vector3 m_start;
            SDK::Dir::Vector3 m_end;
            uint8_t pad2[0x50];
        };

        struct handle_bullet_data_t {
            float m_dmg;
            float m_pen;
            float m_range_mod;
            float m_range;
            int m_pen_count;
            bool m_failed;
        };

        struct TraceHitboxData_t {
            uint8_t pad[0x38];
            int m_nHitGroup;
            uint8_t pad2[0x4];
            int m_nHitboxId;
        };
        static_assert(sizeof(TraceHitboxData_t) == 0x44);

        struct GameTrace_t {
            void* m_pSurface;           // 0x0
            void* m_pHitEntity;         // 0x8
            TraceHitboxData_t* m_pHitboxData; // 0x10
            uint8_t pad0[0x40 - 0x18];
            uint32_t m_uContents;
            uint8_t  pad1[0x78 - 0x44];
            Dir::Vector3 m_vecStartPos;
            Dir::Vector3 m_vecEndPos;
            Dir::Vector3 m_vecNormal;
            Dir::Vector3 m_vecPosition;
            uint8_t  pad2[0xAC - 0xA8];
            float    m_flFraction;
            uint8_t  pad3[0xB6 - 0xB0];
            bool     m_bAllSolid;
            bool     m_bStartSolid;
            uint8_t  pad4[0x110 - 0xB8];
        };

        struct Ray_t {
            Dir::Vector3 m_Start;
            Dir::Vector3 m_End;
            Dir::Vector3 m_Mins;
            Dir::Vector3 m_Maxs;
            uint8_t pad[0x4];
            std::uint8_t UnkownType = 0x0;

            inline Ray_t() = default;
            inline Ray_t(const Dir::Vector3& start, const Dir::Vector3& end) {
                m_Start = start;
                m_End = end;
                m_Mins = { 0.f, 0.f, 0.f };
                m_Maxs = { 0.f, 0.f, 0.f };
            }
        };

        struct alignas(16) TraceFilter_t {
            std::byte pad[0x100];
            std::int64_t m_uTraceMask;
            std::array<std::int64_t, 2> m_v1;
            std::array<std::int32_t, 4> m_arrSkipHandles;
            std::array<std::int16_t, 2> m_arrCollisions;
            std::int16_t m_v2;
            std::uint8_t m_nLayer;
            std::uint8_t m_v4;
            std::uint8_t m_flags;

            inline TraceFilter_t(uintptr_t pLocalPawn, uint64_t mask = 0x46004003) {
                memset(this, 0, sizeof(TraceFilter_t));
                m_uTraceMask = mask;
                if (pLocalPawn != 0) {
                    uint32_t handle = 0;
                    if (Memory::ReadMemory<uint32_t>(pLocalPawn + 0x10, handle)) {
                        m_arrSkipHandles[0] = handle;
                    }
                }
                m_nLayer = 0;
                m_flags = 0x1;
            }

            inline void Init(uint64_t uMask, void* pSkipPawn, int nLayer);
        };

        using fnTraceShape_t = bool(__fastcall*)(void*, SDK::GameTrace::Ray_t*, const SDK::Dir::Vector3*, const SDK::Dir::Vector3*, SDK::GameTrace::TraceFilter_t*, SDK::GameTrace::GameTrace_t*);
        inline static void* pTraceManager = nullptr;
        inline static fnTraceShape_t fnTraceShape = nullptr;

        using fnInitFilter_t = void(__fastcall*)(SDK::GameTrace::TraceFilter_t*, void*, uint32_t, int, int16_t);
        inline static fnInitFilter_t fnInitFilter = nullptr;

        using fnHandleBulletPenetration_t = bool(__fastcall*)(
            void* pTraceManager,
            void* pWeaponData,
            SDK::GameTrace::GameTrace_t* pTrace,
            SDK::Dir::Vector3* pStart,
            SDK::Dir::Vector3* pEnd,
            float* pDamage,
            int* pPenCount
            );
        inline static fnHandleBulletPenetration_t fnHandleBulletPenetration = nullptr;

        class Trace {
        public:
            using fnTraceShape = bool(__fastcall*)(void*, Ray_t*, const Dir::Vector3*, const Dir::Vector3*, TraceFilter_t*, GameTrace_t*);

            static inline void* g_TraceManager = []() -> void* {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 8B 1D ? ? ? ? 24 ? 0C ?");
                if (!addr) return nullptr;
                int32_t offset = *reinterpret_cast<int32_t*>(addr + 3);
                return *reinterpret_cast<void**>(addr + 7 + offset);
                }();

            static inline fnTraceShape g_fnTraceShape = []() -> fnTraceShape {
                uintptr_t addr = Utils::FindPattern("client.dll", "48 89 5C 24 ? 48 89 4C 24 ? 55 57");
                if (!addr) return nullptr;
                return reinterpret_cast<fnTraceShape>(addr);
                }();

            static bool TraceShape(Ray_t& ray, const Dir::Vector3& start, const Dir::Vector3& end, TraceFilter_t& filter, GameTrace_t& trace) {
                if (!g_fnTraceShape || !g_TraceManager) return false;
                return g_fnTraceShape(g_TraceManager, &ray, &start, &end, &filter, &trace);
            }
        };

        inline void TraceFilter_t::Init(uint64_t uMask, void* pSkipPawn, int nLayer) {
            if (!fnInitFilter) return;
            __try {
                fnInitFilter(this, pSkipPawn, static_cast<uint32_t>(uMask), nLayer, 15);
            }
            __except (EXCEPTION_EXECUTE_HANDLER) {}
        }

Кто поможет мне буду ОЧЕНЬ благодарен

Не подскажешь как сделал трасировку? Вообще не понимаю

Вопрос HandleBulletPenetration

Похожие темы