romdev-mcp 0.1.1

package/examples/atari2600/templates/single_screen.asm

@@ -0,0 +1,242 @@
+; ── single_screen.asm — Atari 2600 dodge-the-falling-pixels scaffold ──
+;
+; Player sprite at the bottom of the screen, falling "rocks" (use
+; missile M0) from the top. Joystick port A moves left/right. Goal:
+; avoid the rocks.
+;
+; Demonstrates per-frame missile re-positioning (the rock) + boundary
+; logic + simple "score counter" stored in zero page (rendered as
+; foreground colour change — bright = high score).
+;
+; Why missiles for rocks? 2600's P0 is already the player; M0 (missile
+; 0) is a 1-bit-wide 1-8-pixel-wide alternative graphics object that
+; shares P0's colour. Perfect for small enemies / projectiles.
+
+  processor 6502
+  org $F000
+
+VSYNC    = $00
+VBLANK   = $01
+WSYNC    = $02
+COLUP0   = $06
+COLUBK   = $09
+RESP0    = $10
+RESM0    = $11
+GRP0     = $1B
+ENAM0    = $1D
+HMP0     = $20
+HMM0     = $22
+HMOVE    = $2A
+SWCHA    = $280
+NUSIZ0   = $04
+; TIA audio (R41)
+AUDC0    = $15
+AUDF0    = $17
+AUDV0    = $19
+
+; Zero page
+P_X      = $80
+P_Y      = $81
+ROCK_X   = $82
+ROCK_Y   = $83
+FRAME    = $84
+SCORE    = $85          ; survive-frames / 60
+SFX_LEFT = $86          ; frames remaining on active sfx
+
+START:
+  SEI
+  CLD
+  LDX #$FF
+  TXS
+  LDA #0
+.clr:
+  STA $00,X
+  DEX
+  BNE .clr
+
+  LDA #80
+  STA P_X
+  LDA #160               ; near bottom
+  STA P_Y
+  LDA #40
+  STA ROCK_X
+  LDA #20
+  STA ROCK_Y
+  LDA #$80               ; blue bg
+  STA COLUBK
+  LDA #$0F               ; white
+  STA COLUP0
+  LDA #5                 ; missile = 2-pixel-wide
+  STA NUSIZ0
+
+  ; Boot chime — confirms TIA audio is wired.
+  LDA #$04
+  STA AUDC0
+  LDA #$0C
+  STA AUDF0
+  LDA #$0F
+  STA AUDV0
+  LDA #20
+  STA SFX_LEFT
+
+MAIN:
+  INC FRAME
+
+  ; VSYNC
+  LDA #2
+  STA VSYNC
+  STA WSYNC
+  STA WSYNC
+  STA WSYNC
+  LDA #0
+  STA VSYNC
+
+  ; VBLANK 37
+  LDA #2
+  STA VBLANK
+  LDX #37
+.vb:
+  STA WSYNC
+  DEX
+  BNE .vb
+
+  ; Input — every 2nd frame
+  LDA FRAME
+  AND #$01
+  BNE .skipmove
+  LDA SWCHA
+  ASL                    ; right
+  BCS .nr
+  INC P_X
+  INC P_X
+.nr:
+  ASL                    ; left
+  BCS .nl
+  DEC P_X
+  DEC P_X
+.nl:
+.skipmove:
+
+  ; Move rock down 1 px/frame
+  INC ROCK_Y
+  LDA ROCK_Y
+  CMP #185
+  BCC .norock_reset
+  ; Reset rock to top with a varying-but-deterministic X — chime per dodge.
+  LDA #20
+  STA ROCK_Y
+  LDA FRAME
+  AND #$7F
+  CLC
+  ADC #$10
+  STA ROCK_X
+  INC SCORE              ; survive!
+  ; sfx_chime — short tone confirms you dodged a rock.
+  LDA #$04
+  STA AUDC0
+  LDA #$06
+  STA AUDF0
+  LDA #$0F
+  STA AUDV0
+  LDA #8
+  STA SFX_LEFT
+.norock_reset:
+
+  ; sfx_update: tick countdown, silence on zero.
+  LDA SFX_LEFT
+  BEQ .sfx_done
+  DEC SFX_LEFT
+  BNE .sfx_done
+  LDA #0
+  STA AUDV0
+.sfx_done:
+
+  ; Position P0 at column P_X (race-the-beam — simplified: divide by 15)
+  STA WSYNC
+  LDX P_X
+  LDA #0
+.p0d:
+  CPX #15
+  BCC .p0done
+  SBC #15
+  TAX
+  JMP .p0d
+.p0done:
+  STA RESP0
+  STA HMOVE
+
+  ; Position M0 at column ROCK_X (race-the-beam)
+  STA WSYNC
+  LDX ROCK_X
+  LDA #0
+.m0d:
+  CPX #15
+  BCC .m0done
+  SBC #15
+  TAX
+  JMP .m0d
+.m0done:
+  STA RESM0
+
+  LDA #0
+  STA VBLANK
+
+  ; Visible 192
+  LDY #192
+.draw:
+  STA WSYNC
+  ; Player: 8 rows around P_Y
+  TYA
+  SEC
+  SBC P_Y
+  CMP #8
+  BCS .p_blank
+  TAX
+  LDA SPRITE,X
+  STA GRP0
+  JMP .p_done
+.p_blank:
+  LDA #0
+  STA GRP0
+.p_done:
+  ; Rock: enable missile for the 2 lines around ROCK_Y
+  TYA
+  SEC
+  SBC ROCK_Y
+  CMP #2
+  BCS .m_blank
+  LDA #2
+  STA ENAM0
+  JMP .m_done
+.m_blank:
+  LDA #0
+  STA ENAM0
+.m_done:
+  DEY
+  BNE .draw
+
+  ; Overscan 30
+  LDA #2
+  STA VBLANK
+  LDX #30
+.os:
+  STA WSYNC
+  DEX
+  BNE .os
+
+  JMP MAIN
+
+SPRITE:
+  .byte %00111100
+  .byte %01111110
+  .byte %11011011
+  .byte %11111111
+  .byte %11111111
+  .byte %11011011
+  .byte %01100110
+  .byte %01000010
+
+  org $FFFA
+  .word START
+  .word START
+  .word START

