Checkers

This program implements a draughts (checkers) board game on an 80-cell memory-mapped display area starting at address 16516. The board state is stored directly in PEEK/POKE operations on the display file, using specific byte values (61 for one piece type, 13 and 52/12 for others) to represent pieces and board squares. The direction array D(4) encodes the four diagonal move offsets (11, 9, −9, −11) corresponding to the four diagonal directions on a 9- or 11-wide board layout. The computer’s move logic scans the display memory for valid captures (lines 60–110) before falling back to random single-step moves (lines 120–180), and the human player enters moves by specifying source and destination cell numbers which are translated to memory addresses.

---

Program Analysis

Program Structure

The program divides into three logical sections:

1. Initialisation (line 5000–5200): Sets up the direction array, copies board data from ROM/memory into the display area, seeds the RNG, and returns to begin play.
2. Computer move logic (lines 55–390): First attempts a capturing move, then falls back to a random non-capturing move.
3. Human move input and display (lines 200–480): Prompts for source and destination square numbers, validates the move, updates memory, and redraws the board.

Memory-Mapped Board Representation

The board is stored entirely within the ZX81 display file. The 80-cell region from address 16517 to 16616 (printed at lines 440–470) represents the playable squares. Cell values use specific byte codes:

Value	Meaning
61	Computer piece (SPACE in ZX81 character set = empty cell marker, repurposed)
13	Computer piece (promoted / king)
52	Human piece
12	Human piece (promoted / king)
0	Empty square

The board initialisation at lines 5050–5070 copies 100 bytes from address 16626 downward into 16517, seeding the initial piece layout from pre-existing memory content — an unusual but compact technique that avoids explicit POKE statements for every starting square.

Direction Array and Move Offsets

The array D(4) stores the four diagonal offsets: 11, 9, −9, −11. These correspond to forward-left, forward-right, backward-right, and backward-left moves on a board stored in a linear memory region approximately 9–11 cells wide per row. The subroutine at line 20 uses B as the current cell address and X as the direction index, peeking the current cell (R), the adjacent cell (S = PEEK(B+D(X))), and the cell two steps away (T = PEEK(B+2*D(X))).

Computer AI Logic

The computer’s turn proceeds in two phases:

• Capture scan (lines 55–110): Iterates over all 80 board cells. For each cell containing a computer piece (R=61 for normal, R=13 for king), it checks whether an adjacent cell holds a human piece (S=52 or S=12) and the cell beyond is empty (T=0). If found, execution jumps to line 300 to execute the capture.
• Random move (lines 120–180): Up to 400 attempts are made to find a computer piece with an empty adjacent cell (S=0), then the piece is moved there.

The capture routine at lines 300–390 implements chain captures: after performing a capture it loops back via GOTO 300 to check whether another capture is immediately available from the new position, continuing until no further captures exist.

Promotion (Kinging)

Line 420 checks whether a moved computer piece has reached or passed address 16597 (the far end of the board) and if so, POKEs value 13 to mark it as a king. The equivalent check for the human player is handled at line 230, which POKEs 12 if the destination index is less than 20 (i.e., reached the computer’s back row).

Human Move Input

The human enters moves as square numbers. The program converts these by adding 16516 to obtain the actual memory address (lines 220, 240). The midpoint between source and destination is computed at line 250 — (H+G)/2 — and if the distance is 18 or 22 (the two possible jump distances in this layout), the intermediate cell is cleared to remove the captured piece.

Display Refresh

The board is redrawn at lines 430–472 by reading bytes directly from memory addresses 16517–16616 and printing them via CHR$. Line 460 uses the idiom 10*INT((A+4)/10)=A+4 to detect every tenth cell (end of row), printing a TAB 8 to begin the next row at column 8. The display is anchored at PRINT AT 6,8.

Notable Techniques and Idioms

• FAST/SLOW switching (lines 12, 200, 285, 425) is used to suppress the display flicker during computation-heavy sections while restoring normal display during human interaction.
• RAND at line 5100 (no argument) re-seeds the random number generator, ensuring varied computer openings each game.
• The Z flag (set to 1 at line 5080) allows line 475 to jump back to the capture scan after a human move, enabling the computer to immediately search for captures rather than going through the full initialisation again.
• The subroutine at line 20 (lines 20–50) is called repeatedly within tight loops — a clean factoring of the three-cell lookahead used by both the capture and random-move phases.

Potential Bugs and Anomalies

• Line 230 contains POKE H=16516,12, which is syntactically unusual — this likely should be POKE H+16516,12 or POKE 16516+H,12. As written, it evaluates the Boolean expression H=16516 (0 or 1) as the POKE address, almost certainly a typo for the promotion POKE.
• The board initialisation (lines 5050–5070) relies on specific content at addresses 16626–16725 that is not set by the program itself. This content must exist in memory prior to execution, suggesting the program is intended to be loaded as a saved file where that memory region already contains the board layout.
• No bounds checking is performed on human-entered values G and H, so invalid input could POKE arbitrary memory locations.