C++ Memory Hacking + Offset Kullanımı

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

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

std::string GameName = "MineSweeper";// görev yöneticisindeki adı
LPCSTR LGameWindow = "MineSweeper"; //oyun pencere adı
std::string GameStatus;

bool IsGameAvail;
bool UpdateOnNextRun;

bool AmmoStatus;
int AmmoValue = 100; // değer gir
DWORD AmmoBaseAddress = {0x003590BC}; //adres
DWORD AmmoOffsets[] = {0xD4}; //Offsettt


bool HealthStatus; //
int HealthValue = 200; // değer gir
DWORD HealthBaseAddress = {0x00358FE8};/adress
DWORD HealthOffsets[] = {0xD4}; // offset

int main()
{
    
    HWND hGameWindow = NULL;
    int timeSinceLastUpdate = clock();
    int GameAvailTMR = clock();
    int OnePressTMR;
    DWORD dwProcId = NULL;
    HANDLE hProcHandle = NULL;
    UpdateOnNextRun = true;
    std::string sAmmoStatus;
    std::string sHealthStatus;
    sAmmoStatus = "KAPALI";
    sHealthStatus = "KAPALI";
    OnePressTMR = clock();
    while(!GetAsyncKeyState(VK_INSERT)) //Key is not = '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 = "Oyun Açık Değil!";
                   }
                   else
                   {
                     GameStatus = "Oyun Hile İçin Hazır!";
                     IsGameAvail = true;
                   }
               }
               else GameStatus = "Hile Başarılı Olmadı!";
            }
            else GameStatus = "Oyun Bulunamadı!";
            if(UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
            {
                system("cls");
                std::cout << "----------------------------------------------------" << std::endl;
                std::cout << "        #Küçük Şirin!! Memory Hacker! " << std::endl;
                std::cout << "----------------------------------------------------" << std::endl << std::endl;
                std::cout << "Oyun Durumu:"<< GameStatus  <<"   " << std::endl << std::endl;
                std::cout << "[F1] Hile 1 -> "<< sAmmoStatus <<" <-" << std::endl<< std::endl;
                std::cout << "[F2] Hile 2 ->" << sHealthStatus << "<-" << std::endl<< std::endl;
                std::cout << "[INSERT] Çıkış" << 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 = "AÇIK";
                    else sAmmoStatus = "KAPALI";
                }
                else if(GetAsyncKeyState(VK_F2))
                {
                    OnePressTMR = clock();
                    HealthStatus = !HealthStatus;
                    UpdateOnNextRun = true;
                    
                    if(HealthStatus)sHealthStatus = "AÇIK";
                    else sHealthStatus = "KAPALI";
                }
            }
        }
    }
    //Close any handles once the program is over
    CloseHandle( hProcHandle );
    CloseHandle(hGameWindow);

    //Returns that action was completed successfuly
    return ERROR_SUCCESS;
}


DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress)
{
    //DECLARE BASE ADDRESS
    DWORD pointer = BaseAddress;             // Declare a pointer of DWORD
    //USED TO output the contents in the pointer
    DWORD pTemp;

    DWORD pointerAddr;
    for(int i = 0; i < PointerLevel; i ++)
    {
            if(i == 0)
            {
                ReadProcessMemory(hProcHandle, (LPC****)pointer, &pTemp, 4, NULL);
            }
          
            pointerAddr = pTemp + Offsets[i];   // Set p1 to content of p + offset

          
            ReadProcessMemory(hProcHandle, (LPC****)pointerAddr, &pTemp, 4, NULL);
    }
    return pointerAddr;
}

**** WriteToMemory(HANDLE hProcHandle)
{
   if(AmmoStatus)
   {
       DWORD AmmoAddressToWrite = FindDmaAddy(3, hProcHandle, AmmoOffsets, AmmoBaseAddress);
       WriteProcessMemory( hProcHandle, (BYTE*)AmmoAddressToWrite, &AmmoValue, sizeof(AmmoValue), NULL);
   }

   if(HealthStatus)
   {
       //because health address is only one pointer in we send only to FindDmaAddy
       DWORD HealthAddressToWrite = FindDmaAddy(1, hProcHandle, HealthOffsets, HealthBaseAddress);
       WriteProcessMemory( hProcHandle, (BYTE*)HealthAddressToWrite, &HealthValue, sizeof(HealthValue), NULL);
   }
}

AÇIKLAMA;
std::string GameName = "Wolfteam.bin"; //oyunumuzun uygulama uzantısı ve adını yazıyoruz.

LPCSTR LGameWindow = "WolfTeam"; //oyunumuzun pencere adını yazıyoruz.

int AmmoValue = 100; // uygulayacağımız değeri giriyoruz.

DWORD HealthBaseAddress = {0x00358FE8}; // adresimizi tanımlıyoruz.

DWORD HealthOffsets[] = {0xD4}; // burada offsetimizi tanım