romdev-mcp 0.1.1

package/examples/lynx/templates/sports.c

@@ -0,0 +1,59 @@
+// ── sports.c — Atari Lynx Pong vs AI ─────────────────────────────────
+//
+// Lynx is a handheld with one controller. Right paddle = AI tracking
+// the ball.
+
+#include <tgi.h>
+#include <joystick.h>
+#include <lynx.h>
+#include <stdint.h>
+#include "lynx_sfx.h"
+
+#define PADDLE_H 16
+#define PADDLE_W 3
+#define BALL_SIZE 4
+#define COURT_TOP 4
+#define COURT_BOT 96
+#define PADDLE_X1 6
+#define PADDLE_X2 (160 - 6 - PADDLE_W)
+
+void main(void) {
+  int16_t p1y = 40, p2y = 40, bx = 78, by = 48;
+  int8_t bdx = 2, bdy = 1;
+  uint8_t joy;
+
+  tgi_install(&lynx_160_102_16_tgi);
+  tgi_init();
+  joy_install(&lynx_stdjoy_joy);
+  sfx_init();
+
+  for (;;) {
+    tgi_clear();
+    tgi_setcolor(COLOR_WHITE);
+    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_bar((unsigned)bx, (unsigned)by, (unsigned)(bx + BALL_SIZE - 1), (unsigned)(by + BALL_SIZE - 1));
+    tgi_updatedisplay();
+    sfx_update();
+
+    joy = joy_read(JOY_1);
+    if (JOY_UP(joy)   && p1y > COURT_TOP)             p1y -= 2;
+    if (JOY_DOWN(joy) && p1y < COURT_BOT - PADDLE_H)  p1y += 2;
+
+    /* AI */
+    if (p2y + PADDLE_H/2 < by && p2y < COURT_BOT - PADDLE_H) p2y++;
+    else if (p2y + PADDLE_H/2 > by && p2y > COURT_TOP)       p2y--;
+
+    bx += bdx;
+    by += bdy;
+    if (by < COURT_TOP)              { by = COURT_TOP; bdy = -bdy; sfx_tone(2, 90, 2); }
+    if (by + BALL_SIZE > COURT_BOT)  { by = COURT_BOT - BALL_SIZE; bdy = -bdy; sfx_tone(2, 90, 2); }
+    if (bdx < 0 && bx <= PADDLE_X1 + PADDLE_W && bx + BALL_SIZE >= PADDLE_X1
+        && by + BALL_SIZE > p1y && by < p1y + PADDLE_H) { bdx = -bdx; sfx_tone(0, 70, 3); }
+    if (bdx > 0 && bx + BALL_SIZE >= PADDLE_X2 && bx <= PADDLE_X2 + PADDLE_W
+        && by + BALL_SIZE > p2y && by < p2y + PADDLE_H) { bdx = -bdx; sfx_tone(0, 70, 3); }
+    if (bx < -BALL_SIZE) { bx = 78; by = 48; bdx = 2; sfx_noise(20); }
+    if (bx > 160)        { bx = 78; by = 48; bdx = -2; sfx_tone(0, 50, 12); }
+  }
+}

package/examples/nes/main.c

