Wall hack repair

[kingwolf1426]

I used to use poly wallhack and code, it worked easily with the offset update, but now only Trigger bot works and Wallhack is out of order. Can anyone help me fix it?

esp;

#ifndef ESP_H
#define ESP_H

#include "Engine.h"
#include "Settings.h"

struct GlowObjectDefinition_t
{
DWORD dwBase;
float r;
float g;
float b;
float a;
uint8_t unk1[16];
bool m_bRenderWhenOccluded;
bool m_bRenderWhenUnoccluded;
bool m_bFullBloom;
uint8_t unk2[14];
};

class ESP {
[junk_enable /]

public:
void run() {
[swap_lines]
int objectCount;
DWORD pointerGlow;
float playerhp;
bool enemyHealthBased = Settings()->esp_enemyhealth;
bool friendHealthBased = Settings()->esp_friendhealth;
float alphaFriend = sanitizeChannel(Settings()->esp_friend);
float alphaEnemy = sanitizeChannel(Settings()->esp_enemy);
float alphaInX = sanitizeChannel(Settings()->esp_enemyInX);
[/swap_lines]
if (!(Settings()->esp_key || Settings()->espEnabled)) {
return;
}
while (true) {
[add_junk /]
if (!Settings()->espEnabled) {
continue;
Sleep(20);
}
[add_junk /]
pointerGlow = Engine()->Memory()->Read<DWORD>(Engine()->getClientModule()->dwBase + Engine()->Offsets()->dwGlow);
objectCount = Engine()->Memory()->Read<DWORD>(Engine()->getClientModule()->dwBase + Engine()->Offsets()->dwGlow + 0x4);
if (!(pointerGlow != NULL && objectCount > 0)) {
continue;
Sleep(20);
}
[add_junk /]
for (int i = 0; i < objectCount; i++) {
[add_junk /]
DWORD mObj = pointerGlow + (i * sizeof(GlowObjectDefinition_t));
GlowObjectDefinition_t glowObj = Engine()->Memory()->Read<GlowObjectDefinition_t>(mObj);
Entity* Player = Engine()->getEntityByBase(glowObj.dwBase);
if (!(glowObj.dwBase && Player && !Player->is_dormant && Player->is_alive)) {
continue;
}
[add_junk /]
// Player->hp can be greater than 100.0f on custom servers.
playerhp = Player->hp >= 100 ? 100.0f : (float) Player->hp / 100.0f;
if (Engine()->me.team == Player->team) {
glowPlayer(glowObj, 0, friendHealthBased ? (Player->hp > 75 ? 1 : playerhp * 0.75f) : 0, 1, alphaFriend);
} else if (inCrosshair(Player->id)) {
glowPlayer(glowObj, 0, 1, 0, alphaInX);
} else {
glowPlayer(glowObj, 1, enemyHealthBased ? (Player->hp > 75 ? 1 : playerhp * 0.75f) : 0, 0, alphaEnemy);
}
Engine()->Memory()->Write<GlowObjectDefinition_t>(mObj, glowObj);
[add_junk /]
}
[add_junk /]
Sleep(1);
}
[add_junk /]
}

private:
void glowPlayer(GlowObjectDefinition_t &glowObj, float r, float g, float b, float a) {
[swap_lines]
glowObj.r = r;
glowObj.g = g;
glowObj.b = b;
glowObj.a = a;
glowObj.m_bRenderWhenOccluded = true;
//glowObj.m_bRenderWhenUnoccluded = false;
//glowObj.m_bFullBloom = false;
[/swap_lines]
}
bool inCrosshair(int mObjId) {
[add_junk /]
int idInX = Engine()->Memory()->Read<int>(Engine()->me.dwBase + Engine()->Offsets()->dwInCross);
return (idInX == mObjId);
}
float sanitizeChannel(int value) {
[swap_lines]
if (value > 255) value = 255;
if (value < 0) value = 0;
[/swap_lines]
return (float) value / 255;
}

[junk_disable /]
};

#endif

#include "Offsets.h"

#include <iostream>

[junk_enable /]
[enc_string_enable /]

[swap_blocks]

[block]
std::string COffsets::toHex(DWORD offset) {
std::stringstream ss;
ss << std::hex << offset;
std::string x = ss.str();
for (auto &c : x) c = toupper(c);

return x;
}
[/block]

[block]
void COffsets::getOffsets(PMemory* m) {
mem = m;

modClient = mem->GetModule("client.dll");
modEngine = mem->GetModule("engine.dll");

[swap_lines]
updateEnginePointer();
updateSetViewAngle();
[/swap_lines]
}
[/block]





[block]
void COffsets::updateEnginePointer() {
DWORD epStart = mem->FindPatternArr(modEngine.dwBase, modEngine.dwSize, "x????xxx?x?xxxx", 15, 0xA1, 0x0, 0x0, 0x0, 0x0, 0x33, 0xD2, 0x6A, 0x0, 0x6A, 0x0, 0x33, 0xC9, 0x89, 0xB0);
dwEnginePointer = mem->Read<DWORD>(epStart + 1) - modEngine.dwBase;

}
[/block]

[block]
void COffsets::updateSetViewAngle() {
DWORD FGStart = mem->FindPatternArr(modEngine.dwBase, modEngine.dwSize, "xxxx????xxxxx?xxxx", 18, 0xF3, 0x0F, 0x11, 0x86, 0x0, 0x0, 0x0, 0x0, 0xF3, 0x0F, 0x10, 0x44, 0x24, 0x0, 0xF3, 0x0F, 0x11, 0x86);
dwSetViewAngle = mem->Read<DWORD>(FGStart + 4);
}
[/block]

