romdevtools 0.26.0 → 0.28.0

package/examples/atari2600/templates/sports.asm

@@ -116,14 +116,15 @@ MAIN:
   STA VSYNC
 
   ; ── VBLANK (37 lines) — game logic ────────────────────────────────
-  ; 34 here + the 3 STA WSYNC in the P0/P1 positioning block below = 37 VBLANK
-  ; lines total. (Bug fix: this loop used to be 37 AND the positioning added 3
-  ; more → 265 scanlines/frame → the TV/emulator can't lock vsync → rolling /
-  ; black picture. Exactly 262 lines = 3 VSYNC + 37 VBLANK + 192 visible + 30
-  ; overscan; the positioning WSYNCs MUST be counted against the 37.)
+  ; 32 here + the 5 STA WSYNC in the positioning block below (P0, P1,
+  ; HMOVE, ball, ball-HMOVE) = 37 VBLANK lines total. (Bug fix history:
+  ; this loop used to be 37 AND the positioning added more → >262
+  ; scanlines/frame → the TV/emulator can't lock vsync → rolling /
+  ; black picture. Exactly 262 lines = 3 VSYNC + 37 VBLANK + 192 visible
+  ; + 30 overscan; every positioning WSYNC MUST be counted against the 37.)
   LDA #2
   STA VBLANK
-  LDX #34
+  LDX #32
 .vb:
   STA WSYNC
   DEX
@@ -133,16 +134,22 @@ MAIN:
   LDA FRAME
   AND #$01
   BNE .skip_pad
+  ; Kernel convention: Y counts 192->2 top-to-bottom, so LARGER Y is
+  ; HIGHER on screen. DOWN must therefore DECREASE P0_Y (the old code
+  ; had it backwards — stick down moved the paddle up). 2 px/frame so
+  ; the paddle isn't sluggish.
   LDA SWCHA
   ASL                 ; right (unused)
   ASL                 ; left (unused)
   ASL                 ; down
   BCS .nd
-  INC P0_Y
+  DEC P0_Y
+  DEC P0_Y
 .nd:
   ASL                 ; up
   BCS .nu
-  DEC P0_Y
+  INC P0_Y
+  INC P0_Y
 .nu:
   ; Clamp paddle within bounds
   LDA P0_Y
@@ -246,10 +253,35 @@ MAIN:
   DEX
   BNE .p1d           ; ~64 cycles in (< 76) → P1 lands near the right
   STA RESP1
-  ; Line 3 of 3: apply HMOVE on a FRESH line, right after WSYNC
+  ; Line 3: apply HMOVE on a FRESH line, right after WSYNC
   STA WSYNC
   STA HMOVE
 
+  ; Lines 4-5: position the BALL horizontally at BALL_X.
+  ; THE "ball never moves" fix: RESBL was defined but never strobed, so
+  ; the ball sat at whatever column the TIA powered up with, forever.
+  ; Standard divide-by-15 coarse strobe + HMBL fine offset, re-done every
+  ; frame so BALL_X changes actually show on screen.
+  STA WSYNC
+  LDA BALL_X
+  CLC
+  ADC #14              ; +14: compensate the loop's minimum latency
+  SEC
+.bdiv:
+  SBC #15
+  BCS .bdiv            ; A = remainder - 15 (in -15..-1)
+  STA RESBL            ; coarse: ball lands at the loop-exit column
+  EOR #$FF             ; fine: remainder -> HMBL nibble
+  ASL
+  ASL
+  ASL
+  ASL
+  STA HMBL
+  STA WSYNC
+  STA HMOVE            ; apply the fine offset on a fresh line
+  LDA #0
+  STA HMBL             ; don't re-shift on later HMOVEs
+
   LDA #0
   STA VBLANK
 

package/examples/atari7800/templates/hello_sprite.c

@@ -27,10 +27,14 @@
 #define SWCHA     (*(volatile uint8_t*)0x280)
 
 /* SWCHA bit pattern (port A, active LOW — invert before testing) */
-#define JOY_UP    0x80
-#define JOY_DOWN  0x40
-#define JOY_LEFT  0x20
-#define JOY_RIGHT 0x10
+/* SWCHA P0 nibble, active-low after the ~SWCHA invert. The bit order is
+ * Right/Left/Down/Up from bit7 down — the OLD defines here were exactly
+ * REVERSED (UP=0x80 etc.), which made up/down move the sprite left/right
+ * on every 7800 scaffold. */
+#define JOY_RIGHT 0x80
+#define JOY_LEFT  0x40
+#define JOY_DOWN  0x20
+#define JOY_UP    0x10
 
 /* 16-pixel-wide ball (= 4 bytes in 160A mode), 8 rows tall. */
 static const uint8_t sprite_row0[4] = { 0x05, 0x55, 0x55, 0x50 };

