romdev-mcp 0.1.1

package/examples/gbc/templates/puzzle.c

@@ -0,0 +1,217 @@
+/* ── puzzle.c — Game Boy match-3 falling-block scaffold ─────────────
+ *
+ * Mirrors the NES/Genesis/SNES puzzle scaffolds. 6-wide × 12-tall
+ * grid drawn via BG tilemap (each cell = 1 BG tile). 1×3 vertical
+ * active piece; LEFT/RIGHT shifts, A rotates colour order, DOWN
+ * soft-drops, START hard-drops. Horizontal triples clear and score.
+ *
+ * On the Game Boy we don't have a built-in font, so we render the
+ * grid as coloured tile cells using three BG tile shapes (R/G/B
+ * stripes). Score is kept in WRAM; rendering a numeric HUD requires
+ * a digit-tile blob — left as an extension.
+ */
+
+#include "gb_hardware.h"
+#include "gb_runtime.h"
+
+#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 tile_blank[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+/* Three distinct tile shapes (since GB BG is 2bpp, we differentiate
+ * by *shape*, not colour-on-CGB). The CGB palette path could give us
+ * real colours; for DMG-compatibility we use shape. */
+static const uint8_t tile_r[16] = {
+    0xFF,0x00, 0xFF,0x00, 0xFF,0x00, 0xFF,0x00,
+    0xFF,0x00, 0xFF,0x00, 0xFF,0x00, 0xFF,0x00,
+};
+static const uint8_t tile_g[16] = {
+    0xAA,0x55, 0xAA,0x55, 0xAA,0x55, 0xAA,0x55,
+    0xAA,0x55, 0xAA,0x55, 0xAA,0x55, 0xAA,0x55,
+};
+static const uint8_t tile_b[16] = {
+    0x00,0xFF, 0x00,0xFF, 0x00,0xFF, 0x00,0xFF,
+    0x00,0xFF, 0x00,0xFF, 0x00,0xFF, 0x00,0xFF,
+};
+
+static const uint16_t bg_palette[4]  = { 0x7FFF, 0x5294, 0x294A, 0x0000 };
+
+static uint8_t grid[ROWS][COLS];
+static uint8_t piece[3];
+static int16_t piece_x, 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 random_colour(void) { return 1 + (xorshift() % 3); }
+
+static void new_piece(void) {
+    piece[0] = random_colour();
+    piece[1] = random_colour();
+    piece[2] = random_colour();
+    piece_x = COLS / 2 - 1;
+    piece_y = -3;
+}
+
+static uint8_t tile_for(uint8_t c) {
+    switch (c) {
+        case 1: return T_R;
+        case 2: return T_G;
+        case 3: return T_B;
+        default: return T_BLANK;
+    }
+}
+
+static void draw_cell(int16_t col, int16_t row, uint8_t cell) {
+    /* Map base $9800, 32 cells wide. Centre the 6-col grid → offset +7. */
+    uint8_t *map = (uint8_t *)0x9800;
+    if (row < 0 || row >= ROWS) return;
+    map[(row + 1) * 32 + (col + 7)] = tile_for(cell);
+}
+
+static void draw_grid(void) {
+    int16_t r, c;
+    for (r = 0; r < ROWS; r++)
+        for (c = 0; c < COLS; c++)
+            draw_cell(c, r, grid[r][c]);
+}
+
+static uint8_t collides(int16_t col, int16_t row) {
+    uint8_t i;
+    int16_t r;
+    if (col < 0 || col >= COLS) return 1;
+    for (i = 0; i < 3; i++) {
+        r = 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;
+    int16_t r;
+    int16_t c;
+    uint8_t a, b, d;
+    for (i = 0; i < 3; i++) {
+        r = piece_y + i;
+        if (r >= 0 && r < ROWS) grid[r][piece_x] = piece[i];
+    }
+    for (i = 0; i < 3; i++) {
+        r = 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 += 30;
+            }
+        }
+    }
+    draw_grid();
+}
+
+static void upload_tile(uint8_t slot, const uint8_t *src) {
+    uint8_t *dst = (uint8_t *)(0x8000 + slot * 16);
+    uint8_t i;
+    for (i = 0; i < 16; i++) dst[i] = src[i];
+}
+
+void main(void) {
+    uint8_t pad, prev = 0, fall_rate, t;
+    int16_t r, c;
+    uint8_t i;
+    uint8_t *map;
+    int16_t pr;
+
+    lcd_init_default();
+    LCDC = 0;
+
+    upload_tile(T_BLANK, tile_blank);
+    upload_tile(T_R,     tile_r);
+    upload_tile(T_G,     tile_g);
+    upload_tile(T_B,     tile_b);
+
+    BCPS = 0x80;
+    for (i = 0; i < 4; i++) {
+        BCPD = (uint8_t)(bg_palette[i] & 0xFF);
+        BCPD = (uint8_t)((bg_palette[i] >> 8) & 0xFF);
+    }
+
+    map = (uint8_t *)0x9800;
+    for (i = 0; i < 32; i++) {
+        c = 0;
+        while (c < 32) { map[i * 32 + c] = T_BLANK; c++; }
+    }
+
+    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();
+
+    LCDC = LCDC_LCD_ON | LCDC_BG_ON | LCDC_TILE_DATA_LO;
+
+    while (1) {
+        wait_vblank();
+
+        /* Erase current piece visual (overwrite with what's underneath). */
+        for (i = 0; i < 3; i++) {
+            pr = piece_y + i;
+            if (pr >= 0 && pr < ROWS)
+                draw_cell(piece_x, pr, grid[pr][piece_x]);
+        }
+
+        pad = joypad_read();
+
+        if ((pad & PAD_LEFT)  && !(prev & PAD_LEFT)
+            && !collides(piece_x - 1, piece_y)) piece_x--;
+        if ((pad & PAD_RIGHT) && !(prev & PAD_RIGHT)
+            && !collides(piece_x + 1, piece_y)) piece_x++;
+        if ((pad & PAD_A) && !(prev & PAD_A)) {
+            t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+        }
+        if ((pad & PAD_START) && !(prev & PAD_START)) {
+            while (!collides(piece_x, piece_y + 1)) piece_y++;
+            lock_piece();
+            new_piece();
+            prev = pad;
+            continue;
+        }
+        prev = pad;
+
+        fall_rate = (pad & PAD_DOWN) ? 4 : 30;
+        if (++fall_timer >= fall_rate) {
+            fall_timer = 0;
+            if (collides(piece_x, piece_y + 1)) {
+                lock_piece();
+                new_piece();
+            } else {
+                piece_y++;
+            }
+        }
+
+        /* Re-draw piece in new position. */
+        for (i = 0; i < 3; i++) {
+            pr = piece_y + i;
+            if (pr >= 0 && pr < ROWS) draw_cell(piece_x, pr, piece[i]);
+        }
+    }
+}

