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

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


std::string GameName = "Sta";
LPCSTR LGameWindow = "Sta (64-bit, PCD3D_SM5)";
std::string GameStatus;


bool IsGameAvail;
bool UpdateOnNextRun;

bool FireStatus;
BYTE FireValue[] = { 0x10,0x0,0x0,0x0 };
DWORD FireBaseAddress = { 0x04be6798 };
DWORD FireOffsets[] = { 0x1b8, 0x20, 0x400, 0x78, 0x3bc };


int main()
{

    HWND hGameWindow = NULL;
    int timeSinceLastUpdate = clock();
    int GameAvailTMR = clock();
    int OnePressTMR;
    DWORD dwProcId = NULL;
    HANDLE hProcHandle = NULL;
    UpdateOnNextRun = true;
    std::string sFireStatus;
    sFireStatus = "OFF";
    OnePressTMR = clock();
    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 valid handle";
                    }
                    else
                    {
                        GameStatus = "Ready to hack";
                        IsGameAvail = true;
                    }
                }
                else GameStatus = "Failed to obtain process id";
            }
            else GameStatus = "game NOT FOUND";

            if (UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
            {
                system("cls");
                std::cout << "----------------------------------------------------" << std::endl;
                std::cout << "        memory hacker" << std::endl;
                std::cout << "----------------------------------------------------" << std::endl << std::endl;
                std::cout << "GAME STATUS:" << GameStatus << "   " << std::endl << std::endl;
                std::cout << "[F1] cheat -> " << sFireStatus << " <-" << std::endl << std::endl;
                std::cout << "[INSERT] Exit" << std::endl;
                std::cout << FindDmaAddy(5, hProcHandle, FireOffsets, FireBaseAddress);
                UpdateOnNextRun = false;
                timeSinceLastUpdate = clock();
            }

            if (IsGameAvail)
            {
                WriteToMemory(hProcHandle);
            }
        }

        if (clock() - OnePressTMR > 400)
        {
            if (IsGameAvail)
            {
                if (GetAsyncKeyState(VK_F1))
                {
                    OnePressTMR = clock();
                    FireStatus = !FireStatus;
                    UpdateOnNextRun = true;
                    if (FireStatus)sFireStatus = "ON";
                    else sFireStatus = "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, 4, NULL);
        }
        pointerAddr = pTemp + Offsets[i];


        ReadProcessMemory(hProcHandle, (LPCVOID)pointerAddr, &pTemp, 4, NULL);

    }
    return pointerAddr;
}

void WriteToMemory(HANDLE hProcHandle)
{
    if (FireStatus)
    {
        DWORD AmmoAddressToWrite = FindDmaAddy(5 ,hProcHandle, FireOffsets, FireBaseAddress);
        WriteProcessMemory(hProcHandle, (BYTE*)AmmoAddressToWrite, &FireValue, sizeof(FireValue), NULL);
    }
}