memory.cpp

/**
 * memory.cpp - Memory Manager Implementation
 * 
 * Implements the MemoryManager class for process interaction.
 * Uses Windows API functions for process and memory manipulation.
 * 
 * @version 1.0
 * @date 2026-08-21
 */

#include "memory.h"
#include <TlHelp32.h>
#include <iostream>

MemoryManager::MemoryManager() 
    : m_hProcess(nullptr), m_pid(0), m_baseAddress(0) {}

MemoryManager::~MemoryManager() {
    Detach();
}

bool MemoryManager::AttachToProcess(const wchar_t* processName) {
    // Create a snapshot of all running processes
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return false;
    }

    // Iterate through processes
    PROCESSENTRY32 pe = { sizeof(PROCESSENTRY32) };
    if (!Process32First(hSnapshot, &pe)) {
        CloseHandle(hSnapshot);
        return false;
    }

    do {
        // Compare process name (case-insensitive)
        if (_wcsicmp(pe.szExeFile, processName) == 0) {
            // Found the game process
            m_pid = pe.th32ProcessID;
            m_hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, m_pid);
            CloseHandle(hSnapshot);

            if (m_hProcess) {
                // Get the base address of the main module (the .exe)
                HANDLE hModuleSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_pid);
                if (hModuleSnapshot != INVALID_HANDLE_VALUE) {
                    MODULEENTRY32 me = { sizeof(MODULEENTRY32) };
                    if (Module32First(hModuleSnapshot, &me)) {
                        m_baseAddress = (uintptr_t)me.modBaseAddr;
                    }
                    CloseHandle(hModuleSnapshot);
                }
                return true;
            }
        }
    } while (Process32Next(hSnapshot, &pe));

    CloseHandle(hSnapshot);
    return false;
}

void MemoryManager::Detach() {
    if (m_hProcess) {
        CloseHandle(m_hProcess);
        m_hProcess = nullptr;
    }
    m_pid = 0;
    m_baseAddress = 0;
}

uintptr_t MemoryManager::FindSignature(const std::vector<uint8_t>& pattern, const std::vector<uint8_t>& mask) {
    /**
     * Note: This is a placeholder implementation.
     * In a real project, this would perform a full memory scan
     * to find the specified byte pattern.
     * 
     * The actual implementation would:
     * 1. Read the entire module memory region
     * 2. Search for the pattern using the mask
     * 3. Return the address where it was found
     */
    return m_baseAddress + 0x1000; // Placeholder offset
}