TRAINS

TRAINS displays an animated train moving across the screen in either left or right direction, using 18 user-defined graphics characters (UDGs A through R) to compose the locomotive and carriages. The UDG bitmap data is loaded via a GOSUB routine that POKEs 144 bytes into the UDG area starting at USR “A”. The train animation is achieved by rotating a 32-character string one character at a time each loop iteration, simulating smooth scrolling. Speed is controlled by a user-supplied PAUSE value, and pressing ENTER at any point resets the display and prompts for new settings. The DATA statements use the variable `y` (which is uninitialized and therefore 0 in Sinclair BASIC) as a shorthand for zero-value bytes in the UDG definitions.

---

Program Structure

The program is organized into three logical sections: initialization and UDG loading (lines 20–130), left-direction animation loop (lines 160–280), and right-direction animation loop (lines 290–420), plus the UDG-loading subroutine at lines 430–640.

1. Lines 20–130: Draw a baseline, load UDGs via GOSUB, dimension and initialize the string variables, and prompt for speed (n) and direction (D$).
2. Lines 160–280: Left-moving animation — rotates a$ (train body) and c$ (smoke/cab top) leftward one character per iteration.
3. Lines 290–420: Right-moving animation — rotates a$ rightward and prepends from f$ (smoke for rightward travel).
4. Lines 430–640: GOSUB subroutine that READs 144 bytes and POKEs them into the UDG area starting at USR "A", defining 18 custom characters (A through R).

UDG Definition Technique

The subroutine at line 430 uses a FOR loop iterating x from 0 to 143, READing one byte at a time and POKEing it to USR "A"+x. This defines 18 UDGs (18 × 8 = 144 bytes) covering characters A through R, which together form the locomotive cab, body, wheels, and carriages when assembled into the display string a$.

The “y” Variable as Zero Placeholder

Throughout the DATA statements (lines 470–630), the identifier y appears frequently. In Sinclair BASIC, an uninitialized numeric variable defaults to 0, so y is used as a compact stand-in for the value 0 within the DATA list. This avoids typing repeated zeros and is a space-saving idiom, though it relies on y never having been assigned a non-zero value elsewhere — which holds here since the only use of y as a live variable is in the FOR loop counter at line 430 (where it is the READ target, immediately consumed by POKE). Actually, looking more carefully, y in the FOR loop at line 430 is the READ destination: READ y. After the subroutine returns, y will hold the last value read (0), so using it in DATA as a zero placeholder is safe for all DATA lines that are read after line 430 executes — and all DATA is consumed within that subroutine.

String-Rotation Animation

Smooth scrolling is achieved by treating the 32-character strings as circular buffers. For leftward movement, the first character of a$ is saved, the string is rebuilt as a$(2 TO 32)+b$, and the result is printed. For rightward movement the last character is extracted and prepended. The smoke string (c$ or f$) is similarly rotated one row above the train body on row 0. This rotation-by-slicing technique is a classic Sinclair BASIC scrolling idiom.

Speed and Keypress Control

The user enters a PAUSE value n at line 110; small values produce fast animation and larger values slow it down. Within each animation loop, CODE INKEY$=13 (line 260 / line 400) checks for the ENTER key — if detected, the screen is cleared and the program restarts from line 20, allowing the user to choose a new speed and direction without a full restart.

Bugs and Anomalies

• Loop counter reset (lines 250, 390): IF b=32 THEN LET b=1 is effectively dead code — after this line executes, NEXT b immediately increments b to 2 (or 33 before loop exit), so resetting to 1 does not cause the loop to repeat. The loop runs exactly 32 iterations regardless.
• Right-rotation string growth (lines 330, 350): In the rightward loop, f$=g$+f$ and a$=b$+a$ prepend without trimming, so these strings grow by one character each iteration. After 32 iterations a$ will be 57 characters long (25 initial + 32 prepended). This will cause display overflow onto adjacent screen positions and is a likely bug; the left loop correctly trims by slicing (2 TO 32).
• Line 120 — UDG-M appears twice, UDG-L is absent: The train string references [UDG-M] twice consecutively and skips [UDG-L], which may be intentional (two identical carriage-side segments) or a typo.
• STOP at lines 280 and 420: After one pass of 32 iterations the loop ends and hits STOP rather than looping continuously. Combined with the dead reset code, the animation only runs one 32-step cycle before halting.

Variable Summary

Variable	Purpose
n	PAUSE duration (speed control)
a$	32-char train body string (UDG characters)
b$	Temporary single character during rotation
c$	32-char smoke/top row string for leftward travel
D$	Direction input (“R”/”L”)
e$	Temporary character for rotating c$
f$	32-char smoke/top row string for rightward travel
g$	Temporary character for rotating f$
x	UDG POKE loop counter
y	READ target; doubles as 0 placeholder in DATA
b	Animation loop counter