Metagraphics

Metagraphics is an interactive freehand drawing program that lets the user place and move a cursor character around a 24×32 text display, leaving graphical characters as “paint” on the screen. The program uses a short machine code routine embedded in REM line 1 (bytes `3E 1E ED 47 C9`) to control display speed via POKE/USR calls at lines 910–999. Cursor movement is handled by subroutines at lines 401–489, covering all eight cardinal and diagonal directions with key-held repeat loops. An inverse-video toggle (line 1050), a random-pattern fill function (line 1100), a stamp/flood fill using string concatenation (lines 310–350), and a cycle-through-characters mechanism (lines 810–870) round out the feature set.

---

Program Analysis

Program Structure

The program is divided into two main phases. Lines 9000–9330 form the initialization and title-screen section, which displays a splash screen in inverse video, waits for a keypress, saves the program, then jumps to RUN to restart from line 1. Lines 1–199 form the main loop: setup (lines 35–95), key scanning and dispatch (lines 110–195), cursor display (lines 197–198), and loop-back (line 199 — note the loop target is line 100, which does not exist; execution falls through to line 110, a common ZX81 technique). Subroutines are grouped in the 200s–1100s ranges by function.

Machine Code Usage

Line 1 contains a REM statement whose body is a five-byte machine code routine: 3E 1E (LD A,1E), ED 47 (LD I,A), C9 (RET). This loads the value from address 16515 (the byte following the REM opcode byte, accessed via POKE 16515,I) into the Z80 I register before returning. The routine is invoked with LET ZZZ=USR 16514, where 16514 points to the first byte of the REM data. This is used by the speed-control subroutines (lines 910–999 and 1000–1049) to adjust display timing by varying I in steps of 2 between 0 and 30.

Key Dispatch Table

The main loop scans INKEY$ and dispatches via computed GOSUB or direct comparison:

Key Code	Key	Action	Subroutine
33–36	Cursor keys	Cardinal movement	400+(K-33)*10
112–116	Diagonal keys	Diagonal movement	450+(K-112)*10
46	.	Inverse toggle	1050
28	Shift+4 (£?)	Stamp fill	315
119	W	Wipe/reset cursor char	250
42	*	Swap A$/B$	700
40	(	Advance character	800
15	Enter	Decrement character	850
50	2	Increase speed	900
18	R	Decrease speed	950
53	5	Reset speed/exit	200
41	)	Show palette	500
56	8	Save program	(inline SAVE)
43	+	Random fill	1100
61	=	Reset speed	1000
39	‘	Stamp screen	300

Movement Subroutines

Eight subroutines handle cursor movement (lines 401–489). Each subroutine updates row R and/or column C using a bounded Boolean expression (e.g., LET C=C-(C>0)), prints the cursor graphic C$ at the new position, immediately overwrites it with the drawing character A$ — effectively “painting” — and then loops on INKEY$<>"" for key-held autorepeat. The boundary checks using Boolean arithmetic prevent the cursor from leaving the 24×32 screen.

Character Cycling

Subroutine 800 (advance) and 850 (decrement) step through the character set stored in A$. The advance routine at line 810 increments the character code, wrapping from code 64 (which would be @) back to a space (code 32), and from code 192 (inverse space) to "% " (an inverse-video space), bridging the normal and inverse video halves of the character set. This allows the user to cycle through all drawable characters including inverse graphics.

Inverse Video Toggle

Subroutine 1050 toggles between a normal and inverse version of the current drawing character. Line 1055 checks if CODE A$>65; if so, it assumes the character is already inverse and strips 128 from its code (line 1080), reverting to normal. Otherwise it adds 128 to the code (line 1065) and sets the cursor indicator C$ to "%I" (inverse I) to show inverse mode is active. Returning to normal mode resets C$ to "\@@" (the default cursor glyph, a block graphic).

Screen Fill and Stamp

Subroutine 300/315 (lines 310–399) fills the screen by building a string X$ that starts as a copy of B$ (the saved character), then doubles itself eight times in a loop (FOR A=1 TO 8), producing a 256-character string. Three copies are printed at row 0 column 0, flooding the screen. Subroutine 500 (line 510) similarly constructs D$ as three copies of A$ and displays it in rows 20–22 as a palette preview strip, then waits for a keypress and restores using B$.

Random Pattern Fill

Subroutine 1100 (lines 1100–1230) generates five random characters (A$ through E$), each with a code in the range 0–9 optionally offset by 128 for inverse video (using RND>.5 as a Boolean 0/1 multiplier). These are concatenated into X$ and doubled seven times to produce a 640-character string, which is then printed repeatedly in a loop until a key is pressed, creating an animated random texture.

Notable Techniques

• Boolean arithmetic for boundary clamping: R=R+(R<23), C=C-(C>0)
• Computed GOSUB for movement dispatch: GOSUB 400+(K-33)*10
• String doubling loop to fill screen efficiently without a character-by-character loop
• Dual-print cursor technique: print cursor graphic C$, then immediately overprint with A$ to leave paint while showing position
• Machine code in REM for I-register manipulation affecting display timing
• LET ZZZ=USR discards the USR return value without error, a common ZX81 idiom

Anomalies and Notes

Line 199 executes GOTO 100, but line 100 does not exist; the interpreter falls through to line 110, which is the intended start of the key-scan loop. Line 35 POKEs address 16418 (FRAMES low byte on a ZX81) to zero, likely to reset the frame counter at startup. The subroutine at lines 210–249 (called from line 170 as GOSUB 200) waits for a key-up then key-down event and loops 18 times — its purpose appears to be a keypress synchronization delay. The REM at line 9000 and decorative REM lines serve as a title block within the code rather than documentation.