Вопрос Сломался авол

LittleDed · Четверг в 17:34

после апдейтов игры в определнный момент отвалился авол, не знаю что делать

autowall.cpp:

#include "../../Precompiled.h"

float CalcLengthMod(TraceData_t* pTraceData) {
    using fnCalcLengthMod = float(__fastcall*)(TraceData_t*);
    static fnCalcLengthMod CalcLengthModFunc = reinterpret_cast<fnCalcLengthMod>(
        Memory::FindPattern(CLIENT_DLL, X("40 53 48 83 EC ? 48 8B D9 48 81 C1 ? ? ? ? E8 ? ? ? ? 48 63 83"))
        );

    return CalcLengthModFunc(pTraceData);
}

int CAutowall::CFunctions::CFireBullet::FireBullet( Vector vecStart, Vector vecEnd, C_CSPlayerPawn* pTargetPawn )
{
    float flDamage = static_cast<float>( LocalPlayerData::m_pWeaponBaseVData->m_nDamage( ) );

    TraceData_t objTraceData{};
    objTraceData.m_ArrPointer = &objTraceData.m_Arr;

    TraceFilter_t mFilter( 0x1C300Bu, Globals::m_pLocalPlayerPawn, nullptr, 3 );

    HandleBulletDataObj_t objHandleBulletData = { };
    objHandleBulletData.m_bFailed = false;
    objHandleBulletData.m_flDmg = flDamage;
    objHandleBulletData.m_flPen = LocalPlayerData::m_pWeaponBaseVData->m_flPenetration( );
    objHandleBulletData.m_flRange = LocalPlayerData::m_pWeaponBaseVData->m_flRange( );
    objHandleBulletData.m_flRangeMod = LocalPlayerData::m_pWeaponBaseVData->m_flRangeModifier( );
    objHandleBulletData.m_iPenCount = 4;

    const Vector vecDirection = vecEnd - vecStart;
    Vector vecEndPos = vecDirection * LocalPlayerData::m_pWeaponBaseVData->m_flRange( );

    //g_Autowall->m_RebuiltFunctions.m_TraceToExit.TraceToExit(&objTraceData, vecStart, vecEndPos, mFilter, objHandleBulletData.m_iPenCount, pTargetPawn);
    Interfaces::m_pVPhys2World->TraceToExit( &objTraceData, vecStart, vecEndPos, mFilter, objHandleBulletData.m_iPenCount );

    CTraceInfo* pTraceInfo = nullptr;

    objHandleBulletData.m_flRange = objTraceData.m_vecEnd.Length( );
    g_Autowall->m_Functions.m_TestSurfaces.TestSurfaces( &objTraceData, flDamage, LocalPlayerData::m_pWeaponBaseVData->m_flPenetration( ), LocalPlayerData::m_pWeaponBaseVData->m_flRangeModifier( ), objHandleBulletData.m_iPenCount, Globals::m_pLocalPlayerPawn->m_iTeamNum( ) );
    //g_Autowall->m_RebuiltFunctions.m_TestSurfaces.TestSurfaces(&objTraceData, flDamage, LocalPlayerData::m_pWeaponBaseVData->m_flPenetration(), LocalPlayerData::m_pWeaponBaseVData->m_flRangeModifier(), objHandleBulletData.m_iPenCount, Globals::m_pLocalPlayerPawn->m_iTeamNum(), 0);
    for ( int i = 0; i < objTraceData.m_nSurfaces; i++ )
    {
        CTraceInfo& objTraceInfo = objTraceData.m_pTraceInfo[ i ];
        const bool bShouldBreak = Interfaces::m_pVPhys2World->HandleBulletPenetration( &objTraceData, &objHandleBulletData, &objTraceInfo, static_cast<uint8_t>( Globals::m_pLocalPlayerPawn->m_iTeamNum( ) ) );

        objTraceInfo.m_flDamage = objHandleBulletData.m_flDmg;
        objTraceInfo.m_flCurrentLengthMod = objHandleBulletData.m_flRange;

        if ( bShouldBreak )
            break;

        GameTrace_t objTrace{};
        objTraceInfo.m_flPreviousLengthMod = 0.f;
        Interfaces::m_pVPhys2World->InitTraceInfo( &objTrace );
        Interfaces::m_pVPhys2World->GetTraceInfo( &objTraceData, &objTrace, &objTraceInfo );

        if ( objTrace.m_pHitEntity && objTrace.m_pHitEntity == pTargetPawn )
        {
            flDamage = objTraceInfo.m_flDamage;

            if ( flDamage > 0 )
                g_Autowall->m_Functions.m_ScaleDamage.ScaleDamage( objTrace.m_pHitEntity, LocalPlayerData::m_pWeaponBaseVData, objTrace.GetHitgroup( ), flDamage );

            return static_cast<int>( flDamage );
        }
    }


    return 0;
}

