Money Pail

Money Pail is a catching game in which dollar bills of random denominations fall from the top of the screen and the player moves a pail left and right using the N and M keys to collect them. The pail has a capacity of five bills before it must be taken to a bank column on the right side of the screen, which is triggered automatically when the pail reaches column 27. Eight user-defined graphics (UDGs \a through \h) are loaded from DATA statements to draw the pail sprite and a progressive fill animation representing the bank vault. The SOUND statement is used extensively for audio feedback, including a multi-channel coin-collection fanfare and movement beeps whose pitch corresponds to the vertical position of the falling bill. Skill level selection adjusts two variables, d (BEEP delay) and h (starting row for the drop loop), controlling both fall speed and how early bills become visible.

---

Program Analysis

Program Structure

The code is organized into clearly separated functional blocks accessed via GO SUB:

• Lines 1–10: Startup beep and entry jump to the main initialization routine at line 1000.
• Lines 100–150: Score/collection subroutine — awards a point, plays a SOUND fanfare, and updates the pail graphic.
• Lines 200–230: Bank subroutine — resets the score counter, accumulates total, animates the bank filling up, and plays a two-tone beep.
• Lines 1000–1060: Main game initialization: calls UDG loader (6000), calls intro/skill screen (4000), sets border/paper/ink, initializes variables, and draws the HUD.
• Lines 2000–2140: Core game loop — 20 drops per round, each with a falling bill and player movement inner loop.
• Lines 3000–3040: End-of-round handler — prompts for replay, loops back to line 1020 (skipping UDG reload).
• Lines 4010–4100: Introduction screen, instructions, and skill level selector.
• Lines 6010–6050: UDG definition loader — reads 8×8-byte bitmaps from DATA into UDGs \a through \h.
• Lines 9998–9999: Save/verify block.

User-Defined Graphics

Eight UDGs (\a–\h) are defined at lines 6010–6036, each loaded by a dedicated FOR loop reading 8 bytes from the DATA block at line 6040. The 64 bytes encode eight tiles. UDGs \a, \b, \c form the three-character pail sprite displayed at line 21. UDG \d through \h appear to encode a progressive bar used in the bank fill animation at line 220, where successive PRINT AT statements walk upward from row 12 to row 2 in steps of 2 to simulate bills stacking.

The DATA at line 6040 follows a clear pattern: each successive 8-byte group adds one more set bit column from the left (192, 0, 3, then increasing fill patterns), suggesting a partial-fill visual sequence rather than pictographic characters.

Core Game Loop

The outer loop (lines 2010–2140) iterates 20 times per round (FOR a=1 TO 20). Each iteration:

1. Picks a random denomination: q=10*(INT(RND*9)+1), giving multiples of 10 from 10 to 90. The label a$ is built as "$"+CHR$(q/10+48)+"0" — a three-character string like $30.
2. Picks a random horizontal column c in the range 3–24.
3. Runs an inner loop (FOR b=h TO 20) where the bill falls one row per iteration. The starting row h is set by the skill level, making harder levels start higher and therefore give less reaction time.
4. Inside the inner loop, player movement is handled inline: LET p=p-(INKEY$="n")+(INKEY$="m") with boundary clamping: LET p=p+(p=0)-(p=28).
5. After the fall, checks for a bank visit (line 2115, p=27) and a catch (line 2120, c=p+1 AND sc<5).

Key BASIC Idioms and Techniques

• Boolean arithmetic for movement clamping: p+(p=0)-(p=28) exploits the fact that Sinclair BASIC returns −1 for true conditions; the expression effectively clamps p between 1 and 27 without IF statements.
• Inline INKEY$ polling: Rather than a separate input-reading routine, INKEY$ is read directly inside the falling-bill loop, giving responsive controls without halting the drop animation.
• SOUND for multi-channel audio: Line 100 uses a chained SOUND statement with channels 6–13 for a rich collection fanfare, followed by a silence command on channels 8–10.
• Dynamic score display via CHR$: Line 110 constructs b$ using CHR$(146+sc), selecting a UDG that visually represents the fill level of the pail (sc ranging 0–5), providing a live capacity indicator.
• Skill-level encoding: Line 4080 derives both fall speed (d=7-2*VAL c$) and starting row (h=7-d) from a single digit input, coupling animation speed and difficulty in one calculation.
• HUD using block graphics: Line 1060 uses block graphic escapes (\ :, \:, \:) to draw bordered labels for PAIL, BILLS, and BANK scores on a single line.

Anomalies and Notes

• Line 2115 checks p=27 for a bank visit; the right wall is clamped at p=28 (exclusive), so column 27 is the effective rightmost reachable position, doubling as the bank trigger. This means the player cannot move right of the bank column without banking — a deliberate design constraint.
• The variable x accumulates the dollar value caught (x=x+10*VAL a$(2), extracting the digit character of the denomination), while sc counts bill count (max 5). These serve distinct display purposes: x for dollar amount shown in the HUD at column 7, sc for pail fill graphic.
• Line 4050 uses PAUSE 0 with no following INKEY$ check — it waits for any key press to exit the instructions screen, relying on PAUSE 0’s built-in keypress detection rather than a polling loop.
• Line 3030 calls GO SUB 4060 (skipping the intro text at 4010–4050) before restarting at 1020 (skipping UDG reload at 1000–1010), correctly avoiding redundant re-initialization on replay.
• UDGs \d through \h are defined in the DATA at lines 6032–6036 but are not explicitly referenced elsewhere in the visible listing by name; they may be used implicitly through the CHR$(146+sc) calculation in line 110, as UDG \d corresponds to char 147 (144+3) and subsequent UDGs cover sc values 3–7.

Variable Summary

Variable	Purpose
sc	Current number of bills caught (0–5)
x	Dollar value of bills currently in pail
t	Total banked dollar amount
p	Pail horizontal column position
b$	Three-char pail UDG sprite string
a$	Current falling bill label (e.g. “$30”)
c	Falling bill column
d	Speed/delay factor (derived from skill level)
h	Starting row for bill drop (derived from skill level)
q	Denomination value (multiple of 10)