package/examples/gbc/templates/racing.c

@@ -0,0 +1,164 @@
+/* ── racing.c — Game Boy top-down racing scaffold ──────────────────
+ *
+ * Endless 3-lane top-down dodge for the Game Boy. LEFT/RIGHT switches
+ * lanes (edge-detected), obstacles slide down at speed = 2 + score/500
+ * (capped). Collision triggers a 60-frame freeze + auto-reset.
+ *
+ * Game Boy screen is 160×144 — 3 lanes centred around x = {48, 80, 112}.
+ */
+
+#include "gb_hardware.h"
+#include "gb_runtime.h"
+
+#define LANE_LEFT_X    40
+#define LANE_MID_X     76
+#define LANE_RIGHT_X  112
+#define PLAYER_Y      120
+#define MAX_OBSTACLES   4
+
+static const uint8_t tile_blank[16] = { 0 };
+static const uint8_t tile_car_p1[16] = {
+  0x3C,0x00, 0x7E,0x00, 0x42,0x00, 0x7E,0x00,
+  0x7E,0x00, 0x42,0x00, 0x7E,0x00, 0x66,0x00,
+};
+static const uint8_t tile_car_en[16] = {
+  0x00,0x3C, 0x00,0x7E, 0x00,0x42, 0x00,0x7E,
+  0x00,0x7E, 0x00,0x42, 0x00,0x7E, 0x00,0x66,
+};
+
+static const uint16_t obj_palette[4] = { 0x7FFF, 0x7FFF, 0x001F, 0x03E0 };
+static const uint16_t bg_palette[4]  = { 0x1842, 0x2945, 0x4A53, 0x7FFF };  /* asphalt → lane lines */
+
+typedef struct { int16_t x, y; uint8_t 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 int16_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;
+    }
+  }
+}
+
+static void upload_tile(uint8_t slot, const uint8_t *src) {
+  uint8_t *dst = (uint8_t *)(0x8000 + slot * 16);
+  uint8_t i;
+  for (i = 0; i < 16; i++) dst[i] = src[i];
+}
+
+void main(void) {
+  uint8_t pad;
+  uint8_t i;
+  int16_t step;
+
+  lcd_init_default();
+  LCDC = 0;
+
+  upload_tile(0, tile_blank);
+  upload_tile(1, tile_car_p1);
+  upload_tile(2, tile_car_en);
+
+  OCPS = 0x80;
+  for (i = 0; i < 4; i++) {
+    OCPD = (uint8_t)(obj_palette[i] & 0xFF);
+    OCPD = (uint8_t)((obj_palette[i] >> 8) & 0xFF);
+  }
+  BCPS = 0x80;
+  for (i = 0; i < 4; i++) {
+    BCPD = (uint8_t)(bg_palette[i] & 0xFF);
+    BCPD = (uint8_t)((bg_palette[i] >> 8) & 0xFF);
+  }
+
+  oam_clear();
+  LCDC = LCDC_LCD_ON | LCDC_OBJ_ON | LCDC_TILE_DATA_LO;
+  sound_init();
+
+  reset_run();
+  prev_pad = 0;
+
+  while (1) {
+    wait_vblank();
+
+    /* Stage OAM — player + obstacles. */
+    for (i = 0; i < 40; i++) oam_set(i, 0, 0, 0, 0);
+    oam_set(0, (uint8_t)(player.y + 16), (uint8_t)(player.x + 8), 1, 0);
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+      if (obstacles[i].alive) {
+        oam_set((uint8_t)(1 + i),
+                (uint8_t)(obstacles[i].y + 16),
+                (uint8_t)(obstacles[i].x + 8),
+                2, 0);
+      }
+    }
+    oam_dma_flush();
+
+    pad = joypad_read();
+    if (game_over_timer > 0) {
+      game_over_timer--;
+      if (game_over_timer == 0) reset_run();
+      prev_pad = pad;
+      continue;
+    }
+
+    if ((pad & PAD_LEFT)  && !(prev_pad & PAD_LEFT)  && player_lane > 0) {
+      player_lane--;
+      sound_play_tone(2, 1700, 3);
+    }
+    if ((pad & PAD_RIGHT) && !(prev_pad & PAD_RIGHT) && player_lane < 2) {
+      player_lane++;
+      sound_play_tone(2, 1700, 3);
+    }
+    player.x = lane_x[player_lane];
+    prev_pad = pad;
+
+    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 = (int16_t)(obstacles[i].y + step);
+      if (obstacles[i].y >= 144) obstacles[i].alive = 0;
+    }
+    spawn_timer++;
+    if (spawn_timer >= 36) { spawn_timer = 0; spawn_obstacle(); }
+
+    for (i = 0; i < MAX_OBSTACLES; i++) {
+      if (obstacles[i].alive && aabb(&player, &obstacles[i])) {
+        sound_play_noise(8);
+        game_over_timer = 60;
+        break;
+      }
+    }
+    if (score < 65500) score++;
+  }
+}

