Explosion

Explosion is a two-player strategy board game where a human competes against the computer on a 3×4 or 4×4 grid, placing counters in cells that explode and distribute to neighbors when they exceed the cell’s capacity. The grid is drawn using PLOT and DRAW commands with INK 2 (red) for the border lines, and player pieces are color-coded using PAPER attributes stored in the array z(). The computer’s AI evaluates all possible moves using a scoring subroutine (line 5000) that rewards threatening positions and selects the move with the lowest score, with tie-breaking by RND. A separately LOADed machine code block (referenced by the CODE load at line 44 and saved at line 9998 as 3200 bytes from address 28000) handles character set modification, with POKEs at 23606/23607 pointing to an alternate character set. The program includes explicit compatibility notes distinguishing behavior between two different hardware configurations in the instructions at lines 34–38.

---

Program Structure

The program is organized into a main game loop and a set of numbered subroutine blocks. Control begins at line 8000, which initializes arrays and prompts for board size and starting player, then alternates between the human’s turn (lines 8600–8730) and the computer’s turn (lines 8800–9000). Key subroutine groups are:

• Lines 100–210: Main explosion propagation loop — iterates the board until no further explosions occur.
• Lines 500–520: Cell capacity calculator — returns a = 2 for corners, 3 for edges, 4 for center cells.
• Lines 1000–1190: Explosion distributor — adds 1 to each orthogonal neighbor and resets the exploding cell to 0.
• Lines 1500–1530: Scoring update — multiplies board values by t (±1) into the cost array c.
• Lines 2000–2030: Restore board from c to b.
• Lines 2300–2350: Win-detection — checks whether any cell in array e has fewer than 3 explosions; if all have ≥ 3, the current player has won.
• Lines 3000–3030 / 4000–4030: Copy f→c and c→f respectively (board state save/restore for AI lookahead).
• Lines 5000–5180: AI evaluation — scores the board state for the computer’s move selection.
• Lines 7000–7030: Zeroes the dirty-flag arrays d and e.
• Lines 8000–8090: Initialization — CLears screen, DIMensions arrays, sets display constants.
• Lines 9498–9530: Win/lose display and replay prompt.
• Lines 9900–9910: Single-cell display update using PAPER z(p) attribute.
• Lines 9996–9999: Utility lines — restore character set POKEs, save machine code, save the BASIC program with autostart.

Machine Code and Character Set

Line 4 POKEs addresses 23606 and 23607 (the system variable CHARS) to point to a custom character set at address 28000+256 (i.e., base 28000, offset by 256 so that character 32 maps to address 28256). A 3200-byte machine code/data block is saved separately via SAVE "EXP" CODE 28000,3200 at line 9998 and loaded at line 44 with LOAD "EXP" CODE. Line 9996 restores CHARS to its default value (23607=60, giving base address 15360) before stopping, which is provided as a recovery route documented in the on-screen instructions.

Board Representation

Five parallel 4×4 arrays are used throughout:

Array	Purpose
b(x,y)	Current live board — absolute counter counts during explosion resolution
c(m,n)	Signed board state — positive = computer’s pieces, negative = human’s pieces (×t)
d(m,n)	Dirty flag — marks cells touched during the current explosion wave
e(m,n)	Explosion counter — incremented each time a cell explodes; used for win detection
f(m,n)	Persistent board — the “committed” state; copied to/from c for AI lookahead

The sign convention in c and f is notable: t=1 for the human and t=-1 for the computer, so each player’s pieces are stored as positive values in their own frame of reference. The display always shows ABS f(g,h) (line 9900) to hide the sign from the player.

AI Move Selection

The computer’s AI (lines 8820–8930) is a shallow one-ply minimax variant. For every cell not already owned by the human (f(q,w) <= 0), it tentatively decrements c(q,w) by 1, runs the explosion propagation via GO SUB 105 (line 2000), evaluates the resulting position with GO SUB 5000, and records the move with the lowest score st. Tie-breaking uses RND > 0.5 to randomly select among equally scored moves.

The scoring function (lines 5000–5180) sums all values in c, then adds a 10-point bonus for each neighbor of a near-capacity friendly cell that is also near capacity — rewarding cluster formation that is one move away from a chain explosion.

Explosion Propagation

The main propagation loop (lines 100–210) is a fixed-point iteration: it scans the entire board looking for cells where the absolute count b(x,y) exceeds capacity a. When found, subroutine 1000 distributes +1 to each orthogonal neighbor, zeros the exploded cell, increments e(x,y), and sets the chain-continue flag i=1. The outer loop (line 190) repeats until a full pass finds no overflows. Variable u is set by subroutine 2300 to signal whether play should continue or trigger the win/lose screen.

Display and Layout

The grid is drawn with PLOT/DRAW at lines 8230–8270, using pixel coordinates derived from constants xp, yp, and cell spacing of 16 pixels. BASIC text is overlaid using PRINT AT with x0, xk, y0, yk as origin and stride. Player 1 uses PAPER 5 (cyan) and player 2 uses PAPER 6 (yellow), stored in z(1) and z(2). The variable pl gates all screen updates during the AI’s lookahead phase — when pl=0, no PRINT statements in subroutines 1000 and 100 execute, keeping the display clean during evaluation.

Input Validation and Compatibility

Human input is restricted to strings “1”, “2”, “3”, or the value of k$ (the board size), enforced by multi-branch IF chains at lines 8620 and 8650. An attempt to play in a cell owned by the computer (f(g,h) < 0) triggers a BEEP and re-prompts. Lines 34–38 and the dual-path initialization (lines 10, 32–44, 50, 60) reflect explicit design for two different hardware targets, with line 10 jumping directly to the game setup at line 8000 for one configuration and the instructions block serving the other.

Notable Anomalies

• Line 8320 contains a bare \{16}\{2}\{16}\{0} color sequence before printing i without an AT position reset guard, which may produce minor display glitches depending on current cursor position.
• The variable z is used both as the array z() holding PAPER colors and as a scalar at line 8920 (LET z=w) to store the best AI column. This dual use does not cause a runtime error because BASIC treats z and z() as distinct, but it is potentially confusing.
• Win detection via array e (requiring each cell to have exploded at least 3 times) is an unconventional criterion; in typical chain-reaction games the win condition is ownership of all cells. This may result in games that play longer than expected.
• Lines 44 and 50 (LOAD "EXP" CODE and SAVE "LOADING" LINE 10) are embedded in the middle of the instruction block and will execute if the program is ever RUN from line 1, which aligns with the compatibility warning at lines 34–38.