package/examples/atari7800/main.c

@@ -0,0 +1,88 @@
+// ── Hello, Atari 7800 — MARIA bring-up + single sprite ──────────────
+//
+// Build: buildSource({ platform: "atari7800", source: <this file>,
+//                      language: "c" })
+//
+// Sets up a minimal display list, paints the background blue and renders
+// a 16-byte-wide sprite. Demonstrates the canonical MARIA boot sequence
+// (DLL, DPP, CHARBASE, CTRL.DMA_ENABLE).
+//
+// cc65 NOTE: pointer-to-int casts aren't constant expressions, so the
+// DLL + display-list addresses are patched in at runtime in main().
+
+#include <stdint.h>
+
+// MARIA register pointers ────────────────────────────────────────────
+#define BACKGRND  (*(volatile uint8_t*)0x20)
+#define P0C1      (*(volatile uint8_t*)0x21)
+#define P0C2      (*(volatile uint8_t*)0x22)
+#define P0C3      (*(volatile uint8_t*)0x23)
+#define MSTAT     (*(volatile uint8_t*)0x28)
+#define DPPH      (*(volatile uint8_t*)0x2C)
+#define DPPL      (*(volatile uint8_t*)0x30)
+#define CHARBASE  (*(volatile uint8_t*)0x34)
+#define OFFSET    (*(volatile uint8_t*)0x38)
+#define CTRL      (*(volatile uint8_t*)0x3C)
+
+// Sprite pixel data (16 bytes wide × 8 rows).
+static const uint8_t sprite_pixels[16 * 8] = {
+  0,0,0,0,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0,0,0,0,
+  0,0,0,0xAA,0xAA,0x55,0x55,0x55,0x55,0x55,0x55,0xAA,0xAA,0,0,0,
+  0,0,0xAA,0x55,0x55,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x55,0x55,0xAA,0,0,
+  0,0xAA,0x55,0x55,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x55,0x55,0xAA,0,
+  0,0xAA,0x55,0x55,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x55,0x55,0xAA,0,
+  0,0,0xAA,0x55,0x55,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x55,0x55,0xAA,0,0,
+  0,0,0,0xAA,0xAA,0x55,0x55,0x55,0x55,0x55,0x55,0xAA,0xAA,0,0,0,
+  0,0,0,0,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0,0,0,0,
+};
+
+// DL: 5-byte header pointing at sprite_pixels, then $00.
+// We fill in the address bytes at runtime — cc65 won't evaluate
+// (uintptr_t)&sprite_pixels at compile time for an initializer.
+static uint8_t display_list[6] = {
+  0,
+  0x80 | 16,    // write+width
+  0,
+  0x00,         // palette + H pos hi
+  80,           // X position
+  0x00,         // end-of-DL
+};
+
+// DLL: one zone covering 184 scanlines + end marker.
+static uint8_t dll[6] = {
+  0x80 | 183,
+  0,
+  0,
+  0, 0, 0,
+};
+
+static void vblank_wait(void) {
+  while (MSTAT & 0x80) { }
+  while (!(MSTAT & 0x80)) { }
+}
+
+void main(void) {
+  uint16_t dl_addr = (uint16_t)(uintptr_t)display_list;
+  uint16_t dll_addr = (uint16_t)(uintptr_t)dll;
+  uint16_t sp_addr = (uint16_t)(uintptr_t)sprite_pixels;
+
+  display_list[0] = (uint8_t)(sp_addr & 0xFF);
+  display_list[2] = (uint8_t)(sp_addr >> 8);
+
+  dll[1] = (uint8_t)(dl_addr >> 8);
+  dll[2] = (uint8_t)(dl_addr & 0xFF);
+
+  BACKGRND = 0x88;
+  P0C1 = 0x96;
+  P0C2 = 0x0F;
+  P0C3 = 0x46;
+  CHARBASE = 0;
+  OFFSET = 0;
+
+  DPPL = (uint8_t)(dll_addr & 0xFF);
+  DPPH = (uint8_t)(dll_addr >> 8);
+
+  CTRL = 0x40;    // border off, DMA on
+
+  for (;;) { vblank_wait(); }
+}

