Monster

Monster is a platform-style maze game in which the player navigates a character around a multi-level screen, collecting jewels, eliminating monsters, and reaching a door before a countdown timer expires. The screen layout is built procedurally each level using UDGs (user-defined graphics) loaded via a DATA/POKE USR loop that defines eight custom characters (codes 144–151). Movement is handled with keys 5, 6, 7, and 8, and the ATTR function is used extensively to detect collisions with colored screen objects, distinguishing platforms, monsters, jewels, and the exit door by their ink and paper attribute bytes. Killing a monster triggers an “invisible gas” mechanic that doubles the rate of timer decay, tracked with a flag variable. A high-score variable persists across games within the same session.

---

Program Structure

The program is organized into clearly delineated functional blocks:

1. Lines 1–6: Initialization, high-score reset, and instructions prompt.
2. Line 7: Level selection and validation.
3. Lines 8–120: Level setup — drawing platforms, monster positions, jewels, and the exit door, plus an intro beep sweep.
4. Lines 195–300: Main game loop — player movement, collision detection, scoring, and timer management.
5. Lines 1000–1010: Death-by-falling routine.
6. Lines 2000–2090: UDG definition subroutine via DATA and POKE USR.
7. Lines 5000–5040: End-of-game screen with high-score comparison and replay prompt.
8. Lines 6000–6030: Instructions display (note: called as GO SUB 5500 in line 5, but defined at line 6000 — see Bugs section).

UDG Definitions

Eight UDGs are defined at startup by the subroutine at line 2000, using a nested FOR loop that reads eight bytes per character from DATA lines 2010–2080 and POKEs them into memory with POKE USR CHR$ z+x, a for z running from 144 to 151. The characters and their roles are:

UDG	Code	Role
[UDG-A]	144	Player character
[UDG-B]	145	Player death sprite
[UDG-C]	146	Jewel / collectible
[UDG-D]	147	Monster (placed on platforms)
[UDG-E]	148	Platform block
[UDG-F]	149	Killable monster (row 1)
[UDG-G]	150	Door left half
[UDG-H]	151	Door right half

Level Generation

Platforms are drawn in a loop (lines 10–30) that prints INK 5 platform blocks across each row, stepping up three rows at a time from row 21 down to row 3. Monster sprites are scattered at random column positions using RND *29+1 (line 45), printed in INK 6 pairs two cells tall. Jewels (line 100) are placed at six positions spaced three rows apart, printed BRIGHT 1 INK 7. The exit door (line 110) is fixed at row 20, column 29 in INK 2.

ATTR-Based Collision Detection

The game makes heavy use of ATTR to identify objects by their color attributes rather than tracking sprite positions in variables. Key checks in the main loop include:

• ATTR (a-1,b)=6 — detects a monster above the player (INK 6 = yellow), used for jumping onto platforms with monsters (line 275) and for the downward move (line 281).
• ATTR (a-1,b)=4 — detects a killable monster at row 1 in INK 4 (green), awards 100 points (line 280).
• ATTR (a,b)=71 — detects a jewel (attribute byte 71 = BRIGHT 1 + INK 7 + PAPER 0), awards 50 points (line 285).
• ATTR (a,b)=2 — detects the exit door in INK 2 (red), triggering level advance (line 291).
• SCREEN$ (a-1,b)=" " — checks for empty space above before a simple upward step (line 270).

Movement and Physics

The player position is stored in row a and column b. Movement keys are 5 (left), 8 (right), 7 (up), and 6 (down). Upward movement on a plain space (line 270) is a short one-cell hop that immediately returns the player to their original row — effectively a cosmetic jump with no sustained elevation. The jump onto a monster platform (line 275) moves the player up three rows at once, matching the three-row platform spacing. The downward move through a monster (line 281) similarly shifts three rows and is gated by k >= 16, meaning the player must have collected at least 16 kills. Boundary detection (line 290) triggers the fall subroutine when b=0 or b=31.

Timer and Gas Mechanic

The timer t starts at 1000 and is decremented by l (the current level) each iteration of the main loop (line 282). When a monster is killed, flag n is set to 1 (line 280), and line 287 subtracts an additional 2*l per loop while n=1, effectively tripling the timer drain. The flag is cleared when the player descends through a monster (line 281, LET n=0). Timer display is updated each loop at line 288, and exhaustion at line 289 routes to the end-game subroutine.

Falling Death Routine

Lines 1000–1010 implement a falling animation: the player sprite is printed one row lower on each iteration with an accompanying descending BEEP, and the previous position is erased. When row 21 is reached, the death sprite (UDG-B) is displayed with FLASH 1 in INK 2, a long low beep plays, and the routine falls through to the end-game screen at line 5000.

Notable Techniques

• The OVER 1 mode in lines 250 and 260 XORs the player sprite onto the screen when erasing the previous position, a common sprite-movement technique to avoid explicit background redrawing.
• The intro music (line 120) is a simple FOR sweep from -10 to 20 semitones, producing a rising glide.
• The high-score hs is initialized once at line 1 and persists for the session, compared at line 5000.
• Platform row spacing of 3 is hardcoded throughout and must be consistent between generation (lines 10–30) and movement (lines 275, 281) for gameplay to work correctly.

Bugs and Anomalies

• Missing subroutine target: Line 5 calls GO SUB 5500, but the instructions routine begins at line 6000. There is no line 5500, so requesting instructions would cause a BASIC error. The instructions are never reachable in normal play.
• Level validation error: Line 7 checks IF l<1 OR 1>9 — the second operand should be l>9 not 1>9. Since 1>9 is always false, any value of l that is not less than 1 (i.e., any positive number) bypasses the FOOL message, allowing levels above 9.
• Variable reuse of b: The variable b is used both as a platform-drawing row counter (lines 8–95) and as the player’s column position (lines 195 onward). This is resolved by the explicit reset at line 195 (LET b=1), but the dual use is a potential source of confusion.
• Line 270 jump behavior: The upward hop immediately restores a to its original value with LET a=a+1, so the jump has no lasting effect on position — it is purely cosmetic.
• Line 95 loop variable conflict: The loop at line 95 uses b as both its FOR variable and increments it manually with LET b=b+1 inside the loop body, which interferes with the NEXT b counter and will cause non-standard stepping behavior.