#ifndef OFFSETS_H
#define OFFSETS_H

#include "PMemory.h"

#include <string>
#include <sstream>
#include "Decrypt.h"

class COffsets {
public:
[junk_enable 2 5 /]
[junk_enable_declares /]
[swap_lines]
DWORD dwEnginePointer;
DWORD dwSetViewAngle;

DWORD dwEntityList = 0x4DFFF14;
DWORD dwLocalPlayer = 0xDEA964; //
DWORD dwActiveWeapon = 0x2F08; //m_hActiveWeapon
DWORD dwWeaponId = 0x3340; //m_iWeaponID (m_fAccuracyPenalty + ???)
DWORD dwInCross = 0x11838; //m_iCrossHairID
DWORD dwSpotted = 0x93D; //m_bSpotted
DWORD dwId = 0x64; //m_dwIndex
DWORD dwHealth = 0x100; //m_iHealth
DWORD dwTeam = 0xF4; //m_iTeamNum
DWORD dwAmmo = 0x3274; //m_iClip1
DWORD dwVecPunch = 0x303C; //m_vecPunch (m_aimPunchAngle + m_local)
DWORD dwIShotsFired = 0x103E0; //m_iShotsFired
DWORD dwDormant = 0xED; //m_bDormant
DWORD dwFlags = 0x104; //m_fFlags
DWORD dwGlow = 0x535A9D8; //
DWORD dwAttack = 0x322DD10;//

std::string toHex(DWORD offset);

void getOffsets(PMemory* m);
[/swap_lines]
[junk_disable /]

private:
[swap_lines]
PMemory* mem;
PModule modClient, modEngine;

void updateEnginePointer();
void updateSetViewAngle();
[/swap_lines]

};

#endif

#include "Engine.h"

#include <iostream>

[junk_enable /]
[enc_string_enable /]

CEngine::CEngine() {
[swap_lines]
_modClient = { 0, 0 };
_modEngine = { 0, 0 };
_init = false;
[/swap_lines]
}

void CEngine::start() {
while (!mem.Attach("csgo.exe")) {
Sleep(100);
}
do {
Sleep(1000);
_ofs.getOffsets(&mem);
} while (_ofs.dwLocalPlayer < 65535);
if (_ofs.dwLocalPlayer > 4026531840) {

}
_init = true;
}

PModule* CEngine::getClientModule() {
if (_modClient.dwBase == 0 && _modClient.dwSize == 0) {
_modClient = mem.GetModule("client.dll");
}

return &_modClient;
}

PModule* CEngine::getEngineModule() {
if (_modEngine.dwBase == 0 && _modEngine.dwSize == 0) {
_modEngine = mem.GetModule("engine.dll");
}

return &_modEngine;
}

bool CEngine::initialized() {
return _init;
}

PMemory* CEngine::Memory() {
return &mem;
}

COffsets* CEngine::Offsets() {
return &_ofs;
}

void CEngine::update() {
Entity players[64];
while (true) {
DWORD playerBase = mem.Read<DWORD>(getClientModule()->dwBase + _ofs.dwLocalPlayer);
int hp = mem.Read<int>(playerBase + _ofs.dwHealth);
updateEntityData(&me, playerBase);

int cp = 0;

for (int i = 1; i < 64; i++) {
DWORD entBase = mem.Read<DWORD>((getClientModule()->dwBase + _ofs.dwEntityList) + i * 0x10);

if (entBase == NULL)
continue;

updateEntityData(&players[cp], entBase);

cp++;
}

int cf = 0, ce = 0;

for (int i = 0; i < cp; i++) {
if (players[i].team == me.team) {
entFriendlies[cf] = players[i];
cf++;
}
else {
entEnemies[ce] = players[i];
ce++;
}
}

iEnemies = ce;
iFriendlies = cf;

Sleep(1);
}
}

Entity* CEngine::getEntityByBase(DWORD dwBase) {
for (int i = 0; i < iFriendlies; i++) {
[add_junk /]
if (dwBase == entFriendlies[i].dwBase) {
return &entFriendlies[i];
}
}
for (int i = 0; i < iEnemies; i++) {
[add_junk /]
if (dwBase == entEnemies[i].dwBase) {
return &entEnemies[i];
}
}
return nullptr;
}

void CEngine::updateEntityData(Entity* e, DWORD dwBase) {
int dormant = mem.Read<int>(dwBase + _ofs.dwDormant);
e->dwBase = dwBase;
e->id = mem.Read<int>(dwBase + _ofs.dwId);
e->hp = mem.Read<int>(dwBase + _ofs.dwHealth);
e->team = mem.Read<int>(dwBase + _ofs.dwTeam);
e->is_dormant = dormant == 1;
e->is_alive = e->hp > 0 && e->team > 1 && e->team < 4;

DWORD hWeapon = mem.Read<DWORD>(dwBase + _ofs.dwActiveWeapon);
int weaponEntId = hWeapon & 0xFFF;
DWORD dwWeaponBase = mem.Read<DWORD>(_modClient.dwBase + _ofs.dwEntityList + (weaponEntId - 1) * 0x10);
e->weapon_id = mem.Read<int>(dwWeaponBase + _ofs.dwWeaponId);
e->weapon_ammo = mem.Read<int>(dwWeaponBase + _ofs.dwAmmo);
}

Thanks