romdevtools 0.15.0 → 0.21.0

package/examples/pce/puzzle/main.c

@@ -0,0 +1,304 @@
+/*
+ * PC Engine "puzzle" — a match-3 falling-block scaffold.
+ *
+ * A 1x3 column of coloured blocks falls into a 6-wide x 12-tall well drawn with
+ * background tiles. LEFT/RIGHT slide the piece, button I rotates the three
+ * colours, DOWN soft-drops, button II hard-drops. When a piece locks, any
+ * horizontal run of three same-colour cells clears and scores. Mirrors the
+ * NES/Genesis/SNES/GB/SMS puzzle scaffolds, translated to the PCE helper API.
+ *
+ * The whole field is drawn from BG tiles (no sprites needed) — a grey wall
+ * frame around a dim field interior, with R/G/B block tiles for the cells, so
+ * the screen is clearly a populated playfield (clears the verify gate).
+ *
+ * PCE notes (see pce_hw.h / MENTAL_MODEL.md):
+ *   - bg_enable() turns on the BG plane + the VBlank IRQ (waitvsync needs it).
+ *   - .bss must be non-empty (pce_video.c's _pce_keep[] covers it).
+ *
+ * cc65 is C89 — declare locals at the top of a block.
+ */
+#include <pce.h>
+#include <stdint.h>   /* int8_t for signed grid coordinates                   */
+#include "pce_hw.h"
+
+/* ---- VRAM layout (word addresses) --------------------------------------- */
+#define BAT_VRAM     0x0000
+#define BG_VRAM      0x1000   /* cabinet background (dotted, colour 6/7)     */
+#define RED_VRAM     0x1010   /* block colour 1                             */
+#define GRN_VRAM     0x1020   /* block colour 2                             */
+#define BLU_VRAM     0x1030   /* block colour 3                             */
+#define WALL_VRAM    0x1040   /* well border (colour 4)                     */
+#define FIELD_VRAM   0x1050   /* dim empty field (colour 5)                 */
+
+#define BAT_ENTRY(pal, vram)  ((u16)(((pal) << 12) | ((vram) >> 4)))
+
+#define COLS 6
+#define ROWS 12
+#define GRID_COL0 13   /* well's left BAT column (centres the 6-wide field)  */
+#define GRID_ROW0 4    /* well's top BAT row                                 */
+
+/* ---- state -------------------------------------------------------------- */
+static u8  grid[ROWS][COLS];   /* 0 = empty, 1..3 = colour                   */
+static u8  piece[3];           /* three stacked colours                      */
+static int8_t piece_x;         /* column 0..COLS-1                           */
+static int8_t piece_y;         /* row of top cell (can be negative)          */
+static u8  fall_timer;
+static u16 score;
+static u16 rng;
+static u8  pad, prev_pad;
+static u16 tile_buf[16];
+
+static void make_solid_tile(u16 *t, u8 ci) {
+    u8 r;
+    u8 p0 = (ci & 1) ? 0xFF : 0x00;
+    u8 p1 = (ci & 2) ? 0xFF : 0x00;
+    u8 p2 = (ci & 4) ? 0xFF : 0x00;
+    u8 p3 = (ci & 8) ? 0xFF : 0x00;
+    for (r = 0; r < 8; ++r) {
+        t[r]     = (u16)(p0 | (p1 << 8));
+        t[r + 8] = (u16)(p2 | (p3 << 8));
+    }
+}
+
+/* A block tile: a solid `ci`-colour body with a 1px `frame`-colour border on
+ * all four edges, so adjacent same-colour blocks still read as distinct cells.
+ * For each of the 8 rows we pick a per-plane mask: border rows (0,7) are all
+ * `frame`; interior rows are `ci` body with the left/right edge pixels framed. */
+static void make_block_tile(u16 *t, u8 ci, u8 frame) {
+    u8 r;
+    for (r = 0; r < 8; ++r) {
+        u8 edge_row = (r == 0 || r == 7);
+        /* body colour planes (fill the whole row) */
+        u8 b0 = (ci & 1) ? 0xFF : 0x00, b1 = (ci & 2) ? 0xFF : 0x00;
+        u8 b2 = (ci & 4) ? 0xFF : 0x00, b3 = (ci & 8) ? 0xFF : 0x00;
+        /* frame colour planes */
+        u8 f0 = (frame & 1) ? 0xFF : 0x00, f1 = (frame & 2) ? 0xFF : 0x00;
+        u8 f2 = (frame & 4) ? 0xFF : 0x00, f3 = (frame & 8) ? 0xFF : 0x00;
+        u8 p0, p1, p2, p3;
+        if (edge_row) {
+            p0 = f0; p1 = f1; p2 = f2; p3 = f3;             /* whole row framed */
+        } else {
+            /* body fill, but pixels 0 and 7 (mask 0x81) use the frame colour */
+            p0 = (u8)((b0 & 0x7E) | (f0 & 0x81));
+            p1 = (u8)((b1 & 0x7E) | (f1 & 0x81));
+            p2 = (u8)((b2 & 0x7E) | (f2 & 0x81));
+            p3 = (u8)((b3 & 0x7E) | (f3 & 0x81));
+        }
+        t[r]     = (u16)(p0 | (p1 << 8));
+        t[r + 8] = (u16)(p2 | (p3 << 8));
+    }
+}
+
+/* Cabinet background tile: every pixel is colour 6, with a colour-7 dot on a
+ * sparse lattice, so the whole screen reads as an intentional textured backdrop
+ * rather than the flat hardware backdrop. Colour 6 = planes 1+2; colour 7 adds
+ * plane 0 (so dots = planes 0+1+2). Build per-plane row bytes:
+ *   plane0 (low byte words 0..7)  = dot mask (only dot pixels)
+ *   plane1 (high byte words 0..7) = 0xFF (colour 6 base, all pixels)
+ *   plane2 (low byte words 8..15) = 0xFF (colour 6 base, all pixels)
+ *   plane3 (high byte words 8..15)= 0 */
+static void make_dots_tile(u16 *t) {
+    u8 r;
+    for (r = 0; r < 8; ++r) {
+        u8 dot = ((r & 3) == 0) ? 0x22 : 0x00;   /* dot columns every 4 px      */
+        t[r]     = (u16)(dot | 0xFF00u);          /* plane0=dots, plane1=base    */
+        t[r + 8] = (u16)0x00FFu;                  /* plane2=base,  plane3=0      */
+    }
+}
+
+static void upload_art(void) {
+    make_dots_tile(tile_buf); load_tiles(BG_VRAM, tile_buf, 16);
+    make_block_tile(tile_buf, 1, 6); load_tiles(RED_VRAM, tile_buf, 16);
+    make_block_tile(tile_buf, 2, 6); load_tiles(GRN_VRAM, tile_buf, 16);
+    make_block_tile(tile_buf, 3, 6); load_tiles(BLU_VRAM, tile_buf, 16);
+    make_solid_tile(tile_buf, 4); load_tiles(WALL_VRAM, tile_buf, 16);
+    make_solid_tile(tile_buf, 5); load_tiles(FIELD_VRAM, tile_buf, 16);
+}
+
+static u16 vram_for(u8 cell) {
+    if (cell == 1) return RED_VRAM;
+    if (cell == 2) return GRN_VRAM;
+    if (cell == 3) return BLU_VRAM;
+    return FIELD_VRAM;   /* empty -> dim field interior */
+}
+
+static void put_cell(u8 batCol, u8 batRow, u16 vram) {
+    u16 e = BAT_ENTRY(0, vram);
+    vram_set_write_addr((u16)(BAT_VRAM + batRow * 32 + batCol));
+    VDC_DATA_LO = (u8)(e & 0xFF);
+    VDC_DATA_HI = (u8)(e >> 8);
+}
+
+/* fill the whole BAT with the cabinet background tile */
+static void clear_bat(void) {
+    u8 r, c;
+    u16 e = BAT_ENTRY(0, BG_VRAM);
+    for (r = 0; r < 32; ++r) {
+        vram_set_write_addr((u16)(BAT_VRAM + r * 32));
+        for (c = 0; c < 32; ++c) {
+            VDC_DATA_LO = (u8)(e & 0xFF);
+            VDC_DATA_HI = (u8)(e >> 8);
+        }
+    }
+}
+
+/* draw the well frame + dim interior */
+static void draw_well(void) {
+    int8_t r, c;
+    for (r = -1; r <= ROWS; ++r) {
+        for (c = -1; c <= COLS; ++c) {
+            u16 vram = (r == -1 || r == ROWS || c == -1 || c == COLS)
+                       ? WALL_VRAM : FIELD_VRAM;
+            put_cell((u8)(GRID_COL0 + c), (u8)(GRID_ROW0 + r), vram);
+        }
+    }
+}
+
+static void draw_grid(void) {
+    u8 r, c;
+    for (r = 0; r < ROWS; ++r)
+        for (c = 0; c < COLS; ++c)
+            put_cell((u8)(GRID_COL0 + c), (u8)(GRID_ROW0 + r), vram_for(grid[r][c]));
+}
+
+static u16 next_rand(void) {
+    rng = (u16)(rng * 25173u + 13849u);
+    return rng;
+}
+static u8 rand_color(void) { return (u8)(1 + (next_rand() >> 8) % 3); }
+
+static void new_piece(void) {
+    piece[0] = rand_color();
+    piece[1] = rand_color();
+    piece[2] = rand_color();
+    piece_x = COLS / 2 - 1;
+    piece_y = -3;
+}
+
+static u8 collides(int8_t col, int8_t row) {
+    u8 i;
+    int8_t r;
+    if (col < 0 || col >= COLS) return 1;
+    for (i = 0; i < 3; ++i) {
+        r = (int8_t)(row + i);
+        if (r >= ROWS) return 1;
+        if (r >= 0 && grid[r][col] != 0) return 1;
+    }
+    return 0;
+}
+
+static void draw_piece(u8 clear) {
+    u8 i;
+    for (i = 0; i < 3; ++i) {
+        int8_t r = (int8_t)(piece_y + i);
+        u8 v;
+        if (r < 0 || r >= ROWS) continue;
+        v = clear ? grid[r][piece_x] : piece[i];
+        put_cell((u8)(GRID_COL0 + piece_x), (u8)(GRID_ROW0 + r), vram_for(v));
+    }
+}
+
+static void clear_triples(void) {
+    u8 r;
+    int8_t c;
+    u8 a, b, d;
+    for (r = 0; r < ROWS; ++r) {
+        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 < 9999) score += 30;
+                psg_tone(0, 0x180, 24);
+            }
+        }
+    }
+}
+
+static void lock_piece(void) {
+    u8 i;
+    int8_t r;
+    for (i = 0; i < 3; ++i) {
+        r = (int8_t)(piece_y + i);
+        if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
+    }
+    clear_triples();
+    draw_grid();
+}
+
+void main(void) {
+    u8 r, c;
+    u8 sfx_timer;
+
+    _pce_keep[0] = 0;
+
+    /* palette: BG sub-pal 0 holds field/wall + R/G/B blocks + frame */
+    vce_set_color(0, PCE_RGB(0, 0, 1));   /* backdrop navy            */
+    vce_set_color(1, PCE_RGB(7, 1, 1));   /* c1 red block             */
+    vce_set_color(2, PCE_RGB(1, 6, 1));   /* c2 green block           */
+    vce_set_color(3, PCE_RGB(2, 3, 7));   /* c3 blue block            */
+    vce_set_color(4, PCE_RGB(5, 5, 5));   /* c4 wall grey             */
+    vce_set_color(5, PCE_RGB(1, 2, 4));   /* c5 field blue (clearly   *
+                                           * distinct from backdrop)  */
+    vce_set_color(6, PCE_RGB(1, 0, 2));   /* c6 cabinet purple base + *
+                                           *    block frame           */
+    vce_set_color(7, PCE_RGB(2, 1, 4));   /* c7 cabinet dot           */
+
+    upload_art();
+    clear_bat();
+    draw_well();
+
+    for (r = 0; r < ROWS; ++r) for (c = 0; c < COLS; ++c) grid[r][c] = 0;
+    score = 0;
+    fall_timer = 0;
+    rng = 0x1357;
+    prev_pad = 0;
+    sfx_timer = 0;
+    new_piece();
+    draw_grid();
+
+    pce_joy_init();
+    bg_enable();
+
+    for (;;) {
+        u8 fall_rate;
+        waitvsync();
+
+        draw_piece(1);   /* erase old piece footprint                    */
+
+        pad = pce_joy_read();
+        if ((pad & PCE_JOY_LEFT)  && !(prev_pad & PCE_JOY_LEFT)
+            && !collides((int8_t)(piece_x - 1), piece_y)) piece_x--;
+        if ((pad & PCE_JOY_RIGHT) && !(prev_pad & PCE_JOY_RIGHT)
+            && !collides((int8_t)(piece_x + 1), piece_y)) piece_x++;
+        if ((pad & PCE_JOY_I) && !(prev_pad & PCE_JOY_I)) {
+            u8 t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+            psg_tone(1, 0x300, 18); sfx_timer = 3;
+        }
+        if ((pad & PCE_JOY_II) && !(prev_pad & PCE_JOY_II)) {
+            while (!collides(piece_x, (int8_t)(piece_y + 1))) piece_y++;
+            lock_piece();
+            new_piece();
+            psg_tone(1, 0x140, 22); sfx_timer = 4;
+            prev_pad = pad;
+            if (sfx_timer) { --sfx_timer; }
+            continue;
+        }
+        prev_pad = pad;
+
+        fall_rate = (pad & PCE_JOY_DOWN) ? 4 : 30;
+        fall_timer++;
+        if (fall_timer >= fall_rate) {
+            fall_timer = 0;
+            if (collides(piece_x, (int8_t)(piece_y + 1))) {
+                lock_piece();
+                new_piece();
+            } else {
+                piece_y++;
+            }
+        }
+
+        draw_piece(0);   /* draw piece at new position                   */
+
+        if (sfx_timer) { --sfx_timer; if (sfx_timer == 0) { psg_off(0); psg_off(1); } }
+    }
+}

