External Base for study purposes - Assault Cube

// Very thanks to HxTheDash and Fleep

#include <Windows.h>
#include <TlHelp32.h>
#include <iostream>

using namespace std;

// Address

#define LocalAddress        0x50F4F4
#define EntityAddress       0x50F4F8
#define NumberPlayers       0x50F500
#define NoRecoil            0x463786

// Offsets

#define OffSetLife          0xF8
#define OffSetJump          0x18
#define OffSetPos           0x4
#define OffSetAmmo          0x150
#define OffSetTeam          0x32C

class cPlayerLocal
{
public :

	int pLocal;
	int Life;
	float PosLocal[3];
	int pPlayers;
	int Team;

	void Read(HANDLE hProc)
	{
		ReadProcessMemory(hProc, (LPVOID)(LocalAddress), &pLocal, sizeof(DWORD), 0); // we get the base local address

		ReadProcessMemory(hProc, (LPVOID)(pLocal + OffSetLife), &Life, sizeof(DWORD), 0); // offset local life
		ReadProcessMemory(hProc, (LPVOID)(pLocal + OffSetTeam), &Team, sizeof(DWORD), 0); // offset local team

		ReadProcessMemory(hProc, (LPVOID)(pLocal + OffSetPos), &PosLocal[0], sizeof(float), 0); // offset pos 1 local
		ReadProcessMemory(hProc, (LPVOID)(pLocal + OffSetPos + 0x4), &PosLocal[1], sizeof(float), 0); // offset pos 2 local
		ReadProcessMemory(hProc, (LPVOID)(pLocal + OffSetPos + 0x4 + 0x4), &PosLocal[2], sizeof(float), 0); // offset pos 3 local

		ReadProcessMemory(hProc, (LPVOID)(NumberPlayers), &pPlayers, sizeof(DWORD), 0); // number of players in the match
	}
};

class cEntity
{
public :

	int pEntityGet, pEntity;
	int pEntityLife, Team;
	float pEntityPos[3];

	void Read(HANDLE hProc, int i)
	{
		ReadProcessMemory(hProc, (LPVOID)(EntityAddress), &pEntityGet, sizeof(DWORD), 0); // we get the base entity address

		ReadProcessMemory(hProc, (LPVOID)(pEntityGet + ( 0x4 * i ) ), &pEntity, sizeof(DWORD), 0); // loop to get all the players pointers

		ReadProcessMemory(hProc, (LPVOID)(pEntity + OffSetLife), &pEntityLife, sizeof(DWORD), 0); // offset entity life
		ReadProcessMemory(hProc, (LPVOID)(pEntity + OffSetTeam), &Team, sizeof(DWORD), 0); // offset entity team
				
		ReadProcessMemory(hProc, (LPVOID)(pEntity + OffSetPos), &pEntityPos[0], sizeof(float), 0); // offset pos 1 entity
		ReadProcessMemory(hProc, (LPVOID)(pEntity + OffSetPos + 0x4), &pEntityPos[1], sizeof(float), 0); // offset pos 2 entity
		ReadProcessMemory(hProc, (LPVOID)(pEntity + OffSetPos + 0x8), &pEntityPos[2], sizeof(float), 0); // offset pos 3 entity
	}
};

