romdevtools 0.16.0 → 0.21.0

package/examples/pce/shmup/main.c

@@ -0,0 +1,346 @@
+/*
+ * PC Engine "shmup" — a vertical shoot-'em-up scaffold.
+ *
+ * Fly a ship around the bottom of the screen with the d-pad and fire upward
+ * with button I. Enemies spawn at the top in waves and drift down; a bullet
+ * that overlaps an enemy destroys it and scores 10. The HUD shows the score
+ * with background digit tiles. A scrolling starfield BG keeps the screen full
+ * (so it clears the verify gate and the sprites read clearly).
+ *
+ * Mirrors the NES/Genesis/SNES/GB/SMS shmup scaffolds, translated to the PCE
+ * helper API:
+ *   - object pools (player + bullets + enemies) updated each frame
+ *   - AABB collision
+ *   - a wave spawner on a frame counter
+ *   - 64-sprite shadow SATB + satb_dma()
+ *
+ * PCE notes (see pce_hw.h / MENTAL_MODEL.md):
+ *   - disp_enable() turns on BG + sprites AND the VBlank IRQ so waitvsync()
+ *     actually returns (without the IRQ bit the loop spins forever).
+ *   - .bss must be non-empty; pce_video.c's _pce_keep[] covers that, and we
+ *     touch _pce_keep[0] for clarity.
+ *   - sprites get the SPBG-front bit from set_sprite(), so they draw over the
+ *     opaque starfield BG.
+ *
+ * cc65 is C89 — declare locals at the top of a block.
+ */
+#include <pce.h>
+#include "pce_hw.h"
+
+/* ---- VRAM layout (word addresses) --------------------------------------- */
+#define BAT_VRAM     0x0000   /* 32x32 background map                        */
+#define FONT_VRAM    0x1000   /* digit/glyph tiles (8x8, 16 words each)      */
+#define STAR0_VRAM   0x1400   /* BG tile: empty space (solid colour 1)       */
+#define STAR1_VRAM   0x1410   /* BG tile: space band (solid colour 2)        */
+#define STAR2_VRAM   0x1420   /* BG tile: space + a star pixel               */
+#define SHIP_VRAM    0x1800   /* 16x16 player ship                           */
+#define BULLET_VRAM  0x1840   /* 16x16 bullet                                */
+#define ENEMY_VRAM   0x1880   /* 16x16 enemy                                 */
+
+#define BAT_ENTRY(pal, vram)  ((u16)(((pal) << 12) | ((vram) >> 4)))
+
+#define MAX_BULLETS 6
+#define MAX_ENEMIES 6
+
+/* ---- 5x7 glyph font (digits + a few letters for the HUD) ----------------- */
+#define G_BLANK 0
+#define G_0     1   /* digits 0..9 -> tiles 1..10 */
+#define G_S     11
+#define G_C     12
+#define G_O     13
+#define G_R     14
+#define G_E     15
+#define NUM_GLYPHS 16
+
+static const u8 FONT5x7[NUM_GLYPHS][7] = {
+    /* BLANK */ {0,0,0,0,0,0,0},
+    /* 0 */ {0x0E,0x11,0x13,0x15,0x19,0x11,0x0E},
+    /* 1 */ {0x04,0x0C,0x04,0x04,0x04,0x04,0x0E},
+    /* 2 */ {0x0E,0x11,0x01,0x02,0x04,0x08,0x1F},
+    /* 3 */ {0x1F,0x02,0x04,0x02,0x01,0x11,0x0E},
+    /* 4 */ {0x02,0x06,0x0A,0x12,0x1F,0x02,0x02},
+    /* 5 */ {0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E},
+    /* 6 */ {0x06,0x08,0x10,0x1E,0x11,0x11,0x0E},
+    /* 7 */ {0x1F,0x01,0x02,0x04,0x08,0x08,0x08},
+    /* 8 */ {0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E},
+    /* 9 */ {0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C},
+    /* S */ {0x0F,0x10,0x10,0x0E,0x01,0x01,0x1E},
+    /* C */ {0x0E,0x11,0x10,0x10,0x10,0x11,0x0E},
+    /* O */ {0x0E,0x11,0x11,0x11,0x11,0x11,0x0E},
+    /* R */ {0x1E,0x11,0x11,0x1E,0x14,0x12,0x11},
+    /* E */ {0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F},
+};
+
+/* ---- game state --------------------------------------------------------- */
+typedef struct { u16 x, y; u8 alive; } Obj;
+
+static Obj player;
+static Obj bullets[MAX_BULLETS];
+static Obj enemies[MAX_ENEMIES];
+static u16 score;
+static u8  spawn_timer;
+static u16 rng;
+static u8  pad, prev_pad;
+static u8  sfx_timer;
+
+static u16 tile_buf[16];      /* scratch for one 8x8 tile                    */
+static u16 spr_buf[64];       /* scratch for one 16x16 sprite                */
+
+/* ---- tile/sprite builders ----------------------------------------------- */
+static void make_solid_tile(u16 *t, u8 ci) {
+    u8 r;
+    u8 p0 = (ci & 1) ? 0xFF : 0x00;
+    u8 p1 = (ci & 2) ? 0xFF : 0x00;
+    u8 p2 = (ci & 4) ? 0xFF : 0x00;
+    u8 p3 = (ci & 8) ? 0xFF : 0x00;
+    for (r = 0; r < 8; ++r) {
+        t[r]     = (u16)(p0 | (p1 << 8));
+        t[r + 8] = (u16)(p2 | (p3 << 8));
+    }
+}
+
+/* space tile with one star pixel in colour index 3 at (row 2, col 5) */
+static void make_star_tile(u16 *t) {
+    u8 r;
+    for (r = 0; r < 8; ++r) { t[r] = 0x00FF; t[r + 8] = 0x0000; } /* base = colour 1 */
+    /* star = colour 3 (planes 0+1) at row 2: set plane1 bit too for that row */
+    t[2] = (u16)(0x00FF | (0x04 << 8));   /* plane0 row + plane1 single pixel */
+}
+
+/* upload one 16x16 sprite from a 16-row body mask in colour `ci` */
+static void make_sprite(u16 vram, const u16 *body, u8 ci) {
+    u8 r;
+    for (r = 0; r < 64; ++r) spr_buf[r] = 0;
+    for (r = 0; r < 16; ++r) {
+        if (ci & 1) spr_buf[r]      = body[r];        /* plane0 */
+        if (ci & 2) spr_buf[r + 16] = body[r];        /* plane1 */
+        if (ci & 4) spr_buf[r + 32] = body[r];        /* plane2 */
+        if (ci & 8) spr_buf[r + 48] = body[r];        /* plane3 */
+    }
+    load_tiles(vram, spr_buf, 64);
+}
+
+static void upload_font(void) {
+    u8 g, row, bits, plane0;
+    for (g = 0; g < NUM_GLYPHS; ++g) {
+        for (row = 0; row < 16; ++row) tile_buf[row] = 0;
+        for (row = 0; row < 7; ++row) {
+            bits = FONT5x7[g][row];
+            plane0 = 0;
+            if (bits & 0x10) plane0 |= 0x40;
+            if (bits & 0x08) plane0 |= 0x20;
+            if (bits & 0x04) plane0 |= 0x10;
+            if (bits & 0x02) plane0 |= 0x08;
+            if (bits & 0x01) plane0 |= 0x04;
+            tile_buf[row] = (u16)plane0;
+        }
+        load_tiles((u16)(FONT_VRAM + g * 16), tile_buf, 16);
+    }
+}
+
+static void upload_art(void) {
+    /* ship: an upward-pointing arrow */
+    static const u16 ship[16] = {
+        0x0180, 0x0180, 0x03C0, 0x03C0, 0x07E0, 0x07E0, 0x0FF0, 0x0FF0,
+        0x1FF8, 0x1FF8, 0x3FFC, 0x7FFE, 0xFFFF, 0xE187, 0xC003, 0x8001
+    };
+    /* bullet: a small vertical pellet */
+    static const u16 bullet[16] = {
+        0x0000, 0x0180, 0x03C0, 0x03C0, 0x07E0, 0x07E0, 0x07E0, 0x07E0,
+        0x07E0, 0x07E0, 0x03C0, 0x03C0, 0x0180, 0x0000, 0x0000, 0x0000
+    };
+    /* enemy: a downward, blocky invader */
+    static const u16 enemy[16] = {
+        0x0000, 0x4002, 0x6006, 0x7FFE, 0x7FFE, 0xFDBF, 0xFFFF, 0xFFFF,
+        0xFFFF, 0x7FFE, 0x3FFC, 0x1FF8, 0x300C, 0x6006, 0x4002, 0x0000
+    };
+    upload_font();
+    make_solid_tile(tile_buf, 1); load_tiles(STAR0_VRAM, tile_buf, 16);
+    make_solid_tile(tile_buf, 2); load_tiles(STAR1_VRAM, tile_buf, 16);
+    make_star_tile(tile_buf);     load_tiles(STAR2_VRAM, tile_buf, 16);
+    make_sprite(SHIP_VRAM,   ship,   1);   /* white   */
+    make_sprite(BULLET_VRAM, bullet, 1);   /* white (sub-pal 1 = yellow) */
+    make_sprite(ENEMY_VRAM,  enemy,  1);   /* white (sub-pal 2 = red)    */
+}
+
+/* ---- BAT / HUD ---------------------------------------------------------- */
+static void draw_starfield(void) {
+    u8 r, c;
+    u16 e0 = BAT_ENTRY(0, STAR0_VRAM);
+    u16 e1 = BAT_ENTRY(0, STAR1_VRAM);
+    u16 e2 = BAT_ENTRY(0, STAR2_VRAM);
+    u16 e;
+    for (r = 0; r < 32; ++r) {
+        vram_set_write_addr((u16)(BAT_VRAM + r * 32));
+        for (c = 0; c < 32; ++c) {
+            e = (r & 2) ? e1 : e0;                       /* depth bands */
+            if (((r * 7 + c * 5) & 7) == 0) e = e2;      /* sparse stars */
+            VDC_DATA_LO = (u8)(e & 0xFF);
+            VDC_DATA_HI = (u8)(e >> 8);
+        }
+    }
+}
+
+static void put_glyph(u8 col, u8 row, u8 glyph) {
+    u16 e = BAT_ENTRY(0, (u16)(FONT_VRAM + glyph * 16));
+    vram_set_write_addr((u16)(BAT_VRAM + row * 32 + col));
+    VDC_DATA_LO = (u8)(e & 0xFF);
+    VDC_DATA_HI = (u8)(e >> 8);
+}
+
+static void draw_hud_label(void) {
+    static const u8 lbl[5] = { G_S, G_C, G_O, G_R, G_E };
+    u8 i;
+    for (i = 0; i < 5; ++i) put_glyph((u8)(1 + i), 1, lbl[i]);
+}
+
+static void draw_score(void) {
+    u16 v = score;
+    u8 d0, d1, d2, d3;
+    d3 = (u8)(v % 10); v /= 10;
+    d2 = (u8)(v % 10); v /= 10;
+    d1 = (u8)(v % 10); v /= 10;
+    d0 = (u8)(v % 10);
+    put_glyph(7,  1, (u8)(G_0 + d0));
+    put_glyph(8,  1, (u8)(G_0 + d1));
+    put_glyph(9,  1, (u8)(G_0 + d2));
+    put_glyph(10, 1, (u8)(G_0 + d3));
+}
+
+/* ---- gameplay helpers --------------------------------------------------- */
+static u8 aabb(Obj *a, Obj *b) {
+    return (u8)(a->x < b->x + 14 && a->x + 14 > b->x &&
+                a->y < b->y + 14 && a->y + 14 > b->y);
+}
+
+static u16 next_rand(void) {
+    rng = (u16)(rng * 25173u + 13849u);
+    return rng;
+}
+
+static void fire(void) {
+    u8 i;
+    for (i = 0; i < MAX_BULLETS; ++i) {
+        if (!bullets[i].alive) {
+            bullets[i].x = player.x;
+            bullets[i].y = (u16)(player.y - 10);
+            bullets[i].alive = 1;
+            psg_tone(2, 0x180, 26);
+            sfx_timer = 4;
+            return;
+        }
+    }
+}
+
+static void spawn(void) {
+    u8 i;
+    for (i = 0; i < MAX_ENEMIES; ++i) {
+        if (!enemies[i].alive) {
+            enemies[i].x = (u16)(8 + (next_rand() >> 8) % 224);
+            enemies[i].y = 8;
+            enemies[i].alive = 1;
+            return;
+        }
+    }
+}
+
+void main(void) {
+    u8 i, j;
+
+    _pce_keep[0] = 0;
+
+    /* palette: BG sub-pal 0 + sprite sub-pals 0/1/2 */
+    vce_set_color(0,   PCE_RGB(0, 0, 1));   /* backdrop dark blue          */
+    vce_set_color(1,   PCE_RGB(0, 0, 3));   /* BG c1: deep space blue      */
+    vce_set_color(2,   PCE_RGB(1, 1, 4));   /* BG c2: lighter space band   */
+    vce_set_color(3,   PCE_RGB(7, 7, 7));   /* BG c3: star white           */
+    vce_set_color(256, PCE_RGB(0, 0, 0));   /* spr pal0 transparent        */
+    vce_set_color(257, PCE_RGB(2, 6, 7));   /* spr pal0 c1: cyan ship      */
+    vce_set_color(272, PCE_RGB(0, 0, 0));   /* spr pal1 transparent        */
+    vce_set_color(273, PCE_RGB(7, 7, 0));   /* spr pal1 c1: yellow bullet  */
+    vce_set_color(288, PCE_RGB(0, 0, 0));   /* spr pal2 transparent        */
+    vce_set_color(289, PCE_RGB(7, 1, 1));   /* spr pal2 c1: red enemy      */
+
+    upload_art();
+    draw_starfield();
+    draw_hud_label();
+
+    player.x = 120; player.y = 180; 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;
+    rng = 0xC0DE;
+    prev_pad = 0;
+    sfx_timer = 0;
+    draw_score();
+
+    pce_joy_init();
+    disp_enable();
+
+    for (;;) {
+        waitvsync();
+        pad = pce_joy_read();
+
+        /* move ship */
+        if ((pad & PCE_JOY_LEFT)  && player.x > 2)   player.x -= 3;
+        if ((pad & PCE_JOY_RIGHT) && player.x < 238) player.x += 3;
+        if ((pad & PCE_JOY_UP)    && player.y > 8)   player.y -= 3;
+        if ((pad & PCE_JOY_DOWN)  && player.y < 208) player.y += 3;
+        if ((pad & PCE_JOY_I) && !(prev_pad & PCE_JOY_I)) fire();
+        prev_pad = pad;
+
+        /* advance bullets */
+        for (i = 0; i < MAX_BULLETS; ++i) {
+            if (!bullets[i].alive) continue;
+            if (bullets[i].y < 6) { bullets[i].alive = 0; continue; }
+            bullets[i].y -= 6;
+        }
+
+        /* advance enemies */
+        for (i = 0; i < MAX_ENEMIES; ++i) {
+            if (!enemies[i].alive) continue;
+            enemies[i].y += 1;
+            if (enemies[i].y >= 224) enemies[i].alive = 0;
+        }
+
+        /* spawn waves */
+        spawn_timer++;
+        if (spawn_timer >= 36) { spawn_timer = 0; spawn(); }
+
+        /* bullet vs enemy */
+        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 < 9999) score += 10;
+                    draw_score();
+                    psg_tone(3, 0x040, 28);
+                    sfx_timer = 6;
+                    break;
+                }
+            }
+        }
+
+        /* free the SFX channels so they're blips, not drones */
+        if (sfx_timer) {
+            --sfx_timer;
+            if (sfx_timer == 0) { psg_off(2); psg_off(3); }
+        }
+
+        /* push sprites: player(0), bullets(1..6), enemies(7..12) */
+        set_sprite(0, player.x, player.y, SHIP_VRAM >> 6, 0);
+        for (i = 0; i < MAX_BULLETS; ++i) {
+            u16 by = bullets[i].alive ? bullets[i].y : 0x1F0;  /* park off-screen */
+            set_sprite((u8)(1 + i), bullets[i].x, by, BULLET_VRAM >> 6, 1);
+        }
+        for (i = 0; i < MAX_ENEMIES; ++i) {
+            u16 ey = enemies[i].alive ? enemies[i].y : 0x1F0;
+            set_sprite((u8)(7 + i), enemies[i].x, ey, ENEMY_VRAM >> 6, 2);
+        }
+        satb_dma();
+    }
+}

