romdevtools 0.16.0 → 0.22.0

package/examples/msx/platformer/main.c

@@ -0,0 +1,213 @@
+/* ── platformer/main.c — MSX SIDE-SCROLLING platformer scaffold ──────
+ *
+ * Mirrors the SMS/GB/etc platformer scaffolds, translated to the MSX VDP
+ * via the romdev helper lib (msx_hw.h + msx_vdp.c).
+ *
+ * The world is 512 px wide (64 cells); the screen-2 name table is only 32
+ * cells (256 px) and wraps, so a world wider than one screen needs COLUMN
+ * STREAMING: each time the camera crosses an 8-px boundary we rewrite the
+ * name-table column about to scroll into view with the next world column's
+ * tiles. Screen 2 has no smooth-pixel-scroll register, so the camera moves
+ * in whole 8-px cells — the streaming gives a clean tile-by-tile scroll.
+ *
+ * Subpixel state (x/y in 1/16-pixel units) for fine gravity/acceleration;
+ * the player sprite draws in SCREEN space ((worldX>>4) - camX).
+ *
+ * Controls: joystick LEFT/RIGHT walks, trigger A jumps (only when grounded).
+ *
+ * Cartridge rule: INIT must never return — main() ends in for(;;).
+ */
+#include "msx_hw.h"
+
+/* ── interrupt-free vblank sync (poll VDP status S#0 bit 7) ────────────── */
+__sfr __at 0x99 VDPSTATUS;
+static void vsync(void) {
+    (void)VDPSTATUS;
+    while (!(VDPSTATUS & 0x80)) {
+    }
+}
+/* jump uses the BIOS GTTRIG wrapper (gttrig) provided by msx_hw.h. */
+
+#define T_OPEN  0
+#define T_WALL  1
+
+#define WORLD_COLS 64
+#define WORLD_W    (WORLD_COLS * 8)
+#define SCREEN_W   256
+#define VIS_ROWS   24
+
+/* background tile patterns (8x8) */
+static const uint8_t TILE_OPEN[8] = {0,0,0,0,0,0,0,0};
+static const uint8_t TILE_WALL[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+
+#define COL_OPEN 0x14   /* light-blue "open" (sky) on dark blue */
+#define COL_WALL 0xE4   /* grey wall on dark blue               */
+
+/* player sprite (8x8) */
+static const uint8_t SPR_PLAYER[8] = {0x3C,0x7E,0xFF,0xFF,0xFF,0xFF,0x7E,0x3C};
+#define COL_PLAYER 9    /* red-ish */
+
+typedef struct { int16_t x, y, w, h; } Rect;
+
+/* platforms in WORLD coords, spread across the 512-px world */
+static const Rect platforms[] = {
+    {   0, 176, 512,  16 }, /* floor spans the world */
+    {  32, 144,  56,   8 },
+    { 120, 144,  64,   8 },
+    { 200, 112,  48,   8 },
+    {  56,  96,  40,   8 },
+    { 288, 136,  64,   8 },
+    { 384, 104,  56,   8 },
+    { 440, 152,  48,   8 },
+    { 320,  72,  48,   8 }
+};
+#define N_PLATFORMS (sizeof(platforms) / sizeof(platforms[0]))
+
+static int16_t  px, py;       /* player pos, 1/16-px units */
+static int16_t  vx, vy;
+static int16_t  camX;         /* camera X in pixels (cell-aligned) */
+static int16_t  lastCamCol;
+
+static void load_tiles(void) {
+    uint8_t third;
+    uint16_t poff;
+    for (third = 0; third < 3; third++) {
+        poff = (uint16_t)((uint16_t)third << 11);
+        msx_vram_write((uint16_t)(VRAM_PATTERN + poff + 0), TILE_OPEN, 8);
+        msx_vram_write((uint16_t)(VRAM_PATTERN + poff + 8), TILE_WALL, 8);
+        msx_fill_vram((uint16_t)(VRAM_COLOR + poff + 0), 8, COL_OPEN);
+        msx_fill_vram((uint16_t)(VRAM_COLOR + poff + 8), 8, COL_WALL);
+    }
+}
+
+static uint8_t cell_is_wall(int16_t col, uint8_t row) {
+    int16_t cx = (int16_t)(col << 3);
+    int16_t cy = (int16_t)((int16_t)row << 3);
+    uint8_t i;
+    const Rect *p;
+    for (i = 0; i < N_PLATFORMS; i++) {
+        p = &platforms[i];
+        if (cx + 8 > p->x && cx < p->x + p->w
+            && cy + 8 > p->y && cy < p->y + p->h) return 1;
+    }
+    return 0;
+}
+
+static uint8_t on_platform(int16_t ipx, int16_t ipy) {
+    uint8_t i;
+    const Rect *p;
+    for (i = 0; i < N_PLATFORMS; i++) {
+        p = &platforms[i];
+        if (ipy + 8 == p->y && ipx + 8 > p->x && ipx < p->x + p->w) return 1;
+    }
+    return 0;
+}
+
+/* write one world column into its wrapped name-table column */
+static void paint_column(int16_t worldCol) {
+    uint8_t ntCol, row, tile;
+    uint16_t addr;
+    if (worldCol < 0 || worldCol >= WORLD_COLS) return;
+    ntCol = (uint8_t)(worldCol & 31);
+    for (row = 0; row < VIS_ROWS; row++) {
+        tile = cell_is_wall(worldCol, row) ? T_WALL : T_OPEN;
+        addr = (uint16_t)(VRAM_NAME + (uint16_t)row * 32 + ntCol);
+        msx_vram_write(addr, &tile, 1);
+    }
+}
+
+static void paint_initial(void) {
+    int16_t c;
+    for (c = 0; c < 32; c++) paint_column(c);
+}
+
+void main(void) {
+    const int16_t GRAVITY = 10;
+    const int16_t MOVE    = 24;
+    const int16_t JUMP    = -200;
+    const int16_t MAXFALL = 280;
+    uint8_t dir, trig, prev_trig, grounded, blip;
+
+    msx_set_screen2();
+    msx_clear_sprites();
+    load_tiles();
+    msx_fill_vram(VRAM_NAME, 32 * 24, T_OPEN);
+    msx_vram_write((uint16_t)(VRAM_SPRPAT + 0), SPR_PLAYER, 8);
+
+    px = (int16_t)(16 << 4);
+    py = (int16_t)(64 << 4);
+    vx = 0; vy = 0;
+    camX = 0; lastCamCol = 0;
+    prev_trig = 0; blip = 0;
+
+    paint_initial();
+
+    for (;;) {
+        int16_t ipx, ipy, npy, sx, camCol;
+        int32_t np;
+        uint8_t i, landed;
+        const Rect *p;
+
+        vsync();
+
+        ipx = (int16_t)(px >> 4);
+        ipy = (int16_t)(py >> 4);
+
+        /* camera follows the player, centered, clamped, snapped to a cell */
+        camX = (int16_t)(ipx - (SCREEN_W / 2 - 4));
+        if (camX < 0) camX = 0;
+        if (camX > WORLD_W - SCREEN_W) camX = (int16_t)(WORLD_W - SCREEN_W);
+        camX = (int16_t)(camX & ~7);
+
+        camCol = (int16_t)(camX >> 3);
+        while (camCol > lastCamCol) { lastCamCol++; paint_column((int16_t)(lastCamCol + 31)); }
+        while (camCol < lastCamCol) { lastCamCol--; paint_column(lastCamCol); }
+
+        sx = (int16_t)(ipx - camX);
+        if (sx < 0) sx = 0;
+        if (sx > 248) sx = 248;
+        msx_set_sprite(0, (uint8_t)sx, (uint8_t)ipy, 0, COL_PLAYER);
+
+        dir = msx_read_joystick(1);
+        if (dir == STICK_CENTER) dir = msx_read_joystick(0);
+        trig = (uint8_t)(gttrig(1) || gttrig(2));
+
+        vx = 0;
+        if (dir == STICK_LEFT || dir == STICK_UL || dir == STICK_DL) vx = (int16_t)(-MOVE);
+        if (dir == STICK_RIGHT || dir == STICK_UR || dir == STICK_DR) vx = MOVE;
+
+        grounded = on_platform(ipx, ipy);
+        if (trig && !prev_trig && grounded) { vy = JUMP; msx_psg_tone(0, 0x180, 12); blip = 6; }
+        prev_trig = trig;
+
+        vy = (int16_t)(vy + GRAVITY);
+        if (vy > MAXFALL) vy = MAXFALL;
+        if (grounded && vy > 0) vy = 0;
+
+        px = (int16_t)(px + vx);
+        if (px < 0) px = 0;
+        if (px > (int16_t)((WORLD_W - 8) << 4)) px = (int16_t)((WORLD_W - 8) << 4);
+
+        np = (int32_t)py + (int32_t)vy;
+        npy = (int16_t)(np >> 4);
+        if (vy > 0) {
+            landed = 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 = (int16_t)((p->y - 8) << 4);
+                    vy = 0;
+                    landed = 1;
+                    break;
+                }
+            }
+            if (!landed) py = (int16_t)np;
+        } else {
+            py = (int16_t)np;
+        }
+        if (py > (int16_t)(192 << 4)) { py = (int16_t)(64 << 4); vy = 0; }
+
+        if (blip) { blip--; if (!blip) msx_psg_off(0); }
+    }
+}