package/examples/gbc/templates/shmup.c

@@ -0,0 +1,188 @@
+/* ── shmup.c — Game Boy vertical-shooter scaffold ────────────────────
+ *
+ * Mirrors the NES/Genesis/SNES shmup scaffolds for the Game Boy:
+ *   - Player ship at OAM slot 0
+ *   - 4 bullet slots, 4 enemy slots (smaller pools for the Game Boy's
+ *     40-sprite hard cap — total = 9, leaves plenty of headroom)
+ *   - Wave spawner every ~28 frames
+ *   - Linear movement, AABB collision (8×8 vs 8×8)
+ *   - Score rendered to OAM digits would need a font tile blob; we
+ *     keep a running u16 score in WRAM for now — extend with BG-map
+ *     text rendering when you wire a font.
+ *
+ * GB OAM coords are HARDWARE coords: visible Y range is 16..160,
+ * visible X range is 8..168. Y=0 hides the sprite (off-screen).
+ */
+
+#include "gb_hardware.h"
+#include "gb_runtime.h"
+
+#define MAX_BULLETS 4
+#define MAX_ENEMIES 4
+
+static const uint8_t tile_blank[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+static const uint8_t tile_ship[16] = {
+    0x18,0x18, 0x3C,0x3C, 0x7E,0x7E, 0xFF,0xFF,
+    0xFF,0xFF, 0x7E,0x7E, 0x3C,0x3C, 0x18,0x18,
+};
+static const uint8_t tile_bullet[16] = {
+    0x00,0x00, 0x18,0x18, 0x3C,0x3C, 0x3C,0x3C,
+    0x3C,0x3C, 0x3C,0x3C, 0x18,0x18, 0x00,0x00,
+};
+static const uint8_t tile_enemy[16] = {
+    0x81,0x81, 0x42,0x42, 0x24,0x24, 0xFF,0xFF,
+    0xFF,0xFF, 0x24,0x24, 0x42,0x42, 0x81,0x81,
+};
+
+static const uint16_t obj_palette[4] = {
+    0x7FFF, /* 0 transparent */
+    0x7FFF, /* 1 white   — player ship */
+    0x03FF, /* 2 yellow  — bullets */
+    0x001F, /* 3 red     — enemies */
+};
+
+/* CGB BG palette 0 — used for the dark-blue starfield background. */
+static const uint16_t bg_palette[4] = {
+    0x2842, /* 0 deep space blue */
+    0x4A52, /* 1 mid blue */
+    0x6B5A, /* 2 light blue (stars) */
+    0x7FFF, /* 3 white (highlight) */
+};
+
+typedef struct { uint8_t x, y, alive; } Obj;
+
+static Obj player;
+static Obj bullets[MAX_BULLETS];
+static Obj enemies[MAX_ENEMIES];
+static uint16_t score;
+static uint8_t spawn_timer;
+
+static uint8_t aabb(Obj *a, Obj *b) {
+    /* Coord conversion: sprites are stored in screen coords here
+     * (px..px+8) NOT hardware coords. We translate to hardware in OAM. */
+    return a->x < b->x + 8 && a->x + 8 > b->x
+        && a->y < b->y + 8 && a->y + 8 > b->y;
+}
+
+static void fire(void) {
+    uint8_t i;
+    for (i = 0; i < MAX_BULLETS; i++) {
+        if (!bullets[i].alive) {
+            bullets[i].x = player.x;
+            bullets[i].y = player.y - 8;
+            bullets[i].alive = 1;
+            return;
+        }
+    }
+}
+
+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].y = 0;
+            enemies[i].alive = 1;
+            return;
+        }
+    }
+}
+
+static void upload_tile(uint8_t slot, const uint8_t *src) {
+    uint8_t *dst = (uint8_t *)(0x8000 + slot * 16);
+    uint8_t i;
+    for (i = 0; i < 16; i++) dst[i] = src[i];
+}
+
+void main(void) {
+    uint8_t pad, prev = 0;
+    uint8_t i, j;
+
+    lcd_init_default();
+    LCDC = 0;
+
+    upload_tile(0, tile_blank);
+    upload_tile(1, tile_ship);
+    upload_tile(2, tile_bullet);
+    upload_tile(3, tile_enemy);
+
+    /* Sprite palette 0 — uploaded to OCPS/OCPD (CGB-only registers). */
+    OCPS = 0x80;
+    for (i = 0; i < 4; i++) {
+        OCPD = (uint8_t)(obj_palette[i] & 0xFF);
+        OCPD = (uint8_t)((obj_palette[i] >> 8) & 0xFF);
+    }
+
+    /* BG palette 0 — starfield background colors. */
+    BCPS = 0x80;
+    for (i = 0; i < 4; i++) {
+        BCPD = (uint8_t)(bg_palette[i] & 0xFF);
+        BCPD = (uint8_t)((bg_palette[i] >> 8) & 0xFF);
+    }
+
+    player.x = 76; player.y = 130; player.alive = 1;
+    for (i = 0; i < MAX_BULLETS; i++) bullets[i].alive = 0;
+    for (i = 0; i < MAX_ENEMIES; i++) enemies[i].alive = 0;
+    score = 0;
+    spawn_timer = 0;
+
+    oam_clear();
+    LCDC = LCDC_LCD_ON | LCDC_OBJ_ON | LCDC_TILE_DATA_LO;
+    sound_init();
+
+    while (1) {
+        wait_vblank();
+
+        /* Stage OAM for this frame BEFORE we update game state — the
+         * shadow OAM gets DMA'd next vblank. */
+        for (i = 0; i < 40; i++) oam_set(i, 0, 0, 0, 0);
+        oam_set(0, player.y + 16, player.x + 8, 1, 0);
+        for (i = 0; i < MAX_BULLETS; i++) {
+            if (bullets[i].alive)
+                oam_set(1 + i, bullets[i].y + 16, bullets[i].x + 8, 2, 0);
+        }
+        for (i = 0; i < MAX_ENEMIES; i++) {
+            if (enemies[i].alive)
+                oam_set(5 + i, enemies[i].y + 16, enemies[i].x + 8, 3, 0);
+        }
+        oam_dma_flush();
+
+        pad = joypad_read();
+
+        if (pad & PAD_LEFT  && player.x > 0)        player.x -= 2;
+        if (pad & PAD_RIGHT && player.x < 160 - 8)  player.x += 2;
+        if (pad & PAD_UP    && player.y > 0)        player.y -= 2;
+        if (pad & PAD_DOWN  && player.y < 144 - 8)  player.y += 2;
+        if ((pad & PAD_A) && !(prev & PAD_A)) {
+            fire();
+            sound_play_tone(2, 1900, 4);
+        }
+        prev = pad;
+
+        for (i = 0; i < MAX_BULLETS; i++) {
+            if (!bullets[i].alive) continue;
+            if (bullets[i].y < 4) { bullets[i].alive = 0; continue; }
+            bullets[i].y -= 4;
+        }
+        for (i = 0; i < MAX_ENEMIES; i++) {
+            if (!enemies[i].alive) continue;
+            enemies[i].y += 1;
+            if (enemies[i].y >= 144) enemies[i].alive = 0;
+        }
+        if (++spawn_timer >= 28) { spawn_timer = 0; spawn(); }
+
+        for (i = 0; i < MAX_BULLETS; i++) {
+            if (!bullets[i].alive) continue;
+            for (j = 0; j < MAX_ENEMIES; j++) {
+                if (!enemies[j].alive) continue;
+                if (aabb(&bullets[i], &enemies[j])) {
+                    bullets[i].alive = 0;
+                    enemies[j].alive = 0;
+                    if (score < 65500) score += 10;
+                    sound_play_noise(6);
+                    break;
+                }
+            }
+        }
+    }
+}

