romdev-mcp 0.1.1

package/examples/c64/templates/platformer.c

@@ -0,0 +1,194 @@
+// ── platformer.c — Commodore 64 SIDE-SCROLLING platformer ────────────
+//
+// A horizontally scrolling platformer. C64 scrolling is the fiddliest of
+// the platforms: the VIC-II only does a 0-7 px *fine* scroll in hardware
+// ($D016 low 3 bits), so a wider world needs a software *coarse* shift —
+// re-render screen RAM ($0400) AND color RAM ($D800) from a world map
+// each time the fine offset wraps past a char boundary.
+//
+// World is 80 cols (640 px); the visible window is 40 cols (320 px). A
+// camera follows the player; fine = camX&7 → $D016, coarse = camX>>3
+// indexes which world column sits at screen column 0. We render 40 cols
+// each coarse step and switch to 38-column mode to mask the edge garbage
+// column the fine scroll exposes.
+//
+// One VIC-II hardware sprite for the player, drawn in SCREEN space.
+// Joystick port 2; B1 jumps. See the C64 MENTAL_MODEL.md.
+
+#include "c64_registers.h"
+#include "c64_sfx.h"
+#include <stdint.h>
+
+#define POKE(addr, val) (*(volatile uint8_t*)(addr) = (val))
+#define PEEK(addr)      (*(volatile uint8_t*)(addr))
+
+#define SCREEN ((volatile uint8_t*)0x0400)
+#define COLORS ((volatile uint8_t*)0xD800)
+
+#define JOY_LEFT  0x04
+#define JOY_RIGHT 0x08
+#define JOY_FIRE  0x10
+
+#define SPRITE_POINTERS ((volatile uint8_t*)0x07F8)
+
+#define WORLD_COLS 80                  /* 80 cells = 640 px world          */
+#define VIS_COLS   40                  /* 40 visible char columns (320 px) */
+#define VIS_ROWS   25
+#define WORLD_W    (WORLD_COLS * 8)
+#define SCREEN_VIS_W (VIS_COLS * 8)
+
+/* C64 sprite is 24x21. We draw a 16x16 "filled square" centered. */
+static const uint8_t player_sprite[64] = {
+  0x00,0x00,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00,
+  0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00,
+  0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00,
+  0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00, 0x00,0xFF,0x00,
+  0x00,0xFF,0x00, 0x00,0xFF,0x00, 0,0,0, 0,0,0, 0,0,0, 0,
+};
+
+/* Platforms in WORLD char-cell coords (col_start, col_end+1, row). The
+ * world is 80 cols wide; platforms spread across it. */
+static const uint8_t platforms[][3] = {
+  { 0, 80, 22 },   /* floor spans the world */
+  { 4, 16, 18 },
+  { 22, 34, 16 },
+  { 8, 20, 13 },
+  { 24, 38, 10 },
+  { 2, 14,  7 },
+  { 44, 56, 18 },
+  { 60, 74, 14 },
+  { 50, 64,  9 },
+  { 66, 78, 20 },
+};
+#define N_PLATFORMS (sizeof(platforms) / sizeof(platforms[0]))
+
+/* Is world char-cell (col,row) a platform block? */
+static uint8_t world_is_wall(uint8_t col, uint8_t row) {
+  uint8_t i;
+  for (i = 0; i < N_PLATFORMS; i++) {
+    if (row == platforms[i][2]
+        && col >= platforms[i][0]
+        && col <  platforms[i][1]) return 1;
+  }
+  return 0;
+}
+
+static void wait_vblank(void) {
+  while (PEEK(VIC_RASTER) < 250) { }
+  while (PEEK(VIC_RASTER) >= 250) { }
+}
+
+static void copy_sprite(uint8_t slot, const uint8_t *data) {
+  uint8_t i;
+  volatile uint8_t *dst = (volatile uint8_t*)(0x0800 + slot * 64);
+  for (i = 0; i < 64; i++) dst[i] = data[i];
+}
+
+/* Render the 40 visible columns of screen + color RAM from the world map,
+ * starting at world column `coarseCol`. Called once per coarse-scroll step
+ * (every 8 px of camera movement) — NOT every frame. */
+static void render_view(uint8_t coarseCol) {
+  uint8_t sc, r;
+  uint16_t wc;
+  for (sc = 0; sc < VIS_COLS; sc++) {
+    wc = (uint16_t)coarseCol + sc;
+    for (r = 0; r < VIS_ROWS; r++) {
+      uint16_t off = (uint16_t)r * 40 + sc;
+      if (wc < WORLD_COLS && world_is_wall((uint8_t)wc, r)) {
+        SCREEN[off] = 0xA0;          /* reverse-space solid block */
+        COLORS[off] = 0x0C;          /* mid grey */
+      } else {
+        SCREEN[off] = 0x20;          /* space */
+        COLORS[off] = 0x06;          /* bg color */
+      }
+    }
+  }
+}
+
+/* On-platform test in WORLD pixel coords. Player is ~16 px wide. */
+static uint8_t on_platform(int16_t worldPx, int16_t py) {
+  uint8_t i;
+  int16_t char_row = (py - 50) / 8 + 1;
+  int16_t char_col = worldPx / 8;
+  for (i = 0; i < N_PLATFORMS; i++) {
+    if (char_row == platforms[i][2]
+        && char_col + 2 > platforms[i][0]
+        && char_col     < platforms[i][1]) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+void main(void) {
+  int16_t worldPx = 32, py = 120;   /* worldPx = player X in world pixels */
+  int16_t camX = 0;
+  uint8_t lastCoarse = 0xFF;        /* force first render */
+  int8_t  vy = 0;
+  uint8_t pad, prev = 0;
+  uint8_t fine, coarse;
+  int16_t spx;
+
+  POKE(VIC_SPR_ENA, 0);
+  copy_sprite(0, player_sprite);
+  SPRITE_POINTERS[0] = 0x20;
+  POKE(VIC_SPR_COL(0), 0x07);  /* yellow player */
+  POKE(VIC_BORDER, 0x06);      /* dark blue */
+  POKE(VIC_BG0,    0x06);
+
+  render_view(0);              /* paint the initial 40-col view */
+
+  sfx_init();
+  POKE(VIC_SPR_ENA, 0x01);
+
+  for (;;) {
+    pad = (uint8_t)(~PEEK(CIA1_PRA) & 0x1F);
+    wait_vblank();
+    sfx_update();
+
+    if ((pad & JOY_LEFT)  && worldPx > 0)            worldPx -= 2;
+    if ((pad & JOY_RIGHT) && worldPx < WORLD_W - 16) worldPx += 2;
+    if ((pad & JOY_FIRE) && !(prev & JOY_FIRE) && on_platform(worldPx, py)) {
+      vy = -8; sfx_tone(0, 0x40, 0x20, 6);
+    }
+    prev = pad;
+
+    vy++;                       /* gravity */
+    if (vy > 6) vy = 6;
+    py += vy;
+    if (py < 50)  py = 50;
+    if (py > 240) py = 240;
+
+    if (vy > 0 && on_platform(worldPx, py)) {
+      py = py & 0xF8;           /* snap to 8-pixel boundary */
+      vy = 0;
+    }
+
+    /* Camera follows the player, centered, clamped to the world. */
+    camX = worldPx - (SCREEN_VIS_W / 2 - 8);
+    if (camX < 0) camX = 0;
+    if (camX > WORLD_W - SCREEN_VIS_W) camX = WORLD_W - SCREEN_VIS_W;
+
+    fine   = (uint8_t)(camX & 7);
+    coarse = (uint8_t)(camX >> 3);
+
+    /* Coarse step: re-render the view from the world map when the camera
+     * crosses a char boundary. */
+    if (coarse != lastCoarse) {
+      render_view(coarse);
+      lastCoarse = coarse;
+    }
+
+    /* Fine scroll: $D016 low 3 bits. Content scrolls LEFT as camX grows,
+     * so use 7-fine. Clear bit 3 → 38-column mode to mask the edge
+     * garbage column the fine scroll exposes. */
+    POKE(VIC_CTRL2, (uint8_t)(7 - fine));
+
+    /* Player sprite in SCREEN space. C64 visible sprite X origin is ~24;
+     * X can exceed 255 → set the high bit in $D010. */
+    spx = (worldPx - camX) + 24;
+    POKE(VIC_SPRITE_X(0), (uint8_t)spx);
+    if (spx > 255) POKE(VIC_SPRITES_X8, 0x01); else POKE(VIC_SPRITES_X8, 0x00);
+    POKE(VIC_SPRITE_Y(0), (uint8_t)py);
+  }
+}

package/examples/c64/templates/puzzle.c

@@ -0,0 +1,178 @@
+// ── puzzle.c — Commodore 64 match-3 falling-block puzzle ─────────────
+//
+// 6×12 grid rendered in the C64 screen-RAM character matrix (40×25).
+// 3 colors (R/G/B) via the COLOR_RAM at $D800. Active piece is 1×3
+// vertical. Joystick port 2: LEFT/RIGHT shift, FIRE rotates colors,
+// DOWN soft-drop, B2 hard-drop. Horizontal triples clear + score.
+
+#include "c64_registers.h"
+#include "c64_sfx.h"
+#include <stdint.h>
+
+#define POKE(addr, val) (*(volatile uint8_t*)(addr) = (val))
+#define PEEK(addr)      (*(volatile uint8_t*)(addr))
+
+#define SCREEN ((volatile uint8_t*)0x0400)
+#define COLORS ((volatile uint8_t*)0xD800)
+
+#define JOY_UP    0x01
+#define JOY_DOWN  0x02
+#define JOY_LEFT  0x04
+#define JOY_RIGHT 0x08
+#define JOY_FIRE  0x10
+
+#define COLS 6
+#define ROWS 12
+#define GRID_C 17        /* center grid in the 40-col matrix */
+#define GRID_R 6
+
+#define CELL_CHAR  0xA0  /* solid block */
+
+static uint8_t grid[ROWS][COLS];
+static uint8_t piece[3];
+static int8_t  piece_x, piece_y;
+static uint8_t fall_timer;
+static uint16_t score;
+static uint32_t rng = 1;
+
+static void wait_vblank(void) {
+  while (PEEK(VIC_RASTER) < 250) { }
+  while (PEEK(VIC_RASTER) >= 250) { }
+}
+
+static uint8_t rng_pick(void) {
+  rng = rng * 1103515245u + 12345u;
+  return (uint8_t)(1 + (rng >> 16) % 3);
+}
+
+static void draw_cell(int8_t r, int8_t c) {
+  uint16_t sx, sy;
+  uint8_t col_chr;
+  if (r < 0 || r >= ROWS) return;
+  sx = GRID_C + c;
+  sy = GRID_R + r;
+  col_chr = grid[r][c];
+  if (col_chr == 0) {
+    SCREEN[sy * 40 + sx] = ' ';
+  } else {
+    SCREEN[sy * 40 + sx] = CELL_CHAR;
+    COLORS[sy * 40 + sx] = col_chr;  /* col is the C64 colour id */
+  }
+}
+
+static void draw_grid(void) {
+  uint8_t r, c;
+  for (r = 0; r < ROWS; r++)
+    for (c = 0; c < COLS; c++) draw_cell((int8_t)r, (int8_t)c);
+}
+
+static void draw_piece(uint8_t clear) {
+  uint8_t i;
+  int8_t r;
+  for (i = 0; i < 3; i++) {
+    r = (int8_t)(piece_y + i);
+    if (r < 0 || r >= ROWS) continue;
+    if (clear) {
+      grid[r][piece_x] = 0;
+      draw_cell(r, (int8_t)piece_x);
+    } else {
+      uint8_t saved = grid[r][piece_x];
+      grid[r][piece_x] = piece[i];
+      draw_cell(r, (int8_t)piece_x);
+      grid[r][piece_x] = saved;
+    }
+  }
+}
+
+static uint8_t collides(int8_t x, int8_t y) {
+  uint8_t i;
+  int8_t r;
+  if (x < 0 || x >= COLS) return 1;
+  for (i = 0; i < 3; i++) {
+    r = (int8_t)(y + i);
+    if (r >= ROWS) return 1;
+    if (r >= 0 && grid[r][x] != 0) return 1;
+  }
+  return 0;
+}
+
+static void new_piece(void) {
+  piece[0] = (uint8_t)(2 + rng_pick());  /* C64 colors 3,4,5: red, mauve, green */
+  piece[1] = (uint8_t)(2 + rng_pick());
+  piece[2] = (uint8_t)(2 + rng_pick());
+  piece_x = COLS / 2 - 1;
+  piece_y = -3;
+}
+
+static void lock_piece(void) {
+  uint8_t i, c;
+  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 < 65500) score += 30;
+        sfx_tone(0, 0x80, 0x10, 12);
+      }
+    }
+  }
+  draw_grid();
+}
+
+void main(void) {
+  uint8_t r, c, pad, prev = 0, fall_rate, t;
+  POKE(VIC_BORDER, 0x00);
+  POKE(VIC_BG0,    0x00);
+
+  for (r = 0; r < ROWS; r++)
+    for (c = 0; c < COLS; c++) grid[r][c] = 0;
+
+  score = 0; fall_timer = 0;
+  sfx_init();
+  new_piece();
+  draw_grid();
+
+  for (;;) {
+    pad = (uint8_t)(~PEEK(CIA1_PRA) & 0x1F);
+    wait_vblank();
+    sfx_update();
+    draw_piece(1);
+
+    if ((pad & JOY_LEFT)  && !(prev & JOY_LEFT)  && !collides(piece_x - 1, piece_y)) piece_x--;
+    if ((pad & JOY_RIGHT) && !(prev & JOY_RIGHT) && !collides(piece_x + 1, piece_y)) piece_x++;
+    if ((pad & JOY_FIRE)  && !(prev & JOY_FIRE)) {
+      t = piece[0]; piece[0] = piece[1]; piece[1] = piece[2]; piece[2] = t;
+      sfx_tone(1, 0x20, 0x14, 2);
+    }
+    if ((pad & JOY_UP)    && !(prev & JOY_UP)) {
+      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;
+    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);
+  }
+}

