romdevtools 0.27.0 → 0.28.0

package/examples/gba/templates/puzzle.c

@@ -63,6 +63,13 @@ static const u32 tile_blue[8] = {
 /* Backdrop tile (colour index 4 = steel grey): a dither so the whole screen
  * reads as a "cabinet" behind the playfield instead of flat black — a lone
  * 6x12 grid floating on black looks blank to a human (frame verify <92%). */
+/* Solid light-grey wall tile for the well border. */
+static const u32 tile_wall[8] = {
+    0x55555555, 0x55555555, 0x55555555, 0x55555555,
+    0x55555555, 0x55555555, 0x55555555, 0x55555555,
+};
+#define TILE_WALL  5
+
 static const u32 tile_back[8] = {
     0x40404040, 0x04040404, 0x40404040, 0x04040404,
     0x40404040, 0x04040404, 0x40404040, 0x04040404,
@@ -141,26 +148,87 @@ static int collides(int col, int 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 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(1, 1700, 10);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
     for (int i = 0; i < 3; i++) {
         int r = piece_y + i;
         if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
     }
-    /* Horizontal triples on the affected rows. */
-    for (int i = 0; i < 3; i++) {
-        int r = piece_y + i;
-        if (r < 0 || r >= ROWS) continue;
-        for (int 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(1, 1700, 10);  /* triple-clear chime */
-            }
-        }
-    }
+    resolve_board();
     draw_grid();
 }
 
@@ -177,18 +245,28 @@ int main(void) {
     pal_bg_mem[2] = CLR_LIME;
     pal_bg_mem[3] = CLR_BLUE;
     pal_bg_mem[4] = RGB15(6, 6, 9);   /* steel grey backdrop */
+    pal_bg_mem[5] = RGB15(20, 20, 22);  /* well border grey */
 
     /* BG tile graphics in char-block 3 (separate from TTE which used 2). */
     tonccpy(&tile_mem[3][TILE_RED],   tile_red,   sizeof(tile_red));
     tonccpy(&tile_mem[3][TILE_GREEN], tile_green, sizeof(tile_green));
     tonccpy(&tile_mem[3][TILE_BLUE],  tile_blue,  sizeof(tile_blue));
     tonccpy(&tile_mem[3][TILE_BACK],  tile_back,  sizeof(tile_back));
+    tonccpy(&tile_mem[3][TILE_WALL],  tile_wall,  sizeof(tile_wall));
 
     /* Fill screen-block 28 (BG0 map) with the backdrop tile so the whole
      * screen is covered; the grid cells draw over it. (A blank/black map left
      * the playfield floating on black — reads as blank.) */
     SCR_ENTRY *map = se_mem[28];
     for (int i = 0; i < 32 * 32; i++) map[i] = SE_BUILD(TILE_BACK, 0, 0, 0);
+    /* Well border — playtest: "needs border around play area". One wall
+     * cell left/right of the grid columns + a floor row underneath. */
+    for (int r = 0; r <= ROWS; r++) {
+        map[(GRID_TY + r) * 32 + (GRID_TX - 1)]    = SE_BUILD(TILE_WALL, 0, 0, 0);
+        map[(GRID_TY + r) * 32 + (GRID_TX + COLS)] = SE_BUILD(TILE_WALL, 0, 0, 0);
+    }
+    for (int c = -1; c <= COLS; c++)
+        map[(GRID_TY + ROWS) * 32 + (GRID_TX + c)] = SE_BUILD(TILE_WALL, 0, 0, 0);
 
     REG_BG0CNT = BG_CBB(3) | BG_SBB(28) | BG_REG_32x32 | BG_4BPP | BG_PRIO(0);
     /* Bump TTE's BG1 to a LOWER priority so the grid (BG0, prio 0) renders

package/examples/gba/templates/racing.c

@@ -100,10 +100,22 @@ 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) {
     for (int 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 = -8;
             obstacles[i].alive = 1;
             return;

package/examples/gba/templates/shmup.c

@@ -104,11 +104,23 @@ static void fire_bullet(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 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) {
     for (int i = 0; i < MAX_ENEMIES; i++) {
         if (!enemies[i].alive) {
             /* cheap deterministic x scatter */
-            enemies[i].x = ((spawn_timer * 37) & 0xFF) % (240 - 16) + 8;
+            enemies[i].x = rand8() % (240 - 16) + 8;
             enemies[i].y = -8;
             enemies[i].alive = 1;
             return;

package/examples/gba/templates/sports.c

@@ -201,11 +201,23 @@ int main(void) {
 
         oam_copy(oam_mem, obj_buffer, 7);
 
-        /* Score digits. */
-        tte_erase_rect(28, 2, 36, 14);
-        tte_printf("#{P:28,2}%d", score_p1 % 10);
-        tte_erase_rect(220, 2, 228, 14);
-        tte_printf("#{P:220,2}%d", score_p2 % 10);
+        /* Score digits — via tte_write, NOT tte_printf. tte_printf is
+         * broken in this libtonc build (GBA-1): it crashes with an
+         * undefined-instruction exception, and since this ran EVERY
+         * frame the whole game froze on iteration 1 ("game never
+         * starts"). racing/puzzle already avoided it the same way. */
+        {
+            char sb[12];
+            sb[0]='#'; sb[1]='{'; sb[2]='P'; sb[3]=':';
+            tte_erase_rect(28, 2, 36, 14);
+            sb[4]='2'; sb[5]='8'; sb[6]=','; sb[7]='2'; sb[8]='}';
+            sb[9] = (char)('0' + (score_p1 % 10)); sb[10] = 0;
+            tte_write(sb);
+            tte_erase_rect(220, 2, 228, 14);
+            tte_write("#{P:220,2}");
+            sb[0] = (char)('0' + (score_p2 % 10)); sb[1] = 0;
+            tte_write(sb);
+        }
     }
     return 0;
 }

package/examples/gbc/templates/platformer.c

@@ -119,10 +119,11 @@ void main(void) {
     const Rect *p;
     const int16_t GRAVITY = 10;
     const int16_t MOVE    = 20;
-    const int16_t JUMP    = -180;
+    const int16_t JUMP    = -140;  /* was -180: ~100px peak (most of the screen) — 'jumps a little too high' */
     const int16_t MAXFALL = 280;
 
     lcd_init_default();
+    sound_init();
     enable_vblank_irq();   /* MANDATORY: HALT-driven wait_vblank. Without this,
                             * busy-poll wait_vblank runs ~1/30 speed on the WASM
                             * emulator and the game loop appears to hang. */
@@ -172,7 +173,10 @@ void main(void) {
         if (pad & PAD_RIGHT) vx =  MOVE;
 
         grounded = on_platform(ipx, ipy);
-        if ((pad & PAD_A) && !(prev & PAD_A) && grounded) vy = JUMP;
+        if ((pad & PAD_A) && !(prev & PAD_A) && grounded) {
+            vy = JUMP;
+            sound_play_tone(1, 1750, 8);    /* jump blip (ch2 square) */
+        }
         prev = pad;
 
         vy += GRAVITY;