Tunnel Run

Tunnel Run is a four-stage space navigation game in which the player pilots a ship through a missile tunnel, an asteroid field, a winding tunnel, and finally a landing pad. Each stage uses a different subset of keys: 5 and 8 for lateral movement, 0 to fire in the asteroid section, and R for retro-boost during the landing approach. The program defines two custom UDG characters at startup by POKEing eight bytes each into the UDG area starting at USR “\\l”, creating a ship sprite and an asteroid graphic. Collision detection is performed using ATTR to read the color attributes of the cell occupied by the player’s ship, with each stage expecting a specific ink/paper color combination to confirm a safe position. Score is tracked throughout all four sections, with a persistent high score maintained across playthroughs within the same session.

---

Program Structure

The program is divided into clearly sequential sections separated by border/paper color changes used as visual cues for each stage:

1. Initialization and title screen (lines 10–110): UDG setup, instructions, and wait for keypress.
2. Stage 1 — Missile Tunnel (lines 120–450): Blue border, 200-frame loop; player moves laterally across row 0 while a scrolling floor is printed at row 21. ATTR-based collision checks for ink 0/paper 1 (value 8) or ink 4/paper 1 (value 12).
3. Stage 2 — Asteroids (lines 460–770): Red border; player can fire vertically with key 0, scoring −20 per shot and +100 per hit on target asteroid at column c.
4. Stage 3 — Winding Tunnel (lines 780–980): Yellow border; a scrolling gap tu drifts randomly; enemy craft appear at random within the gap.
5. Stage 4 — Landing Pad (lines 990–1230): Black background; player descends vertically (x increments each frame), must align with the yellow landing square at column g.
6. End screens (lines 1240–1290): Crash message or success display with high score and CIRCLE graphic; option to replay from line 90.

UDG Initialization

Lines 10–50 define two custom characters. The loop runs f=0 TO 15, POKEing 16 bytes total into USR "\\l" + f. The first eight bytes (from the DATA at line 30: 0,66,153,189,255,153,66,0) define the UDG at \\l (the ship sprite). The second eight bytes (line 50: 126,60,24,126,126,126,90,24) define the UDG at \\m (used as the player’s ship icon printed at row 0). Note that the DATA at line 30 is interleaved with the loop structure: the READ at line 20 inside the loop reads all 16 values sequentially across both DATA statements.

Collision Detection via ATTR

Each stage uses ATTR (0,a) to determine whether the player’s ship position is safe, relying on the background color rendered at row 0:

Stage	Expected ATTR value(s)	Meaning
Missile Tunnel	8 or 12	INK 0 or INK 4 on PAPER 1 (blue)
Asteroids	16	INK 0 on PAPER 2 (red)
Winding Tunnel	24	INK 0 on PAPER 3 (yellow)
Landing Pad	Column match with g	Positional, not ATTR-based

Any mismatch in stages 1–3 branches to line 1240 (crash). Stage 4 checks a <> g at row 15.

Key BASIC Idioms

• Boolean movement: LET a=a+(INKEY$="8")-(INKEY$="5") — a standard Sinclair BASIC idiom exploiting the fact that boolean expressions evaluate to 1 (true) or 0 (false).
• POKE 23692,255: Resets the scroll counter to suppress the scroll? prompt, preventing the screen from pausing during fast-moving display loops.
• PAUSE 0 / INKEY$ loop: Lines 100–110 use the standard idiom of draining the keyboard buffer before waiting for a fresh keypress.
• Tunnel drift clamping (line 890): LET tu=tu+(tu<1)-(tu>24) keeps the tunnel gap within screen bounds using boolean arithmetic rather than an IF statement.

Stage 2 — Asteroid Firing Mechanic

When the player presses 0, lines 580–650 draw a vertical beam of "I" characters in INK 6 from row 1 to 21 at column a, then check whether a = c (the asteroid’s column). A hit awards +100 points and flashes the asteroid position. The asteroid position c drifts each frame via LET c=c+(RND>.5)-(RND<.5), making it a moving target. A copyright symbol character (\\*) is used as a random obstacle sprite at line 700.

Stage 4 — Landing Pad

The landing section introduces vertical movement: x increments each frame simulating gravity. Pressing key 0 or r decrements x (retro-boost), allowing the player to control descent rate. The target column g is randomized at line 1010. A safe landing requires a = g when x >= 15; any other column at that row causes a crash. Horizontal wrapping is implemented at line 1090: LET a=a+(a<0)-(a>31).

Notable Techniques and Anomalies

• The CIRCLE 125,85,80 at line 1210 is used as a decorative success graphic on the win screen, one of the few uses of the graphics command in the program.
• The transition loop at lines 280–380 acts as a brief “corridor” between stage 1’s main loop and stage 2, printing blank lines to scroll the tunnel display away.
• In stage 3 (line 910), enemy craft appear stochastically: IF RND>.7 THEN PRINT AT 21,(RND*5)+tu; INK 1;"\\l" — the UDG ship character is reused as an enemy sprite.
• The high score high is initialized at line 60 and persists across replays within the session since GO TO 90 does not re-execute line 60.
• Stage 1’s floor at line 210 prints a yellow "^" character (caret, used as a missile sprite) at a random column between 10 and 16, creating an animated hazard on row 21 distinct from the wall blocks.