package/examples/c64/templates/racing.c

@@ -0,0 +1,140 @@
+// ── racing.c — Commodore 64 top-down racing scaffold ─────────────────
+//
+// 3-lane endless racer. Player car at the bottom; obstacles spawn from
+// top and slide down. LEFT/RIGHT switches lanes. Joystick port 2.
+
+#include "c64_registers.h"
+#include "c64_sfx.h"
+#include <stdint.h>
+
+#define POKE(addr, val) (*(volatile uint8_t*)(addr) = (val))
+#define PEEK(addr)      (*(volatile uint8_t*)(addr))
+
+#define JOY_LEFT  0x04
+#define JOY_RIGHT 0x08
+
+#define SPRITE_POINTERS ((volatile uint8_t*)0x07F8)
+
+#define MAX_OBS 4
+#define LANE0_X 88
+#define LANE1_X 152
+#define LANE2_X 216
+
+static const uint8_t lane_x[3] = { LANE0_X, LANE1_X, LANE2_X };
+
+/* Filled car-shaped sprite. */
+static const uint8_t car_sprite[64] = {
+  0,0,0, 0x00,0x7E,0x00, 0x00,0xFF,0x00, 0x01,0xFF,0x80,
+  0x01,0xFF,0x80, 0x01,0xFF,0x80, 0x03,0xFF,0xC0, 0x07,0xFF,0xE0,
+  0x07,0xE7,0xE0, 0x07,0xC3,0xE0, 0x07,0xC3,0xE0, 0x07,0xFF,0xE0,
+  0x07,0xFF,0xE0, 0x07,0xE7,0xE0, 0x07,0xC3,0xE0, 0x07,0xC3,0xE0,
+  0x07,0xC3,0xE0, 0x07,0xC3,0xE0, 0x07,0xFF,0xE0, 0x07,0xFF,0xE0,
+  0x03,0xFF,0xC0, 0,
+};
+
+typedef struct { uint8_t x, y, alive; } Car;
+
+static Car player;
+static Car obstacles[MAX_OBS];
+static uint8_t spawn_timer;
+static uint8_t player_lane = 1;
+static uint8_t prev_pad;
+static uint8_t game_over_timer;
+static uint32_t rng = 1;
+
+static void wait_vblank(void) {
+  while (PEEK(VIC_RASTER) < 250) { }
+  while (PEEK(VIC_RASTER) >= 250) { }
+}
+
+static void copy_sprite(uint8_t slot, const uint8_t *data) {
+  uint8_t i;
+  volatile uint8_t *dst = (volatile uint8_t*)(0x0800 + slot * 64);
+  for (i = 0; i < 64; i++) dst[i] = data[i];
+}
+
+static void spawn(void) {
+  uint8_t i;
+  rng = rng * 1103515245u + 12345u;
+  for (i = 0; i < MAX_OBS; i++) {
+    if (!obstacles[i].alive) {
+      obstacles[i].x = lane_x[(rng >> 16) % 3];
+      obstacles[i].y = 50;
+      obstacles[i].alive = 1;
+      return;
+    }
+  }
+}
+
+static uint8_t aabb(Car *a, Car *b) {
+  return a->x < b->x + 24 && a->x + 24 > b->x
+      && a->y < b->y + 24 && a->y + 24 > b->y;
+}
+
+void main(void) {
+  uint8_t i, pad;
+  POKE(VIC_SPR_ENA, 0);
+  copy_sprite(0, car_sprite);
+  SPRITE_POINTERS[0] = 0x20;
+  for (i = 0; i < MAX_OBS; i++) SPRITE_POINTERS[1 + i] = 0x20;
+  POKE(VIC_SPR_COL(0), 0x07);  /* yellow player */
+  for (i = 0; i < MAX_OBS; i++) POKE(VIC_SPR_COL(1 + i), 0x02);  /* red obstacles */
+  POKE(VIC_BORDER, 0x00);
+  POKE(VIC_BG0,    0x09);  /* brown road */
+
+  player.x = LANE1_X; player.y = 220; player.alive = 1;
+  for (i = 0; i < MAX_OBS; i++) obstacles[i].alive = 0;
+  spawn_timer = 0;
+  game_over_timer = 0;
+  sfx_init();
+  POKE(VIC_SPR_ENA, 0x1F);
+
+  for (;;) {
+    pad = (uint8_t)(~PEEK(CIA1_PRA) & 0x1F);
+    wait_vblank();
+    sfx_update();
+
+    if (game_over_timer > 0) {
+      game_over_timer--;
+      if (game_over_timer == 0) {
+        for (i = 0; i < MAX_OBS; i++) obstacles[i].alive = 0;
+        player_lane = 1;
+        player.x = LANE1_X;
+      }
+    } else {
+      if ((pad & JOY_LEFT)  && !(prev_pad & JOY_LEFT)  && player_lane > 0) {
+        player_lane--; sfx_tone(1, 0x40, 0x18, 2);
+      }
+      if ((pad & JOY_RIGHT) && !(prev_pad & JOY_RIGHT) && player_lane < 2) {
+        player_lane++; sfx_tone(1, 0x40, 0x18, 2);
+      }
+      player.x = lane_x[player_lane];
+      prev_pad = pad;
+
+      for (i = 0; i < MAX_OBS; i++) {
+        if (!obstacles[i].alive) continue;
+        obstacles[i].y += 2;
+        if (obstacles[i].y >= 245) obstacles[i].alive = 0;
+      }
+      spawn_timer++;
+      if (spawn_timer >= 40) { spawn_timer = 0; spawn(); }
+
+      for (i = 0; i < MAX_OBS; i++) {
+        if (obstacles[i].alive && aabb(&player, &obstacles[i])) {
+          game_over_timer = 60;
+          sfx_noise(40);
+          break;
+        }
+      }
+    }
+
+    POKE(VIC_SPRITE_X(0), player.x);
+    POKE(VIC_SPRITE_Y(0), player.y);
+    for (i = 0; i < MAX_OBS; i++) {
+      uint8_t ox = obstacles[i].alive ? obstacles[i].x : 0;
+      uint8_t oy = obstacles[i].alive ? obstacles[i].y : 0;
+      POKE(VIC_SPRITE_X(1 + i), ox);
+      POKE(VIC_SPRITE_Y(1 + i), oy);
+    }
+  }
+}

