It does not work after recent updates
iam update offsets and do not work again
Does anyone help to repair

code.
 
code
Engine.cpp
Code:
#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) {
        std::cout << "\n\nWARNING!!\nYou probably need to recompile these cheats with Polyloader 2.0.\n\n";
	}
	_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);
}
ENGINE.h
Code:
#ifndef ENGINE_H
#define ENGINE_H

#include <thread>

#include "PMemory.h"
#include "Offsets.h"

#include "Decrypt.h"

template <typename T, size_t N>
size_t countof(T (&array)[N]) {
    return N;
}

struct Entity {
	[swap_lines]
	DWORD dwBase;
	int id;
	int hp;
	int team;
	int weapon_id;
	int weapon_ammo;
	bool is_dormant;
	bool is_alive;
	[/swap_lines]
};

class CEngine {
public:
	[junk_enable 2 5 /]
	[junk_enable_declares /]
	[swap_lines]
	CEngine();

	void start();

	void update();

	bool initialized();

	PMemory* Memory();
	COffsets* Offsets();
	Entity* getEntityByBase(DWORD dwBase);

	PModule* getClientModule();
	PModule* getEngineModule();

	int iFriendlies;
	int iEnemies;
	Entity entEnemies[32];
	Entity entFriendlies[32];
	Entity me;
	[/swap_lines]
	[junk_disable /]

private:
	[junk_enable 2 5 /]
	[junk_enable_declares /]
	PMemory mem;
	PModule _modClient, _modEngine;
	COffsets _ofs;
	bool _init;

	void updateEntityData(Entity* e, DWORD dwBase);
	[junk_disable /]
};

inline CEngine* Engine() {
	static CEngine instance;
	[add_junk /]
	return &instance;
}

#endif
ESP.h
Code:
#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) {
                Sleep(3000);
                continue;
			}
            [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)) {
                Sleep(3000);
                continue;
            }
            [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(10);
		}
		[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
MAIN.cpp
Code:
#include <iostream>

#include "Engine.h"
#include "Settings.h"
#include "ESP.h"
#include "Triggerbot.h"
#include "Status.h"

[junk_enable /]
[enc_string_enable /]

int main() {
    Status()->credits();
    
	Settings()->writeConfig();
	
	std::cout << "Waiting for csgo.exe ... ";
	
	Engine()->start();
	std::thread engineThread(&CEngine::update, Engine());

	std::cout << "Found!\n\n";

	Sleep(10);
	
	std::thread settingsThread(&CSettings::run, Settings());
	
	Sleep(10);
	
	std::thread triggerThread(&Triggerbot::run, Triggerbot());
	std::thread espThread(&ESP::run, ESP());
    
    Sleep(10);
    
    Status()->refresh();

	while (KeyUp(Settings()->exit_key)) {
		Sleep(100);
	}

	exit(0);

	return 0;
}
offsets.cpp
Code:
#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", 13, 0xF3, 0x0F, 0x11, 0x80, 0x0, 0x0, 0x0, 0x0, 0xD9, 0x46, 0x04, 0xD9, 0x05);
	dwSetViewAngle = mem->Read<DWORD>(FGStart + 4);
}
[/block]
offsets.h
Code:
#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 = 0x4CE34DC;
	DWORD dwLocalPlayer = 0xCD2764; //
	DWORD dwActiveWeapon = 0x2EF8; //m_hActiveWeapon
	DWORD dwWeaponId = 0x3304; //m_iWeaponID (m_fAccuracyPenalty + ???)
	DWORD dwInCross = 0xB394; //m_iCrossHairID
	DWORD dwSpotted = 0x93D; //m_bSpotted
	DWORD dwId = 0xA3F8; //m_dwIndex
	DWORD dwHealth = 0x100; //m_iHealth
	DWORD dwTeam = 0xF4; //m_iTeamNum
	DWORD dwAmmo = 0x3244; //m_iClip1
	DWORD dwVecPunch = 0x302C; //m_vecPunch (m_aimPunchAngle + m_local)
	DWORD dwIShotsFired = 0xA370; //m_iShotsFired
	DWORD dwDormant = 0xED; //m_bDormant
	DWORD dwFlashMaxAlpha = 0xA3DC; //m_flFlashMaxAlpha
	DWORD dwFlashDuration = 0xA3E0; //m_flFlashDuration
	DWORD dwFlags = 0x104; //m_fFlags
	DWORD dwGlow = 0x5223730; // 
	DWORD dwJump = 0x5186978;// 
	DWORD dwAttack = 0x3114BA4;//
	
	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