int CAutowall::CalculateDamage( C_CSPlayerPawn* pTargetPawn, C_CSWeaponBaseGun* pBaseGun, Vector vecEnd )
{
    return g_Autowall->m_Functions.m_FireBullet.FireBullet( Globals::m_pLocalPlayerPawn->GetEyePosition( true )/*g_PredictionSystem->GetEyePos()*/, vecEnd, pTargetPawn );
}

struct TraceResult_t
{
    Vector m_vecEndPos;
    char unk1[28];
};

unsigned __int8 sub_61C8A0(void* a1, void* a2, __int64 a3, unsigned __int8 a4)
{
    using sub_61C8A0Fn = unsigned __int8(__fastcall*)(void*, void*, __int64, unsigned __int8);
    static sub_61C8A0Fn sub_61C8A0 = reinterpret_cast<sub_61C8A0Fn>(
        Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, X("E8 ? ? ? ? 48 8B 5C 24 ? 48 8B 6C 24 ? 48 8B 74 24 ? 0F 28 74 24 ? 48 83 C4 ? 5F C3 CC CC CC 48 89 5C 24")), 0x1, 0x0)
        );

    return sub_61C8A0(a1, a2, a3, a4);
}

Vector* NormalizeVectorInPlace(Vector* vector)
{
    using NormalizeVectorInPlaceFn = Vector * (__fastcall*)(Vector*);
    static NormalizeVectorInPlaceFn NormalizeVectorInPlace = reinterpret_cast<NormalizeVectorInPlaceFn>(
        Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, X("E8 ? ? ? ? F2 0F 10 0B 4C 8B C3")), 0x1, 0x0)
        );

    return NormalizeVectorInPlace(vector);
}

bool FillTraceData(TraceData_t* pTraceData, TraceResult_t* pTraceResult)
{
    using FillTraceDataFn = bool(__fastcall*)(TraceData_t*, TraceResult_t*);
    static FillTraceDataFn FillTraceDataFunc = reinterpret_cast<FillTraceDataFn>(
        Memory::FindPattern(CLIENT_DLL, X("40 55 41 54 41 55 41 56 41 57 48 8B EC"))
        );

    return FillTraceDataFunc(pTraceData, pTraceResult);
}

static bool CheckHitboxesWrapper(CVPhys2World* pVPhys2World, TraceData_t* pTraceData, Vector* vecStart, TraceResult_t* pTraceResult, int64_t* pTraceMask, int nMagicNumber)
{
    using CheckHitboxesWrapperFn = char(__fastcall*)(CVPhys2World*, TraceData_t*, Vector*, TraceResult_t*, int64_t*, int);
    static CheckHitboxesWrapperFn CheckHitboxesWrapperFunc = reinterpret_cast<CheckHitboxesWrapperFn>(
        Memory::FindPattern(CLIENT_DLL, X("48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 57 48 83 EC ? 48 8B 09"))
        );

    return CheckHitboxesWrapperFunc(pVPhys2World, pTraceData, vecStart, pTraceResult, pTraceMask, nMagicNumber);
}

