romdev-mcp 0.1.1

package/examples/snes/templates/puzzle-data.asm

@@ -0,0 +1,14 @@
+; ── puzzle-data.asm — font stubs only ─────────────────────────────
+; puzzle.c uses only consoleDrawText, so we don't need sprite tile
+; or palette data.
+.include "hdr.asm"
+
+.section ".rodata1" superfree
+
+tilfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+palfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+.ends

package/examples/snes/templates/puzzle.c

@@ -0,0 +1,199 @@
+/* ── puzzle.c — SNES PVSnesLib match-3 falling-block scaffold ──────
+ *
+ * 6-wide × 12-tall grid drawn entirely via text-mode characters
+ * (R = red, G = green, B = blue). Active piece is 1×3 vertical;
+ * LEFT/RIGHT shifts, A rotates colour order, DOWN soft-drops, START
+ * hard-drops. Horizontal triples clear and score.
+ *
+ * Why text-mode? PVSnesLib's consoleDrawText is the simplest
+ * "draw something to a cell" path on SNES. Real puzzle games use
+ * BG-tile sprite cells with proper graphics — that's the natural
+ * next step from this scaffold.
+ */
+
+#include <snes.h>
+#include "snes_sfx.c"
+
+extern char tilfont, palfont;
+
+#define COLS 6
+#define ROWS 12
+
+static u8 grid[ROWS][COLS];
+static u8 piece[3];
+static s16 piece_x;
+static s16 piece_y;
+static u16 fall_timer;
+static u16 score;
+static u32 rng = 1;
+
+static u32 xorshift(void) {
+    rng ^= rng << 13;
+    rng ^= rng >> 17;
+    rng ^= rng << 5;
+    return rng;
+}
+
+static u8 random_colour(void) { return 1 + (xorshift() % 3); }
+
+static char glyph_for(u8 v) {
+    switch (v) {
+        case 1: return 'R';
+        case 2: return 'G';
+        case 3: return 'B';
+        default: return '.';
+    }
+}
+
+static void new_piece(void) {
+    piece[0] = random_colour();
+    piece[1] = random_colour();
+    piece[2] = random_colour();
+    piece_x = COLS / 2 - 1;
+    piece_y = -3;
+}
+
+static void draw_cell(s16 col, s16 row) {
+    char s[2];
+    if (row < 0 || row >= ROWS) return;
+    s[0] = glyph_for(grid[row][col]);
+    s[1] = 0;
+    consoleDrawText(col + 12, row + 4, s);
+}
+
+static void draw_grid(void) {
+    s16 r, c;
+    for (r = 0; r < ROWS; r++)
+        for (c = 0; c < COLS; c++)
+            draw_cell(c, r);
+}
+
+static void draw_piece(u8 clear) {
+    u16 i;
+    s16 r;
+    char s[2];
+    for (i = 0; i < 3; i++) {
+        r = piece_y + i;
+        if (r < 0 || r >= ROWS) continue;
+        s[0] = clear ? glyph_for(grid[r][piece_x])
+                     : glyph_for(piece[i]);
+        s[1] = 0;
+        consoleDrawText(piece_x + 12, r + 4, s);
+    }
+}
+
+static u8 collides(s16 col, s16 row) {
+    u16 i;
+    s16 r;
+    if (col < 0 || col >= COLS) return 1;
+    for (i = 0; i < 3; i++) {
+        r = row + i;
+        if (r >= ROWS) return 1;
+        if (r >= 0 && grid[r][col] != 0) return 1;
+    }
+    return 0;
+}
+
+static void lock_piece(void) {
+    u16 i;
+    s16 r, c;
+    u8 a, b, d;
+    for (i = 0; i < 3; i++) {
+        r = piece_y + i;
+        if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
+    }
+    for (i = 0; i < 3; i++) {
+        r = piece_y + i;
+        if (r < 0 || r >= ROWS) continue;
+        for (c = 0; c <= COLS - 3; c++) {
+            a = grid[r][c]; b = grid[r][c + 1]; d = grid[r][c + 2];
+            if (a != 0 && a == b && b == d) {
+                grid[r][c]     = 0;
+                grid[r][c + 1] = 0;
+                grid[r][c + 2] = 0;
+                if (score < 65500) score += 30;
+                sfx_play(2);  /* triple-clear chime */
+            }
+        }
+    }
+    draw_grid();
+}
+
+static void render_score(void) {
+    char buf[6];
+    u16 v;
+    s8 i;
+    buf[0]='0'; buf[1]='0'; buf[2]='0'; buf[3]='0'; buf[4]='0'; buf[5]=0;
+    v = score;
+    for (i = 4; i >= 0; i--) { buf[i] = '0' + (v % 10); v /= 10; }
+    consoleDrawText(20, 2, buf);
+}
+
+int main(void) {
+    s16 r, c;
+    u16 pad, prev = 0, fall_rate;
+    u8 t;
+
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    for (r = 0; r < ROWS; r++)
+        for (c = 0; c < COLS; c++)
+            grid[r][c] = 0;
+
+    score = 0;
+    fall_timer = 0;
+    new_piece();
+
+    consoleDrawText(14, 2, "SCORE");
+    consoleDrawText(2, 26, "LR MOVE A ROT START DROP");
+    sfx_init();
+    draw_grid();
+
+    setScreenOn();
+
+    while (1) {
+        pad = padsCurrent(0);
+        draw_piece(1);
+
+        if ((pad & KEY_LEFT)  && !(prev & KEY_LEFT)
+            && !collides(piece_x - 1, piece_y)) piece_x--;
+        if ((pad & KEY_RIGHT) && !(prev & KEY_RIGHT)
+            && !collides(piece_x + 1, piece_y)) piece_x++;
+        if ((pad & KEY_A) && !(prev & KEY_A)) {
+            t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+            sfx_play(1);  /* rotate click */
+        }
+        if ((pad & KEY_START) && !(prev & KEY_START)) {
+            while (!collides(piece_x, piece_y + 1)) piece_y++;
+            lock_piece();
+            new_piece();
+            prev = pad;
+            render_score();
+            WaitForVBlank();
+            continue;
+        }
+        prev = pad;
+
+        fall_rate = (pad & KEY_DOWN) ? 4 : 30;
+        if (++fall_timer >= fall_rate) {
+            fall_timer = 0;
+            if (collides(piece_x, piece_y + 1)) {
+                lock_piece();
+                new_piece();
+            } else {
+                piece_y++;
+            }
+        }
+
+        draw_piece(0);
+        render_score();
+        WaitForVBlank();
+    }
+    return 0;
+}

