ESP source code

#include "Func.h"

__int32 main()
{
	//initalize
	Engine info;
	
	while(1)
	{
		//HOTKEYS
		if(GetAsyncKeyState(VK_F1)&1)
		{
			info.tOn = !info.tOn;
			_cwprintf(L"Triggerbot Toggled\n");
		}

		if(GetAsyncKeyState(VK_F2)&1)
		{
			info.aOn = !info.aOn;
			_cwprintf(L"Aimbot Toggled\n");
		}
		
		if(GetAsyncKeyState(VK_F3)&1)
		{
			info.eOn = !info.eOn;		
			_cwprintf(L"ESP Toggled\n");
		}

		if(GetAsyncKeyState(VK_F4)&1)
			return 0;


		//MISC
		info.i_Count = 1;
		info.Reading(info.eOn || info.aOn || info.tOn);

		//FUNCTIONS
		info.Trigger();//Triggerbot, Current xhair ID
		info.ESP();	//ESP
		info.Aimbot();

	}
	system("pause");
	return 0;
}

#include "Func.h"
#include "ProcMem.h"

ProcMem mem;
Store EntList[32];

Store::Store(){
	//Constructor
};

Engine::Engine()
{
	//MISC
	//ShowWindow(FindWindowA("ConsoleWindowClass", NULL), false);

	//Initialize Variables
	tOn = false;
	eOn = false;
	aOn = false;

	//Initialize Memory
	mem.GetProcess("csgo.exe");
	dwClient = mem.Module("client.dll");
	dwPBase = mem.Read<DWORD>(dwClient + 0x99E324);	
	dwEngine = mem.Module("engine.dll");
	dwAngPtr = mem.Read<DWORD>(dwEngine + 0x52F424);

	//Initialize GDI Drawing
	TargetWnd = FindWindow(0, "Counter-Strike: Global Offensive");
	HDC_Desktop = GetDC(TargetWnd);
	GetWindowRect(FindWindow(NULL, "Counter-Strike: Global Offensive"), &m_Rect);
	EnemyBrush = CreateSolidBrush(RGB(255, 0, 0));
	TextCOLOR = RGB(255, 0, 0);
}

void Engine::Reading(bool on)	
{	
	if(on)
	{
		if(eOn || aOn)
		{
			//Read Our Info			
			EntList[0].fPos[0] = mem.Read<float>(dwPBase + 0x134);					
			EntList[0].fPos[1] = mem.Read<float>(dwPBase + 0x138);				
			EntList[0].fPos[2] = mem.Read<float>(dwPBase + 0x13C);
			W2S_M = mem.Read<WorldToScreenMatrix_t>(dwClient + 0x9A2954);
		}

		//Read our TeamNum to filter out team mates
		i_team = mem.Read<int>(dwPBase + 0xF0);

		for(int i = 1; i < 64; i++)
		{
			//Loop From Base Entity Address by 0x10 On Each Iteration
			dwEntity = mem.Read<DWORD>((dwClient + 0x9B76B4) + (i * 0x10));
 
			//Prevent Crash From Reading Null Pointer - also stop counting when weve read the last entity   
			if(!dwEntity)     
				return;
 		
			//Read Current Entity's TeamNum For Compare
			e_team = mem.Read<int>(dwEntity + 0xF0);

			//If An Enemy Has Been Found, Store Their Entity Index ID Inside Array
			if(e_team != i_team && e_team > 1)
			{
				if(tOn)	
					i_Enemies[i_Count] = mem.Read<int>(dwEntity + 0x64);//Ent ID
		
				if(eOn || aOn)
				{	
					EntList[i_Count].fPos[0] = mem.Read<float>(dwEntity + 0x134);//X			
					EntList[i_Count].fPos[1] = mem.Read<float>(dwEntity + 0x138);//Y			
					EntList[i_Count].fPos[2] = mem.Read<float>(dwEntity + 0x13C);//Z 				
					EntList[i_Count].iHealth = mem.Read<int>(dwEntity + 0xFC);//HP	
					EntList[i_Count].fFlags = mem.Read<int>(dwEntity + 0x100);//HP	
				}		
				i_Count++;
			}	
		}
	}
}

float Engine::Get3D(float X, float Y, float Z, float eX, float eY, float eZ)	
{
	return(sqrtf( (eX - X) * (eX - X) + (eY - Y) * (eY - Y) + (eZ - Z) * (eZ - Z)));
}

