Гайд Asphyxia base fix Visible check

[pasterok1181881]

// used: game trace manager
#include "cgametracemanager.h"
// used: c_csplayerpawn
#include "../../sdk/entity.h"

uint8_t* initAddr = 0;
bool GameTrace_t::IsVisible() const
{
    return (m_flFraction > 0.97f);
}
TraceFilter_t::TraceFilter_t(std::uint64_t uMask, C_CSPlayerPawn* pSkip1, C_CSPlayerPawn* pSkip2, int nLayer)
{
    try
    {
        using fnInitFilter = __int64(__fastcall*)(
            void*,              // a1 (this / TraceFilter_t*)
            C_CSPlayerPawn*,     // a2
            uint64_t,           // a3
            uint8_t,            // a4
            uint8_t             // a5
            );

        if (initAddr == 0)
        {
            initAddr  = MEM::FindPattern(
                CLIENT_DLL,
                CS_XOR("48 89 5C 24 ? 48 89 74 24 ? 57 48 83 EC ? 0F B6 41 ? 33 FF 24")

            );
        
        }

        if (!initAddr) {
            printf("InitTraceFilter not found\n");
            return;
        }

        fnInitFilter fn = reinterpret_cast<fnInitFilter>(initAddr);

        fn(this, pSkip1, uMask, (uint8_t)nLayer, 7);
    }
    catch (...)
    {

    }
}

#pragma once
// used: pad and findpattern
#include "../../utilities/memory.h"
// used: vector
#include "../../sdk/datatypes/vector.h"
// used: array
#include <array>

// used: game trace manager

// used: c_csplayerpawn
#include "../../sdk/entity.h"
struct Ray_t{
    Vector_t  m_Start;
    Vector_t  m_End;
    Vector_t  m_Mins;
    Vector_t  m_Maxs;
    uint8_t pad[0x4];
    std::uint8_t UnkownType = 0x0;

    Ray_t() = default;

    Ray_t(const Vector_t & start, const Vector_t & 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;
    TraceFilter_t() = default;
    TraceFilter_t(std::uint64_t uMask, C_CSPlayerPawn* pSkip1, C_CSPlayerPawn* pSkip2, int nLayer);
};

struct SurfaceData_t
{
public:
    uint8_t pad[0x8];
    float m_flPenetrationModifier;
    float m_flDamageModifier;
    uint8_t pad2[0x4];
    int m_iMaterial;
};

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

struct GameTrace_t
{
public:
    GameTrace_t() = default;

 
    bool IsVisible() const;

    void* m_pSurface;
    C_CSPlayerPawn* m_pHitEntity;
    TraceHitboxData_t* m_pHitboxData;
    uint8_t pad[0x38];
    std::uint32_t m_uContents;
    uint8_t pad2[0x24];
    Vector_t  m_vecStartPos;
    Vector_t  m_vecEndPos;
    Vector_t  m_vecNormal;
    Vector_t  m_vecPosition;
    uint8_t pad3[0x4];;
    float m_flFraction;
    uint8_t pad4[0x6];
    bool m_bAllSolid;
    uint8_t pad5[0x4D];
};


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

    static inline void* GetTraceManager() {
        static void* ptr = []() -> void* {
            uint8_t* addr = MEM::FindPattern(
                CLIENT_DLL,
                CS_XOR("48 8B 1D ? ? ? ? 48 8B 01 FF 90 ? ? ? ? 4C 8B 0B 4C 8D 44 24 ? 48 8B 94 24")
            );

            if (!addr) {
                L_PRINT(LOG_INFO) << CS_XOR("Trace::TraceShape: GetTraceManager() returned Pattern nullptr");
                return nullptr;
            }

            int offset = *(int*)(addr + 3);
            uint8_t* global = addr + 7 + offset;

            return *(void**)global;
            }();

        return ptr;
    }

    static inline fnTraceShape GetFn() {
        static fnTraceShape fn = []() -> fnTraceShape {
            uint8_t* addr = MEM::FindPattern(

                CLIENT_DLL,
                CS_XOR("48 89 5C 24 ? 48 89 4C 24 ? 55 57"));



            if (!addr) {
                L_PRINT(LOG_INFO) << CS_XOR("Trace::TraceShape: GetFn() returned Pattern nullptr");
                return nullptr;
            }

            return reinterpret_cast<fnTraceShape>(addr);
            }();

        return fn;
    }

    static inline bool TraceShape(
        Ray_t& ray,
        Vector_t* start,
        Vector_t* end,
        TraceFilter_t& filter,
        GameTrace_t& trace
    ) {
        return GetFn()(GetTraceManager(), &ray, start, end, &filter, &trace);
    }
};

пример как использовать добавляем в aim.cpp
Vector_t vecPos = pPawn->GetEyePosition();

Vector_t vecStart = pLocalPawn->GetEyePosition();
Vector_t vecEnd = pPawn->GetEyePosition();
alignas(16) Ray_t ray {};

TraceFilter_t filter(0x1C3003, pLocalPawn, nullptr, 3);

GameTrace_t trace{};

Trace::TraceShape(ray, &vecStart, &vecEnd, filter, trace);
забыл добавляем еще aim.cpp после trace::traceshape
if (trace.m_pHitEntity != pPawn || !trace.IsVisible())

continue;