package/examples/pce/sports/main.c

@@ -0,0 +1,254 @@
+/*
+ * PC Engine "sports" — a Pong-style two-paddle scaffold.
+ *
+ * Two paddles and a bouncing ball on a netted court. The d-pad moves player 1's
+ * (left) paddle up/down. Player 2's (right) paddle follows the ball with a
+ * chase-AI so the game is playable solo. The ball deflects off paddles and the
+ * top/bottom court lines; a ball past either edge scores for the other side and
+ * re-serves. Score is shown with background digit tiles. Mirrors the
+ * NES/Genesis/SNES/GB/SMS sports scaffolds.
+ *
+ * Paddles + ball are hardware sprites; the court (green field, white border
+ * lines, dashed centre net) is the BG tilemap, so the screen is clearly a
+ * sports court (clears the verify gate).
+ *
+ * PCE notes (see pce_hw.h / MENTAL_MODEL.md):
+ *   - disp_enable() turns on BG + sprites + the VBlank IRQ (waitvsync needs it).
+ *   - .bss must be non-empty (pce_video.c's _pce_keep[] covers it).
+ *
+ * cc65 is C89 — declare locals at the top of a block.
+ */
+#include <pce.h>
+#include <stdint.h>   /* int8_t/int16_t for ball velocity + positions         */
+#include "pce_hw.h"
+
+/* ---- VRAM layout (word addresses) --------------------------------------- */
+#define BAT_VRAM     0x0000
+#define FONT_VRAM    0x1000   /* digit tiles                                 */
+#define GREEN_VRAM   0x1400   /* court field (colour 1)                      */
+#define LINE_VRAM    0x1410   /* court line / border (colour 2)             */
+#define NET_VRAM     0x1420   /* dashed centre net                         */
+#define PADDLE_VRAM  0x1800   /* 16x16 paddle segment                       */
+#define BALL_VRAM    0x1840   /* 16x16 ball                                  */
+
+#define BAT_ENTRY(pal, vram)  ((u16)(((pal) << 12) | ((vram) >> 4)))
+
+#define COURT_TOP   24
+#define COURT_BOT   216
+#define PADDLE_H    48          /* 3 stacked 16px sprite segments             */
+#define BALL_SIZE   12
+#define PADDLE_X1   16
+#define PADDLE_X2   224
+
+/* ---- font (digits only) ------------------------------------------------- */
+#define NUM_GLYPHS 10
+static const u8 FONT5x7[NUM_GLYPHS][7] = {
+    {0x0E,0x11,0x13,0x15,0x19,0x11,0x0E}, /* 0 */
+    {0x04,0x0C,0x04,0x04,0x04,0x04,0x0E}, /* 1 */
+    {0x0E,0x11,0x01,0x02,0x04,0x08,0x1F}, /* 2 */
+    {0x1F,0x02,0x04,0x02,0x01,0x11,0x0E}, /* 3 */
+    {0x02,0x06,0x0A,0x12,0x1F,0x02,0x02}, /* 4 */
+    {0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E}, /* 5 */
+    {0x06,0x08,0x10,0x1E,0x11,0x11,0x0E}, /* 6 */
+    {0x1F,0x01,0x02,0x04,0x08,0x08,0x08}, /* 7 */
+    {0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E}, /* 8 */
+    {0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C}  /* 9 */
+};
+
+/* ---- state -------------------------------------------------------------- */
+static int16_t p1y, p2y, bx, by;
+static int8_t  bdx, bdy;
+static u8  score_p1, score_p2;
+static u8  serve_timer;
+static u8  pad;
+static u16 tile_buf[16];
+static u16 spr_buf[64];
+static u8  sfx_timer;
+
+static void make_solid_tile(u16 *t, u8 ci) {
+    u8 r;
+    u8 p0 = (ci & 1) ? 0xFF : 0x00;
+    u8 p1 = (ci & 2) ? 0xFF : 0x00;
+    u8 p2 = (ci & 4) ? 0xFF : 0x00;
+    u8 p3 = (ci & 8) ? 0xFF : 0x00;
+    for (r = 0; r < 8; ++r) {
+        t[r]     = (u16)(p0 | (p1 << 8));
+        t[r + 8] = (u16)(p2 | (p3 << 8));
+    }
+}
+
+/* net tile: green field (colour 1) with a colour-2 vertical dash centre column */
+static void make_net_tile(u16 *t) {
+    u8 r;
+    for (r = 0; r < 8; ++r) {
+        u8 dash = (r < 5);   /* dashed: top 5 rows of each tile are the dash  */
+        u8 p1 = dash ? 0x18 : 0x00;  /* centre 2 px -> colour 2 (plane1)       */
+        t[r]     = (u16)(0x00FF | (p1 << 8));  /* plane0 full (green) + dash   */
+        t[r + 8] = 0x0000;
+    }
+}
+
+static void make_paddle_sprite(void) {
+    u8 r;
+    for (r = 0; r < 64; ++r) spr_buf[r] = 0;
+    /* a solid 8px-wide vertical bar centred in the 16px cell, colour 1 */
+    for (r = 0; r < 16; ++r) spr_buf[r] = 0x0FF0;
+    load_tiles(PADDLE_VRAM, spr_buf, 64);
+}
+
+static void make_ball_sprite(void) {
+    static const u16 ball[16] = {
+        0x0000, 0x0000, 0x07E0, 0x0FF0, 0x1FF8, 0x1FF8, 0x3FFC, 0x3FFC,
+        0x3FFC, 0x3FFC, 0x1FF8, 0x1FF8, 0x0FF0, 0x07E0, 0x0000, 0x0000
+    };
+    u8 r;
+    for (r = 0; r < 64; ++r) spr_buf[r] = 0;
+    for (r = 0; r < 16; ++r) spr_buf[r] = ball[r];   /* colour 1 */
+    load_tiles(BALL_VRAM, spr_buf, 64);
+}
+
+static void upload_font(void) {
+    u8 g, row, bits, plane0;
+    for (g = 0; g < NUM_GLYPHS; ++g) {
+        for (row = 0; row < 16; ++row) tile_buf[row] = 0;
+        for (row = 0; row < 7; ++row) {
+            bits = FONT5x7[g][row];
+            plane0 = 0;
+            if (bits & 0x10) plane0 |= 0x40;
+            if (bits & 0x08) plane0 |= 0x20;
+            if (bits & 0x04) plane0 |= 0x10;
+            if (bits & 0x02) plane0 |= 0x08;
+            if (bits & 0x01) plane0 |= 0x04;
+            tile_buf[row] = (u16)plane0;
+        }
+        load_tiles((u16)(FONT_VRAM + g * 16), tile_buf, 16);
+    }
+}
+
+static void draw_court(void) {
+    u8 r, c;
+    u16 g  = BAT_ENTRY(0, GREEN_VRAM);
+    u16 ln = BAT_ENTRY(0, LINE_VRAM);
+    u16 nt = BAT_ENTRY(0, NET_VRAM);
+    u16 e;
+    for (r = 0; r < 32; ++r) {
+        vram_set_write_addr((u16)(BAT_VRAM + r * 32));
+        for (c = 0; c < 32; ++c) {
+            if (r <= 2 || r >= 27)       e = ln;   /* top/bottom border       */
+            else if (c == 1 || c == 30)  e = ln;   /* sidelines               */
+            else if (c == 16)            e = nt;   /* centre net              */
+            else                          e = g;    /* field                   */
+            VDC_DATA_LO = (u8)(e & 0xFF);
+            VDC_DATA_HI = (u8)(e >> 8);
+        }
+    }
+}
+
+static void put_glyph(u8 col, u8 row, u8 digit) {
+    u16 e = BAT_ENTRY(0, (u16)(FONT_VRAM + digit * 16));
+    vram_set_write_addr((u16)(BAT_VRAM + row * 32 + col));
+    VDC_DATA_LO = (u8)(e & 0xFF);
+    VDC_DATA_HI = (u8)(e >> 8);
+}
+
+static void draw_scores(void) {
+    put_glyph(12, 1, (u8)(score_p1 % 10));
+    put_glyph(19, 1, (u8)(score_p2 % 10));
+}
+
+static void serve_ball(u8 to_left) {
+    bx = 120; by = 110;
+    bdx = to_left ? -2 : 2;
+    bdy = ((score_p1 + score_p2) & 1) ? -1 : 1;
+    serve_timer = 40;
+}
+
+void main(void) {
+    u8 i;
+
+    _pce_keep[0] = 0;
+
+    /* palette */
+    vce_set_color(0,   PCE_RGB(0, 1, 0));   /* backdrop dark green          */
+    vce_set_color(1,   PCE_RGB(0, 4, 1));   /* BG c1: court green           */
+    vce_set_color(2,   PCE_RGB(7, 7, 7));   /* BG c2: white lines/net/digit */
+    vce_set_color(256, PCE_RGB(0, 0, 0));   /* spr pal0 transparent         */
+    vce_set_color(257, PCE_RGB(7, 7, 7));   /* spr pal0 c1: white paddle    */
+    vce_set_color(272, PCE_RGB(0, 0, 0));   /* spr pal1 transparent         */
+    vce_set_color(273, PCE_RGB(7, 7, 0));   /* spr pal1 c1: yellow ball     */
+
+    upload_font();
+    make_solid_tile(tile_buf, 1); load_tiles(GREEN_VRAM, tile_buf, 16);
+    make_solid_tile(tile_buf, 2); load_tiles(LINE_VRAM, tile_buf, 16);
+    make_net_tile(tile_buf);      load_tiles(NET_VRAM, tile_buf, 16);
+    make_paddle_sprite();
+    make_ball_sprite();
+
+    draw_court();
+
+    p1y = 90; p2y = 90;
+    score_p1 = 0; score_p2 = 0;
+    sfx_timer = 0;
+    serve_ball(0);
+    draw_scores();
+
+    pce_joy_init();
+    disp_enable();
+
+    for (;;) {
+        u8 slot;
+        int16_t target;
+        waitvsync();
+
+        /* stage sprites: P1 paddle (3 segs), P2 paddle (3 segs), ball */
+        slot = 0;
+        for (i = 0; i < 3; ++i)
+            set_sprite(slot++, PADDLE_X1, (u16)(p1y + i * 16), PADDLE_VRAM >> 6, 0);
+        for (i = 0; i < 3; ++i)
+            set_sprite(slot++, PADDLE_X2, (u16)(p2y + i * 16), PADDLE_VRAM >> 6, 0);
+        set_sprite(slot++, (u16)bx, (u16)by, BALL_VRAM >> 6, 1);
+        satb_dma();
+
+        pad = pce_joy_read();
+
+        /* P1 control */
+        if ((pad & PCE_JOY_UP)   && p1y > COURT_TOP)            p1y -= 3;
+        if ((pad & PCE_JOY_DOWN) && p1y < COURT_BOT - PADDLE_H) p1y += 3;
+
+        /* P2 chase-AI */
+        target = (int16_t)(by - PADDLE_H / 2 + BALL_SIZE / 2);
+        if (p2y < target && p2y < COURT_BOT - PADDLE_H) p2y += 2;
+        else if (p2y > target && p2y > COURT_TOP)       p2y -= 2;
+
+        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); psg_tone(1, 0x280, 18); sfx_timer = 4; }
+            if (by + BALL_SIZE > COURT_BOT) { by = (int16_t)(COURT_BOT - BALL_SIZE); bdy = (int8_t)(-bdy); psg_tone(1, 0x280, 18); sfx_timer = 4; }
+
+            /* left paddle */
+            if (bdx < 0 && bx <= PADDLE_X1 + 12 && bx + BALL_SIZE >= PADDLE_X1 &&
+                by + BALL_SIZE > p1y && by < p1y + PADDLE_H) {
+                bdx = (int8_t)(-bdx);
+                bx = PADDLE_X1 + 12;
+                psg_tone(0, 0x200, 22); sfx_timer = 4;
+            }
+            /* right paddle */
+            if (bdx > 0 && bx + BALL_SIZE >= PADDLE_X2 && bx <= PADDLE_X2 + 12 &&
+                by + BALL_SIZE > p2y && by < p2y + PADDLE_H) {
+                bdx = (int8_t)(-bdx);
+                bx = (int16_t)(PADDLE_X2 - BALL_SIZE);
+                psg_tone(0, 0x200, 22); sfx_timer = 4;
+            }
+
+            /* scoring */
+            if (bx < 2)   { if (score_p2 < 9) score_p2++; draw_scores(); psg_tone(0, 0x100, 24); sfx_timer = 8; serve_ball(0); }
+            if (bx > 246) { if (score_p1 < 9) score_p1++; draw_scores(); psg_tone(0, 0x100, 24); sfx_timer = 8; serve_ball(1); }
+        }
+
+        if (sfx_timer) { --sfx_timer; if (sfx_timer == 0) { psg_off(0); psg_off(1); } }
+    }
+}