package/examples/msx/puzzle/main.c

@@ -0,0 +1,250 @@
+/* ── puzzle/main.c — MSX match-3 falling-block scaffold (screen 2) ───
+ *
+ * Mirrors the SMS/GB/etc puzzle scaffolds, translated to the MSX VDP via
+ * the romdev helper lib (msx_hw.h + msx_vdp.c).
+ *
+ * A 6-wide x 12-tall well drawn entirely with the BG tilemap: distinct
+ * R/G/B cell tiles, a grey border frame, and a dim field interior so the
+ * playfield is visible even when empty (the screen is never blank). A 1x3
+ * active piece falls; clears happen on a horizontal triple of one colour.
+ *
+ * Controls (joystick PORT 1 + triggers):
+ *   LEFT/RIGHT  shift the piece (edge-detected)
+ *   trigger A   rotate the colour order of the 1x3 piece
+ *   DOWN        soft-drop (fast fall)
+ *   trigger B   hard-drop + lock
+ *
+ * Cartridge rule: INIT must never return — main() ends in for(;;).
+ */
+#include "msx_hw.h"
+
+/* ── interrupt-free vblank sync (poll VDP status S#0 bit 7) ────────────── */
+__sfr __at 0x99 VDPSTATUS;
+static void vsync(void) {
+    (void)VDPSTATUS;
+    while (!(VDPSTATUS & 0x80)) {
+    }
+}
+/* triggers use the BIOS GTTRIG wrapper (gttrig) provided by msx_hw.h. */
+
+#define COLS 6
+#define ROWS 12
+
+#define T_BLANK 0
+#define T_R     1
+#define T_G     2
+#define T_B     3
+#define T_WALL  4   /* well border         */
+#define T_FIELD 5   /* dim well interior   */
+
+/* 8x8 tile patterns: solid fills (the colour comes from the colour table) */
+static const uint8_t TILE_SOLID[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+static const uint8_t TILE_BLANK[8] = {0,0,0,0,0,0,0,0};
+static const uint8_t TILE_CELL[8]  = {0x7E,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x7E};
+
+/* colour bytes (hi nibble fg, lo nibble bg). TMS9918 palette:
+ * 9=red, 12=green(light), 4=blue, 14=grey, 1=black. */
+#define COL_R     0x91
+#define COL_G     0xC1
+#define COL_B     0x41
+#define COL_WALL  0xE1
+#define COL_FIELD 0x41   /* same blue as B but used for the empty field */
+
+static uint8_t  grid[ROWS][COLS];
+static uint8_t  piece[3];
+static int8_t   piece_x;
+static int8_t   piece_y;
+static uint8_t  fall_timer;
+static uint16_t score;
+static uint16_t rng;
+static uint8_t  blip;
+
+static uint16_t xorshift(void) {
+    rng ^= (uint16_t)(rng << 7);
+    rng ^= (uint16_t)(rng >> 9);
+    rng ^= (uint16_t)(rng << 8);
+    return rng;
+}
+static uint8_t rand_color(void) { return (uint8_t)(1 + (xorshift() % 3)); }
+
+static uint8_t tile_for(uint8_t c) {
+    if (c == 1) return T_R;
+    if (c == 2) return T_G;
+    if (c == 3) return T_B;
+    return T_FIELD;   /* empty cell shows the dim field, not the backdrop */
+}
+
+static void load_tiles(void) {
+    uint8_t third;
+    uint16_t pat, col;
+    for (third = 0; third < 3; third++) {
+        pat = (uint16_t)(VRAM_PATTERN + ((uint16_t)third << 11));
+        col = (uint16_t)(VRAM_COLOR   + ((uint16_t)third << 11));
+        msx_vram_write((uint16_t)(pat + T_BLANK * 8), TILE_BLANK, 8);
+        msx_vram_write((uint16_t)(pat + T_R     * 8), TILE_CELL,  8);
+        msx_vram_write((uint16_t)(pat + T_G     * 8), TILE_CELL,  8);
+        msx_vram_write((uint16_t)(pat + T_B     * 8), TILE_CELL,  8);
+        msx_vram_write((uint16_t)(pat + T_WALL  * 8), TILE_SOLID, 8);
+        msx_vram_write((uint16_t)(pat + T_FIELD * 8), TILE_SOLID, 8);
+        msx_fill_vram((uint16_t)(col + T_BLANK * 8), 8, 0x11);
+        msx_fill_vram((uint16_t)(col + T_R     * 8), 8, COL_R);
+        msx_fill_vram((uint16_t)(col + T_G     * 8), 8, COL_G);
+        msx_fill_vram((uint16_t)(col + T_B     * 8), 8, COL_B);
+        msx_fill_vram((uint16_t)(col + T_WALL  * 8), 8, COL_WALL);
+        msx_fill_vram((uint16_t)(col + T_FIELD * 8), 8, COL_FIELD);
+    }
+}
+
+static void set_cell_tile(uint8_t row, uint8_t col, uint8_t tile) {
+    msx_vram_write((uint16_t)(VRAM_NAME + (uint16_t)row * 32 + col), &tile, 1);
+}
+
+/* grid cell (col,row) -> name-table (row+1, col+13): centres the well */
+static void draw_cell(int8_t col, int8_t row, uint8_t cell) {
+    if (row < 0 || row >= ROWS) return;
+    set_cell_tile((uint8_t)(row + 1), (uint8_t)(col + 13), tile_for(cell));
+}
+
+/* grey frame around the 6x12 field + dim interior so it is always visible.
+ * field cells are rows 1..12, cols 13..18; frame rows 0..13, cols 12..19. */
+static void draw_well(void) {
+    uint8_t r, c, t;
+    for (r = 0; r <= 13; r++) {
+        for (c = 12; c <= 19; c++) {
+            t = T_FIELD;
+            if (r == 0 || r == 13 || c == 12 || c == 19) t = T_WALL;
+            set_cell_tile(r, c, t);
+        }
+    }
+}
+
+static void draw_grid(void) {
+    int8_t r, c;
+    for (r = 0; r < ROWS; r++)
+        for (c = 0; c < COLS; c++) draw_cell(c, r, grid[r][c]);
+}
+
+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 uint8_t collides(int8_t col, int8_t row) {
+    uint8_t 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 lock_piece(void) {
+    uint8_t i;
+    int8_t r, c;
+    uint8_t a, b, d;
+    for (i = 0; i < 3; i++) {
+        r = (int8_t)(piece_y + i);
+        if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
+    }
+    for (i = 0; i < 3; i++) {
+        r = (int8_t)(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 < 999) score += 3;
+                msx_psg_tone(0, 0x180, 13);
+                blip = 8;
+            }
+        }
+    }
+    draw_grid();
+}
+
+static void draw_piece(uint8_t clear) {
+    uint8_t i;
+    int8_t r;
+    uint8_t v;
+    for (i = 0; i < 3; i++) {
+        r = (int8_t)(piece_y + i);
+        if (r < 0 || r >= ROWS) continue;
+        v = clear ? grid[r][piece_x] : piece[i];
+        draw_cell(piece_x, r, v);
+    }
+}
+
+void main(void) {
+    uint8_t r, c, dir, prev_dir, ta, tb, prev_ta, prev_tb, fall_rate, t;
+
+    msx_set_screen2();
+    msx_clear_sprites();
+    load_tiles();
+    msx_fill_vram(VRAM_NAME, 32 * 24, T_BLANK);
+
+    for (r = 0; r < ROWS; r++)
+        for (c = 0; c < COLS; c++) grid[r][c] = 0;
+
+    score = 0;
+    fall_timer = 0;
+    rng = 0xACE1;
+    blip = 0;
+    prev_dir = 0; prev_ta = 0; prev_tb = 0;
+    new_piece();
+    draw_well();
+    draw_grid();
+
+    for (;;) {
+        vsync();
+        draw_piece(1);
+
+        dir = msx_read_joystick(1);
+        if (dir == STICK_CENTER) dir = msx_read_joystick(0);
+        ta = (uint8_t)(gttrig(1) != 0);
+        tb = (uint8_t)(gttrig(2) != 0);
+
+        if ((dir == STICK_LEFT || dir == STICK_UL || dir == STICK_DL)
+            && !(prev_dir == STICK_LEFT || prev_dir == STICK_UL || prev_dir == STICK_DL)
+            && !collides((int8_t)(piece_x - 1), piece_y)) piece_x--;
+        if ((dir == STICK_RIGHT || dir == STICK_UR || dir == STICK_DR)
+            && !(prev_dir == STICK_RIGHT || prev_dir == STICK_UR || prev_dir == STICK_DR)
+            && !collides((int8_t)(piece_x + 1), piece_y)) piece_x++;
+
+        if (ta && !prev_ta) {
+            t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+            msx_psg_tone(1, 0x280, 8); blip = 4;
+        }
+
+        if (tb && !prev_tb) {
+            while (!collides(piece_x, (int8_t)(piece_y + 1))) piece_y++;
+            lock_piece();
+            new_piece();
+            prev_dir = dir; prev_ta = ta; prev_tb = tb;
+            if (blip) { blip--; if (!blip) { msx_psg_off(0); msx_psg_off(1); } }
+            continue;
+        }
+
+        prev_dir = dir; prev_ta = ta; prev_tb = tb;
+
+        fall_rate = (dir == STICK_DOWN || dir == STICK_DL || dir == STICK_DR) ? 4 : 30;
+        fall_timer = (uint8_t)(fall_timer + 1);
+        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);
+
+        if (blip) { blip--; if (!blip) { msx_psg_off(0); msx_psg_off(1); } }
+    }
+}