namespace Interfaces
{
    class CCSHitboxSystem
    {
    public:
        __int64(__fastcall** ppfunc0)(__int64, TraceData_t*, __int64, Vector*, TraceResult_t*, int, int, __int64, int);
        MEM_PAD(0x28);
        int* m_pEntityList;
    public:
        bool HandleEntityList(TraceData_t* pTraceData, Vector* vecStart, TraceResult_t* pTraceResult, __int64 nTraceMask, int nMagicNumber)
        {
            using fnHandleEntityList = bool(__fastcall*)(CCSHitboxSystem*, TraceData_t*, Vector*, TraceResult_t*, __int64, int, int);
            static auto HandleEntityList_INTERNAL = reinterpret_cast<fnHandleEntityList>(Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, "E8 ? ? ? ? 84 C0 74 ? 48 63 03"), 0x1, 0x0));

            return HandleEntityList_INTERNAL(this, pTraceData, vecStart, pTraceResult, nTraceMask, 0, nMagicNumber);;
        }


    };

    CCSHitboxSystem* m_pHitboxSystem = nullptr;
}


static bool HandleEntityListRebuilt(C_CSPlayerPawn* pTargetPawn, Vector* vecStart, TraceResult_t* pTraceResult, TraceData_t* pTraceData, int nMagicNumber, int64_t* pTraceMask)
{
    using fnSetTraceData = __int64(__fastcall*)(TraceData_t*, void*);
    static fnSetTraceData SetTraceData = (fnSetTraceData)Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, "E8 ? ? ? ? 8B 85 ? ? ? ? 48 8D 54 24 ? F2 0F 10 45"), 0x1, 0x0);

    GameTrace_t objGameTrace = GameTrace_t();
    TraceFilter_t objFilter = TraceFilter_t(0x1C3003, Globals::m_pLocalPlayerPawn, nullptr, 4);
    Ray_t objRay = Ray_t();

    auto pCollisionProperty = Memory::CallVFunc<__int64, 57>(pTargetPawn);
    Matrix3x4_t v31 = *(Matrix3x4_t*)(pCollisionProperty + 0x18);
    
    Interfaces::m_pVPhys2World->TraceShape(&objRay, *vecStart, pTraceResult->m_vecEndPos, &objFilter, &objGameTrace);
    bool bHitPlayer = objGameTrace.m_pHitEntity == pTargetPawn;
    if (bHitPlayer)
    {
        SetTraceData(pTraceData, &v31);

        pTraceResult->m_vecEndPos = objGameTrace.m_vecEndPos;
    }
    return bHitPlayer;
}

char __fastcall CheckHitboxesWrapperRebuilt(CVPhys2World* pVPhys2World, TraceData_t* pTraceData, Vector* vecStart, TraceResult_t* pTraceResult, uint64_t* pTraceMask, int nMagicNumber, C_CSPlayerPawn* pTargetPawn)
{
    Memory::CallVFunc<unsigned int, 263>(*(void**)pVPhys2World, pTraceData, vecStart, &pTraceResult->m_vecEndPos, (void*)pTraceMask, true, nMagicNumber);

    // obiot too lazy to add to interfaces
    if (!Interfaces::m_pHitboxSystem)
        Interfaces::m_pHitboxSystem = *(Interfaces::CCSHitboxSystem**)(Memory::ResolveRelativeAddress(Memory::FindPattern(CLIENT_DLL, "48 8B 0D ? ? ? ? 4C 8B CE F3 0F 11 74 24"), 0x3, 0x7));

    using fnUpdateBuffer = unsigned __int8(__fastcall*)(void*, void*, __int64, unsigned __int8);
    static auto UpdateBuffer = reinterpret_cast<fnUpdateBuffer>(Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, "E8 ? ? ? ? 49 8B EF 48 8B C5 48 2B C7 48 3D"), 0x1, 0x0));

    using fnHandleEntityList = bool(__fastcall*)(Interfaces::CCSHitboxSystem*, TraceData_t*, Vector*, TraceResult_t*, __int64, int, int);
    static auto HandleEntityList = reinterpret_cast<fnHandleEntityList>(Memory::GetAbsoluteAddress(Memory::FindPattern(CLIENT_DLL, "E8 ? ? ? ? 84 C0 74 ? 48 63 03"), 0x1, 0x0));

    bool result = *pTraceMask >> 1;
    if ((*pTraceMask & 2))
    {
        //result = HandleEntityListRebuilt(pTargetPawn, vecStart, pTraceResult, pTraceData, nMagicNumber, pTraceMask);
        result = HandleEntityList(Interfaces::m_pHitboxSystem, pTraceData, vecStart, pTraceResult, (__int64)pTraceMask, 0, nMagicNumber);
        if (result)
        {
            return UpdateBuffer(
                pTraceData->m_ArrPointer,
                &((char*)pTraceData->m_ArrPointer)[sizeof(TraceArrElement_t) * pTraceData->m_uk1],
                pTraceData->m_uk1,
                (unsigned __int8)pTraceMask
            );
        }
    }
    return result;
}


