romdevtools 0.13.0 → 0.15.0

package/examples/gg/templates/platformer.c

@@ -40,13 +40,27 @@ extern void gg_sat_upload(void);
 #define SCREEN_W   160                /* GG visible window is 160 px wide */
 #define VIS_ROWS   24
 
-static const uint8_t palette[32] = {
-  /* BG: backdrop blue, wall mid-grey */
-  0x10,0x14,0x00,0x00, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-  /* Sprite: player red */
-  0x00,0x03,0x00,0x00, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+/* ── Game Gear visible viewport ──────────────────────────────────────
+ * Only the centered 160x144 of the 256x192 frame shows. The BG is
+ * scrolled so world column camX/8 appears at fetch pixel VIS_X0, and the
+ * player sprite is drawn at (worldX - camX) + VIS_X0 so it stays aligned
+ * with the BG inside the visible window. */
+#define VIS_X0     48
+#define VIS_Y0     24
+#define VIS_X1     207   /* 48 + 160 - 1 */
+#define VIS_Y1     167   /* 24 + 144 - 1 */
+
+/* GG palette = 32 entries × 2 bytes (4-4-4 BGR LE): low=(g<<4)|r, high=b.
+ * gg_load_palette reads 64 bytes; a 32-byte array leaves the sprite palette
+ * (entries 16-31) reading garbage = invisible sprites. BG colour 1 = entry 1
+ * (mid-grey wall); sprite colour 1 = entry 17 (white player). */
+static const uint8_t palette[64] = {
+  /* BG 0-15: entry 0 = dark navy backdrop, entry 1 = mid-grey wall */
+  0x20,0x02, 0xAA,0x0A, 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, 0,0,
+  /* SPRITE 16-31: 16=transparent, 17=white player */
+  0,0, 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, 0,0,
 };
 
 static const uint8_t bg_tiles[32 * 2] = {
@@ -123,7 +137,10 @@ static void paint_initial(void) {
 }
 
 void main(void) {
-  int16_t px = 16 << 4, py = 64 << 4;
+  /* Start above the x=32..88 platform (world y=144) so the player lands on
+   * it inside the GG visible vertical band [VIS_Y0..VIS_Y1], not on the
+   * floor at world y=176 which sits just below the visible window. */
+  int16_t px = 48 << 4, py = 96 << 4;
   int16_t vx = 0, vy = 0;
   int16_t camX = 0, lastCamCol = 0;
   uint8_t prev = 0;
@@ -170,13 +187,18 @@ void main(void) {
     while (camCol > lastCamCol) { lastCamCol++; paint_column(lastCamCol + 31); }
     while (camCol < lastCamCol) { lastCamCol--; paint_column(lastCamCol); }
 
-    gg_vdp_write_reg(8, (uint8_t)(-camX & 0xFF));
-
-    /* Player drawn in SCREEN space. The GG visible window starts 48 px
-     * into the 256-px fetch, but the SAT X is in full-frame coords and
-     * R8 shifts both alike, so worldX - camX lands the sprite correctly
-     * relative to the scrolled BG. */
-    sx = ipx - camX;
+    /* Scroll so world column (camX/8) lands at fetch pixel VIS_X0 — the
+     * left edge of the GG visible window. (SMS shows the whole 256-px
+     * fetch and uses R8 = -camX; the GG only shows the centered 160-px
+     * crop, so we bias by +VIS_X0.) */
+    gg_vdp_write_reg(8, (uint8_t)((VIS_X0 - camX) & 0xFF));
+
+    /* Player X is biased into the visible window so it stays pinned to the
+     * horizontally-scrolled BG: sx = (worldX - camX) + VIS_X0. The BG is
+     * NOT vertically scrolled (R9 = 0), so world rows map 1:1 to fetch rows
+     * and the player Y needs no bias — world Y already lands in the visible
+     * band [VIS_Y0..VIS_Y1] for the level layout below. */
+    sx = (ipx - camX) + VIS_X0;
     gg_sprite_set(0, (uint8_t)sx, (uint8_t)ipy, 0);
     gg_sat_upload();
 

package/examples/gg/templates/racing.c

@@ -24,18 +24,31 @@ extern void    gg_sprite_init(void);
 extern void    gg_sprite_set(uint8_t slot, uint8_t x, uint8_t y, uint8_t tile);
 extern void    gg_sat_upload(void);
 
-#define LANE_LEFT_X    72
-#define LANE_MID_X    124
-#define LANE_RIGHT_X  176
-#define PLAYER_Y      160
+/* ── Game Gear visible viewport ──────────────────────────────────────
+ * Only the centered 160x144 of the 256x192 frame shows. Lanes and the
+ * player must sit inside [VIS_X0..VIS_X1] x [VIS_Y0..VIS_Y1]. */
+#define VIS_X0         48
+#define VIS_Y0         24
+#define VIS_X1         207   /* 48 + 160 - 1 */
+#define VIS_Y1         167   /* 24 + 144 - 1 */
+
+#define LANE_LEFT_X    (VIS_X0 + 28)    /* 76  */
+#define LANE_MID_X     ((VIS_X0 + VIS_X1) / 2 - 4)  /* ~123 */
+#define LANE_RIGHT_X   (VIS_X1 - 36)    /* 171 */
+#define PLAYER_Y       (VIS_Y1 - 16)
 #define MAX_OBSTACLES   4
 
-static const uint8_t palette[32] = {
-  0x10, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  /* Sprite palette: white (1), red (2) */
-  0x00, 0x3F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+/* GG palette = 32 entries × 2 bytes (4-4-4 BGR LE): low=(g<<4)|r, high=b.
+ * gg_load_palette reads 64 bytes; a 32-byte array leaves the sprite palette
+ * (entries 16-31) reading garbage = invisible sprites. Sprite colour 1 = entry
+ * 17 (white), colour 2 = entry 18 (red). */
+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,
+  0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
+  /* SPRITE 16-31: 16=transparent, 17=white, 18=red */
+  0,0, 0xFF,0x0F, 0x0F,0x00, 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,
 };
 
 /* Two sprite tiles — player (colour 1) + enemy (colour 2). */
@@ -86,7 +99,7 @@ static void spawn_obstacle(void) {
   for (i = 0; i < MAX_OBSTACLES; i++) {
     if (!obstacles[i].alive) {
       obstacles[i].x = lane_x[(spawn_timer * 13) % 3];
-      obstacles[i].y = 0;
+      obstacles[i].y = VIS_Y0;   /* enter at the top of the visible window */
       obstacles[i].alive = 1;
       return;
     }
@@ -142,7 +155,7 @@ void main(void) {
     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;
+      if (obstacles[i].y >= VIS_Y1) obstacles[i].alive = 0;  /* off visible bottom */
     }
 
     spawn_timer = (uint8_t)(spawn_timer + 1);

package/examples/gg/templates/shmup.c

@@ -46,12 +46,18 @@ extern void gg_sat_upload(void);
 #define T_BULLET 1
 #define T_ENEMY  2
 
-static const uint8_t palette[32] = {
-  0x10,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-  /* Sprite palette: white, yellow, red */
-  0x00,0x3F,0x0F,0x03, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+/* GG palette = 32 entries × 2 bytes (4-4-4 BGR LE): low=(g<<4)|r, high=b.
+ * Entries 0-15 = BG, 16-31 = SPRITE. (The earlier 32-byte SMS-style array was
+ * the GG #1 invisible-sprite bug: gg_load_palette reads 64 bytes, so a 32-byte
+ * array left the sprite palette (entries 16-31) reading past the array = garbage
+ * = invisible sprites.) */
+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,
+  0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
+  /* SPRITE 16-31: 16=transparent, 17=white, 18=yellow, 19=red */
+  0,0, 0xFF,0x0F, 0xFF,0x00, 0x0F,0x00, 0,0, 0,0, 0,0, 0,0,
+  0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
 };
 
 static const uint8_t sprite_tiles[32 * 3] = {

package/examples/gg/templates/sports.c

@@ -17,19 +17,32 @@ extern void    gg_sprite_init(void);
 extern void    gg_sprite_set(uint8_t slot, uint8_t x, uint8_t y, uint8_t tile);
 extern void    gg_sat_upload(void);
 
-#define COURT_TOP   8
-#define COURT_BOT   184
+/* ── Game Gear visible viewport ──────────────────────────────────────
+ * Only the centered 160x144 of the 256x192 frame shows. Keep the whole
+ * court inside [VIS_X0..VIS_X1] x [VIS_Y0..VIS_Y1] or it's off-screen. */
+#define VIS_X0      48
+#define VIS_Y0      24
+#define VIS_X1      207   /* 48 + 160 - 1 */
+#define VIS_Y1      167   /* 24 + 144 - 1 */
+
+#define COURT_TOP   VIS_Y0
+#define COURT_BOT   VIS_Y1
 #define PADDLE_H    24
 #define BALL_SIZE   8
-#define PADDLE_X1   16
-#define PADDLE_X2   232
-
-static const uint8_t palette[32] = {
-  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  /* Sprite palette: white at idx 1 */
-  0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+#define PADDLE_X1   (VIS_X0 + 8)    /* near the visible left edge   */
+#define PADDLE_X2   (VIS_X1 - 16)   /* near the visible right edge  */
+
+/* GG palette = 32 entries × 2 bytes (4-4-4 BGR LE): low=(g<<4)|r, high=b.
+ * gg_load_palette reads 64 bytes; a 32-byte array leaves the sprite palette
+ * (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,
+  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,
+  0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,
 };
 
 static const uint8_t tile_solid[32] = {
@@ -45,15 +58,16 @@ static uint8_t score_p1, score_p2;
 static uint8_t serve_timer;
 
 static void serve_ball(uint8_t to_left) {
-  bx = 124;
-  by = 90;
+  bx = (VIS_X0 + VIS_X1) / 2;
+  by = (VIS_Y0 + VIS_Y1) / 2;
   bdx = to_left ? -2 : 2;
   bdy = ((score_p1 + score_p2) & 1) ? -1 : 1;
   serve_timer = 30;
 }
 
 static void reset_match(void) {
-  p1y = 84; p2y = 84;
+  p1y = (VIS_Y0 + VIS_Y1) / 2 - PADDLE_H / 2;
+  p2y = p1y;
   score_p1 = 0; score_p2 = 0;
   serve_ball(0);
 }
@@ -130,8 +144,8 @@ void main(void) {
         sfx_tone(0, 250, 3);
       }
 
-      if (bx < 4)   { if (score_p2 < 9) score_p2++; sfx_noise(20); serve_ball(0); }
-      if (bx > 252) { if (score_p1 < 9) score_p1++; sfx_tone(0, 180, 16); serve_ball(1); }
+      if (bx < VIS_X0)        { if (score_p2 < 9) score_p2++; sfx_noise(20); serve_ball(0); }
+      if (bx > VIS_X1 - BALL_SIZE) { if (score_p1 < 9) score_p1++; sfx_tone(0, 180, 16); serve_ball(1); }
     }
   } while (1);
 }

package/examples/gg/templates/tile_engine.c

@@ -30,15 +30,28 @@ extern void gg_sat_upload(void);
 
 #define T_OPEN  0
 #define T_WALL  1
-#define T_SPR   0   /* sprite tile uses sprite-tile-bank (R6=0xFB) */
-
-static const uint8_t palette[32] = {
-  /* BG palette: backdrop blue, wall colour 1 dark grey, colour 2 light grey */
-  0x10,0x14,0x2A,0x00, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
-  /* Sprite palette: white at idx 1 */
-  0x00,0x3F,0x00,0x00, 0x00,0x00,0x00,0x00,
-  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+#define T_SPR   0   /* sprite tile uses sprite-tile-bank (R6=0xFF → $2000) */
+
+/* ── Game Gear visible viewport ──────────────────────────────────────
+ * The 32x24 name table fills the whole 256x192 frame, but only the
+ * centered 160x144 SHOWS: fetch pixels [VIS_X0..VIS_X1] x [VIS_Y0..VIS_Y1]
+ * (tile columns 6..25, rows 3..20). Place the player sprite inside it. */
+#define VIS_X0  48
+#define VIS_Y0  24
+#define VIS_X1  207   /* 48 + 160 - 1 */
+#define VIS_Y1  167   /* 24 + 144 - 1 */
+
+/* GG palette = 32 entries × 2 bytes (4-4-4 BGR LE): low=(g<<4)|r, high=b.
+ * gg_load_palette reads 64 bytes; a 32-byte array leaves the sprite palette
+ * (entries 16-31) reading garbage = invisible sprites. BG colour 1 = entry 1
+ * (dark grey wall); sprite colour 1 = entry 17 (white player). */
+static const uint8_t palette[64] = {
+  /* BG 0-15: entry 0 = dark navy backdrop, entry 1 = dark grey wall */
+  0x20,0x02, 0x66,0x06, 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, 0,0,
+  /* SPRITE 16-31: 16=transparent, 17=white player */
+  0,0, 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, 0,0,
 };
 
 static const uint8_t bg_tiles[32 * 2] = {
@@ -92,7 +105,8 @@ static uint8_t solid_at(int16_t px, int16_t py) {
 }
 
 void main(void) {
-  int16_t px = 16, py = 16;
+  /* Start the player inside the visible window (tile ~10,10 = pixel 80,80). */
+  int16_t px = 80, py = 80;
 
   gg_vdp_init();
   gg_load_palette(palette);

package/examples/lynx/templates/platformer.c

@@ -43,7 +43,13 @@ void main(void) {
   sfx_init();
 
   for (;;) {
-    tgi_clear();
+    /* Lynx frame loop: WAIT for the blitter, then clear with a full-screen
+     * tgi_bar (NOT tgi_clear, which leaves the back page stale on this core)
+     * — 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());
     tgi_setcolor(COLOR_GREY);
     for (i = 0; i < N_PLATFORMS; i++) {
       tgi_bar(platforms[i].x, platforms[i].y, platforms[i].x + platforms[i].w - 1, platforms[i].y + platforms[i].h - 1);

package/examples/lynx/templates/puzzle.c

@@ -62,7 +62,7 @@ static void lock_piece(void) {
       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 < 65500) score += 30;
+        if (score < 65500u) score += 30;
         sfx_tone(0, 60, 10);
       }
     }
@@ -93,7 +93,13 @@ void main(void) {
   new_piece();
 
   for (;;) {
-    tgi_clear();
+    /* Lynx frame loop: WAIT for the blitter, then clear with a full-screen
+     * tgi_bar (NOT tgi_clear, which leaves the back page stale on this core)
+     * — 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());
     /* grid */
     for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) {
       if (grid[r][c] != 0) {

package/examples/lynx/templates/racing.c

@@ -31,7 +31,13 @@ void main(void) {
   for (i = 0; i < MAX_OBS; i++) obs[i].alive = 0;
 
   for (;;) {
-    tgi_clear();
+    /* Lynx frame loop: WAIT for the blitter, then clear with a full-screen
+     * tgi_bar (NOT tgi_clear, which leaves the back page stale on this core)
+     * — 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 */
     tgi_setcolor(COLOR_DARKGREY);
     tgi_line(28, 0, 28, 101);

package/examples/lynx/templates/sports.c

@@ -28,7 +28,13 @@ void main(void) {
   sfx_init();
 
   for (;;) {
-    tgi_clear();
+    /* Lynx frame loop: WAIT for the blitter, then clear with a full-screen
+     * tgi_bar (NOT tgi_clear, which leaves the back page stale on this core)
+     * — 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());
     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/nes/main.c

@@ -9,9 +9,9 @@
  *   5. Enables the PPU and loops forever (NMI does all the real work).
  *
  * BUILD: this file expects linkerConfig: "chr-ram" so the CHR-RAM
- * region is writable at runtime. Pass it to buildSource:
+ * region is writable at runtime. Pass it to build:
  *
- *   buildSource({
+ *   build({ output: "rom", 
  *     platform: "nes",
  *     language: "c",
  *     linkerConfig: "chr-ram",

package/examples/nes/space-shooter/nes_runtime.h

@@ -1,5 +1,5 @@
 /* ── nes_runtime.h — neslib-shaped runtime for cc65 NES builds ───
- * Auto-included on every `buildSource({platform:"nes", language:"c"})`.
+ * Auto-included on every `build({ output: "rom", platform:"nes", language:"c"})`.
  *
  * API mirrors Shiru's neslib so existing tutorials port cleanly:
  *

package/examples/nes/templates/default.c

@@ -13,7 +13,10 @@
 
 #include "nes_runtime.h"
 
-static const uint8_t bg_colors[4] = { 0x0F, 0x01, 0x21, 0x31 };
+/* 4 VISIBLE hues — never 0x0F (black), so a screenshot on ANY phase of the
+ * cycle shows a non-black backdrop (NES-2: the old cycle started on + passed
+ * through black, so a fresh agent's screenshot could land on a "blank" frame). */
+static const uint8_t bg_colors[4] = { 0x21, 0x01, 0x11, 0x31 };
 
 void main(void) {
   uint8_t palette[32];

package/examples/nes/templates/racing.c

@@ -56,6 +56,26 @@ static const uint8_t tile_digits[10 * 16] = {
 #define T_CAR_ENEMY 2
 #define T_DIGIT0    3
 
+/* ── Background road tiles ───────────────────────────────────────────
+ * Default PPUCTRL ($90) reads BG patterns from pattern table 1 ($1000),
+ * so these go to CHR $1000+ and are indexed independently of the sprite
+ * tiles above. Colour 1 (white, BG palette 0) draws the markings; the
+ * grey backdrop (colour 0) is the road surface.
+ *
+ * BG_T_EDGE: a solid 2px vertical stripe — the road shoulder line.
+ * BG_T_LANE: a 2px vertical dash (on for 4 rows, off for 4) — the
+ *            dashed centre lane marking when stacked down a column. */
+#define BG_T_EDGE   1
+#define BG_T_LANE   2
+static const uint8_t bg_tile_edge[16] = {
+  0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,   /* plane 0 (colour bit 0) */
+  0,    0,    0,    0,    0,    0,    0,    0,
+};
+static const uint8_t bg_tile_lane[16] = {
+  0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,   /* dash: 4 on, 4 off */
+  0,    0,    0,    0,    0,    0,    0,    0,
+};
+
 static const uint8_t palette[32] = {
   /* BG palettes — light grey backdrop simulates road */
   0x10, 0x30, 0x16, 0x12,
@@ -93,6 +113,29 @@ static uint8_t aabb(Car *a, Car *b) {
       && a->y < b->y + 8 && a->y + 8 > b->y;
 }
 
+/* Draw the static road into nametable 0 ($2000): solid shoulder lines on
+ * the outside of the outer lanes and dashed dividers between the three
+ * lanes. PPU must be OFF — call from init (uses vram_unsafe_set). Tile
+ * columns: lanes sit at 11/15/19, so dividers go at 13/17 and shoulders
+ * just outside at 9/21. */
+#define ROAD_TOP_ROW   2
+#define ROAD_BOT_ROW   27
+#define ROAD_EDGE_L    9
+#define ROAD_EDGE_R    21
+#define ROAD_DIV_1     13
+#define ROAD_DIV_2     17
+static void draw_road(void) {
+  uint8_t row;
+  uint16_t base;
+  for (row = ROAD_TOP_ROW; row <= ROAD_BOT_ROW; row++) {
+    base = (uint16_t)(0x2000 + (uint16_t)row * 32);
+    vram_unsafe_set((uint16_t)(base + ROAD_EDGE_L), BG_T_EDGE);
+    vram_unsafe_set((uint16_t)(base + ROAD_EDGE_R), BG_T_EDGE);
+    vram_unsafe_set((uint16_t)(base + ROAD_DIV_1),  BG_T_LANE);
+    vram_unsafe_set((uint16_t)(base + ROAD_DIV_2),  BG_T_LANE);
+  }
+}
+
 static void reset_run(void) {
   uint8_t i;
   player_lane = 1;
@@ -138,7 +181,13 @@ void main(void) {
   chr_ram_upload(T_CAR_ENEMY * 16, tile_car_enemy, 16);
   chr_ram_upload(T_DIGIT0    * 16, tile_digits,    sizeof(tile_digits));
 
+  /* BG road tiles live in pattern table 1 ($1000) — that's where the
+   * default PPUCTRL ($90) tells the PPU to read background patterns. */
+  chr_ram_upload((uint16_t)(0x1000 + BG_T_EDGE * 16), bg_tile_edge, 16);
+  chr_ram_upload((uint16_t)(0x1000 + BG_T_LANE * 16), bg_tile_lane, 16);
+
   palette_load(palette);
+  draw_road();          /* paint the static road while the PPU is off */
   oam_clear();
   ppu_on_all();
   sound_init();
@@ -198,6 +247,6 @@ void main(void) {
       }
     }
 
-    if (score < 65500) score++;
+    if (score < 65500u) score++;
   }
 }

package/examples/pce/main.c

@@ -3,7 +3,7 @@
  *
  * Boots to a guaranteed-VISIBLE screen using cc65's conio (text) library, which
  * initializes the HuC6270 VDC + HuC6260 VCE for you and uploads a font to VRAM.
- * Build with: buildSource({ platform: "pce" })  (language defaults to C).
+ * Build with: build({ output: "rom",  platform: "pce" })  (language defaults to C).
  *
  * FOOTGUN — the empty-BSS crt0 trap (cc65 pce/crt0.s line 84):
  *   The PCE crt0 clears .bss with `tii __BSS_RUN__, __BSS_RUN__+1, __BSS_SIZE__-1`.

package/examples/sms/templates/hello_sprite.c

@@ -11,7 +11,7 @@
  *   - 64 sprite slots × 4 bytes (Y / X / tile / unused)
  *
  * Multi-file project — main.c plus the runtime .c files. Build with:
- *   buildSource({platform:"sms", language:"c",
+ *   build({ output: "rom", platform:"sms", language:"c",
  *                sources: { "main.c": ..., "vdp_init.c": ..., ... },
  *                includes: { "sms_hw.h": ... }})
  *

package/examples/sms/templates/music_demo.c

@@ -12,7 +12,7 @@
  * them by name-table index).
  *
  * Build via createProject({platform:"sms", template:"music_demo"}) or
- * buildSource({platform:"sms", language:"c", sources:{ "main.c": ...,
+ * build({ output: "rom", platform:"sms", language:"c", sources:{ "main.c": ...,
  * "sms_music.c": ... , ...runtime... }}).
  */
 

package/examples/sms/templates/puzzle.c

@@ -126,7 +126,7 @@ static void lock_piece(void) {
       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 < 65500) score = (uint16_t)(score + 30);
+        if (score < 65500u) score = (uint16_t)(score + 30);
         sfx_tone(0, 200, 10);  /* triple-clear chime */
       }
     }

package/examples/sms/templates/racing.c

@@ -156,6 +156,6 @@ void main(void) {
       }
     }
 
-    if (score < 65500) score = (uint16_t)(score + 1);
+    if (score < 65500u) score = (uint16_t)(score + 1);
   } while (1);
 }

package/examples/sms/templates/shmup.c

@@ -157,7 +157,7 @@ void main(void) {
         if (aabb(&bullets[i], &enemies[j])) {
           bullets[i].alive = 0;
           enemies[j].alive = 0;
-          if (score < 65500) score = (uint16_t)(score + 10);
+          if (score < 65500u) score = (uint16_t)(score + 10);
           sfx_noise(8);
           break;
         }

package/examples/sms/templates/shmup_2p.c

@@ -199,7 +199,7 @@ void main(void) {
         if (p1_bullets[i].alive && aabb(&p1_bullets[i], &enemies[j])) {
           p1_bullets[i].alive = 0;
           enemies[j].alive = 0;
-          if (score_p1 < 65500) score_p1 = (uint16_t)(score_p1 + 10);
+          if (score_p1 < 65500u) score_p1 = (uint16_t)(score_p1 + 10);
           sfx_noise(8);
           break;
         }
@@ -209,7 +209,7 @@ void main(void) {
         if (p2_bullets[i].alive && aabb(&p2_bullets[i], &enemies[j])) {
           p2_bullets[i].alive = 0;
           enemies[j].alive = 0;
-          if (score_p2 < 65500) score_p2 = (uint16_t)(score_p2 + 10);
+          if (score_p2 < 65500u) score_p2 = (uint16_t)(score_p2 + 10);
           sfx_noise(8);
           break;
         }

package/examples/snes/main.asm

@@ -20,7 +20,7 @@
 ;   - nmi_safe.asm: vblank handler skeleton
 ;
 ; BUILD: complete LoROM image, no extra options needed.
-;   buildSource({ platform: "snes", source: /* this file */ });
+;   build({ output: "rom",  platform: "snes", source: /* this file */ });
 
 lorom