package/examples/msx/racing/main.c

@@ -0,0 +1,249 @@
+/* ── racing/main.c — MSX top-down 3-lane racing scaffold (screen 2) ──
+ *
+ * Mirrors the SMS/GB/etc racing scaffolds, translated to the MSX VDP via
+ * the romdev helper lib (msx_hw.h + msx_vdp.c).
+ *
+ * Endless 3-lane top-down racer. Grey road down the centre lanes + green
+ * grass shoulders fill the whole 32x24 screen-2 name table. The player car
+ * sits near the bottom; obstacle cars (object pool) spawn at the top and
+ * slide down. Speed grows with score; an AABB crash triggers a ~60-frame
+ * freeze then auto-reset. SCORE is drawn as on-screen tiles.
+ *
+ * Controls: joystick PORT 1 LEFT/RIGHT (edge-detected) switches lanes.
+ *
+ * Cartridge rule: INIT must never return — main() ends in for(;;).
+ */
+#include "msx_hw.h"
+
+/* ── interrupt-free vblank sync (poll VDP status S#0 bit 7) ────────────── */
+__sfr __at 0x99 VDPSTATUS;
+static void vsync(void) {
+    (void)VDPSTATUS;
+    while (!(VDPSTATUS & 0x80)) {
+    }
+}
+
+#define LANE_LEFT_X    96
+#define LANE_MID_X    124
+#define LANE_RIGHT_X  152
+#define PLAYER_Y      160
+#define MAX_OBSTACLES   4
+
+/* ── tile font (digits + S C O R E) + track tiles ─────────────────────── */
+#define T_SPACE 0
+#define T_S     1
+#define T_C     2
+#define T_O     3
+#define T_R     4
+#define T_E     5
+#define T_0     6
+#define T_GRASS 16
+#define T_ROAD  17
+#define T_LANE  18   /* dashed lane marker */
+
+static const uint8_t font[19][8] = {
+    /* 0  SPACE */ {0,0,0,0,0,0,0,0},
+    /* 1  S */ {0x7C,0xC0,0xC0,0x78,0x0C,0x0C,0xF8,0x00},
+    /* 2  C */ {0x7C,0xC6,0xC0,0xC0,0xC0,0xC6,0x7C,0x00},
+    /* 3  O */ {0x7C,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00},
+    /* 4  R */ {0xFC,0xC6,0xC6,0xFC,0xD8,0xCC,0xC6,0x00},
+    /* 5  E */ {0xFE,0xC0,0xC0,0xF8,0xC0,0xC0,0xFE,0x00},
+    /* 6  0 */ {0x7C,0xCE,0xDE,0xF6,0xE6,0xC6,0x7C,0x00},
+    /* 7  1 */ {0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00},
+    /* 8  2 */ {0x7C,0xC6,0x06,0x1C,0x70,0xC0,0xFE,0x00},
+    /* 9  3 */ {0x7C,0xC6,0x06,0x3C,0x06,0xC6,0x7C,0x00},
+    /* 10 4 */ {0x1C,0x3C,0x6C,0xCC,0xFE,0x0C,0x0C,0x00},
+    /* 11 5 */ {0xFE,0xC0,0xFC,0x06,0x06,0xC6,0x7C,0x00},
+    /* 12 6 */ {0x3C,0x60,0xC0,0xFC,0xC6,0xC6,0x7C,0x00},
+    /* 13 7 */ {0xFE,0x06,0x0C,0x18,0x30,0x30,0x30,0x00},
+    /* 14 8 */ {0x7C,0xC6,0xC6,0x7C,0xC6,0xC6,0x7C,0x00},
+    /* 15 9 */ {0x7C,0xC6,0xC6,0x7E,0x06,0x0C,0x78,0x00},
+    /* 16 GRASS */ {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
+    /* 17 ROAD  */ {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
+    /* 18 LANE  */ {0x18,0x18,0x18,0x00,0x00,0x18,0x18,0x18}
+};
+
+/* colour bytes. 3=green(dark), 12=green(light), 14=grey, 15=white, 1=black */
+#define COL_TEXT  0xF1   /* white text on black              */
+#define COL_GRASS 0xC1   /* light green grass on black       */
+#define COL_ROAD  0xE1   /* grey road on black               */
+#define COL_LANE  0xAE   /* yellow dashes on grey road       */
+
+/* sprite patterns (8x8): player car + enemy car */
+static const uint8_t spr_player[8] = {0x18,0x3C,0x24,0x3C,0x7E,0x24,0x7E,0x66};
+static const uint8_t spr_enemy[8]  = {0x66,0x7E,0x24,0x7E,0x3C,0x24,0x3C,0x18};
+#define PAT_PLAYER 0
+#define PAT_ENEMY  1
+#define COL_PLAYER 15   /* white  */
+#define COL_ENEMY  9    /* red    */
+
+typedef struct { uint8_t x, y, alive; } Car;
+
+static Car      player;
+static Car      obstacles[MAX_OBSTACLES];
+static uint16_t score;
+static uint8_t  spawn_timer;
+static uint8_t  game_over_timer;
+static uint8_t  player_lane;
+static uint16_t rng;
+static uint8_t  blip;
+
+static const uint8_t lane_x[3] = { LANE_LEFT_X, LANE_MID_X, LANE_RIGHT_X };
+
+static uint8_t next_rand(void) {
+    rng ^= (uint16_t)(rng << 7);
+    rng ^= (uint16_t)(rng >> 9);
+    rng ^= (uint16_t)(rng << 8);
+    return (uint8_t)(rng & 0xFF);
+}
+
+static uint8_t 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 load_tiles(void) {
+    uint8_t third, i;
+    uint16_t pat, col;
+    for (third = 0; third < 3; third++) {
+        pat = (uint16_t)(VRAM_PATTERN + ((uint16_t)third << 11));
+        col = (uint16_t)(VRAM_COLOR   + ((uint16_t)third << 11));
+        for (i = 0; i < 19; i++) {
+            uint8_t cc = COL_TEXT;
+            if (i == T_GRASS) cc = COL_GRASS;
+            else if (i == T_ROAD) cc = COL_ROAD;
+            else if (i == T_LANE) cc = COL_LANE;
+            msx_vram_write((uint16_t)(pat + ((uint16_t)i << 3)), font[i], 8);
+            msx_fill_vram((uint16_t)(col + ((uint16_t)i << 3)), 8, cc);
+        }
+    }
+}
+
+static void put_tile(uint8_t col, uint8_t row, uint8_t tile) {
+    msx_vram_write((uint16_t)(VRAM_NAME + (uint16_t)row * 32 + col), &tile, 1);
+}
+
+/* road spans cols ~11..20 (player X 96..152); grass elsewhere; dashed lane
+ * markers between the three lanes (cols 14 and 17) on alternating rows. */
+static void draw_track(void) {
+    uint8_t row, col, t;
+    for (row = 0; row < 24; row++) {
+        for (col = 0; col < 32; col++) {
+            t = (col >= 11 && col <= 20) ? T_ROAD : T_GRASS;
+            if ((col == 14 || col == 17) && (row & 1)) t = T_LANE;
+            put_tile(col, row, t);
+        }
+    }
+}
+
+static void draw_label(void) {
+    put_tile(1, 0, T_S); put_tile(2, 0, T_C); put_tile(3, 0, T_O);
+    put_tile(4, 0, T_R); put_tile(5, 0, T_E);
+}
+
+static void draw_score(void) {
+    uint16_t s = score;
+    put_tile(7, 0, (uint8_t)(T_0 + (s / 100) % 10));
+    put_tile(8, 0, (uint8_t)(T_0 + (s / 10) % 10));
+    put_tile(9, 0, (uint8_t)(T_0 + s % 10));
+}
+
+static void reset_run(void) {
+    uint8_t 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;
+    draw_score();
+}
+
+static void spawn_obstacle(void) {
+    uint8_t i;
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+        if (!obstacles[i].alive) {
+            obstacles[i].x = lane_x[next_rand() % 3];
+            obstacles[i].y = 16;
+            obstacles[i].alive = 1;
+            return;
+        }
+    }
+}
+
+void main(void) {
+    uint8_t i, slot, dir, prev_dir;
+    int16_t step;
+
+    msx_set_screen2();
+    msx_clear_sprites();
+    load_tiles();
+    draw_track();
+    draw_label();
+
+    msx_vram_write((uint16_t)(VRAM_SPRPAT + PAT_PLAYER * 8), spr_player, 8);
+    msx_vram_write((uint16_t)(VRAM_SPRPAT + PAT_ENEMY  * 8), spr_enemy,  8);
+
+    rng = 0xACE1;
+    blip = 0;
+    prev_dir = 0;
+    reset_run();
+
+    for (;;) {
+        vsync();
+
+        /* push sprites */
+        slot = 0;
+        msx_set_sprite(slot++, player.x, player.y, PAT_PLAYER, COL_PLAYER);
+        for (i = 0; i < MAX_OBSTACLES; i++)
+            msx_set_sprite(slot++, obstacles[i].x,
+                           obstacles[i].alive ? obstacles[i].y : SPRITE_END_Y,
+                           PAT_ENEMY, COL_ENEMY);
+
+        dir = msx_read_joystick(1);
+        if (dir == STICK_CENTER) dir = msx_read_joystick(0);
+
+        if (game_over_timer > 0) {
+            game_over_timer--;
+            if (game_over_timer == 0) reset_run();
+            prev_dir = dir;
+            if (blip) { blip--; if (!blip) msx_psg_off(0); }
+            continue;
+        }
+
+        if ((dir == STICK_LEFT || dir == STICK_UL || dir == STICK_DL)
+            && !(prev_dir == STICK_LEFT || prev_dir == STICK_UL || prev_dir == STICK_DL)
+            && player_lane > 0) { player_lane--; msx_psg_tone(1, 0x280, 6); blip = 3; }
+        if ((dir == STICK_RIGHT || dir == STICK_UR || dir == STICK_DR)
+            && !(prev_dir == STICK_RIGHT || prev_dir == STICK_UR || prev_dir == STICK_DR)
+            && player_lane < 2) { player_lane++; msx_psg_tone(1, 0x280, 6); blip = 3; }
+        player.x = lane_x[player_lane];
+        prev_dir = dir;
+
+        step = (int16_t)(2 + (score / 200));
+        if (step > 4) step = 4;
+
+        for (i = 0; i < MAX_OBSTACLES; i++) {
+            if (!obstacles[i].alive) continue;
+            obstacles[i].y = (uint8_t)(obstacles[i].y + step);
+            if (obstacles[i].y >= 184) obstacles[i].alive = 0;
+        }
+
+        spawn_timer = (uint8_t)(spawn_timer + 1);
+        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;
+                msx_psg_tone(0, 0x600, 15); blip = 12;
+                break;
+            }
+        }
+
+        if (score < 999) { score++; draw_score(); }
+
+        if (blip) { blip--; if (!blip) { msx_psg_off(0); msx_psg_off(1); } }
+    }
+}