romdev-mcp 0.1.1

package/examples/sms/templates/platformer.c

@@ -0,0 +1,215 @@
+/* ── platformer.c — SMS SIDE-SCROLLING platformer scaffold ─────────
+ *
+ * A horizontally scrolling platformer. The world is 512 px wide (64
+ * cells); the SMS 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 that
+ * is about to scroll into view with the next world column's tiles.
+ *
+ * Smooth pixel scroll comes from VDP register 8 (R8 = -camX & 0xFF).
+ * Subpixel state (x/y in 1/16-pixel units) for fine acceleration; the
+ * player sprite draws in SCREEN space (worldX>>4) - camX.
+ *
+ * See the SMS MENTAL_MODEL.md "Horizontal scrolling" section.
+ */
+#include "sms_hw.h"
+#include "sms_sfx.h"
+#include <stdint.h>
+
+extern void sms_vdp_init(void);
+extern void sms_vdp_display_on(void);
+extern void sms_vdp_write_reg(uint8_t reg, uint8_t value);
+extern void sms_vdp_set_addr(uint16_t addr, uint8_t prefix);
+extern void sms_load_palette(const uint8_t *palette);
+extern void sms_load_tiles(uint16_t vram_dest, const uint8_t *src, uint16_t byte_count);
+extern void sms_set_tilemap_cell(uint8_t row, uint8_t col, uint8_t tile_idx, uint8_t attr);
+extern void sms_vblank_wait(void);
+extern uint8_t sms_joypad_read(void);
+extern void sms_sprite_init(void);
+extern void sms_sprite_set(uint8_t slot, uint8_t x, uint8_t y, uint8_t tile);
+extern void sms_sat_upload(void);
+
+#define T_OPEN  0
+#define T_WALL  1
+
+#define WORLD_COLS 64                 /* 64 cells = 512 px world          */
+#define WORLD_W    (WORLD_COLS * 8)
+#define SCREEN_W   256
+#define VIS_ROWS   24                 /* 192-line display = 24 rows       */
+
+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,
+};
+
+static const uint8_t bg_tiles[32 * 2] = {
+  /* T_OPEN — blank */
+  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,0,0,
+  /* T_WALL — solid block in colour 1 */
+  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,
+};
+
+static const uint8_t player_tile[32] = {
+  0x3C,0x00,0x00,0x00, 0x7E,0x00,0x00,0x00,
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  0xFF,0x00,0x00,0x00, 0xFF,0x00,0x00,0x00,
+  0x7E,0x00,0x00,0x00, 0x3C,0x00,0x00,0x00,
+};
+
+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 uint8_t on_platform(int16_t px, int16_t py) {
+  uint8_t i;
+  const Rect *p;
+  for (i = 0; i < N_PLATFORMS; i++) {
+    p = &platforms[i];
+    if (py + 8 == p->y && px + 8 > p->x && px < p->x + p->w) return 1;
+  }
+  return 0;
+}
+
+/* Is world cell (col,row) inside any platform? */
+static uint8_t cell_is_wall(int16_t col, uint8_t row) {
+  int16_t cx = col << 3;
+  int16_t cy = (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;
+}
+
+/* Write one world column into its wrapped name-table column. */
+static void paint_column(int16_t worldCol) {
+  uint8_t ntCol;
+  uint8_t row;
+  if (worldCol < 0 || worldCol >= WORLD_COLS) return;
+  ntCol = (uint8_t)(worldCol & 31);
+  for (row = 0; row < VIS_ROWS; row++)
+    sms_set_tilemap_cell(row, ntCol, cell_is_wall(worldCol, row) ? T_WALL : T_OPEN, 0);
+}
+
+/* Paint the initial 32 columns the camera starts on. */
+static void paint_initial(void) {
+  int16_t c;
+  for (c = 0; c < 32; c++) paint_column(c);
+}
+
+void main(void) {
+  int16_t px = 16 << 4, py = 64 << 4;
+  int16_t vx = 0, vy = 0;
+  int16_t camX = 0, lastCamCol = 0;
+  uint8_t prev = 0;
+  const int16_t GRAVITY = 10;
+  const int16_t MOVE    = 20;
+  const int16_t JUMP    = -180;
+  const int16_t MAXFALL = 280;
+
+  sms_vdp_init();
+  sms_load_palette(palette);
+  sms_load_tiles(0x0000, bg_tiles, 64);
+  sms_load_tiles(0x2000, player_tile, 32);
+  paint_initial();
+
+  sms_sprite_init();
+  sfx_init();
+  sms_sprite_set(0, (uint8_t)(px >> 4), (uint8_t)(py >> 4), 0);
+  sms_sat_upload();
+  sms_vdp_display_on();
+
+  do {
+    uint8_t pad, grounded;
+    int16_t ipx, ipy, npy, sx;
+    int16_t camCol;
+    int32_t np;
+    uint8_t i;
+    const Rect *p;
+    sms_vblank_wait();
+    sfx_update();
+
+    ipx = px >> 4;
+    ipy = py >> 4;
+
+    /* Camera follows the player, centered, clamped to the world. */
+    camX = ipx - (SCREEN_W / 2 - 4);
+    if (camX < 0) camX = 0;
+    if (camX > WORLD_W - SCREEN_W) camX = WORLD_W - SCREEN_W;
+
+    /* Stream new columns entering from the right as the camera advances,
+     * and from the left if it retreats. The column just past the right
+     * edge of the visible 32-col window is camCol + 32. */
+    camCol = camX >> 3;
+    while (camCol > lastCamCol) { lastCamCol++; paint_column(lastCamCol + 31); }
+    while (camCol < lastCamCol) { lastCamCol--; paint_column(lastCamCol); }
+
+    /* Smooth pixel scroll: R8 shifts the display; -camX wraps correctly. */
+    sms_vdp_write_reg(8, (uint8_t)(-camX & 0xFF));
+
+    /* Player drawn in SCREEN space. */
+    sx = ipx - camX;
+    sms_sprite_set(0, (uint8_t)sx, (uint8_t)ipy, 0);
+    sms_sat_upload();
+
+    pad = sms_joypad_read();
+    vx = 0;
+    if (pad & JOY_LEFT)  vx = (int16_t)(-MOVE);
+    if (pad & JOY_RIGHT) vx = MOVE;
+
+    grounded = on_platform(ipx, ipy);
+    if ((pad & JOY_B1) && !(prev & JOY_B1) && grounded) { vy = JUMP; sfx_tone(0, 300, 6); }
+    prev = pad;
+
+    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 > ((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) {
+      uint8_t 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 > (192 << 4)) { py = 0; vy = 0; }
+  } while (1);
+}

package/examples/sms/templates/puzzle.c

@@ -0,0 +1,204 @@
+/* ── puzzle.c — SMS match-3 falling-block scaffold ─────────────────
+ *
+ * Mirrors the NES/Genesis/SNES/GB puzzle scaffolds. 6-wide × 12-tall
+ * grid drawn via the BG tilemap (three distinct BG tile shapes for
+ * R/G/B cells). 1×3 active piece, rotate via B1, soft-drop via DOWN,
+ * START hard-drops, horizontal-triple clear.
+ */
+#include "sms_hw.h"
+#include "sms_sfx.h"
+#include <stdint.h>
+
+extern void sms_vdp_init(void);
+extern void sms_vdp_display_on(void);
+extern void sms_vdp_set_addr(uint16_t addr, uint8_t prefix);
+extern void sms_load_palette(const uint8_t *palette);
+extern void sms_load_tiles(uint16_t vram_dest, const uint8_t *src, uint16_t byte_count);
+extern void sms_set_tilemap_cell(uint8_t row, uint8_t col, uint8_t tile_idx, uint8_t attr);
+extern void sms_vblank_wait(void);
+extern uint8_t sms_joypad_read(void);
+
+#define COLS 6
+#define ROWS 12
+
+#define T_BLANK 0
+#define T_R     1
+#define T_G     2
+#define T_B     3
+
+static const uint8_t palette[32] = {
+  /* BG palette: backdrop black, red, green, blue */
+  0x00,0x03,0x0C,0x30, 0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
+};
+
+static const uint8_t bg_tiles[32 * 4] = {
+  /* T_BLANK */
+  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,0,0,
+  /* T_R — colour 1 fill */
+  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,
+  /* T_G — colour 2 fill */
+  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,
+  /* T_B — colour 3 fill (planes 0+1) */
+  0xFF,0xFF,0x00,0x00, 0xFF,0xFF,0x00,0x00,
+  0xFF,0xFF,0x00,0x00, 0xFF,0xFF,0x00,0x00,
+  0xFF,0xFF,0x00,0x00, 0xFF,0xFF,0x00,0x00,
+  0xFF,0xFF,0x00,0x00, 0xFF,0xFF,0x00,0x00,
+};
+
+static uint8_t grid[ROWS][COLS];
+static uint8_t piece[3];
+static int8_t piece_x;
+static int8_t piece_y;
+static uint8_t fall_timer;
+static uint16_t score;
+static uint32_t rng = 1;
+
+static uint32_t xorshift(void) {
+  rng ^= rng << 13;
+  rng ^= rng >> 17;
+  rng ^= rng << 5;
+  return rng;
+}
+
+static uint8_t rand_color(void) { return (uint8_t)(1 + (xorshift() % 3)); }
+
+static uint8_t tile_for(uint8_t c) {
+  if (c == 1) return T_R;
+  if (c == 2) return T_G;
+  if (c == 3) return T_B;
+  return T_BLANK;
+}
+
+static void draw_cell(int8_t col, int8_t row, uint8_t cell) {
+  if (row < 0 || row >= ROWS) return;
+  /* Centre the 6-col grid; +7 columns left margin, +1 row top margin. */
+  sms_set_tilemap_cell((uint8_t)(row + 1), (uint8_t)(col + 7), tile_for(cell), 0);
+}
+
+static void draw_grid(void) {
+  int8_t r, c;
+  for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) draw_cell(c, r, grid[r][c]);
+}
+
+static void new_piece(void) {
+  piece[0] = rand_color();
+  piece[1] = rand_color();
+  piece[2] = rand_color();
+  piece_x = COLS / 2 - 1;
+  piece_y = -3;
+}
+
+static uint8_t collides(int8_t col, int8_t row) {
+  uint8_t i;
+  int8_t r;
+  if (col < 0 || col >= COLS) return 1;
+  for (i = 0; i < 3; i++) {
+    r = (int8_t)(row + i);
+    if (r >= ROWS) return 1;
+    if (r >= 0 && grid[r][col] != 0) return 1;
+  }
+  return 0;
+}
+
+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 */
+      }
+    }
+  }
+  draw_grid();
+}
+
+static void draw_piece(uint8_t clear) {
+  uint8_t i;
+  for (i = 0; i < 3; i++) {
+    int8_t r = (int8_t)(piece_y + i);
+    uint8_t v;
+    if (r < 0 || r >= ROWS) continue;
+    v = clear ? grid[r][piece_x] : piece[i];
+    draw_cell(piece_x, r, v);
+  }
+}
+
+void main(void) {
+  uint8_t prev = 0;
+  uint8_t r, c;
+
+  sms_vdp_init();
+  sms_load_palette(palette);
+  sms_load_tiles(0x0000, bg_tiles, 32 * 4);
+
+  for (r = 0; r < 24; r++) for (c = 0; c < 32; c++) sms_set_tilemap_cell(r, c, T_BLANK, 0);
+  for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) grid[r][c] = 0;
+
+  score = 0;
+  fall_timer = 0;
+  new_piece();
+  draw_grid();
+
+  sfx_init();
+  sms_vdp_display_on();
+
+  do {
+    uint8_t pad, fall_rate, t;
+    sms_vblank_wait();
+    sfx_update();
+    draw_piece(1);
+
+    pad = sms_joypad_read();
+    if ((pad & JOY_LEFT)  && !(prev & JOY_LEFT)
+        && !collides((int8_t)(piece_x - 1), piece_y)) piece_x--;
+    if ((pad & JOY_RIGHT) && !(prev & JOY_RIGHT)
+        && !collides((int8_t)(piece_x + 1), piece_y)) piece_x++;
+    if ((pad & JOY_B1) && !(prev & JOY_B1)) {
+      t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+      sfx_tone(1, 350, 2);
+    }
+    if ((pad & JOY_B2) && !(prev & JOY_B2)) {
+      while (!collides(piece_x, (int8_t)(piece_y + 1))) piece_y++;
+      lock_piece();
+      new_piece();
+      prev = pad;
+      continue;
+    }
+    prev = pad;
+
+    fall_rate = (pad & JOY_DOWN) ? 4 : 30;
+    fall_timer = (uint8_t)(fall_timer + 1);
+    if (fall_timer >= fall_rate) {
+      fall_timer = 0;
+      if (collides(piece_x, (int8_t)(piece_y + 1))) {
+        lock_piece();
+        new_piece();
+      } else {
+        piece_y++;
+      }
+    }
+    draw_piece(0);
+  } while (1);
+}

