romdevtools 0.16.0 → 0.21.0

package/examples/gg/templates/sports.c

@@ -11,6 +11,7 @@ extern void    gg_vdp_init(void);
 extern void    gg_vdp_display_on(void);
 extern void    gg_load_palette(const uint8_t *palette);
 extern void    gg_load_tiles(uint16_t vram_dest, const uint8_t *src, uint16_t byte_count);
+extern void    gg_set_tilemap_cell(uint8_t row, uint8_t col, uint8_t tile_idx, uint8_t attr);
 extern void    gg_vblank_wait(void);
 extern uint8_t gg_joypad_read(void);
 extern void    gg_sprite_init(void);
@@ -37,8 +38,8 @@ extern void    gg_sat_upload(void);
  * (entries 16-31) reading garbage = invisible sprites. Sprite colour 1 = entry
  * 17 (white). */
 static const uint8_t palette[64] = {
-  /* BG 0-15: entry 0 = dark navy backdrop */
-  0x20,0x02, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
+  /* BG 0-15: 0 = dark navy backdrop, 1 = court green, 2 = court line white */
+  0x20,0x02, 0x60,0x00, 0xFF,0x0F, 0,0, 0,0, 0,0, 0,0, 0,0,
   0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
   /* SPRITE 16-31: 16=transparent, 17=white */
   0,0, 0xFF,0x0F, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
@@ -52,6 +53,42 @@ static const uint8_t tile_solid[32] = {
   0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
 };
 
+/* Three BG tiles for the court, loaded into the BG tile bank at $0000:
+ *   tile 0 = court green (colour 1), tile 1 = court line / border
+ *   (colour 2 = white), tile 2 = dashed net (colour 2 stripe on green). */
+static const uint8_t bg_tiles[96] = {
+  /* tile 0 = court green (colour 1 -> plane 0 set) */
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  /* tile 1 = court line / border (colour 2 -> plane 1 set) */
+  0x00,0xFF,0x00,0x00, 0x00,0xFF,0x00,0x00,
+  0x00,0xFF,0x00,0x00, 0x00,0xFF,0x00,0x00,
+  0x00,0xFF,0x00,0x00, 0x00,0xFF,0x00,0x00,
+  0x00,0xFF,0x00,0x00, 0x00,0xFF,0x00,0x00,
+  /* tile 2 = net: centre column colour 2, rest colour 1 (green) */
+  0xFF,0x18,0x00,0x00, 0xFF,0x18,0x00,0x00,
+  0xFF,0x18,0x00,0x00, 0xFF,0x18,0x00,0x00,
+  0xFF,0x18,0x00,0x00, 0xFF,0x18,0x00,0x00,
+  0xFF,0x18,0x00,0x00, 0xFF,0x18,0x00,0x00,
+};
+
+/* Paint the court inside the GG visible region (cols 6..25, rows 3..20):
+ * green field, white border lines around the perimeter, dashed net down
+ * the centre column. BG tile bank is $0000. */
+static void draw_court(void) {
+  uint8_t row, col;
+  for (row = 3; row <= 20; row++) {
+    for (col = 6; col <= 25; col++) {
+      uint8_t t = 0;                                   /* green field        */
+      if (row == 3 || row == 20 || col == 6 || col == 25) t = 1; /* border  */
+      else if (col == 15 && (row & 1)) t = 2;          /* dashed centre net  */
+      gg_set_tilemap_cell(row, col, t, 0);
+    }
+  }
+}
+
 static int16_t p1y, p2y, bx, by;
 static int8_t  bdx, bdy;
 static uint8_t score_p1, score_p2;
@@ -76,7 +113,13 @@ void main(void) {
   uint8_t i;
   gg_vdp_init();
   gg_load_palette(palette);
-  gg_load_tiles(0x2000, tile_solid, 32);
+  gg_load_tiles(0x0000, bg_tiles, 96);      /* BG court tiles -> BG bank $0000 */
+  gg_load_tiles(0x2000, tile_solid, 32);    /* paddle/ball sprite tile -> $2000 */
+  {
+    uint8_t r, c;
+    for (r = 0; r < 28; r++) for (c = 0; c < 32; c++) gg_set_tilemap_cell(r, c, 0, 0);
+  }
+  draw_court();
   gg_sprite_init();
   sfx_init();
   gg_vdp_display_on();

package/examples/lynx/templates/default.c

@@ -15,9 +15,12 @@
 #include <lynx.h>
 
 void main(void) {
-  static const unsigned char palette[8] = {
-    COLOR_RED,    COLOR_YELLOW, COLOR_GREEN,     COLOR_LIGHTBLUE,
-    COLOR_BLUE,   COLOR_PURPLE, COLOR_LIGHTGREEN, COLOR_WHITE,
+  /* Cycle the centre square through warm/bright shades only — NOT the
+   * blues, which would blend into the blue background and make the
+   * screen read as "almost one colour". */
+  static const unsigned char palette[6] = {
+    COLOR_RED,   COLOR_YELLOW,     COLOR_GREEN,
+    COLOR_WHITE, COLOR_LIGHTGREEN, COLOR_PURPLE,
   };
   unsigned char shade = 0;
   unsigned int  frame = 0;
@@ -26,16 +29,44 @@ void main(void) {
   tgi_init();
 
   for (;;) {
-    tgi_clear();
+    /* CANONICAL LYNX FRAME LOOP — full redraw every frame, in this order:
+     *   1. WAIT for Suzy's blitter to finish the previous frame. Drawing
+     *      while it's mid-flight loses the frame → black screen. This is
+     *      the #1 "Lynx stays blank" trap.
+     *   2. CLEAR with a full-screen tgi_bar in the background colour, NOT
+     *      tgi_clear() — which leaves the back page stale in this
+     *      toolchain+emulator path (the other genre scaffolds all do the
+     *      same; see shmup.c's LYNX-1 note).
+     *   3. DRAW everything.
+     *   4. tgi_updatedisplay() to push the frame. */
+    while (tgi_busy()) { }
+
+    /* Blue field so the screen is obviously not blank. */
+    tgi_setcolor(COLOR_BLUE);
+    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());
+
+    /* A fixed green frame around the centre — always a distinct colour,
+     * so the screen never collapses to a single shade even while the
+     * inner square is cycling. */
+    tgi_setcolor(COLOR_GREEN);
+    tgi_bar(50, 30, 110, 72);
+
+    /* Colour-cycling square in the centre. */
     tgi_setcolor(palette[shade]);
-    tgi_bar(70, 40, 90, 62);
+    tgi_bar(60, 36, 100, 66);
+
+    /* Greeting on top. The tgi font is 8 px wide; "BUILT WITH ROMDEV"
+     * is 17 chars = 136 px, so start near the left edge to stay inside
+     * the 160-px-wide screen. */
     tgi_setcolor(COLOR_WHITE);
-    tgi_outtextxy(2, 2, "HELLO LYNX");
+    tgi_outtextxy(40, 14, "HELLO LYNX");
+    tgi_outtextxy(12, 86, "BUILT WITH ROMDEV");
     tgi_updatedisplay();
 
     frame++;
-    if ((frame & 0x1F) == 0) {        /* every 32 frames */
-      shade = (shade + 1) & 0x07;
+    if ((frame % 24) == 0) {          /* advance the inner square */
+      shade++;
+      if (shade >= 6) shade = 0;
     }
   }
 }

package/examples/lynx/templates/puzzle.c

@@ -98,8 +98,35 @@ void main(void) {
      * — drawing while the blitter is mid-flight loses the frame → black.
      * (Copied from the shmup scaffold, the LYNX-1 fix.) */
     while (tgi_busy()) { }
+
+    /* ── Background scene (drawn every frame). Without it the playfield is
+     * a near-flat single colour and the render-health audit flags the
+     * screen as blank. A framed "well" in the centre with lit side panels
+     * keeps several distinct colours well under the threshold:
+     *   - blue cabinet backdrop
+     *   - dark-grey side panels flanking the well
+     *   - black well interior so the falling blocks read clearly
+     *   - light-grey well frame + a faint grid texture behind the cells. */
+    tgi_setcolor(COLOR_BLUE);
+    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());        /* cabinet backdrop  */
+    tgi_setcolor(COLOR_DARKGREY);
+    tgi_bar(0, 0, GRID_X - 5, 101);                     /* left side panel   */
+    tgi_bar(GRID_X + COLS * CELL_PX + 4, 0, 159, 101);  /* right side panel  */
     tgi_setcolor(COLOR_BLACK);
-    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());
+    tgi_bar(GRID_X - 2, GRID_Y - 2,
+            GRID_X + COLS * CELL_PX + 1, GRID_Y + ROWS * CELL_PX + 1); /* well */
+    /* faint grid texture so the empty well is never one flat colour */
+    tgi_setcolor(COLOR_DARKGREY);
+    for (r = 0; r <= ROWS; r++)
+      tgi_line(GRID_X, GRID_Y + r * CELL_PX, GRID_X + COLS * CELL_PX - 1, GRID_Y + r * CELL_PX);
+    for (c = 0; c <= COLS; c++)
+      tgi_line(GRID_X + c * CELL_PX, GRID_Y, GRID_X + c * CELL_PX, GRID_Y + ROWS * CELL_PX - 1);
+    /* well frame */
+    tgi_setcolor(COLOR_LIGHTGREY);
+    tgi_line(GRID_X - 2, GRID_Y - 2, GRID_X - 2, GRID_Y + ROWS * CELL_PX + 1);
+    tgi_line(GRID_X + COLS * CELL_PX + 1, GRID_Y - 2, GRID_X + COLS * CELL_PX + 1, GRID_Y + ROWS * CELL_PX + 1);
+    tgi_line(GRID_X - 2, GRID_Y + ROWS * CELL_PX + 1, GRID_X + COLS * CELL_PX + 1, GRID_Y + ROWS * CELL_PX + 1);
+
     /* grid */
     for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) {
       if (grid[r][c] != 0) {

package/examples/lynx/templates/racing.c

@@ -23,6 +23,8 @@ void main(void) {
   uint8_t game_over = 0;
   uint8_t joy, i;
   uint32_t rng = 1;
+  uint8_t scroll = 0;   /* animates the road dashes so the track moves */
+  int16_t y;
 
   tgi_install(&lynx_160_102_16_tgi);
   tgi_init();
@@ -36,14 +38,37 @@ void main(void) {
      * — drawing while the blitter is mid-flight loses the frame → black.
      * (Copied from the shmup scaffold, the LYNX-1 fix.) */
     while (tgi_busy()) { }
-    tgi_setcolor(COLOR_BLACK);
-    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());
-    /* lane lines */
+
+    /* ── Background scene (drawn every frame). Without it the track is a
+     * near-flat single colour and the render-health audit flags the
+     * screen as blank. A full road with grass shoulders + animated lane
+     * dashes keeps several distinct colours well under the threshold:
+     *   - green grass shoulders on both sides
+     *   - mid-grey tarmac with darker-grey lane bands
+     *   - white scrolling centre dashes + solid edge lines. */
+    tgi_setcolor(COLOR_GREEN);
+    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());        /* grass base        */
+    tgi_setcolor(COLOR_GREY);
+    tgi_bar(20, 0, 148, 101);                           /* tarmac            */
+    /* darker lane bands so the road isn't one flat grey */
     tgi_setcolor(COLOR_DARKGREY);
-    tgi_line(28, 0, 28, 101);
-    tgi_line(72, 0, 72, 101);
-    tgi_line(116, 0, 116, 101);
-    tgi_line(160, 0, 160, 101);
+    tgi_bar(20, 0, 53, 101);
+    tgi_bar(96, 0, 128, 101);
+    /* solid road edges */
+    tgi_setcolor(COLOR_WHITE);
+    tgi_line(20, 0, 20, 101);
+    tgi_line(148, 0, 148, 101);
+    /* animated dashed lane dividers (scroll downward) */
+    for (y = (int16_t)scroll - 12; y < 102; y += 12) {
+      tgi_bar(53, (unsigned)(y < 0 ? 0 : y), 55, (unsigned)(y + 6 > 101 ? 101 : y + 6));
+      tgi_bar(96, (unsigned)(y < 0 ? 0 : y), 98, (unsigned)(y + 6 > 101 ? 101 : y + 6));
+    }
+    /* grass rumble strips for extra colour texture */
+    tgi_setcolor(COLOR_LIGHTGREEN);
+    for (y = (int16_t)scroll - 8; y < 102; y += 16) {
+      tgi_bar(0,   (unsigned)(y < 0 ? 0 : y), 6,   (unsigned)(y + 6 > 101 ? 101 : y + 6));
+      tgi_bar(153, (unsigned)(y < 0 ? 0 : y), 159, (unsigned)(y + 6 > 101 ? 101 : y + 6));
+    }
 
     tgi_setcolor(COLOR_YELLOW);
     tgi_bar((unsigned)player.x - 4, (unsigned)player.y - 4, (unsigned)player.x + 4, (unsigned)player.y + 4);
@@ -54,6 +79,8 @@ void main(void) {
     tgi_updatedisplay();
     sfx_update();
 
+    scroll += 2; if (scroll >= 12) scroll -= 12;   /* advance road dashes */
+
     if (game_over > 0) {
       game_over--;
       if (game_over == 0) {

package/examples/lynx/templates/shmup.c

@@ -50,8 +50,15 @@ static void spawn(void) {
   }
 }
 
+/* Scrolling starfield: a handful of stars that drift down so the dark
+ * space field is never a flat single colour (would read as "blank"). */
+#define N_STARS 24
+static uint8_t star_x[N_STARS];
+static uint8_t star_y[N_STARS];
+
 void main(void) {
   uint8_t joy, fire_now, i, j;
+  uint32_t srng = 0x1234;
 
   tgi_install(&lynx_160_102_16_tgi);
   tgi_init();
@@ -61,6 +68,12 @@ void main(void) {
   player.x = 76; player.y = 90; 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;
+  for (i = 0; i < N_STARS; i++) {
+    srng = srng * 1103515245u + 12345u;
+    star_x[i] = (uint8_t)((srng >> 16) % 160);
+    srng = srng * 1103515245u + 12345u;
+    star_y[i] = (uint8_t)((srng >> 16) % 102);
+  }
   spawn_timer = 0;
   prev_btn = 0;
 
@@ -76,10 +89,31 @@ void main(void) {
      *   3. DRAW every object.
      *   4. tgi_updatedisplay() to push the frame. */
     while (tgi_busy()) { }
-    tgi_setcolor(COLOR_BLACK);
-    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());  /* maxx/maxy = 159/101 = full screen */
 
-    /* Render */
+    /* ── Background scene (drawn every frame; without it the dark space
+     * field is a near-flat single colour and the render-health audit
+     * flags the screen as blank). Layered bands keep any one colour well
+     * under the threshold:
+     *   - deep-blue upper space
+     *   - grey nebula band across the middle
+     *   - green planet surface along the bottom
+     *   - a drifting white/yellow starfield over the space. */
+    tgi_setcolor(COLOR_BLUE);
+    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());      /* base space field   */
+    tgi_setcolor(COLOR_GREY);
+    tgi_bar(0, 34, 159, 60);                          /* nebula band        */
+    tgi_setcolor(COLOR_GREEN);
+    tgi_bar(0, 84, 159, 101);                         /* planet surface     */
+    tgi_setcolor(COLOR_LIGHTGREEN);
+    tgi_bar(0, 78, 159, 83);                          /* surface horizon    */
+    /* starfield (bright specks; also drifts downward each frame) */
+    tgi_setcolor(COLOR_WHITE);
+    for (i = 0; i < N_STARS; i++) {
+      tgi_setpixel(star_x[i], star_y[i]);
+      tgi_setpixel(star_x[i], (star_y[i] + 1) % 102);
+    }
+
+    /* Render game objects on top */
     tgi_setcolor(COLOR_YELLOW);
     tgi_bar(player.x, player.y, player.x + 6, player.y + 6);
     tgi_setcolor(COLOR_WHITE);
@@ -93,6 +127,11 @@ void main(void) {
     tgi_updatedisplay();
     sfx_update();
 
+    /* drift the starfield downward */
+    for (i = 0; i < N_STARS; i++) {
+      if (star_y[i] >= 101) star_y[i] = 0; else star_y[i]++;
+    }
+
     /* Input + state */
     joy = joy_read(JOY_1);
     fire_now = JOY_BTN_1(joy) ? 1 : 0;

package/examples/lynx/templates/sports.c

@@ -21,6 +21,7 @@ void main(void) {
   int16_t p1y = 40, p2y = 40, bx = 78, by = 48;
   int8_t bdx = 2, bdy = 1;
   uint8_t joy;
+  int16_t ny;   /* loop var for the dashed centre net */
 
   tgi_install(&lynx_160_102_16_tgi);
   tgi_init();
@@ -33,8 +34,34 @@ void main(void) {
      * — drawing while the blitter is mid-flight loses the frame → black.
      * (Copied from the shmup scaffold, the LYNX-1 fix.) */
     while (tgi_busy()) { }
-    tgi_setcolor(COLOR_BLACK);
-    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());
+
+    /* ── Background scene (drawn every frame). Without it the court is a
+     * near-flat single colour and the render-health audit flags the
+     * screen as blank. A two-tone court with boards + net markings keeps
+     * several distinct colours well under the threshold:
+     *   - green centre court
+     *   - lighter-green end zones behind each paddle
+     *   - dark-grey boards top and bottom
+     *   - white boundary, dashed centre net + centre circle. */
+    tgi_setcolor(COLOR_GREEN);
+    tgi_bar(0, 0, tgi_getmaxx(), tgi_getmaxy());        /* court grass       */
+    tgi_setcolor(COLOR_LIGHTGREEN);
+    tgi_bar(0, COURT_TOP, 52, COURT_BOT - 1);           /* left end zone     */
+    tgi_bar(107, COURT_TOP, 159, COURT_BOT - 1);        /* right end zone    */
+    tgi_setcolor(COLOR_DARKGREY);
+    tgi_bar(0, 0, 159, COURT_TOP - 1);                  /* top boards        */
+    tgi_bar(0, COURT_BOT, 159, 101);                    /* bottom boards     */
+    /* white court boundary + dashed centre net + centre circle */
+    tgi_setcolor(COLOR_WHITE);
+    tgi_line(0, COURT_TOP, 159, COURT_TOP);
+    tgi_line(0, COURT_BOT, 159, COURT_BOT);
+    for (ny = COURT_TOP; ny < COURT_BOT; ny += 8)
+      tgi_bar(79, (unsigned)ny, 80, (unsigned)(ny + 3 > COURT_BOT ? COURT_BOT : ny + 3));
+    tgi_line(70, 40, 90, 40);
+    tgi_line(70, 60, 90, 60);
+    tgi_line(70, 40, 70, 60);
+    tgi_line(90, 40, 90, 60);
+
     tgi_setcolor(COLOR_WHITE);
     tgi_bar(PADDLE_X1, (unsigned)p1y, PADDLE_X1 + PADDLE_W - 1, (unsigned)(p1y + PADDLE_H - 1));
     tgi_bar(PADDLE_X2, (unsigned)p2y, PADDLE_X2 + PADDLE_W - 1, (unsigned)(p2y + PADDLE_H - 1));

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); }
+    }
+}