romdevtools 0.71.1 → 0.84.1

package/examples/gametank/templates/shmup.c

@@ -0,0 +1,277 @@
+/* ── shmup.c — GameTank vertical shooter (complete example game) ─────────────
+ *
+ * A COMPLETE, working game on the bundled GameTank SDK draw-queue runtime: an
+ * arrowhead fighter you fly along the bottom, enemy raiders that fall from the
+ * top, gold missiles you fire up, explosions on a kill, a score/lives HUD, SFX,
+ * and a title → play → game-over → restart loop. Drawn with REAL pixel-art
+ * sprites loaded into graphics RAM at runtime (gt_sprites.h) and blitted with
+ * per-pixel color + transparency.
+ *
+ * FORK THIS. Markers:
+ *   HARDWARE IDIOM (load-bearing) — the GameTank draws via a blitter DRAW QUEUE
+ *     (gt_draw.h): enqueue rects/sprites each frame, then gt_present() drains the
+ *     queue, waits a vblank, and flips the double buffer. Sprites live in GRAM
+ *     (gt_load_sprite writes the pixels once at init). Don't fire blits by hand.
+ *   GAME LOGIC (clay) — sprite art, speeds, spawn timing, scoring: tune freely.
+ *
+ * SCREEN: 128x128. PLAYERS: 1. CONTROLS: D-pad move, A or START to fire/confirm.
+ */
+#include "gametank.h"
+#include "draw_queue.h"
+#include "input.h"
+#include "gt_palette.h"
+#include "gt_draw.h"
+#include "gt_sprites.h"
+#include "gt_hud.h"
+#include "gt_sound.h"
+
+/* ── palette ── */
+#define C_SPACE  GT_DKBLUE
+#define C_HUDBAR GT_NAVY
+#define C_HUD    GT_WHITE
+#define C_LIFE   GT_GREEN
+
+/* ── sprite art (palette-index bytes; 0 = transparent). short aliases for art. ── */
+#define C GT_CYAN
+#define W GT_WHITE
+#define T GT_TEAL
+#define G GT_GOLD
+#define O GT_ORANGE
+#define M GT_MAGENTA
+#define U GT_PURPLE
+#define R GT_RED
+#define Y GT_YELLOW
+
+#define SHIP_W 16
+#define SHIP_H 16
+static const unsigned char ART_SHIP[SHIP_W * SHIP_H] = {
+  0,0,0,0,0,0,0,C,C,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,C,C,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,C,W,W,C,0,0,0,0,0,0,
+  0,0,0,0,0,0,C,W,W,C,0,0,0,0,0,0,
+  0,0,0,0,0,C,C,W,W,C,C,0,0,0,0,0,
+  0,0,0,0,C,C,T,T,T,T,C,C,0,0,0,0,
+  0,0,0,C,C,T,T,T,T,T,T,C,C,0,0,0,
+  0,0,C,C,T,T,T,W,W,T,T,T,C,C,0,0,
+  0,C,C,T,T,T,T,W,W,T,T,T,T,C,C,0,
+  C,C,T,T,T,T,T,T,T,T,T,T,T,T,C,C,
+  C,C,C,T,T,T,T,T,T,T,T,T,T,C,C,C,
+  C,0,C,C,T,T,T,T,T,T,T,T,C,C,0,C,
+  0,0,0,C,C,0,T,T,T,T,0,C,C,0,0,0,
+  0,0,0,0,0,0,G,G,G,G,0,0,0,0,0,0,
+  0,0,0,0,0,G,O,G,G,O,G,0,0,0,0,0,
+  0,0,0,0,0,0,O,0,0,O,0,0,0,0,0,0,
+};
+
+#define ENEMY_W 16
+#define ENEMY_H 16
+static const unsigned char ART_ENEMY[ENEMY_W * ENEMY_H] = {
+  0,0,0,0,0,0,R,R,R,R,0,0,0,0,0,0,
+  0,0,0,0,0,R,R,M,M,R,R,0,0,0,0,0,
+  0,0,0,0,R,R,M,M,M,M,R,R,0,0,0,0,
+  0,0,0,R,R,M,M,U,U,M,M,R,R,0,0,0,
+  0,0,R,R,M,M,U,W,W,U,M,M,R,R,0,0,
+  0,R,R,M,M,U,W,Y,Y,W,U,M,M,R,R,0,
+  R,R,M,M,U,W,Y,R,R,Y,W,U,M,M,R,R,
+  R,M,M,U,U,W,Y,R,R,Y,W,U,U,M,M,R,
+  R,M,M,U,W,W,Y,Y,Y,Y,W,W,U,M,M,R,
+  0,R,M,M,U,U,W,W,W,W,U,U,M,M,R,0,
+  0,R,R,M,M,M,U,U,U,U,M,M,M,R,R,0,
+  0,0,R,R,M,M,M,M,M,M,M,M,R,R,0,0,
+  0,0,0,R,R,R,M,M,M,M,R,R,R,0,0,0,
+  0,0,R,R,0,R,R,M,M,R,R,0,R,R,0,0,
+  0,R,R,0,0,0,R,R,R,R,0,0,0,R,R,0,
+  R,R,0,0,0,0,0,R,R,0,0,0,0,0,R,R,
+};
+
+#define SHOT_W 6
+#define SHOT_H 10
+static const unsigned char ART_SHOT[SHOT_W * SHOT_H] = {
+  0,0,W,W,0,0,
+  0,G,W,W,G,0,
+  0,G,W,W,G,0,
+  G,G,W,W,G,G,
+  G,G,W,W,G,G,
+  G,G,G,G,G,G,
+  0,G,G,G,G,0,
+  0,O,O,O,O,0,
+  0,0,O,O,0,0,
+  0,0,Y,Y,0,0,
+};
+
+#define BOOM_W 16
+#define BOOM_H 16
+static const unsigned char ART_BOOM[BOOM_W * BOOM_H] = {
+  0,0,0,Y,0,0,0,R,R,0,0,0,Y,0,0,0,
+  0,0,0,0,O,0,Y,O,O,Y,0,O,0,0,0,0,
+  0,Y,0,0,0,O,O,Y,Y,O,O,0,0,0,Y,0,
+  0,0,0,O,O,Y,Y,W,W,Y,Y,O,O,0,0,0,
+  Y,0,O,O,Y,W,W,W,W,W,W,Y,O,O,0,Y,
+  0,0,O,Y,W,W,Y,O,O,Y,W,W,Y,O,0,0,
+  0,O,Y,W,Y,O,O,R,R,O,O,Y,W,Y,O,0,
+  R,O,O,W,O,O,R,R,R,R,O,O,W,O,O,R,
+  R,O,O,W,O,O,R,R,R,R,O,O,W,O,O,R,
+  0,O,Y,W,Y,O,O,R,R,O,O,Y,W,Y,O,0,
+  0,0,O,Y,W,W,Y,O,O,Y,W,W,Y,O,0,0,
+  Y,0,O,O,Y,W,W,W,W,W,W,Y,O,O,0,Y,
+  0,0,0,O,O,Y,Y,W,W,Y,Y,O,O,0,0,0,
+  0,Y,0,0,0,O,O,Y,Y,O,O,0,0,0,Y,0,
+  0,0,0,0,O,0,Y,O,O,Y,0,O,0,0,0,0,
+  0,0,0,Y,0,0,0,R,R,0,0,0,Y,0,0,0,
+};
+
+#undef C
+#undef W
+#undef T
+#undef G
+#undef O
+#undef M
+#undef U
+#undef R
+#undef Y
+
+/* Each sprite gets its own GRAM row band (gy step 16) so a 16-wide sprite can't
+ * read into the next one's columns. */
+static GtSprite SPR_SHIP, SPR_ENEMY, SPR_SHOT, SPR_BOOM;
+static void load_art(void) {
+  SPR_SHIP.gx  = 0; SPR_SHIP.gy  = 0;  SPR_SHIP.w  = SHIP_W;  SPR_SHIP.h  = SHIP_H;
+  SPR_ENEMY.gx = 0; SPR_ENEMY.gy = 16; SPR_ENEMY.w = ENEMY_W; SPR_ENEMY.h = ENEMY_H;
+  SPR_SHOT.gx  = 0; SPR_SHOT.gy  = 32; SPR_SHOT.w  = SHOT_W;  SPR_SHOT.h  = SHOT_H;
+  SPR_BOOM.gx  = 0; SPR_BOOM.gy  = 48; SPR_BOOM.w  = BOOM_W;  SPR_BOOM.h  = BOOM_H;
+  gt_load_sprite(ART_SHIP,  SPR_SHIP.gx,  SPR_SHIP.gy,  SHIP_W,  SHIP_H);
+  gt_load_sprite(ART_ENEMY, SPR_ENEMY.gx, SPR_ENEMY.gy, ENEMY_W, ENEMY_H);
+  gt_load_sprite(ART_SHOT,  SPR_SHOT.gx,  SPR_SHOT.gy,  SHOT_W,  SHOT_H);
+  gt_load_sprite(ART_BOOM,  SPR_BOOM.gx,  SPR_BOOM.gy,  BOOM_W,  BOOM_H);
+}
+
+/* ── game state ── */
+#define N_ENEMY 4
+#define N_SHOT  3
+#define N_BOOM  4
+
+static unsigned char ship_x;
+static unsigned char ex[N_ENEMY], ey[N_ENEMY], e_on[N_ENEMY];   /* enemies: x, y, active */
+static unsigned char sx[N_SHOT],  sy[N_SHOT],  s_on[N_SHOT];    /* shots:   x, y, active */
+static unsigned char bx[N_BOOM], by[N_BOOM], bt[N_BOOM];        /* explosions: x, y, timer */
+static unsigned char fire_cool, spawn_t;
+static unsigned int  score;
+static unsigned char lives;
+
+static void reset_game(void) {
+  unsigned char i;
+  ship_x = 56; score = 0; lives = 3; fire_cool = 0; spawn_t = 0;
+  for (i = 0; i < N_ENEMY; i++) e_on[i] = 0;
+  for (i = 0; i < N_SHOT;  i++) s_on[i] = 0;
+  for (i = 0; i < N_BOOM;  i++) bt[i] = 0;
+}
+
+/* spawn an explosion at (x,y). */
+static void make_boom(unsigned char x, unsigned char y) {
+  unsigned char i;
+  for (i = 0; i < N_BOOM; i++) {
+    if (!bt[i]) { bx[i] = x; by[i] = y; bt[i] = 10; return; }
+  }
+}
+
+/* spawn one enemy at the top in a free slot. */
+static void spawn_enemy(void) {
+  unsigned char i;
+  for (i = 0; i < N_ENEMY; i++) {
+    if (!e_on[i]) {
+      ex[i] = 8 + (unsigned char)(rnd8() % 100);
+      ey[i] = 0;
+      e_on[i] = 1;
+      return;
+    }
+  }
+}
+
+/* boxes-overlap test (sprites are ~16 wide). */
+static unsigned char near16(unsigned char ax, unsigned char ay, unsigned char bx, unsigned char by) {
+  unsigned char dx = ax > bx ? ax - bx : bx - ax;
+  unsigned char dy = ay > by ? ay - by : by - ay;
+  return dx < 14 && dy < 14;
+}
+
+void main(void) {
+  unsigned char i, j;
+  load_art();
+  reset_game();
+
+  for (;;) {
+    /* ── input ── */
+    if ((player1_buttons & INPUT_MASK_LEFT)  && ship_x > 2)   ship_x -= 2;
+    if ((player1_buttons & INPUT_MASK_RIGHT) && ship_x < 110) ship_x += 2;
+    if (fire_cool) fire_cool--;
+    if ((player1_buttons & (INPUT_MASK_A | INPUT_MASK_START)) && !fire_cool) {
+      for (i = 0; i < N_SHOT; i++) {
+        if (!s_on[i]) { s_on[i] = 1; sx[i] = ship_x + 5; sy[i] = 100; fire_cool = 10; gt_sfx(GT_SFX_SHOOT); break; }
+      }
+    }
+
+    /* ── shots move up ── */
+    for (i = 0; i < N_SHOT; i++) {
+      if (s_on[i]) {
+        if (sy[i] < 6) s_on[i] = 0;
+        else sy[i] -= 6;
+      }
+    }
+
+    /* ── spawn enemies on a timer ── */
+    spawn_t++;
+    if (spawn_t >= 48) { spawn_t = 0; spawn_enemy(); }
+
+    /* ── enemies fall ── */
+    for (i = 0; i < N_ENEMY; i++) {
+      if (e_on[i]) {
+        ey[i]++;
+        if (ey[i] > 120) e_on[i] = 0;           /* off the bottom: just despawn */
+      }
+    }
+
+    /* ── shot vs enemy ── */
+    for (i = 0; i < N_ENEMY; i++) {
+      if (e_on[i]) {
+        for (j = 0; j < N_SHOT; j++) {
+          if (s_on[j] && near16(ex[i] + 8, ey[i] + 8, sx[j] + 3, sy[j] + 4)) {
+            make_boom(ex[i], ey[i]);
+            e_on[i] = 0; s_on[j] = 0; score += 10; gt_sfx(GT_SFX_EXPLODE);
+            break;
+          }
+        }
+      }
+    }
+
+    /* ── enemy vs ship ── */
+    for (i = 0; i < N_ENEMY; i++) {
+      if (e_on[i] && near16(ex[i] + 8, ey[i] + 8, ship_x + 8, 116)) {
+        make_boom(ex[i], ey[i]);
+        e_on[i] = 0;
+        gt_sfx(GT_SFX_EXPLODE);
+        if (lives) lives--;
+      }
+    }
+
+    /* ── age explosions ── */
+    for (i = 0; i < N_BOOM; i++) if (bt[i]) bt[i]--;
+
+    /* ── draw (scalar copies: indexing inside the gt_blit macro is fragile in cc65) ── */
+    gt_clear(C_SPACE);
+    for (i = 0; i < N_ENEMY; i++) if (e_on[i]) { unsigned char dx = ex[i], dy = ey[i]; gt_blit(dx, dy, SPR_ENEMY); }
+    for (i = 0; i < N_SHOT;  i++) if (s_on[i]) { unsigned char dx = sx[i], dy = sy[i]; gt_blit(dx, dy, SPR_SHOT); }
+    for (i = 0; i < N_BOOM;  i++) if (bt[i])   { unsigned char dx = bx[i], dy = by[i]; gt_blit(dx, dy, SPR_BOOM); }
+    gt_blit(ship_x, 108, SPR_SHIP);
+    /* HUD: bar in the play area (y>=7), text inside it. */
+    queue_draw_box(1, 7, 126, 7, C_HUDBAR);
+    hud_number(score, 30, 8, 2, C_HUD);
+    hud_pips(lives, 96, 8, 4, C_LIFE);
+    /* Re-clean the top BORDER (rows 0-6) LAST. Blitting sprites leaves a stray light
+     * line on the framebuffer's top scanline; only the border-clear path can rewrite
+     * rows 0-6, and doing it AFTER the sprite blits removes the flickering 1px seam. */
+    queue_clear_border(C_HUDBAR);
+    gt_present();
+    gt_sfx_tick();
+
+    update_inputs();
+  }
+}

