BLOKMAN

BLOKMAN is a maze-avoidance and bomb-defusal game in which the player navigates a two-character-wide sprite across a grid, using a joystick in the left port, collecting flags, avoiding skulls, and defusing TNT before a shrinking timer bar runs out. The program uses a block of UDG characters (lines 8–13) loaded via POKE into USR addresses at startup, defining the player, enemy, flag, bomb, and explosion sprites as 8×8 bitmaps read from DATA statements that use the literal variable `b` (value 0) and `-4` (252) as shorthand constants within the data. Joystick input is handled through the TS2068 STICK keyword, with keyboard equivalents mapped in the string `b$` at line 50. The timer is visualized as a row of colored block characters printed at row 20, shrinking one character per frame via the loop variable `j`. A two-stage level structure sends the player through five enemy screens before a bonus flag-catching mini-game, then repeats with a narrower timer bar; difficulty at startup is set by adjusting the initial timer width `i` based on a 0–9 player-chosen level.

---

Program Analysis

Program Structure

The program is organized into clearly separated functional regions, navigated by computed GO TO and GO SUB targets expressed as numeric literals and floating-point shorthand (e.g., GO SUB 8e3, GO TO 5e3, GO TO 6e3, GO TO 7e3). The major regions are:

1. Lines 2–7: Initialization — UDG setup, variable reset, screen attributes, entry point.
2. Lines 8–18: UDG loader subroutine — POKEs bitmap data into the UDG area.
3. Lines 19–30: Grid drawing — draws a repeating diamond/tile pattern across the play field.
4. Lines 40–300: Main game loop — places enemies and flags, runs the timer bar, handles movement, collision detection, and scoring.
5. Lines 1000: Wraparound subroutine for player position.
6. Lines 4000–4120: Stage 2 bonus mini-game — player must press a key when the man is over the flag.
7. Lines 5000–5020: Time-expired handler (bomb explodes).
8. Lines 6000–6040: TNT defused handler — awards bonus, advances level, calls stage 2.
9. Lines 7000–7070: Life-loss handler — death animation, high-score check, restart logic.
10. Lines 8000–8270: Title screen, instructions, and difficulty/level entry.

UDG Sprite Loading

Lines 8–18 form a subroutine that loads 20 UDG definitions (characters \a through \t, i.e., UDGs A–T) by POKEing 8 bytes each into the range USR "a" to USR "t"+7. The data is read with RESTORE 9 to reset the DATA pointer, then a single FOR/READ/POKE/NEXT loop fills all 160 bytes. This covers the player (4 UDGs in a 2×2 arrangement), flag, skull/enemy, bomb/TNT, and explosion sprites.

Within the DATA statements, the program exploits the fact that at the time of reading, the variable b holds the value 0 (it was used as a loop counter in line 8 and has just finished at 0 from the previous run, or is initialized to 0 at line 2). This allows b to serve as a compact zero literal inside DATA lines. Similarly, -4 appears as a shorthand for 252 (i.e., 256-4), which BASIC stores and READs as the negative value but which POKE interprets modulo 256.

Sprite Rendering

All in-game objects use 2×2 character (4-cell) UDG sprites, printed with two consecutive PRINT AT statements: the top row at AT r,s and the bottom row at AT r+1,s. Each sprite occupies UDGs arranged as quadrants: for example the player uses \a\b / \c\d, the enemy uses \e\g / \f\h, the flag uses \m\o / \n\p, and the TNT bomb uses \i\k / \j\l. The explosion sprite uses \q\s / \r\t.

Timer Bar

The countdown timer is rendered as a row of colored block characters (\::, the solid block UDG/graphic) at row 20, printed with INK 3. At line 115, the bar is initialized to width i (set from the difficulty level at line 8260 as 32-2*(VAL a$), ranging from 32 at easy to 14 at hardest). The outer loop at line 117 counts j down from i-1 to 0; at line 135 the leftmost cell is erased by printing a space at position j, giving a smooth left-to-right shrink. When the loop exhausts, control falls to line 165 and then jumps to 5e3 (line 5000), the explosion handler.

