🎮 Game Memory Editor MCP Server

A high-performance Model Context Protocol (MCP) server that equips Antigravity and LLM agents with native, real-time memory inspection, multi-stage value scanning, pointer chain traversal, Cheat Engine Table (.CT) execution, Lua scripting, reflective manual mapping, and stealth low-footprint operations for single-player games on Windows.

🏛️ Architecture Overview

                               ┌────────────────────────────────────────────────────────┐
                               │                      Antigravity                       │
                               │                (AI Coding Assistant)                   │
                               └───────────────────────────┬────────────────────────────┘
                                                           │  MCP Tool Call (JSON-RPC)
                                                           ▼
┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                           Game Memory Editor MCP Server                                           │
├───────────────────────────────┬───────────────────────────────┬───────────────────────────────┬───────────────────┤
│        Memory Engine          │        Stealth Engine         │       Modding & Tables        │   Manual Mapper   │
│  • Fast Regex AOB Scanner     │  • Direct NTDLL Syscalls      │  • Cheat Table (.CT) Parser   │  • PE Mapper      │
│  • Multi-stage Value Scanner  │  • Ephemeral Handle Lifecycle │  • LuaJIT Runtime (CE Globals)│  • Base Relocs    │
│  • Multilevel Pointer Chains  │  • Smart Adaptive Freezing    │  • Script Obfuscation (XOR)   │  • IAT Resolution │
│  • Memory Protection Restore  │  • Jittered Polling Delays    │  • Standard DLL Injector      │  • Wiped Headers  │
└───────────────────────────────┴───────────────┬───────────────┴───────────────────────────────┴───────────────────┘
                                                │  Win32 / Native NT Syscalls
                                                ▼
                               ┌────────────────────────────────────────────────────────┐
                               │               Single-Player Game Process               │
                               │                   (x64 / x86 Virtual Memory)           │
                               └────────────────────────────────────────────────────────┘

Related MCP server: memscope-mcp

⚡ Key Capabilities

1. 🔍 High-Performance Memory Scanner

• Regex-Accelerated AOB Pattern Scanner: Compiled regular expressions scan committed memory pages in 2MB chunks with wildcards (??), executing up to 100x faster than naive loops.

• Multi-Stage Value Filtering: Supports first_scan and next_scan with exact value, increased, decreased, changed, and unchanged modes.

• Precision Floating-Point Support: Accurate float (f32) and double (f64) comparisons using math.isclose to eliminate IEEE-754 rounding discrepancies.

• Multilevel Pointer Chains: Resolves nested pointer offsets (base + off1 -> [ptr] + off2 -> [ptr] + ...).

2. 🥷 Stealth & Low-Footprint Operations

• Direct NT Syscalls: Calls NtReadVirtualMemory, NtWriteVirtualMemory, and NtProtectVirtualMemory directly, bypassing user-mode hooks placed on kernel32.dll.

• Ephemeral Handle Lifecycle: Opens handles on demand with minimal required access rights (PROCESS_VM_READ | PROCESS_VM_WRITE) and closes them immediately, leaving no persistent open handle signatures.

• Smart Adaptive Freezing (Write-on-Change): Reads memory before writing and only issues a write when the value changes in-game (e.g., 40 checks resulted in only 1 actual write in tests).

• Timing Jitter: Introduces randomized micro-delays (e.g. 40ms–120ms) to disrupt static polling frequency heuristics.

• Memory Protection Restoration: Automatically elevates page protections to PAGE_EXECUTE_READWRITE before writing and restores the original page protection immediately afterward.

3. 📜 Cheat Engine Table (.CT) Integration

• Native XML Parser: Parses Cheat Engine tables, resolving module-relative addresses ("game.exe"+01A2B3C0), negative offsets ("game.exe"-0x50), and deep pointer chains.

• Direct Value Manipulation: Read, write, and freeze individual table entries without launching the Cheat Engine GUI.

4. 🌙 Embedded Lua Scripting Runtime

• Cheat Engine API Compatibility: Provides built-in functions:

  readInteger(addr), writeInteger(addr, value)
  readFloat(addr),   writeFloat(addr, value)
  readDouble(addr),  writeDouble(addr, value)
  readString(addr),  writeString(addr, value)
  freeze(addr, type, value), unfreeze(addr)
  getModuleBase(name), print(...)

• Script Obfuscation: Encrypts scripts using multi-byte rolling XOR keys and outputs standalone self-decrypting Lua stubs that execute in-memory.

5. 💉 Reflective Manual Mapping & DLL Injection

• PE Manual Mapper: Maps DLLs directly into process memory without LoadLibraryW:

  • Maps .text, .rdata, .data sections to their virtual addresses.

  • Applies Base Relocations (IMAGE_DIRECTORY_ENTRY_BASERELOC).

  • Resolves Import Address Tables (IAT) (IMAGE_DIRECTORY_ENTRY_IMPORT).

  • Executes DllMain via an ABI-compliant assembly trampoline.

  • Wipes PE headers from target memory to hide from memory scanners.

• Standard Win32 Injector: CreateRemoteThread injection with thread exit code validation.

🛠️ MCP Tools Reference

Process & Memory Management

Memory Scanning

Stealth & Low-Footprint

Cheat Tables & Scripting

🚀 Quickstart

1. Installation

Clone repository and install dependencies:

git clone https://github.com/ZiggyBonham/game-memory-mcp.git
cd game-memory-mcp
pip install -r requirements.txt

2. Antigravity MCP Registration

Add the server to your ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "game-memory": {
      "command": "python",
      "args": [
        "C:\\Users\\Ziggy\\mcp-servers\\game-memory\\server.py"
      ]
    }
  }
}

3. Example Agent Conversations

Memory Scanning Flow:

User: "Attach to hades.exe and search for my health which is currently 250."
Antigravity: Calls attach_process("hades.exe"), then first_scan("hp", "int32", 250).
User: "I took damage, health is now 215. Filter the scan."
Antigravity: Calls next_scan("hp", "exact", 215).
User: "Set health to 5000 and smart-freeze it."
Antigravity: Calls smart_freeze("0x140A2C48", "int32", 5000).

Cheat Table Flow:

User: "Load EldenRing.CT and show me the player stats."
Antigravity: Calls load_cheat_table("er", "C:\\Cheats\\EldenRing.CT"), then list_cheat_table_entries("er").
User: "Freeze Runes to 9999999."
Antigravity: Calls set_cheat_table_entry("er", "entry_runes", 9999999, freeze=True).

🧪 Automated Test Suites

Run the complete verification battery:

# Core memory engine (Attach, Scan, Read, Write, Freeze, Unfreeze)
python test_suite.py

# Modding features (Lua Scripting, Cheat Tables)
python test_extended_features.py

# Stealth features (Direct NT Syscalls, Smart Freeze, Protection Restore, Obfuscator)
python test_stealth.py

# High-speed optimizations (parse_address, Float Scanning, Regex AOB Scan)
python test_optimizations.py

🛡️ Requirements & Safety Notice

1. Windows Administrator Privileges: Modifying virtual memory of external processes (PROCESS_VM_WRITE, PROCESS_VM_READ) requires running your terminal / IDE with Administrator rights.

2. Single-Player Games Only: This tool is designed strictly for offline single-player games and reverse-engineering research. Games utilizing active anti-cheat engines (Easy Anti-Cheat, BattlEye, Vanguard) must be launched offline with anti-cheat disabled.

📄 License

Distributed under the MIT License. Copyright (c) 2026 Ziggy.