Checkers

This program implements a two-player checkers (draughts) game where a human plays against a computer opponent on an 8×8 board. The board state is stored in a one-dimensional array Q(99), where piece positions are encoded using ASCII character codes: H for human checkers, K for human kings, C for computer checkers, and $ for computer kings. The computer’s move selection uses a scored candidate list S(10) combined with RND-based random selection, and falls back to random wandering if no strategic moves are found within 300 attempts. King promotion is handled by scanning rows 11–18 for computer pieces and rows 82–88 for human pieces after each move. The title screen uses OVER 1 and block graphic characters (█) to draw a checkerboard pattern, with FLASH and INVERSE attributes applied to a scrolling “CHECKERS ANYONE?” display.

Program Structure

The program is organized into several logical sections accessed via GO SUB:

• Lines 1–3: Title/splash screen with scrolling CHECKERS text using inverse characters and BEEP.
• Lines 10–110: Main game loop. POKE 23658,8 enables caps-lock mode. The flow calls initialization (GO SUB 1010), then alternates between the computer move routine (GO SUB 600, GO SUB 130) and the human move routine (GO SUB 760).
• Lines 130–580: Computer AI — candidate move scoring, jump detection, and piece movement.
• Lines 600–750: Board display and win detection.
• Lines 760–990: Human input handler, move validation, jump logic, and king promotion.
• Lines 1010–1260: Initialization — array setup, board population from DATA statements, direction vectors.
• Lines 1270–1330: Special-case logic forcing the computer to advance a piece to the king row.
• Lines 1340–9998: Utility routines — delay loop, decorative checkerboard overlay, and animated title card.

Board Representation

The board is a flat array Q(99) indexed by a two-digit row-column scheme (e.g., position 34 = row 3, column 4). Squares are initialized to OF=-99 as an off-board sentinel. Valid squares are seeded from 64 DATA pairs (position, piece-code). The piece encoding uses ASCII codes directly:

Variable	ASCII char	Meaning
H	H (72)	Human checker
HK	K (75)	Human king
C	C (67)	Computer checker
CK	$ (36)	Computer king
E	space (32)	Empty square

This allows the board to be printed directly using CHR$ (Q(F+G)) at line 660 without any translation table — an efficient trick that blends storage and display.

Direction Vectors

Movement directions are stored in N(4), loaded from DATA -11,-9,11,9. Indices 1–2 represent forward (toward lower row numbers, i.e., the computer’s advancing direction) and indices 3–4 represent backward. A regular checker uses B up to 2; a king uses B up to 4. This is checked with the guard IF B<2 OR (Q(A)=CK AND B<4) at lines 230 and 380.

Computer AI

The computer’s move generation (lines 130–580) scans all positions from 89 down to 11. For each computer piece found, it evaluates up to 4 directions. Capture moves (jump over an adjacent human piece into an empty landing square) are executed immediately at line 280. Non-capture moves are scored and stored in S(SC) as 100*A + B + 20, encoding both the source square and direction index into a single integer. A random candidate is then selected from the list.

If no scored moves exist (SC=0), the computer falls back to random piece selection (lines 470–550), retrying up to 300 times before conceding at line 560. This is a simple but functional fallback that prevents lockup in sparse board positions.

The subroutine at lines 1270–1330 provides a special override: if a computer piece is on row 2 (positions 21–28) and the corresponding king-row square is empty, it forces that advancing move and sets flag FL=1 to bypass the normal move selection.

Human Input and Validation

The human enters moves as two separate INPUT values: the source position A and destination B, each as a two-digit row-column number. Entry of 99 at the “FROM” prompt concedes the game. Validation checks that the source contains a human piece (H or HK) and the destination is empty. Jumps are detected by ABS(A-B)>=12 at line 900 — if the move spans more than one row step, it is treated as a capture and the intermediate square is cleared at line 940. The player is then asked if they wish to jump again, supporting multi-jump turns.

King Promotion

After the human moves, lines 850–880 scan rows 11–17 (positions 11–18) for computer pieces that have reached the human’s back rank and promote them to CK, and rows 82–88 for human pieces to promote to HK. The same scan is repeated at lines 950–960 after a capture, ensuring promotion happens correctly mid-multi-jump. Note that line 855 contains LET CH= CODE "$", which assigns a value to CH but this variable is never subsequently used — it appears to be an unused remnant.

Display Routine

The board is rendered at lines 600–680 by printing the column header, then iterating F from 80 to 10 in steps of -10 (rows 8 down to 1), printing CHR$ (Q(F+G)) for each column G from 1 to 8. Win detection at line 690 checks if either capture count (CO for computer, HU for human) has reached 12.

Title Screen Animation

Lines 1564–1700 draw a decorative checkerboard using PRINT OVER 1 with solid block graphic characters (█) across multiple rows, then display “CHECKERS ANYONE?” one character at a time with FLASH 1 and INVERSE 1 active, producing a flashing inverse-video crawl effect.

Notable Anomalies

• Line 310 references LET A=M+N where N is the scalar initialized at line 1010 as 0, not the array N(). This means after a computer jump, the re-jump scan starts from the original landing square offset by 0, which is likely a bug where N(B) was intended.
• The condition at line 220 is extremely long and complex, combining multiple strategic heuristics (avoiding squares attacked by human pieces, preferring safe destinations) in a single IF chain. It is difficult to verify correctness and likely contains logical oversights.
• Line 855 sets CH= CODE "$" inside the king-promotion loop but CH is never read elsewhere in the program.
• The DIM S(10) at line 1060 limits the scored move list to 10 entries, but the guard at line 400 is IF SC<10, so only indices 1–10 are used safely.