package/examples/atari7800/templates/default.c

@@ -0,0 +1,183 @@
+/* default.c — Atari 7800 MARIA single-sprite minimal demo.
+ *
+ * Renders ONE sprite (16 pixels wide × 8 scanlines tall) at (X=80,
+ * Y=110) on a solid blue background. Plays a boot chime on the TIA.
+ * Smallest known-working 7800 boot.
+ *
+ * ── MARIA hierarchy ──────────────────────────────────────────────
+ *
+ * The 7800 has no tilemap. Each frame, MARIA:
+ *
+ *   DPP register → DLL (one entry per zone)
+ *                     → DL (one entry per object in that zone)
+ *                          → raw pixel bytes
+ *
+ * You build the DL and DLL; MARIA walks them and writes a line buffer
+ * that becomes the framebuffer. See MENTAL_MODEL.md for the full
+ * register / mode-byte reference.
+ *
+ * ── Why this scaffold is structured the way it is ────────────────
+ *
+ * MARIA's per-scanline addressing has a quirk: within a multi-line
+ * zone, sprite row N is read from `ADDR + (zone_height - 1 - N) * 256`.
+ * That forces page-aligned per-row layouts (8 separate 256-byte
+ * pages for an 8-row sprite) UNLESS you side-step the quirk.
+ *
+ * This scaffold side-steps it: every zone is ONE scanline tall
+ * (offset=0), and we have 8 separate DL entries (one per row of the
+ * sprite). Each DL points at one row of contiguous pixel data. No
+ * page-alignment dance.
+ *
+ * Tradeoff: the DLL needs ONE entry per visible scanline, plus the
+ * 10 lines of top overscan that MARIA walks before the visible area
+ * starts. That's 243 entries × 3 bytes = 729 bytes — fits easily in
+ * the 4KB of internal RAM.
+ *
+ * ── Build ───────────────────────────────────────────────────────
+ *   buildSource({ platform: "atari7800", sources: { "main.c": ... } })
+ */
+#include <stdint.h>
+#include "atari7800_sfx.h"
+
+#define BACKGRND  (*(volatile uint8_t*)0x20)
+#define P0C1      (*(volatile uint8_t*)0x21)
+#define P0C2      (*(volatile uint8_t*)0x22)
+#define P0C3      (*(volatile uint8_t*)0x23)
+#define MSTAT     (*(volatile uint8_t*)0x28)
+#define DPPH      (*(volatile uint8_t*)0x2C)
+#define DPPL      (*(volatile uint8_t*)0x30)
+#define CHARBASE  (*(volatile uint8_t*)0x34)
+#define OFFSET    (*(volatile uint8_t*)0x38)
+#define CTRL      (*(volatile uint8_t*)0x3C)
+
+/* Sprite rows. In 160A mode (the default), 1 byte = 4 pixels of
+ * 2-bit colour. So 4 bytes per row = 16 pixels wide. Each 2-bit
+ * value selects: 00=backdrop, 01=P0C1, 10=P0C2, 11=P0C3.
+ *
+ * Pattern below = an 8x16 ball (orange-and-white). */
+static const uint8_t sprite_row0[4] = { 0x05, 0x55, 0x55, 0x50 };
+static const uint8_t sprite_row1[4] = { 0x55, 0xAA, 0xAA, 0x55 };
+static const uint8_t sprite_row2[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row3[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row4[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row5[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row6[4] = { 0x55, 0xAA, 0xAA, 0x55 };
+static const uint8_t sprite_row7[4] = { 0x05, 0x55, 0x55, 0x50 };
+
+/* DL for ONE sprite scanline. 5-byte (extended) form:
+ *   [0] = ADDR LSB                  (patched at runtime)
+ *   [1] = mode = 0x40 — extended form (bits 0-4 = 0) + bit 6 set so
+ *         MARIA's parse-loop continues. bit 7 unset = "write mode 0"
+ *         (4-pixels-per-byte, 160A graphics). bit 5 unset = direct.
+ *   [2] = ADDR MSB                  (patched at runtime)
+ *   [3] = palette(3) | width-encoding(5). Palette 0 (bits 5-7 = 0) +
+ *         width 4 bytes encoded as (32-4) = 0x1C in bits 0-4.
+ *         Final byte = 0x1C.
+ *   [4] = X position (in MARIA cell units; visible range ~0..159).
+ *
+ * After the 5-byte entry, MARIA reads `dp + 6` as the next entry's
+ * mode byte. So we need byte 6 to be 0 (terminator). Total: 7 bytes.
+ *
+ * A previous version of this scaffold used a 6-byte array — MARIA
+ * then read random memory at offset 6 as the next "mode" byte and
+ * walked off into garbage. If you change this size, update the
+ * terminator slot accordingly.
+ */
+#define MK_DL(name) static uint8_t name[7] = { 0, 0x40, 0, 0x1C, 80, 0, 0 }
+MK_DL(dl_row0); MK_DL(dl_row1); MK_DL(dl_row2); MK_DL(dl_row3);
+MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
+
+/* Empty DL — for zones with no objects. MARIA reads the mode byte
+ * at dp+1; if it's 0, the parse loop exits immediately. */
+static uint8_t dl_empty[2] = { 0, 0 };
+
+/* DLL: one entry per visible scanline + the 10-line top overscan
+ * MARIA walks BEFORE the visible area begins. NTSC display area =
+ * scanlines 16..258 = 243 lines.
+ *
+ * Per entry (3 bytes):
+ *   byte 0: DLI(bit 7) | H16(bit 6) | H8(bit 5) | offset(bits 0-3)
+ *           offset = (lines_in_zone - 1), max 15.
+ *   byte 1: DL pointer HIGH
+ *   byte 2: DL pointer LOW
+ *
+ * MARIA has NO DLL terminator — it just walks for every scanline.
+ * If your DLL is shorter than 243 entries, MARIA reads past the
+ * end into random memory and renders garbage. Always cover the
+ * full 243 lines.
+ */
+#define DLL_ZONES 243
+static uint8_t dll[DLL_ZONES * 3];
+
+#define SPRITE_Y 110  /* DLL index — ~middle of the visible area */
+
+static void set_dl_addr(uint8_t* dl, const uint8_t* row) {
+  uint16_t a = (uint16_t)(uintptr_t)row;
+  dl[0] = (uint8_t)(a & 0xFF);
+  dl[2] = (uint8_t)(a >> 8);
+}
+
+static void set_dll_entry(int idx, uint16_t dl_ptr) {
+  dll[idx * 3 + 0] = 0;                          /* offset=0, no DLI/holey */
+  dll[idx * 3 + 1] = (uint8_t)(dl_ptr >> 8);     /* HIGH */
+  dll[idx * 3 + 2] = (uint8_t)(dl_ptr & 0xFF);   /* LOW */
+}
+
+static void vblank_wait(void) {
+  while (MSTAT & 0x80) { }       /* if already in vblank, wait for it to end */
+  while (!(MSTAT & 0x80)) { }    /* then wait for next vblank to start */
+}
+
+void main(void) {
+  uint16_t dll_addr;
+  uint16_t empty_dl = (uint16_t)(uintptr_t)dl_empty;
+  int i;
+
+  /* Patch each row's DL to point at its sprite-data row. */
+  set_dl_addr(dl_row0, sprite_row0);
+  set_dl_addr(dl_row1, sprite_row1);
+  set_dl_addr(dl_row2, sprite_row2);
+  set_dl_addr(dl_row3, sprite_row3);
+  set_dl_addr(dl_row4, sprite_row4);
+  set_dl_addr(dl_row5, sprite_row5);
+  set_dl_addr(dl_row6, sprite_row6);
+  set_dl_addr(dl_row7, sprite_row7);
+
+  /* Build the DLL: empty zones everywhere except the 8 sprite rows. */
+  for (i = 0; i < DLL_ZONES; i++) {
+    uint16_t dl_ptr = empty_dl;
+    if      (i == SPRITE_Y + 0) dl_ptr = (uint16_t)(uintptr_t)dl_row0;
+    else if (i == SPRITE_Y + 1) dl_ptr = (uint16_t)(uintptr_t)dl_row1;
+    else if (i == SPRITE_Y + 2) dl_ptr = (uint16_t)(uintptr_t)dl_row2;
+    else if (i == SPRITE_Y + 3) dl_ptr = (uint16_t)(uintptr_t)dl_row3;
+    else if (i == SPRITE_Y + 4) dl_ptr = (uint16_t)(uintptr_t)dl_row4;
+    else if (i == SPRITE_Y + 5) dl_ptr = (uint16_t)(uintptr_t)dl_row5;
+    else if (i == SPRITE_Y + 6) dl_ptr = (uint16_t)(uintptr_t)dl_row6;
+    else if (i == SPRITE_Y + 7) dl_ptr = (uint16_t)(uintptr_t)dl_row7;
+    set_dll_entry(i, dl_ptr);
+  }
+
+  /* Palette + background. Atari NTSC palette: HHHL nibble form. */
+  BACKGRND = 0x88;   /* light blue */
+  P0C1     = 0x46;   /* orange-red */
+  P0C2     = 0x0F;   /* white */
+  P0C3     = 0x36;   /* pink */
+  CHARBASE = 0;
+  OFFSET   = 0;
+
+  /* Point MARIA at our DLL. */
+  dll_addr = (uint16_t)(uintptr_t)dll;
+  DPPL = (uint8_t)(dll_addr & 0xFF);
+  DPPH = (uint8_t)(dll_addr >> 8);
+
+  /* Enable DMA. Bit 6 = DMA on, bits 0-1 = 0 (160A mode), colour-burst on. */
+  CTRL = 0x40;
+
+  sfx_init();
+  sfx_tone(0, 10, 12);   /* boot chime */
+
+  for (;;) {
+    vblank_wait();
+    sfx_update();
+  }
+}

package/examples/atari7800/templates/hello_sprite.c

@@ -0,0 +1,141 @@
+/* hello_sprite.c — Atari 7800 single movable sprite + joystick.
+ *
+ * Extends default.c with joystick input: stick port A (SWCHA) drives
+ * X/Y. Same MARIA pattern (1-scanline zones, 7-byte DLs, 243-entry
+ * DLL — see default.c and MENTAL_MODEL.md for the full explanation
+ * of why every detail matters).
+ *
+ * Horizontal movement: mutate the X byte in each row's DL.
+ * Vertical movement: rebuild the DLL each frame so the 8 sprite-row
+ * DLs land at different DLL indices.
+ */
+#include <stdint.h>
+#include "atari7800_sfx.h"
+
+#define BACKGRND  (*(volatile uint8_t*)0x20)
+#define P0C1      (*(volatile uint8_t*)0x21)
+#define P0C2      (*(volatile uint8_t*)0x22)
+#define P0C3      (*(volatile uint8_t*)0x23)
+#define MSTAT     (*(volatile uint8_t*)0x28)
+#define DPPH      (*(volatile uint8_t*)0x2C)
+#define DPPL      (*(volatile uint8_t*)0x30)
+#define CHARBASE  (*(volatile uint8_t*)0x34)
+#define OFFSET    (*(volatile uint8_t*)0x38)
+#define CTRL      (*(volatile uint8_t*)0x3C)
+#define SWCHA     (*(volatile uint8_t*)0x280)
+
+/* SWCHA bit pattern (port A, active LOW — invert before testing) */
+#define JOY_UP    0x80
+#define JOY_DOWN  0x40
+#define JOY_LEFT  0x20
+#define JOY_RIGHT 0x10
+
+/* 16-pixel-wide ball (= 4 bytes in 160A mode), 8 rows tall. */
+static const uint8_t sprite_row0[4] = { 0x05, 0x55, 0x55, 0x50 };
+static const uint8_t sprite_row1[4] = { 0x55, 0xAA, 0xAA, 0x55 };
+static const uint8_t sprite_row2[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row3[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row4[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row5[4] = { 0x5A, 0xFF, 0xFF, 0xA5 };
+static const uint8_t sprite_row6[4] = { 0x55, 0xAA, 0xAA, 0x55 };
+static const uint8_t sprite_row7[4] = { 0x05, 0x55, 0x55, 0x50 };
+
+/* 5-byte extended DL + terminator at byte 6 (next entry's mode). */
+#define MK_DL(name) static uint8_t name[7] = { 0, 0x40, 0, 0x1C, 80, 0, 0 }
+MK_DL(dl_row0); MK_DL(dl_row1); MK_DL(dl_row2); MK_DL(dl_row3);
+MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
+
+static uint8_t dl_empty[2] = { 0, 0 };
+
+#define DLL_ZONES 243
+static uint8_t dll[DLL_ZONES * 3];
+
+static void set_dl_addr(uint8_t* dl, const uint8_t* row) {
+  uint16_t a = (uint16_t)(uintptr_t)row;
+  dl[0] = (uint8_t)(a & 0xFF);
+  dl[2] = (uint8_t)(a >> 8);
+}
+
+static void set_dll_entry(int idx, uint16_t dl_ptr) {
+  dll[idx * 3 + 0] = 0;
+  dll[idx * 3 + 1] = (uint8_t)(dl_ptr >> 8);
+  dll[idx * 3 + 2] = (uint8_t)(dl_ptr & 0xFF);
+}
+
+/* Build the DLL with the sprite's 8 rows placed at DLL index sprite_y. */
+static void build_dll(uint8_t sprite_y) {
+  uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
+  int i;
+  for (i = 0; i < DLL_ZONES; i++) {
+    uint16_t dl;
+    int d = i - (int)sprite_y;
+    switch (d) {
+      case 0: dl = (uint16_t)(uintptr_t)dl_row0; break;
+      case 1: dl = (uint16_t)(uintptr_t)dl_row1; break;
+      case 2: dl = (uint16_t)(uintptr_t)dl_row2; break;
+      case 3: dl = (uint16_t)(uintptr_t)dl_row3; break;
+      case 4: dl = (uint16_t)(uintptr_t)dl_row4; break;
+      case 5: dl = (uint16_t)(uintptr_t)dl_row5; break;
+      case 6: dl = (uint16_t)(uintptr_t)dl_row6; break;
+      case 7: dl = (uint16_t)(uintptr_t)dl_row7; break;
+      default: dl = empty; break;
+    }
+    set_dll_entry(i, dl);
+  }
+}
+
+static void set_x(uint8_t x) {
+  dl_row0[4] = x; dl_row1[4] = x; dl_row2[4] = x; dl_row3[4] = x;
+  dl_row4[4] = x; dl_row5[4] = x; dl_row6[4] = x; dl_row7[4] = x;
+}
+
+static void vblank_wait(void) {
+  while (MSTAT & 0x80) { }
+  while (!(MSTAT & 0x80)) { }
+}
+
+void main(void) {
+  uint16_t dll_addr;
+  uint8_t x = 80;
+  uint8_t y = 110;
+
+  /* Wire each DL's address bytes to its sprite-row data. */
+  set_dl_addr(dl_row0, sprite_row0);
+  set_dl_addr(dl_row1, sprite_row1);
+  set_dl_addr(dl_row2, sprite_row2);
+  set_dl_addr(dl_row3, sprite_row3);
+  set_dl_addr(dl_row4, sprite_row4);
+  set_dl_addr(dl_row5, sprite_row5);
+  set_dl_addr(dl_row6, sprite_row6);
+  set_dl_addr(dl_row7, sprite_row7);
+
+  set_x(x);
+  build_dll(y);
+
+  BACKGRND = 0x88;
+  P0C1     = 0x46;
+  P0C2     = 0x0F;
+  P0C3     = 0x36;
+  CHARBASE = 0;
+  OFFSET   = 0;
+
+  dll_addr = (uint16_t)(uintptr_t)dll;
+  DPPL = (uint8_t)(dll_addr & 0xFF);
+  DPPH = (uint8_t)(dll_addr >> 8);
+
+  CTRL = 0x40;
+
+  sfx_init();
+  sfx_tone(0, 10, 12);
+
+  for (;;) {
+    uint8_t pad;
+    vblank_wait();
+    sfx_update();
+    pad = ~SWCHA;
+    if ((pad & JOY_LEFT)  && x > 4)        { x--; set_x(x); }
+    if ((pad & JOY_RIGHT) && x < 152)      { x++; set_x(x); }
+    if ((pad & JOY_UP)    && y > 12)       { y--; build_dll(y); }
+    if ((pad & JOY_DOWN)  && y < DLL_ZONES - 9) { y++; build_dll(y); }
+  }
+}