package/examples/snes/templates/racing-data.asm

@@ -0,0 +1,33 @@
+; ── racing-data.asm — font + player car + enemy car tiles ─────────
+.include "hdr.asm"
+
+.section ".rodata1" superfree
+
+tilfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+palfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+tilsprite:
+; Tile 0 — player car (colour 1)
+.db $3C, $00, $7E, $00, $42, $00, $7E, $00
+.db $7E, $00, $42, $00, $7E, $00, $66, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+; Tile 1 — enemy car (colour 2)
+.db $00, $3C, $00, $7E, $00, $42, $00, $7E
+.db $00, $7E, $00, $42, $00, $7E, $00, $66
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+palsprite:
+.db $00, $00       ; 0 transparent
+.db $FF, $7F       ; 1 white (player)
+.db $00, $7C       ; 2 red (enemy)
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+.ends

package/examples/snes/templates/racing.c

@@ -0,0 +1,146 @@
+/* ── racing.c — SNES PVSnesLib top-down racing scaffold ────────────
+ *
+ * Endless 3-lane top-down racer for SNES. LEFT/RIGHT switches lanes
+ * (edge-detected), obstacles slide down at speed that grows with
+ * score. Collision triggers a 60-frame game-over freeze + auto-reset.
+ *
+ * tcc-65816 is C89 — declarations at block top.
+ */
+
+#include <snes.h>
+#include "snes_sfx.c"
+
+extern char tilfont, palfont;
+extern char tilsprite, palsprite;
+
+#define LANE_LEFT_X    72
+#define LANE_MID_X    124
+#define LANE_RIGHT_X  176
+#define PLAYER_Y      180
+#define MAX_OBSTACLES   4
+
+typedef struct { s16 x, y; u8 alive; } Car;
+
+static Car player;
+static Car obstacles[MAX_OBSTACLES];
+static u16 score;
+static u8  spawn_timer;
+static u8  game_over_timer;
+static u16 prev_pad;
+static u8  player_lane;
+
+static const s16 lane_x[3] = { LANE_LEFT_X, LANE_MID_X, LANE_RIGHT_X };
+
+static u8 aabb(Car *a, Car *b) {
+    return a->x < b->x + 8 && a->x + 8 > b->x
+        && a->y < b->y + 8 && a->y + 8 > b->y;
+}
+
+static void reset_run(void) {
+    u8 i;
+    player_lane = 1;
+    player.x = lane_x[1];
+    player.y = PLAYER_Y;
+    player.alive = 1;
+    for (i = 0; i < MAX_OBSTACLES; i++) obstacles[i].alive = 0;
+    score = 0;
+    spawn_timer = 0;
+    game_over_timer = 0;
+}
+
+static void spawn_obstacle(void) {
+    u8 i;
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+        if (!obstacles[i].alive) {
+            obstacles[i].x = lane_x[(spawn_timer * 13) % 3];
+            obstacles[i].y = 0;
+            obstacles[i].alive = 1;
+            return;
+        }
+    }
+}
+
+static void render_score(void) {
+    char buf[6];
+    u16 v;
+    s8 i;
+    buf[0]='0'; buf[1]='0'; buf[2]='0'; buf[3]='0'; buf[4]='0'; buf[5]=0;
+    v = score;
+    for (i = 4; i >= 0; i--) { buf[i] = '0' + (v % 10); v /= 10; }
+    consoleDrawText(22, 2, buf);
+}
+
+int main(void) {
+    u16 pad;
+    u8 i;
+    s16 step;
+
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    /* 2 sprite tiles × 32 bytes = 64 bytes */
+    oamInitGfxSet(&tilsprite, 64, &palsprite, 32, 0, 0x0000, OBJ_SIZE8_L16);
+
+    consoleDrawText(2, 2, "SCORE");
+    consoleDrawText(6, 26, "L/R SWITCH LANES");
+
+    /* Hide all OAM. */
+    for (i = 0; i < 1 + MAX_OBSTACLES; i++) oamSet(i, 0, 240, 3, 0, 0, 0, 0);
+
+    setScreenOn();
+    sfx_init();
+    reset_run();
+    prev_pad = 0;
+
+    while (1) {
+        /* Stage OAM. */
+        oamSet(0, player.x, player.y, 3, 0, 0, 0, 0);
+        for (i = 0; i < MAX_OBSTACLES; i++) {
+            u16 ey = obstacles[i].alive ? obstacles[i].y : 240;
+            oamSet((u16)(1 + i), obstacles[i].x, ey, 3, 0, 0, 32, 0);
+        }
+        oamUpdate();
+        render_score();
+        WaitForVBlank();
+
+        pad = padsCurrent(0);
+
+        if (game_over_timer > 0) {
+            game_over_timer--;
+            if (game_over_timer == 0) reset_run();
+            prev_pad = pad;
+            continue;
+        }
+
+        if ((pad & KEY_LEFT)  && !(prev_pad & KEY_LEFT)  && player_lane > 0) { player_lane--; sfx_play(1); }
+        if ((pad & KEY_RIGHT) && !(prev_pad & KEY_RIGHT) && player_lane < 2) { player_lane++; sfx_play(1); }
+        player.x = lane_x[player_lane];
+        prev_pad = pad;
+
+        step = (s16)(2 + (score / 500));
+        if (step > 4) step = 4;
+
+        for (i = 0; i < MAX_OBSTACLES; i++) {
+            if (!obstacles[i].alive) continue;
+            obstacles[i].y = (s16)(obstacles[i].y + step);
+            if (obstacles[i].y >= 224) obstacles[i].alive = 0;
+        }
+        spawn_timer++;
+        if (spawn_timer >= 36) { spawn_timer = 0; spawn_obstacle(); }
+
+        for (i = 0; i < MAX_OBSTACLES; i++) {
+            if (obstacles[i].alive && aabb(&player, &obstacles[i])) {
+                game_over_timer = 60;
+                sfx_play(2);  /* crash */
+                break;
+            }
+        }
+        if (score < 65500) score++;
+    }
+    return 0;
+}

