#include "stdafx.h"
    #include <windows.h>
    #include <TlHelp32.h>
    #include <iostream>

    typedef unsigned char uint8_t;

    template <typename T, size_t N>

    size_t countof(T(&array)[N])
    {
    	return N;
    }

    DWORD dwLocalPlayer; //will be scanned
    DWORD dwEntityList;  //will be scanned
    DWORD dwGlow;        //will be scanned

    DWORD dwTeam = 0xF0;
    DWORD dwDormant = 0xE9;

    struct PModule
    {
    	DWORD dwBase;
    	DWORD dwSize;
    };

    /* Debugger/Process API implementation class */
    class process
    {

    public:
    	bool 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);
    				return true;
    			}
    		while (Process32Next(handle, &entry));
    		return false;
    	}
    	PModule 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;
    	}

    	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);
    	}

    	DWORD FindPattern(DWORD start, DWORD size, const char* sig, const char* mask) {
    		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)) {
    				return start + i;
    			}
    		}
    		return NULL;
    	}

    	DWORD FindPatternArray(DWORD start, DWORD size, const char* mask, int count, ...) {
    		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';
    		return FindPattern(start, size, sig, mask);
    	}


    private:
    	HANDLE _process;
    	DWORD pID;
    	bool DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {
    		for (; *pszMask; ++pszMask, ++pData, ++pMask) {
    			if (*pszMask == 'x' && *pData != *pMask) {
    				return false;
    			}
    		}
    		return (*pszMask == NULL);
    	}
    };

    /* Glow Object structure in csgo */
    struct glow_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];
    };

    /* Entity structure in csgo */
    struct Entity
    {
    	DWORD dwBase;
    	int team;
    	bool is_dormant;
    };

    /* Player structure in csgo */
    struct Player
    {
    	DWORD dwBase;
    	bool isDormant;
    };

    process memory;
    process _modClient;
    process* mem;
    PModule modClient;

    int iFriendlies;
    int iEnemies;

    Entity entEnemies[32];
    Entity entFriendlies[32];
    Entity me;

    void update_entity_data(Entity* e, DWORD dwBase)
    {
    	int dormant = memory.Read<int>(dwBase + dwDormant);
    	e->dwBase = dwBase;
    	e->team = memory.Read<int>(dwBase + dwTeam);
    	e->is_dormant = dormant == 1;
    }
    /* Get Pointer To Client.dll*/
    PModule* GetClientModule() {
    	if (modClient.dwBase == 0 && modClient.dwSize == 0) {
    		modClient = memory.GetModule("client.dll");
    	}
    	return &modClient;
    }

    Entity* GetEntityByBase(DWORD dwBase) {

    	for (int i = 0; i < iFriendlies; i++) {
    		if (dwBase == entFriendlies[i].dwBase) {
    			return &entFriendlies[i];
    		}
    	}
    	for (int i = 0; i < iEnemies; i++) {
    		if (dwBase == entEnemies[i].dwBase) {
    			return &entEnemies[i];
    		}
    	}
    	return nullptr;
    }

    /* offset updating class, that uses patterns to find memory addresses */
    class offset
    {
    private:
    	static void update_local_player() {
    		DWORD lpStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "xxx????xx????xxxxx?", 19, 0x8D, 0x34, 0x85, 0x0, 0x0, 0x0, 0x0, 0x89, 0x15, 0x0, 0x0, 0x0, 0x0, 0x8B, 0x41, 0x8, 0x8B, 0x48, 0x0);
    		DWORD lpP1 = mem->Read<DWORD>(lpStart + 3);
    		BYTE lpP2 = mem->Read<BYTE>(lpStart + 18);
    		dwLocalPlayer = (lpP1 + lpP2) - modClient.dwBase;
    	}

    	static void update_entity_list() {
    		DWORD elStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "x????xx?xxx", 11, 0x5, 0x0, 0x0, 0x0, 0x0, 0xC1, 0xE9, 0x0, 0x39, 0x48, 0x4);
    		DWORD elP1 = mem->Read<DWORD>(elStart + 1);
    		BYTE elP2 = mem->Read<BYTE>(elStart + 7);
    		dwEntityList = (elP1 + elP2) - modClient.dwBase;
    	}

    	static void update_glow() {
    		DWORD gpStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "xxx????xxxxx????????", 20, 0x0F, 0x11, 0x05, 0x0, 0x0, 0x0, 0x0, 0x83, 0xC8, 0x01, 0xC7, 0x05, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0);
    		dwGlow = mem->Read<DWORD>(gpStart + 3) - modClient.dwBase;
    	}
    public:
    	static void get_offset(process* m) {
    		mem = m;
    		modClient = mem->GetModule("client.dll");
    		update_local_player();
    		update_entity_list();
    		update_glow();
    	}

    	//constantly scanning & updating our offsets
    	static DWORD WINAPI scan_offsets(LPVOID PARAM)
    	{
    		Entity players[64];
    		while (true) {
				Sleep(1);
    			DWORD playerBase = memory.Read<DWORD>(GetClientModule()->dwBase + dwLocalPlayer);
    			int cp = 0;

    			update_entity_data(&me, playerBase);
    			for (int i = 1; i < 64; i++) {
    				DWORD entBase = memory.Read<DWORD>((GetClientModule()->dwBase + dwEntityList) + i * 0x10);

    				if (entBase == NULL)
    					continue;

    				update_entity_data(&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;
    		}
    	}
    };


    class virtualesp
    {
    private:
    	static void glow_player(DWORD mObj, float r, float g, float b)
    	{
    		memory.Write<float>(mObj + 0x4, r);
    		memory.Write<float>(mObj + 0x8, g);
    		memory.Write<float>(mObj + 0xC, b);
    		memory.Write<float>(mObj + 0x10, 1.0f);
    		memory.Write<BOOL>(mObj + 0x24, true);
    		memory.Write<BOOL>(mObj + 0x25, false);
    	}

    	static float SanitizeColor(int value)
    	{
    		if (value > 255) value = 255;
    		if (value < 0) value = 0;
    		return (float)value / 255;
    	}
    public:
    	static void start_engine() {
    		while (!memory.Attach("csgo.exe", PROCESS_ALL_ACCESS)) {
    			Sleep(100);
    		}
    		do {
    			Sleep(1000);
    			offset::get_offset(&memory);
    		} while (dwLocalPlayer < 65535);
    		CreateThread(NULL, NULL, &offset::scan_offsets, NULL, NULL, NULL);
    	}

    	static unsigned long __stdcall esp_thread(void*)
    	{
    		int objectCount;
    		DWORD pointerToGlow;
    		Entity* Player = NULL;
    		float Friend = SanitizeColor(100);
    		float Enemy = SanitizeColor(140);

    		while (true)
    		{
				Sleep(1);
    			pointerToGlow = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow);
    			objectCount = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow + 0x4);
    			if (pointerToGlow != NULL && objectCount > 0)
    			{
    				for (int i = 0; i < objectCount; i++)
    				{
    					DWORD mObj = pointerToGlow + i * sizeof(glow_t);
    					glow_t glowObject = memory.Read<glow_t>(mObj);
    					Player = GetEntityByBase(glowObject.dwBase);

    					if (glowObject.dwBase == NULL || Player == nullptr || Player->is_dormant) {
    						continue;
    					}
    					if (me.team == Player->team) {
    						//glow_player(mObj, 0, 0, Friend);
    					}
    					else {
    						glow_player(mObj, Enemy, 0, 0);
    					}
    				}
    			}
    		}
    		return EXIT_SUCCESS;
    	}
    };


    int main()
    {
		SetConsoleTitle("Example Glow");
    	bool enabled = false;
    	HANDLE ESP = NULL;

    	virtualesp::start_engine();

    	std::cout << "press F1 to toggle Glow!" << std::endl;
    	while (TRUE)
    	{
			Sleep(1);
    		if (GetAsyncKeyState(VK_F1) & 1) {
    			enabled = !enabled;
    			if (enabled) {
    				std::cout << "Glow: on" << std::endl;
    				ESP = CreateThread(NULL, NULL, &virtualesp::esp_thread, NULL, NULL, NULL);
    			}
    			else {
    				std::cout << "Glow: off" << std::endl;
    				TerminateThread(ESP, 0);
    				CloseHandle(ESP);
    			}
    		}
    	}
    }