Donkey Kong

This program implements a Donkey Kong-style arcade game in BASIC. The player character moves along platforms using keys 5, 8, 7 (left, right, jump) and I/T for diagonal jumps, while barrels scroll back and forth across four platform rows. The game uses a clever collision detection technique: it reads the character cell at the player’s current screen position via PEEK on the system variables at addresses 16398/16399 (the display file pointer), comparing the character found there against known hazard characters such as “O” for barrels. Block graphics characters render the Kong figure, barrels, ladders, and platforms, with a score variable G that decrements each loop iteration and is added to the cumulative score S on reaching Kong at line 9080.

---

Program Analysis

Program Structure

The program is organised into a main setup block, a game loop, subroutines for movement, and end-game handlers:

1. Lines 10–70: Initialisation — variables for barrel column positions (C, D), barrel directions (E, F), player position (A row, B column), and score penalty counter G.
2. Lines 200–340: Static screen drawing — platforms, Kong figure, and decorative elements using block graphics and inverse characters.
3. Lines 350–510: Main game loop — barrel rendering, player drawing, input handling, barrel direction reversal, and loop back to 350.
4. Lines 600–650: Gravity/fall subroutine — the player falls downward until a non-space character is detected below them.
5. Lines 6000–6009: Jump-up subroutine (key 7) — animates the player rising four rows.
6. Lines 7000–7020: Diagonal jump right (key I) — animates a two-column rightward arc.
7. Lines 8000–8020: Diagonal jump left (key T) — mirror of the I subroutine.
8. Lines 9000–9070: Death/game-over sequence — flashes the player’s cell and prints “GAME OVER”.
9. Lines 9080–9130: Win sequence — reached when player position equals Kong’s cell (row 6, column 7); adds G to cumulative score S, animates Kong, redraws, and restarts the level.
10. Lines 9140–9150: SAVE and RUN — used only for distribution; not reached during normal play.

Screen Layout

Row(s)	Content
0	Title: “DONKEY-KONG” in inverse video
1–6	Kong figure (block graphics + inverse chars)
7	Top platform
10	First barrel row (columns driven by C)
11	Second platform
14	Second barrel row (driven by D)
15	Third platform
18	Third barrel row (driven by C)
19	Fourth platform
22	Fourth barrel row (driven by D)
23	Ground/base platform
20–22, col 0	Decorative element (barrels stacked)

Collision Detection via PEEK

The game’s collision detection relies entirely on reading the display file. The address of the current character at screen position (A,B) is computed using the ZX81/TS1000 system variables at addresses 16398 (D_FILE low byte) and 16399 (D_FILE high byte). The expression CHR$ PEEK (PEEK 16398+256*PEEK 16399) retrieves whatever character is currently displayed at the top-left of the screen; critically, the program first positions the cursor with PRINT AT A,B; (a semicolon suppresses the newline, moving the print position without outputting anything), so the subsequent PEEK reads the character at exactly that cell.

Specifically:

• Line 352: reads cell (A,B) into A$; if it equals "O" (a barrel character), jumps to the death routine at 9000.
• Lines 376–378: reads cell (A+1,B) into B$; if it is a space, the player is over a gap and the fall subroutine at 600 is triggered.
• Lines 620–631: inside the fall loop, reads cell (A+2,B) into G$; a non-space stops the fall, but a non-space at that position also triggers death (line 631), meaning landing on a barrel kills the player.
• Lines 7002, 8002: check whether a diagonal jump landing cell contains "O".

Variable Usage

Variable	Purpose
A	Player row
B	Player column
C	Starting column for odd barrel rows
D	Starting column for even barrel rows
E	Direction increment for C (+1 or −1)
F	Direction increment for D (+1 or −1)
G	Score penalty counter (decrements each loop; added to S on win)
S	Cumulative score (persists across levels)
A$, B$, G$, U$	Temporary screen-read character buffers

Key Input Handling

Input is polled inside the main loop at lines 470–500 using INKEY$:

• Key 7: Jump upward — calls subroutine 6000 only if the character at (A,B) is a ladder ("H").
• Key 8: Move right — line 480 uses a Boolean expression: B=B+(INKEY$="8" AND B<30), incrementing B by 1 only when within bounds.
• Key 5: Move left — same Boolean idiom, decrementing B when B>0.
• Key I: Diagonal jump right — calls subroutine 7000.
• Key T: Diagonal jump left — calls subroutine 8000.

Note that INKEY$ is evaluated independently for each condition in lines 480–500, so pressing multiple keys simultaneously may yield unexpected behaviour due to re-polling.

Kong Animation

Lines 375 and 505 alternate between two states of Kong’s arms, creating a two-frame animation. Line 375 draws Kong with arms in one position as part of the barrel-update phase; line 505 redraws them in the alternate position after input handling. This gives a crude but effective looping animation tied to the game loop speed.

Score System

G is initialised to 0 at line 25 and decremented by 1 every main loop iteration at line 411. Upon reaching Kong (line 9081), S=S+G adds the (negative) value of G to the running score. Because G becomes more negative over time, the score rewards reaching Kong quickly. G is reset to 0 at line 25 on each level restart (via GOTO 10 at line 9130, which re-runs initialisation).

Notable Techniques and Anomalies

• POKE 16418,0 at line 15 clears the ZX81/TS1000 system variable MARGIN, which controls the TV picture margin — commonly used to allow printing to all 32 columns cleanly.
• The fall routine at line 600 does not use GOSUB/RETURN; it is entered via GOTO 600 from the main loop and exits with GOTO 350 (implicitly, by falling through from line 632 back to 650 and looping until it can place the player). The loop at 600–650 increments A on each iteration, moving the player down one row per cycle.
• Line 631 triggers GOTO 9000 (death) when G$<>" ", meaning any non-space character below the falling player kills them immediately. This means landing on a platform character or barrel is fatal, though in practice only barrel encounters ("O") are the intended hazard.
• The win condition check at line 412 (IF A=6 AND B=7 THEN GOTO 9080) hard-codes Kong’s screen position.
• GOTO 1 at line 9070 (game over) targets a non-existent line — this is a standard idiom that causes execution to restart from the first line of the program (line 10), effectively performing a full program restart including variable re-initialisation.
• The diagonal jump subroutines (7000, 8000) draw and erase a series of intermediate positions without delay loops, making the arc animation very fast but effectively instant on slower machines.