romdev-mcp 0.1.1

package/examples/snes/main.asm

@@ -0,0 +1,70 @@
+; Hello, SNES — a real hello-world scaffold for asar.
+;
+; What this does:
+;   1. Standard SNES reset (sei, clc xce → native mode, stack at $1FFF).
+;   2. Uploads a single CGRAM color (bright blue) so you see a colored
+;      backdrop — proof your build is running. NOT just a black screen.
+;   3. Turns on the screen at full brightness, then parks forever.
+;
+; SUFFICIENT FOR: confirming your toolchain works + your user has
+; something to see in playtest. To go further (load tiles, set up BGs,
+; sprites, sound, vblank handler) see src/platforms/snes/lib/* snippets:
+;
+;   listStarterSnippets({platform:"snes"})
+;
+; The key snippets are:
+;   - lorom_header.asm: full SNES header (this scaffold's is minimal)
+;   - cgram_upload.asm: palette upload boilerplate
+;   - vram_dma_upload.asm: fast tile/map uploads
+;   - oam_upload.asm: sprite table writes
+;   - nmi_safe.asm: vblank handler skeleton
+;
+; BUILD: complete LoROM image, no extra options needed.
+;   buildSource({ platform: "snes", source: /* this file */ });
+
+lorom
+
+INIDISP  = $2100   ; screen brightness / forced blank
+NMITIMEN = $4200
+CGADD    = $2121
+CGDATA   = $2122
+
+; -----------------------------------------------------------------------
+org $008000
+START:
+        sei
+        clc
+        xce             ; → native 65816 mode
+        rep #$30        ; A/X/Y = 16-bit
+        ldx #$1FFF
+        txs             ; stack at $1FFF
+        sep #$20        ; A = 8-bit
+
+        ; Blank screen during init.
+        lda #$80
+        sta INIDISP
+
+        ; Disable interrupts.
+        stz NMITIMEN
+
+        ; Upload one color to CGRAM[0] (the backdrop / transparency color).
+        ; BGR-555 little-endian. $7C00 = bright blue.
+        stz CGADD
+        lda #$00
+        sta CGDATA
+        lda #$7C
+        sta CGDATA
+
+        ; Enable screen at full brightness (bit 7 = 0 to disable forced
+        ; blank; low nybble = brightness 0..15).
+        lda #$0F
+        sta INIDISP
+
+LOOP:
+        bra LOOP
+
+; -----------------------------------------------------------------------
+; Emulation-mode reset vector (used at boot, before `xce` flips to native).
+; asar's `lorom` directive handles header + rest of vector table padding.
+org $00FFFC
+        dw START

package/examples/snes/templates/c-hello-data.asm

@@ -0,0 +1,28 @@
+; ── c-hello-data.asm — stub data symbols for the c-hello template ──
+;
+; Two symbols required by main.c's consoleInitText call:
+;
+;   tilfont   — pointer to font tile data (.pic format = wla-dx
+;               binary include, 2 KB for a 16x16 ASCII font in 2bpp)
+;   palfont   — pointer to font palette data (.pal = 32-byte SNES
+;               CGRAM blob: 16 colors × 2 bytes per color in BGR555)
+;
+; Both stubbed as 8 zero bytes here so the link resolves. Real
+; projects replace these stubs with `.incbin "myfont.pic"` and
+; `.incbin "myfont.pal"`.
+;
+; Convert a PNG to .pic + .pal with PVSnesLib's gfx4snes tool (not
+; bundled in romdev yet — pre-convert outside the MCP and ship
+; the binary artifacts alongside your source).
+
+.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/c-hello.c

