romdevtools 0.85.0 → 0.86.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to `romdevtools`. Dates are release dates.
 (Published as `romdev-mcp` through 0.11.0; renamed to `romdevtools` in 0.13.0 —
 the `romdev-mcp` bin is kept as an alias.)
 
+## 0.86.0 — 2026-07-01
+
+- **GameTank Game Genie — a brand-new cheat-code format.** Nobody had made GameTank cheat codes
+  before; this adds a Game-Genie-style read-substitution device to the emulated GameTank core plus
+  a code format that is HARDWARE-COMPATIBLE (the same codes would work on a physical Game Genie
+  built for the console's open cart bus).
+  - Core (`romdev-core-gametank@0.2.0`): a value-override cheat device in the shared debug lib
+    (`romdev_cheat_set`/`romdev_cheat_read`/`romdev_cheat_get`, 24 slots). `MemoryRead` returns the
+    substitute byte on an address match, with optional compare-against-original (survives bank
+    switching) — exactly what a hardware Game Genie does. Any core that adds the one-line
+    `romdev_cheat_read` call to its bus read gets this for free.
+  - Format: `encodeGameTankGameGenie`/`decodeGameTankGameGenie` — a distinct 16-letter wheel
+    (`KLMNPQRSTVWXYZ23`), 16-bit address + 8-bit value (+ optional compare), scrambled with a
+    checksum. Plain codes are `XXX-XXXX`, compare codes `XXXX-XXXXX` (e.g. `$8100→0x42` = KTM-LPK3).
+    Wired into every device dispatcher; `cheats({op:'make', platform:'gametank', …})` generates
+    codes and `cheats({op:'apply'})` applies them live. GameTank's `retro_cheat_set` is a stub, so
+    `LibretroHost.setCheat` routes GameTank cheats through the romdev value-override device.
+- **jsgame test no longer skips.** It ran only under `--experimental-vm-modules`, so the default
+  suite skipped it. It now runs in an isolated forked child process (SDL is main-thread-only;
+  rungame leaks handles) driven over rawr JSON-RPC — the child carries the flag and is killed when
+  the RPC resolves, so the main suite stays clean. Suite: 1099 tests, 1099 pass, 0 skipped.
+
 ## 0.85.0 — 2026-07-01
 
 - **Native-runtime game kinds — wasmcart + jsgame are now first-class hosts.** romdev is a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "romdevtools",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "Tool server giving coding agents full control of homebrew ROM development AND reverse-engineering/romhacking across 17 retro platforms (NES, SNES, GB, Genesis, Atari, C64, PC Engine, MSX, PlayStation, N64, Dreamcast, ...) via WASM toolchains + emulator cores. Use over plain HTTP, as an Agent Skill, or as an MCP server.",
   "type": "module",
   "main": "src/mcp/server.js",
@@ -13,8 +13,7 @@
     "postinstall": "node src/install/postinstall.mjs",
     "smoke": "node --enable-source-maps src/cli/smoke.js",
     "mcp": "node --enable-source-maps src/mcp/server.js",
-    "test": "node --test 'src/**/*.test.js' 'test/**/*.test.js'",
-    "test:jsgame": "node --experimental-vm-modules --test-force-exit --test test/jsgame-host.test.js"
+    "test": "node --test 'src/**/*.test.js' 'test/**/*.test.js'"
   },
   "keywords": [
     "mcp",
@@ -59,7 +58,7 @@
     "romdev-core-fceumm": "0.11.0",
     "romdev-core-flycast": "0.2.0",
     "romdev-core-gambatte": "0.10.0",
-    "romdev-core-gametank": "0.1.0",
+    "romdev-core-gametank": "0.2.0",
     "romdev-core-geargrafx": "0.8.0",
     "romdev-core-gpgx": "0.13.0",
     "romdev-core-handy": "0.8.0",
@@ -111,5 +110,8 @@
   "homepage": "https://github.com/monteslu/romdev#readme",
   "bugs": {
     "url": "https://github.com/monteslu/romdev/issues"
+  },
+  "devDependencies": {
+    "rawr": "^1.0.1"
   }
 }