float Engine::CloseEnt()
{
	//Variables
	float fLowest = 100000, TMP;
	int iIndex;

	for(int i = 1; i < i_Count; i++)
	{
		//Store Distances In Array
		TMP = Get3D(EntList[0].fPos[0], EntList[0].fPos[1], EntList[0].fPos[2], EntList[i].fPos[0], EntList[i].fPos[1], EntList[i].fPos[2]);

		//If Enemy Has Lower Distance The Player 1, Replace (var)Lowest With Current Enemy Distance
		if(TMP < fLowest && EntList[i].iHealth != 0)
		{
			fLowest = TMP;	
			iIndex = i;
		}
	}
	return iIndex;
}

void Engine::Trigger()
{
	if(tOn && mem.Locate(i_Enemies, i_Count, mem.Read<int>(dwPBase + 0x23B4)))   	
	{      	
		mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );       	
		Sleep(1); //Response Time     				
		mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );
	}
    return;
}

//Thanks to Fleep for providing these functions in his tutorials, Ive updated as much as I can
bool Engine::WorldToScreen(float * from, float * to)
{
	to[0] = W2S_M.flMatrix[0][0] * from[0] + W2S_M.flMatrix[0][1] * from[1] + W2S_M.flMatrix[0][2] * from[2] + W2S_M.flMatrix[0][3];
	to[1] = W2S_M.flMatrix[1][0] * from[0] + W2S_M.flMatrix[1][1] * from[1] + W2S_M.flMatrix[1][2] * from[2] + W2S_M.flMatrix[1][3];

	float w = W2S_M.flMatrix[3][0] * from[0] + W2S_M.flMatrix[3][1] * from[1] + W2S_M.flMatrix[3][2] * from[2] + W2S_M.flMatrix[3][3];

	if(w < 0.01f)
		return false;

	float invw = 1.0f / w;
	to[0] *= invw;
	to[1] *= invw;

	int width = (int)(m_Rect.right - m_Rect.left);
	int height = (int)(m_Rect.bottom - m_Rect.top);

	float x = width/2;
	float y = height/2;

	x += 0.5 * to[0] * width + 0.5;
	y -= 0.5 * to[1] * height + 0.5;

	to[0] = x + m_Rect.left;
	to[1] = y + m_Rect.top;

	return true;
}

void Engine::DrawFilledRect(int x, int y, int w, int h)
{
	RECT rect = { x, y, x + w, y + h }; 
	FillRect(HDC_Desktop, &rect, EnemyBrush);
}

void Engine::DrawBorderBox(int x, int y, int w, int h, int thickness)
{
	//Top horiz line
	DrawFilledRect(x, y, w, thickness);
	//Left vertical line
	DrawFilledRect( x, y, thickness, h);
	//right vertical line
	DrawFilledRect((x + w), y, thickness, h);
	//bottom horiz line
	DrawFilledRect(x, y + h, w+thickness, thickness);
}

void Engine::DrawString(int x, int y, COLORREF color, const char* text)
{	
	SetTextAlign(HDC_Desktop,TA_CENTER|TA_NOUPDATECP);

	SetBkColor(HDC_Desktop,RGB(0,0,0));
	SetBkMode(HDC_Desktop,TRANSPARENT);

	SetTextColor(HDC_Desktop,color);

	SelectObject(HDC_Desktop,Font);

	TextOutA(HDC_Desktop,x,y,text,strlen(text));

	DeleteObject(Font);
}

void Engine::DrawESP(int x, int y, float distance, int Health, int fFlags)
{
	//ESP RECTANGLE
	int width = 18100/distance;
	int height = 36000/distance;

	if(fFlags == 775)
	{
		width = 10950/distance;
	    height = 14000/distance;
	}

	DrawBorderBox(x-(width/2), y-(height+30), width, height, 2);

	std::stringstream ss, hp;
	ss << (int)distance/3;
	hp << Health;

	char * distanceInfo = new char[ss.str().size()+1];
	strcpy(distanceInfo, ss.str().c_str());

	char * HealthInfo = new char[hp.str().size()+1];
	strcpy(HealthInfo, hp.str().c_str());

	DrawString(x - 10, y-(height+50), TextCOLOR, "HP:");
	DrawString(x + 15, y-(height+50), TextCOLOR, HealthInfo);
	
	DrawString(x - 10, y-30, TextCOLOR, "Dist:");
	DrawString(x + 20, y-30, TextCOLOR, distanceInfo);

	delete [] HealthInfo, distanceInfo;

}