@@ -0,0 +1,71 @@
+/* ── c-hello.c — minimal PVSnesLib starter ─────────────────────────
+ *
+ * Tested boots-from-cold game-loop skeleton for SNES C:
+ *   - consoleInitText sets up PVSnesLib's text mode against tilfont + palfont
+ *   - setMode(BG_MODE1, 0) selects a standard 4-color BG + sprite mix
+ *   - consoleDrawText writes ASCII into the configured map at (col, row)
+ *   - WaitForVBlank is the canonical PVSnesLib game-loop heartbeat
+ *
+ * Sibling data.asm provides tilfont + palfont. Real projects replace
+ * the stub bytes there with .incbin of a real font asset (gfx4snes
+ * converts PNG → .pic + .pal; we don't bundle gfx4snes yet, so a hand-
+ * authored .pic + .pal works equivalently).
+ *
+ * Build via romdev:
+ *   buildSource({
+ *     platform: "snes", language: "c",
+ *     sources: {
+ *       "main.c":   <this file>,
+ *       "data.asm": <sibling>,
+ *     },
+ *   })
+ *
+ * Output: ~35 KB SNES LoROM. PVSnesLib runtime (crt0, libm, libtcc,
+ * libc) is auto-linked.
+ */
+
+#include <snes.h>
+
+extern char tilfont, palfont;
+
+int main(void) {
+    /* ── 1. PVSnesLib text-mode setup ─────────────────────────────
+     * Map + tile-data + palette-offset addresses are conventions —
+     * any free VRAM region will work, these match PVSnesLib's
+     * hello_world example layout.
+     */
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+
+    /* ── 2. Pick a BG mode ────────────────────────────────────────
+     * BG_MODE1 = 16-color BG0/BG1 + 4-color BG2. Good default.
+     * Disable BG1 / BG2 since we only use BG0 for text here.
+     */
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    /* ── 3. Draw text ─────────────────────────────────────────────
+     * consoleDrawText(col, row, str). Coordinates are tile-space
+     * (BG_MODE1 BG0 is 32 cols × 28 rows in a 256x224 viewport).
+     */
+    consoleDrawText(10, 10, "Hello SNES");
+    consoleDrawText( 6, 14, "BUILT WITH ROM-DEV-MCP");
+
+    /* ── 4. Turn the screen on ────────────────────────────────────
+     * Until setScreenOn fires, the SNES forces blank (INIDISP $80).
+     */
+    setScreenOn();
+
+    /* ── 5. Game loop ─────────────────────────────────────────────
+     * WaitForVBlank is the PVSnesLib heartbeat. Update game state
+     * BEFORE the call so the NMI handler's auto-DMA picks up your
+     * sprite changes before the next frame draws.
+     */
+    while (1) {
+        WaitForVBlank();
+    }
+    return 0;
+}

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

@@ -0,0 +1,36 @@
+; ── default-data.asm — symbols required by default.c ───────────────
+;
+; Provides:
+;   tilsprite — one 8×8 4bpp tile (32 bytes), a filled diamond shape
+;   palsprite — sprite palette, 16 colours × 2 bytes BGR555
+;
+; SNES 4bpp tile layout is bitplane-interleaved:
+;   bytes 0-15  = rows 0..7 of planes 0+1 (low/hi pair per row)
+;   bytes 16-31 = rows 0..7 of planes 2+3
+; "All pixels in colour 1" needs plane 0 = bits set, planes 1/2/3 = 0.
+
+.include "hdr.asm"
+
+.section ".rodata1" superfree
+
+tilsprite:
+; Plane 0 — diamond shape (colour 1 where bits are set)
+.db $18, $00, $3C, $00, $7E, $00, $FF, $00
+.db $FF, $00, $7E, $00, $3C, $00, $18, $00
+; Plane 1 — zero
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+palsprite:
+; BGR555: c = 0BBBBBGGGGGRRRRR, 2 bytes little-endian per colour.
+; 16 colours = 32 bytes. Colour 0 = transparent (skipped by SNES).
+.db $00, $00     ; 0 transparent
+.db $FF, $7F     ; 1 white  (R=31 G=31 B=31)
+.db $00, $7C     ; 2 red
+.db $E0, $03     ; 3 green
+.db $1F, $00     ; 4 blue
+.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/default.c

