Towers of Hanoi

This program implements the Towers of Hanoi puzzle on a pixel-graphics display, supporting both manual play and an automated computer solver. The display uses PLOT/UNPLOT to draw disc representations on three pegs drawn with block graphics characters, and the game tracks move counts against the theoretical minimum of 2ⁿ−1. The computer solver at line 700 uses two different movement strategies depending on whether the disc count is odd or even, cycling through pairs of pegs (subroutine 900) until all discs reach peg 3. Disc size is encoded as an integer in a two-dimensional array D(N,3), with a stack-pointer array N(3) tracking the top disc on each peg.

---

Program Analysis

Program Structure

The program is organized into clearly delineated sections accessed via GOSUB:

Line range	Purpose
65–185	Initialization: screen drawing, disc count input, stack setup
185–285	Main game loop: manual move input and validation
300–382	Move execution subroutine (calls UNPLOT and PLOT routines, updates arrays)
383–397	Win/new-game handler
400–460	PLOT subroutine — draws a disc on a peg
500–580	UNPLOT subroutine — erases a disc from a peg
600–695	Computer-solve prompt subroutine
700–780	Computer solver — even disc count strategy
800–855	Computer solver — odd disc count strategy
900–935	Single legal move between a peg pair
940–960	CLEAR, SAVE and RUN for auto-restart

Data Representation

Two arrays manage the puzzle state. N(3) (declared at line 140, shadowing the scalar N which holds the disc count — note the name collision) acts as a stack pointer for each of the three pegs. D(N,3) is a 2-D array where D(k,p) holds the size of disc at position k on peg p. Disc sizes run from 1 (smallest) to N (largest). A value of 0 in D means the slot is empty.

There is a notable naming collision: the variable N is first used as the disc count scalar, then DIM N(3) at line 140 replaces it with an array. Sinclair BASIC allows a scalar and an array to share the same letter, so both coexist, with N (scalar) remaining accessible as the disc count and N(x) being the stack-pointer array.

Display Technique

The three pegs are represented as vertical columns of block-graphic characters ("\@@" — solid block characters) drawn with PRINT AT in lines 75–86. Disc graphics are rendered with PLOT/UNPLOT in the pixel domain. The PLOT subroutine (lines 400–460) computes a horizontal centre H = 20*Y - 6 for each peg and a vertical coordinate V = 27 + 2*N(Y), then plots symmetric pairs of pixels outward from the centre for each unit of disc size. The UNPLOT subroutine mirrors this to erase. This gives discs a proportional pixel-width representation.

Input Handling

All key input uses the pattern of printing a flashing cursor (alternating plain "?" and inverse "%?"), then reading CODE INKEY$ in a tight loop. This is a standard TS2068/Spectrum idiom for single-keypress input without blocking via INPUT. Digit keys 1–8 have CODE values 29–36 (Sinclair key codes), checked at lines 116 and 215/242. The ENTER/NEW-LINE key has code 118, checked at line 395.

Computer Solver Algorithm

The solver does not use recursion. Instead it exploits the cyclic property of the Tower of Hanoi: for an even number of discs, the optimal solution is achieved by repeatedly cycling moves in the order (1→2), (1→3), (2→3); for odd disc counts the order is (1→3), (1→2), (3→2). The cycle repeats until peg 3 holds all discs, then jumps to the win handler at line 383.

Subroutine 900 (lines 905–935) implements a single legal move between pegs P and Q: it picks the peg with the smaller top disc (or the non-empty peg if one is empty) as the source, then calls the move execution subroutine at 300.

Move Validation

Manual moves are validated at lines 257–270. If the destination stack is non-empty (N(Y)>0) and the moving disc is not smaller than the top disc on the destination, the move is rejected as illegal. An empty destination always accepts any disc (line 257). Same-peg moves are caught at line 250.

Win Condition

The game checks N(3)=N (i.e., the stack pointer for peg 3 equals the total disc count) at lines 275 and 760/820. When satisfied, the win handler prints a prompt and waits for ENTER to start a new game via GOTO 2 (a non-existent line, which causes the program to fall through to the next available line — line 65 — a well-known Sinclair BASIC technique).

Notable Techniques

• Flashing cursor using alternating plain and inverse ? with PRINT AT over the same position.
• Pixel-level disc drawing with PLOT/UNPLOT symmetrically around a peg centre.
• Non-recursive computer solver using a fixed peg-pair cycling strategy differentiated by disc parity.
• The SAVE "1026%1" at line 950 uses an inverse character in the filename as an auto-run marker.
• VAL (CHR$ C) at lines 117 and 245 converts a key code to its digit value without a lookup table.

Bugs and Anomalies

• Line 270 uses GOTO 200 and line 285 uses GOTO 2, both targeting non-existent lines; execution resumes at the next existing line (205 and 65 respectively). This is intentional Sinclair BASIC shorthand.
• The subroutine nominally starting at line 300 actually begins at line 305, since there is no line 300. The GOSUB 300 calls at lines 271 and 930 correctly fall through to line 305.
• Line 703 resets NN=0 for the computer solver run but this does not reset the on-screen counter until the first move is printed; a minor cosmetic inconsistency.
• The win check at line 275 only tests N(3)<N and jumps to 200 if false, meaning it only detects victory when all discs are on peg 3, which is the conventional goal but means the game cannot end on peg 1 or 2.