memory.h

/**
 * memory.h - Memory Manager Header
 * 
 * Provides functionality for reading and writing process memory.
 * Used to interact with the game's memory space.
 * 
 * @version 1.0
 * @date 2026-08-21
 */

#pragma once
#include <Windows.h>
#include <vector>
#include <cstdint>

/**
 * MemoryManager Class
 * 
 * Handles process attachment, memory reading/writing,
 * and signature scanning functionality.
 */
class MemoryManager {
public:
    MemoryManager();
    ~MemoryManager();

    /**
     * Attach to a process by name.
     * 
     * @param processName The name of the process (e.g., "Pax Autocratica.exe")
     * @return true if attachment was successful, false otherwise
     */
    bool AttachToProcess(const wchar_t* processName);
    
    /**
     * Detach from the current process.
     */
    void Detach();

    /**
     * Read a value from memory.
     * 
     * @tparam T The type of value to read (e.g., int, float)
     * @param address The memory address to read from
     * @return The value read from memory
     */
    template<typename T>
    T Read(uintptr_t address) {
        T buffer;
        ReadProcessMemory(m_hProcess, (LPCVOID)address, &buffer, sizeof(T), nullptr);
        return buffer;
    }

    /**
     * Write a value to memory.
     * 
     * @tparam T The type of value to write (e.g., int, float)
     * @param address The memory address to write to
     * @param value The value to write
     */
    template<typename T>
    void Write(uintptr_t address, T value) {
        WriteProcessMemory(m_hProcess, (LPVOID)address, &value, sizeof(T), nullptr);
    }

    /**
     * Find a byte pattern (signature) in memory.
     * 
     * @param pattern The byte pattern to search for
     * @param mask The mask for the pattern (e.g., "xx?x")
     * @return The address where the pattern was found, or 0 if not found
     */
    uintptr_t FindSignature(const std::vector<uint8_t>& pattern, const std::vector<uint8_t>& mask);

    /**
     * Get the base address of the main module.
     * 
     * @return The base address of the game's main executable
     */
    uintptr_t GetBaseAddress() const { return m_baseAddress; }

    /**
     * Get the process handle.
     * 
     * @return The handle to the game process
     */
    HANDLE GetProcessHandle() const { return m_hProcess; }

    /**
     * Get the process ID.
     * 
     * @return The process ID of the game
     */
    DWORD GetProcessId() const { return m_pid; }

private:
    HANDLE m_hProcess;      // Handle to the game process
    DWORD m_pid;            // Process ID
    uintptr_t m_baseAddress; // Base address of the main module
};