Glow ESP

#include "HackProcess.h" 
 
CHackProcess lmao;
 
bool lol;
int myteam;
DWORD GlowPointer;
 
struct GlowStruct
{
    float r; 
    float g;  
    float b;  
    float a;
    bool rwo; 
    bool rwuo;  
};
 
GlowStruct CRed = { 0.4f, 0.f, 0.f, 1.f, true, false };
GlowStruct CGreen = { 0.f, 0.4f, 0.f, 1.f, true, false };
 
struct PlayerList_t
{
    DWORD CBaseEntity;
    int Team;
    float Position[3];
    int Health;
    int Dormant;
 
    void ReadInformation(int Player)
    {
        ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(lmao.__dwordClient + 0x04A1D3A4 + (Player * 16)),
            &CBaseEntity, sizeof(DWORD), 0);
        ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(CBaseEntity + 0xF0), &Team, sizeof(int), 0);
        ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(CBaseEntity + 0xFC), &Health, sizeof(int), 0);
        ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(CBaseEntity + 0x134), &Position, sizeof(float[3]), 0);
        ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(CBaseEntity + 0xE9), &Dormant, sizeof(int), 0);
 
    }
}PlayerList[32];
 
void DrawGlow(int GlowIndex, GlowStruct Color)
{
    bool one = true;
    bool two = false;
 
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0x4))), &Color.r, sizeof(float), 0);
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0x8))), &Color.g, sizeof(float), 0);
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0xC))), &Color.b, sizeof(float), 0);
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0x10))), &Color.a, sizeof(float), 0);
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0x24))), &one, sizeof(bool), 0);
    WriteProcessMemory(lmao.__HandleProcess, (PBYTE*)((GlowPointer + ((GlowIndex * 0x34) + 0x25))), &two, sizeof(bool), 0);
}
 
 
void main()
{
 
    lmao.RunProcess();
 
    for (;;) // or for(;;)
    {
        for (int i = 0; i < 32; i++)
        {
            PlayerList[i].ReadInformation(i);
            DWORD myplayer;
            ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(lmao.__dwordClient + 0xA7AFBC), &myplayer, sizeof(DWORD), 0);
            ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(myplayer + 0xF0), &myteam, sizeof(int), 0);
 
 
            if (GetAsyncKeyState(VK_INSERT))
            {
                lol = !lol;
                Sleep(250);
            }
 
            if (lol)
            {
                DWORD g_currentPlayer;
                int g_currentPlayerTeam;
                int g_currentPlayer_GlowIndex;
 
 
                ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(lmao.__dwordClient + 0x04B303A4), &GlowPointer, sizeof(DWORD), 0);
                ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(lmao.__dwordClient + 0x04A1D3A4 + ((i)* 16)), &g_currentPlayer, sizeof(DWORD), 0);
                ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(g_currentPlayer + 0x1DCC), &g_currentPlayer_GlowIndex, sizeof(int), 0);
                ReadProcessMemory(lmao.__HandleProcess, (PBYTE*)(g_currentPlayer + 0xF0), &g_currentPlayerTeam, sizeof(int), 0);
 
                if (!PlayerList[i].Dormant != 1)
                    continue;
 
                if (PlayerList[i].Team == myteam)
                {
                }
                else
                {
                    DrawGlow(g_currentPlayer_GlowIndex, CRed);
                }
            }
        }
        Sleep(1);
 
    }
}

#pragma once
 
#include <Windows.h>
#include <TlHelp32.h>
 
class CHackProcess
{
public:
 
    PROCESSENTRY32 __gameProcess;
    HANDLE __HandleProcess;
    HWND __HWNDCss;
    DWORD __dwordClient;
 
    DWORD FindProcessName(const char *__ProcessName, PROCESSENTRY32 *pEntry)
    {
        PROCESSENTRY32 __ProcessEntry;
        __ProcessEntry.dwSize = sizeof(PROCESSENTRY32);
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return 0;        if (!Process32First(hSnapshot, &__ProcessEntry))
        {
            CloseHandle(hSnapshot);
            return 0;
        }
        do {
            if (!_strcmpi(__ProcessEntry.szExeFile, __ProcessName))
            {
                memcpy((void *)pEntry, (void *)&__ProcessEntry, sizeof(PROCESSENTRY32));
                CloseHandle(hSnapshot);
                return __ProcessEntry.th32ProcessID;
            }
        } while (Process32Next(hSnapshot, &__ProcessEntry));
        CloseHandle(hSnapshot);
        return 0;
    }
 
 
    DWORD getThreadByProcess(DWORD __DwordProcess)
    {
        THREADENTRY32 __ThreadEntry;
        __ThreadEntry.dwSize = sizeof(THREADENTRY32);
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
        if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
 
        if (!Thread32First(hSnapshot, &__ThreadEntry)) { CloseHandle(hSnapshot); return 0; }
 
        do {
            if (__ThreadEntry.th32OwnerProcessID == __DwordProcess)
            {
                CloseHandle(hSnapshot);
                return __ThreadEntry.th32ThreadID;
            }
        } while (Thread32Next(hSnapshot, &__ThreadEntry));
        CloseHandle(hSnapshot);
        return 0;
    }
 
    DWORD GetModuleNamePointer(LPSTR LPSTRModuleName, DWORD __DwordProcessId)
    {
        MODULEENTRY32 lpModuleEntry = { 0 };
        HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, __DwordProcessId);
        if (!hSnapShot)
            return NULL;
        lpModuleEntry.dwSize = sizeof(lpModuleEntry);
        BOOL __RunModule = Module32First(hSnapShot, &lpModuleEntry);
        while (__RunModule)
        {
            if (!strcmp(lpModuleEntry.szModule, LPSTRModuleName))
            {
                CloseHandle(hSnapShot);
                return (DWORD)lpModuleEntry.modBaseAddr;
            }
            __RunModule = Module32Next(hSnapShot, &lpModuleEntry);
        }
        CloseHandle(hSnapShot);
        return NULL;
    }
 
 
    void runSetDebugPrivs()
    {
        HANDLE __HandleProcess = GetCurrentProcess(), __HandleToken;
        TOKEN_PRIVILEGES priv;
        LUID __LUID;
        OpenProcessToken(__HandleProcess, TOKEN_ADJUST_PRIVILEGES, &__HandleToken);
        LookupPrivilegeValue(0, "seDebugPrivilege", &__LUID);
        priv.PrivilegeCount = 1;
        priv.Privileges[0].Luid = __LUID;
        priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(__HandleToken, false, &priv, 0, 0, 0);
        CloseHandle(__HandleToken);
        CloseHandle(__HandleProcess);
    }
 
 
 
    void RunProcess()
    {
        runSetDebugPrivs();
        while (!FindProcessName("csgo.exe", &__gameProcess));
        while (!(getThreadByProcess(__gameProcess.th32ProcessID)));
        __HandleProcess = OpenProcess(PROCESS_ALL_ACCESS, false, __gameProcess.th32ProcessID);
        while (__dwordClient == 0x0) __dwordClient = GetModuleNamePointer("client.dll", __gameProcess.th32ProcessID);
        __HWNDCss = FindWindow(NULL, "Counter-Strike: Global Offsensive");
    }
};
 
extern CHackProcess lmao;