Black Box

Black Box is a three-dimensional adaptation of the classic deduction puzzle, extending the traditional 2D grid into an 8×8×8 cube space with five hidden atoms. The player fires laser beams into the cube by specifying three coordinates; the beam-tracing routine at lines 150–250 uses delta-direction vectors (dx, dy, dz) and iterates through all 27 neighboring cells to compute reflections caused by adjacent atoms, normalizing the result with SGN after each deflection step. Atoms are placed randomly in the inner 6×6×6 region (coordinates 2–9 internally, displayed as 1–8) using a DIM b(10,10,10) array, with the outer layer reserved as entry/exit boundary. The introduction subroutine at line 530 draws an isometric cube diagram using PLOT and DRAW to illustrate the coordinate system before gameplay begins.

---

Program Structure

The program is organized as a collection of subroutines dispatched from a main loop, with a one-time introduction sequence that runs before the game begins. Control flow is as follows:

1. Line 30: GO SUB 530 — runs the full introduction and diagram sequence, then returns.
2. Line 50: GO TO 420 — jumps to the main program block.
3. Lines 420–520: Main loop — places atoms, then cycles between shooting (GO SUB 60 → GO SUB 140) and guessing (GO SUB 260) based on player input.

The subroutines and their roles are:

• Lines 60–130: Input a shot (surface entry point).
• Lines 140–250: Beam-tracing — computes the exit coordinates of a fired beam.
• Lines 260–310: Input and evaluate an atom-location guess.
• Lines 320–410: Shared coordinate input routine used by both shooting and guessing.
• Lines 530–830: Introduction screens with text and isometric cube diagram.

Data Representation

The playing field is a 10×10×10 array b(10,10,10) declared at line 40. Atoms occupy the internal region with indices 2–9 (corresponding to displayed values 1–8), leaving index 1 and 10 unused. The outer playable surface (indices 2 and 9 in any axis) serves as the beam entry/exit boundary. A cell containing an atom is set to 1; all others remain 0 (the default for a numeric array).

Atom placement at line 440 uses RND*6+2, which generates a real number in [2, 8), truncated by array indexing to integers 2–7. This means atoms are never placed in row/column 8 (displayed as 7 or 8 depending on truncation), which is a subtle off-by-one issue — atoms should occupy positions 2–9 but the formula only reaches index 7 (displayed as 6–7 range), slightly biasing placement toward the interior.

Beam-Tracing Algorithm

The beam tracer (lines 150–250) is the technical core of the program. It operates on the current beam position (px, py, pz) and direction vector (dx, dy, dz), each component being −1, 0, or 1.

1. A triple nested loop over x, y, z from −1 to 1 checks all 27 neighboring cells (including the current cell itself) for atoms.
2. For each atom found, the direction vector is modified by subtracting the offset (x, y, z) from (dx, dy, dz).
3. After the loop, each direction component is normalized to {−1, 0, 1} using SGN (line 210), modeling the reflection rule.
4. The beam advances one step (line 220) and the loop repeats until the beam reaches a surface (line 230 checks if any coordinate equals 2 or 9).

Line 230 uses addition of boolean expressions as a sum — if any coordinate is on a surface, at least one term is 1, making the total non-zero, and the beam exits. This is a compact idiom for an OR condition across multiple equality tests.

Coordinate Input and Validation

The shared input subroutine at lines 320–410 adds 1 to each entered coordinate (px=px+1 etc.) to translate the user’s 1–8 range into the internal 2–9 indexing. Validation loops (lines 350, 370, 390) re-prompt if any coordinate falls outside the valid range. The shot-input subroutine (lines 60–130) additionally checks that at least one of dx, dy, dz is non-zero, enforcing that the entry point is on a surface rather than in the interior.

The direction components are derived at lines 90–110 using boolean arithmetic: (px=2)-(px=9) evaluates to 1 if px=2 (beam moving in the positive direction), −1 if px=9 (moving in the negative direction), and 0 otherwise. This is an elegant Sinclair BASIC idiom for computing a signed direction without IF statements.

Introduction and Diagram

Lines 530–830 form a multi-screen introduction. Lines 600–670 draw an isometric cube using PLOT and DRAW: horizontal grid lines are drawn in two passes (lines 600–610 and 620–630), and diagonal lines completing the isometric perspective are drawn in a loop at lines 640–670. The axis labels and numbered coordinate scales are then PRINTed using AT positioning (lines 680–740).

Three screens of rules text explain the three reflection cases: direct back-reflection when a beam hits an atom head-on, right-angle reflection for beams passing through an orthogonally adjacent cell, and double right-angle (diagonal) reflection for cells diagonally adjacent to an atom. Each screen waits for a keypress using the IF INKEY$="" THEN GO TO idiom.

Notable Techniques and Anomalies

• The 27-neighbor loop (including the (0,0,0) offset) means the beam’s own cell is checked for atoms. Since a beam enters from the surface and atoms cannot be on the surface, this does not cause errors in practice, but it is technically unnecessary for the (0,0,0) case.
• The main loop at lines 460–520 does not track the number of shots fired or provide a scoring mechanism — the game ends when the player guesses correctly, with no penalty count.
• Line 440 does not check for duplicate atom placements; two RND calls could produce the same cell, resulting in fewer than five distinct atoms.
• The SAVE "Black Box" LINE 20 at line 840 saves the program with an auto-run start line.
• Output of results (line 240) and inputs (line 400) subtract 1 from internal coordinates to display the user-facing 1–8 range.