Invaders

Invaders is a Space Invaders-style game in which the player moves a rocket launcher across the bottom of the screen and fires upward to eliminate a grid of alien invaders before they descend too far. The program defines eleven UDG (User Defined Graphics) characters via DATA statements to render the invaders, the launcher, the rocket, the laser shields, the command ship, and an explosion sprite. Game state is tracked through a 50-element DIM array I() that marks which invaders have been destroyed, and a scan of this array drives both the win condition and the per-row animation shuffle. Scoring awards 20 points per invader (inferred from the instructions text), 200 points for a command ship direct hit, and deducts 10 points per miss, with a running high score and cumulative total maintained across rounds. Invaders that advance within range of the player become indestructible, adding a time-pressure mechanic.

---

Program Structure

The program is organized into clearly commented blocks separated by REM statements. Execution begins at line 460 (initialization), flows through an instruction screen, then enters the main game loop at line 50 via GO TO 790 → GO TO 50. The main loop at line 50 calls two subroutines repeatedly: the invader shuffle routine starting at line 70 (actually implemented from line 100) and the keyboard input routine at line 220. End states branch to line 800 (planet taken over) or line 900 (all invaders destroyed), both converging at line 910 for score display and restart logic.

• Lines 20–30: Array allocation and jump to init
• Lines 50–200: Main loop, invader movement, display
• Lines 220–295: Keyboard handler (move left/right, fast move)
• Lines 330–380: Rocket fire subroutine
• Lines 460–790: Initialization, UDG setup, instructions, game setup
• Lines 800–940: End-of-game handling and restart
• Lines 1000–1090: UDG DATA
• Lines 2000–3010: Dead code (debug/test utilities, never called from main flow)

UDG Sprite System

Eleven UDG characters are defined by POKEing pixel data into USR addresses via READ/DATA loops in lines 465–497. The sprites and their roles are:

UDG	Role	String variable
S, I	Invader body (two halves)	I$
A, B	Rocket launcher	T$
C, D, E, F, G	Command ship (5 chars wide)	G$
J, K, L	Laser shield segments	D$
H	Rocket projectile	R$
M	Explosion sprite	M$

The rocket UDG H is defined with seven rows of 24 (binary 00011000, a two-pixel vertical bar) and a final row of 0, giving a clean projectile image.

Invader State Array

The 50-element array I() at line 20 tracks destroyed invaders. The grid is 7 columns × 7 rows (P=7, Q=6), addressed as I(P*row + col). When a rocket hits at row R and column derived from XP, line 370 sets the corresponding element to 1. The win-detection scan at line 100 walks the array looking for any element still equal to U (1 = alive); if none is found it jumps to line 900. A separate scan checks for any non-zero entry to detect FX status.

Movement and Display Logic

The invader shuffle subroutine uses variables L (current column offset, 0–Q), Z (direction, ±1), A (current invader row on screen), and C (step counter). Each call to the subroutine advances L by U (1); when L exceeds Q it resets to 0, reverses Z, increments C, and when C reaches V (5) it clears the top row and advances A downward. The FX flag is used to skip the first display pass so the grid is printed before movement begins.

Line 125 checks L+A>21 to detect invaders reaching the player row, branching to line 800 (game over). The SCREEN$ function at line 350 is used for collision detection on the rocket’s upward path — it scans row by row for a non-space character.

Keyboard Handling

The keyboard routine at lines 220–295 uses INKEY$ for non-blocking input. Movement keys are “5” (left one step) and “8” (right one step). Cursor key codes 8 and 9 (detected via CODE X$) provide fast movement, moving V (5) positions at a time with boundary clamping. The fire key is detected by CODE X$=11 or X$="7", both routing to the rocket subroutine at line 330. A BEEP at line 245 provides audio feedback for any keypress.

Rocket Fire Subroutine

The firing routine at line 330 computes XN=(XP-U+W)*T and checks the result modulo W to determine whether the launcher is positioned behind a shield — if so, firing is suppressed and the routine returns early. This is an unusual shield-blocking mechanic encoded as arithmetic rather than SCREEN$ lookup. The rocket reserve RR is decremented; if it reaches zero, a FLASH warning is shown and no rocket is fired.

Line 350 uses a FOR loop scanning upward from row 18 to row 0, checking SCREEN$ for impact. On a miss, the score is decremented by W (10) and a “MISS!” message flashes. On a hit, line 360 plays an explosion animation using M$ with three BEEP tones in a loop. Line 370 records the hit in the I() array.

Scoring and Persistence

Score SC is updated at lines 360 and 350. The expression 200-(180*SGN R) at line 360 awards 200 points for a hit in row 0 (the top) and 20 for any lower row, since SGN R returns 1 for R>0. High score HS and total score TS persist across restarts (lines 910–915) and are displayed at line 920. On restart, line 940 resets I(), SC, RR, and XP, then returns to line 725 for a fresh game.

Variable Reference Table

Variable	Purpose
U	Constant 1 (used as step increment and truth value)
V	Constant 5 (fast-move step; C rollover threshold)
W	Constant 10 (miss score penalty; shield modulus base)
P	Constant 7 (number of invader columns)
Q	Constant 6 (max column offset before direction reverse)
T	Constant 2 (char width scale factor)
L	Current lateral offset of invader grid
Z	Horizontal direction (±1)
A	Vertical row of top invader row on screen
C	Step counter for downward advance
XP	Launcher horizontal position
RR	Remaining rocket count
SC, HS, TS	Current score, high score, total score
FX	First-pass flag for invader display

Bugs and Anomalies

• Line 725 sets Q, T, U, V, and W twice each — the duplicate assignments are harmless redundancy.
• Line 100 references GO TO 900 (win) and U as a boolean zero/nonzero test; since U=1, comparisons like I(X)=U test for value 1, which is intentional and correct.
• The REM at line 69 says “INVADER SHUFFLE ROUTINE” but the subroutine entry from GO SUB 70 at line 50 actually begins executing at line 100 (the next line after 70), since line 70 does not exist — this is normal behavior.
• Lines 2000–3010 are dead code left from development: line 2000 is a keycode inspector and line 3000 is an AT/SCREEN$ tester, neither reachable from the main program.
• Line 330’s shield-blocking calculation uses XS <>T AND XS <>T AND XS <>T+T — the first two conditions are identical, so only two distinct positions are actually checked rather than three as apparently intended.
• The instructions text at line 560 contains “ANDTO” (missing space) due to line wrapping in the PRINT statement.