Manimation

This program animates a walking stick figure (“Manimation”) across the screen using two sets of User Defined Graphics (UDGs) stored in string arrays. It exploits the TS2068’s ability to relocate the UDG table by POKEing system variables 23675 and 23676, allowing up to 80 UDGs across multiple memory-mapped sets rather than the standard 21. Frame data for each animation pose is packed into 24-element string arrays (d$ and e$), with each element holding two or three UDG character references that are later offset by 79 using CHR$ arithmetic to map from letters A–U into the UDG character range (144–164). The DATA statements from line 1000 onward define the pixel bitmaps for all UDG shapes, loaded via POKE USR in nested FOR loops. A variable l controls the figure’s horizontal travel distance, which decrements by 3 on each loop pass until the animation stops.

---

Program Analysis

Program Structure

The program is divided into three logical phases:

1. Initialization (lines 1–6): Sets up memory, plays a startup beep sequence, and prints a title and description screen.
2. Data loading (lines 20–120): Populates two string arrays (d$ and e$) with animation frame references, loads UDG bitmap data from DATA statements into multiple UDG table locations, then converts the A–U letter codes in the arrays to the actual UDG character codes by adding 79.
3. Animation loop (lines 130–250): Renders the walking figure descending the screen (using d$), then crossing the screen horizontally (using e$), repeating with a shorter travel distance on each pass until l reaches 2.

Multiple UDG Table Technique

The most technically significant feature is the use of multiple UDG tables to exceed the normal 21-UDG limit. System variables at addresses 23675–23676 hold a pointer to the UDG table base. By POKEing different values into these locations, the program relocates the UDG table to different areas of RAM, effectively creating independent sets of 20–21 UDGs each. This allows the program to define and use approximately 80 UDG shapes total across four table locations.

POKE 23675	POKE 23676	Purpose
176	254	First UDG set, first pass (d$ graphics, right half)
5	(same)	First UDG set, second pass (d$ graphics, left half)
88	255	Restore default after d$ loading
93	253	Second UDG set base (e$ graphics)
181	252	Second UDG set, second bank (e$ graphics continuation)

String Array Frame Encoding

DIM d$(24,3) and DIM e$(24,3) each create a 24-element array of 3-character strings. Each element represents one row of a 3-row sprite tile, using letters A through U (and spaces for blank tiles) to reference UDG characters. After the arrays are populated, lines 100–120 convert every non-space character by adding 79 to its ASCII code: CHR$(CODE d$(x,y)+79). Since CODE "A" = 65, adding 79 gives 144, the first UDG slot (\a), mapping A→UDG-a, B→UDG-b, etc., up to U→UDG-u (164).

Animation Rendering

The descent animation (lines 130–160) iterates rows i from 10 to 18 and frame indices j from 1 to 22 in steps of 3, printing three consecutive rows of d$ at screen position (i, 2). A special case at j=13 switches the UDG table pointer mid-loop to access the second bank of walking-figure graphics. The horizontal walk (lines 180–210) similarly steps through e$ frames at column i, which increments from 2 to l, with a UDG bank switch at frame 11.

Speed Control

Lines 140 and 190 implement optional speed-up: IF INKEY$="" THEN PAUSE 20 (or PAUSE 30). When the user holds a key, the PAUSE is skipped, making the animation run faster. This is a common Sinclair BASIC idiom for interactive speed control without breaking the main loop structure.

Loop Shortening and Termination

The variable l is initialized to 29 (line 1). After each full animation pass, line 240 decrements l by 3 and line 250 jumps back to line 130. Line 230 checks IF l=2 THEN STOP, halting when the figure has no room left to walk. This creates a figure that appears to travel progressively shorter distances, though the exact visual intent depends on screen layout.

UDG Data Loading

Lines 40–90 use nested FOR loops to READ and POKE UDG bitmap data. The outer loop over i (144 to 163 or 164) selects the character, and the inner loop over j (0 to 7) fills each of the 8 pixel rows via POKE USR CHR$ i + j, a. The z=1 TO 2 loop loads the same UDG range twice into different table locations by changing the base pointer before the second pass.

Notable Techniques and Idioms

• Use of CLEAR 64699 to set RAMTOP and protect the upper RAM area used for additional UDG tables.
• Frame data encoded as letter strings with post-load offset arithmetic, keeping DATA lines human-readable during development.
• OVER 1 at line 6 draws an underline using XOR mode without overwriting existing content.
• The SAVE line (9998) uses LINE 1 for autostart and chains a VERIFY immediately after saving.
• Line 1000 onwards contains a large block of DATA values; no checksumming is performed, so any data corruption would silently produce garbled graphics.

Potential Anomalies

At line 1030, the DATA statement contains only 13 values before the next line, while the loop expects 16 values per UDG (2 bytes × 8 rows) — however, READ draws sequentially across all DATA lines, so partial lines are valid. More notably, line 220 references variable i after the loop at line 210 exits; since BASIC retains the last loop value, i will equal l+1 after the FOR loop ends, which is intentional for printing the final frame at the correct column position.