romdevtools 0.26.0 → 0.28.0

package/examples/gbc/templates/racing.c

@@ -100,11 +100,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;

package/examples/gbc/templates/shmup.c

@@ -94,11 +94,23 @@ static void fire(void) {
     }
 }
 
+/* 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(void) {
     uint8_t i;
     for (i = 0; i < MAX_ENEMIES; i++) {
         if (!enemies[i].alive) {
-            enemies[i].x = ((spawn_timer * 37) & 0x7F) % (160 - 16) + 8;
+            enemies[i].x = rand8() % (160 - 16) + 8;
             enemies[i].y = 0;
             enemies[i].alive = 1;
             return;

package/examples/gbc/templates/sports.c

@@ -133,15 +133,21 @@ void main(void) {
 
   while (1) {
     wait_vblank();
+    /* OAM DMA FIRST — at the leading edge of vblank. The old order staged
+     * 45 oam_set CALLS before the DMA; the SDCC call overhead pushed the
+     * DMA ~a third of the frame into ACTIVE display, so the sprites tore
+     * on one fixed scanline ("horizontal line a 3rd of the way down").
+     * Sprites now display the state staged LAST frame (1 frame of latency,
+     * imperceptible in Pong). */
+    oam_dma_flush();
 
-    /* Stage OAM: left paddle (2 stacked), right paddle (2 stacked), ball. */
-    for (i = 0; i < 40; i++) oam_set(i, 0, 0, 0, 0);
+    /* Stage next frame's OAM (RAM only — safe any time). Slots 5-39 were
+     * zeroed once by oam_clear() at boot and never change. */
     oam_set(0, (uint8_t)(p1y + 16),         (uint8_t)(PADDLE_X1 + 8), 1, 0);
     oam_set(1, (uint8_t)(p1y + 16 + 8),     (uint8_t)(PADDLE_X1 + 8), 1, 0);
     oam_set(2, (uint8_t)(p2y + 16),         (uint8_t)(PADDLE_X2 + 8), 1, 0);
     oam_set(3, (uint8_t)(p2y + 16 + 8),     (uint8_t)(PADDLE_X2 + 8), 1, 0);
     oam_set(4, (uint8_t)(by + 16),          (uint8_t)(bx + 8),        1, 0);
-    oam_dma_flush();
 
     pad = joypad_read();
     if (pad & PAD_UP    && p1y > COURT_TOP)            p1y -= 2;

package/examples/genesis/templates/puzzle.c

@@ -140,26 +140,87 @@ static void draw_piece(s16 col, s16 row, bool clear) {
     }
 }
 
+/* ── 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];
+static const s8 DIRS4[4][2] = { {0,1}, {1,0}, {1,1}, {1,-1} };
+
+static u8 mark_and_count(void) {
+  u8 r, c, d, len, k, cnt;
+  u8 col;
+  s8 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) {
+  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 < 65500u) score += amt;
+    sfx_tone(0, 250, 12);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
     for (u16 i = 0; i < 3; i++) {
         s16 r = piece_y + i;
         if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
     }
-    /* Check horizontal triples on the affected rows. */
-    for (u16 i = 0; i < 3; i++) {
-        s16 r = piece_y + i;
-        if (r < 0 || r >= ROWS) continue;
-        for (s16 c = 0; c <= COLS - 3; c++) {
-            u8 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 < 65500u) score += 30;
-                sfx_tone(0, 250, 12);  /* triple-clear chime */
-            }
-        }
-    }
+    resolve_board();
     draw_grid();
 }
 

package/examples/genesis/templates/racing.c

@@ -129,11 +129,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 u8 rng_state = 0xA5;
+static u8 rand8(void) {
+  u8 lsb = (u8)(rng_state & 1);
+  rng_state >>= 1;
+  if (lsb) rng_state ^= 0xB8;
+  return rng_state;
+}
+
 static void spawn_obstacle(void) {
     u16 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 = TRUE;
             return;

package/examples/genesis/templates/shmup_2p.c

@@ -91,11 +91,23 @@ static void fire(Obj* ship, Obj* pool) {
     }
 }
 