Movement and Collision Detection

Player position is stored in x (column, always even) and y (row, always even), reflecting the 2×2 sprite grid. Movement direction d is decoded from the action string b$="ASZXPLaszxpl" at line 50, where indices 1–6 map to shoot/left/right/up/down actions (the program uses 3=left, 4=right, 5=up, 6=down based on the arithmetic at lines 175–185). Joystick directions from STICK (1,1) are translated to the same letter values at lines 140–143.

After movement, the subroutine at line 1000 applies toroidal wraparound: if x reaches -2 it wraps to 30, and if it reaches 32 it wraps to 0; similarly for y between -2 and 20. Collision is detected at line 200 by reading the screen attribute at the new position with ATTR (y,x) and comparing to known attribute values:

ATTR value	Meaning	Action
54	Wall/obstacle (INK 6, PAPER 6, BRIGHT 1)	Movement reversed
42	Flag (INK 2, PAPER 5)	+140 points, sound effect
>63	Skull/enemy (BRIGHT or FLASH set)	Life lost (go to 6000)
48	TNT/bomb (FLASH 1, INK 4, PAPER 0 → 4+48=52? checked carefully)	Defuse sequence (go to 7000)

Note: The ATTR value 48 matches INK 0, PAPER 6 (no BRIGHT/FLASH), which corresponds to the background grid squares — the bomb check at line 230 may actually detect background cells rather than the TNT sprite whose ATTR would be BRIGHT 1 + FLASH 1 + INK 4 + PAPER 0 = 192+128+4 = 324 mod 256. This could be a latent bug in collision detection for the bomb object.

Joystick Support

The STICK (1,1) keyword is used at lines 140–143 to read a joystick port, with bitmask values 4=down, 8=up, 1=right, 2=left mapped to the corresponding keyboard letter variables. Keyboard input is handled by scanning INKEY$ against the string b$ in the loop at lines 150–160.

Stage 2 Bonus Mini-Game

After completing 5 screens (loop at lines 85–6030 with FOR t=1 TO 5), the program calls the subroutine at line 4000. This displays a row of background tiles with a randomly placed flag, then animates the player sprite walking across all grid positions. The player must press any key when the man sprite is over the flag column (x=b). The bonus is 4000-(50*y), rewarding faster reactions (lower y means higher row, reached sooner). Success detection uses the idiom FOR a=n TO 1: IF INKEY$<>"" — since n=0, this loop body executes once per iteration and exits via GO TO 4100 on a keypress, or falls through the outer x/y loops on no input.

Sound Effects

Movement sounds at line 250 use a compact single BEEP expression: BEEP .01,(12 AND d=6)+(d<>5)+(5 AND d=3)+(17 AND d=4), exploiting the fact that Boolean expressions evaluate to 1 (true) or 0 (false), so each directional condition contributes a different pitch offset. The death sequence (line 7000) uses a flashing INVERSE animation loop before showing an explosion sprite. The level-complete/defuse tune at lines 7015 plays notes encoded in the parallel strings x$ and y$ initialized at line 5.

Notable Techniques

• b used as a zero literal in DATA statements, saving bytes over writing 0 repeatedly.
• Floating-point line number targets (1e3, 4e3, 5e3, 6e3, 7e3, 8e3) compress jump targets to fewer characters in the source.
• Boolean arithmetic for direction-dependent pitch in a single BEEP call.
• Screen attribute reading via ATTR for collision detection, avoiding a separate sprite-tracking array.
• Toroidal wraparound encoded as a single-line subroutine at line 1000 using compound Boolean arithmetic.
• Difficulty level mapped linearly: i=32-2*(VAL a$) gives timer widths 32 (level 0) down to 14 (level 9).
• PRINT #1; FLASH 1;"Press any key to begin" at line 8200 prints to the lower screen (stream 1 = bottom two lines), keeping the instruction text visible without scrolling.