package/examples/atari7800/templates/platformer.c

@@ -25,10 +25,14 @@
 #define SWCHA     (*(volatile uint8_t*)0x280)
 #define INPT4     (*(volatile uint8_t*)0x0C)
 
-#define JOY_UP    0x80
-#define JOY_DOWN  0x40
-#define JOY_LEFT  0x20
-#define JOY_RIGHT 0x10
+/* SWCHA P0 nibble, active-low after the ~SWCHA invert. The bit order is
+ * Right/Left/Down/Up from bit7 down — the OLD defines here were exactly
+ * REVERSED (UP=0x80 etc.), which made up/down move the sprite left/right
+ * on every 7800 scaffold. */
+#define JOY_RIGHT 0x80
+#define JOY_LEFT  0x40
+#define JOY_DOWN  0x20
+#define JOY_UP    0x10
 
 /* 16-pixel-wide (= 4 bytes in 160A), 8 rows tall player ball. */
 static const uint8_t player_row0[4] = { 0x05, 0x55, 0x55, 0x50 };
@@ -126,10 +130,10 @@ static void vblank_wait(void) {
 }
 
 /* Physics in 4.4 fixed point — 16 = 1 px, allows half-pixel velocity. */
-#define GRAVITY    8
-#define MOVE_PX    1
-#define JUMP_VEL  (-48)
-#define MAXFALL    48
+#define GRAVITY    6
+#define MOVE_PX    2   /* 1 px/frame read as 'doesn't move' — 2 is snappy */
+#define JUMP_VEL  (-80)  /* was -48: a 10px hop over ~12 frames read as 'jumps very slowly' — this is ~27px in the same time */
+#define MAXFALL    64
 #define GROUND_Y   200   /* DLL index of the ground line */
 
 void main(void) {

package/examples/atari7800/templates/puzzle.c

@@ -31,8 +31,11 @@
 #define SWCHA     (*(volatile uint8_t*)0x280)
 #define INPT4     (*(volatile uint8_t*)0x0C)
 
-#define JOY_LEFT  0x20
-#define JOY_RIGHT 0x10
+/* SWCHA bit order is Right(0x80)/Left(0x40)/Down(0x20)/Up(0x10) — the
+ * old 0x20/0x10 masks here were the DOWN/UP bits, so the stick's
+ * vertical axis steered horizontally. */
+#define JOY_LEFT  0x40
+#define JOY_RIGHT 0x80
 
 #define COLS         8
 #define CELL_W_PIX   8
@@ -181,11 +184,11 @@ void main(void) {
     if (pad & JOY_RIGHT && piece_x_col < COLS - 1) { piece_x_col++; set_x((uint8_t)(60 + piece_x_col * CELL_W_PIX)); }
 
     btn = (INPT4 & 0x80) ? 0 : 1;
-    if (btn && !prev_btn) { fall_timer = 30; sfx_tone(0, 4, 4); }
+    if (btn && !prev_btn) { fall_timer = 18; sfx_tone(0, 4, 4); }
     prev_btn = btn;
 
     fall_timer++;
-    if (fall_timer >= 30) {
+    if (fall_timer >= 18) {  /* was 30 — 'moving down very slowly' */
       fall_timer = 0;
       piece_y++;
       if (piece_y >= BOT_Y) {

package/examples/atari7800/templates/racing.c

@@ -27,8 +27,11 @@
 #define CTRL      (*(volatile uint8_t*)0x3C)
 #define SWCHA     (*(volatile uint8_t*)0x280)
 
-#define JOY_LEFT  0x20
-#define JOY_RIGHT 0x10
+/* SWCHA bit order is Right(0x80)/Left(0x40)/Down(0x20)/Up(0x10) — the
+ * old 0x20/0x10 masks here were the DOWN/UP bits, so the stick's
+ * vertical axis steered horizontally. */
+#define JOY_LEFT  0x40
+#define JOY_RIGHT 0x80
 
 /* 16-pixel-wide (= 4 bytes in 160A) × 8 row car sprite. */
 static const uint8_t car_row0[4] = { 0x05, 0x55, 0x55, 0x50 };

package/examples/atari7800/templates/shmup.c

@@ -31,10 +31,14 @@
 #define SWCHA     (*(volatile uint8_t*)0x280)
 #define INPT4     (*(volatile uint8_t*)0x0C)
 
-#define JOY_UP    0x80
-#define JOY_DOWN  0x40
-#define JOY_LEFT  0x20
-#define JOY_RIGHT 0x10
+/* SWCHA P0 nibble, active-low after the ~SWCHA invert. The bit order is
+ * Right/Left/Down/Up from bit7 down — the OLD defines here were exactly
+ * REVERSED (UP=0x80 etc.), which made up/down move the sprite left/right
+ * on every 7800 scaffold. */
+#define JOY_RIGHT 0x80
+#define JOY_LEFT  0x40
+#define JOY_DOWN  0x20
+#define JOY_UP    0x10
 
 /* Ship sprite — 16 px wide × 8 rows. */
 static const uint8_t ship_row0[4] = { 0x00, 0x05, 0x50, 0x00 };

package/examples/atari7800/templates/sports.c

@@ -31,8 +31,11 @@
 #define CTRL      (*(volatile uint8_t*)0x3C)
 #define SWCHA     (*(volatile uint8_t*)0x280)
 
-#define P1_UP    0x80
-#define P1_DOWN  0x40
+/* SWCHA bit order is Right(0x80)/Left(0x40)/Down(0x20)/Up(0x10) — the
+ * old 0x80/0x40 masks were the RIGHT/LEFT bits, so the stick's
+ * horizontal axis moved the paddle vertically. */
+#define P1_UP    0x10
+#define P1_DOWN  0x20
 #define P2_UP    0x08
 #define P2_DOWN  0x04
 
@@ -169,7 +172,7 @@ static void serve_ball(uint8_t to_left) {
   bx = 76;
   by = 120;
   bdx = to_left ? -2 : 2;
-  bdy = 1;
+  bdy = 2;             /* was 1 — the rally felt 'very slow' */
 }
 
 void main(void) {

package/examples/c64/templates/platformer.c

@@ -62,17 +62,6 @@ static const uint8_t platforms[][3] = {
 };
 #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) { }
@@ -88,33 +77,48 @@ static void copy_sprite(uint8_t slot, const uint8_t *data) {
  * 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;
+  uint8_t sc, r, i, c8;
+  uint16_t wc, off;
+  uint8_t wallrow[VIS_ROWS];
+  /* PERFORMANCE IS LOAD-BEARING HERE. The old version re-scanned the
+   * 10-entry platform table for EVERY CELL and computed a 16-bit modulo
+   * (a cc65 library call) per sky cell — ~2 SECONDS per re-render at
+   * 1 MHz, re-run on every 8-px coarse step. The game spent nearly all
+   * its time in here: scrolling froze, jump presses were eaten between
+   * the multi-second loop passes, and the sprite setup after the first
+   * renders didn't run for hundreds of frames. This version flags each
+   * column's platform rows ONCE (40 table scans total, not 1000) and
+   * uses mask arithmetic for the sky texture. ~20x faster. */
   for (sc = 0; sc < VIS_COLS; sc++) {
     wc = (uint16_t)coarseCol + sc;
+    c8 = (uint8_t)wc;
+    for (r = 0; r < VIS_ROWS; r++) wallrow[r] = 0;
+    if (wc < WORLD_COLS) {
+      for (i = 0; i < N_PLATFORMS; i++) {
+        if (c8 >= platforms[i][0] && c8 < platforms[i][1])
+          wallrow[platforms[i][2]] = 1;
+      }
+    }
+    off = 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)) {
+      if (wallrow[r]) {
         SCREEN[off] = 0xA0;          /* reverse-space solid block */
         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. */
+        /* dithered earth below the floor row */
         SCREEN[off] = 0xA0;
-        COLORS[off] = (((uint8_t)wc ^ r) & 1) ? 0x09 : 0x08;  /* brown / orange */
+        COLORS[off] = ((c8 ^ r) & 1) ? 0x09 : 0x08;  /* brown / orange */
       } else {
-        /* 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) {
+        /* textured sky: sparse '.' stars on a cheap AND-mask lattice */
+        if (((uint8_t)(c8 + (r << 2)) & 15) == 0) {
           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 */
+          COLORS[off] = ((c8 ^ (r >> 1)) & 1) ? 0x06 : 0x0E;  /* blue / light blue */
         }
       }
+      off += 40;
     }
   }
 }

package/examples/c64/templates/puzzle.c

@@ -133,28 +133,89 @@ static void new_piece(void) {
   piece_y = -3;
 }
 
+/* ── match / clear / gravity core (ported from the GBC reference puzzle).
+ * The old scan was horizontal-only AND cleared cells mid-scan, so vertical
+ * and diagonal runs never cleared, 4+ runs half-cleared, and nothing ever
+ * fell afterwards ("rows don't shift down"). This marks every 3+ run in all
+ * 4 directions, clears them, applies per-column gravity, and loops so
+ * cascades chain (score scales with chain depth). */
+static uint8_t matched[ROWS][COLS];
+static const int8_t DIRS4[4][2] = { {0,1}, {1,0}, {1,1}, {1,-1} };
+
+static uint8_t mark_and_count(void) {
+  uint8_t r, c, d, len, k, cnt;
+  uint8_t col;
+  int8_t dr, dc;
+  int sr, sc;
+  cnt = 0;
+  for (r = 0; r < ROWS; r++) for (c = 0; c < COLS; c++) matched[r][c] = 0;
+  for (r = 0; r < ROWS; r++) {
+    for (c = 0; c < COLS; c++) {
+      col = grid[r][c];
+      if (col == 0) continue;
+      for (d = 0; d < 4; d++) {
+        dr = DIRS4[d][0]; dc = DIRS4[d][1];
+        sr = (int)r - dr; sc = (int)c - dc;
+        if (sr >= 0 && sr < ROWS && sc >= 0 && sc < COLS
+            && grid[sr][sc] == col) continue;  /* not the run's start */
+        len = 1;
+        sr = (int)r + dr; sc = (int)c + dc;
+        while (sr >= 0 && sr < ROWS && sc >= 0 && sc < COLS
+               && grid[sr][sc] == col) { len++; sr += dr; sc += dc; }
+        if (len >= 3) {
+          sr = r; sc = c;
+          for (k = 0; k < len; k++) {
+            if (!matched[sr][sc]) { matched[sr][sc] = 1; cnt++; }
+            sr += dr; sc += dc;
+          }
+        }
+      }
+    }
+  }
+  return cnt;
+}
+
+/* collapse each column so survivors rest on the floor (in place: walk
+ * from the bottom, copying gems down to a write cursor, then zero above) */
+static void apply_gravity(void) {
+  uint8_t c;
+  int r, w;
+  for (c = 0; c < COLS; c++) {
+    w = ROWS - 1;
+    for (r = ROWS - 1; r >= 0; r--) {
+      if (grid[r][c] != 0) { grid[w][c] = grid[r][c]; w--; }
+    }
+    for (; w >= 0; w--) grid[w][c] = 0;
+  }
+}
+
+static void resolve_board(void) {
+  uint8_t n, r, c, chain;
+  unsigned int amt;
+  chain = 0;
+  while (1) {
+    n = mark_and_count();
+    if (n == 0) break;
+    chain++;
+    for (r = 0; r < ROWS; r++)
+      for (c = 0; c < COLS; c++)
+        if (matched[r][c]) grid[r][c] = 0;
+    amt = (unsigned int)n * 10u;
+    if (chain > 1) amt = amt * chain;
+    if (score < 65500u) score += amt;
+    sfx_tone(0, 0x80, 0x10, 12);  /* clear chime */
+    apply_gravity();
+  }
+}
+
 static void lock_piece(void) {
-  uint8_t i, c;
+  uint8_t i;
   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 < 65500u) score += 30;
-        sfx_tone(0, 0x80, 0x10, 12);
-      }
-    }
-  }
+  resolve_board();
   draw_grid();
 }
 