@@ -0,0 +1,143 @@
+/* Hello, NES — a real hello-world scaffold, not just while(1) {}.
+ *
+ * What this does:
+ *   1. Disables PPU during init (avoids race with first frame).
+ *   2. Uploads a 4-color palette.
+ *   3. Writes a single 8x8 tile (a yellow 'H') into CHR-RAM.
+ *   4. Drops a single sprite into shadow OAM ($0200..) — the NMI
+ *      handler DMAs it to the PPU every vblank.
+ *   5. Enables the PPU and loops forever (NMI does all the real work).
+ *
+ * BUILD: this file expects linkerConfig: "chr-ram" so the CHR-RAM
+ * region is writable at runtime. Pass it to buildSource:
+ *
+ *   buildSource({
+ *     platform: "nes",
+ *     language: "c",
+ *     linkerConfig: "chr-ram",
+ *     sources: {
+ *       "main.c": <this file>,
+ *     },
+ *   });
+ *
+ * The chr-ram preset auto-includes a custom crt0 that emits an iNES
+ * header with CHR-RAM=0, points the NMI vector at a `nmi: rti` stub.
+ * To install a real NMI handler, add nmi_handler.c + nmi_trampoline.s
+ * from getStarterSnippet and modify the crt0 to drop its `nmi:` line
+ * (see those snippets' comments for the exact edits).
+ *
+ * cc65 IS C89: declare loop variables at the top of blocks, no //
+ * comments inside some contexts, no s16/uint64_t (cc65 stdint.h covers
+ * uint8/16/32 and int8/16/32 only). Use C89 idioms or you'll get
+ * 200+ errors on first build.
+ */
+
+#include <stdint.h>
+
+/* PPU registers. */
+#define PPUCTRL    (*(volatile uint8_t*)0x2000)
+#define PPUMASK    (*(volatile uint8_t*)0x2001)
+#define PPUSTATUS  (*(volatile uint8_t*)0x2002)
+#define PPUADDR    (*(volatile uint8_t*)0x2006)
+#define PPUDATA    (*(volatile uint8_t*)0x2007)
+#define OAMADDR    (*(volatile uint8_t*)0x2003)
+#define OAMDMA     (*(volatile uint8_t*)0x4014)
+
+/* Shadow OAM — DMA'd to PPU sprite RAM every vblank by the NMI. */
+#pragma bss-name(push, "OAM")
+uint8_t oam[256];
+#pragma bss-name(pop)
+
+/* Tile 1 — an 8x8 'H' glyph. NES tiles are 2bpp (16 bytes per tile:
+ * 8 bytes plane 0, 8 bytes plane 1). For a 1-color glyph we use plane
+ * 0 only; plane 1 is all zeros. */
+static const uint8_t tile_H[16] = {
+    /* plane 0: shape */
+    0b10000010,
+    0b10000010,
+    0b10000010,
+    0b11111110,
+    0b10000010,
+    0b10000010,
+    0b10000010,
+    0b00000000,
+    /* plane 1: empty (color stays in palette 0) */
+    0,0,0,0,0,0,0,0,
+};
+
+/* Palette: 4 colors per palette × 4 sprite palettes + 4 BG palettes. */
+static const uint8_t palette[32] = {
+    /* BG palette 0..3 (4 colors each) */
+    0x0F, 0x30, 0x10, 0x00,   /* gray-on-white */
+    0x0F, 0x21, 0x11, 0x01,   /* blue */
+    0x0F, 0x27, 0x17, 0x07,   /* orange */
+    0x0F, 0x2A, 0x1A, 0x0A,   /* green */
+    /* Sprite palette 0..3 (color 0 is transparent) */
+    0x0F, 0x28, 0x18, 0x08,   /* yellow — used by our sprite */
+    0x0F, 0x21, 0x11, 0x01,
+    0x0F, 0x27, 0x17, 0x07,
+    0x0F, 0x2A, 0x1A, 0x0A,
+};
+
+static void wait_vblank(void) {
+    /* Spin until bit 7 of PPUSTATUS is set, then reset latch. */
+    while ((PPUSTATUS & 0x80) == 0) { /* wait */ }
+}
+
+static void ppu_addr(uint16_t a) {
+    PPUSTATUS;             /* clear address latch */
+    PPUADDR = (uint8_t)(a >> 8);
+    PPUADDR = (uint8_t)(a & 0xFF);
+}
+
+void main(void) {
+    uint16_t i;
+
+    /* 1. Initial PPU off — disable rendering, NMI, IRQ. */
+    PPUCTRL = 0;
+    PPUMASK = 0;
+
+    /* 2. Wait two vblanks (NES init protocol — PPU warm-up). */
+    wait_vblank();
+    wait_vblank();
+
+    /* 3. Upload our tile to CHR-RAM at $0010 (tile index 1, sprite table). */
+    ppu_addr(0x0010);
+    for (i = 0; i < 16; i++) PPUDATA = tile_H[i];
+
+    /* 4. Upload palette to $3F00. */
+    ppu_addr(0x3F00);
+    for (i = 0; i < 32; i++) PPUDATA = palette[i];
+
+    /* 5. Init shadow OAM: hide all sprites (Y = $FF moves off screen). */
+    for (i = 0; i < 256; i += 4) {
+        oam[i + 0] = 0xFF;  /* Y */
+        oam[i + 1] = 0;     /* tile */
+        oam[i + 2] = 0;     /* attr */
+        oam[i + 3] = 0;     /* X */
+    }
+    /* Drop sprite 0 in the middle of the screen, using tile 1, sprite palette 0. */
+    oam[0] = 110;     /* Y */
+    oam[1] = 0x01;    /* tile index */
+    oam[2] = 0x00;    /* attrs: palette 0, no flip, in front */
+    oam[3] = 124;     /* X */
+
+    /* 6. Reset scroll. */
+    ppu_addr(0x2000);
+    PPUSTATUS;
+    /* Scroll regs would go here (write to $2005) if we wanted to scroll. */
+
+    /* 7. One-shot OAM DMA now (NMI will keep doing this every frame
+     *    if you install an NMI handler — see nmi_handler.c). */
+    OAMADDR = 0;
+    OAMDMA = 0x02;  /* DMA from $0200 */
+
+    /* 8. Enable rendering: show sprites, leftmost 8px shown. */
+    PPUMASK = 0x1E;
+    /* PPUCTRL = $80 to enable NMI; leaving disabled for this minimal
+     * scaffold so vblank doesn't fire (we don't have an NMI handler
+     * installed). The screen will just sit showing the sprite.
+     * Add NMI later via nmi_handler.c. */
+
+    while (1) { /* park here forever */ }
+}

