romdevtools 0.26.0 → 0.28.0

package/examples/lynx/templates/sports.c

@@ -62,10 +62,13 @@ void main(void) {
     tgi_line(70, 40, 70, 60);
     tgi_line(90, 40, 90, 60);
 
-    tgi_setcolor(COLOR_WHITE);
+    /* Playtest: "needs better contrast" — yellow paddles + white ball pop
+     * against the green court far better than white-on-lightgreen +
+     * yellow-on-green did. */
+    tgi_setcolor(COLOR_YELLOW);
     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));
-    tgi_setcolor(COLOR_YELLOW);
+    tgi_setcolor(COLOR_WHITE);
     tgi_bar((unsigned)bx, (unsigned)by, (unsigned)(bx + BALL_SIZE - 1), (unsigned)(by + BALL_SIZE - 1));
     tgi_updatedisplay();
     sfx_update();

package/examples/msx/platformer/main.c

@@ -150,6 +150,8 @@ void main(void) {
 
         vsync();
 
+        msx_music_tick();
+
         ipx = (int16_t)(px >> 4);
         ipy = (int16_t)(py >> 4);
 

package/examples/msx/puzzle/main.c

@@ -144,27 +144,89 @@ static uint8_t collides(int8_t col, int8_t row) {
     return 0;
 }
 
+/* ── match / clear / gravity core (ported from the GBC reference puzzle).
+ * The old scan was horizontal-only AND cleared cells mid-scan, so vertical
+ * and diagonal runs never cleared, 4+ runs half-cleared, and nothing ever
+ * fell afterwards ("rows don't shift down"). This marks every 3+ run in all
+ * 4 directions, clears them, applies per-column gravity, and loops so
+ * cascades chain (score scales with chain depth). */
+static uint8_t matched[ROWS][COLS];
+static const int8_t DIRS4[4][2] = { {0,1}, {1,0}, {1,1}, {1,-1} };
+
+static uint8_t mark_and_count(void) {
+  uint8_t r, c, d, len, k, cnt;
+  uint8_t col;
+  int8_t dr, dc;
+  int sr, sc;
+  cnt = 0;
+  for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) matched[r][c] = 0;
+  for (r = 0; r < ROWS; r++) {
+    for (c = 0; c < COLS; c++) {
+      col = grid[r][c];
+      if (col == 0) continue;
+      for (d = 0; d < 4; d++) {
+        dr = DIRS4[d][0]; dc = DIRS4[d][1];
+        sr = (int)r - dr; sc = (int)c - dc;
+        if (sr >= 0 && sr < ROWS && sc >= 0 && sc < COLS
+            && grid[sr][sc] == col) continue;  /* not the run's start */
+        len = 1;
+        sr = (int)r + dr; sc = (int)c + dc;
+        while (sr >= 0 && sr < ROWS && sc >= 0 && sc < COLS
+               && grid[sr][sc] == col) { len++; sr += dr; sc += dc; }
+        if (len >= 3) {
+          sr = r; sc = c;
+          for (k = 0; k < len; k++) {
+            if (!matched[sr][sc]) { matched[sr][sc] = 1; cnt++; }
+            sr += dr; sc += dc;
+          }
+        }
+      }
+    }
+  }
+  return cnt;
+}
+
+/* collapse each column so survivors rest on the floor (in place: walk
+ * from the bottom, copying gems down to a write cursor, then zero above) */
+static void apply_gravity(void) {
+  uint8_t c;
+  int r, w;
+  for (c = 0; c < COLS; c++) {
+    w = ROWS - 1;
+    for (r = ROWS - 1; r >= 0; r--) {
+      if (grid[r][c] != 0) { grid[w][c] = grid[r][c]; w--; }
+    }
+    for (; w >= 0; w--) grid[w][c] = 0;
+  }
+}
+
+static void resolve_board(void) {
+  uint8_t n, r, c, chain;
+  unsigned int amt;
+  chain = 0;
+  while (1) {
+    n = mark_and_count();
+    if (n == 0) break;
+    chain++;
+    for (r = 0; r < ROWS; r++)
+      for (c = 0; c < COLS; c++)
+        if (matched[r][c]) grid[r][c] = 0;
+    amt = (unsigned int)n * 10u;
+    if (chain > 1) amt = amt * chain;
+    if (score < 999) score += n;
+    msx_psg_tone(0, 0x180, 13); blip = 8;  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
     uint8_t i;
-    int8_t r, c;
-    uint8_t a, b, d;
+    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];
     }