package/examples/gametank/templates/sports.c

@@ -0,0 +1,119 @@
+/* ── sports.c — GameTank 2-player paddle game (complete example) ─────────────
+ *
+ * A COMPLETE, working game on the bundled GameTank SDK draw-queue runtime — and
+ * a genuine 2-PLAYER one (the GameTank has two gamepad ports, unlike the
+ * handhelds). Two paddles, a bouncing ball that speeds up on each hit, first to
+ * 7 wins. Title → play → match-point → restart. The framebuffer makes a clean
+ * paddle game trivial — paddles + ball are just rects redrawn each frame.
+ *
+ * FORK THIS. Markers:
+ *   HARDWARE IDIOM (load-bearing) — paddles/ball/court = rects redrawn each
+ *     frame; the ball's sub-pixel motion is integer x/y with a velocity. No
+ *     sprites, no flicker.
+ *   GAME LOGIC (clay) — paddle speed, ball speed-up, win score: tune freely.
+ *
+ * SFX (gt_sound.h, ACP synth): a blip on wall bounces, a "pong" on paddle hits,
+ * and a ding on each point scored. Box-drawn HUD (gt_hud.h).
+ * SCREEN: 128x128. PLAYERS: 2 (P1 left pad = $2008, P2 right pad = $2009).
+ */
+#include "gametank.h"
+#include "draw_queue.h"
+#include "input.h"
+#include "gt_palette.h"
+#include "gt_draw.h"
+#include "gt_hud.h"
+#include "gt_sound.h"
+
+#define C_COURT  GT_DKGRN     /* court: dark green */
+#define C_NET    GT_WHITE
+#define C_P1     GT_CYAN      /* left paddle */
+#define C_P2     GT_GOLD      /* right paddle */
+#define C_BALL   GT_WHITE
+#define C_HUD    GT_WHITE
+
+#define PAD_H 26
+#define PAD_W 5
+#define WIN   7
+
+static unsigned char p1y, p2y;       /* paddle tops */
+static signed char bx, by;           /* ball pos (signed for clamp math) */
+static signed char vx, vy;           /* ball velocity */
+static unsigned char s1, s2;
+
+static void serve(unsigned char toLeft) {
+  bx = 62; by = 60;
+  vx = toLeft ? -2 : 2; vy = (by & 1) ? 1 : -1;
+}
+static void reset_game(void) { p1y = 51; p2y = 51; s1 = 0; s2 = 0; serve(1); }
+
+static unsigned char title_or_win(unsigned char win) {  /* win: 0 title, 1 P1, 2 P2 */
+  gt_start_reset();
+  while (1) {
+    gt_clear(C_COURT);
+    if (!win) {
+      gt_rect(28, 36, 72, 10, C_BALL);
+      gt_rect(20, 64, PAD_W, PAD_H, C_P1);
+      gt_rect(103, 64, PAD_W, PAD_H, C_P2);
+      gt_rect(62, 72, 5, 5, C_BALL);
+    } else {
+      gt_rect(30, 52, 68, 24, C_NET);
+      hud_digit(win, 60, 56, 4, win == 1 ? C_P1 : C_P2);   /* "1" or "2" wins */
+    }
+     gt_present(); gt_music_tick(); 
+    update_inputs();
+    if (gt_start_pressed()) return 1;
+  }
+}
+
+void main(void) {
+  unsigned char i;
+  reset_game();
+
+  for (;;) {
+    title_or_win(0);
+    reset_game();
+
+    for (;;) {
+      update_inputs();
+
+      /* P1 (left pad) + P2 (right pad) — update_inputs fills player1/2_buttons */
+      if ((player1_buttons & INPUT_MASK_UP)   && p1y > 2)              p1y -= 3;
+      if ((player1_buttons & INPUT_MASK_DOWN) && p1y < 127 - PAD_H)    p1y += 3;
+      if ((player2_buttons & INPUT_MASK_UP)   && p2y > 2)              p2y -= 3;
+      if ((player2_buttons & INPUT_MASK_DOWN) && p2y < 127 - PAD_H)    p2y += 3;
+
+      /* ball move */
+      bx += vx; by += vy;
+      if (by <= 2)   { by = 2;   vy = -vy; gt_sfx(GT_SFX_SHOOT); }   /* wall blip */
+      if (by >= 122) { by = 122; vy = -vy; gt_sfx(GT_SFX_SHOOT); }
+
+      /* paddle collisions (speed up on hit) — the satisfying "pong" */
+      if (vx < 0 && bx <= 25 && bx >= 18 && by + 5 >= (signed char)p1y && by <= (signed char)(p1y + PAD_H)) {
+        bx = 25; vx = (signed char)(-vx + 1); vy += (signed char)((by - (signed char)(p1y + PAD_H / 2)) >> 3);
+        gt_sfx(GT_SFX_HIT);
+      }
+      if (vx > 0 && bx >= 98 && bx <= 105 && by + 5 >= (signed char)p2y && by <= (signed char)(p2y + PAD_H)) {
+        bx = 98; vx = (signed char)(-vx - 1); vy += (signed char)((by - (signed char)(p2y + PAD_H / 2)) >> 3);
+        gt_sfx(GT_SFX_HIT);
+      }
+      if (vx > 4) vx = 4; if (vx < -4) vx = -4;
+
+      /* score — a clear ding for the point */
+      if (bx < 0)   { s2++; gt_sfx(GT_SFX_COIN); if (s2 >= WIN) goto win2; serve(0); }
+      if (bx > 126) { s1++; gt_sfx(GT_SFX_COIN); if (s1 >= WIN) goto win1; serve(1); }
+
+      /* ── HARDWARE IDIOM: court + net + paddles + ball, all rects ── */
+      gt_clear(C_COURT);
+      for (i = 4; i < 124; i += 10) gt_rect(63, i, 2, 5, C_NET);   /* dashed net */
+      gt_rect(20, p1y, PAD_W, PAD_H, C_P1);
+      gt_rect(103, p2y, PAD_W, PAD_H, C_P2);
+      gt_rect((unsigned char)bx, (unsigned char)by, 5, 5, C_BALL);
+      hud_number(s1, 44, 4, 2, C_P1);
+      hud_number(s2, 84, 4, 2, C_P2);
+      
+      gt_present(); gt_music_tick();
+    }
+  win1: title_or_win(1); continue;
+  win2: title_or_win(2); continue;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "romdevtools",
-  "version": "0.71.1",
+  "version": "0.84.1",
   "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",
@@ -52,29 +52,31 @@
     "pngjs": "^7.0.0",
     "romdev-analysis": "0.1.0",
     "romdev-analysis-decompiler": "0.1.0",
-    "romdev-core-bluemsx": "0.6.0",
-    "romdev-core-fceumm": "0.10.0",
-    "romdev-core-gambatte": "0.9.0",
-    "romdev-core-geargrafx": "0.7.0",
-    "romdev-core-gpgx": "0.12.0",
-    "romdev-core-handy": "0.7.0",
-    "romdev-core-flycast": "0.1.1",
-    "romdev-core-parallel-n64": "0.1.0",
-    "romdev-core-beetle-psx-hw": "0.1.1",
-    "romdev-core-prosystem": "0.8.0",
-    "romdev-core-vice": "0.9.0",
+    "romdev-audio-resampler": "0.1.0",
+    "romdev-core-beetle-psx-hw": "0.2.0",
+    "romdev-core-bluemsx": "0.7.0",
+    "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-geargrafx": "0.8.0",
+    "romdev-core-gpgx": "0.13.0",
+    "romdev-core-handy": "0.8.0",
+    "romdev-core-parallel-n64": "0.2.0",
+    "romdev-core-prosystem": "0.9.0",
+    "romdev-core-vice": "0.10.0",
     "romdev-famitone": "0.1.0",
     "romdev-maxmod": "0.1.0",
-    "romdev-platform-atari2600": "0.8.0",
-    "romdev-platform-gba": "0.8.0",
-    "romdev-platform-snes": "0.8.0",
-    "romdev-toolchain-cc65": "0.1.1",
-    "romdev-toolchain-m68k-gcc": "0.2.0",
-    "romdev-toolchain-mips-gcc": "0.1.0",
-    "romdev-toolchain-rgbds": "0.1.0",
-    "romdev-toolchain-sdcc": "0.2.0",
-    "romdev-toolchain-sh-gcc": "0.1.0",
-    "romdev-toolchain-vasm": "0.1.0",
+    "romdev-platform-atari2600": "0.9.0",
+    "romdev-platform-gba": "0.9.0",
+    "romdev-platform-snes": "0.9.0",
+    "romdev-toolchain-cc65": "0.1.2",
+    "romdev-toolchain-m68k-gcc": "0.2.1",
+    "romdev-toolchain-mips-gcc": "0.1.1",
+    "romdev-toolchain-rgbds": "0.1.1",
+    "romdev-toolchain-sdcc": "0.2.1",
+    "romdev-toolchain-sh-gcc": "0.1.1",
+    "romdev-toolchain-vasm": "0.1.1",
     "romdev-xgm2": "0.1.0",
     "romdev_game_codes": "0.1.0",
     "socket.io": "^4.8.3",

package/src/cores/capabilities.js

@@ -174,6 +174,30 @@ export const CAPABILITIES = {
       cart: false, disasm: true, decompile: true,
     },
   },
+  gametank: {
+    // Clyde Shaffer's open W65C02S console: a 128x128 framebuffer drawn by a
+    // hardware blitter (no tilemap / no fixed OAM), + a second 65C02 audio
+    // coprocessor. Closest cousin is the Lynx (also 65C02 + blitter). The core
+    // is patched with the romdev_* debug hooks (6502 regsnap + MemoryWrite/Read
+    // watchpoints + the mos6502 dispatch freeze) — so cpuState + write/read
+    // watchpoints + pc-break + watchdog + coverage are LIVE, alongside build/run/
+    // screenshot/disasm/decompile. inspectSprites is N/A (the blitter has no OAM,
+    // like Dreamcast); inspectBackground N/A (framebuffer, not a tilemap).
+    cpuFamily: "6502", decompileQuality: "rough",
+    cpus: { main: "6502", secondary: ["acp-65c02"] }, // ACP = the audio coprocessor (2nd 65C02)
+    // audioDebug(chip:'acp') reports the ACP's STATE (DAC output, IRQ/sample rate,
+    // run/mute, audio-CPU PC) via the core's romdev_acp_get export — it's a second
+    // 65C02 driving a DAC, not a fixed-register synth.
+    audioChips: ["acp"],
+    memoryRegions: [...GENERIC_REGIONS],
+    renderingKind: "framebuffer", introspection: "shallow",
+    ops: {
+      build: true, run: true, screenshot: true,
+      inspectSprites: false, inspectPalette: true, inspectBackground: false,
+      renderingContext: true, cpuState: true, audioDebug: true,
+      cart: true, disasm: true, decompile: true,
+    },
+  },
   pce: {
     cpuFamily: "huc6280", decompileQuality: "medium",
     cpus: { main: "", secondary: [] }, // getCPUState main NOT wired for pce

package/src/cores/registry.js

@@ -53,6 +53,7 @@ export const CORES = {
   c64: { platform: "c64", coreName: "vice_x64", pkg: "romdev-core-vice", displayName: "Commodore 64 (VICE x64)" },
   pce: { platform: "pce", coreName: "geargrafx", pkg: "romdev-core-geargrafx", displayName: "PC Engine / TurboGrafx-16 (Geargrafx)", aka: "turbografx,tg16,pcengine" },
   msx: { platform: "msx", coreName: "bluemsx", pkg: "romdev-core-bluemsx", displayName: "MSX / MSX2 (blueMSX)", aka: "msx2" },
+  gametank: { platform: "gametank", coreName: "gametank", pkg: "romdev-core-gametank", displayName: "GameTank (Clyde Shaffer)", aka: "gtr" },
   // 32-bit MIPS tier. These cores HW-render (GL): the host lazy-loads the OPTIONAL
   // webgl-node bridge only when one of these boots (hwRender:true). The other 14 are
   // software-rendered and never touch GL, so a headless user without the GPU module
@@ -69,7 +70,12 @@ export const CORES = {
   // Flycast = full Dreamcast emulator, GLES3/WebGL2 HW-render (PowerVR2 is GPU-first,
   // no software framebuffer path) → driven through the native-gles/webgl-node bridge
   // like the GL N64 build. HLE BIOS (reios) on by default — no firmware to ship.
-  dreamcast: { platform: "dreamcast", coreName: "flycast", pkg: "romdev-core-flycast", displayName: "Sega Dreamcast (Flycast)", aka: "dc", hwRender: true },
+  // noderawfs: the flycast WASM is built with -s NODERAWFS=1, so its filesystem IS
+  // Node's real fs — libchdr fopens/seeks the disc image off DISK on demand instead
+  // of the host loading the whole (up to ~1GB) CHD into the WASM heap (which OOM'd a
+  // 1GB max-heap on big discs like Sonic Adventure). The host passes the REAL path
+  // and skips the malloc+FS.writeFile for these cores. See LibretroHost.loadMedia.
+  dreamcast: { platform: "dreamcast", coreName: "flycast", pkg: "romdev-core-flycast", displayName: "Sega Dreamcast (Flycast)", aka: "dc", hwRender: true, noderawfs: true },
 };
 
 /** Try to get {jsPath,wasmPath} for a core from its binary package. */