romdevtools 0.16.0 → 0.22.0

package/examples/atari7800/templates/platformer.c

@@ -14,6 +14,8 @@
 #define P0C1      (*(volatile uint8_t*)0x21)
 #define P0C2      (*(volatile uint8_t*)0x22)
 #define P0C3      (*(volatile uint8_t*)0x23)
+#define P1C1      (*(volatile uint8_t*)0x25)
+#define P2C1      (*(volatile uint8_t*)0x29)
 #define MSTAT     (*(volatile uint8_t*)0x28)
 #define DPPH      (*(volatile uint8_t*)0x2C)
 #define DPPL      (*(volatile uint8_t*)0x30)
@@ -44,6 +46,40 @@ MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
 
 static uint8_t dl_empty[2] = { 0, 0 };
 
+/* ── Background playfield ─────────────────────────────────────────
+ * Without a full-screen drawable the display list emits only the
+ * player and ~99% of the screen stays the flat BACKGRND colour
+ * (reads as "blank"). These full-width bands give the level a sky,
+ * a field, and a solid ground strip the player stands on.
+ *
+ * A single DL drawable is at most 32 bytes = 128 px wide, so a full
+ * 160-px line needs TWO drawables. Width = byte[3] low 5 bits (32-n);
+ * high 3 bits = palette. */
+static const uint8_t band_pix[32] = {
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+};
+#define MK_BAND(name, pal) static uint8_t name[11] = { \
+  0, 0x40, 0, ((pal) << 5) | 0,  0,    /* 128 px @ x0   */ \
+  0, 0x40, 0, ((pal) << 5) | 24, 128,  /* 32 px  @ x128 */ \
+  0 }
+MK_BAND(dl_field, 1);
+MK_BAND(dl_ground, 2);
+/* Ground strip starts just below where the player rests (GROUND_Y). */
+#define GROUND_ZONE 200
+
+static void set_band_addr(uint8_t* dl) {
+  uint16_t a = (uint16_t)(uintptr_t)band_pix;
+  dl[0] = dl[5] = (uint8_t)(a & 0xFF);
+  dl[2] = dl[7] = (uint8_t)(a >> 8);
+}
+
+static uint16_t bg_zone_dl(int zone) {
+  if (zone >= GROUND_ZONE) return (uint16_t)(uintptr_t)dl_ground;
+  if (zone >= 28)          return (uint16_t)(uintptr_t)dl_field;
+  return (uint16_t)(uintptr_t)dl_empty;
+}
+
 #define DLL_ZONES 243
 static uint8_t dll[DLL_ZONES * 3];
 
