Radar hack.

#include "PMem.h"
#include <iostream>
#include <Windows.h>

RPM Mem;

const DWORD entList = 0x049EE2E4;

DWORD dwClient;


DWORD getEntityByID(int _id) {
	return Mem.Read<DWORD>(dwClient + entList + (_id*0x10));
}


int main()
{
	Mem.Process("csgo.exe");
	dwClient = Mem.Module("client.dll");
	while(true) {
		for (int i = 0; i < 64; i++) {
			DWORD pEnt = getEntityByID(i);
			Mem.Write<BYTE>(pEnt + 0x935, 1);
		}
	}
}

/* .cpp  mem class http://pastebin.com/JXezXVxm */
#ifndef PMEM_H
#define PMEM_H
#include <iostream>
#include <Windows.h>
#include <cmath>
#include <string>
#include <TlHelp32.h>
#include <stdint.h>


class RPM {
protected:
        HANDLE hProcess;
        DWORD dwPID, dwProtection, dwCaveAddress;
        BOOL bPOn, bIOn, bProt;

public:
        RPM();
        ~RPM();
        int chSizeOfArray(char *chArray);
        int iSizeOfArray(int *iArray);
        bool iFind(int *iAry, int iVal);

		 /* Read Template! */
         template <class cData>
        cData Read(DWORD dwAddress)
        {
                cData cRead;
                ReadProcessMemory(hProcess, (LPVOID)dwAddress, &cRead, sizeof(cData), NULL);
                return cRead;
        }
 
       
        template <class cData>
        cData Read(DWORD dwAddress, char *Offset, BOOL Type)
        {
 
                int iSize = iSizeOfArray(Offset) - 1;
                dwAddress = Read<DWORD>(dwAddress);
 
 
                for (int i = 0; i < iSize; i++)
                        dwAddress = Read<DWORD>(dwAddress + Offset[i]);
 
                if (!Type)
                        return dwAddress + Offset[iSize];
                else
                        return Read<cData>(dwAddress + Offset[iSize]);
        }
 
 
        template <class cData>
        void Read(DWORD dwAddress, cData Value)
        {
                ReadProcessMemory(hProcess, (LPVOID)dwAddress, &Value, sizeof(cData), NULL);
        }
 
 
        template <class cData>
        void Read(DWORD dwAddress, char *Offset, cData Value)
        {
                Read<cData>(Read<cData>(dwAddress, Offset, false), Value);
        }
		/* End of Read template */
 
        virtual void Process(char* ProcessName);
        virtual void Patch(DWORD dwAddress, char *chPatch_Bts, char *chDefault_Bts);
        virtual DWORD AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *chPattern);
        virtual DWORD Module(LPSTR ModuleName);

		/* WriteProcessMemory */

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

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

/* Header mem class http://pastebin.com/2w5fWhH3 */
#include "PMem.h"

#pragma region Misc functions
RPM::RPM() { }

RPM::~RPM() {
CloseHandle(hProcess);
}

int RPM::chSizeOfArray(char *chArray){
 
 
        for (int iLength = 1; iLength < MAX_PATH; iLength++)
                if (chArray[iLength] == '*')
                        return iLength;
 
        std::cout << "\nLENGTH: Failed To Read Length Of Array\n";
        return 0;
}

int RPM::iSizeOfArray(int *iArray) {
        for (int iLength = 1; iLength < MAX_PATH; iLength++)
                if (iArray[iLength] == '*')
                        return iLength;
 
        std::cout << "\nLENGTH: Failed To Read Length Of Array\n";
        return 0;

}


bool RPM::iFind(int *iAry, int iVal){
 
        for (int i = 0; i < 64; i++)
                if (iVal == iAry[i] && iVal != 0)
                        return true;
 
        return false;
}
#pragma endregion Misc functions end


#pragma region RPM/WPM start
void RPM::Process(char* ProcessName) {
	        HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
        PROCESSENTRY32 ProcEntry;
        ProcEntry.dwSize = sizeof(ProcEntry);
 
 
        do
                if (!strcmp(ProcEntry.szExeFile, ProcessName))
                {
 
 
                dwPID = ProcEntry.th32ProcessID;
                CloseHandle(hPID);
 
 
                hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
                return;
                }
        while (Process32Next(hPID, &ProcEntry));
 
        std::cout << "\nPROCESS: Process Not Found\n";
		std::cout << "Open Game, then open hack!\n";
        system("pause");
        exit(0);
}


void RPM::Patch(DWORD dwAddress, char *Patch_Bts, char *Default_Bts) {
        int iSize = chSizeOfArray(Default_Bts);
 
 
        if (!bPOn)
                for (int i = 0; i < iSize; i++)
                        Read<BYTE>(dwAddress + i, Patch_Bts[i]);
        else
                for (int i = 0; i < iSize; i++)
                        Read<BYTE>(dwAddress + i, Default_Bts[i]);
 
       bPOn = !bPOn;
}

DWORD RPM::AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *Bytes) {
	    int iBytesToRead = 0, iTmp = 0;
        int length = chSizeOfArray(Bytes);
        bool bTmp = false;
 
 
        if (Bytes[0] == '?')
        {
                for (; iBytesToRead < MAX_PATH; iBytesToRead++)
                        if (Bytes[iBytesToRead] != '?')
                        {
                        iTmp = (iBytesToRead + 1);
                        break;
                        }
        }
 
 
        for (; dwAddress < dwEnd; dwAddress++)
        {
                if (iBytesToRead == length)
                        return dwAddress - iBytesToRead;
 
                if (Read<BYTE>(dwAddress) == Bytes[iBytesToRead] || (bTmp && Bytes[iBytesToRead] == '?'))
                {
                        iBytesToRead++;
                        bTmp = true;
                }
                else
                {
                        iBytesToRead = iTmp;
                        bTmp = false;
                }
        }
 
        std::cout << "\nAOB_SCAN: Failed To Find Byte Pattern\n";
        return 0;
}

DWORD RPM::Module(LPSTR ModuleName){
 
 
        HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
        MODULEENTRY32 mEntry;
        mEntry.dwSize = sizeof(mEntry);
 
 
        do
                if (!strcmp(mEntry.szModule, ModuleName))
                {
                CloseHandle(hModule);
                return (DWORD)mEntry.modBaseAddr;
                }
        while (Module32Next(hModule, &mEntry));
 
        std::cout << "\nMODULE: Process Platform Invalid\n";
        return 0;
}

WriteDMAInteger("csgo", GetModuleHandle("csgo", "client.dll") + &H49EE2E4 + i * &H10, {&H935}, 1, 1, 1)