Clerical Spell List D&D

This program manages and prints a Clerical Spell List for the Dungeons & Dragons tabletop role-playing game. It collects spell names for all seven clerical spell levels: 20 spells each for levels 1–3 (paired into 64-character strings in array A$), 16 spells each for levels 4–5 (stored in B$), and 12 spells each for levels 6–7 (stored in C$). Each pair or triplet of spell names is concatenated and packed into a single fixed-length string row using the DIM statement’s 64-character width. An 80-column printer is required to display the output correctly via LPRINT, and the program includes a SAVE routine at line 9900 to preserve entered data.

---

Program Analysis

Program Structure

The program is divided into four clear phases:

1. Initialisation (lines 5–80): Declares single-row, 20-character working string arrays (E$ through Z$) used as temporary input buffers, plus a blank/empty reference array E$.
2. Data entry (lines 200–600): Three loops collect spell names for levels 1–3 (20 entries each), levels 4–5 (16 entries each), and levels 6–7 (12 entries each), packing them into the storage arrays A$, B$, and C$.
3. Print phase (lines 610–800): Entered via GO TO 610 (either directly after entry or on re-run), the program waits for a keypress then sends all stored spells to the printer via LPRINT.
4. Save routine (line 9900): Saves the program (with populated arrays) to tape, then falls through to the print phase.

String Array Storage Technique

The three storage arrays are declared with 64-character row widths: DIM A$(20,64), DIM B$(16,64), and DIM C$(12,64). Each row holds a concatenation of two or three 20-character spell name strings. For A$, three 20-character strings are packed into 60 characters (leaving 4 characters of padding to 64). For B$ and C$, two 20-character strings occupy 40 characters. This packing means the 80-column printer prints two or three spells per line, making efficient use of paper width.

Buffer Clearing with E$

After each row is assembled, the temporary input buffers are reset by assigning them the contents of E$(1) (lines 280–300, 410–420, 560–570). Because E$ is declared DIM E$(1,20) and never written to, it always contains 20 spaces. This is a clean idiom for blanking a fixed-length string variable without using string literals or explicit space padding.

Entry Point Design

The REM at line 0 documents that the program should be entered at line 610 on subsequent runs (after saving with populated arrays). Line 605 uses STOP to halt after data entry, with lines 603–604 printing instructions. This two-entry-point design — data entry from line 200, print-only from line 610 — lets the saved file be reloaded and used purely as a print utility without re-entering spell names.

Notable Idioms and Observations

• PAUSE 4E4 at line 620 pauses for 40,000 display frames (approximately 27 minutes at 50 Hz), effectively waiting for user intervention rather than a specific keypress — a common long-pause wait technique.
• The loop variable Z is reused across all three data-entry loops (lines 200, 350, 500) as well as the print loops, which is valid since each loop completes before the next begins.
• Array Z$ (lines 60, 540, 550, 570) shares its name with the loop counter Z. In this BASIC, numeric and string variables are distinct namespaces, so there is no conflict, but it is an unusual stylistic choice.
• The working arrays (F$, S$, T$, U$, V$, X$, Z$) are all declared DIM x$(1,20); only row 1 is ever used, so they function as simple 20-character string variables with the syntax overhead of array indexing.
• The SAVE at line 9900 uses an inverse-video digit in the filename, functioning as an auto-run marker so the saved program can resume at the print phase automatically on load.

Potential Issues

• Spell names longer than 20 characters will be silently truncated by the fixed-width string array rows, with no warning to the user.
• There is no validation or correction mechanism; a mistyped spell name requires restarting the entire entry process from line 200.
• The concatenated output lines (A$(Z) etc.) are printed with LPRINT without separating delimiters, so distinguishing individual spell names within a printed row depends entirely on the user having entered consistent-length names.