RAM, чтение и запись в RAM, Pointer ы

#include <windows.h>
#include <TlHelp32.h>
#include "MemoryManager.h"
#include <gdiplus.h>
 
#pragma comment(lib, "gdiplus.lib")
 
#define ID_BUTTON1 3000
#define ID_BUTTON2 3001
#define ID_BUTTON3 3002
#define ID_EDIT1 2000
 
 
HINSTANCE hInst;
char* szClassName = "ClassOFTheWindow";
char* szWindowName = "Sniper Elite Multiplayer Trainer";
 
WCHAR Health[32];
WCHAR Ammo[32];
WCHAR Grenades[32];
 
 
void GdiPaint(HDC hdc)
{
    Gdiplus::Graphics graphics(hdc);
    Gdiplus::SolidBrush brush(Gdiplus::Color::Chocolate);
    Gdiplus::Pen BrushPen(Gdiplus::Color::Aqua);
    Gdiplus::FontFamily fontFamily(L"Times New Roman");
    Gdiplus::Font font(&fontFamily, 24, Gdiplus::FontStyleRegular, Gdiplus::UnitPixel);
    Gdiplus::PointF HealtTextPos(10.0f, 20.0f);
    Gdiplus::PointF AmmoTextPos(10.0f, 75.0f);
 
    graphics.DrawString(Health, -1, &font, HealtTextPos, &brush);
    graphics.DrawString(Grenades, -1, &font, AmmoTextPos, &brush);
}
 
int RegClass(WNDPROC Proc, LPCTSTR szName)
{
WNDCLASS WindowClass; 
WindowClass.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS; 
WindowClass.cbClsExtra = WindowClass.cbWndExtra = 0; 
WindowClass.lpfnWndProc = Proc; 
WindowClass.hInstance = hInst; 
WindowClass.hIcon = LoadIcon(NULL, IDI_WINLOGO); 
WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW); 
WindowClass.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH); 
WindowClass.lpszMenuName = (LPCSTR)NULL; 
WindowClass.lpszClassName = szName; 
return RegisterClass(&WindowClass);
}
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
static short cx; 
static short cy; 
static short left; 
static short top;
 