+/* 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 u8 rng_state = 0xA5;
+static u8 rand8(void) {
+  u8 lsb = (u8)(rng_state & 1);
+  rng_state >>= 1;
+  if (lsb) rng_state ^= 0xB8;
+  return rng_state;
+}
+
 static void spawn_enemy(void) {
     u16 i;
     for (i = 0; i < MAX_ENEMIES; i++) {
         if (!enemies[i].alive) {
-            enemies[i].x = ((spawn_timer * 37) & 0xFF) % (320 - 16) + 8;
+            enemies[i].x = (s16)((((u16)rand8()) * (320 - 16)) >> 8) + 8;
             enemies[i].y = -8;
             enemies[i].alive = TRUE;
             return;

package/examples/gg/templates/platformer.c

@@ -17,6 +17,7 @@
  */
 #include "gg_hw.h"
 #include "gg_sfx.h"
+#include "gg_music.h"
 #include <stdint.h>
 
 extern void gg_vdp_init(void);
@@ -163,6 +164,8 @@ void main(void) {
 
   gg_sprite_init();
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   gg_sprite_set(0, (uint8_t)(px >> 4), (uint8_t)(py >> 4), 0);
   gg_sat_upload();
   gg_vdp_display_on();
@@ -176,6 +179,7 @@ void main(void) {
     const Rect *p;
     gg_vblank_wait();
     sfx_update();
+    music_update();
 
     ipx = px >> 4;
     ipy = py >> 4;

package/examples/gg/templates/puzzle.c

@@ -7,6 +7,7 @@
  */
 #include "gg_hw.h"
 #include "gg_sfx.h"
+#include "gg_music.h"
 #include <stdint.h>
 
 extern void gg_vdp_init(void);
@@ -140,27 +141,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 < 65500) score = (uint16_t)(score + amt);
+    sfx_tone(0, 200, 10);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
   uint8_t i;
   int8_t r;
-  int8_t 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 < 65500) score = (uint16_t)(score + 30);
-        sfx_tone(0, 200, 10);  /* triple-clear chime */
-      }
-    }
-  }
+  resolve_board();
   draw_grid();
 }
 
