Maze Dash

Maze Dash is a single-player maze navigation game in which the player steers a character (represented by the dollar sign) rightward through a randomly generated vertical-barrier maze, trying to exit through the right side while colliding with as few walls as possible. The maze is built using a loop that prints inverse-video space characters every two columns across the screen, then punches random gaps in each barrier using a RND-positioned blank print. Collision detection is performed via a direct PEEK of the display file, calculated from the system variables at addresses 16396–16397 to find the base of the screen memory, then checking whether the character at the player’s new position equals 128 (inverse space). The score starts at 20000, decreasing by 50 each move and by 673 per wall hit, with a penalty of dividing by three for going out of bounds; the high score is preserved across multiple rounds. The FAST/SLOW mode toggle is offered before maze generation, and key-repeat is implemented by remembering the last pressed key in variable A$.

---

Program Analysis

Program Structure

The program is organised into several logical blocks spread across line ranges:

• Lines 0–3: Title REM and immediate jump to the introduction routine at line 6000.
• Lines 4–125: Maze initialisation — speed selection, maze drawing, player start-up via GOSUB 9000.
• Lines 150–165: Wall-hit subroutine — decrements score by 673 and displays it.
• Lines 167–500: Main game loop — reads keyboard, moves player, checks collisions, handles out-of-bounds.
• Lines 510–580: End-of-round summary, high-score flash animation, and play-again prompt.
• Lines 6000–6090: Introduction screen with inverse-video title, instructions, and a software delay loop.
• Lines 9000–9500: Player initialisation subroutine — sets starting position, score, and switches to SLOW mode.
• Lines 9888–9993: Housekeeping — STOP, RND seed helper, CLEAR, SAVE.

The entry point is line 6000 (via GOTO 6000 at line 3), which eventually jumps to line 7 — a non-existent line that falls through to line 9, the speed-selection prompt. This is a deliberate “fall-through” idiom common in Sinclair BASIC.

Maze Generation

The maze is constructed in two phases. First, vertical barriers are drawn every two columns (FOR B=2 TO 28 STEP 2) by printing inverse spaces ("% ") from row 0 to row 19. Then a random gap is cut in each barrier with:

PRINT AT RND*14+3,B;" "

This places a one-cell opening somewhere between rows 3 and 17, ensuring no gap appears at the very top or bottom rows (which are covered by the horizontal borders drawn in lines 60–110). The borders themselves use the block graphic \## (a solid block character) printed along rows 0 and 19 (top/bottom) and column 0 and 30 (left/right).

Display-File Collision Detection

Rather than maintaining an array of wall positions, the game reads directly from the ZX81 display file to detect collisions. Line 233 performs:

IF PEEK (PEEK 16396+256*PEEK 16397+33*A+B+1)=128 THEN GOSUB 150

System variables at addresses 16396 and 16397 hold the low and high bytes of the display file base address (D_FILE). Each screen row occupies 33 bytes (32 character positions plus a NEWLINE at the start of each line in the ZX81 format), so the offset 33*A+B+1 locates the character at row A, column B. The value 128 is an inverse space, confirming the player has entered a barrier cell.

Player Movement and Key Repeat

Movement uses a concise BASIC idiom at lines 220–230:

• LET A=A+(Z$="Z")-(Z$="Q") — moves down (Z) or up (Q) by evaluating boolean expressions as 1 or 0.
• LET B=B+(Z$="L") — moves right only; there is no leftward movement, which is intentional given the objective.

Key repeat is implemented by storing the last pressed key in A$ (line 490) and substituting it when INKEY$ returns an empty string (line 170). This gives the player continuous motion without re-pressing a key.

Scoring

Event	Score change
Each move (always)	−50
Wall collision	−673
Out-of-bounds (top/bottom/left)	Score divided by 3 (INT)
Exiting right side	Round ends

The starting score is 20000 (set at line 9020). The high score (U) is preserved across rounds but resets on a fresh program start via line 6002.

End-of-Round Animation

Lines 530–552 produce a flashing effect by alternating inverse and normal renderings of the player character and the “HIGH SCORE” label six times in a tight FOR loop with no delay other than the PRINT overhead, creating a visible flicker on real hardware.

FAST/SLOW Mode Handling

Before maze generation, the player is offered the option to watch the maze being drawn. Choosing option 2 invokes FAST (line 12) so drawing is invisible; choosing option 1 skips to line 15 leaving the display active so the barriers appear incrementally. In either case, SLOW is restored inside the initialisation subroutine at line 9490 before returning to the game loop.

Bugs and Anomalies

• Line 580 performs GOTO 5, but line 5 does not exist. The interpreter falls through to line 9 (the speed-selection prompt), which is the intended replay entry point — this is intentional fall-through behaviour.
• The out-of-bounds check at line 255 applies the score penalty but does not prevent the player from actually occupying the out-of-bounds cell; the terminal check at line 260 ends the round. A single step out of bounds therefore triggers both the divide-by-three penalty and immediate round termination.
• There is no leftward movement key, so a player who overshoots a gap cannot backtrack — this is a design constraint, not a bug.
• Line 9975 (LET R=RND*RND*RND) and line 9991 (CLEAR) are unreachable dead code; they appear to be development remnants.
• The INPUT ANS at line 562 expects a numeric value; entering a non-numeric response will cause a BASIC error rather than being handled gracefully.