package/examples/pce/racing/main.c

@@ -0,0 +1,304 @@
+/*
+ * PC Engine "racing" — a top-down lane-racer scaffold.
+ *
+ * Drive a car at the bottom of the screen up a 3-lane road. LEFT/RIGHT switch
+ * lanes; obstacle cars spawn at the top and slide down toward you. Dodge them —
+ * a collision freezes the game for a beat, then auto-resets. The road scrolls
+ * (dashed lane stripes animate via the BG Y-scroll register) and speed grows
+ * with your distance score. Mirrors the NES/Genesis/SNES/GB/SMS racing
+ * scaffolds, translated to the PCE helper API.
+ *
+ * Cars are hardware sprites; the road (grey lanes between green shoulders with
+ * animated dashed lane lines) is the BG tilemap, so the screen is clearly a
+ * road scene (clears the verify gate).
+ *
+ * PCE notes (see pce_hw.h / MENTAL_MODEL.md):
+ *   - disp_enable() turns on BG + sprites + the VBlank IRQ (waitvsync needs it).
+ *   - the road scroll is BG Y-scroll: vdc_set_reg(VDC_BYR, scroll).
+ *   - .bss must be non-empty (pce_video.c's _pce_keep[] covers it).
+ *
+ * cc65 is C89 — declare locals at the top of a block.
+ */
+#include <pce.h>
+#include <stdint.h>   /* int16_t for the per-frame speed step                 */
+#include "pce_hw.h"
+
+/* ---- VRAM layout (word addresses) --------------------------------------- */
+#define BAT_VRAM     0x0000
+#define FONT_VRAM    0x1000
+#define GRASS_VRAM   0x1400   /* shoulder grass (colour 1)                   */
+#define ROAD_VRAM    0x1410   /* plain road (colour 2)                       */
+#define DASH_VRAM    0x1420   /* road with a lane dash (colour 3)            */
+#define PLAYER_VRAM  0x1800   /* 16x16 player car                            */
+#define ENEMY_VRAM   0x1840   /* 16x16 enemy car                             */
+
+#define BAT_ENTRY(pal, vram)  ((u16)(((pal) << 12) | ((vram) >> 4)))
+
+#define LANE_L_X     76
+#define LANE_M_X    120
+#define LANE_R_X    164
+#define PLAYER_Y    176
+#define MAX_OBST      4
+
+/* ---- font (digits only) ------------------------------------------------- */
+#define NUM_GLYPHS 10
+static const u8 FONT5x7[NUM_GLYPHS][7] = {
+    {0x0E,0x11,0x13,0x15,0x19,0x11,0x0E},
+    {0x04,0x0C,0x04,0x04,0x04,0x04,0x0E},
+    {0x0E,0x11,0x01,0x02,0x04,0x08,0x1F},
+    {0x1F,0x02,0x04,0x02,0x01,0x11,0x0E},
+    {0x02,0x06,0x0A,0x12,0x1F,0x02,0x02},
+    {0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E},
+    {0x06,0x08,0x10,0x1E,0x11,0x11,0x0E},
+    {0x1F,0x01,0x02,0x04,0x08,0x08,0x08},
+    {0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E},
+    {0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C}
+};
+
+/* ---- state -------------------------------------------------------------- */
+typedef struct { u16 x, y; u8 alive; } Car;
+
+static Car player;
+static Car obst[MAX_OBST];
+static u16 score;
+static u8  spawn_timer;
+static u8  crash_timer;
+static u8  player_lane;
+static u8  road_scroll;
+static u16 rng;
+static u8  pad, prev_pad;
+static u8  sfx_timer;
+static u16 tile_buf[16];
+static u16 spr_buf[64];
+
+static const u16 lane_x[3] = { LANE_L_X, LANE_M_X, LANE_R_X };
+
+static void make_solid_tile(u16 *t, u8 ci) {
+    u8 r;
+    u8 p0 = (ci & 1) ? 0xFF : 0x00;
+    u8 p1 = (ci & 2) ? 0xFF : 0x00;
+    u8 p2 = (ci & 4) ? 0xFF : 0x00;
+    u8 p3 = (ci & 8) ? 0xFF : 0x00;
+    for (r = 0; r < 8; ++r) {
+        t[r]     = (u16)(p0 | (p1 << 8));
+        t[r + 8] = (u16)(p2 | (p3 << 8));
+    }
+}
+
+/* road tile with a centred lane dash in colour 3 (top half of the tile) */
+static void make_dash_tile(u16 *t) {
+    u8 r;
+    make_solid_tile(t, 2);          /* base road (colour 2) */
+    for (r = 0; r < 4; ++r) {
+        /* centre 4px (mask 0x18) -> colour 3 (planes 0+1): add plane0 bits */
+        t[r] = (u16)((t[r] & 0xFF00) | 0x18 | (t[r] & 0x00FF));
+    }
+}
+
+static void make_car_sprite(u16 vram, u8 ci) {
+    static const u16 car[16] = {
+        0x0660, 0x0660, 0x3FFC, 0x7FFE, 0x7FFE, 0x7FFE, 0x6FF6, 0x6FF6,
+        0x7FFE, 0x7FFE, 0x6FF6, 0x6FF6, 0x7FFE, 0x3FFC, 0x6006, 0x6006
+    };
+    u8 r;
+    for (r = 0; r < 64; ++r) spr_buf[r] = 0;
+    for (r = 0; r < 16; ++r) {
+        if (ci & 1) spr_buf[r]      = car[r];
+        if (ci & 2) spr_buf[r + 16] = car[r];
+        if (ci & 4) spr_buf[r + 32] = car[r];
+    }
+    load_tiles(vram, spr_buf, 64);
+}
+
+static void upload_font(void) {
+    u8 g, row, bits, plane0;
+    for (g = 0; g < NUM_GLYPHS; ++g) {
+        for (row = 0; row < 16; ++row) tile_buf[row] = 0;
+        for (row = 0; row < 7; ++row) {
+            bits = FONT5x7[g][row];
+            plane0 = 0;
+            if (bits & 0x10) plane0 |= 0x40;
+            if (bits & 0x08) plane0 |= 0x20;
+            if (bits & 0x04) plane0 |= 0x10;
+            if (bits & 0x02) plane0 |= 0x08;
+            if (bits & 0x01) plane0 |= 0x04;
+            tile_buf[row] = (u16)plane0;
+        }
+        load_tiles((u16)(FONT_VRAM + g * 16), tile_buf, 16);
+    }
+}
+
+/* Paint the road: grass shoulders, grey road in the middle, dashed lane lines
+ * between the three lanes. Player X spans ~76..164 -> BAT cols ~9..22. */
+static void draw_road(void) {
+    u8 r, c;
+    u16 grass = BAT_ENTRY(0, GRASS_VRAM);
+    u16 road  = BAT_ENTRY(0, ROAD_VRAM);
+    u16 dash  = BAT_ENTRY(0, DASH_VRAM);
+    u16 e;
+    for (r = 0; r < 32; ++r) {
+        vram_set_write_addr((u16)(BAT_VRAM + r * 32));
+        for (c = 0; c < 32; ++c) {
+            if (c < 8 || c > 23) {
+                e = grass;
+            } else if ((c == 12 || c == 17) && (r & 1)) {
+                e = dash;            /* dashed lane dividers, every other row  */
+            } else {
+                e = road;
+            }
+            VDC_DATA_LO = (u8)(e & 0xFF);
+            VDC_DATA_HI = (u8)(e >> 8);
+        }
+    }
+}
+
+static void put_glyph(u8 col, u8 row, u8 digit) {
+    u16 e = BAT_ENTRY(0, (u16)(FONT_VRAM + digit * 16));
+    vram_set_write_addr((u16)(BAT_VRAM + row * 32 + col));
+    VDC_DATA_LO = (u8)(e & 0xFF);
+    VDC_DATA_HI = (u8)(e >> 8);
+}
+
+static void draw_score(void) {
+    u16 v = score;
+    u8 d0, d1, d2, d3;
+    d3 = (u8)(v % 10); v /= 10;
+    d2 = (u8)(v % 10); v /= 10;
+    d1 = (u8)(v % 10); v /= 10;
+    d0 = (u8)(v % 10);
+    put_glyph(1, 1, d0);
+    put_glyph(2, 1, d1);
+    put_glyph(3, 1, d2);
+    put_glyph(4, 1, d3);
+}
+
+static u8 aabb(Car *a, Car *b) {
+    return (u8)(a->x < b->x + 14 && a->x + 14 > b->x &&
+                a->y < b->y + 14 && a->y + 14 > b->y);
+}
+
+static u16 next_rand(void) {
+    rng = (u16)(rng * 25173u + 13849u);
+    return rng;
+}
+
+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_OBST; ++i) obst[i].alive = 0;
+    score = 0;
+    spawn_timer = 0;
+    crash_timer = 0;
+}
+
+static void spawn_obst(void) {
+    u8 i;
+    for (i = 0; i < MAX_OBST; ++i) {
+        if (!obst[i].alive) {
+            obst[i].x = lane_x[(next_rand() >> 9) % 3];
+            obst[i].y = 0;
+            obst[i].alive = 1;
+            return;
+        }
+    }
+}
+
+void main(void) {
+    u8 i;
+
+    _pce_keep[0] = 0;
+
+    /* palette */
+    vce_set_color(0,   PCE_RGB(0, 1, 0));   /* backdrop dark green          */
+    vce_set_color(1,   PCE_RGB(1, 5, 1));   /* BG c1: grass                 */
+    vce_set_color(2,   PCE_RGB(2, 2, 2));   /* BG c2: road grey             */
+    vce_set_color(3,   PCE_RGB(7, 7, 1));   /* BG c3: yellow lane dash      */
+    vce_set_color(256, PCE_RGB(0, 0, 0));   /* spr pal0 transparent         */
+    vce_set_color(257, PCE_RGB(2, 5, 7));   /* spr pal0 c1: cyan player     */
+    vce_set_color(272, PCE_RGB(0, 0, 0));   /* spr pal1 transparent         */
+    vce_set_color(273, PCE_RGB(7, 1, 1));   /* spr pal1 c1: red enemy       */
+
+    upload_font();
+    make_solid_tile(tile_buf, 1); load_tiles(GRASS_VRAM, tile_buf, 16);
+    make_solid_tile(tile_buf, 2); load_tiles(ROAD_VRAM, tile_buf, 16);
+    make_dash_tile(tile_buf);     load_tiles(DASH_VRAM, tile_buf, 16);
+    make_car_sprite(PLAYER_VRAM, 1);   /* colour 1 */
+    make_car_sprite(ENEMY_VRAM,  1);   /* colour 1 (sub-pal 1 = red) */
+
+    draw_road();
+
+    rng = 0xBEEF;
+    road_scroll = 0;
+    prev_pad = 0;
+    sfx_timer = 0;
+    reset_run();
+    draw_score();
+
+    pce_joy_init();
+    disp_enable();
+
+    for (;;) {
+        u8 slot;
+        int16_t step;
+        waitvsync();
+
+        /* stage sprites: player + obstacles */
+        slot = 0;
+        set_sprite(slot++, player.x, player.y, PLAYER_VRAM >> 6, 0);
+        for (i = 0; i < MAX_OBST; ++i) {
+            u16 ey = obst[i].alive ? obst[i].y : 0x1F0;
+            set_sprite(slot++, obst[i].x, ey, ENEMY_VRAM >> 6, 1);
+        }
+        satb_dma();
+
+        pad = pce_joy_read();
+
+        if (crash_timer > 0) {
+            crash_timer--;
+            if (crash_timer == 0) reset_run();
+            prev_pad = pad;
+            if (sfx_timer) { --sfx_timer; if (sfx_timer == 0) psg_off(0); }
+            continue;
+        }
+
+        /* lane switch (edge-triggered) */
+        if ((pad & PCE_JOY_LEFT)  && !(prev_pad & PCE_JOY_LEFT)  && player_lane > 0) { player_lane--; psg_tone(1, 0x2C0, 16); sfx_timer = 3; }
+        if ((pad & PCE_JOY_RIGHT) && !(prev_pad & PCE_JOY_RIGHT) && player_lane < 2) { player_lane++; psg_tone(1, 0x2C0, 16); sfx_timer = 3; }
+        player.x = lane_x[player_lane];
+        prev_pad = pad;
+
+        /* speed grows with score */
+        step = (int16_t)(2 + (score / 400));
+        if (step > 5) step = 5;
+
+        /* scroll the road to sell motion */
+        road_scroll = (u8)(road_scroll + step);
+        vdc_set_reg(VDC_BYR, (u16)road_scroll);
+
+        for (i = 0; i < MAX_OBST; ++i) {
+            if (!obst[i].alive) continue;
+            obst[i].y = (u16)(obst[i].y + step);
+            if (obst[i].y >= 216) obst[i].alive = 0;
+        }
+
+        spawn_timer++;
+        if (spawn_timer >= 40) { spawn_timer = 0; spawn_obst(); }
+
+        for (i = 0; i < MAX_OBST; ++i) {
+            if (obst[i].alive && aabb(&player, &obst[i])) {
+                crash_timer = 70;
+                psg_tone(0, 0x080, 28);   /* crash buzz */
+                sfx_timer = 16;
+                break;
+            }
+        }
+
+        if (score < 9999) score++;
+        if ((score & 7) == 0) draw_score();
+
+        if (sfx_timer) { --sfx_timer; if (sfx_timer == 0) { psg_off(0); psg_off(1); } }
+    }
+}