void Engine::ESP()
{
	if(eOn)
		for(int i = 1; i < i_Count; i ++)
		{
			float EnemyXY[3];
			
			if(EntList[i].iHealth != 0 && WorldToScreen(EntList[i].fPos, EnemyXY))
				DrawESP(EnemyXY[0] - m_Rect.left, EnemyXY[1] - m_Rect.top, Get3D(EntList[0].fPos[0], EntList[0].fPos[1], EntList[0].fPos[2], EntList[i].fPos[0], EntList[i].fPos[1], EntList[i].fPos[2]), EntList[i].iHealth, EntList[i].fFlags);	
		}
}

void Engine::CalcAngle( float *src, float *dst, float *angles , int fFlags)
{
	double delta[3] = { (src[0]-dst[0]), (src[1]-dst[1]), (src[2]-dst[2]) };
	double hyp = sqrt(delta[0]*delta[0] + delta[1]*delta[1]);
	angles[0] = (float) (asinf(delta[2]/hyp) * 57.295779513082f);
	angles[1] = (float) (atanf(delta[1]/delta[0]) * 57.295779513082f);
	angles[2] = 0.0f;

	if(delta[0] >= 0.0) 
	{ 
		angles[1] += 180.0f; 
	}

	if(fFlags == 775)
		angles[0] = angles[0] + 5; 
}

void Engine::Aimbot(){

	if(GetAsyncKeyState(0x02))
	{
		//Get Closest Entity Array Index Number
		int Index = CloseEnt();

		//Calculate Angle To Closest Entity
		CalcAngle(EntList[0].fPos, EntList[Index].fPos, EntList[Index].Angle, EntList[Index].fFlags);

		//Write To AngRotation The Current Angle Of The Entity
		mem.Write<float>(dwAngPtr + 0x4C88, EntList[Index].Angle[0]);
		mem.Write<float>(dwAngPtr + 0x4C8C, EntList[Index].Angle[1]);
		//I did call the games function SetAng Here but it has bugs, Will be fixed on next release
		//Ill also add Bone-Aimbot ( i just cba to add it all in with the bulk pointers :P
	}
	
}

//De-Constructors
Store::~Store(){
	//De-Constructor
};
Engine::~Engine()
{}

#ifndef FUNC_H
#define FUNC_H

#include "Includes.h"

struct Store{
	Store();
	~Store();
public:
	bool tOn, eOn, aOn;
	int i_team, e_team, iHealth,  i_Count, fFlags;
	float fPos[3], Angle[3];
};

class Engine: public Store{
public:

#pragma region FUNCTION PROTOTYPES

	//Misc & Reading Functions
	Engine();
	float Get3D(float X, float Y, float Z, float eX, float eY, float eZ);
	void Reading(bool on);
	~Engine();

	//Triggerbot
	void Trigger();

	//ESP Prototypes
	bool WorldToScreen(float * from, float * to);
	void DrawFilledRect(int x, int y, int w, int h);
	void DrawBorderBox(int x, int y, int w, int h, int thickness);
	void DrawString(int x, int y, COLORREF color, const char* text);
	void DrawESP(int x, int y, float distance, int Health, int fFlags);
	void ESP();

	//Aim-Bot Prototypes
	void CalcAngle( float *src, float *dst, float *angles, int fFlags);
	float CloseEnt();
	void Aimbot();

#pragma endregion

#pragma region Variables

	//Misc Variables
	DWORD dwClient, dwEngine, dwPBase, dwEntity, dwBase, dwAngPtr;
	int i_Enemies[32];
	
	//ESP Variables
	RECT m_Rect; 
	HDC HDC_Desktop;//Our desktop handle
	HBRUSH EnemyBrush;//Brush to paint ESP etc
	HFONT Font; //font we use to write text with
	HWND TargetWnd, Handle;
	COLORREF TextCOLOR;
	
	//World To Screen Info
	typedef struct{
		float flMatrix [4][4];
	}WorldToScreenMatrix_t;

	WorldToScreenMatrix_t W2S_M;

#pragma endregion
};

#endif

#ifndef INCLUDES_H //Define Guard
#define INCLUDES_H
#define WIN32_LEAN_AND_MEAN //Excludes Headers We Wont Use (Increase Compile Time)

#include <windows.h> //Standard Windows Functions/Data Types
#include <algorithm>
#include <iostream> //Constains Input/Output Functions (cin/cout etc..)
#include <TlHelp32.h> //Contains Read/Write Functions
#include <string> //Support For Strings
#include <sstream> //Supports Data Conversion