int main()
{
	int valuelife = 999, valueammo = 999;
	float valuejump = 10.0f;

	BYTE bytesize[] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90}; 

	int Hack[999];

	for( int i = 0; i < 998; i++)
		Hack[i] = 0;

	HANDLE hProc;

	HWND hWND = FindWindow(0,"AssaultCube");

	if(hWND == 0)
	{
		cout << "Cannot found the window !\n\n" << endl;
	} else {
		cout << "We found the window !";

		DWORD pId;
		GetWindowThreadProcessId(hWND, &pId);
		hProc = OpenProcess(PROCESS_ALL_ACCESS, false, pId);

		if(!hProc)
		{
			cout << "\n\nFail to get the process.";
		} else {

			cout << "\n\nWe got the process, now we will read and modify.\n\n";

			cPlayerLocal *pLocal = new cPlayerLocal();
			pLocal->Read(hProc);

			for ( int i = 1; i < pLocal->pPlayers; i ++ )
			{
				cEntity *pEntity = new cEntity();
				pEntity->Read(hProc, i);

				cout << "Life Player : " << i << " : " << pEntity->pEntityLife << "\n";
				cout << "\nPos Player : " << i << " : " << pEntity->pEntityPos[0] << " , " << pEntity->pEntityPos[1] << " , " << pEntity->pEntityPos[2] << "\n\n";
			}

			cout << "\n\nLife Local Player : " << pLocal->Life << "\n\n";
			cout << "Pos Local Player : " << pLocal->PosLocal[0] << " , " << pLocal->PosLocal[1] << " , " << pLocal->PosLocal[2] << "\n\n";

			cout << "Now, the menu of the functions :\n\n";
			cout << "/////////////////////////////////////////////////////\n"
				<< "///// NUMPAD1 -> Infinite Life ///////////\n"
				<< "///// NUMPAD2 -> Super Jump ////////\n"
				<< "///// NUMPAD3 -> NoRecoil ////////\n"
				<< "///// NUMPAD4 -> Infinite Ammo  ////////\n"
				<< "///// NUMPAD5 -> OPK  /////////////////////\n"
				<< "//////////////////////////////////////////////////////\n\n\n";

			for(;;)
			{
				if(GetAsyncKeyState(VK_NUMPAD1)&1)
					Hack[0] =! Hack[0];
				if(GetAsyncKeyState(VK_NUMPAD2)&1)
					Hack[1] =! Hack[1];
				if(GetAsyncKeyState(VK_NUMPAD3)&1)
					Hack[2] =! Hack[2];
				if(GetAsyncKeyState(VK_NUMPAD4)&1)
					Hack[3] =! Hack[3];
				if(GetAsyncKeyState(VK_NUMPAD5)&1)
					Hack[4] =! Hack[4];

				if( Hack[0] )
					WriteProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetLife), &valuelife, sizeof(valuelife), NULL);

				if( Hack[1] )
					if(GetAsyncKeyState(VK_SPACE)<0)
						WriteProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetJump), &valuejump, sizeof(valuejump), NULL);

				if( Hack[2] )
					WriteProcessMemory(hProc, (LPVOID)(NoRecoil), &bytesize, sizeof(bytesize), NULL);

				if( Hack[3] )
					WriteProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetAmmo), &valueammo, sizeof(valueammo), NULL);

				if( Hack[4] )
				{
					float valuepos[3];

					ReadProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetPos), &valuepos[0], sizeof(valuepos[0]), NULL);
					ReadProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetPos + 0x4), &valuepos[1], sizeof(valuepos[1]), NULL);
					ReadProcessMemory(hProc, (LPVOID)(pLocal->pLocal + OffSetPos + 0x8), &valuepos[2], sizeof(valuepos[2]), NULL);

					for ( int i = 1; i < pLocal->pPlayers; i ++ )
					{
						cEntity *pEntity = new cEntity();
						pEntity->Read(hProc, i);

						if( pLocal->Team =! pEntity->Team )
						{
							WriteProcessMemory(hProc, (LPVOID)(pEntity->pEntity + OffSetPos), &valuepos[0], sizeof(valuepos[0]), NULL);
							WriteProcessMemory(hProc, (LPVOID)(pEntity->pEntity + OffSetPos + 0x4), &valuepos[1], sizeof(valuepos[1]), NULL);
							WriteProcessMemory(hProc, (LPVOID)(pEntity->pEntity + OffSetPos + 0x8), &valuepos[2], sizeof(valuepos[2]), NULL);
						}
					}
				}
			}

			CloseHandle(hProc);
		}
	}

	system("pause");

	return 0;
}