package/examples/c64/templates/shmup.c

@@ -0,0 +1,201 @@
+// ── shmup.c — Commodore 64 vertical-shooter scaffold ─────────────────
+//
+// Cross-platform shmup shape: player + 4 bullets + 4 enemies (pool),
+// wave spawner, AABB collisions, SID sound effects on fire + hit.
+//
+// VIC-II hardware sprites give us up to 8 MOBs — we use 1 player +
+// 4 bullets + 4 enemies = 9, so we double-up: the four bullets share
+// sprite slots 1-4 in time-multiplexed style — actually we keep it
+// honest by allocating only 8 slots (player + 3 bullets + 4 enemies)
+// to demonstrate the C64's tight sprite budget.
+//
+// Joystick port 2 drives the player (CIA1_PRA via the standard C64
+// idiom — port 1 conflicts with the keyboard scan matrix).
+
+#include "c64_registers.h"
+#include "c64_sfx.h"
+#include <stdint.h>
+
+#define POKE(addr, val) (*(volatile uint8_t*)(addr) = (val))
+#define PEEK(addr)      (*(volatile uint8_t*)(addr))
+
+#define SPRITE_POINTERS  ((volatile uint8_t*)0x07F8)
+#define SPRITE_DATA_BASE 0x0800  /* sprite N data at $0800 + N*64 */
+
+#define JOY_UP    0x01
+#define JOY_DOWN  0x02
+#define JOY_LEFT  0x04
+#define JOY_RIGHT 0x08
+#define JOY_FIRE  0x10
+
+#define MAX_BULLETS 3
+#define MAX_ENEMIES 4
+
+/* 8 hardware sprite slots:
+ *   0       player
+ *   1..3    bullets
+ *   4..7    enemies */
+#define SLOT_PLAYER  0
+#define SLOT_BULLET0 1
+#define SLOT_ENEMY0  4
+
+static const uint8_t ship_sprite[64] = {
+  0x00,0x18,0x00, 0x00,0x3C,0x00, 0x00,0x7E,0x00, 0x00,0xFF,0x00,
+  0x01,0xFF,0x80, 0x03,0xFF,0xC0, 0x07,0xFF,0xE0, 0x0F,0x18,0xF0,
+  0x1F,0x18,0xF8, 0x3F,0xFF,0xFC, 0x7F,0xFF,0xFE, 0x7F,0xFF,0xFE,
+  0x7F,0xFF,0xFE, 0x3F,0xFF,0xFC, 0x1F,0xFF,0xF8, 0x0F,0xFF,0xF0,
+  0x07,0xFF,0xE0, 0x03,0xFF,0xC0, 0x01,0xFF,0x80, 0x00,0xFF,0x00,
+  0x00,0x3C,0x00, 0,
+};
+static const uint8_t bullet_sprite[64] = {
+  0x00,0x18,0x00, 0x00,0x3C,0x00, 0x00,0x3C,0x00, 0x00,0x3C,0x00,
+  0x00,0x3C,0x00, 0x00,0x3C,0x00, 0x00,0x3C,0x00, 0x00,0x3C,0x00,
+  0x00,0x3C,0x00, 0x00,0x3C,0x00, 0x00,0x18,0x00,
+  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,
+};
+static const uint8_t enemy_sprite[64] = {
+  0xFF,0x81,0xFF, 0x7E,0x42,0x7E, 0x3C,0x24,0x3C, 0x18,0x18,0x18,
+  0x3C,0x3C,0x3C, 0x7E,0x66,0x7E, 0xFF,0xC3,0xFF, 0xC3,0x18,0xC3,
+  0xC3,0x18,0xC3, 0xC3,0x18,0xC3, 0x18,0x18,0x18, 0x3C,0x3C,0x3C,
+  0x7E,0x7E,0x7E, 0xFF,0xFF,0xFF, 0x7E,0x7E,0x7E, 0x3C,0x3C,0x3C,
+  0x18,0x18,0x18, 0,0,0, 0,0,0, 0,0,0, 0,0,0, 0,
+};
+
+typedef struct { uint8_t x, y, alive; } Obj;
+
+static Obj player;
+static Obj bullets[MAX_BULLETS];
+static Obj enemies[MAX_ENEMIES];
+static uint8_t spawn_timer;
+static uint8_t prev_pad;
+static uint16_t score;
+
+static uint8_t aabb(Obj *a, Obj *b) {
+  return a->x < b->x + 12 && a->x + 12 > b->x
+      && a->y < b->y + 16 && a->y + 16 > 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 - 10;
+      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 = (uint8_t)(48 + ((spawn_timer * 37) & 0xFF) % 240);
+      enemies[i].y = 30;
+      enemies[i].alive = 1;
+      return;
+    }
+  }
+}
+
+static void wait_vblank(void) {
+  while (PEEK(VIC_RASTER) < 250) { }
+  while (PEEK(VIC_RASTER) >= 250) { }
+}
+
+static void copy_sprite(uint8_t slot, const uint8_t *data) {
+  uint8_t i;
+  volatile uint8_t *dst = (volatile uint8_t*)(SPRITE_DATA_BASE + slot * 64);
+  for (i = 0; i < 64; i++) dst[i] = data[i];
+}
+
+void main(void) {
+  uint8_t i, j;
+
+  POKE(VIC_SPR_ENA, 0);     /* sprites off while we set up */
+
+  copy_sprite(0, ship_sprite);
+  copy_sprite(1, bullet_sprite);
+  copy_sprite(2, enemy_sprite);
+
+  /* Sprite pointers: slot N points at /64 index into the VIC bank.
+   * Default bank = $0000-$3FFF. $0800 / 64 = 32 = $20. */
+  SPRITE_POINTERS[SLOT_PLAYER] = 0x20;
+  for (i = 0; i < MAX_BULLETS; i++) SPRITE_POINTERS[SLOT_BULLET0 + i] = 0x21;
+  for (i = 0; i < MAX_ENEMIES; i++) SPRITE_POINTERS[SLOT_ENEMY0 + i] = 0x22;
+
+  POKE(VIC_SPR_COL(SLOT_PLAYER), 0x07);  /* yellow */
+  for (i = 0; i < MAX_BULLETS; i++) POKE(VIC_SPR_COL(SLOT_BULLET0 + i), 0x01);  /* white */
+  for (i = 0; i < MAX_ENEMIES; i++) POKE(VIC_SPR_COL(SLOT_ENEMY0  + i), 0x02);  /* red */
+
+  POKE(VIC_BORDER, 0x00);
+  POKE(VIC_BG0, 0x00);
+
+  player.x = 152; player.y = 200; 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;
+  prev_pad = 0;
+  sfx_init();
+
+  /* Enable all 8 sprite slots. */
+  POKE(VIC_SPR_ENA, 0xFF);
+
+  for (;;) {
+    uint8_t pad = (uint8_t)(~PEEK(CIA1_PRA) & 0x1F);
+    wait_vblank();
+    sfx_update();
+
+    if ((pad & JOY_LEFT)  && player.x > 24)  player.x -= 2;
+    if ((pad & JOY_RIGHT) && player.x < 240) player.x += 2;
+    if ((pad & JOY_UP)    && player.y > 50)  player.y -= 2;
+    if ((pad & JOY_DOWN)  && player.y < 230) player.y += 2;
+    if ((pad & JOY_FIRE) && !(prev_pad & JOY_FIRE)) { fire(); sfx_tone(0, 0x80, 0x20, 4); }
+    prev_pad = pad;
+
+    for (i = 0; i < MAX_BULLETS; i++) {
+      if (!bullets[i].alive) continue;
+      if (bullets[i].y < 50) { 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 >= 245) enemies[i].alive = 0;
+    }
+    spawn_timer++;
+    if (spawn_timer >= 32) { 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;
+          sfx_noise(8);
+          break;
+        }
+      }
+    }
+
+    /* Stage VIC sprite positions. */
+    POKE(VIC_SPRITE_X(SLOT_PLAYER), player.x);
+    POKE(VIC_SPRITE_Y(SLOT_PLAYER), player.y);
+    for (i = 0; i < MAX_BULLETS; i++) {
+      uint8_t sx = bullets[i].alive ? bullets[i].x : 0;
+      uint8_t sy = bullets[i].alive ? bullets[i].y : 0;
+      POKE(VIC_SPRITE_X(SLOT_BULLET0 + i), sx);
+      POKE(VIC_SPRITE_Y(SLOT_BULLET0 + i), sy);
+    }
+    for (i = 0; i < MAX_ENEMIES; i++) {
+      uint8_t ex = enemies[i].alive ? enemies[i].x : 0;
+      uint8_t ey = enemies[i].alive ? enemies[i].y : 0;
+      POKE(VIC_SPRITE_X(SLOT_ENEMY0 + i), ex);
+      POKE(VIC_SPRITE_Y(SLOT_ENEMY0 + i), ey);
+    }
+  }
+}