#include <iostream>
#include <Windows.h>
#include <string>
#include <ctime>


DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress);
void WriteToMemory(HANDLE hProcHandle);

std::string GameName = "AssultCube";
LPCSTR LGameWindow = "AssultCube";
std::string GameStatus;

bool IsGameAvail;
bool UpdateOnNextRun;

//Ammo Variables
bool AmmoStatus;
BYTE AmmoValue[] = {0xA3, 0x1c, 0x0, 0x0};
DWORD AmmoBaseAddress = {0x004DF73C};
DWORD AmmoOffsets[] = {0x378, 0x14, 0x0};

//Health Variables
bool HealthStatus;
BYTE HealthValue[] = {0x39, 0x5, 0x0, 0x0};
DWORD HealthBaseAddress = {0x004e4dbc};
DWORD HealthOffsets[] = {0xF4};


int main()
{
	HWND hGameWindow = NULL;
	int timeSinceLastUpdate = clock();
	int GameAvailTMR = clock();
	int OnePressTMR = clock();
	DWORD dwProcID = NULL;
	HANDLE hProcHandle = NULL;
	UpdateOnNextRun = true;
	std::string sAmmoStatus = "OFF";
	std::string sHealthStatus = "OFF";
		
	
	while(!GetAsyncKeyState(VK_INSERT));
	{		
		if(clock() - GameAvailTMR > 100)
		{
			GameAvailTMR = clock();
			IsGameAvail = false;

			hGameWindow = FindWindow(NULL, LGameWindow);
			if(hGameWindow)
			{
				GetWindowThreadProcessId(hGameWindow, &dwProcID);
				if(dwProcID !=0)
				{
					hProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcID);
					if(hProcHandle == INVALID_HANDLE_VALUE || hProcHandle == NULL)
					{
						GameStatus = "Failed to open Process for handle";			
					}
					else
					{
						GameStatus = "Assult Cube ready to hack";
						IsGameAvail = true;
					}
				}
				else
				{
					GameStatus = "Failed to get process ID";
				}
			}
			else
			{
				GameStatus = "Assult Cube NOT FOUND";
			}

			if(UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
			{
				system("cls");
				std::cout << "------------------------------------------------" << std::endl ;
				std::cout << "           Assult Cube Memory Hacker"                << std::endl;
				std::cout << "------------------------------------------------" << std::endl << std::endl;
			    std::cout << "Game Status:" << GameStatus << std::endl << std::endl;
				std::cout << "[F1] Unlimited ammo ->" << sAmmoStatus << "<-" << std::endl << std::endl;
				std::cout << "[F2] Unlimited health ->" << sHealthStatus << "<-" << std::endl << std::endl;
				std::cout << "[INSERT] to EXIT" << std::endl;

				UpdateOnNextRun = false;
				timeSinceLastUpdate = clock();
			}
			if(IsGameAvail)
			{
				WriteToMemory(hProcHandle);
			}
		}

		if(clock() - OnePressTMR > 400)
		{
			if(IsGameAvail)
			{
				if(GetAsyncKeyState(VK_F1))
				{
					OnePressTMR = clock();
					AmmoStatus = !AmmoStatus;
					UpdateOnNextRun = true;
					if(AmmoStatus)sAmmoStatus = "ON";
					else sAmmoStatus = "OFF";
				}
				else if(GetAsyncKeyState(VK_F2))
				{
					OnePressTMR = clock();
					HealthStatus = !HealthStatus;
					UpdateOnNextRun = true;
					if(HealthStatus)sHealthStatus = "ON";
					else sHealthStatus = "OFF";
				}
			}
		}	
	}
		
	CloseHandle(hProcHandle);
	CloseHandle(hGameWindow);
	return ERROR_SUCCESS;		

}
	


DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress)
{
	DWORD pointer = BaseAddress;
	DWORD pTemp;
	DWORD pointerAddr;
	for(int i = 0; i < PointerLevel; i++)
	{
		if(i == 0)
		{
			ReadProcessMemory(hProcHandle, (LPCVOID)pointer, &pTemp, sizeof(pTemp), NULL); 
		}
		pointerAddr = pTemp + Offsets[i];
		ReadProcessMemory(hProcHandle, (LPCVOID)pointerAddr, &pTemp, sizeof(pTemp), NULL);
	}
	return pointerAddr;

}



void WriteToMemory(HANDLE hProcHandle)
{
	DWORD AddressToWrite;
	if(AmmoStatus)
	{
		AddressToWrite = FindDmaAddy(3, hProcHandle, AmmoOffsets, AmmoBaseAddress);
		WriteProcessMemory(hProcHandle,(BYTE*)AddressToWrite, &AmmoValue, sizeof(AmmoValue), NULL);
	}
	if(HealthStatus)
	{
		AddressToWrite = FindDmaAddy(1, hProcHandle, HealthOffsets, HealthBaseAddress);
		WriteProcessMemory(hProcHandle,(BYTE*)AddressToWrite, &HealthValue, sizeof(HealthValue), NULL);
	}
}