PMemory.cpp
Code:
#include "PMemory.h"

[junk_enable /]

PMemory::PMemory() {}
PMemory::~PMemory() {}

bool PMemory::Attach(char* pName, DWORD rights) {
	HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	PROCESSENTRY32 entry;
	entry.dwSize = sizeof(entry);

	do
	if (!strcmp(entry.szExeFile, pName)) {
		pID = entry.th32ProcessID;
		CloseHandle(handle);

		_process = OpenProcess(rights, false, pID);

		Attached = true;

		return true;
	}
	while (Process32Next(handle, &entry));

	return false;
}

void PMemory::Detach() {
	Attached = false;
	CloseHandle(_process);
}

PModule PMemory::GetModule(char* moduleName) {
	HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pID);
	MODULEENTRY32 mEntry;
	mEntry.dwSize = sizeof(mEntry);

	do {
		if (!strcmp(mEntry.szModule, (LPSTR)moduleName)) {
			CloseHandle(module);

			PModule mod = { (DWORD)mEntry.hModule, mEntry.modBaseSize };
			return mod;
		}
	} while (Module32Next(module, &mEntry));

	PModule mod = { (DWORD)false, (DWORD)false };
	return mod;
}

HMODULE PMemory::LoadModule(const char* moduleName) {
	HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pID);
	MODULEENTRY32 mEntry;
	mEntry.dwSize = sizeof(mEntry);

	do {
		if (!strcmp(mEntry.szModule, (LPSTR)moduleName)) {
			CloseHandle(module);

			char szPath[MAX_PATH] = { NULL };
			GetModuleFileNameEx(_process, mEntry.hModule, szPath, MAX_PATH);

			return LoadLibrary(szPath);
		}
	} while (Module32Next(module, &mEntry));

	return NULL;
}

bool PMemory::DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {
	[add_junk /]
	for (; *pszMask; ++pszMask, ++pData, ++pMask) {
		if (*pszMask == 'x' && *pData != *pMask) {
			return false;
		}
	}

	[add_junk /]

	return (*pszMask == NULL);
}