package/examples/c64/templates/racing.c

@@ -82,6 +82,15 @@ void main(void) {
   POKE(VIC_BORDER, 0x00);
   POKE(VIC_BG0,    0x09);  /* brown road */
 
+  /* Clear screen RAM: a .prg starts over the BASIC screen, so the
+   * KERNAL's startup text (the leftover the playtest saw at the top)
+   * stays visible until someone wipes it. */
+  {
+    uint16_t k;
+    volatile uint8_t *scr = (volatile uint8_t*)0x0400;
+    for (k = 0; k < 1000; k++) scr[k] = 0x20;
+  }
+
   player.x = LANE1_X; player.y = 220; player.alive = 1;
   for (i = 0; i < MAX_OBS; i++) obstacles[i].alive = 0;
   spawn_timer = 0;

package/examples/c64/templates/shmup.c

@@ -91,11 +91,23 @@ static void fire(void) {
   }
 }
 
+/* Galois LFSR (taps $B8), period 255 -- real per-spawn randomness.
+ * The old code derived the spawn column from spawn_timer, but the caller
+ * resets spawn_timer just before calling here, so it was CONSTANT and
+ * every enemy spawned in the same left column/lane. */
+static uint8_t rng_state = 0xA5;
+static uint8_t rand8(void) {
+  uint8_t lsb = (uint8_t)(rng_state & 1);
+  rng_state >>= 1;
+  if (lsb) rng_state ^= 0xB8;
+  return rng_state;
+}
+
 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].x = (uint8_t)(24 + (rand8() % 232));
       enemies[i].y = 30;
       enemies[i].alive = 1;
       return;

