3-D TicTacToe

This program implements a three-dimensional Tic-Tac-Toe game on a 3×3×3 grid, where players designate moves by entering a layer letter (A, B, or C) followed by a position number (1–9). The board is rendered using block graphics to depict three overlapping grids in isometric-style perspective, representing front, middle, and rear planes. Cell coordinates for display are packed into strings X$ and Y$ and decoded at startup by extracting two-character substrings and converting them with VAL, an efficient data-storage technique for position tables. Win detection works by summing A() array values (1 for X, −1 for O) along 13 center-based symmetrical axes and 18 additional non-center lines defined by offset tables C() and R(), scoring accumulated wins in SX and SO rather than halting play after the first three-in-a-row. The first move is restricted from the center square (position 14, the cube’s center), and entering “R” resets the game.

---

Program Structure

The program is organized into a main loop with several subroutines:

• Lines 1–4: Introduction and instructions display
• Lines 5–90: Array and data initialization (dimensions, coordinate tables, win-line tables)
• Lines 100–120: Game state reset
• Lines 170–280: Main game loop (display, input, move processing)
• Lines 390–395: Illegal move handler
• Lines 500–580: Win-detection and scoring subroutine
• Lines 800–810: Score incrementing helper
• Line 900–905: Screen color setup subroutine
• Lines 1000–1090: Board drawing subroutine
• Lines 9997–9999: Stop, SAVE, and VERIFY

Data Encoding in Strings

A compact data-packing technique is used for screen coordinates and win-line definitions. X$ and Y$ (line 30–35) each hold 54 characters encoding 27 two-digit decimal numbers representing screen column and row positions for each of the 27 board cells. Similarly, C$ and R$ (lines 60–65) encode 18 two-digit values each, defining the center cell and offset for additional win-line checks. All values are decoded with VAL X$(2*Z-1 TO 2*Z), a standard Sinclair BASIC string-slicing idiom that avoids the need for DATA/READ statements and saves memory.

Board Representation

The 3×3×3 cube is mapped to a flat array A(27). Layers are addressed as offsets: A=cells 1–9, B=cells 10–18, C=cells 19–27. Player input converts a letter (A/B/C) to a base offset (0, 9, or 18) and adds the digit entered, producing a direct index into A(). Cell 14 is the geometric center of the cube; the program explicitly forbids occupying it on the first move (line 245).

Win Detection Algorithm

Win detection (lines 500–565) operates in two passes rather than checking all 49 lines explicitly:

1. Center-symmetric lines (lines 515–530): For Z=1 to 13, it sums A(14-Z) + A(14) + A(14+Z). Because the center cell is always included and the 13 offsets cover all lines passing through the cube’s center, this elegantly handles all center-passing three-in-a-rows.
2. Non-center lines (lines 535–565): Uses C(Z) as the middle cell and R(Z) as the step offset. It checks both the line and its mirror (V = 28 - C(Z)) to cover symmetric non-center lines on the cube’s faces and diagonals.

Rather than stopping at the first win, scoring accumulates into SX (X wins) and SO (O wins) across all 27 turns, and totals are printed after every move. This means the game is effectively a full-game scoring variant rather than a stop-at-first-win game.

Notable Bugs and Anomalies

• Line 540 double-add bug: LET W=A(C(Z))+A(C(Z))+A(C(Z)+R(Z)) adds the middle cell twice instead of using A(C(Z)-R(Z))+A(C(Z))+A(C(Z)+R(Z)). This means the non-center line check is incorrect — it tests 2×middle + one neighbor rather than left + middle + right. This is a genuine bug that would cause missed or false win detections on non-center lines.
• No input validation beyond occupancy: If the player enters an invalid layer letter or non-numeric digit, VAL Z$(2) may produce 0 or cause an error. No guard against single-character input for the digit is present.
• Center restriction only on move 1: Line 245 prevents the center square on N=1, but the center is otherwise playable from move 2 onward. The instructions describe this rule correctly.
• Game does not end on a win: Play always continues until all 27 cells are filled (N=28 triggers a reset at line 205), at which point the game restarts without displaying final scores prominently.

Board Drawing

The subroutine at lines 1000–1090 draws an isometric-perspective three-layer board using block graphic characters. The three grids (A front, B middle, C rear) are overlaid with connecting lines rendered via block graphic escape sequences, giving visual depth. Cell labels 1–9 appear on each layer and layer letters A, B, C are shown on the right edge. The drawing is purely static — moves are plotted individually by printing “X” or “O” at precomputed AT Y(Z),X(Z) positions from the coordinate arrays.

Screen and Color Setup

Line 900 sets PAPER 6 (yellow), INK 1 (blue), and BORDER 6 at the start of each redraw. The FLASH attribute is used for feedback: FLASH 1 is applied to the illegal-move warning at line 390, and FLASH 0 is reset before each INPUT at line 200.

Variable Summary

Variable	Purpose
A(27)	Board state: 0=empty, 1=X, -1=O
X(27), Y(27)	Screen column/row for each cell
C(18), R(18)	Center cell and step for non-center win lines
S	Current player: 1=X, -1=O
N	Move counter (1–27)
SX, SO	Accumulated win-line counts for X and O
Z$	Player input string (e.g., “A5”)
W	Sum of three cells for win-line check