DWORD PMemory::FindPattern(DWORD start, DWORD size, const char* sig, const char* mask) {
	[add_junk /]
	BYTE* data = new BYTE[size];

	unsigned long bytesRead;

	if (!ReadProcessMemory(_process, (LPVOID)start, data, size, &bytesRead)) {
		return NULL;
	}

	for (DWORD i = 0; i < size; i++) {
		if (DataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {
            delete data; // thx klorik! https://www.*************.me/forum/1354757-post1079.html
			return start + i;
		}
	}

	[add_junk /]

	return NULL;
}

DWORD PMemory::FindPatternArr(DWORD start, DWORD size, const char* mask, int count, ...) {
	[add_junk /]
	char* sig = new char[count + 1];
	va_list ap;
	va_start(ap, count);
	for (int i = 0; i < count; i++) {
		char read = va_arg(ap, char);
		sig[i] = read;
	}
	va_end(ap);
	sig[count] = '\0';

	[add_junk /]

	return FindPattern(start, size, sig, mask);
}
PMEMORY.h
Code:
 #ifndef PMEMORY_H
#define PMEMORY_H

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <TlHelp32.h>
#include <string>
#include <Psapi.h>
#include <stdarg.h>

struct PModule {
	DWORD dwBase;
	DWORD dwSize;
};

class PMemory {

public:
	[junk_enable 2 5 /]
	[junk_enable_declares /]
	[swap_lines]
	PMemory();
	~PMemory();

	bool Attached;

	bool Attach(char* pName, DWORD rights = PROCESS_ALL_ACCESS);

	void Detach();

	PModule GetModule(char* moduleName);

	HMODULE LoadModule(const char* moduleName);
	[/swap_lines]

	template <class T>
	T Read(DWORD addr) {
		T _read;
		ReadProcessMemory(_process, (LPVOID)addr, &_read, sizeof(T), NULL);
		return _read;
	}

	template <class T>
	void Write(DWORD addr, T val) {
		WriteProcessMemory(_process, (LPVOID)addr, &val, sizeof(T), NULL);
	}

	template <class T>
	void WriteProtect(DWORD addr, T val) {
		PDWORD oldProtect;
		VirtualProtectEx(_process, (LPVOID)addr, sizeof(T), PAGE_EXECUTE_READWRITE, &oldProtect);
		Write(addr, val);
		VirtualProtectEx(_process, (LPVOID)addr, sizeof(T), oldProtect, NULL);
	}

	DWORD FindPattern(DWORD start, DWORD size, const char* sig, const char* mask);
	DWORD FindPatternArr(DWORD start, DWORD size, const char* mask, int count, ...);

private:
	HANDLE _process;
	DWORD pID;
	bool DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask);
	[junk_disable /]

};

#endif
Triggerbot.h
Code:
#ifndef TRIGGERBOT_H
#define TRIGGERBOT_H

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

class Triggerbot {

[junk_enable /]

public: 
	void run() {
		bool autoAttacking = false;
		if (!(Settings()->trigger_key || Settings()->triggerEnabled)) {
            return;
        }
		while (true) {
			[add_junk /]
			if (autoAttacking && KeyUp(VK_LBUTTON)) {
                Engine()->Memory()->Write<int>(Engine()->getClientModule()->dwBase + Engine()->Offsets()->dwAttack, 4);
                autoAttacking = false;
			}
			[add_junk /]
			if (!Engine()->me.is_alive) {
				Sleep(1);
                continue;
			}
			if (!isTriggerEnabled()) {
				Sleep(1);
                continue;
				
            }
            [add_junk /]
            if (Engine()->me.weapon_ammo > 0 && inCrosshair()) {
                Sleep(Settings()->triggerdelay);
                Engine()->Memory()->Write<int>(Engine()->getClientModule()->dwBase + Engine()->Offsets()->dwAttack, 5);
                autoAttacking = true;
				Sleep(50);
            }
            [add_junk /]
			Sleep(1);
		}
		[add_junk /]
	}

private:
    bool isTriggerEnabled() {
		[add_junk /]
        if (!Settings()->triggerEnabled) {
            return false;
            [add_junk /]        
        }
        // If we're not using the holdkey, then it's always enabled
		if (Settings()->trigger_holdkey == 0) {
            return true;
            [add_junk /]
        }
        // Otherwise it's only enabled if holdkey is currently being held
        return KeyDown(Settings()->trigger_holdkey);
        [junk_disable /]
    }
	bool inCrosshair() {
		[junk_enable /]
		[add_junk /]

		int idInX = Engine()->Memory()->Read<int>(Engine()->me.dwBase + Engine()->Offsets()->dwInCross);

		if (idInX != 0) {
			[add_junk /]
			for (int i = 0; i < Engine()->iEnemies; i++) {
				if (Engine()->entEnemies[i].id == idInX) {
					return (Engine()->entEnemies[i].hp > 0);
				}
			}
			[add_junk /]
		}
		[add_junk /]
		return false;
	}
[junk_disable /]
};

#endif