HWND hEdit;
switch(msg)
{
 case WM_CREATE: { 
      
      return 0;
      }
 case WM_PAINT: {
      PAINTSTRUCT ps;
      HDC hdc = BeginPaint(hwnd, &ps);
      GdiPaint(hdc);
      EndPaint(hwnd, &ps);
      
      return 0;
      }
 case WM_MOVE: { 
      left = LOWORD(lParam);
      top = HIWORD(lParam);
      return 0;
      }
 case WM_SIZE: { 
      cx = LOWORD(lParam);
      cy = HIWORD(lParam);
      return 0;
      }
 case WM_COMMAND: { 
      switch(LOWORD(wParam))
      {   
        case ID_BUTTON1: {
             MemoryManager* MM = new MemoryManager("sniperelite.exe");
             DWORD offsets[3] = {0x438, 0x30, 0x328};
             DWORD offsetsAmmo[3] = {0x4c, 0x16c, 0x18};
             DWORD offsetsGrenades[3] = {0x594, 0x174, 0x20};
             
             wsprintfW(Health, L"Proccess ID = %d \nЖизни: %d(0x%X)         ", MM->GetPID(),
                (DWORD)MM->ReadPointer(0x1dc0e28, offsets, 3).toFloat(), MM->ReadPointer(0x1dc0e28, offsets, 3, true).toDword());
             
             wsprintfW(Ammo, L"\nПатроны: %d(0x%X)", MM->ReadPointer(0x1088F4F8, offsetsAmmo, 3).toDword(), MM->ReadPointer(0x1088F4F8, offsetsAmmo, 3, true).toDword());
             InvalidateRect(hwnd, NULL, true);
 
             wsprintfW(Grenades, L"\nЛимонки: %d(0x%X)", MM->ReadPointer(0x100f5830, offsetsGrenades, 3).toDword(), MM->ReadPointer(0x100f5830, offsetsAmmo, 3, true).toDword());
             InvalidateRect(hwnd, NULL, true);
             return 0; 
             }
      }
      return 0;
      }
 case WM_DESTROY: {
      PostQuitMessage(0);
      return 0;
      }
 }
 return DefWindowProc(hwnd, msg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
{
 MSG msg;
 HWND hwnd;
 HWND hButton1;
 Gdiplus::GdiplusStartupInput gdiplusStartupInput;
 ULONG_PTR gdiplusToken;
 if(!RegClass(WndProc, szClassName))
                       return FALSE;
 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 hwnd = CreateWindow(szClassName, szWindowName, WS_OVERLAPPEDWINDOW, 0, 0, 400, 200, NULL, NULL, hInst, NULL);
 if(!hwnd)
          return FALSE;
 
 hButton1 = CreateWindow("button", "Обновить", WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON, 100, 125, 100, 25, hwnd, (HMENU)ID_BUTTON1, hInst, NULL);
 
 ShowWindow(hwnd, SW_SHOW);
 UpdateWindow(hwnd);
 
 while(GetMessage(&msg, NULL, 0, 0))
 {
  TranslateMessage(&msg);
  DispatchMessage(&msg);
 }
 Gdiplus::GdiplusShutdown(gdiplusToken);
 return msg.wParam;
}

#define MAXBUFFER_SIZE 255
class MemoryManager
{
public: 
        MemoryManager(char* pName)
        {
         this->pName = pName;  
         UpdatePID();                  
        }
        ~MemoryManager();
        
        void UpdatePID()
{
      HANDLE SnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      PROCESSENTRY32 pInfo;
      pInfo.dwSize = sizeof(PROCESSENTRY32);
      
      if(Process32First(SnapShot, &pInfo))
      {
           while(Process32Next(SnapShot, &pInfo))
                   {
                    if(_stricmp(pName, pInfo.szExeFile) == 0)
                    {
                     pID = pInfo.th32ProcessID;
                     CloseHandle(SnapShot);
                     break;
                    }
                   }
      }
 
}
 
MemoryManager& ReadMemory(DWORD adress, DWORD size)
{
      memset(buffer, 0, MAXBUFFER_SIZE);
      DWORD OLDPROTECT = 0;
      
      HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pID);
      VirtualProtectEx(hProcess, (void*)adress, size, PAGE_EXECUTE_READWRITE, &OLDPROTECT);
      ReadProcessMemory(hProcess, (void*)adress, buffer, size, NULL);
      VirtualProtectEx(hProcess, (void*)adress, size, OLDPROTECT, &OLDPROTECT);
      CloseHandle(hProcess);
      return *this;
}
 
void WriteMemory(DWORD adress, void* content, DWORD size)
{
      DWORD OLDPROTECT = 0;
      
      HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pID);
      VirtualProtectEx(hProcess, (void*)adress, size, PAGE_EXECUTE_READWRITE, &OLDPROTECT);
      WriteProcessMemory(hProcess, (void*)adress, content, size, NULL);
      VirtualProtectEx(hProcess, (void*)adress, size, OLDPROTECT, &OLDPROTECT);
      CloseHandle(hProcess);
}
 
DWORD toDword()
{
      DWORD buf = 0;
      memcpy(&buf, buffer, sizeof(DWORD));
      return buf;
}
 
MemoryManager& ReadPointer(DWORD adress, DWORD* offset, DWORD nOffsets, bool getAddr = false)
{
        for(int i = 0; i < nOffsets; i++)
       {
       if(i == nOffsets - 1)
            {
             if(getAddr == true)
                {
                 DWORD buff = adress + offset[i];
                 memcpy(buffer, &buff, sizeof(DWORD));
                 return *this;
                }
            }
        adress = ReadMemory(adress + offset[i], sizeof(DWORD)).toDword();
       }
       return *this;
}
 
 
 
char* toStringA()
{
      DWORD len = strlen((char*)buffer);
      static char buff[MAXBUFFER_SIZE];
      memset(buff, 0, MAXBUFFER_SIZE);
      strncpy(buff, (char*)buffer, len);
      return buff;
}
float toFloat()
{
      float buf = 0.f;
      memcpy(&buf, buffer, sizeof(float));
      return buf;
}
DWORD GetPID(){return pID;}
private:
        char* pName;
        DWORD pID;
        byte buffer[MAXBUFFER_SIZE];
};

#include <iostream>
#include <windows.h>
using namespace std;
 
int main()
{
    void* p = (void*)GetModuleHandle(NULL);
    cout << p << endl;
}