// WIP ^^^^^

bool CAutowall::CRebuiltFunctions::CTraceToExit::TraceToExit(TraceData_t* pTraceData, Vector& vecStart, Vector& vecEnd, TraceFilter_t mTraceFilter, int iPenCount, C_CSPlayerPawn* pTargetPawn)
{
    if (!pTraceData)
        return false;

    TraceResult_t objTraceResult = { };

    pTraceData->m_vecStart = vecStart;

    objTraceResult.m_vecEndPos = vecEnd;

    FillTraceData(pTraceData, &objTraceResult);

    //CheckHitboxesWrapper(Interfaces::m_pVPhys2World, pTraceData, &vecStart, &objTraceResult, &mTraceFilter.m_uTraceMask, -1.0f);
    CheckHitboxesWrapperRebuilt(Interfaces::m_pVPhys2World, pTraceData, &vecStart, &objTraceResult, &mTraceFilter.m_uTraceMask, -1.0f, pTargetPawn);

    return FillTraceData(pTraceData, &objTraceResult);
}

void CAutowall::CFunctions::CScaleDamage::ScaleDamage(C_CSPlayerPawn* pPawn, CCSWeaponBaseVData* pWeaponVData, int iHitGroup, float& flDamage)
{
    const float damage_scale_ct_head = Convar::mp_damage_scale_ct_head->GetFloat();
    const float damage_scale_t_head = Convar::mp_damage_scale_t_head->GetFloat();
    const float damage_scale_ct_body = Convar::mp_damage_scale_ct_body->GetFloat();
    const float damage_scale_t_body = Convar::mp_damage_scale_t_body->GetFloat();

    const bool bIsCT = pPawn->m_iTeamNum() == 3;
    const bool bIsT = pPawn->m_iTeamNum() == 2;

    const float head_damage_scale = bIsCT
        ? damage_scale_ct_head
        : (bIsT ? damage_scale_t_head : 1.0f);

    const float body_damage_scale = bIsCT
        ? damage_scale_ct_body
        : (bIsT ? damage_scale_t_body : 1.0f);

    switch (iHitGroup) {
    case HITGROUP_HEAD:
        flDamage *= pWeaponVData->m_flHeadshotMultiplier() * head_damage_scale;
        break;
    case HITGROUP_NECK:
        flDamage *= body_damage_scale;
        break;
    case HITGROUP_STOMACH:
        flDamage *= 1.25f * body_damage_scale;
        break;
    case HITGROUP_LEFTLEG:
    case HITGROUP_RIGHTLEG:
        flDamage *= 0.75f * body_damage_scale;
        break;
    default:
        break;
    }

    if (!pPawn->IsArmored(iHitGroup))
        return;

    constexpr float heavy_armor_bonus = 1.0f;
    constexpr float armor_bonus = 0.5f;
    const float armor_ratio = pWeaponVData->m_flArmorRatio() * 0.5f;

    float damage_to_health = flDamage * armor_ratio;
    const float damage_to_armor = (flDamage - damage_to_health) * (heavy_armor_bonus * armor_bonus);

    if (damage_to_armor > static_cast<float>(pPawn->m_ArmorValue()))
        damage_to_health = flDamage - static_cast<float>(pPawn->m_ArmorValue()) / armor_bonus;

    flDamage = damage_to_health;
}

autowall.h:

#pragma once

