Druidical Spell List

This program manages and prints a Druidical spell list for Dungeons and Dragons, collecting up to 16 spells each for levels 1–3, and 12 spells each for levels 4–7, then formatting them onto a printed listing via LPRINT. Spell names are entered interactively in triplets or pairs, packed into fixed-length string arrays (A$, B$, C$) of 64 characters each by concatenating 20-character sub-strings. An 80-column printer is required, as each packed row spans three or two 20-character spell names side by side. The program requires manual entry via GO TO 610 rather than RUN, as noted in the REM at line 3. Clearing buffers by assigning E$(1) (an empty string array row) back to the input variables between iterations is an efficient way to blank working strings without re-dimensioning.

---

Program Analysis

Program Structure

The program is divided into three phases: data entry, a pause/menu stub, and printing. Lines 5–100 declare all working arrays. Lines 200–590 handle interactive input in three loops. Lines 600–605 present a brief stop with instructions. Lines 610–800 perform the actual LPRINT output. Line 9905 contains a SAVE command and line 9910 loops back to the print routine.

1. Initialisation (5–100): Declares single-row 20-character working strings and three multi-row packed arrays.
2. Level 1–3 input loop (200–320): 16 iterations; packs three 20-char spell names into one 64-char row of A$.
3. Level 4–5 input loop (350–440): 12 iterations; packs two 20-char names into one 40-char row of B$ (declared as 64 chars).
4. Level 6–7 input loop (500–590): 12 iterations; packs two 20-char names into one 40-char row of C$.
5. Menu stub (600–605): Prints GO TO instructions and STOPs; user must manually GO TO 610.
6. Print section (610–800): Dumps all three arrays to the printer with spacing.
7. Save/restart (9905–9910): SAVEs the program, then GO TO 610.

Array Layout

Array	Dimensions	Contents	Spell levels packed
A$(16,64)	16 rows × 64 chars	Three 20-char spell names per row	1st, 2nd, 3rd
B$(12,64)	12 rows × 64 chars	Two 20-char spell names per row	4th, 5th
C$(12,64)	12 rows × 64 chars	Two 20-char spell names per row	6th, 7th

Key BASIC Idioms

• Single-row working arrays as input buffers: F$(1,20), S$(1,20), etc. are dimensioned as 1-row arrays so that INPUT F$(1) fills the entire row as a fixed-length string. This ensures consistent 20-character strings for concatenation.
• Buffer clearing via E$: After packing each row, variables are reset by assigning E$(1) (which is always a blank 20-character string since E$ is never written to). This is a clean zero-without-retyping technique.
• String concatenation into packed rows: LET A$(Z)=F$(1)+S$(1)+T$(1) at line 270 concatenates three 20-character strings into a single 60-character value stored in a 64-character row, relying on string assignment padding the remainder with spaces.
• PAUSE 4E4: Line 620 uses PAUSE 4E4 (40,000 frames ≈ 11 minutes on a 50 Hz machine) as an extended wait before printing, effectively pausing until the user presses a key.
• Manual GO TO entry point: REM at line 3 explicitly warns not to RUN the program but to GO TO 610 to reach the print section after the STOP at line 605. This is required because RUN would restart data entry.

Notable Techniques

The use of DIM E$(1,20) as a permanent blank-string source is economical: rather than assigning a string literal of spaces, the program exploits the fact that a freshly dimensioned string array is initialised to all spaces, and E$ is never overwritten, so it always holds 20 spaces.

Packing multiple spell names side-by-side into a single array row (rather than using separate arrays per level) reduces the number of array variables needed and produces columnar output when LPRINTed on an 80-column printer — three 20-character columns fit neatly in 60 characters with room to spare.

Bugs and Anomalies

• Loop variable collision: The outer FOR loop at lines 500–590 iterates on Z, but Z is also the name of a declared string array (Z$(1,20)) used as an input buffer inside the same loop (line 540). This is legal because the numeric variable Z and the string array Z$ are distinct, but it is confusing style.
• B$ and C$ packing mismatch: B$(12,64) and C$(12,64) are declared 64 characters wide, but only 40 characters (two 20-char names) are packed into each row. The trailing 24 characters will always be spaces, wasting approximately 288 bytes per array.
• No input length validation: If a user enters a spell name longer than 20 characters, the INPUT into a 20-char array row will either truncate or cause an error, depending on the interpreter’s behaviour.
• SAVE at line 9905 then GO TO 610: After saving, the program jumps directly to the print routine at line 9910, which may be intentional to confirm data is intact, but could confuse users who expect the program to terminate after saving.