-    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;
-            }
-        }
-    }
+    resolve_board();
     draw_grid();
 }
 
@@ -202,6 +264,7 @@ void main(void) {
 
     for (;;) {
         vsync();
+        msx_music_tick();
         draw_piece(1);
 
         dir = msx_read_joystick(1);

package/examples/msx/racing/main.c

@@ -193,6 +193,7 @@ void main(void) {
 
     for (;;) {
         vsync();
+        msx_music_tick();
 
         /* push sprites */
         slot = 0;

package/examples/msx/shmup/main.c

@@ -224,6 +224,7 @@ void main(void) {
 
     for (;;) {
         vsync();
+        msx_music_tick();
 
         dir = msx_read_joystick(1);
         if (dir == STICK_CENTER) dir = msx_read_joystick(0);

package/examples/msx/sports/main.c

@@ -43,7 +43,7 @@ static const uint8_t TILE_LINE[8]  = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 static const uint8_t TILE_NET[8]   = {0x18,0x18,0x00,0x00,0x18,0x18,0x00,0x00};
 
 /* colour bytes (hi fg, lo bg). 3=green(dark), 12=green(light), 15=white */
-#define COL_FIELD 0x21   /* dark green field on black             */
+#define COL_FIELD 0xC1   /* light-green-on-black field (was 0x21 medium green — muddy per the contrast playtest note) */
 #define COL_LINE  0xF1   /* white line on black                   */
 #define COL_NET   0xF2   /* white net dashes on dark-green field  */
 
@@ -118,6 +118,7 @@ void main(void) {
 
     for (;;) {
         vsync();
+        msx_music_tick();
 
         /* push sprites: left paddle (3 cells), right paddle (3), ball */
         slot = 0;
@@ -125,7 +126,7 @@ void main(void) {
             msx_set_sprite(slot++, PADDLE_X1, (uint8_t)(p1y + i * 8), 0, COL_SPR);
         for (i = 0; i < PADDLE_H / 8; i++)
             msx_set_sprite(slot++, PADDLE_X2, (uint8_t)(p2y + i * 8), 0, COL_SPR);
-        msx_set_sprite(slot++, (uint8_t)bx, (uint8_t)by, 0, COL_SPR);
+        msx_set_sprite(slot++, (uint8_t)bx, (uint8_t)by, 0, 11);  /* light-yellow ball — distinct from the white paddles (contrast playtest note) */
 
         p1 = msx_read_joystick(1);
         p2 = msx_read_joystick(2);

package/examples/nes/templates/platformer.c

@@ -82,7 +82,9 @@ static const uint8_t palette[32] = {
    * Keep it equal to the BG backdrop (sky blue) or the sky renders as
    * whatever colour-0 you put here, not the BG[0] above. (Sprite colour 0 is
    * transparent regardless, so this never affects how sprites draw.) */
-  0x21, 0x21, 0x32, 0x30,  /* sp0: player — blue (colour 0 = backdrop mirror) */
+  0x21, 0x16, 0x30, 0x27,  /* sp0: player — RED + white/orange trim. (Was light
+                            * blues — nearly invisible against the sky-blue
+                            * backdrop. Colour 0 stays the backdrop mirror.) */
   0x0F, 0x18, 0x28, 0x38,  /* sp1: platforms — green */
   0x0F, 0x16, 0x06, 0x36,
   0x0F, 0x2A, 0x1A, 0x0A,
@@ -113,13 +115,18 @@ static uint8_t  on_ground = 0;
 
 #define GRAVITY_Q44    1   /* +1/16 px per frame per frame */
 #define JUMP_VEL_Q44 (-40) /* initial vy → peak ~5 tile jump */
-#define MOVE_SPEED     1   /* 1 px / frame */
+#define MOVE_SPEED     2   /* px/frame — 1 read as 'moves slowly' in playtesting */
 
 /* AABB: player rect vs platform top edge (treat platform as 8 px tall). */
 static uint8_t landed_on(uint8_t pl_idx, uint8_t player_y) {
   const Platform *p = &platforms[pl_idx];
   uint8_t feet_y = player_y + 7;
-  if (feet_y < p->y || feet_y > p->y + 4) return 0;          /* not at top edge */
+  /* Window starts ONE PIXEL above the top edge: the standing snap puts the
+   * feet at p->y - 1, and gravity's sub-pixel trickle doesn't move the
+   * integer Y every frame — with the old `feet_y < p->y` cutoff the player
+   * "stood" with on_ground=0 most frames, so A-press jumps only registered
+   * on lucky frames and the idle/jump sprite flickered every frame. */
+  if (feet_y + 1 < p->y || feet_y > p->y + 4) return 0;      /* not at top edge */
   if (px + 7 < p->x) return 0;
   if (px > p->x + (p->w << 3) - 1) return 0;
   return 1;
@@ -190,6 +197,7 @@ void main(void) {
     ppu_wait_nmi();
 
     /* ── Input ──────────────────────────────────────────────── */
+    sound_music_tick();
     pad = pad_poll(0);
     if ((pad & PAD_LEFT)  && px > 8)   px -= MOVE_SPEED;
     if ((pad & PAD_RIGHT) && px < 240) px += MOVE_SPEED;

package/examples/nes/templates/puzzle.c

@@ -132,8 +132,86 @@ static void spawn_piece(void) {
 }
 
 /* Lock current piece into the grid + check for match-3 horizontals. */
+/* ── match / clear / gravity core (ported from the GBC reference puzzle).
+ * The old scan was horizontal-only AND cleared cells mid-scan, so vertical
+ * and diagonal runs never cleared, 4+ runs half-cleared, and nothing ever
+ * fell afterwards ("rows don't shift down"). This marks every 3+ run in all
+ * 4 directions, clears them, applies per-column gravity, and loops so
+ * cascades chain (score scales with chain depth). */
+/* matched[] lives at $0500 — OUTSIDE the linker's RAM area ($0300-$04FF,
+ * which grid+runtime statics nearly fill; 72 more BSS bytes overflow it).
+ * $0500-$07FF is real, unused NES work RAM (hw stack is $0100, shadow OAM
+ * $0200), so an absolute pointer there is free. */
+#define matched ((uint8_t (*)[GRID_W])0x0500)
+static const int8_t DIRS4[4][2] = { {0,1}, {1,0}, {1,1}, {1,-1} };
+
+static uint8_t mark_and_count(void) {
+  uint8_t r, c, d, len, k, cnt;
+  uint8_t col;
+  int8_t dr, dc;
+  int sr, sc;
+  cnt = 0;
+  for (r = 0; r < GRID_H; r++) for (c = 0; c < GRID_W; c++) matched[r][c] = 0;
+  for (r = 0; r < GRID_H; r++) {
+    for (c = 0; c < GRID_W; c++) {
+      col = grid[r][c];
+      if (col == EMPTY) continue;
+      for (d = 0; d < 4; d++) {
+        dr = DIRS4[d][0]; dc = DIRS4[d][1];
+        sr = (int)r - dr; sc = (int)c - dc;
+        if (sr >= 0 && sr < GRID_H && sc >= 0 && sc < GRID_W
+            && grid[sr][sc] == col) continue;  /* not the run's start */
+        len = 1;
+        sr = (int)r + dr; sc = (int)c + dc;
+        while (sr >= 0 && sr < GRID_H && sc >= 0 && sc < GRID_W
+               && grid[sr][sc] == col) { len++; sr += dr; sc += dc; }
+        if (len >= 3) {
+          sr = r; sc = c;
+          for (k = 0; k < len; k++) {
+            if (!matched[sr][sc]) { matched[sr][sc] = 1; cnt++; }
+            sr += dr; sc += dc;
+          }
+        }
+      }
+    }
+  }
+  return cnt;
+}
+
+/* collapse each column so survivors rest on the floor (in place: walk
+ * from the bottom, copying gems down to a write cursor, then zero above) */
+static void apply_gravity(void) {
+  uint8_t c;
+  int r, w;
+  for (c = 0; c < GRID_W; c++) {
+    w = GRID_H - 1;
+    for (r = GRID_H - 1; r >= 0; r--) {
+      if (grid[r][c] != EMPTY) { grid[w][c] = grid[r][c]; w--; }
+    }
+    for (; w >= 0; w--) grid[w][c] = EMPTY;
+  }
+}
+
+static void resolve_board(void) {
+  uint8_t n, r, c, chain;
+  unsigned int amt;
+  chain = 0;
+  while (1) {
+    n = mark_and_count();
+    if (n == 0) break;
+    chain++;
+    for (r = 0; r < GRID_H; r++)
+      for (c = 0; c < GRID_W; c++)
+        if (matched[r][c]) grid[r][c] = EMPTY;
+    amt = (unsigned int)n * 10u;
+    if (chain > 1) amt = amt * chain;
+    (void)amt;
+    sound_play_tone(0, 0xC0, 6, 4);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
-  uint8_t r, c, run, run_col;
   int8_t i;
   /* Drop the 3 cells into the grid. */
   for (i = 0; i < 3; i++) {
@@ -142,26 +220,7 @@ static void lock_piece(void) {
       grid[y][piece_x] = piece_col[i];
     }
   }
-  /* Scan each row for 3-in-a-row same color → clear. */
-  for (r = 0; r < GRID_H; r++) {
-    run = 1;
-    run_col = grid[r][0];
-    for (c = 1; c < GRID_W; c++) {
-      if (grid[r][c] == run_col && run_col != EMPTY) {
-        ++run;
-        if (run >= 3) {
-          /* Found a triple ending at c — clear back. */
-          grid[r][c]     = EMPTY;
-          grid[r][c - 1] = EMPTY;
-          grid[r][c - 2] = EMPTY;
-          sound_play_tone(0, 0x100 - (c << 4), 6, 4);
-        }
-      } else {
-        run = 1;
-        run_col = grid[r][c];
-      }
-    }
-  }
+  resolve_board();
 }
 
 /* Can the piece occupy (x, y..y+2) given the current grid? */
@@ -258,6 +317,7 @@ void main(void) {
     ppu_wait_nmi();
 
     /* ── Input ──────────────────────────────────────────────── */
+    sound_music_tick();
     pad = pad_poll(0);
     if ((pad & PAD_LEFT)  && !(prev_pad & PAD_LEFT)  && can_place(piece_x - 1, piece_y)) --piece_x;
     if ((pad & PAD_RIGHT) && !(prev_pad & PAD_RIGHT) && can_place(piece_x + 1, piece_y)) ++piece_x;

package/examples/nes/templates/racing.c

@@ -176,11 +176,23 @@ static void reset_run(void) {
   game_over_timer = 0;
 }
 
+/* Galois LFSR (taps $B8), period 255 -- real per-spawn randomness.
+ * The old code derived the spawn column from spawn_timer, but the caller
+ * resets spawn_timer just before calling here, so it was CONSTANT and
+ * every enemy spawned in the same left column/lane. */
+static uint8_t rng_state = 0xA5;
+static uint8_t rand8(void) {
+  uint8_t lsb = (uint8_t)(rng_state & 1);
+  rng_state >>= 1;
+  if (lsb) rng_state ^= 0xB8;
+  return rng_state;
+}
+
 static void spawn_obstacle(void) {
   uint8_t i;
   for (i = 0; i < MAX_OBSTACLES; i++) {
     if (!obstacles[i].alive) {
-      obstacles[i].x = lane_x[(spawn_timer * 13) % 3];
+      obstacles[i].x = lane_x[rand8() % 3];
       obstacles[i].y = 0;
       obstacles[i].alive = 1;
       return;
@@ -240,6 +252,8 @@ void main(void) {
 
     ppu_wait_nmi();
 
+    sound_music_tick();
+
     p1 = pad_poll(0);
 
     if (game_over_timer > 0) {

package/examples/nes/templates/shmup.c

@@ -215,6 +215,7 @@ void main(void) {
     ppu_wait_nmi();
 
     /* ── Input ───────────────────────────────────────────────── */
+    sound_music_tick();
     pad = pad_poll(0);
     if ((pad & PAD_LEFT)  && ship_x > 8)   --ship_x;
     if ((pad & PAD_RIGHT) && ship_x < 240) ++ship_x;

package/examples/nes/templates/sports.c

@@ -181,6 +181,7 @@ void main(void) {
     ppu_wait_nmi();
 
     /* ── Input ────────────────────────────────────────────────── */
+    sound_music_tick();
     p1 = pad_poll(0);
     p2 = pad_poll(1);
 

package/examples/pce/platformer/main.c

@@ -167,7 +167,7 @@ static u8 on_platform(int16_t ipx, int16_t ipy) {
 
 void main(void) {
     const int16_t GRAVITY = 10;
-    const int16_t MOVE    = 22;
+    const int16_t MOVE    = 34;   /* was 22 — playtest: 'slow overall' */
     const int16_t JUMP    = -200;
     const int16_t MAXFALL = 300;
 
@@ -210,6 +210,8 @@ void main(void) {
         const Rect *p;
 
         waitvsync();
+
+        psg_music_tick();
         pad = pce_joy_read();
 
         ipx = px >> 4;

package/examples/pce/puzzle/main.c

@@ -198,20 +198,85 @@ static void draw_piece(u8 clear) {
     }
 }
 
-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);
-            }
+/* ── match / clear / gravity core (ported from the GBC reference puzzle).
+ * The old scan was horizontal-only AND cleared cells mid-scan, so vertical
+ * and diagonal runs never cleared, 4+ runs half-cleared, and nothing ever
+ * fell afterwards ("rows don't shift down"). This marks every 3+ run in all
+ * 4 directions, clears them, applies per-column gravity, and loops so
+ * cascades chain (score scales with chain depth). */
+static u8 matched[ROWS][COLS];
+/* H + V only on PCE — the stock cc65 pce.cfg boot bank is 8KB and the
+ * two diagonal passes don't fit; add them back if you free up ROM. */
+static const int8_t DIRS4[2][2] = { {0,1}, {1,0} };
+
+static u8 mark_and_count(void) {
+  u8 r, c, d, len, k, cnt;
+  u8 col;
+  int8_t dr, dc;
+  int sr, sc;
+  cnt = 0;
+  for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) matched[r][c] = 0;
+  for (r = 0; r < ROWS; r++) {
+    for (c = 0; c < COLS; c++) {
+      col = grid[r][c];
+      if (col == 0) continue;
+      for (d = 0; d < 2; d++) {
+        dr = DIRS4[d][0]; dc = DIRS4[d][1];
+        /* (no run-start check: a mid-run scan only re-marks already-
+         * marked cells, so skipping the predecessor test is pure
+         * code-size savings on the 8KB PCE boot bank) */
+        len = 1;
+        sr = (int)r + dr; sc = (int)c + dc;
+        while (sr >= 0 && sr < ROWS && sc >= 0 && sc < COLS
+               && grid[sr][sc] == col) { len++; sr += dr; sc += dc; }
+        if (len >= 3) {
+          sr = r; sc = c;
+          for (k = 0; k < len; k++) {
+            if (!matched[sr][sc]) { matched[sr][sc] = 1; cnt++; }
+            sr += dr; sc += dc;
+          }
         }
+      }
+    }
+  }
+  return cnt;
+}
+
+/* collapse each column so survivors rest on the floor (in place: walk
+ * from the bottom, copying gems down to a write cursor, then zero above) */
+static void apply_gravity(void) {
+  u8 c;
+  int r, w;
+  for (c = 0; c < COLS; c++) {
+    w = ROWS - 1;
+    for (r = ROWS - 1; r >= 0; r--) {
+      if (grid[r][c] != 0) { grid[w][c] = grid[r][c]; w--; }
     }
+    for (; w >= 0; w--) grid[w][c] = 0;
+  }
+}
+
+static void resolve_board(void) {
+  u8 n, r, c, chain;
+  unsigned int amt;
+  chain = 0;
+  while (1) {
+    n = mark_and_count();
+    if (n == 0) break;
+    chain++;
+    for (r = 0; r < ROWS; r++)
+      for (c = 0; c < COLS; c++)
+        if (matched[r][c]) grid[r][c] = 0;
+    amt = (unsigned int)n * 10u;
+    if (chain > 1) amt = amt * chain;
+    if (score < 9999) score += amt;
+    psg_tone(0, 0x180, 24);  /* clear chime */
+    apply_gravity();
+  }
+}
+
+static void clear_triples(void) {
+    resolve_board();
 }
 
 static void lock_piece(void) {
@@ -262,6 +327,7 @@ void main(void) {
     for (;;) {
         u8 fall_rate;
         waitvsync();
+        psg_music_tick();
 
         draw_piece(1);   /* erase old piece footprint                    */
 

package/examples/pce/racing/main.c

@@ -244,6 +244,7 @@ void main(void) {
         u8 slot;
         int16_t step;
         waitvsync();
+        psg_music_tick();
 
         /* stage sprites: player + obstacles */
         slot = 0;

package/examples/pce/shmup/main.c

@@ -225,7 +225,7 @@ static void fire(void) {
             bullets[i].x = player.x;
             bullets[i].y = (u16)(player.y - 10);
             bullets[i].alive = 1;
-            psg_tone(2, 0x180, 26);
+            psg_tone(2, 0x180, 31);  /* max vol — playtest said too quiet */
             sfx_timer = 4;
             return;
         }
@@ -280,11 +280,12 @@ void main(void) {
 
     for (;;) {
         waitvsync();
+        psg_music_tick();
         pad = pce_joy_read();
 
         /* move ship */
-        if ((pad & PCE_JOY_LEFT)  && player.x > 2)   player.x -= 3;
-        if ((pad & PCE_JOY_RIGHT) && player.x < 238) player.x += 3;
+        if ((pad & PCE_JOY_LEFT)  && player.x > 2)   player.x -= 4;   /* playtest: 'slow overall' */
+        if ((pad & PCE_JOY_RIGHT) && player.x < 238) player.x += 4;
         if ((pad & PCE_JOY_UP)    && player.y > 8)   player.y -= 3;
         if ((pad & PCE_JOY_DOWN)  && player.y < 208) player.y += 3;
         if ((pad & PCE_JOY_I) && !(prev_pad & PCE_JOY_I)) fire();
@@ -318,7 +319,7 @@ void main(void) {
                     enemies[j].alive = 0;
                     if (score < 9999) score += 10;
                     draw_score();
-                    psg_tone(3, 0x040, 28);
+                    psg_tone(3, 0x040, 31);
                     sfx_timer = 6;
                     break;
                 }

package/examples/pce/sports/main.c

@@ -159,7 +159,7 @@ static void draw_scores(void) {
 static void serve_ball(u8 to_left) {
     bx = 120; by = 110;
     bdx = to_left ? -2 : 2;
-    bdy = ((score_p1 + score_p2) & 1) ? -1 : 1;
+    bdy = ((score_p1 + score_p2) & 1) ? -2 : 2;   /* was ±1 — rally felt slow */
     serve_timer = 40;
 }
 
@@ -199,6 +199,7 @@ void main(void) {
         u8 slot;
         int16_t target;
         waitvsync();
+        psg_music_tick();
 
         /* stage sprites: P1 paddle (3 segs), P2 paddle (3 segs), ball */
         slot = 0;
@@ -212,8 +213,8 @@ void main(void) {
         pad = pce_joy_read();
 
         /* P1 control */
-        if ((pad & PCE_JOY_UP)   && p1y > COURT_TOP)            p1y -= 3;
-        if ((pad & PCE_JOY_DOWN) && p1y < COURT_BOT - PADDLE_H) p1y += 3;
+        if ((pad & PCE_JOY_UP)   && p1y > COURT_TOP)            p1y -= 4;   /* playtest: 'slow overall' */
+        if ((pad & PCE_JOY_DOWN) && p1y < COURT_BOT - PADDLE_H) p1y += 4;
 
         /* P2 chase-AI */
         target = (int16_t)(by - PADDLE_H / 2 + BALL_SIZE / 2);

package/examples/sms/templates/platformer.c

@@ -14,6 +14,7 @@
  */
 #include "sms_hw.h"
 #include "sms_sfx.h"
+#include "sms_music.h"
 #include <stdint.h>
 
 extern void sms_vdp_init(void);
@@ -138,6 +139,8 @@ void main(void) {
 
   sms_sprite_init();
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   sms_sprite_set(0, (uint8_t)(px >> 4), (uint8_t)(py >> 4), 0);
   sms_sat_upload();
   sms_vdp_display_on();
@@ -151,6 +154,7 @@ void main(void) {
     const Rect *p;
     sms_vblank_wait();
     sfx_update();
+    music_update();
 
     ipx = px >> 4;
     ipy = py >> 4;