//namespace Autowall
//{
//    int ScaleDamage2(int hitgroup, C_CSPlayerPawn* entity, CCSWeaponBaseVData* weapon_data, int& damage);
//
//    float GetHitgroupDamageMultiplier(float flHeadshotMultiplier, int iHitgroup);
//    int ScaleDamage(int curDmg, int hitgroup, C_CSPlayerPawn* ent, CCSWeaponBaseVData* wpData);
//    void TestSurfaces(TraceData_t* pTraceData, float flDamage, float flPenetration, float flRangeModifier, int nPenetrationCount, int nTeamNum, std::int64_t sv_showimpacts_penetration);
//    int Firebullet(Vector Start, Vector End, C_CSPlayerPawn* lp, C_CSPlayerPawn* target, CCSWeaponBaseVData* wpData);
//    float CalculateDamage(C_CSPlayerPawn* target, C_CSWeaponBaseGun* gun, Vector targetPos);
//}

class CAutowall
{
public:
    class CRebuiltFunctions
    {
    public:
        class CTraceToExit
        {
        public:
            void PenTest(C_CSPlayerPawn* pTarget, Vector vShootPos, Vector vPoint);

            bool TraceToExit(TraceData_t* pTraceData, Vector& vecStart, Vector& vecEnd, TraceFilter_t mTraceFilter, int iPenCount, C_CSPlayerPawn* pTargetPawn);
        }; CTraceToExit m_TraceToExit;

        class CTestSurfaces
        {
        public:
            void TestSurfaces(TraceData_t* pTraceData, double flDamage, double flPenetration, double flRangeModifier, int iPenCount, int nTeamNum, __int64 sv_showimpacts_penetration);
        }; CTestSurfaces m_TestSurfaces;
    }; CRebuiltFunctions m_RebuiltFunctions;

    class CFunctions
    {
    public:
        class CScaleDamage
        {
        public:
            void ScaleDamage(C_CSPlayerPawn* pPawn, CCSWeaponBaseVData* pWeaponVData, int iHitGroup, float& iDamage);
        }; CScaleDamage m_ScaleDamage;


        class CFireBullet
        {
        public:
            int FireBullet(Vector vecStart, Vector vecEnd, C_CSPlayerPawn* pTargetPawn);
        }; CFireBullet m_FireBullet;

        class CTestSurfaces
        {
        public:
            void TestSurfaces(TraceData_t* pTraceData, float flDamage, float flPenetration, float flRangeModifier, int nPenetrationCount, int nTeamNum)
            {
                using fnTestSurfaces = void(__fastcall*)(TraceData_t*, float, float, float, int, int, __int64);
                static const fnTestSurfaces oTestSurfaces = reinterpret_cast<fnTestSurfaces>(Memory::FindPattern(CLIENT_DLL, X("40 53 57 41 56 48 83 EC 50 8B")));

                return oTestSurfaces(pTraceData, flDamage, flPenetration, flRangeModifier, nPenetrationCount, nTeamNum, 0);
            }
        }; CTestSurfaces m_TestSurfaces;

    }; CFunctions m_Functions;

    class CStructs
    {
    public:
        /*struct HandleBulletDataObj_t
        {
            float m_flDmg;
            float m_flPen;
            float m_flRangeMod;
            float m_flRange;

            int m_iPenCount;

            bool m_bFailed;
        };*/

    }; CStructs m_Structs;

    int CalculateDamage(C_CSPlayerPawn* pTargetPawn, C_CSWeaponBaseGun* pBaseGun, Vector vecEnd);

    int MaxPossibleDamageToHitbox(C_CSPlayerPawn* pTargetPawn, int iHitGroup, float iWeaponDamage) {

        auto copy = iWeaponDamage;

        m_Functions.m_ScaleDamage.ScaleDamage(pTargetPawn, LocalPlayerData::m_pWeaponBaseVData, iHitGroup, copy);
        return copy;
    }
};

inline std::unique_ptr<CAutowall> g_Autowall = std::make_unique<CAutowall>();

verteich · Пятница в 14:18

LittleDed написал(а):
определнный момент отвалился авол, не знаю что делать

Дебаж, узнай где обваливается код и оттуда действуй уже.

Jadovran · Пятница в 14:38

verteich написал(а):
Дебаж, узнай где обваливается код и оттуда действуй уже.

ахуеть спасибо папаша

Вопрос Сломался авол

Похожие темы