@@ -193,12 +256,15 @@ void main(void) {
   draw_grid();
 
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   gg_vdp_display_on();
 
   do {
     uint8_t pad, fall_rate, t;
     gg_vblank_wait();
     sfx_update();
+    music_update();
     draw_piece(1);
 
     pad = gg_joypad_read();

package/examples/gg/templates/racing.c

@@ -12,6 +12,7 @@
  */
 #include "gg_hw.h"
 #include "gg_sfx.h"
+#include "gg_music.h"
 #include <stdint.h>
 
 extern void    gg_vdp_init(void);
@@ -141,11 +142,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 = VIS_Y0;   /* enter at the top of the visible window */
       obstacles[i].alive = 1;
       return;
@@ -162,6 +175,8 @@ void main(void) {
   draw_track();
   gg_sprite_init();
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   gg_vdp_display_on();
 
   reset_run();
@@ -173,6 +188,7 @@ void main(void) {
     int16_t step;
     gg_vblank_wait();
     sfx_update();
+    music_update();
 
     /* Stage SAT. */
     slot = 0;

package/examples/gg/templates/shmup.c

@@ -8,6 +8,7 @@
  */
 #include "gg_hw.h"
 #include "gg_sfx.h"
+#include "gg_music.h"
 #include <stdint.h>
 
 extern void gg_vdp_init(void);
@@ -145,12 +146,24 @@ static void fire(void) {
   }
 }
 
+/* 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(void) {
   uint8_t i;
   for (i = 0; i < MAX_ENEMIES; i++) {
     if (!enemies[i].alive) {
       /* Spawn across the VISIBLE width (hardware X in [VIS_X0..VIS_X1-8]). */
-      enemies[i].x = (uint8_t)(VIS_X0 + ((spawn_timer * 37u) % (VIS_W - 8)));
+      enemies[i].x = (uint8_t)(VIS_X0 + (rand8() % (VIS_W - 8)));
       enemies[i].y = VIS_Y0;   /* enter at the top of the visible region */
       enemies[i].alive = 1;
       return;
@@ -179,6 +192,8 @@ void main(void) {
 
   gg_sprite_init();
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   gg_vdp_display_on();
 
   do {
@@ -186,6 +201,7 @@ void main(void) {
     uint8_t i, j;
     gg_vblank_wait();
     sfx_update();
+    music_update();
 
     /* Stage SAT for the new frame. */
     gg_sprite_set(0, player.x, player.y, T_SHIP);

package/examples/gg/templates/sports.c

@@ -5,6 +5,7 @@
  */
 #include "gg_hw.h"
 #include "gg_sfx.h"
+#include "gg_music.h"
 #include <stdint.h>
 
 extern void    gg_vdp_init(void);
@@ -125,6 +126,8 @@ void main(void) {
   draw_court();
   gg_sprite_init();
   sfx_init();
+  music_init();
+  music_play(0);   /* continuous background music ("no sound" was the playtest verdict) */
   gg_vdp_display_on();
 
   reset_match();
@@ -135,6 +138,7 @@ void main(void) {
     int16_t target;
     gg_vblank_wait();
     sfx_update();
+    music_update();
 
     /* Stage SAT first — uploaded at vblank. */
     slot = 0;

package/examples/lynx/templates/platformer.c

@@ -68,11 +68,30 @@ void main(void) {
     if (btn && !prev && grounded) { vy = -6; sfx_tone(0, 100, 6); }
     prev = btn;
 
-    vy++;
-    if (vy > 4) vy = 4;
-    py += vy;
-    if (py < 0)  py = 0;
-    if (py > 96) py = 96;
-    if (vy > 0 && on_platform(px, py)) { py = py & 0xFC; vy = 0; }
+    {
+      /* Land-on-top via a CROSSING test. The old check demanded
+       * py+6 == platform.y EXACTLY after the move — falls step up to
+       * 4px/frame, so the exact value was usually skipped (fall-through),
+       * and the `py & 0xFC` snap then broke the equality for the next
+       * frame's grounded test (couldn't jump from floating platforms). */
+      int16_t old_py = py;
+      uint8_t i;
+      vy++;
+      if (vy > 4) vy = 4;
+      py += vy;
+      if (vy > 0) {
+        for (i = 0; i < N_PLATFORMS; i++) {
+          if (old_py + 6 <= platforms[i].y && py + 6 >= platforms[i].y
+              && px + 6 > platforms[i].x
+              && px < platforms[i].x + platforms[i].w) {
+            py = platforms[i].y - 6;
+            vy = 0;
+            break;
+          }
+        }
+      }
+      if (py < 0)  py = 0;
+      if (py > 96) py = 96;
+    }
   }
 }

package/examples/lynx/templates/puzzle.c

@@ -47,26 +47,89 @@ static uint8_t collides(int8_t x, int8_t y) {
   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 < 65500u) score += amt;
+    sfx_tone(0, 60, 10);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
-  uint8_t i, c;
+  uint8_t i;
   int8_t r;
-  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 < 65500u) score += 30;
-        sfx_tone(0, 60, 10);
-      }
-    }
-  }
+  resolve_board();
 }
 
 static uint8_t cell_color(uint8_t v) {

package/examples/lynx/templates/shmup.c

@@ -38,11 +38,23 @@ static void fire(void) {
   }
 }
 
+/* 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(void) {
   uint8_t i;
   for (i = 0; i < MAX_ENEMIES; i++) {
     if (!enemies[i].alive) {
-      enemies[i].x = (uint8_t)(8 + ((spawn_timer * 37) & 0x7F));
+      enemies[i].x = (uint8_t)(8 + (rand8() % (160 - 16)));
       enemies[i].y = 0;
       enemies[i].alive = 1;
       return;