gameframe

Plugin gameframe from marketplace game-frame in tanepiper/game-frame. Commands read from the repo's manifest — 6 days ago.

Skills (16)

• re-browse

  Build and grow a resource viewer for a game - first the catalogue (tools/formats/catalog.py, a static HTML page and JSON manifest of every file, its kind, entropy, hex and what the Python decoders make of it, with pictures), then the project's own viewer app on the port's readers (pictures, palettes

• re-cleanroom

  Run a source-visible specification and source-blind implementation workflow when a project wants independent reimplementation from a neutral behavior contract.

• re-emulate

  Run individual functions from a game's Windows x64 binaries (tools/emu/pe_emu.py), 32-bit x86 Windows binaries (tools/emu/pe32_emu.py) or 16-bit DOS/NE programs (tools/emu/dos_emu/) under the Unicorn emulator to capture exact ground truth for chosen inputs, and record the calls they make (random dra

• re-format

  Decode a game's data files - package/archive containers, compressed entries, resource and asset formats, save games - by finding the code that reads them, prototyping a decoder with tools/formats/reader.py, proving it against every file of its type with validate.py (all bytes consumed), then porting

• re-ghidra

  Decompile a game's binaries with Ghidra in headless mode and work with the result as text - the full export (decomp.c, functions, strings, imports, exports), queries with decomp_query.py, one-off decompiles of functions Ghidra missed, vtable and reference listings, constants read from the binary, an

• re-inventory

  First look at a game's files (Windows PE, or DOS MZ/NE/LE executables) - which binaries hold the game's own code, which engine and middleware it uses, whether it is native, managed, scripted or packed, which data containers and save files exist - and record it in docs/FINDINGS.md; then read the manu

• re-land

  Finish a reverse-engineering slice by documenting evidence, updating labels and the checklist, then committing only your own files, merging completed work into local main, and pushing. Never leave completed, merge-ready work uncommitted or waiting to merge.

• re-observe

  Run the original game where it can be watched, driven and captured - GameFrame's emulators, DOSBox-X, 86Box, Wine, a Windows machine or a streamed PC, console emulators - and capture frames, state, inputs, calls, file reads and sound as measured evidence. Also list every input from outside, inventor

• re-port

  Reimplement traced game behaviour in new code that behaves exactly like the original - mirroring its structure, numeric types and order of operations, random draw order, iteration order and integer semantics, citing the original function on every item and marking every intentional difference as a De

• re-profile

  Build an evidence-backed game profile and project quick start after the first inventory. Classify the game, engine, presentation, release, hardware and input; identify project-specific traps and the next useful steps. Ask the human only about unknowns that could change the route or goal. Use after r

• re-rea

  When and how to use REA (Reverse Engineer Anything, the rea-agents MCP server) alongside GameFrame - quick evidence-backed inspection of binaries, archives, Android/iOS/.NET/Electron/browser targets, focused decompilation and call graphs through Ghidra, and runtime observation. Use for targets the t

• re-setup

  Install and check the reverse-engineering toolchain (Ghidra, JDK 21, Python with Unicorn/pefile/capstone and optional Frida, objdump, Node for REA, Zig for the sample) and register the REA MCP server for the agent. Use at the start of a project, when a tool is missing or fails to start, or when REA

• re-site

  Build and keep a project's website - a VitePress site in sites/NAME/ (or one site/) that logs the work in live diary entries during the day, one per milestone, consolidated into one update-notes post per past day, and shows the project's own documents (findings, formats, status) through @include, so

• re-start

  Entry point for reverse engineering a game (or any closed program) with GameFrame, an agentic framework for reverse engineering games. Use first, whenever a task involves understanding, documenting or reimplementing a game from its shipped binaries and data files. Gives the rules, the loop, a first-

• re-trace

  Find and understand how the original game implements something - from a string, a resource name, an import, an export, a C++ class name or a known caller to the function, its inputs, the fields it reads and writes, the constants it uses and the loop that calls it - and write the result down as evide

• re-verify

  Prove that a reimplementation matches the original - bit-exact parity tests against emulator ground truth (bitcompare.py), random-draw order (seqdiff.py), determinism of two identical runs with digests at checkpoints and on every platform, recordings and replays, round trips of real save files, pict

Subagents (23)

• re-accelerator

  Maps how a game used the 3D card APIs of the 1990s (3dfx Glide, ATI3DCIF, S3D Toolkit and early Direct3D): imports, state calls named, texture uploads with their formats and sizes, which data files and fields each per-card build reads, and what each build gives the chip. Use when a game has a render

• re-cataloguer

  Makes an inventory of every screen of a game's interface: how to reach it, the code or layout that draws it, its states, inputs, the changes it makes, its text and font, with a capture of each state. Use before porting the interface or a menu.

• re-checker

  Checks the claims in documents: every finding has an evidence label and points to its evidence, every cited address and file exists, every external fact matches its source, and unconfirmed claims are marked. Reports or fixes what is wrong. Use before publishing documents or after research.

• re-cleanroomporter

  Implements a behavior contract in a source-blind task using only its allow-listed packet, public references and new code workspace. Use after re-specifier; does not inspect the original or source evidence.

• re-decoder

  Decodes one of the game's data files (archives, compressed entries, resources, assets, saves) by finding the code that reads it, prototyping a decoder, and proving it against every file of its type with all bytes consumed. Use when a file type is not yet understood or a decoder fails on some files.

• re-decompiler

  Exports the game's own binaries with Ghidra in headless mode (decomp.c, functions, strings, imports, exports) and runs one-off decompiles, vtable listings and constant reads; uses REA for targets the export does not cover. Use when the project needs pseudocode for a binary, including 16-bit DOS and

• re-editor

  Edits documentation, skills and posts to GameFrame's writing rules: plain English, one idea per sentence, and none of the patterns to avoid (colon reveals, \"X, not Y\" endings, matched pairs, paired clauses, \"and the\" chains, signposts, figures of speech, statements about how a page was made). Ch

• re-identifier

  Identifies the engine, the middleware, the compiler and the libraries linked into a game from its files, strings, imports, RTTI and magic numbers, labels the library code so tracing skips it, and records each with its evidence. Use at the start of a project, or when an unknown library turns up.

• re-lander

  Finishes a slice of work: writes findings into docs/ in the evidence style, adds function and field labels, updates the checklist, commits only its own files, merges completed work into local main, and pushes. Never leave completed, merge-ready work uncommitted or waiting to merge. Use at the end of

• re-listener

  Lists every input a game reads from outside: controls, clocks and timers, random seeds, files and configuration, hardware detection, window messages and network messages, with the address of each read, and proposes the port's input record. Use before porting the main loop or anything that must repla

• re-mapper

  Maps how a game uses its machine: hardware registers and ports, memory banks and overlays, video and sound chips, and the variables in RAM, with a name and evidence for each address. Use for DOS, home computer, console and arcade games before tracing their logic.

• re-matcher

  Checks whether a ready implementation matches the game's own version: a GameFrame crate (OPL2, WMA, MSVC CRT, Turbo Pascal), a released engine source or a library, by running the original on many inputs and comparing bit for bit. Use before depending on code you did not port from this game.

• re-measurer

  Runs chosen functions of the original under the Unicorn emulator (Windows x64, 32-bit x86 Windows, or 16-bit DOS/NE) to capture exact ground truth for chosen inputs, and records the calls they make, such as random draws. Use for anything a reimplementation must match bit for bit.

• re-observer

  Runs the original game where it can be watched, driven and captured (GameFrame's emulators, DOSBox-X, 86Box, Wine, a streamed PC) and records frames, state, inputs, file reads and sound as measured evidence; lists every input and screen. Use before porting a system whose behaviour must be seen.

• re-porter

  Reimplements traced and measured game behaviour in new code that behaves exactly like the original: same structure, numeric types, order of operations, random draw order, iteration order and integer semantics, citing the original function on every item. Use when writing the reimplementation of anyth

• re-publisher

  Builds and keeps the project's website in sites/NAME/ (or site/): writes a live diary entry for each milestone, consolidates each past day into one update-notes post, adds a page for each new document through @include, keeps the front page's status true, and checks that nothing from the game is on i

• re-randomiser

  Finds every random number generator in a game, its state, its seeding and every caller, then measures the draw order with call traces so a port can draw the same numbers in the same order. Use before porting anything that draws random numbers.

• re-specifier

  Writes a behavior-only contract from authorized original artifacts and keeps its source evidence in a separate ledger. Use for clean-room-style reimplementation; does not write code.

• re-surveyor

  First stage for a game. Checks the toolchain, inventories the game's files, classifies the game and builds an evidence-backed quick-start profile from its genre, engine, release, graphics, sound and input support. Reads the manual and the program's long strings into docs/lore.md and records findings

• re-tracer

  Finds how the original implements one thing, from a string, resource name, import, export, class name or known caller to the function, its inputs, the fields it reads and writes, its constants and the loop that calls it, and writes the result down as evidence. Use for any 'how does the game do X?' q

• re-typer

  Recovers the game's structures, classes and enumerations from the code that uses them: sizes from allocations, fields from constructors, serialisers and every access, the C++ containers they hold, and names from evidence, written to Ghidra and labels/fields.tsv. Use when pseudocode is full of param_

• re-vectoriser

  Finds a game's hand-written SIMD code (MMX, 3DNow!, SSE) and its separate CPU builds or code paths, groups the routines by job, matches each to its plain twin, measures both under the emulator and records which build is the reference. Use when a game has an MMX build or a CPUID-selected code path.

• re-verifier

  Proves that a reimplementation matches the original: bit-exact parity against emulator ground truth, random-draw order, determinism with digests, recordings and replays, real save files, pictures against the original. Use after every reimplemented slice and before landing it.

MCP servers (1)

• gameframe

  runs: ./gameframe serve

Hooks (7)

• SessionStart

  python3

• PreToolUse

  python3

• PreToolUse

  python3

• PreToolUse

  python3

• PreToolUse

  python3

• PostToolUse

  python3

• PostToolUseFailure

  python3

Similar plugins