package/examples/sms/main.c

@@ -47,9 +47,10 @@ static void vdp_init(void) {
 }
 
 /* ─── Palette + tile data ─────────────────────────────────────────── */
-/* SMS CRAM: 2-2-2 BGR. Entry 0 = backdrop. */
+/* SMS CRAM: 2-2-2 BGR. Entry 0 = backdrop. Entries: 1 = yellow 'H',
+ * 2 = blue panel, 3 = dark-blue panel (the checkerboard fill colours). */
 static const uint8_t palette[32] = {
-  0x30, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   /* BG: blue, yellow */
+  0x10, 0x0F, 0x30, 0x14, 0x00, 0x00, 0x00, 0x00,   /* BG: backdrop, yellow, blue, dk-blue */
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   /* sprite palette unused */
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -68,6 +69,23 @@ static const uint8_t tile_h[32] = {
   0x00, 0x00, 0x00, 0x00,
 };
 
+/* Tile 2 = solid colour 2 (blue), tile 3 = solid colour 3 (dark blue).
+ * The whole 32×24 screen is painted as a 2-colour checkerboard so the
+ * screen is obviously not blank and no single colour dominates. Plane 1
+ * set → colour 2; planes 0+1 set → colour 3. */
+static const uint8_t tile_fill2[32] = {
+  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,
+};
+static const uint8_t tile_fill3[32] = {
+  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,
+};
+
 /* ─── Upload helpers ──────────────────────────────────────────────── */
 static void load_palette(void) {
   uint8_t i;
@@ -77,16 +95,27 @@ static void load_palette(void) {
 
 static void load_tile(void) {
   uint8_t i;
-  /* Tile 1 at VRAM offset 32 (= tile_idx * 32). Tile 0 left blank. */
+  /* Tile 1 = 'H' at VRAM offset 32 (= tile_idx * 32). Tile 0 left blank. */
   vdp_set_addr(32, VDP_VRAM_WRITE);
   for (i = 0; i < 32; i++) PORT_VDP_DATA = tile_h[i];
+  /* Tile 2 = blue fill (offset 64), tile 3 = dark-blue fill (offset 96). */
+  vdp_set_addr(64, VDP_VRAM_WRITE);
+  for (i = 0; i < 32; i++) PORT_VDP_DATA = tile_fill2[i];
+  vdp_set_addr(96, VDP_VRAM_WRITE);
+  for (i = 0; i < 32; i++) PORT_VDP_DATA = tile_fill3[i];
 }
 
+/* Paint the whole 32×24 visible screen as a blue/dark-blue checkerboard so
+ * the screen is obviously not blank and no single colour dominates. */
 static void clear_name_table(void) {
-  uint16_t i;
+  uint8_t row, col;
   vdp_set_addr(0x3800, VDP_VRAM_WRITE);
-  /* 32 cols × 28 rows × 2 bytes = 1792 entries. */
-  for (i = 0; i < 1792; i++) PORT_VDP_DATA = 0;
+  for (row = 0; row < 24; row++) {
+    for (col = 0; col < 32; col++) {
+      PORT_VDP_DATA = ((row ^ col) & 1) ? 2 : 3;   /* checkerboard tiles 2/3 */
+      PORT_VDP_DATA = 0;                            /* attr: BG palette, no flip */
+    }
+  }
 }
 
 static void place_h(void) {