package/examples/snes/templates/shmup-data.asm

@@ -0,0 +1,61 @@
+; ── shmup-data.asm — font + 3-sprite blob for shmup.c ─────────────
+;
+; tilsprite contains three 8×8 4bpp tiles back-to-back:
+;   tile 0 (offset 0)  — ship  (palette colour 1, mid-blue)
+;   tile 1 (offset 32) — bullet (palette colour 2, yellow)
+;   tile 2 (offset 64) — enemy (palette colour 3, red)
+;
+; Each 8×8 4bpp tile = 32 bytes (4 bitplanes × 8 rows × 1 byte).
+; SNES interleaves planes 0+1 first (16 bytes), then 2+3 (16 bytes).
+
+.include "hdr.asm"
+
+.section ".rodata1" superfree
+
+; ⚠ KNOWN ISSUE (text-BG HUD): this is a STUB font. consoleInitText DMAs
+; 3072 bytes from here into VRAM; with only a stub, it reads past into
+; adjacent data → a garbage font → the text BG shows a junk checkerboard
+; AND the HUD text is unreadable. The real fix is to ship PVSnesLib's
+; open-source bitmap font: convert pvsneslibfont.png with gfx2snes and
+; `.incbin "pvsneslibfont.pic"` / `.pal` here (see the official PVSnesLib
+; hello_world example). Tracked as R7(c) follow-up. The GAME itself
+; (sprites, motion, input, collision, sound) renders + plays correctly;
+; only the on-BG HUD text is affected.
+tilfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+; HUD font palette — colour 1 = white so consoleDrawText() is VISIBLE
+; once a real font is dropped in above.
+palfont:
+.db $00, $00          ; 0 transparent (BG shows through)
+.db $FF, $7F          ; 1 white (text)
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00
+
+tilsprite:
+; Tile 0 — ship (cannon: wide base + central barrel, reads as a player)
+.db $18, $00, $18, $00, $18, $00, $3C, $00
+.db $7E, $00, $FF, $00, $FF, $00, $E7, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+; Tile 1 — bullet (vertical bolt, colour 2 → plane 1 set)
+.db $00, $18, $00, $18, $00, $3C, $00, $3C
+.db $00, $3C, $00, $3C, $00, $18, $00, $18
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+; Tile 2 — enemy (classic invader silhouette, colour 3 → planes 0+1)
+.db $24, $24, $7E, $7E, $DB, $DB, $FF, $FF
+.db $FF, $FF, $5A, $5A, $24, $24, $42, $42
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+palsprite:
+.db $00, $00          ; 0 transparent
+.db $1F, $7E          ; 1 cyan-blue (ship)
+.db $E0, $03          ; 2 yellow    (bullet)
+.db $1F, $00          ; 3 green     (enemy — classic invader green)
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+.ends

