Вопрос Киньте текущий trace_data

[cloppkiller]

просьба в названии

 

[electronics]

На юц сливали когда-то уже структуры в секции «реверс, структуры и оффсеты» как-то так. Могу свои рабочие скинуть если скажешь какая именно тебе нужна структура (конструктор trace T?)

 

[dxvxlxsh]

struct trace_data_t {
private:
    inline static constexpr std::int32_t kNumLocalElements = 0x80;
    inline static constexpr std::int32_t kNumLocalUpdateValues = 0x8;
 
    std::int32_t num_elements_{}; // 0x0
    float unk0_{ 52.f };
    trace_arr_element_t* elements_pointer_{}; // 0x8
    std::int32_t num_local_elements_{ kNumLocalElements }; // 0x10
    std::uint32_t unk1_{ 0x80000000u };
    std::array<trace_arr_element_t, kNumLocalElements> elements_{}; // 0x18
    zyra_mem_pad(0x8); // 1818
    std::int32_t num_update_values_{}; // 0x1820
    update_value_t* update_values_pointer_{}; // 0x1828
    std::int32_t num_local_update_values_{ kNumLocalUpdateValues }; // 0x1830
    std::uint32_t unk2_{ 0x80000000u };
    std::array<update_value_t, kNumLocalUpdateValues> update_values_; // 0x1838
    zyra::vec3 start_{}, end_{}; // 0x18F8
    float scale_{ 1.f }; // 0x1910
    std::int32_t uk5_{}; // 0x1914
    zyra_mem_pad(0x48); // 0x1918
 
public:
    trace_data_t() noexcept {
        elements_pointer_ = elements_.data();
        update_values_pointer_ = update_values_.data();
    }
    ~trace_data_t() {
        if (update_values_pointer_ != nullptr &&
            update_values_pointer_ != update_values_.data()) {
            zyra::g_interfaces()->iMemAlloc->free(update_values_pointer_);
            update_values_pointer_ = nullptr;
        }
 
        if (elements_pointer_ != nullptr &&
            elements_pointer_ != elements_.data()) {
            zyra::g_interfaces()->iMemAlloc->free(elements_pointer_);
            elements_pointer_ = nullptr;
        }
    }
 
public:
    zyra_always_inline [[nodiscard]] auto update_values_size() const noexcept {
        return num_update_values_;
    }
    template <std::integral T>
    zyra_always_inline [[nodiscard]] auto& update_value(T i) const noexcept {
        assert(static_cast<std::size_t>(i) < static_cast<std::size_t>(update_values_size()));
        return update_values_pointer_[i];
    }
    zyra_always_inline [[nodiscard]] auto elements_size() const noexcept {
        return num_elements_;
    }
    template <std::integral T>
    zyra_always_inline [[nodiscard]] auto& element(T i) const noexcept {
        assert(static_cast<std::size_t>(i) < static_cast<std::size_t>(elements_size()));
        return elements_pointer_[i];
    }
    zyra_always_inline [[nodiscard]] const auto& start() const noexcept {
        return start_;
    }
    zyra_always_inline [[nodiscard]] const auto& end() const noexcept {
        return end_;
    }
};

 

[cloppkiller]

В чем проблема? где тут старые структуры?:

#pragma once

#include "../../../sdk/vfunc/vfunc.hpp"

#include <array>
#include "../../../sdk/typedefs/vec_t.hpp"
#include "../../modules/modules.hpp"
#include "../../../utils/utils.hpp"

struct ray_t
{
public:
    vec3_t m_start{};
    vec3_t m_end{};
    vec3_t m_mins{};
    vec3_t m_maxs{};
    std::byte pad_001[ 0x4 ];
    std::uint8_t type{};
};
static_assert( sizeof( ray_t ) == 0x38 );

struct surface_data_t
{
public:
    std::byte pad_001[ 0x8 ];
    float m_pen_data_modifier{};
    float m_dmg_modifier{};
    std::byte pad_002[ 0x4 ];
    int m_material{};
};

static_assert( sizeof( surface_data_t ) == 0x18 );

struct trace_hitbox_data_t
{
public:
    std::byte pad_001[ 0x38 ];
    int m_hit_group{};
    std::byte pad_002[ 0x4 ];
    int m_hitbox_id{};
};
static_assert( sizeof( trace_hitbox_data_t ) == 0x44 );

struct trace_array_element_t {
    std::byte pad_001[ 0x30 ];
};

struct trace_data_t {
    std::int32_t uk1{ };
    float uk2{ 52.0f };
    void* arr_pointer{ };
    std::int32_t uk3{ 128 };
    std::int32_t uk4{ static_cast<std::int32_t>( 0x80000000 ) };
    std::array< trace_array_element_t, 0x80 > arr = { };
    std::byte pad_001[ 0x8 ];
    std::int64_t num_update{ };
    void* pointer_update_value{ };
    std::byte pad_002[ 0xC8 ];
    vec3_t start{ }, end{ };
    std::byte pad_003[ 0x50 ];
};

