FORTRESS

FORTRESS is a two-player (or one-player-vs-computer) strategy game played on a network of 18 labeled nodes arranged across the screen. The attacker tries to reach the defender’s position by moving along connecting edges, while the defender attempts to block progress by using up passage tokens. Node positions and connectivity are stored in parallel arrays: screen coordinates in p() and q(), adjacency lists in l$(), and zone classifications in c(), all initialized from DATA statements. The computer AI (when playing as attacker or defender) uses a scored evaluation array g(4) to select the best adjacent node each turn, weighting moves toward the defender, away from the defender’s zone, and penalizing already-used passages marked with asterisks. A custom UDG character is defined for the attacker token using 16 bytes of DATA POKEd into memory at USR "[UDG-A]".

---

Program Analysis

Program Structure

The program is organized into a set of well-separated subroutines and game-loop segments. Entry is at line 100, with the main menu at line 200. The flow branches into attacker turn (lines 1000–1240) and defender turn (lines 2000–2140), with win detection and replay at lines 7000–7070. Computer AI for the attacker occupies lines 8500–8660, and for the defender lines 8000–8050. Initialization of all map data is handled by the subroutine at lines 9000–9060, consuming DATA from lines 9070–9090.

• Lines 5–50: Map drawing subroutine (nodes and edges)
• Line 60: Status message display/flash subroutine
• Lines 70–75: Attacker/defender token display subroutines
• Lines 100–190: Initialization (UDGs, arrays, defaults)
• Lines 200–230: Main menu and game start
• Lines 500–530: Turn router (dispatches between attacker and defender)
• Lines 1000–1240: Attacker’s turn (human)
• Lines 2000–2140: Defender’s turn (human)
• Line 3000–3020: Single-player role selection
• Lines 7000–7070: Win announcement and replay
• Lines 8000–8050: Computer defender logic
• Lines 8500–8660: Computer attacker AI with scoring
• Line 8700: UDG shape data
• Lines 9000–9090: Map data initialization

Data Structures

The 18 nodes are represented by several parallel arrays, all dimensioned and populated from DATA in the 9000 subroutine:

Array	Dimensions	Contents
p(18,2)	18×2	Screen row/column for node labels (PRINT AT coordinates)
q(18,2)	18×2	Pixel coordinates for PLOT/DRAW graphics
c(18)	18	Zone classification (1, 2, or 3) for each node
l$(18,4)	18×4 string	Original adjacency lists — node letters for each of up to 4 neighbors
m$(18,4)	18×4 string	Working copy of adjacency lists; used passages replaced with *

Pixel coordinates are derived from print positions with the formula q(j,1) = 4 + p(j,2)*8 and q(j,2) = 172 - p(j,1)*8, mapping character-cell positions to the pixel grid.

Node and Passage System

Each node is identified by a letter A–R (nodes 1–18 map to CHR$(65)–CHR$(82)). When the attacker moves from node X to node Y, both the entry in m$(X) pointing to Y and the reverse entry in m$(Y) pointing to X are replaced with "*", marking that passage as consumed. This one-way depletion mechanic is the core of the game: passages are finite, and a node surrounded by used passages (m$(ap)="****") results in a defender win.

Turn Routing and Player Encoding

The variable no encodes the game mode and player role. In two-player mode, no=2. In single-player mode, the player’s choice of “a” (attacker) or “d” (defender) is stored as no = CODE i$, giving 97 or 100 respectively. The turn router at lines 500–530 checks these values: no=100 triggers the computer attacker AI at line 8500, and no=97 triggers the computer defender logic at line 8000, while both dispatch correctly for the human’s own turn.

Computer AI

The attacker AI uses a scoring array g(4), one entry per possible move. On the first move (g=1), a random adjacent node is chosen. On subsequent moves, each candidate is scored:

• -30: passage already used (pm = -22, i.e., ASCII of * minus 64)
• +30: move directly captures the defender
• +15: destination is in the same zone as the defender
• -10: destination is in zones 1–2 or zone 4 (attacker’s own area)
• -1 per already-used passage: penalizes nodes that are becoming dead ends

The best-scoring move is selected; if the best score is -30, all moves are blocked and the defender wins immediately. The defender AI (lines 8000–8050) uses a pre-computed c() zone lookup to pick a safe adjacent node for the defender to move to.

Graphics

The map is drawn using PLOT and DRAW with INK 4 (green) for edges, connecting nodes via pixel-coordinate differences. The DRAW statement in line 25 uses relative coordinates: q(dest,1)-q(src,1) and q(dest,2)-q(src,2). Used passages are erased from the display using DRAW OVER 1 at line 1180, XORing the line away. Labels are printed with PRINT AT using the character-cell coordinate arrays.

UDG Definition

Line 100 POKEs 16 bytes of shape data (from line 8700) into memory starting at USR "[UDG-A]", defining two custom UDG characters (each 8 bytes) for the attacker and defender tokens. These are displayed in INK 2 (red) and INK 1 (blue) respectively via the subroutines at lines 70 and 75.

Notable Techniques and Idioms

• The status message at line 60 is flashed by printing it, delaying with an empty FOR loop, then reprinting it with OVER 1 to erase it — a common Spectrum technique for temporary messages without attribute clutter.
• Uppercase-to-lowercase conversion uses CODE i$-32 and CHR$(CODE i$+32) to shuttle between the user’s letter input and internal node numbering.
• INKEY$ debouncing is performed at lines 1220 and 2120 by waiting until the key is released before proceeding.
• The adjacency strings in l$ and m$ use exactly 4 characters, with "*" as a sentinel for depleted or unused passages, and "****" indicating total blockade.
• The RESTORE at line 9010 explicitly targets line 9000 to ensure DATA is read from the correct point, independent of earlier RESTORE calls in the initialization sequence.

Potential Bugs and Anomalies

• Line 8050 uses the expression 1050+(1020 AND no=97) to jump either to line 1050 (two-player or computer-as-attacker path) or line 2070 (computer-as-defender path). The value 1020 added to 1050 gives 2070, an elegant arithmetic branch, but relies on Spectrum BASIC’s boolean result being numeric 1 for true.
• At line 1060, variable j is used as the FOR loop counter but is also set to 4 at line 1070 to force early loop termination — a deliberate early-exit idiom, not a bug, though it leaves j=4 after the NEXT at line 1080.
• The computer defender AI at lines 8000–8050 references array c(ap) and offsets the result by checking equality with 3, suggesting the defender is constrained to nodes in zone 3 (a–c, nodes 1–3), which matches the DATA showing c(j) values of 1, 2, or 3.