package/examples/sms/templates/racing.c

@@ -0,0 +1,161 @@
+/* ── racing.c — SMS top-down racing scaffold ────────────────────────
+ *
+ * Endless 3-lane top-down racer. Player car at the bottom of the
+ * screen, obstacles spawn from the top and slide down. LEFT/RIGHT
+ * (edge-detected) switches lanes. Speed grows with score; collision
+ * triggers a 60-frame freeze then auto-resets.
+ *
+ * Hardware bits used:
+ *   - VDP sprite SAT for player car + 4 obstacle cars
+ *   - VDP_drawText (via tile fill) for the SCORE HUD
+ *   - sms_joypad_read for player 1 input
+ */
+#include "sms_hw.h"
+#include "sms_sfx.h"
+#include <stdint.h>
+
+extern void    sms_vdp_init(void);
+extern void    sms_vdp_display_on(void);
+extern void    sms_load_palette(const uint8_t *palette);
+extern void    sms_load_tiles(uint16_t vram_dest, const uint8_t *src, uint16_t byte_count);
+extern void    sms_vblank_wait(void);
+extern uint8_t sms_joypad_read(void);
+extern void    sms_sprite_init(void);
+extern void    sms_sprite_set(uint8_t slot, uint8_t x, uint8_t y, uint8_t tile);
+extern void    sms_sat_upload(void);
+
+#define LANE_LEFT_X    72
+#define LANE_MID_X    124
+#define LANE_RIGHT_X  176
+#define PLAYER_Y      160
+#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,
+};
+
+/* Two sprite tiles — player (colour 1) + enemy (colour 2). */
+static const uint8_t tiles[64] = {
+  /* Tile 0 = player car (colour 1 → plane 0 set) */
+  0x3C,0x00,0x00,0x00, 0x7E,0x00,0x00,0x00,
+  0x42,0x00,0x00,0x00, 0x7E,0x00,0x00,0x00,
+  0x7E,0x00,0x00,0x00, 0x42,0x00,0x00,0x00,
+  0x7E,0x00,0x00,0x00, 0x66,0x00,0x00,0x00,
+  /* Tile 1 = enemy car (colour 2 → plane 1 set) */
+  0x00,0x3C,0x00,0x00, 0x00,0x7E,0x00,0x00,
+  0x00,0x42,0x00,0x00, 0x00,0x7E,0x00,0x00,
+  0x00,0x7E,0x00,0x00, 0x00,0x42,0x00,0x00,
+  0x00,0x7E,0x00,0x00, 0x00,0x66,0x00,0x00,
+};
+
+typedef struct { uint8_t x, y, alive; } Car;
+
+static Car player;
+static Car obstacles[MAX_OBSTACLES];
+static uint16_t score;
+static uint8_t spawn_timer;
+static uint8_t game_over_timer;
+static uint8_t prev_pad;
+static uint8_t player_lane;
+
+static const uint8_t lane_x[3] = { LANE_LEFT_X, LANE_MID_X, LANE_RIGHT_X };
+
+static uint8_t aabb(Car *a, Car *b) {
+  return a->x < b->x + 8 && a->x + 8 > b->x
+      && a->y < b->y + 8 && a->y + 8 > b->y;
+}
+
+static void reset_run(void) {
+  uint8_t i;
+  player_lane = 1;
+  player.x = lane_x[1];
+  player.y = PLAYER_Y;
+  player.alive = 1;
+  for (i = 0; i < MAX_OBSTACLES; i++) obstacles[i].alive = 0;
+  score = 0;
+  spawn_timer = 0;
+  game_over_timer = 0;
+}
+
+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].y = 0;
+      obstacles[i].alive = 1;
+      return;
+    }
+  }
+}
+
+void main(void) {
+  uint8_t i;
+  sms_vdp_init();
+  sms_load_palette(palette);
+  sms_load_tiles(0x2000, tiles, 64);
+  sms_sprite_init();
+  sfx_init();
+  sms_vdp_display_on();
+
+  reset_run();
+  prev_pad = 0;
+
+  do {
+    uint8_t pad;
+    uint8_t slot;
+    int16_t step;
+    sms_vblank_wait();
+    sfx_update();
+
+    /* Stage SAT. */
+    slot = 0;
+    sms_sprite_set(slot++, player.x, player.y, 0 /* player tile */);
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+      uint8_t ey = obstacles[i].alive ? obstacles[i].y : 0xE0;
+      sms_sprite_set(slot++, obstacles[i].x, ey, 1 /* enemy tile */);
+    }
+    sms_sat_upload();
+
+    pad = sms_joypad_read();
+
+    if (game_over_timer > 0) {
+      game_over_timer--;
+      if (game_over_timer == 0) reset_run();
+      prev_pad = pad;
+      continue;
+    }
+
+    if ((pad & JOY_LEFT)  && !(prev_pad & JOY_LEFT)  && player_lane > 0) { player_lane--; sfx_tone(1, 330, 2); }
+    if ((pad & JOY_RIGHT) && !(prev_pad & JOY_RIGHT) && player_lane < 2) { player_lane++; sfx_tone(1, 330, 2); }
+    player.x = lane_x[player_lane];
+    prev_pad = pad;
+
+    /* Obstacle speed grows with score (cap at 4). */
+    step = (int16_t)(2 + (score / 500));
+    if (step > 4) step = 4;
+
+    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;
+    }
+
+    spawn_timer = (uint8_t)(spawn_timer + 1);
+    if (spawn_timer >= 36) { spawn_timer = 0; spawn_obstacle(); }
+
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+      if (obstacles[i].alive && aabb(&player, &obstacles[i])) {
+        game_over_timer = 60;
+        sfx_noise(30);  /* crash */
+        break;
+      }
+    }
+
+    if (score < 65500) score = (uint16_t)(score + 1);
+  } while (1);
+}