@@ -0,0 +1,74 @@
+/* default.c — SNES PVSnesLib starter (C).
+ *
+ * Smallest "ROM that does something visible" — sets a blue backdrop
+ * and parks a white diamond sprite in the centre of the screen.
+ * Pressing the d-pad moves the sprite.
+ *
+ * Picked as the default SNES template because:
+ *   - PVSnesLib gives a clean C API (oamSet, padsCurrent, etc.)
+ *     instead of raw 65816 / direct register pokes.
+ *   - tcc-65816 builds it in <2s.
+ *   - You read this file once and know how every SNES C scaffold
+ *     is structured (hello_sprite, shmup, platformer all extend it).
+ *
+ * For raw 65816 see template:"asm" (kept for cycle-accurate work).
+ * For text-mode console output see template:"c_hello".
+ * For genre-shaped scaffolds see createGame({genre:"shmup", ...}).
+ *
+ * Sibling `data.asm` provides the sprite tile + palette bytes.
+ * Build:
+ *   buildSource({
+ *     platform:"snes", language:"c",
+ *     sourcesPaths:{"main.c":"...","data.asm":"..."},
+ *   })
+ */
+#include <snes.h>
+
+extern char tilsprite, palsprite;
+
+int main(void) {
+    u16 x = 120, y = 100;
+
+    /* BG_MODE1 with all BG layers disabled — we render only the
+     * sprite layer on top of the backdrop colour. */
+    setMode(BG_MODE1, 0);
+    bgSetDisable(0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    /* Backdrop colour (CGRAM entry 0). RGB5: red=0, green=0, blue=15
+     * → bright SNES blue. setPaletteColor packs to BGR555 for us. */
+    setPaletteColor(0, RGB5(0, 0, 15));
+
+    /* Upload 32 bytes of sprite tile + 32 bytes of sprite palette to
+     * VRAM $0000 / OBJ palette slot 0. OBJ_SIZE8_L16 = small sprites
+     * are 8×8, large 16×16 (we use small). */
+    oamInitGfxSet(&tilsprite, 32, &palsprite, 32,
+                  0,              /* OBJ palette slot */
+                  0x0000,         /* VRAM address for sprite tiles */
+                  OBJ_SIZE8_L16);
+
+    /* Place sprite #0 at the centre. */
+    oamSet(0, x, y,
+           3 /* highest priority */,
+           0 /* no flip */, 0 /* palette */, 0 /* tile index */, 0 /* objsize */);
+    oamSetEx(0, OBJ_SMALL, OBJ_SHOW);
+
+    /* Until setScreenOn() fires, the SNES holds forced blank
+     * (INIDISP $80) and nothing renders. */
+    setScreenOn();
+
+    while (1) {
+        u16 pad = padsCurrent(0);
+
+        if (pad & KEY_LEFT  && x > 0)         x -= 1;
+        if (pad & KEY_RIGHT && x < 256 - 8)   x += 1;
+        if (pad & KEY_UP    && y > 0)         y -= 1;
+        if (pad & KEY_DOWN  && y < 224 - 8)   y += 1;
+
+        oamSetXY(0, x, y);
+        oamUpdate();
+        WaitForVBlank();
+    }
+    return 0;
+}

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

@@ -0,0 +1,45 @@
+; ── hello_sprite-data.asm — symbols required by hello_sprite.c ────
+;
+; Provides:
+;   tilfont   — text-font tile data (stubbed; replace with real .pic)
+;   palfont   — text-font palette (stubbed)
+;   tilsprite — sprite tile data, one 8×8 4bpp tile (32 bytes), drawn
+;               here as a filled diamond using colour 1
+;   palsprite — sprite palette, 16 colours × 2 bytes BGR555
+;
+; SNES 4bpp tile layout is bitplane-interleaved: rows 0-7 store
+; planes 0+1 (16 bytes), then rows 0-7 store planes 2+3 (16 bytes).
+; For "all colour 1" pixels we want plane 0 = 1, planes 1/2/3 = 0.
+
+.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:
+; Plane 0 — diamond shape (colour 1 where bits are set)
+.db $18, $00, $3C, $00, $7E, $00, $FF, $00
+.db $FF, $00, $7E, $00, $3C, $00, $18, $00
+; Plane 1 — zero
+.db $00, $00, $00, $00, $00, $00, $00, $00
+.db $00, $00, $00, $00, $00, $00, $00, $00
+
+palsprite:
+; BGR555: c=BBBBBGGGGGRRRRR0, 2 bytes little-endian per colour.
+; 16 colours = 32 bytes. Colour 0 = transparent; we colour the
+; sprite via colour 1 = bright cyan.
+.db $00, $00     ; 0 transparent
+.db $FF, $7F     ; 1 white-ish
+.db $00, $7C     ; 2 red
+.db $E0, $03     ; 3 green
+.db $1F, $00     ; 4 blue
+.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/hello_sprite.c

@@ -0,0 +1,76 @@
+/* ── hello_sprite.c — SNES PVSnesLib starter (one sprite + d-pad) ──
+ *
+ * Drives one 8×8 sprite around the screen with the directional pad.
+ * Uses PVSnesLib's oamSet + oamUpdate path — the canonical SNES C
+ * sprite loop.
+ *
+ * Boots-from-cold game-loop:
+ *   1. consoleInitText + setMode(BG_MODE1) — gives us text on BG0
+ *      so we have a visible status line.
+ *   2. oamInitGfxSet uploads the sprite tile data + sprite palette
+ *      into VRAM/CGRAM.
+ *   3. oamSet places sprite #0 at its initial position.
+ *   4. setScreenOn lifts the forced blank.
+ *   5. Game loop reads padsCurrent(0), moves the sprite, oamUpdate,
+ *      WaitForVBlank.
+ *
+ * Sibling data.asm provides tilfont + palfont (text font) AND
+ * tilsprite + palsprite (sprite tile + palette). Both are stubbed
+ * with hand-authored 8×8 4bpp data — replace with .incbin'd .pic /
+ * .pal from gfx4snes for real art.
+ */
+
+#include <snes.h>
+
+extern char tilfont, palfont;
+extern char tilsprite, palsprite;
+
+int main(void) {
+    u16 x = 120, y = 100;
+    u16 prev = 0;
+
+    /* Text setup — same layout as c-hello. */
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    /* OAM init — sprite tiles at VRAM $0000, 8x8 default. */
+    oamInitGfxSet(&tilsprite, 32 /* sprite tile bytes */,
+                  &palsprite, 32 /* palette bytes */,
+                  0 /* palette slot */, 0x0000 /* VRAM addr */,
+                  OBJ_SIZE8_L16);
+
+    consoleDrawText(2, 2, "D-PAD MOVES THE SPRITE");
+    consoleDrawText(2, 4, "START FOR SOFT RESET");
+
+    /* Place sprite #0. */
+    oamSet(0, x, y, 3 /* highest priority */, 0, 0, 0, 0);
+    oamSetEx(0, OBJ_SMALL, OBJ_SHOW);
+
+    setScreenOn();
+
+    while (1) {
+        u16 pad = padsCurrent(0);
+
+        if (pad & KEY_LEFT)  x = (x > 0)         ? x - 1 : 0;
+        if (pad & KEY_RIGHT) x = (x < 255 - 8)   ? x + 1 : 247;
+        if (pad & KEY_UP)    y = (y > 0)         ? y - 1 : 0;
+        if (pad & KEY_DOWN)  y = (y < 223 - 8)   ? y + 1 : 215;
+
+        /* Edge-detect START → centre. */
+        if ((pad & KEY_START) && !(prev & KEY_START)) {
+            x = 120; y = 100;
+        }
+        prev = pad;
+
+        oamSetXY(0, x, y);
+        oamUpdate();
+        WaitForVBlank();
+    }
+    return 0;
+}

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

@@ -0,0 +1,20 @@
+; ── music_demo-data.asm — stub data symbols for music_demo ─────────
+;
+; PVSnesLib's consoleInitText needs tilfont + palfont symbols at link
+; time. We stub them as zero bytes here so the link resolves; the SNES
+; ROM will boot fine but the text glyphs will render as blank tiles
+; until you replace these stubs with real .pic + .pal blobs.
+;
+; (See examples/snes/templates/c-hello-data.asm for the same pattern.)
+
+.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/music_demo.c

@@ -0,0 +1,83 @@
+/* ── music_demo.c — SNES SPC700 continuous-music demo ──────────────
+ *
+ * Standalone demo of the R46 music engine in the bundled SPC driver.
+ * After sfx_init(), calling sfx_music_play() kicks off a looping
+ * 16-step C-major arpeggio on voice 1. Press B to layer the "shoot"
+ * sfx (voice 0) on top; press A to stop the music; press START to
+ * resume it.
+ *
+ * What this demonstrates:
+ *   - Music engine runs autonomously on the SPC700 once started —
+ *     no per-frame work is required from the 65816 side. The 65816
+ *     just sends one command byte ($03 = start, $04 = stop) and the
+ *     SPC700 walks the song table itself, driven by its own Timer 0.
+ *   - SFX and music coexist on separate DSP voices (voice 0 vs 1),
+ *     so triggering a shoot doesn't interrupt the melody.
+ *
+ * Pair with a real BRR instrument sample for proper music tone — the
+ * bundled shoot.brr is short and percussive, so the arpeggio sounds
+ * chirpy/8-bit. Replace via apu_blob.asm + scripts/build-apu-blob.js.
+ *
+ * Sibling music_demo-data.asm provides the font stubs (same shape
+ * as c-hello-data.asm).
+ */
+
+#include <snes.h>
+#include "snes_sfx.c"
+
+extern char tilfont, palfont;
+
+int main(void) {
+    u16 pad;
+    u16 prev = 0;
+    u16 frame = 0;
+    u8 music_running;
+
+    /* ── Text-mode setup (PVSnesLib convention) ─────────────────── */
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    /* ── Upload SPC driver + sample bank + song table to ARAM ──── */
+    sfx_init();
+
+    consoleDrawText( 8, 6,  "SNES MUSIC DEMO");
+    consoleDrawText( 3, 11, "B    = SHOOT SFX");
+    consoleDrawText( 3, 13, "A    = STOP MUSIC");
+    consoleDrawText( 3, 15, "STRT = PLAY MUSIC");
+
+    setScreenOn();
+
+    /* Auto-start music. */
+    sfx_music_play();
+    music_running = 1;
+    consoleDrawText( 8, 20, "MUSIC: PLAYING");
+
+    /* ── Game loop ─────────────────────────────────────────────── */
+    while (1) {
+        pad = padsCurrent(0);
+
+        if ((pad & KEY_B) && !(prev & KEY_B)) {
+            sfx_play(1);
+        }
+        if ((pad & KEY_A) && !(prev & KEY_A)) {
+            sfx_music_stop();
+            music_running = 0;
+            consoleDrawText( 8, 20, "MUSIC: STOPPED");
+        }
+        if ((pad & KEY_START) && !(prev & KEY_START)) {
+            sfx_music_play();
+            music_running = 1;
+            consoleDrawText( 8, 20, "MUSIC: PLAYING");
+        }
+        prev = pad;
+        frame++;
+
+        WaitForVBlank();
+    }
+    return 0;
+}

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

@@ -0,0 +1,27 @@
+; ── platformer-data.asm — one sprite (player) + font stubs ─────────
+.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 (filled diamond, colour 1)
+.db $18, $00, $3C, $00, $7E, $00, $FF, $00
+.db $FF, $00, $7E, $00, $3C, $00, $18, $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 $00, $7C          ; 1 red
+.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/platformer.c

@@ -0,0 +1,142 @@
+/* ── platformer.c — SNES PVSnesLib SIDE-SCROLLING platformer scaffold
+ *
+ * A horizontally scrolling platformer: gravity + jump physics with
+ * land-on-top collision against a static platform list spread across a
+ * 512-px world. A camera follows the player; the BG scrolls in hardware
+ * via bgSetScroll(0, camX, 0) and the player sprite draws in SCREEN
+ * space (worldX - camX). Mirrors the GB/Genesis side-scroller scaffolds.
+ *
+ * Physics is fixed-point: x/y in 1/16-pixel subpixel units for sub-pixel
+ * acceleration.
+ *
+ * NOTE ON VISUALS: this scaffold uses the PVSnesLib console (text) BG,
+ * which has no tiled platform art — so as you scroll you see the on-BG
+ * text slide (proof the hardware scroll register is moving) while the
+ * player stays screen-centered. For visible tiled platforms across a
+ * wide world, build a real tileset with gfx2snes + bgInitTileSet on a
+ * 64-wide map and stream tilemap columns into VRAM during vblank as the
+ * camera advances. See the SNES MENTAL_MODEL.md "Horizontal scrolling".
+ */
+
+#include <snes.h>
+#include "snes_sfx.c"
+
+extern char tilfont, palfont;
+extern char tilsprite, palsprite;
+
+typedef struct { s16 x, y, w, h; } Rect;
+
+#define WORLD_W  512
+#define SCREEN_W 256
+
+/* Platforms in WORLD coords, spread across the 512-px world. */
+static const Rect platforms[] = {
+    {   0, 200, 512,  24 }, /* floor spans the world */
+    {  30, 160,  56,   8 },
+    { 110, 140,  64,   8 },
+    { 190, 110,  48,   8 },
+    {  60, 100,  32,   8 },
+    { 300, 150,  64,   8 },
+    { 400, 120,  56,   8 },
+    { 360,  84,  48,   8 },
+    { 460, 168,  48,   8 },
+};
+#define N_PLATFORMS (sizeof(platforms) / sizeof(platforms[0]))
+
+#define GRAVITY    12
+#define MOVE_SPEED 24
+#define JUMP_VEL   -200
+#define MAX_FALL   320
+
+static u8 on_platform(s16 px, s16 py) {
+    u16 i;
+    const Rect* p;
+    for (i = 0; i < N_PLATFORMS; i++) {
+        p = &platforms[i];
+        if (py + 8 == p->y && px + 8 > p->x && px < p->x + p->w) return 1;
+    }
+    return 0;
+}
+
+int main(void) {
+    s32 px = 32 << 4, py = 100 << 4;
+    s32 vx = 0,       vy = 0;
+    s32 np;
+    s16 ipx, ipy, npy, camX = 0;
+    u8 grounded;
+    u16 i, pad, prev = 0;
+    const Rect* p;
+
+    consoleSetTextMapPtr(0x6800);
+    consoleSetTextGfxPtr(0x3000);
+    consoleSetTextOffset(0x0100);
+    consoleInitText(0, 16 * 2, &tilfont, &palfont);
+    setMode(BG_MODE1, 0);
+    bgSetDisable(1);
+    bgSetDisable(2);
+
+    oamInitGfxSet(&tilsprite, 32, &palsprite, 32, 0, 0x0000, OBJ_SIZE8_L16);
+
+    consoleDrawText(2, 1, "D-PAD MOVE   A JUMP");
+    /* Column markers across the BG so the hardware scroll is visible as
+     * you move (the console map is 32 cells / 256 px and wraps). */
+    consoleDrawText( 1, 12, "|0");
+    consoleDrawText( 9, 12, "|64");
+    consoleDrawText(17, 12, "|128");
+    consoleDrawText(25, 12, "|192");
+    sfx_init();
+
+    oamSet(0, 32, 100, 3, 0, 0, 0, 0);
+    setScreenOn();
+
+    while (1) {
+        pad = padsCurrent(0);
+        vx = 0;
+        if (pad & KEY_LEFT)  vx = -MOVE_SPEED;
+        if (pad & KEY_RIGHT) vx =  MOVE_SPEED;
+
+        ipx = px >> 4;
+        ipy = py >> 4;
+        grounded = on_platform(ipx, ipy);
+        if ((pad & KEY_A) && !(prev & KEY_A) && grounded) { vy = JUMP_VEL; sfx_play(1); }
+        prev = pad;
+
+        vy += GRAVITY;
+        if (vy > MAX_FALL) vy = MAX_FALL;
+        if (grounded && vy > 0) vy = 0;
+
+        px += vx;
+        if (px < 0) px = 0;
+        if (px > (WORLD_W - 8) << 4) px = (WORLD_W - 8) << 4;
+
+        np = py + vy;
+        npy = np >> 4;
+        if (vy > 0) {
+            for (i = 0; i < N_PLATFORMS; i++) {
+                p = &platforms[i];
+                if (ipy + 8 <= p->y && npy + 8 >= p->y
+                    && ipx + 8 > p->x && ipx < p->x + p->w) {
+                    py = (p->y - 8) << 4;
+                    vy = 0;
+                    goto done;
+                }
+            }
+        }
+        py = np;
+        if (py > 224 << 4) { py = 0; vy = 0; }
+done:   ;
+
+        /* Camera follows the player, centered, clamped to the world.
+         * bgSetScroll moves the BG in hardware; the player draws in
+         * SCREEN space (worldX - camX). */
+        camX = (px >> 4) - (SCREEN_W / 2 - 4);
+        if (camX < 0) camX = 0;
+        if (camX > WORLD_W - SCREEN_W) camX = WORLD_W - SCREEN_W;
+        bgSetScroll(0, camX, 0);
+
+        oamSetXY(0, (px >> 4) - camX, py >> 4);
+        oamUpdate();
+        WaitForVBlank();
+    }
+    return 0;
+}