#endif

#include "ProcMem.h"

using namespace std;

ProcMem::ProcMem(){
	//Constructor For Class, Do Not Remove!
}

__int32 ProcMem::GetLength(char *chArray){

	//Loop Through *chArray To Get Amount Of Bytes
	for(__int32 iLength = 1; iLength < MAX_PATH; iLength++)
		if (chArray[iLength] == '*')	
			return iLength;	

	cout << "\nLENGTH: Failed To Read Length Of Array\n";
	return 0;
} 

bool ProcMem::Locate(int *iAry, int iSize, int iVal){

	for(__int32 i = 0; i != iSize; i++)
		if(iVal == iAry[i])
			return true;

	return false;
}

void ProcMem::Patch(DWORD dwAddress, char *Patch_Bts, char *Default_Bts){
 
	//Variables
	__int32 iSize = GetLength(Default_Bts);		

	//Loop Through Addresses Writing Bytes
	if (!bPOn)
		for(__int32 i = 0; i < iSize; i++)	
			Write<BYTE>(dwAddress + i, Patch_Bts[i]);		
	else
		for(__int32 i = 0; i < iSize; i++)	 	
			Write<BYTE>(dwAddress + i, Default_Bts[i]);        		        	

	bPOn = !bPOn; 
}

void ProcMem::GetProcess(char* ProcessName){

	//Variables
	HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL); //Snapshot To View All Active Processes
	PROCESSENTRY32 pEntry;
	pEntry.dwSize = sizeof(pEntry); //Declare Structure Size And Populate It

	//Loop Through All Running Processes To Find Process
	do
	    if(!strcmp(pEntry.szExeFile, ProcessName))
		{
			//Store Process ID
			dwPID = pEntry.th32ProcessID;
			CloseHandle(hPID);

			//Give Our Handle All Access Rights 
	        hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID); 
			return;
		}
	while(Process32Next(hPID, &pEntry));

	cout << "\nPROCESS: Process Not Found\n";
	system("pause");
    exit(0);
}

void ProcMem::Inject(DWORD dwAddress, char *Inj_Bts, char *Def_Bts, BOOL Type){
	
	//Variables
	__int32 i_ISize = GetLength(Inj_Bts);
	__int32 i_DSize = GetLength(Def_Bts); 

	if(!bIOn)
	{		
		//NOP All Bytes In The Array Past The 5th Byte	
		if(i_DSize >= 5)
			for (__int32 i = 6; i < i_DSize; i++)
				Write<BYTE>(dwAddress + i, 0x90);	
		else {cout << "\nINJECTION: Default Bytes Must Be More Than 5\n"; return;}

		//Create Codecave
		dwCaveAddress = (DWORD)VirtualAllocEx(hProcess, NULL,  i_ISize + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

		//Calculate Jmp/Return Distances In Bytes To Write
		DWORD dwRetJmp = (dwAddress + i_DSize) - dwCaveAddress - 5; //(NextInstruction - CaveAddress - 5) - is correct equation.
		DWORD dwBaseJmp = dwCaveAddress - dwAddress - 5; //Base Jmp

		//Loop Through Each Address Writing Inj_Bts Inside The Codecave
		for (__int32 i = 0; i <= i_ISize; i++)			
			Write<BYTE>(dwCaveAddress+i, Inj_Bts[i]);
		
		//Write The Return Distance In Bytes (E9 = Jmp | E8 = Call) To The Original Address
		Write<BYTE>(dwCaveAddress + i_ISize, Type ? 0xE9 : 0xE8);
		Write<DWORD>(dwCaveAddress + i_ISize + 1, dwRetJmp);
		
		//Write The Jump From The Original Address To The Codecave
		Write<BYTE>(dwAddress, Type ? 0xE9 : 0xE8);
		Write<DWORD>(dwAddress + 1, dwBaseJmp);
	}	

	if(bIOn)
	{			
		//Restore Original Bytes
		for(__int32 i = 0; i < i_DSize; i++)					
			Write<BYTE>(dwAddress + i, Def_Bts[i]);	

		//Clean Up! (DeAllocate CodeCave)
		VirtualFreeEx(hProcess, (LPVOID)dwCaveAddress, i_ISize + 5, MEM_DECOMMIT);
	}
    bIOn = !bIOn; 
} 

DWORD ProcMem::AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *Bytes){

	//VARIABLES
	__int32 iBytesToRead(0);
	__int32 length = GetLength(Bytes);

	//Increase Start Address Till It Reaches The End Address
	for(;dwAddress < dwEnd; dwAddress++) 	
		if(Read<BYTE>(dwAddress) == Bytes[iBytesToRead] || Bytes[iBytesToRead] == '?') 	
			iBytesToRead++;
		else if(iBytesToRead >= length)
			return dwAddress - iBytesToRead;					
		else iBytesToRead = 0;		

	cout << "\nAOB_SCAN: Failed To Find Byte Pattern\n";
	return 0;
}