package/src/cheats/gamegenie.js

@@ -277,6 +277,98 @@ export function decodeSnesGameGenie(code) {
   return { address, value };
 }
 
+// ── GameTank Game Genie ─────────────────────────────────────────────────
+// A NEW format for Clyde Shaffer's open GameTank console — no prior art exists
+// (nobody has made GameTank cheat codes before). The GameTank CPU (W65C02S) sees a
+// flat 16-bit address space, so a code encodes a 16-bit READ address + an 8-bit
+// substitute value, plus an optional 8-bit compare byte (the compare form survives
+// the cart's flash bank switching, exactly like NES/GB compare codes). The device
+// intercepts the CPU's bus read and substitutes the value — identical behaviour to
+// a hardware Game Genie you could build for the console's open cart bus.
+//
+// Encoding: a distinct 16-letter wheel (so codes read as GameTank, not NES). The
+// payload nibbles are laid out and lightly scrambled so a small address change moves
+// several letters (the GG "feel"), then a 1-nibble checksum guards typos.
+//   plain:   6 payload nibbles (addr16 + val8) + 1 checksum = 7 letters, shown "XXX-XXXX"
+//   compare: 8 payload nibbles (addr16 + val8 + cmp8) + 1 checksum = 9 letters, "XXXX-XXXXX"
+const GT_GG_LETTERS = "KLMNPQRSTVWXYZ23"; // 16 distinct glyphs, no vowels/0-1-O-I ambiguity
+
+function gtNibblesToLetters(nibs) {
+  return nibs.map((x) => GT_GG_LETTERS[x & 0xF]).join("");
+}
+function gtLettersToNibbles(code) {
+  const clean = code.replace(/-/g, "").toUpperCase();
+  const n = [];
+  for (const ch of clean) {
+    const v = GT_GG_LETTERS.indexOf(ch);
+    if (v < 0) return null;
+    n.push(v);
+  }
+  return n;
+}
+// Simple nibble checksum: XOR of all payload nibbles, folded to 4 bits.
+function gtChecksum(payloadNibs) {
+  let c = 0;
+  for (const x of payloadNibs) c ^= x & 0xF;
+  return c & 0xF;
+}
+// Scramble/unscramble the payload-nibble ORDER (a fixed permutation) so a code
+// doesn't read as plain hex. Self-inverse pairs keep decode trivial.
+const GT_PERM6 = [3, 0, 5, 1, 4, 2];      // plain: 6 nibbles
+const GT_PERM8 = [5, 2, 7, 0, 4, 1, 6, 3]; // compare: 8 nibbles
+function applyPerm(arr, perm) { return perm.map((i) => arr[i]); }
+function invertPerm(perm) {
+  const inv = new Array(perm.length);
+  perm.forEach((p, i) => { inv[p] = i; });
+  return inv;
+}
+
+/** ENCODE → GameTank Game Genie. `address` 0..0xFFFF, `value` 0..0xFF, optional
+ *  `compare` 0..0xFF. Returns the dashed letter code, or null if out of range. */
+export function encodeGameTankGameGenie({ address, value, compare }) {
+  if (address == null || value == null) return null;
+  const a = address & 0xFFFF, v = value & 0xFF;
+  if (address < 0 || address > 0xFFFF || value < 0 || value > 0xFF) return null;
+
+  // payload nibbles, MSB-first: addr[15:12],addr[11:8],addr[7:4],addr[3:0],val[7:4],val[3:0]
+  let payload = [(a >> 12) & 0xF, (a >> 8) & 0xF, (a >> 4) & 0xF, a & 0xF, (v >> 4) & 0xF, v & 0xF];
+  let perm = GT_PERM6;
+  if (compare != null) {
+    if (compare < 0 || compare > 0xFF) return null;
+    const c = compare & 0xFF;
+    payload = payload.concat([(c >> 4) & 0xF, c & 0xF]);
+    perm = GT_PERM8;
+  }
+  const scrambled = applyPerm(payload, perm);
+  const sum = gtChecksum(payload);
+  const nibs = scrambled.concat([sum]);
+  const letters = gtNibblesToLetters(nibs);
+  // dash after the first 3 (plain) / 4 (compare) letters for readability
+  const cut = compare != null ? 4 : 3;
+  return letters.slice(0, cut) + "-" + letters.slice(cut);
+}
+
+/** Decode a GameTank Game Genie code → { address, value, compare? } or null. */
+export function decodeGameTankGameGenie(code) {
+  const n = gtLettersToNibbles(code);
+  if (!n) return null;
+  let perm, payloadLen;
+  if (n.length === 7) { perm = GT_PERM6; payloadLen = 6; }
+  else if (n.length === 9) { perm = GT_PERM8; payloadLen = 8; }
+  else return null;
+
+  const scrambled = n.slice(0, payloadLen);
+  const sum = n[payloadLen];
+  const payload = applyPerm(scrambled, invertPerm(perm));
+  if (gtChecksum(payload) !== sum) return null; // typo / not a valid GameTank code
+
+  const address = ((payload[0] << 12) | (payload[1] << 8) | (payload[2] << 4) | payload[3]) & 0xFFFF;
+  const value = ((payload[4] << 4) | payload[5]) & 0xFF;
+  if (payloadLen === 6) return { address, value };
+  const compare = ((payload[6] << 4) | payload[7]) & 0xFF;
+  return { address, value, compare };
+}
+
 // ── Game Boy GameShark ──────────────────────────────────────────────────
 // 8 hex digits "TTVVAAAA": TT = type/RAM-bank byte, VV = replacement value,
 // AAAA = the RAM address in LITTLE-ENDIAN order. (Distinct from GB Game Genie,