package/examples/c64/templates/sports.c

@@ -96,7 +96,11 @@ void main(void) {
 
   /* P1 paddle on left, P2 on right. */
   POKE(VIC_SPRITE_X(0), 30);
-  POKE(VIC_SPRITE_X(1), 240);
+  /* P2 at X=310 — the right side of the REAL court. The old 240 sat only
+   * ~2/3 across the screen ("computer player too close to center"): C64
+   * sprite X is 9-bit, the extra bit lives in $D010, and the court design
+   * had been squeezed into 8 bits. */
+  POKE(VIC_SPRITE_X(1), 310 - 256);
 
   sfx_init();
   POKE(VIC_SPR_ENA, 0x07);
@@ -122,16 +126,17 @@ void main(void) {
       bdx = -bdx; sfx_tone(0, 0x40, 0x20, 3);
     }
     /* Paddle 2 collision */
-    if (bdx > 0 && bx > 232 && bx < 248 && by > p2y - 8 && by < p2y + 22) {
+    if (bdx > 0 && bx > 296 && bx < 314 && by > p2y - 8 && by < p2y + 22) {
       bdx = -bdx; sfx_tone(0, 0x40, 0x20, 3);
     }
     /* Score */
-    if (bx < 5)   { p2_score++; if (p2_score > 9) p2_score = 0; sfx_noise(20); bx = 150; by = 130; bdx = 2; }
-    if (bx > 250) { p1_score++; if (p1_score > 9) p1_score = 0; sfx_tone(0, 0x80, 0x10, 16); bx = 150; by = 130; bdx = -2; }
+    if (bx < 5)   { p2_score++; if (p2_score > 9) p2_score = 0; sfx_noise(20); bx = 170; by = 130; bdx = 2; }
+    if (bx > 330) { p1_score++; if (p1_score > 9) p1_score = 0; sfx_tone(0, 0x80, 0x10, 16); bx = 170; by = 130; bdx = -2; }
 
     POKE(VIC_SPRITE_Y(0), p1y);
     POKE(VIC_SPRITE_Y(1), p2y);
     POKE(VIC_SPRITE_X(2), (uint8_t)bx);
+    POKE(VIC_SPRITES_X8, (uint8_t)(0x02 | ((bx > 255) ? 0x04 : 0x00)));
     POKE(VIC_SPRITE_Y(2), (uint8_t)by);
   }
 }

package/examples/gb/templates/platformer.c

@@ -116,10 +116,11 @@ void main(void) {
     const Rect *p;
     const int16_t GRAVITY = 10;
     const int16_t MOVE    = 20;
-    const int16_t JUMP    = -180;
+    const int16_t JUMP    = -140;  /* was -180: ~100px peak (most of the screen) — 'jumps a little too high' */
     const int16_t MAXFALL = 280;
 
     lcd_init_default();
+    sound_init();
     enable_vblank_irq();   /* MANDATORY: HALT-driven wait_vblank. Without this,
                             * busy-poll wait_vblank runs ~1/30 speed on the WASM
                             * emulator and the game loop appears to hang. */
@@ -169,7 +170,10 @@ void main(void) {
         if (pad & PAD_RIGHT) vx =  MOVE;
 
         grounded = on_platform(ipx, ipy);
-        if ((pad & PAD_A) && !(prev & PAD_A) && grounded) vy = JUMP;
+        if ((pad & PAD_A) && !(prev & PAD_A) && grounded) {
+            vy = JUMP;
+            sound_play_tone(1, 1750, 8);    /* jump blip (ch2 square) */
+        }
         prev = pad;
 
         vy += GRAVITY;