@@ -60,7 +96,6 @@ static void set_dll_entry(int idx, uint16_t dl_ptr) {
 }
 
 static void build_dll(uint8_t y) {
-  uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
   int i;
   for (i = 0; i < DLL_ZONES; i++) {
     uint16_t dl;
@@ -74,7 +109,7 @@ static void build_dll(uint8_t y) {
       case 5: dl = (uint16_t)(uintptr_t)dl_row5; break;
       case 6: dl = (uint16_t)(uintptr_t)dl_row6; break;
       case 7: dl = (uint16_t)(uintptr_t)dl_row7; break;
-      default: dl = empty; break;
+      default: dl = bg_zone_dl(i); break;
     }
     set_dll_entry(i, dl);
   }
@@ -112,13 +147,17 @@ void main(void) {
   set_dl_addr(dl_row5, player_row5);
   set_dl_addr(dl_row6, player_row6);
   set_dl_addr(dl_row7, player_row7);
+  set_band_addr(dl_field);
+  set_band_addr(dl_ground);
   set_x((uint8_t)px);
   build_dll((uint8_t)(py16 >> 4));
 
-  BACKGRND = 0x84;
-  P0C1     = 0x46;
+  BACKGRND = 0x84;   /* sky */
+  P0C1     = 0x46;   /* player */
   P0C2     = 0x0F;
   P0C3     = 0x36;
+  P1C1     = 0x96;   /* distant field (teal) */
+  P2C1     = 0x24;   /* ground (brown) */
   CHARBASE = 0;
   OFFSET   = 0;
 

package/examples/atari7800/templates/puzzle.c

@@ -20,6 +20,8 @@
 #define P0C1      (*(volatile uint8_t*)0x21)
 #define P0C2      (*(volatile uint8_t*)0x22)
 #define P0C3      (*(volatile uint8_t*)0x23)
+#define P1C1      (*(volatile uint8_t*)0x25)
+#define P2C1      (*(volatile uint8_t*)0x29)
 #define MSTAT     (*(volatile uint8_t*)0x28)
 #define DPPH      (*(volatile uint8_t*)0x2C)
 #define DPPL      (*(volatile uint8_t*)0x30)
@@ -53,6 +55,37 @@ MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
 
 static uint8_t dl_empty[2] = { 0, 0 };
 
+/* ── Background well ──────────────────────────────────────────────
+ * Without a full-screen drawable the display list emits only the
+ * falling block and ~99% of the screen stays the flat BACKGRND colour
+ * (reads as "blank"). Each well zone draws three full-width segments:
+ * a side wall (palette 2), the playfield well in the centre where the
+ * piece falls (palette 1), the other wall (palette 2). Width =
+ * byte[3] low 5 bits (32-n); high 3 bits = palette. */
+static const uint8_t band_pix[16] = {
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+};
+/* 12 bytes (48 px) wall @ x0, 16 bytes (64 px) well @ x48,
+ * 12 bytes (48 px) wall @ x112, terminator. */
+static uint8_t dl_well[16] = {
+  0, 0x40, 0, (2 << 5) | 20, 0,
+  0, 0x40, 0, (1 << 5) | 16, 48,
+  0, 0x40, 0, (2 << 5) | 20, 112,
+  0
+};
+
+static void set_well_addr(void) {
+  uint16_t a = (uint16_t)(uintptr_t)band_pix;
+  dl_well[0] = dl_well[5] = dl_well[10] = (uint8_t)(a & 0xFF);
+  dl_well[2] = dl_well[7] = dl_well[12] = (uint8_t)(a >> 8);
+}
+
+static uint16_t bg_zone_dl(int zone) {
+  if (zone >= 32 && zone < 200) return (uint16_t)(uintptr_t)dl_well;
+  return (uint16_t)(uintptr_t)dl_empty;
+}
+
 #define DLL_ZONES 243
 static uint8_t dll[DLL_ZONES * 3];
 
@@ -80,7 +113,6 @@ static void set_x(uint8_t x) {
 }
 
 static void build_dll(int y) {
-  uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
   int i;
   for (i = 0; i < DLL_ZONES; i++) {
     uint16_t dl;
@@ -94,7 +126,7 @@ static void build_dll(int y) {
       case 5: dl = (uint16_t)(uintptr_t)dl_row5; break;
       case 6: dl = (uint16_t)(uintptr_t)dl_row6; break;
       case 7: dl = (uint16_t)(uintptr_t)dl_row7; break;
-      default: dl = empty; break;
+      default: dl = bg_zone_dl(i); break;
     }
     set_dll_entry(i, dl);
   }
@@ -120,13 +152,16 @@ void main(void) {
   piece_x_col = COLS / 2;
   piece_y = TOP_Y;
   color_cycle = 0;
+  set_well_addr();
   set_x((uint8_t)(60 + piece_x_col * CELL_W_PIX));
   build_dll(piece_y);
 
-  BACKGRND = 0x00;
-  P0C1 = 0x46;   /* red */
+  BACKGRND = 0x00;   /* black surround */
+  P0C1 = 0x46;   /* falling piece (red) */
   P0C2 = 0x46;
   P0C3 = 0x46;
+  P1C1 = 0x02;   /* well interior (dark blue-grey) */
+  P2C1 = 0x08;   /* well walls (steel) */
   CHARBASE = 0;
   OFFSET = 0;
 

package/examples/atari7800/templates/racing.c

@@ -17,6 +17,8 @@
 #define P0C1      (*(volatile uint8_t*)0x21)
 #define P0C2      (*(volatile uint8_t*)0x22)
 #define P0C3      (*(volatile uint8_t*)0x23)
+#define P1C1      (*(volatile uint8_t*)0x25)
+#define P2C1      (*(volatile uint8_t*)0x29)
 #define MSTAT     (*(volatile uint8_t*)0x28)
 #define DPPH      (*(volatile uint8_t*)0x2C)
 #define DPPL      (*(volatile uint8_t*)0x30)
@@ -44,6 +46,37 @@ MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
 
 static uint8_t dl_empty[2] = { 0, 0 };
 
+/* ── Background road ──────────────────────────────────────────────
+ * Without a full-screen drawable the display list emits only the car
+ * and ~99% of the screen stays the flat BACKGRND colour (reads as
+ * "blank"). Each road zone draws three full-width segments: grass on
+ * the left (palette 1), the grey road down the centre (palette 2),
+ * grass on the right (palette 1). Width = byte[3] low 5 bits (32-n);
+ * high 3 bits = palette. */
+static const uint8_t band_pix[16] = {
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+};
+/* 8 bytes (32 px) grass @ x0, 16 bytes (64 px) road @ x32,
+ * 8 bytes (32 px) grass @ x96, terminator. */
+static uint8_t dl_road[16] = {
+  0, 0x40, 0, (1 << 5) | 24, 0,
+  0, 0x40, 0, (2 << 5) | 16, 32,
+  0, 0x40, 0, (1 << 5) | 24, 96,
+  0
+};
+
+static void set_road_addr(void) {
+  uint16_t a = (uint16_t)(uintptr_t)band_pix;
+  dl_road[0]  = dl_road[5]  = dl_road[10] = (uint8_t)(a & 0xFF);
+  dl_road[2]  = dl_road[7]  = dl_road[12] = (uint8_t)(a >> 8);
+}
+
+static uint16_t bg_zone_dl(int zone) {
+  if (zone >= 16 && zone < 220) return (uint16_t)(uintptr_t)dl_road;
+  return (uint16_t)(uintptr_t)dl_empty;
+}
+
 #define DLL_ZONES 243
 static uint8_t dll[DLL_ZONES * 3];
 
@@ -71,7 +104,6 @@ static void set_x(uint8_t x) {
 }
 
 static void build_dll(void) {
-  uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
   int i;
   for (i = 0; i < DLL_ZONES; i++) {
     uint16_t dl;
@@ -85,7 +117,7 @@ static void build_dll(void) {
       case 5: dl = (uint16_t)(uintptr_t)dl_row5; break;
       case 6: dl = (uint16_t)(uintptr_t)dl_row6; break;
       case 7: dl = (uint16_t)(uintptr_t)dl_row7; break;
-      default: dl = empty; break;
+      default: dl = bg_zone_dl(i); break;
     }
     set_dll_entry(i, dl);
   }
@@ -110,13 +142,16 @@ void main(void) {
   set_dl_addr(dl_row7, car_row7);
 
   lane = 1;
+  set_road_addr();
   set_x(lane_xs[lane]);
   build_dll();
 
-  BACKGRND = 0x88;
-  P0C1     = 0x46;
+  BACKGRND = 0x88;   /* sky/horizon */
+  P0C1     = 0x46;   /* car */
   P0C2     = 0x0F;
   P0C3     = 0x36;
+  P1C1     = 0xC8;   /* roadside grass (green) */
+  P2C1     = 0x06;   /* road surface (grey) */
   CHARBASE = 0;
   OFFSET   = 0;
 

package/examples/atari7800/templates/shmup.c

@@ -20,6 +20,8 @@
 #define P0C1      (*(volatile uint8_t*)0x21)
 #define P0C2      (*(volatile uint8_t*)0x22)
 #define P0C3      (*(volatile uint8_t*)0x23)
+#define P1C1      (*(volatile uint8_t*)0x25)
+#define P2C1      (*(volatile uint8_t*)0x29)
 #define MSTAT     (*(volatile uint8_t*)0x28)
 #define DPPH      (*(volatile uint8_t*)0x2C)
 #define DPPL      (*(volatile uint8_t*)0x30)
@@ -50,6 +52,39 @@ MK_DL(dl_row4); MK_DL(dl_row5); MK_DL(dl_row6); MK_DL(dl_row7);
 
 static uint8_t dl_empty[2] = { 0, 0 };
 
+/* ── Background playfield ─────────────────────────────────────────
+ * Without a full-screen drawable the display list emits only the
+ * ship and ~99% of the screen stays the flat BACKGRND colour (reads
+ * as "blank"). These full-width bands fill the non-ship zones with a
+ * starfield-style background so the frame has real content.
+ *
+ * A single DL drawable is at most 32 bytes = 128 px wide, so a full
+ * 160-px line needs TWO drawables. Width = byte[3] low 5 bits (32-n);
+ * high 3 bits = palette. */
+static const uint8_t band_pix[32] = {
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+};
+#define MK_BAND(name, pal) static uint8_t name[11] = { \
+  0, 0x40, 0, ((pal) << 5) | 0,  0,    /* 128 px @ x0   */ \
+  0, 0x40, 0, ((pal) << 5) | 24, 128,  /* 32 px  @ x128 */ \
+  0 }
+MK_BAND(dl_field, 1);
+MK_BAND(dl_ground, 2);
+#define GROUND_ZONE 188
+
+static void set_band_addr(uint8_t* dl) {
+  uint16_t a = (uint16_t)(uintptr_t)band_pix;
+  dl[0] = dl[5] = (uint8_t)(a & 0xFF);
+  dl[2] = dl[7] = (uint8_t)(a >> 8);
+}
+
+static uint16_t bg_zone_dl(int zone) {
+  if (zone >= GROUND_ZONE) return (uint16_t)(uintptr_t)dl_ground;
+  if (zone >= 28)          return (uint16_t)(uintptr_t)dl_field;
+  return (uint16_t)(uintptr_t)dl_empty;
+}
+
 #define DLL_ZONES 243
 static uint8_t dll[DLL_ZONES * 3];
 
@@ -74,7 +109,6 @@ static void set_x(uint8_t x) {
 }
 
 static void build_dll(int y) {
-  uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
   int i;
   for (i = 0; i < DLL_ZONES; i++) {
     uint16_t dl;
@@ -88,7 +122,7 @@ static void build_dll(int y) {
       case 5: dl = (uint16_t)(uintptr_t)dl_row5; break;
       case 6: dl = (uint16_t)(uintptr_t)dl_row6; break;
       case 7: dl = (uint16_t)(uintptr_t)dl_row7; break;
-      default: dl = empty; break;
+      default: dl = bg_zone_dl(i); break;
     }
     set_dll_entry(i, dl);
   }
@@ -111,6 +145,8 @@ void main(void) {
   set_dl_addr(dl_row5, ship_row5);
   set_dl_addr(dl_row6, ship_row6);
   set_dl_addr(dl_row7, ship_row7);
+  set_band_addr(dl_field);
+  set_band_addr(dl_ground);
 
   player_x = 80;
   player_y = 180;
@@ -121,6 +157,8 @@ void main(void) {
   P0C1     = 0x0F;
   P0C2     = 0x1C;
   P0C3     = 0x46;
+  P1C1     = 0x84;   /* upper nebula band (deep blue) */
+  P2C1     = 0x82;   /* lower nebula band (darker blue) */
   CHARBASE = 0;
   OFFSET   = 0;
 

package/examples/atari7800/templates/sports.c

@@ -21,6 +21,8 @@
 #define P0C1      (*(volatile uint8_t*)0x21)
 #define P0C2      (*(volatile uint8_t*)0x22)
 #define P0C3      (*(volatile uint8_t*)0x23)
+#define P1C1      (*(volatile uint8_t*)0x25)
+#define P2C1      (*(volatile uint8_t*)0x29)
 #define MSTAT     (*(volatile uint8_t*)0x28)
 #define DPPH      (*(volatile uint8_t*)0x2C)
 #define DPPL      (*(volatile uint8_t*)0x30)
@@ -60,6 +62,29 @@ static uint8_t scanline_dls[PLAY_LINES * DL_BYTES_PER_LINE];
 
 static uint8_t dl_empty[2] = { 0, 0 };
 
+/* ── Court border bands ───────────────────────────────────────────
+ * The court itself (per-scanline DLs below) only draws two thin
+ * paddles + a ball, so on a black screen ~99% of the frame is blank.
+ * Fill the zones above and below the court with full-width bands so
+ * the court is framed by visible walls. A single DL drawable is at
+ * most 32 bytes = 128 px wide, so a full 160-px line needs TWO
+ * drawables. Width = byte[3] low 5 bits (32-n); high 3 bits = palette. */
+static const uint8_t band_pix[32] = {
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
+  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
+};
+#define MK_BAND(name, pal) static uint8_t name[11] = { \
+  0, 0x40, 0, ((pal) << 5) | 0,  0,    /* 128 px @ x0   */ \
+  0, 0x40, 0, ((pal) << 5) | 24, 128,  /* 32 px  @ x128 */ \
+  0 }
+MK_BAND(dl_wall, 1);
+
+static void set_band_addr(uint8_t* dl) {
+  uint16_t a = (uint16_t)(uintptr_t)band_pix;
+  dl[0] = dl[5] = (uint8_t)(a & 0xFF);
+  dl[2] = dl[7] = (uint8_t)(a >> 8);
+}
+
 #define DLL_ZONES 243
 static uint8_t dll[DLL_ZONES * 3];
 
@@ -92,19 +117,23 @@ static uint8_t emit_obj(uint8_t* dl, uint8_t off, uint16_t data_addr,
 
 /* Rebuild ALL scanline DLs + DLL based on current object positions. */
 static void rebuild(void) {
+  uint16_t wall = (uint16_t)(uintptr_t)dl_wall;
   uint16_t empty = (uint16_t)(uintptr_t)dl_empty;
   uint16_t solid = (uint16_t)(uintptr_t)solid_row;
   int line;
   int i;
 
-  /* DLL: point each play-area line at its scanline DL slot; everything
-   * else at the empty DL. */
+  /* DLL: point each play-area line at its scanline DL slot; frame the
+   * court with full-width wall bands above and below, leaving a thin
+   * empty gutter right at the court edges. */
   for (i = 0; i < DLL_ZONES; i++) {
     if (i >= COURT_TOP && i < COURT_BOT) {
       uint16_t dlp = (uint16_t)(uintptr_t)&scanline_dls[(i - COURT_TOP) * DL_BYTES_PER_LINE];
       set_dll_entry(i, dlp);
+    } else if (i >= COURT_TOP - 8 && i < COURT_BOT + 8) {
+      set_dll_entry(i, empty);   /* small gutter around the court */
     } else {
-      set_dll_entry(i, empty);
+      set_dll_entry(i, wall);
     }
   }
 
@@ -151,13 +180,15 @@ void main(void) {
   p1y = 110; p2y = 110;
   serve_ball(0);
 
-  BACKGRND = 0x00;   /* black */
-  P0C1     = 0x0F;   /* white sprite */
+  BACKGRND = 0x00;   /* black court */
+  P0C1     = 0x0F;   /* white paddles + ball */
   P0C2     = 0x0F;
   P0C3     = 0x0F;
+  P1C1     = 0x48;   /* court walls (blue) */
   CHARBASE = 0;
   OFFSET   = 0;
 
+  set_band_addr(dl_wall);
   rebuild();
 
   dll_addr = (uint16_t)(uintptr_t)dll;

package/examples/c64/templates/platformer.c

@@ -96,10 +96,24 @@ static void render_view(uint8_t coarseCol) {
       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 */
+        COLORS[off] = 0x0C;          /* mid grey platform */
+      } else if (r >= 22) {
+        /* Ground fill below the floor row: dithered earth so the lower
+         * band reads as solid terrain, not void. */
+        SCREEN[off] = 0xA0;
+        COLORS[off] = (((uint8_t)wc ^ r) & 1) ? 0x09 : 0x08;  /* brown / orange */
       } else {
-        SCREEN[off] = 0x20;          /* space */
-        COLORS[off] = 0x06;          /* bg color */
+        /* Textured sky so two colours share the backdrop and neither the
+         * sky nor the border dominates the frame. Sparse '.' stars on a
+         * coarse lattice add detail; reverse-space everywhere else gives a
+         * filled (non-blank) sky band that scrolls with the world. */
+        if (((wc * 3u + r * 7u) % 23u) == 0u) {
+          SCREEN[off] = 0x2E;        /* '.' distant detail */
+          COLORS[off] = 0x01;        /* white */
+        } else {
+          SCREEN[off] = 0xA0;        /* solid block sky */
+          COLORS[off] = (((uint8_t)wc ^ (r >> 1)) & 1) ? 0x06 : 0x0E;  /* blue / light blue */
+        }
       }
     }
   }
@@ -133,8 +147,8 @@ void main(void) {
   copy_sprite(0, player_sprite);
   SPRITE_POINTERS[0] = 0x80;  /* $2000/64 */
   POKE(VIC_SPR_COL(0), 0x07);  /* yellow player */
-  POKE(VIC_BORDER, 0x06);      /* dark blue */
-  POKE(VIC_BG0,    0x06);
+  POKE(VIC_BORDER, 0x00);      /* black border frames the scene */
+  POKE(VIC_BG0,    0x06);      /* sky-blue (shows through any gaps) */
 
   render_view(0);              /* paint the initial 40-col view */
 

package/examples/c64/templates/puzzle.c

@@ -40,6 +40,35 @@ static void wait_vblank(void) {
   while (PEEK(VIC_RASTER) >= 250) { }
 }
 
+/* Paint the playfield surround so the board reads as a real puzzle screen
+ * instead of a tiny well floating in a black void: a dithered backdrop fills
+ * the whole 40x25 matrix (two dark blues, so two colours share the screen
+ * and neither dominates), then a bright frame is drawn one cell outside the
+ * 6x12 well, and the well interior is cleared to black so the falling blocks
+ * pop. Call ONCE before draw_grid(); draw_grid() owns the interior after. */
+static void draw_field(void) {
+  uint16_t i;
+  uint8_t r, c;
+  int8_t  fr, fc;
+  for (i = 0; i < 1000; i++) {
+    SCREEN[i] = 0xA0;                       /* solid block backdrop */
+    COLORS[i] = ((i ^ (i >> 5)) & 1) ? 0x06 : 0x0E;  /* blue / light blue */
+  }
+  /* Bright frame one cell outside the well. */
+  for (fc = -1; fc <= COLS; fc++) {
+    r = (uint8_t)(GRID_R - 1);       SCREEN[r * 40 + GRID_C + fc] = 0xA0; COLORS[r * 40 + GRID_C + fc] = 0x01;
+    r = (uint8_t)(GRID_R + ROWS);    SCREEN[r * 40 + GRID_C + fc] = 0xA0; COLORS[r * 40 + GRID_C + fc] = 0x01;
+  }
+  for (fr = -1; fr <= ROWS; fr++) {
+    r = (uint8_t)(GRID_R + fr);
+    SCREEN[r * 40 + GRID_C - 1]   = 0xA0; COLORS[r * 40 + GRID_C - 1]   = 0x01;
+    SCREEN[r * 40 + GRID_C + COLS] = 0xA0; COLORS[r * 40 + GRID_C + COLS] = 0x01;
+  }
+  /* Clear the well interior to black so colored blocks stand out. */
+  for (r = 0; r < ROWS; r++)
+    for (c = 0; c < COLS; c++) SCREEN[(GRID_R + r) * 40 + GRID_C + c] = ' ';
+}
+
 static uint8_t rng_pick(void) {
   rng = rng * 1103515245u + 12345u;
   return (uint8_t)(1 + (rng >> 16) % 3);
@@ -131,14 +160,15 @@ static void lock_piece(void) {
 
 void main(void) {
   uint8_t r, c, pad, prev = 0, fall_rate, t;
-  POKE(VIC_BORDER, 0x00);
-  POKE(VIC_BG0,    0x00);
+  POKE(VIC_BORDER, 0x06);   /* blue border frames the playfield */
+  POKE(VIC_BG0,    0x00);   /* black well interior so blocks pop */
 
   for (r = 0; r < ROWS; r++)
     for (c = 0; c < COLS; c++) grid[r][c] = 0;
 
   score = 0; fall_timer = 0;
   sfx_init();
+  draw_field();             /* paint the textured surround + well frame */
   new_piece();
   draw_grid();
 

package/examples/c64/templates/shmup.c

@@ -19,6 +19,9 @@
 #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 SPRITE_POINTERS  ((volatile uint8_t*)0x07F8)
 #define SPRITE_DATA_BASE 0x2000  /* sprite N data at $2000 + N*64 — NOT $0800,
                                   * which collides with the $0801 .prg load (C64-1) */
@@ -105,6 +108,28 @@ static void wait_vblank(void) {
   while (PEEK(VIC_RASTER) >= 250) { }
 }
 
+/* Paint a deep-space backdrop into the 40x25 character matrix so the
+ * playfield reads as space instead of a flat black void. Every cell gets
+ * a dithered "nebula" char (reverse-space 0xA0) in one of two dark blues,
+ * so two colours share the screen and no single colour dominates. A sparse
+ * scatter of bright '.' stars (drawn as a normal glyph over the dither)
+ * adds twinkle. Cosmetic only — sprites still move over the top. */
+static void draw_starfield(void) {
+  uint16_t i;
+  uint8_t r, c;
+  for (i = 0; i < 1000; i++) {
+    SCREEN[i] = 0xA0;                       /* solid block fills the cell  */
+    COLORS[i] = ((i ^ (i >> 5)) & 1) ? 0x06 : 0x0B;  /* blue / dark grey   */
+  }
+  /* Scatter stars on a coarse lattice so ~1 in 12 cells twinkles. */
+  for (r = 1; r < 25; r += 3) {
+    for (c = (uint8_t)(r * 5u % 7u); c < 40; c += 7) {
+      SCREEN[r * 40 + c] = 0x2E;            /* '.' star glyph              */
+      COLORS[r * 40 + c] = ((r + c) & 1) ? 0x01 : 0x0F;  /* white / l.grey */
+    }
+  }
+}
+
 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);
@@ -130,8 +155,9 @@ void main(void) {
   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);
+  POKE(VIC_BORDER, 0x00);   /* black border frames the starfield */
+  POKE(VIC_BG0, 0x06);      /* deep-blue space background */
+  draw_starfield();         /* paint the textured space backdrop */
 
   player.x = 152; player.y = 200; player.alive = 1;
   for (i = 0; i < MAX_BULLETS; i++) bullets[i].alive = 0;

package/examples/c64/templates/sports.c

@@ -11,6 +11,9 @@
 #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
 
@@ -39,6 +42,30 @@ static void wait_vblank(void) {
   while (PEEK(VIC_RASTER) >= 250) { }
 }
 
+/* Paint a Pong court into the 40x25 character matrix so the table reads as
+ * a real court instead of a flat black void: a dithered green playfield
+ * (two greens, so two colours share the screen and neither dominates),
+ * solid top/bottom boundary rails, and a dashed centre net. Cosmetic only —
+ * the paddle/ball sprites move over the top. */
+static void draw_court(void) {
+  uint16_t i;
+  uint8_t r, c;
+  /* Dithered green playfield fills every cell. */
+  for (i = 0; i < 1000; i++) {
+    SCREEN[i] = 0xA0;                       /* solid block */
+    COLORS[i] = ((i ^ (i >> 5)) & 1) ? 0x05 : 0x09;  /* green / brown    */
+  }
+  /* Top + bottom boundary rails (rows 1 and 23) in white. */
+  for (c = 0; c < 40; c++) {
+    SCREEN[1 * 40 + c]  = 0xA0; COLORS[1 * 40 + c]  = 0x01;
+    SCREEN[23 * 40 + c] = 0xA0; COLORS[23 * 40 + c] = 0x01;
+  }
+  /* Dashed centre net (column 20). */
+  for (r = 2; r < 23; r++) {
+    if (r & 1) { SCREEN[r * 40 + 20] = 0xA0; COLORS[r * 40 + 20] = 0x01; }
+  }
+}
+
 static void copy_sprite(uint8_t slot, const uint8_t *data) {
   uint8_t i;
   volatile uint8_t *dst = (volatile uint8_t*)(0x2000 + slot * 64);  /* $2000, not $0800 (collides w/ $0801 .prg) */
@@ -63,8 +90,9 @@ void main(void) {
   POKE(VIC_SPR_COL(1), 0x01);
   POKE(VIC_SPR_COL(2), 0x07);  /* yellow ball */
 
-  POKE(VIC_BORDER, 0x00);
-  POKE(VIC_BG0,    0x00);
+  POKE(VIC_BORDER, 0x00);   /* black border frames the court */
+  POKE(VIC_BG0,    0x05);   /* green court background */
+  draw_court();             /* paint the textured Pong court */
 
   /* P1 paddle on left, P2 on right. */
   POKE(VIC_SPRITE_X(0), 30);