Авто волл (хелп

[Xeroza]

короче делаю свой чит перенес с darkside авто волл а он дерьмовый какойто короче не все стены простреливает , простреливает стены толстые которые незя короче хочу попросить норм авто волл у кого есть а так вот код мой
#include "../../Precompiled.h"

// COMPLETE AUTOWALL IMPLEMENTATION FROM darkside-sdk-fix-main
// Fully adapted to work with this project's structure

void CAutowall::CFunctions::CScaleDamage::ScaleDamage(int hitgroup, C_CSPlayerPawn* entity, CCSWeaponBaseVData* weapon_data, float& damage)
{
CONVAR(mp_damage_scale_ct_head);
CONVAR(mp_damage_scale_t_head);
CONVAR(mp_damage_scale_ct_body);
CONVAR(mp_damage_scale_t_body);

float damage_scale_ct_head = mp_damage_scale_ct_head->GetFloat();
float damage_scale_t_head = mp_damage_scale_t_head->GetFloat();
float damage_scale_ct_body = mp_damage_scale_ct_body->GetFloat();
float damage_scale_t_body = mp_damage_scale_t_body->GetFloat();

const bool is_ct = entity->m_iTeamNum() == 3;
const bool is_t = entity->m_iTeamNum() == 2;

float head_damage_scale = is_ct ? damage_scale_ct_head : is_t ? damage_scale_t_head : 1.f;
const float body_damage_scale = is_ct ? damage_scale_ct_body : is_t ? damage_scale_t_body : 1.f;

switch (hitgroup)
{
case HITGROUP_HEAD:
damage *= weapon_data->m_flHeadshotMultiplier() * head_damage_scale;
break;
case HITGROUP_CHEST:
case HITGROUP_LEFTARM:
case HITGROUP_RIGHTARM:
case HITGROUP_NECK:
damage *= body_damage_scale;
break;
case HITGROUP_STOMACH:
damage *= 1.25f * body_damage_scale;
break;
case HITGROUP_LEFTLEG:
case HITGROUP_RIGHTLEG:
damage *= .75f * body_damage_scale;
break;
default:
break;
}

if (!entity->IsArmored(hitgroup))
return;

float heavy_armor_bonus = 1.f;
float armor_bonus = .5f;
float armor_ratio = weapon_data->m_flArmorRatio() * .5f;

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

if (damage_to_armor > static_cast<float>(entity->m_ArmorValue()))
damage_to_health = damage - static_cast<float>(entity->m_ArmorValue()) / armor_bonus;

damage = damage_to_health;
}

bool CAutowall::CFunctions::CFireBullet::FireBullet(Vector start, Vector end, penetration_data_t* pen_data, C_CSPlayerPawn* target, bool is_taser)
{
C_CSPlayerPawn* local_player = Globals::m_pLocalPlayerPawn;

if (!local_player)
return false;

auto weapon_data = LocalPlayerData::m_pWeaponBaseVData;
if (!weapon_data)
return false;

TraceData_t trace_data = TraceData_t();
trace_data.m_ArrPointer = &trace_data.m_Arr;

Vector direction = end - start;
Vector end_pos = direction * weapon_data->m_flRange();

const TraceFilter_t filter(0x1C300B, local_player, nullptr, 3);
Interfaces::m_pVPhys2World->TraceToExit(&trace_data, start, end_pos, filter, 4);

HandleBulletDataObj_t handle_bullet_data(
static_cast<float>(weapon_data->m_nDamage()),
weapon_data->m_flPenetration(),
weapon_data->m_flRange(),
weapon_data->m_flRangeModifier(),
4,
false
);

float max_range = weapon_data->m_flRange();
pen_data->m_damage = static_cast<float>(weapon_data->m_nDamage());

for (int i = 0; i < trace_data.m_nSurfaces; i++)
{
UpdateValue_t* modulate_values = reinterpret_cast<UpdateValue_t* const>(
reinterpret_cast<std::uintptr_t>(trace_data.pointer_update_value) + i * sizeof(UpdateValue_t)
);

GameTrace_t game_trace;
Interfaces::m_pVPhys2World->InitTraceInfo(&game_trace);
Interfaces::m_pVPhys2World->GetTraceInfo(
&trace_data,
&game_trace,
0.0f,
reinterpret_cast<void*>(
reinterpret_cast<std::uintptr_t>(trace_data.m_Arr) +
sizeof(trace_array_element_t) * (modulate_values->m_HandleIdx & ENT_ENTRY_MASK)
)
);

if (game_trace.m_pHitEntity && game_trace.m_pHitEntity->IsPlayerPawn())
{
if (pen_data->m_damage < 1.f)
continue;

g_Autowall->m_Functions.m_ScaleDamage.ScaleDamage(
game_trace.GetHitgroup(),
game_trace.m_pHitEntity,
weapon_data,
pen_data->m_damage
);

pen_data->m_hitbox = game_trace.GetHitboxId();
pen_data->m_penetrated = i == 0;

if (is_taser && pen_data->m_penetrated)
break;

return true;
}

if (Interfaces::m_pVPhys2World->HandleBulletPenetration(
&trace_data,
&handle_bullet_data,
modulate_values,
static_cast<int>(local_player->m_iTeamNum())
))
break;

pen_data->m_damage = handle_bullet_data.m_flDmg;
}

return false;
}

int CAutowall::CalculateDamage(C_CSPlayerPawn* pTargetPawn, C_CSWeaponBaseGun* pBaseGun, Vector vecEnd)
{
return 0;
}

// Helper structures and functions for TraceToExit fallback
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 56 41 54 41 55 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;
}

bool __fastcall CheckHitboxesWrapperRebuilt(CVPhys2World* pVPhys2World, TraceData_t* pTraceData, Vector* vecStart, TraceResult_t* pTraceResult, uint64_t* pTraceMask, int nMagicNumber)
{
using fn = bool(__fastcall*)(CVPhys2World*, TraceData_t*, Vector*, TraceResult_t*, uint64_t*, int);
static fn x = (fn)Memory::FindPattern(CLIENT_DLL, "48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 57 48 83 EC ? 48 8B 09");
return x(pVPhys2World, pTraceData, vecStart, pTraceResult, pTraceMask, nMagicNumber);
}

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);
CheckHitboxesWrapperRebuilt(Interfaces::m_pVPhys2World, pTraceData, &vecStart, &objTraceResult, &mTraceFilter.m_uTraceMask, -1.0f);

return FillTraceData(pTraceData, &objTraceResult);
}