package/examples/nes/space-shooter/README.md

@@ -0,0 +1,68 @@
+# NES space-shooter — canonical "NES-shaped C" reference
+
+A complete, runnable NES game in C (~440 lines) — a generic fixed-shooter
+(player cannon vs. a descending alien grid, with shields and a HUD) that
+demonstrates how to work *within* the NES's hard constraints instead of
+fighting them. Fork this when you want a real game structure, not just a
+hello-world. (Original example in the shoot-the-aliens *genre* — not a clone of
+any specific commercial title.)
+
+## Build
+
+```
+buildSource({
+  platform: "nes",
+  language: "c",
+  sources: { "main.c": ..., "nes_runtime.c": ... },
+  includes: { "nes_runtime.h": ... },
+  linkerConfig: "chr-ram-runtime"
+})
+```
+
+Use the **`chr-ram-runtime`** preset (not bare `chr-ram`): it bundles the crt0
+(iNES header + reset vector), the NMI handler that DMAs shadow OAM each vblank,
+and the `_shadow_oam` definition this game's `oam_spr`/`oam_clear` rely on. The
+bare `chr-ram` preset has only an `nmi: rti` stub and no `_shadow_oam`, so it
+fails to link here. Don't add your own crt0 source either — the preset supplies
+it (a second one causes `Duplicate external identifier: __STARTUP__`). Produces
+a 32 KB NROM `.nes` (CHR-RAM — tiles uploaded at runtime, no CHR-ROM bank). Check the `ramUsage` field in the build response: this game runs
+at **BSS ≈ 371 B** of the ~512 B normal-RAM budget — comfortably under, but a
+good illustration of how tight NES RAM is.
+
+## What it teaches (the NES constraints, made concrete)
+
+- **Tiny RAM → bit-packed state.** All 20 aliens live in `uint8_t
+  alien_alive_mask[4]` (one bit per column), not a 20-byte array. Everything is
+  `uint8_t`/`int8_t`; there are no large structs. This is *why* NES C looks the
+  way it does — the ~512 B BSS ceiling forces it.
+- **8-sprites-per-scanline limit → 5 alien columns.** The formation is 5 wide on
+  purpose so a row never exceeds the hardware's per-scanline sprite cap (which
+  would otherwise drop/flicker sprites). Wide-but-shallow beats tall-and-narrow.
+- **OAM staging order.** `stage_sprites()` (which calls `oam_clear` + `oam_spr`)
+  runs **before** `ppu_wait_nmi()` in the main loop. The NMI handler DMAs shadow
+  OAM → real OAM at the *start* of vblank, so sprites must be staged before you
+  wait. Staging after `ppu_wait_nmi()` is the #1 "sprites flicker/vanish" bug.
+- **Sprites vs background, split by job.** Moving things (player, aliens, shots)
+  are OAM sprites; static structure (shields, HUD score/wave/lives) are
+  background tiles written with `tile_set`. Shields erode by swapping their BG
+  tile as `hp` drops.
+- **CHR-RAM upload.** `chr_ram_upload()` writes the tile bitmaps into both
+  pattern tables at boot (NROM CHR-RAM has no tiles until you do).
+- **APU SFX.** `sound_play_tone` / `sound_play_noise` for shoot / hit / death —
+  fire-and-forget, no music driver needed.
+
+## The main loop shape (copy this)
+
+```c
+for (;;) {
+  stage_sprites();   /* oam_clear + oam_spr — BEFORE the wait */
+  ppu_wait_nmi();    /* NMI DMAs shadow OAM at vblank start */
+  pad = pad_poll(0);
+  update_game(pad);  /* logic runs after vblank, off the hot path */
+  draw_hud();
+}
+```
+
+Game logic (movement, collision, spawning) runs *after* `ppu_wait_nmi()` so it
+happens during the visible frame, not during vblank — keeps the vblank window
+free for the DMA + any tile writes.

