Buster-Bill’s Obsession

“Buster-Bill’s Obsession” (also titled “Block Buster” in the instructions) is a puzzle-action game in which the player steers a character around a grid of blocks, defusing time bombs before they detonate. The 20×30 character grid is stored entirely as a string array m$(20,30), allowing row-shift mechanics using BASIC’s string slicing — pressing keys 1 or 2 rotates the player’s current row left or right by concatenating substrings. Sixteen user-defined graphics (UDGs “a” through “p”) are loaded from DATA statements to draw the player sprite, safe blocks, flags, and bombs. The game supports up to nine progressive difficulty levels, with the number of bombs per level determined by the formula l*3+3, and includes a persistent high-score tracked across playthroughs within the same session.

---

Program Analysis

Program Structure

The program is organized into clearly delineated sections, each introduced by a REM statement:

• Lines 5–60: Initialization, UDG setup (via GO SUB 5000), title screen, and key-wait.
• Lines 70–900: Core game loop — screen/level setup, main movement and collision logic, bomb handling, and row-shift mechanics.
• Lines 1000–1060: Life-loss handler with death animation.
• Lines 2000–2060: Game-over screen with replay prompt and high-score update.
• Lines 3000–3040: Level-completion bonus and level advancement.
• Lines 4000–4540: Screen setup, map initialization, display refresh, and random-position subroutine.
• Lines 5000–5090: UDG data loader.
• Lines 6000–6070: Instructions screen.

Grid and Map Representation

The entire playfield is stored as a two-dimensional string array m$(20,30), where each cell holds one character of the display. This means collision detection, block content checks, and rendering all operate directly on this string array rather than a separate numeric map. Block tiles occupy two rows and two columns of UDG characters, so the logical grid is 10×15 tiles within the 20-row, 30-column character space (column 0 is reserved for the score/status line).

The player position (a, b) and all sprite positions are stored in even/odd row and column coordinates matching this two-character-wide tile layout.

Row-Shift Mechanic

The most technically notable feature is the row-scrolling mechanic on keys 1 and 2. Lines 610–640 and 700–720 implement a circular left or right shift of both rows of the player’s current tile row using BASIC string concatenation and slicing:

• Left shift (key 1): m$(a+x) = m$(a+x, 3 TO ) + m$(a+x) — appends the full string to its own tail, then implicitly truncates to 30 chars.
• Right shift (key 2): m$(a+x) = m$(a+x, 29 TO ) + m$(a+x) — similarly wraps from the rightmost two characters.

After each shift, the flag position (f2) and bomb position (b2) are adjusted by ±2 to track with their tile, and wrap-around at columns −1 and 31 is corrected at lines 810–820.

Movement and Wrapping

Player movement uses keys 5–8 (standard cursor keys). Lines 510–520 add or subtract 2 from a (row) or b (column) and then wrap with arithmetic: a = a + (20 AND a<1) - (20 AND a>19). This idiom exploits BASIC’s boolean values (1/0) as integers — a well-known Spectrum BASIC optimization that avoids IF statements inside the tight game loop.

Bomb Timer and Display

The bomb timer t counts down from 50 (adjusted by level: 50-1*4 — note the 1 here should arguably be l, suggesting a possible bug where bomb timing does not scale with level). When active, line 190 displays a flashing countdown at the bomb location and emits a beep pitched to the timer value. The bomb is placed in the map array with UDG characters, and its map coordinates are stored in b1, b2. A value of t=-1 signals no active bomb.

UDG Character Set

Sixteen UDGs (“a” through “p”) are defined via 128 bytes of DATA loaded at line 5010. Their roles as used in the program are:

UDG pair	Role
\:: / \a (top), \b / \c (bottom)	Safe block tile
\d / \e (top), \f / \g (bottom)	Flag
\h / \i (top), \j / \k (bottom)	Unactivated bomb
\l / \m (top), \n / \o (bottom)	Player sprite

Note that \:: (the solid block graphic, char 143) is used as part of the block tile pattern alongside UDG “a”, giving a distinctive checkerboard appearance to the playing field.

Level Progression and Scoring

The number of bombs per level is l*3+3, stored in the numeric array m() which records each bomb’s row for later retrieval. Level advances when bo (bombs defused) exceeds l*3+3 (line 170). The level cap is 9 (l=l+(l<9)). Scoring events include: +2 per block cleared, +20 for reaching a flag, +15 per bomb defused, and a level-completion super bonus of 55*l.

Notable Bugs and Anomalies

• Non-scaling bomb timer: Line 200 sets t=50-1*4. The literal 1 is almost certainly meant to be the level variable l, meaning bombs always have a timer of 46 regardless of level. This appears to be a typographical error.
• Duplicate + operator: Line 4520 reads LET z=INT (RND*15)*2++1 — the double + is syntactically valid (unary plus) and evaluates correctly to *2+1, but is likely a typo.
• Score multiplier: Line 150 computes sc=sc+1*15. The 1* is redundant (again, likely meant to be l*15 for level-scaled scoring), so bomb defusal always awards exactly 15 points.
• String truncation in row-shift: The shifted row string is assigned back into the fixed-length m$() array entry, which automatically truncates to 30 characters — a convenient side effect of Sinclair BASIC’s fixed-length string arrays.
• Death animation: Line 1010 iterates x from 7 to 0 step −0.2, using a fractional step to slow the flash-to-dark color transition of the player sprite — an effective visual effect using the INK attribute cycle.

Key Input Handling

The main loop polls INKEY$ without a PAUSE, meaning the game runs as fast as BASIC allows. The guard IF x$<"5" THEN GO TO 540 at line 500 efficiently filters out non-movement keys before the movement arithmetic, falling through to the row-shift handler at line 540 only for keys “1” and “2”.