DROPABLOCK

DROPABLOCK is a block-dropping crane simulation game in which the player purchases a crane, orders blocks, and drops them onto a construction platform during a simulated workday. The game uses 14 User-Defined Graphics (UDGs A through N), defined via a DATA/POKE loop at line 710 that writes 112 bytes into UDG memory to render cranes, blocks, and platform tiles. Gameplay tracks money (M), days elapsed (D), and block inventory (A), with economic consequences for damage events and a high-score comparison at session end. The screen layout combines PRINT AT, INK, BRIGHT, FLASH, and OVER attributes to produce a layered construction-site scene with scrolling crane movement driven by a floating-point X/Y position increment variable I.

---

Program Structure

The program is organized as a main game loop with several distinct phases handled by line ranges:

1. Lines 10–20: Title REM and initialization subroutine call (line 710).
2. Lines 30–60: Session setup — initializes high score, money, day counter, and routes end-of-day logic.
3. Lines 70–90: Scene drawing — renders the construction platform using UDG characters and sets up the backdrop string W$.
4. Lines 100–150: Equipment selection — player chooses between two crane types with different capacities and costs.
5. Lines 160–230: Block ordering — player inputs how many blocks to buy, with money and capacity validation.
6. Lines 240–390: Main gameplay loop — moves the crane horizontally, renders it, and polls INKEY$ for block drops.
7. Lines 400–510: Drop subroutine — animates a block falling from the crane to the platform level.
8. Lines 520–570: End-of-day lorry sequence — a vehicle crosses the screen and triggers damage checks.
9. Lines 580–670: Damage and lawsuit logic — handles collisions with yachts and falling lorry incidents.
10. Lines 680–700: Profit/high-score reporting and replay.
11. Lines 710–750: Initialization subroutine — sets display attributes, reads 112 bytes of UDG data, and POKEs them into UDG memory.
12. Line 760: SAVE with autostart.

UDG Definitions

Line 710 uses a FOR N=0 TO 111 loop reading from DATA statements at lines 720–750, POKEing each byte into USR "[UDG-A]"+N. This defines 14 UDGs (A through N), covering crane arm parts ([UDG-A], [UDG-B]), truck/lorry shapes ([UDG-C], [UDG-D]), platform tiles ([UDG-E], [UDG-J]), and smaller crane type 2 graphics ([UDG-K], [UDG-L], [UDG-M], [UDG-N]).

Key Variables

Variable	Role
M	Player’s money (starts at 10000)
D	Day counter (drives end-of-game condition at D=16)
A	Block inventory count
S	Crane type chosen (1 = large, 2 = small)
I	Horizontal movement increment (1.0 for type 1, 0.5 for type 2)
T	In-game clock (simulated minutes past 3:00 PM)
Y	Crane horizontal position (floating point)
X	Crane row (fixed at 2)
N	Platform height (random, 2–14 rows from bottom)
HI	High score (best profit across replays)
SUE	Flag for yacht lawsuit event

Notable BASIC Idioms

• NOT PI evaluates to 0 (since PI is non-zero, NOT PI = 0); used throughout as a compact zero literal — e.g., LET FU= NOT PI, PRINT AT NOT PI, NOT PI.
• SGN PI evaluates to 1 (since PI > 0); used to initialize D=1 and set BRIGHT 1 at line 710.
• FOR N= NOT PI TO VAL "RND*12+2" at line 70 uses VAL of a string expression for the upper bound — this defers evaluation and is a known memory/token optimization.
• PAUSE NOT PI (i.e., PAUSE 0) followed by GO TO acts as a keypress wait without an explicit INKEY$ loop.

Gameplay Mechanics

The crane moves automatically from left to right across the screen; the player presses SPACE to drop a block. Block dropping is handled by the subroutine at line 400, which animates the block falling row by row using a FOR F loop with PRINT AT F,G, erasing the previous row each iteration. The crane type affects both the horizontal speed (I) and the time cost per block dropped (type 2 costs 2.5 time units vs. 0.5 for type 1).

The end-of-day trigger is when T >= 59 (representing 4:00 PM), after which a lorry animation runs across the screen at line 520. The lorry is randomly assigned one of several UDG patterns ([UDG-C], [UDG-D], or [UDG-G][UDG-H]), with the last variant only used when both platform inspection points show ATTR = 66 (INK 2, PAPER 0, BRIGHT 1 — a correctly loaded block attribute).

Damage and Economic Events

The damage subroutine at lines 580–670 uses both ATTR and SCREEN$ checks to detect collisions. If the lorry runs over a yacht (ATTR = 70), the player is fined $500 and sued for an additional $1500. If the lorry hits a block in its path (SCREEN$ non-space), it incurs $1500 damage. The falling subroutine at line 670 iterates from the platform top downward, calling line 580 for each row to check for obstructions.

Screen Layout and Attributes

The scene uses OVER 1 at line 90 to draw the road/ground overlay. FLASH 1 is used at end-of-day messages and the lower border status area (PRINT #1 writes to the lower screen). BRIGHT 0 at line 250 marks the lorry drop zones on the platform. The display column check at line 290 (IF INT Y>28) wraps the crane back to column 2 when it reaches the right edge.

Bugs and Anomalies

• Line 550 has a potential infinite loop: IF P=3 AND ATTR(...) fails when the attribute condition is not met, causing GO TO 520 which may again pick P=3, repeating indefinitely if the platform blocks are not correctly loaded.
• The variable INK is used as both a BASIC keyword and a numeric variable (e.g., LET INK= INT (RND*6)+2 at line 520). On the Spectrum, INK is a keyword/color modifier, so using it as a variable name this way is unconventional and may cause interpreter confusion depending on context.
• Line 450 has IF f=19-n THEN GO SUB 510:RETURN — the RETURN after GO SUB exits the drop loop early when the block lands, which is intentional but means the NEXT F at line 500 is not reached in that case.
• Variable FAL is set at line 590 but never subsequently read, making it a dead assignment.
• The lowercase variable names s, x, y, i appear at lines 420–430, mixed with their uppercase equivalents elsewhere; on the Spectrum these are treated as distinct variables, which could cause unexpected behavior if the case is inconsistent.