package/examples/nes/space-shooter/main.c

@@ -0,0 +1,441 @@
+/*
+ * NES fixed-shooter (space-shooter genre)
+ *
+ * Player cannon at the bottom shoots a descending grid of aliens, with
+ * destructible shields and a score/lives HUD. A 5-column formation keeps
+ * each row under the NES 8-sprites-per-scanline limit; shields and HUD are
+ * drawn as background tiles. (Generic genre example — not based on any
+ * specific commercial game.)
+ */
+
+#include "nes_runtime.h"
+
+#define ALIEN_COLS 5
+#define ALIEN_ROWS 4
+#define ALIEN_COUNT 20
+#define SHIELD_COUNT 3
+#define SHIELD_BLOCKS 6
+
+#define STATE_PLAY 0
+#define STATE_WIN 1
+#define STATE_OVER 2
+
+#define T_BLANK 0
+#define T_SHIELD_FULL 1
+#define T_SHIELD_HIT 2
+#define T_DIGIT_0 3
+#define T_ALIEN_0 13
+#define T_ALIEN_1 14
+#define T_ALIEN_2 15
+#define T_PLAYER_L 16
+#define T_PLAYER_R 17
+#define T_PLAYER_SHOT 18
+#define T_ALIEN_SHOT 19
+#define T_BANNER 20
+#define TILE_COUNT 21
+
+#define PAL_PLAYER 0
+#define PAL_SHOT 1
+#define PAL_ALIEN 2
+#define PAL_RED 3
+
+typedef struct {
+  uint8_t active;
+  uint8_t x;
+  uint8_t y;
+} Shot;
+
+typedef struct {
+  uint8_t hp[SHIELD_BLOCKS];
+} Shield;
+
+static uint8_t alien_alive_mask[ALIEN_ROWS];
+static Shield shields[SHIELD_COUNT];
+static Shot player_shot;
+static Shot alien_shot;
+
+static uint8_t player_x;
+static uint8_t player_cooldown;
+static uint8_t alien_x;
+static uint8_t alien_y;
+static int8_t alien_dir;
+static uint8_t alien_step_delay;
+static uint8_t alien_step_timer;
+static uint8_t wave;
+static uint8_t lives;
+static uint16_t score;
+static uint8_t state;
+static uint8_t frame_count;
+static uint16_t rng_state;
+
+static const uint8_t palette[32] = {
+  0x0F, 0x27, 0x17, 0x30,
+  0x0F, 0x21, 0x11, 0x30,
+  0x0F, 0x2A, 0x1A, 0x30,
+  0x0F, 0x16, 0x06, 0x30,
+  0x0F, 0x2A, 0x1A, 0x30,
+  0x0F, 0x27, 0x17, 0x30,
+  0x0F, 0x21, 0x11, 0x30,
+  0x0F, 0x16, 0x06, 0x30
+};
+
+static uint16_t next_rand(void) {
+  rng_state = (uint16_t)(rng_state * 109u + 1021u);
+  return rng_state;
+}
+
+static const uint8_t chr_tiles[16 * TILE_COUNT] = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xF7, 0xFF, 0xBB, 0xEF, 0xFE, 0x7D, 0xFF, 0xDF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3C, 0x66, 0x06, 0x1C, 0x30, 0x60, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x7C, 0x06, 0x06, 0x3C, 0x06, 0x06, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0C, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x7E, 0x60, 0x60, 0x7C, 0x06, 0x06, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3C, 0x7E, 0xDB, 0xFF, 0xA5, 0x7E, 0x24, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x7E, 0xDB, 0xFF, 0xFF, 0x5A, 0x81, 0x42,
+  0x81, 0x42, 0x7E, 0xDB, 0xFF, 0x3C, 0x24, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xDB, 0x00, 0x01, 0x03, 0x0F, 0x3F, 0x00, 0x00, 0xDB,
+  0x00, 0x80, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xDB, 0x00, 0x80, 0xC0, 0xF0, 0xFC, 0x00, 0x00, 0xDB,
+  0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x24, 0x18, 0x24, 0x18, 0x24, 0x18, 0x24, 0x00, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x00,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static void draw_number(uint8_t row, uint8_t col, uint16_t value, uint8_t digits) {
+  uint16_t div;
+  uint8_t i;
+  uint8_t digit;
+
+  div = 1;
+  for (i = 1; i < digits; i++) div = (uint16_t)(div * 10u);
+  for (i = 0; i < digits; i++) {
+    digit = (uint8_t)((value / div) % 10u);
+    tile_set(0, (uint8_t)(col + i), row, (uint8_t)(T_DIGIT_0 + digit));
+    div = (uint16_t)(div / 10u);
+  }
+}
+
+static void draw_hud(void) {
+  uint8_t i;
+
+  draw_number(0, 1, score, 5);
+  draw_number(0, 14, wave, 2);
+  for (i = 0; i < 3; i++) tile_set(0, (uint8_t)(25 + i), 0, i < lives ? T_SHIELD_FULL : T_BLANK);
+}
+
+static void clear_tilemap_init(void) {
+  uint16_t addr;
+  for (addr = 0x2000; addr < 0x23C0; addr++) vram_unsafe_set(addr, T_BLANK);
+  for (addr = 0x23C0; addr < 0x2400; addr++) vram_unsafe_set(addr, 0);
+}
+
+static void draw_shields(void) {
+  uint8_t s;
+  uint8_t b;
+  uint8_t base_col;
+  uint8_t row;
+  uint8_t col;
+  uint8_t tile;
+
+  for (s = 0; s < SHIELD_COUNT; s++) {
+    base_col = (uint8_t)(6 + s * 9);
+    for (b = 0; b < SHIELD_BLOCKS; b++) {
+      row = (uint8_t)(22 + b / 3);
+      col = (uint8_t)(base_col + b % 3);
+      if (shields[s].hp[b] == 0) tile = T_BLANK;
+      else if (shields[s].hp[b] == 1) tile = T_SHIELD_HIT;
+      else tile = T_SHIELD_FULL;
+      tile_set(0, col, row, tile);
+    }
+  }
+}
+
+static uint8_t alien_cell_x(uint8_t col) {
+  return (uint8_t)(alien_x + col * 24);
+}
+
+static uint8_t alien_cell_y(uint8_t row) {
+  return (uint8_t)(alien_y + row * 18);
+}
+
+static uint8_t alien_bit(uint8_t col) {
+  return (uint8_t)(1u << col);
+}
+
+static uint8_t aliens_alive(void) {
+  uint8_t row;
+  uint8_t col;
+  uint8_t count;
+
+  count = 0;
+  for (row = 0; row < ALIEN_ROWS; row++) {
+    for (col = 0; col < ALIEN_COLS; col++) {
+      if (alien_alive_mask[row] & alien_bit(col)) count++;
+    }
+  }
+  return count;
+}
+
+static void reset_wave(void) {
+  uint8_t i;
+  uint8_t s;
+  uint8_t b;
+
+  for (i = 0; i < ALIEN_ROWS; i++) alien_alive_mask[i] = 0x1F;
+  for (s = 0; s < SHIELD_COUNT; s++) {
+    for (b = 0; b < SHIELD_BLOCKS; b++) shields[s].hp[b] = 3;
+  }
+
+  player_x = 120;
+  player_cooldown = 0;
+  alien_x = 68;
+  alien_y = 48;
+  alien_dir = 1;
+  alien_step_delay = (uint8_t)(24 - wave * 2);
+  if (alien_step_delay < 8) alien_step_delay = 8;
+  alien_step_timer = 0;
+  player_shot.active = 0;
+  alien_shot.active = 0;
+  draw_shields();
+}
+
+static void reset_game(void) {
+  wave = 1;
+  lives = 3;
+  score = 0;
+  state = STATE_PLAY;
+  frame_count = 0;
+  rng_state = 0xACE1;
+  reset_wave();
+}
+
+static uint8_t point_hits_shield(uint8_t x, uint8_t y) {
+  uint8_t s;
+  uint8_t bx;
+  uint8_t local_x;
+  uint8_t local_y;
+  uint8_t index;
+
+  if (y < 176 || y >= 192) return 0;
+  for (s = 0; s < SHIELD_COUNT; s++) {
+    bx = (uint8_t)(48 + s * 72);
+    if (x < bx || x >= (uint8_t)(bx + 24)) continue;
+    local_x = (uint8_t)(x - bx);
+    local_y = (uint8_t)(y - 176);
+    index = (uint8_t)((local_y / 8) * 3 + local_x / 8);
+    if (index < SHIELD_BLOCKS && shields[s].hp[index] > 0) {
+      shields[s].hp[index]--;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static void fire_player(void) {
+  if (player_shot.active || player_cooldown) return;
+  player_shot.active = 1;
+  player_shot.x = (uint8_t)(player_x + 4);
+  player_shot.y = 204;
+  player_cooldown = 14;
+  sound_play_tone(0, 0x100, 8, 5);
+}
+
+static void spawn_alien_shot(void) {
+  uint8_t tries;
+  uint8_t col;
+  uint8_t row;
+
+  if (alien_shot.active) return;
+  if ((next_rand() & 31u) > 2u) return;
+
+  for (tries = 0; tries < 16; tries++) {
+    col = (uint8_t)(next_rand() % ALIEN_COLS);
+    for (row = ALIEN_ROWS; row > 0; row--) {
+      if (alien_alive_mask[row - 1] & alien_bit(col)) {
+        alien_shot.active = 1;
+        alien_shot.x = (uint8_t)(alien_cell_x(col) + 2);
+        alien_shot.y = (uint8_t)(alien_cell_y((uint8_t)(row - 1)) + 8);
+        return;
+      }
+    }
+  }
+}
+
+static void update_aliens(void) {
+  uint8_t row;
+  uint8_t col;
+  uint8_t x;
+  uint8_t hit_edge;
+
+  alien_step_timer++;
+  if (alien_step_timer < alien_step_delay) return;
+  alien_step_timer = 0;
+  hit_edge = 0;
+
+  for (row = 0; row < ALIEN_ROWS; row++) {
+    for (col = 0; col < ALIEN_COLS; col++) {
+      if (!(alien_alive_mask[row] & alien_bit(col))) continue;
+      x = alien_cell_x(col);
+      if ((alien_dir > 0 && x > 178) || (alien_dir < 0 && x < 12)) {
+        hit_edge = 1;
+        break;
+      }
+    }
+    if (hit_edge) break;
+  }
+
+  if (hit_edge) {
+    alien_dir = (int8_t)-alien_dir;
+    alien_y = (uint8_t)(alien_y + 7);
+    if (alien_step_delay > 6) alien_step_delay--;
+  } else if (alien_dir > 0) {
+    alien_x = (uint8_t)(alien_x + 4);
+  } else {
+    alien_x = (uint8_t)(alien_x - 4);
+  }
+}
+
+static void update_shots(void) {
+  uint8_t row;
+  uint8_t col;
+  uint8_t ax;
+  uint8_t ay;
+
+  if (player_shot.active) {
+    if (player_shot.y < 18) player_shot.active = 0;
+    else player_shot.y = (uint8_t)(player_shot.y - 5);
+    if (player_shot.active && point_hits_shield(player_shot.x, player_shot.y)) {
+      player_shot.active = 0;
+      draw_shields();
+    }
+  }
+
+  if (alien_shot.active) {
+    alien_shot.y = (uint8_t)(alien_shot.y + 3);
+    if (alien_shot.y > 226) alien_shot.active = 0;
+    if (alien_shot.active && point_hits_shield(alien_shot.x, (uint8_t)(alien_shot.y + 4))) {
+      alien_shot.active = 0;
+      draw_shields();
+      sound_play_noise(8, 8, 3);
+    }
+    if (alien_shot.active &&
+        alien_shot.x >= player_x && alien_shot.x <= (uint8_t)(player_x + 16) &&
+        alien_shot.y >= 208 && alien_shot.y <= 224) {
+      alien_shot.active = 0;
+      if (lives > 0) lives--;
+      sound_play_noise(8, 8, 10);
+      if (lives == 0) state = STATE_OVER;
+    }
+  }
+
+  if (!player_shot.active) return;
+  for (row = 0; row < ALIEN_ROWS; row++) {
+    for (col = 0; col < ALIEN_COLS; col++) {
+      if (!(alien_alive_mask[row] & alien_bit(col))) continue;
+      ax = alien_cell_x(col);
+      ay = alien_cell_y(row);
+      if (player_shot.x >= ax && player_shot.x <= (uint8_t)(ax + 8) &&
+          player_shot.y >= ay && player_shot.y <= (uint8_t)(ay + 8)) {
+        alien_alive_mask[row] &= (uint8_t)~alien_bit(col);
+        player_shot.active = 0;
+        score = (uint16_t)(score + 10u + (ALIEN_ROWS - row) * 5u);
+        sound_play_noise(8, 8, 6);
+        if (aliens_alive() == 0) {
+          wave++;
+          if (wave > 9) state = STATE_WIN;
+          else reset_wave();
+        }
+        return;
+      }
+    }
+  }
+}
+
+static void update_game(uint8_t pad) {
+  uint8_t row;
+  uint8_t col;
+
+  if (state != STATE_PLAY) {
+    if (pad & PAD_START) reset_game();
+    return;
+  }
+
+  if ((pad & PAD_LEFT) && player_x > 8) player_x = (uint8_t)(player_x - 2);
+  if ((pad & PAD_RIGHT) && player_x < 232) player_x = (uint8_t)(player_x + 2);
+  if (pad & PAD_A) fire_player();
+  if (player_cooldown) player_cooldown--;
+
+  update_aliens();
+  spawn_alien_shot();
+  update_shots();
+
+  for (row = 0; row < ALIEN_ROWS; row++) {
+    for (col = 0; col < ALIEN_COLS; col++) {
+      if ((alien_alive_mask[row] & alien_bit(col)) && alien_cell_y(row) > 196) {
+        state = STATE_OVER;
+        sound_play_noise(8, 8, 15);
+        return;
+      }
+    }
+  }
+}
+
+static void stage_sprites(void) {
+  uint8_t row;
+  uint8_t col;
+  uint8_t tile;
+
+  oam_clear();
+  if (state == STATE_PLAY) {
+    oam_spr(player_x, 216, T_PLAYER_L, PAL_PLAYER);
+    oam_spr((uint8_t)(player_x + 8), 216, T_PLAYER_R, PAL_PLAYER);
+  }
+
+  if (player_shot.active) oam_spr(player_shot.x, player_shot.y, T_PLAYER_SHOT, PAL_SHOT);
+  if (alien_shot.active) oam_spr(alien_shot.x, alien_shot.y, T_ALIEN_SHOT, PAL_RED);
+
+  for (row = 0; row < ALIEN_ROWS; row++) {
+    for (col = 0; col < ALIEN_COLS; col++) {
+      if (!(alien_alive_mask[row] & alien_bit(col))) continue;
+      tile = (uint8_t)(T_ALIEN_0 + row % 3);
+      oam_spr(alien_cell_x(col), alien_cell_y(row), tile, (uint8_t)(row & 3));
+    }
+  }
+
+  if (state != STATE_PLAY) {
+    for (col = 0; col < 8; col++) {
+      oam_spr((uint8_t)(80 + col * 12), 112, T_BANNER, PAL_RED);
+    }
+  }
+}
+
+void main(void) {
+  uint8_t pad;
+
+  ppu_off();
+  chr_ram_upload(0x0000, chr_tiles, sizeof(chr_tiles));
+  chr_ram_upload(0x1000, chr_tiles, sizeof(chr_tiles));
+  palette_load(palette);
+  clear_tilemap_init();
+  oam_clear();
+  ppu_scroll(0, 0);
+  sound_init();
+  reset_game();
+  ppu_on_all();
+
+  for (;;) {
+    stage_sprites();
+    ppu_wait_nmi();
+    pad = pad_poll(0);
+    update_game(pad);
+    draw_hud();
+    frame_count++;
+  }
+}