GRAVE-YARD

GRAVE-YARD is a two-character chase game in which the player maneuvers a ghost sprite around a bordered arena while a second ghost wanders randomly, and both characters must avoid collision with the arena’s underscore walls. The player moves using keys 5–8 (the standard Spectrum directional keys), with the player sprite changing shape based on the direction of travel using one of four UDGs (A–D). A 60-unit countdown timer drives the game’s pace, displayed at the bottom of the screen alongside a score that increments by three each time the wandering ghost (UDG F) catches the player’s ghost, triggering a respawn at fixed coordinates. Six UDGs are defined at startup via a DATA-driven POKE loop targeting USR “A” through USR “F”, covering directional player sprites, a collision sprite (UDG E), and the enemy sprite (UDG F). The high score is retained across rounds within the same session and displayed on the game-over screen alongside a prompt to restart.

---

Program Analysis

Program Structure

The program is organized into a main game loop with clearly separated initialization and setup subroutines:

• 9000–9080: UDG definition — reads pixel data and POKEs six UDGs (A–F) via a loop over USR "A" to USR "F"+7.
• 8000–8990: Game variable initialization — sets border/paper/ink, positions, score, timer, and initial sprite character.
• 7000–7060: Screen setup — draws a bordered arena using INVERSE INK 6 underscores and prints the score line.
• 50–200: Main game loop — handles player input, player movement, enemy movement, collision detection, and timer management.
• 1000–1060: Score/respawn handler — increments score, plays a beep sequence, and respawns both characters.
• 2000–2050: Game-over sequence — displays score, updates high score, and prompts replay.

UDG Initialization

Subroutine 9000 defines six UDGs (A through F) by reading 8 bytes each from DATA statements at lines 9030–9080 and POKEing them into the UDG area. The loop iterates from USR "A" to USR "F"+7, covering all 48 bytes. UDGs A–D are directional player sprites (left, right, down, up), UDG E is a collision/capture sprite, and UDG F is the enemy ghost sprite.

Player Input and Movement

Lines 51–70 implement a latching input scheme. INKEY$ is only accepted if it falls in the range "5"–"8"; otherwise the last direction stored in A$ is retained. Movement is computed using Boolean arithmetic:

• V (row) changes by (A$="6")-(A$="7") — key 6 moves down, key 7 moves up.
• H (column) changes by (A$="8")-(A$="5") — key 8 moves right, key 5 moves left.

The previous position is saved in V1, H1 before each move. If the new cell contains an underscore (wall), the move is cancelled by restoring V1, H1 and clearing A$ at line 90.

Directional Sprite Switching

Line 110 updates the player’s display character C$ based on the current direction key using concatenated Boolean string expressions — a common Spectrum BASIC idiom where a string multiplied by a true condition yields the string and by a false condition yields an empty string. The four cases map keys 5–8 to UDGs D, A, C, and B respectively. If no direction key is active (C$=""), the previous sprite D$ is retained (line 120).

Enemy Ghost Movement

The enemy ghost at coordinates (J,K) moves pseudo-randomly each frame (lines 150–180). Its row and column each change by INT(RND*3)-1, giving a displacement of −1, 0, or +1. Like the player, it saves its prior position and cancels moves into wall cells. Collision with an empty cell (SCREEN$="") at line 175 triggers the catch event at line 1000.

Collision Detection via SCREEN$

Both player and enemy use SCREEN$ to detect the contents of the target cell before moving into it. An empty string result indicates the player and enemy have overlapped, triggering the score event at line 1000. An underscore character indicates a wall boundary, blocking movement.

Timer Mechanism

The timer variable TI is initialized to 60 and decremented by 0.2 each main loop iteration at line 125. This is a software timer driven by loop speed rather than the system clock. When TI drops below zero, the game-over routine at line 2000 is triggered. The display uses INT TI to show whole seconds.

Bugs and Anomalies

• Line 1060 sets K=20 and then immediately overwrites it with K=16 — the intent was almost certainly H=16 to reset the player’s column, since H is the player’s horizontal coordinate. As written, H is never reset here, so the player respawns at whatever column they were at when the catch occurred.
• Line 80 checks SCREEN$(V,H)="" after the player has already moved, meaning the check fires when the player moves into a cell occupied by the enemy — this is the intended catch condition, but the logic is inverted from what a reader might expect (empty screen = collision rather than a solid obstacle).
• The BEEP .008,SC at line 130 pitches the movement sound to the current score, so the tone rises throughout the game as the score increases.

Key Variable Summary

Variable	Purpose
V, H	Player row and column
V1, H1	Previous player position (for wall revert)
J, K	Enemy ghost row and column
J1, K1	Previous enemy position (for wall revert)
A$	Current/latched direction key
C$	Current player UDG sprite character
D$	Previous player UDG sprite (fallback)
SC	Current score
HI	Session high score
TI	Countdown timer (software-driven)