Исходник Актуальные external оффсеты

[maximka0318]

IGameFramework - 0x142A98AA8
ViewMat - 0x142A578E8
ProjMat - 0x142A57928

SSGE:

class c_ssystem_global_environment
{
public:
    static c_ssystem_global_environment* get_instance() {
        return reinterpret_cast<c_ssystem_global_environment*>(memory->read<uintptr_t>(0x142A330A7) - 0x22C39CEBF5B95407LL);
    }

    c_renderer* get_renderer() {
       return reinterpret_cast<c_renderer*>(memory->read<uintptr_t>(reinterpret_cast<uintptr_t>(this) + 0x51) + 0xB89DFE4A4805D56LL);
    }

   c_timer* get_timer() {
        return reinterpret_cast<c_timer*>(memory->read<uintptr_t>(reinterpret_cast<uintptr_t>(this) + 0x149) - 0x23787E3D84908DA0LL);
    }
};

CTimer:

class c_timer
{
public:
    uint64_t get_tick_per_sec() {
        return memory->read<uint64_t>(reinterpret_cast<uintptr_t>(this) + 0x40);
    }

    uint64_t get_current_time() {
        return memory->read<uint64_t>(reinterpret_cast<uintptr_t>(this) + 0x58);
    }

    float get_abs_time() {
        return (float)((double)this->get_current_time() / (double)this->get_tick_per_sec());
    }
};

CRenderer:

class c_renderer {
public:
    viewport_t get_viewport() {
        return memory->read<viewport_t>(reinterpret_cast<uptr>(this) + 0x14B718);
    }

    bool world_to_screen(const vec3_t& pos, vec3_t& out, float screen_w, float screen_h, matrix4x4_t view, matrix4x4_t proj) {
        view.sanitize();
        proj.sanitize();

        viewport_t vp = get_viewport();
        i32 viewport[4] = { vp.x, vp.y, vp.z, vp.w };

        auto result = project_rebuild(pos, viewport, proj, view);
        if (result.empty() || result.z < 0.f)
            return false;

        out.x = result.x * 100.f / viewport[2] * (screen_w / 100.f);
        out.y = result.y * 100.f / viewport[3] * (screen_h / 100.f);
        out.z = result.z;

        if (!std::isfinite(out.x) || !std::isfinite(out.y))
            return false;

        return true;
    }
};

CGameFramework:

class c_game_framework {
public:
    static c_game_framework* get_instance() {
        return memory->read<c_game_framework*>(offsets::framework);
    }

    std::string get_level_name() {
        auto level_system = memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x4D8);
        if (!level_system)
            return "";

        auto current_level = memory->read<uptr>(level_system + 0x40);
        if (!current_level)
            return "";

        return memory->read_string(memory->read<uptr>(current_level + 0x10), 128);
    }

    i32 get_local_player_id() {
        auto v1 = memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x50);
        if (!v1)
            return 0;

        auto v3 = memory->read<uptr>(v1 + 0x48);
        if (!v3)
            return 0;

        auto v0 = memory->read<uptr>(v3 + 0x10);
        if (!v0)
            return 0;

        return memory->read<i32>(v0 + 0x20);
    }

    c_actor_system* get_actor_system() {
        return memory->read<c_actor_system*>(reinterpret_cast<uptr>(this) + 0x4E0);
    }

    c_item_system* get_item_system() {
        return memory->read<c_item_system*>(reinterpret_cast<uptr>(this) + 0x4E8);
    }
};

CActorSystem:

class c_actor_system {
public:
    void create_actor_map(std::unordered_map<i32, c_actor*>& map) {
        auto m_actors = memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x30);
        auto m_buf = memory->read<uptr>(m_actors);