struct update_value_t {
    float m_previous_length_mod{ };
    float m_current_length_mod{ };
    std::byte pad_001[ 0x8 ];
    short m_handle_index{ };
    std::byte pad_002[ 0x6 ];
};

class c_cs_player_pawn;

struct game_trace_t
{
public:
    game_trace_t() = default;

    surface_data_t* get_surface_data_t();
    int get_hitbox_id();
    int get_hit_group();

    void* m_surface{};
    c_cs_player_pawn* m_hit_entity{};
    trace_hitbox_data_t* m_hitbox_data{};
    std::byte pad_001[0x38];
    std::uint32_t m_contents{};
    std::byte pad_002[0x24];
    vec3_t m_start{};
    vec3_t m_end{};
    vec3_t m_normal{};
    vec3_t m_pos{};
    std::byte pad_003[0x4];
    float m_fraction{};
    std::byte pad_004[0x6];
    bool m_all_solid{};
    std::byte pad_005[0x4D];
};

static_assert( sizeof( game_trace_t ) == 0x108 );

struct trace_filter_t
{
public:
    char pad_0000[8];
    int64_t m_mask;
    std::array<int64_t, 2> m_ptr{};
    std::array<int32_t, 4> m_skip_handles{};
    std::array<int16_t, 2> m_arr_collisions{};
    uint8_t m_ptr2{};
    uint8_t m_ptr3{};
    uint8_t m_ptr4{};
    uint8_t m_ptr5{};
    uint8_t m_collision{};

    trace_filter_t( ) = default;
    trace_filter_t( std::uint64_t mask, c_cs_player_pawn* entity, c_cs_player_pawn* player, int layer );
};
static_assert( sizeof( trace_filter_t ) == 0x40 );

class i_trace
{
    using fn_init_trace_info = void(__fastcall*) (game_trace_t*);
    using fn_get_trace_info = void(__fastcall*) (trace_data_t*, game_trace_t*, float, void*);
public:
    void init_trace(trace_filter_t& filter, c_cs_player_pawn* pawn, uint64_t mask, uint8_t layer, uint16_t unknown) {
        using fn_init_trace_t = trace_filter_t * (__fastcall*)(trace_filter_t&, void*, uint64_t, uint8_t, uint16_t);
        static fn_init_trace_t fn = reinterpret_cast<fn_init_trace_t>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 0F B6 41 ? 33 FF 24"));

        fn(filter, pawn, mask, layer, unknown);
    }

    void create_trace(trace_data_t* const trace, vec3_t start, vec3_t end, const trace_filter_t& filter, int penetration_count) {
        using fn_create_trace_t = void(__fastcall*) (trace_data_t*, vec3_t, vec3_t, trace_filter_t, int);
        static fn_create_trace_t fn = reinterpret_cast<fn_create_trace_t>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 57 41 56 41 57 48 83 EC ? F2 0F 10 02"));

        fn(trace, start, end, filter, penetration_count);
    }

    void init_trace_info(game_trace_t* const hit) {
        static fn_init_trace_info fn = reinterpret_cast<fn_init_trace_info>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "40 55 41 55 41 57 48 83 EC"));

        fn(hit);
    }

    void get_trace_info(trace_data_t* const trace, game_trace_t* const hit, const float unknown_float, void* unknown) {
        static fn_get_trace_info fn = reinterpret_cast<fn_get_trace_info>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 57 48 83 EC ? 48 8B E9 0F 29 74 24 ? 48 8B CA"));

        fn(trace, hit, unknown_float, unknown);
    }

    bool trace_shape(ray_t* ray, vec3_t start, vec3_t end, trace_filter_t* filter, game_trace_t* game_trace)
    {
        using fn_trace_shape = bool(__fastcall*)(i_trace*, ray_t*, vec3_t*, vec3_t*, trace_filter_t*, game_trace_t*);
        static fn_trace_shape o_trace_shape = reinterpret_cast<fn_trace_shape>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "48 89 5C 24 ? 48 89 4C 24 ? 55 57"));

        return o_trace_shape(this, ray, &start, &end, filter, game_trace);
    }

    bool clip_ray_entity(ray_t* ray, vec3_t start, vec3_t end, c_cs_player_pawn* pawn, trace_filter_t* filter, game_trace_t* game_trace)
    {
        using fn_clip_ray_entity = bool(__fastcall*)(i_trace*, ray_t*, vec3_t*, vec3_t*, c_cs_player_pawn*, trace_filter_t*, game_trace_t*);
        static fn_clip_ray_entity o_clip_ray_entity = reinterpret_cast<fn_clip_ray_entity>(g_opcodes->scan(g_modules->m_modules.client_dll.get_name(), "48 8B C4 48 89 58 ? 55 56 57 41 54 41 56 48 8D 68 ? 48 81 EC ? ? ? ? 48 8B 5D"));

        return o_clip_ray_entity(this, ray, &start, &end, pawn, filter, game_trace);
    }
};