package/examples/snes/templates/shmup.c

@@ -0,0 +1,199 @@
+/* ── shmup.c — SNES PVSnesLib vertical-shooter scaffold ─────────────
+ *
+ * Complete runnable vertical-shmup baseline. Layout mirrors the NES
+ * and Genesis shmup scaffolds:
+ *   - Player ship (8×8 OAM 0), d-pad moves, B fires
+ *   - 6 bullet slots (OAM 1..6), 6 enemy slots (OAM 7..12)
+ *   - Wave spawner: one enemy from the top every ~28 frames
+ *   - Linear movement, AABB collision (8×8 vs 8×8)
+ *
+ * SNES screen is 256×224 (NTSC). All movement / spawn coords use
+ * that range. PVSnesLib's oamSet places OAM entries; oamUpdate
+ * flushes them via DMA on the NMI.
+ *
+ * Sibling data.asm provides the font + sprite-tile + sprite-palette
+ * blobs. We use tile index 0 (ship), 1 (bullet), 2 (enemy).
+ *
+ * ⚠ TWO PVSnesLib footguns this scaffold handles for you:
+ *  1. oamSet's FIRST arg is a BYTE OFFSET into OAM, not a slot number.
+ *     Each sprite is 4 bytes, so sprite slot N lives at offset N*4.
+ *     Passing a plain slot number interleaves/corrupts entries. We use
+ *     the SPR(slot) macro below — always address sprites through it.
+ *  2. sfx_init() must run AFTER setScreenOn() and its return must be
+ *     checked. If it stalls before the screen is on, you get a black
+ *     screen forever. See the main() ordering below.
+ */
+
+#include <snes.h>
+/* Single .c file in buildSnesC, so the sound wrapper is #include'd
+ * inline rather than linked separately. */
+#include "snes_sfx.c"
+
+extern char tilfont, palfont;
+extern char tilsprite, palsprite;
+
+/* OAM is addressed by BYTE OFFSET; sprite slot N = offset N*4. */
+#define SPR(slot) ((slot) << 2)
+
+#define MAX_BULLETS 6
+#define MAX_ENEMIES 6
+
+typedef struct { s16 x, y; u8 alive; } Obj;
+
+static Obj player;
+static Obj bullets[MAX_BULLETS];
+static Obj enemies[MAX_ENEMIES];
+static u16 score;
+static u16 spawn_timer;
+
+static u8 aabb(Obj* a, Obj* b) {
+    return a->x < b->x + 8 && a->x + 8 > b->x
+        && a->y < b->y + 8 && a->y + 8 > b->y;
+}
+
+static void render_score(void) {
+    char buf[8];
+    u16 v;
+    s8 i;
+    buf[0]='0'; buf[1]='0'; buf[2]='0'; buf[3]='0'; buf[4]='0'; buf[5]=0;
+    v = score;
+    for (i = 4; i >= 0; i--) { buf[i] = '0' + (v % 10); v /= 10; }
+    consoleDrawText(20, 1, buf);
+}
+
+static void fire(void) {
+    u16 i;
+    for (i = 0; i < MAX_BULLETS; i++) {
+        if (!bullets[i].alive) {
+            bullets[i].x = player.x;
+            bullets[i].y = player.y - 8;
+            bullets[i].alive = 1;
+            return;
+        }
+    }
+}
+
+/* Write all sprites into the OAM low table. Slot layout: 0=player,
+ * 1..6=bullets, 7..12=enemies. SPR(slot) = slot*4 (oamSet's id is a BYTE
+ * offset). Inactive objects park at Y=240 (off-screen) — that's how you
+ * "hide" a sprite; no oamSetEx needed (oamInitGfxSet leaves slots shown).
+ * Call oamUpdate() after to DMA the table to hardware. */
+static void stage_frame(void) {
+    u16 i, by, ey;
+    oamSet(SPR(0), player.x, player.y, 3, 0, 0, 0, 0);    /* player tile 0 */
+    for (i = 0; i < MAX_BULLETS; i++) {
+        by = bullets[i].alive ? bullets[i].y : 240;
+        oamSet(SPR(1 + i), bullets[i].x, by, 3, 0, 0, 1, 0); /* gfxoffset = tile INDEX 1 (not a byte offset) */
+    }
+    for (i = 0; i < MAX_ENEMIES; i++) {
+        ey = enemies[i].alive ? enemies[i].y : 240;
+        oamSet(SPR(7 + i), enemies[i].x, ey, 3, 0, 0, 2, 0); /* gfxoffset = tile INDEX 2 (not a byte offset) */
+    }
+}
+
+static void spawn(void) {
+    u16 i;
+    for (i = 0; i < MAX_ENEMIES; i++) {
+        if (!enemies[i].alive) {
+            enemies[i].x = ((spawn_timer * 37) & 0xFF) % (256 - 16) + 4;
+            enemies[i].y = 0;
+            enemies[i].alive = 1;
+            return;
+        }
+    }
+}
+
+int main(void) {
+    u16 i, j, pad;
+    u16 prev = 0;
+    u16 by, ey;
+
+    dmaClearVram();
+
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+    setMode(BG_MODE1, 0);
+    /* Disable ALL BG layers and render on a solid backdrop — the same
+     * clean approach the `default` template uses. (BG0 was the text-console
+     * layer, but its stub font rendered as a garbage checkerboard; until a
+     * real pvsneslibfont .pic is dropped in for an on-BG HUD, a clean
+     * sprite-only screen looks far better than garbage tiles.) */
+    bgSetDisable(0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+    setPaletteColor(0, RGB5(0, 0, 6));   /* dark-blue backdrop (CGRAM 0) */
+
+    /* 3 sprite tiles (ship/bullet/enemy) × 32 bytes = 96 bytes. */
+    oamInitGfxSet(&tilsprite, 96, &palsprite, 32, 0,
+                  0x0000, OBJ_SIZE8_L16);
+
+    player.x = 120; player.y = 180; player.alive = 1;
+    for (i = 0; i < MAX_BULLETS; i++) bullets[i].alive = 0;
+    for (i = 0; i < MAX_ENEMIES; i++) enemies[i].alive = 0;
+    score = 0;
+    spawn_timer = 0;
+
+    consoleDrawText(14, 1, "SCORE");
+    consoleDrawText(2, 26, "D-PAD MOVE B FIRE");
+
+    /* Pre-stage all 13 OAM slots off-screen (SPR() = slot*4 — oamSet's id
+     * is a BYTE OFFSET). After oamInitGfxSet, sprites default to shown, so
+     * just set position; hide an inactive sprite by parking it at Y=240. */
+    for (i = 0; i < 13; i++) oamSet(SPR(i), 0, 240, 3, 0, 0, 0, 0);
+
+    /* Stage the first real frame + flush it to OAM BEFORE the screen turns
+     * on, so frame 1 shows the game (not power-on garbage). */
+    stage_frame();
+    oamUpdate();
+
+    /* Screen ON first, THEN sound. If the SPC wedges, sfx_init returns
+     * nonzero and we keep running silently — never a black screen. */
+    setScreenOn();
+    sfx_init();
+
+    while (1) {
+        pad = padsCurrent(0);
+
+        if (pad & KEY_LEFT  && player.x > 8)       player.x -= 2;
+        if (pad & KEY_RIGHT && player.x < 256 - 16) player.x += 2;
+        if (pad & KEY_UP    && player.y > 16)      player.y -= 2;
+        if (pad & KEY_DOWN  && player.y < 224 - 16) player.y += 2;
+        if ((pad & KEY_B) && !(prev & KEY_B)) { fire(); sfx_play(1); }
+        prev = pad;
+
+        for (i = 0; i < MAX_BULLETS; i++) {
+            if (!bullets[i].alive) continue;
+            bullets[i].y -= 4;
+            if (bullets[i].y < 0 || bullets[i].y > 230) bullets[i].alive = 0;
+        }
+        for (i = 0; i < MAX_ENEMIES; i++) {
+            if (!enemies[i].alive) continue;
+            enemies[i].y += 1;
+            if (enemies[i].y >= 224) enemies[i].alive = 0;
+        }
+        if (++spawn_timer >= 28) { spawn_timer = 0; spawn(); }
+
+        for (i = 0; i < MAX_BULLETS; i++) {
+            if (!bullets[i].alive) continue;
+            for (j = 0; j < MAX_ENEMIES; j++) {
+                if (!enemies[j].alive) continue;
+                if (aabb(&bullets[i], &enemies[j])) {
+                    bullets[i].alive = 0;
+                    enemies[j].alive = 0;
+                    if (score < 65500) score += 10;
+                    sfx_play(2);
+                    break;
+                }
+            }
+        }
+
+        stage_frame();
+        oamUpdate();
+
+        render_score();
+        WaitForVBlank();
+    }
+    return 0;
+}

package/examples/snes/templates/sports-data.asm

@@ -0,0 +1,28 @@
+; ── sports-data.asm — font + paddle/ball sprite data for sports.c ────
+; One sprite tile: a solid 8×8 white block reused for paddles + ball.
+.include "hdr.asm"
+
+.section ".rodata1" superfree
+
+tilfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+palfont:
+.db 0, 0, 0, 0, 0, 0, 0, 0
+
+tilsprite:
+; Tile 0 — solid 8×8 block, colour 1
+.db $FF, $00, $FF, $00, $FF, $00, $FF, $00
+.db $FF, $00, $FF, $00, $FF, $00, $FF, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+palsprite:
+.db $00, $00       ; 0 transparent
+.db $FF, $7F       ; 1 white
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+.ends