Ask your agent

Run and capture the original. Copy this prompt into your coding agent:

In my GameFrame project, get the original game running where we can watch and capture it.

1. Read docs/observe/running-the-original.md and the re-observe skill.
2. Pick the environment for this game (GameFrame's emulators, DOSBox-X, Wine, a console
   emulator). Tell me what it needs before you install anything.
3. Write a script that starts the game, plays a fixed input and saves frames and state.
4. Record next to each capture the game version, the settings, the seed and the inputs.
5. Keep every capture in the ignored derived/ folder.

Observing the original

These pages describe how to run the original game, watch it, drive it and capture what it does, so each claim about the port can cite a measurement. Read them after you have used the taxonomy to find what kind of game you have.

• Running the original: where to run it, what to capture, how to drive it by script, how to compare.
• Using 86Box: configure a full period PC and sound card, and record the machine settings needed to repeat a run.
• Emulators as instruments: save states, input movies, RAM maps, comparing the port with the original frame by frame with ramdiff.py, and community records of games.
• Inputs: every kind of input from outside, where each is read, and how a port takes them through one entry point.
• Capturing the interface: why game interfaces are custom, how to inventory every screen, and how to capture and rebuild them.
• Tracing calls to the system: logging the files, clock, sound and libraries the original uses, with Wine, Process Monitor, strace and proxy libraries.
• Debugging the original: debuggers and GDB stubs for each kind of game, Ghidra's debugger and emulator, and patching a copy.
• Capturing what the game draws: apitrace, RenderDoc and dgVoodoo 2; draw order, textures, geometry and matrices from the original.
• Network games: capturing a protocol, reading its messages with pcap.py and fields.py, and checking a rebuilt server or client.
• Finding values in memory: scanning memory dumps for a value you can see, confirming the address, and finding the structure around it.
• Recording the original, and replaying it: recording a whole run from the game's memory with memrec.py, reading it with memlog.py, what an outside reader cannot see, and replaying the recording into the port with a window for each sample.
• A model to query: an object model of the game, like a web page's, with entry points for queries, input, time and capture, in both the original and the port.