DWORD ProcMem::Module(LPSTR ModuleName){
       
	//Variables
	HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID); //Take A Module Snapshot Of The Process (Grab All Loaded Modules)
	MODULEENTRY32 mEntry; //Declare Module Entry Structure
	mEntry.dwSize = sizeof(mEntry); //Declare Structure Size And Populate It With Loaded Modules
	
	//Scan For Module By Name
	do 
		if(!strcmp(mEntry.szModule, ModuleName))
		{
			CloseHandle(hModule);			
			return (DWORD)mEntry.modBaseAddr;	
		}
	while(Module32Next(hModule, &mEntry));
	
	cout << "\nMODULE: Process Platform Invalid\n";
	return 0;
}

ProcMem::~ProcMem(){

	//Clean Up! (Close Handle - Not Needed Anymore)
	CloseHandle(hProcess);
}

#ifndef PROCMEM_H //If Not Defined
#define PROCMEM_H //Define Now

#include "Includes.h"

class ProcMem{

public:

	//STORAGE
	HANDLE hProcess;
	DWORD dwPID;

	//FUNCTION PROTOTYPES
	ProcMem();
	~ProcMem();
    __int32 GetLength(char *chArray);
	bool Locate(int iAry[], int iSize, int iVal);
	void Patch(DWORD dwAddress, char *Patch_Bts, char *Default_Bts);
	void GetProcess(char* ProcessName);
	void Inject(DWORD dwAddress, char *Inj_Bts, char *Def_Bts, BOOL Type);
	DWORD AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *Bytes);
	DWORD Module(LPSTR ModuleName);

#pragma region TEMPLATE MEMORY FUNCTIONS

	//REMOVE READ/WRITE PROTECTION
	template <class cData>
	void Protection(DWORD dwAddress)
	{	   
		if(!bProt)
			VirtualProtectEx(hProcess, (LPVOID)dwAddress, sizeof(cData), PAGE_EXECUTE_READWRITE, &dwProtection); //Remove Read/Write Protection By Giving It New Permissions
		else
			VirtualProtectEx(hProcess, (LPVOID)dwAddress, sizeof(cData), dwProtection, &dwProtection); //Restore The Old Permissions After You Have Red The dwAddress
		
		bProt = !bProt;
	}

	//READ MEMORY 
	template <class cData>
	cData Read(DWORD dwAddress)
	{
		cData cRead; //Generic Variable To Store Data
		ReadProcessMemory(hProcess, (LPVOID)dwAddress, &cRead, sizeof(cData), NULL); //Win API - Reads Data At Specified Location 
		return cRead; //Returns Value At Specified dwAddress
	}
    	
	//READ MEMORY - Pointer
	template <class cData>
	cData Read(DWORD dwAddress, char *Offset, BOOL Type)
	{
		//Variables
		__int32 iSize = GetLength(Offset) -1; //Size Of *Array Of Offsets 
		dwAddress = Read<DWORD>(dwAddress); //HEX VAL
	
		//Loop Through Each Offset & Store Hex Value (Address) In dwTMP
		for (__int32 i = 0; i < iSize; i++)	
			dwAddress = Read<DWORD>(dwAddress + Offset[i]);

		if (!Type)
			return dwAddress + Offset[iSize]; //FALSE - Return Address
		else
			return Read<cData>(dwAddress + Offset[iSize]); //TRUE - Return Value
	}

	//WRITE MEMORY
	template <class cData>
	void Write(DWORD dwAddress, cData Value)
	{ WriteProcessMemory(hProcess, (LPVOID)dwAddress, &Value, sizeof(cData), NULL); }

	//WRITE MEMORY - Pointer
	template <class cData>
	void Write(DWORD dwAddress, char *Offset, cData Value)
	{ Write<cData>(Read<cData>(dwAddress, Offset, false), Value); }
	
#pragma endregion	

private:

	//STORAGE
    DWORD dwProtection, dwCaveAddress;

	//MISC
	BOOL bPOn, bIOn, bProt;
};
#endif