@@ -340,6 +432,11 @@ export function detectDevice(code, platform) {
       if (hex8 || hyphenHex) return "action-replay"; // SMS/GG Action Replay
       if (/^[0-9A-F]{3}-[0-9A-F]{3}/i.test(c)) return "game-genie";
       return "unknown";
+    case "gametank":
+      // 7-letter (XXX-XXXX) or 9-letter (XXXX-XXXXX) GameTank wheel code.
+      if (/^[KLMNPQRSTVWXYZ23]{3}-[KLMNPQRSTVWXYZ23]{4}$/i.test(c) ||
+          /^[KLMNPQRSTVWXYZ23]{4}-[KLMNPQRSTVWXYZ23]{5}$/i.test(c)) return "game-genie";
+      return "unknown";
     default:
       return "unknown";
   }
@@ -370,6 +467,8 @@ export function decodeCode(code, platform) {
     case "gg":
       // SMS/GG Action Replay raw-hex (addr/val, no scramble).
       return decodeProActionReplay(c, platform);
+    case "gametank":
+      return decodeGameTankGameGenie(c);
     default:
       return null;
   }
@@ -476,6 +575,7 @@ export function nativeDevicesFor(platform) {
     case "snes": return ["pro-action-replay", "game-genie"];
     case "gb": case "gbc": return ["game-genie", "gameshark"];
     case "sms": case "gg": return ["action-replay"];
+    case "gametank": return ["game-genie"];
     default: return ["raw"];
   }
 }