        while (m_actors != m_buf) {
            auto id = memory->read<i32>(m_buf + 0x20);
            auto actor = memory->read<c_actor*>(m_buf + 0x28);
            map[id] = actor;

            auto m_parent = memory->read<uptr>(m_buf + 0x10);
            if (memory->read<u8>(m_parent + 0x19)) {
                auto it = memory->read<uptr>(m_buf + 0x8);
                while (!memory->read<u8>(it + 0x19)) {
                    if (m_buf != memory->read<uptr>(it + 0x10))
                        break;

                    m_buf = it;
                    it = memory->read<uptr>(it + 0x8);
                }
                m_buf = it;
            }
            else {
                m_buf = memory->read<uptr>(m_buf + 0x10);
                auto i = memory->read<uptr>(m_parent);
                while (!memory->read<u8>(i + 0x19)) {
                    m_buf = i;
                    i = memory->read<uptr>(i);
                }
            }
        }
    }
};

CItemSystem:

class c_item_system {
public:
    c_item_proxy* get_item(i32 item_id) {
        auto m_params = memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x80);
        auto m_buf = memory->read<uptr>(m_params);
        auto parent = memory->read<uptr>(m_params + 0x8);

        while (!memory->read<u8>(parent + 0x19)) {
            if (memory->read<i32>(parent + 0x20) >= item_id) {
                m_buf = parent;
                parent = memory->read<uptr>(parent);
            }
            else {
                parent = memory->read<uptr>(parent + 0x10);
            }
        }

        if (m_buf == m_params || item_id < memory->read<i32>(m_buf + 0x20))
            m_buf = m_params;

        return (m_buf == m_params) ? nullptr : memory->read<c_item_proxy*>(m_buf + 0x28);
    }
};

CActor:

class c_actor {
public:
    c_entity* get_entity() {
        return memory->read<c_entity*>(reinterpret_cast<uptr>(this) + 0x10);
    }

    c_inventory* get_inventory() {
        return memory->read<c_inventory*>(reinterpret_cast<uptr>(this) + 0x38);
    }

    i32 get_health() {
        auto v1 = memory->read<i32>(reinterpret_cast<uptr>(this) + 0x64);
        if (!v1)
            return 0;

        auto v2 = v1 ^ memory->read<i32>(reinterpret_cast<uptr>(this) + 0x60);
        auto value = 0.f;
        *(i32*)&value = v2;
        return (i32)value;
    }

    i32 get_max_health() {
        auto key = memory->read<i32>(reinterpret_cast<uptr>(this) + 0x78);
        if (!key)
            return 0;

        return key ^ memory->read<i32>(reinterpret_cast<uptr>(this) + 0x74);
    }

    i32 get_team() {
        return memory->read<i32>(reinterpret_cast<uptr>(this) + 0x790);
    }
};

CInventory:

class c_inventory {
public:
    i32 get_current_item_id() {
        return memory->read<i32>(reinterpret_cast<uptr>(this) + 0xB0);
    }
};

CItemProxy:

class c_item_proxy {
public:
    c_weapon_general* get_weapon_ext() {
        return memory->read<c_weapon_general*>(reinterpret_cast<uptr>(this) + 0x30);
    }

    c_item_box* get_item_box() {
        return memory->read<c_item_box*>(reinterpret_cast<uptr>(this) + 0x40);
    }
};

CItemBox:

class c_item_box {
public:
    void set_fire_target(vec3_t pos) {
        memory->write<vec3_t>(reinterpret_cast<uptr>(this) + 0x1C, pos);
    }
};

CWeaponGeneral:

class c_weapon_general {
public:
    c_weapon_parameters* get_parameters() {
        return memory->read<c_weapon_parameters*>(reinterpret_cast<uptr>(this) + 0xC8);
    }
};

CWeaponParameters:

class c_weapon_parameters {
public:
    c_stats_array* get_stats() {
        return reinterpret_cast<c_stats_array*>(reinterpret_cast<uptr>(this) + 0x70);
    }

    void no_spread() {
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x24, vec2_t(0, 0));
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x2C, vec2_t(0, 0));
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x34, vec2_t(0, 0));
    }

    void no_sway() {
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x0, vec2_t(0, 0));
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x8, vec2_t(0, 0));
        memory->write<vec2_t>(reinterpret_cast<uptr>(this) + 0x54, vec2_t(0, 0));
    }
};

CStatsArray:

class c_stats_array {
public:
    float get_value(e_game_stat_type stat) {
        auto head = memory->read<uptr>(reinterpret_cast<uptr>(this));
        auto node = memory->read<uptr>(head + 0x8);

        auto found = head;

        while (!memory->read<u8>(node + 0x19)) {
            if (memory->read<i16>(node + 0x1C) >= (i16)stat) {
                found = node;
                node = memory->read<uptr>(node);
            }
            else {
                node = memory->read<uptr>(node + 0x10);
            }
        }

        if (memory->read<u8>(found + 0x19) || (i16)stat < memory->read<i16>(found + 0x1C) || found == head)
            return 0.f;

        auto mask = memory->read<u32>(found + 0x24);
        if (!mask)
            return 0.f;

        auto val = mask ^ memory->read<u32>(found + 0x20);
        return *reinterpret_cast<float*>(&val);
    }

    void set_value(e_game_stat_type stat, float value) {
        auto head = memory->read<uptr>(reinterpret_cast<uptr>(this));
        auto node = memory->read<uptr>(head + 0x8);

        auto found = head;

        while (!memory->read<u8>(node + 0x19)) {
            if (memory->read<i16>(node + 0x1C) >= (i16)stat) {
                found = node;
                node = memory->read<uptr>(node);
            }
            else {
                node = memory->read<uptr>(node + 0x10);
            }
        }

        if (memory->read<u8>(found + 0x19) || (i16)stat < memory->read<i16>(found + 0x1C) || found == head)
            return;

        auto mask = memory->read<u32>(found + 0x24);
        auto encrypted = *reinterpret_cast<u32*>(&value) ^ mask;
        memory->write<u32>(found + 0x20, encrypted);
    }
};

CEntity:

class c_entity {
public:
    matrix34_t get_world_tm() {
        return memory->read<matrix34_t>(reinterpret_cast<uptr>(this) + 0x40);
    }

    vec3_t get_pos() {
        return memory->read<vec3_t>(reinterpret_cast<uptr>(this) + 0x70);
    }

    std::string get_name() {
        return memory->read_string(memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x170));
    }

    c_character_instance* get_character(i32 slot) {
        auto render_proxy = memory->read<uptr>(reinterpret_cast<uptr>(this) + 0xB8);
        auto entity_object = memory->read<uptr>(memory->read<uptr>(render_proxy + 0x60)) + (slot << 16);
        return memory->read<c_character_instance*>(entity_object + 0x78);
    }

    c_entity_proxy* get_proxy() {
        return memory->read<c_entity_proxy*>(reinterpret_cast<uptr>(this) + 0xB8);
    }
};

CEntityProxy:

class c_entity_proxy {
public:
    float get_last_seen_time() {
        return memory->read< float>((std::uintptr_t)this + 0xA0);
    }

    bool is_visible(float abs_time) {
        float last_seen = this->get_last_seen_time();
        float delta = abs_time - last_seen;
        return delta < 2.0f;
    }
};

CCharacterInstance

class c_character_instance {
public:
    c_skeleton_pose* get_skeleton_pose() {
        return (c_skeleton_pose*)(reinterpret_cast<uptr>(this) + 0xA80);
    }
};

CSkeletonPose:

class c_skeleton_pose {
public:
    quat_t get_abs_joint_by_id(i32 joint_id) {
        return memory->read<quat_t>(memory->read<uptr>(reinterpret_cast<uptr>(this) + 0x1B8) + 0x1C * joint_id);
    }
};

CGameCVars:

class c_game_cvars {
public:
    static c_game_cvars* get_instance() {
        return memory->read<c_game_cvars*>(0x142A97CE8);
    }

    i32 get_victory_condition() {
        return memory->read<i32>(reinterpret_cast<uptr>(this) + 0x8E0);
    }

    bool is_pve() {
        return get_victory_condition() == 3;
    }

    const char* get_game_mode_name() {
        auto vc = get_victory_condition();
        if (vc == 3)
            return "PVE";

        if ((vc >= 1 && vc <= 2) || (vc >= 4 && vc <= 11))
            return "PVP";

        return "LOBBY";
    }
};