package/examples/gbc/templates/sports.c

@@ -0,0 +1,142 @@
+/* ── sports.c — Game Boy Pong scaffold (player-vs-AI) ─────────────────
+ *
+ * The Game Boy hardware has ONE controller port — no native two-player
+ * support without the Link Cable + custom serial code. So "sports" on
+ * GB is single-controller player-vs-AI Pong: left paddle is the human
+ * (UP/DOWN on port 0), right paddle chases the ball.
+ *
+ * Same gameplay shape as the NES / SMS / Genesis 2P versions — just
+ * with the AI permanently driving port 1.
+ *
+ * Game Boy screen is 160×144. Court spans the full visible area.
+ */
+
+#include "gb_hardware.h"
+#include "gb_runtime.h"
+
+#define COURT_TOP   8
+#define COURT_BOT   136
+#define PADDLE_H    16
+#define BALL_SIZE   8
+#define PADDLE_X1   16
+#define PADDLE_X2   136
+
+static const uint8_t tile_blank[16] = { 0 };
+/* Solid 8×8 block (white on DMG, colour 1 on CGB). */
+static const uint8_t tile_solid[16] = {
+  0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF,
+  0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF,
+};
+
+static const uint16_t obj_palette[4] = { 0x7FFF, 0x001F, 0x03E0, 0x7C00 };
+static const uint16_t bg_palette[4]  = { 0x2104, 0x294A, 0x4631, 0x7FFF };  /* deep court green */
+
+static int16_t p1y, p2y, bx, by;
+static int8_t  bdx, bdy;
+static uint8_t score_p1, score_p2;
+static uint8_t serve_timer;
+
+static void serve_ball(uint8_t to_left) {
+  bx = 76;
+  by = 68;
+  bdx = to_left ? -2 : 2;
+  bdy = ((score_p1 + score_p2) & 1) ? -1 : 1;
+  serve_timer = 30;
+}
+
+static void reset_match(void) {
+  p1y = 64;
+  p2y = 64;
+  score_p1 = 0;
+  score_p2 = 0;
+  serve_ball(0);
+}
+
+static void upload_tile(uint8_t slot, const uint8_t *src) {
+  uint8_t *dst = (uint8_t *)(0x8000 + slot * 16);
+  uint8_t i;
+  for (i = 0; i < 16; i++) dst[i] = src[i];
+}
+
+void main(void) {
+  uint8_t pad;
+  uint8_t i;
+  int16_t target;
+
+  lcd_init_default();
+  LCDC = 0;
+
+  upload_tile(0, tile_blank);
+  upload_tile(1, tile_solid);
+
+  OCPS = 0x80;
+  for (i = 0; i < 4; i++) {
+    OCPD = (uint8_t)(obj_palette[i] & 0xFF);
+    OCPD = (uint8_t)((obj_palette[i] >> 8) & 0xFF);
+  }
+  BCPS = 0x80;
+  for (i = 0; i < 4; i++) {
+    BCPD = (uint8_t)(bg_palette[i] & 0xFF);
+    BCPD = (uint8_t)((bg_palette[i] >> 8) & 0xFF);
+  }
+
+  oam_clear();
+  LCDC = LCDC_LCD_ON | LCDC_OBJ_ON | LCDC_TILE_DATA_LO;
+  sound_init();
+
+  reset_match();
+
+  while (1) {
+    wait_vblank();
+
+    /* Stage OAM: left paddle (2 stacked), right paddle (2 stacked), ball. */
+    for (i = 0; i < 40; i++) oam_set(i, 0, 0, 0, 0);
+    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;
+    if (pad & PAD_DOWN  && p1y < COURT_BOT - PADDLE_H) p1y += 2;
+
+    /* Right-paddle AI — chase ball Y. */
+    target = by - PADDLE_H / 2;
+    if (p2y < target && p2y < COURT_BOT - PADDLE_H) p2y += 1;
+    else if (p2y > target && p2y > COURT_TOP)       p2y -= 1;
+
+    if (serve_timer > 0) {
+      serve_timer--;
+    } else {
+      bx = (int16_t)(bx + bdx);
+      by = (int16_t)(by + bdy);
+
+      if (by < COURT_TOP)             { by = COURT_TOP; bdy = (int8_t)(-bdy); }
+      if (by + BALL_SIZE > COURT_BOT) { by = COURT_BOT - BALL_SIZE; bdy = (int8_t)(-bdy); }
+
+      if (bdx < 0
+          && bx <= PADDLE_X1 + 8
+          && bx + BALL_SIZE >= PADDLE_X1
+          && by + BALL_SIZE > p1y
+          && by < p1y + PADDLE_H) {
+        bdx = (int8_t)(-bdx);
+        bx = PADDLE_X1 + 8;
+        sound_play_tone(2, 1900, 4);
+      }
+      if (bdx > 0
+          && bx + BALL_SIZE >= PADDLE_X2
+          && bx <= PADDLE_X2 + 8
+          && by + BALL_SIZE > p2y
+          && by < p2y + PADDLE_H) {
+        bdx = (int8_t)(-bdx);
+        bx = PADDLE_X2 - BALL_SIZE;
+        sound_play_tone(2, 1900, 4);
+      }
+
+      if (bx < 4)   { if (score_p2 < 9) score_p2++; sound_play_noise(8); serve_ball(0); }
+      if (bx > 156) { if (score_p1 < 9) score_p1++; sound_play_noise(8); serve_ball(1); }
+    }
+  }
+}