@@ -494,6 +594,7 @@ export function encodeForDevice({ address, value, compare }, platform, device) {
       else if (["genesis", "megadrive", "md"].includes(platform)) code = encodeGenesisGameGenie({ address, value });
       else if (["gb", "gbc"].includes(platform)) code = encodeGbGameGenie({ address, value, compare });
       else if (platform === "snes") code = encodeSnesGameGenie({ address, value });
+      else if (platform === "gametank") code = encodeGameTankGameGenie({ address, value, compare });
       return code ? { code, device: "game-genie" } : null;
     }
     case "pro-action-replay": {

package/src/host/LibretroHost.js

@@ -214,6 +214,11 @@ export const PLATFORM_VIRTUAL_EXT = {
   msx:        ".rom",
 };
 import { RETRO_DEVICE_JOYPAD, ROMDEV_PIXEL_FORMAT_RGBA8888 } from "./retroConstants.js";
+import { decodeCode as decodeCheatCode } from "../cheats/gamegenie.js";
+
+// Platforms whose core stubs retro_cheat_set but ships romdev's value-override cheat
+// device (romdev_cheat_set) — cheats route through that read-substitution instead.
+const CHEAT_PREFER_ROMDEV_DEVICE = new Set(["gametank"]);
 
 // C64 controller→keyboard map (the Batocera/RetroDeck model: a CONTROLLER alone
 // plays C64 — no physical keyboard needed — by mapping spare buttons/stick to
@@ -1536,7 +1541,18 @@ export class LibretroHost {
    *  (Older bundled cores predate the cheat-export build flag.) */
   cheatsSupported() {
     const mod = this.mod;
-    return !!(mod && typeof mod._retro_cheat_set === "function");
+    // Real cheat support = EITHER the core's retro_cheat_set actually applies codes,
+    // OR romdev's value-override cheat device (romdev_cheat_set) is present. Some cores
+    // (GameTank) stub retro_cheat_set but ship the romdev_cheat_* read-substitution
+    // device — that's the working path for them.
+    return !!(mod && (typeof mod._romdev_cheat_set === "function" || typeof mod._retro_cheat_set === "function"));
+  }
+
+  /** True if this core applies cheats via romdev's value-override device (romdev_cheat_set)
+   *  rather than the libretro retro_cheat_set (which is a stub on some cores). */
+  _usesRomdevCheatDevice() {
+    return !!(this.mod && typeof this.mod._romdev_cheat_set === "function" &&
+      CHEAT_PREFER_ROMDEV_DEVICE.has(this.status.platform));
   }
 
   /**
@@ -1553,6 +1569,32 @@ export class LibretroHost {
    */
   setCheat(index, code, enabled = true) {
     const mod = this._needMod();
+
+    // romdev value-override device (GameTank etc.): the core's retro_cheat_set is a
+    // stub, but romdev_cheat_set installs a hardware-faithful read substitution. Decode
+    // the code to {address,value,compare} and hand it to the device.
+    if (this._usesRomdevCheatDevice()) {
+      const decoded = decodeCheatCode(String(code), this.status.platform);
+      if (!decoded || decoded.address == null || decoded.value == null) {
+        throw new Error(
+          `setCheat: could not decode '${code}' for ${this.status.platform}. ` +
+          `Provide a GameTank Game Genie code or a raw ADDR:VAL[:COMPARE].`,
+        );
+      }
+      mod._romdev_cheat_set(
+        index >>> 0,
+        decoded.address & 0xFFFF,
+        decoded.value & 0xFF,
+        (decoded.compare ?? 0) & 0xFF,
+        decoded.compare != null ? 1 : 0,
+        enabled ? 1 : 0,
+      );
+      if (!this._activeCheats) this._activeCheats = new Map();
+      if (enabled) this._activeCheats.set(index, code);
+      else this._activeCheats.delete(index);
+      return;
+    }
+
     if (typeof mod._retro_cheat_set !== "function") {
       throw new Error(
         "this core build does not expose the cheat interface (retro_cheat_set). " +

package/src/mcp/tools/cheats.js

@@ -18,6 +18,9 @@ const GG_ADDR_RANGE = {
   snes: [0x008000, 0xFFFFFF], // mapped ROM ($xx:8000-$xx:FFFF); the Game Genie
                               // ROM device patches here. (Pro Action Replay is
                               // a RAM poke — for a ROM patch we pick GG below.)
+  gametank: [0x0000, 0xFFFF], // flat 16-bit CPU space. GameTank's Game Genie is a
+                              // READ substitution on the bus, so any read address is
+                              // valid (RAM or cart ROM). A NEW format — see gamegenie.js.
 };
 
 // The native ROM-PATCH device per platform (installs a read-intercept), as
@@ -94,6 +97,7 @@ const SUPPORTED = new Set([
 const MAKE_CHEAT_PLATFORMS = [
   "nes", "gb", "gbc", "snes", "genesis", "sms", "gg",
   "atari2600", "atari7800", "lynx", "gba", "c64", "pce", "msx",
+  "gametank", // NEW: GameTank Game Genie (read-substitution device) — see gamegenie.js
 ];
 
 // gameCheats indexes whose codes are predominantly ENCRYPTED at the source