Bomber

Bomber is a horizontally-scrolling arcade game in which the player pilots an aircraft across a cityscape, dropping bombs onto buildings. The aircraft moves row by row down the screen while the player presses “Z” to release a single bomb per pass; a one-time altitude boost with “K” adds a tactical element. Custom UDGs are defined in the subroutine at line 1500 to render the plane, bomb, explosion, and building-top graphics. Three separate high-score tables are maintained across three difficulty levels, each accepting up to 13 characters of player name via INPUT. The city skyline is procedurally generated using randomized building heights biased by the chosen difficulty offset variable L.

---

Program Structure

The program is organized into a main loop and several distinct subroutines accessed via GO SUB:

• Lines 5–170: Initialization, title screen, intro music, and the core gameplay loop.
• Lines 1000–1020: City generation subroutine — draws randomized buildings and ground.
• Lines 1100–1189: High-score and controls display screen.
• Lines 1200–1250: Initializes the three-slot high-score name array Q$ and zeroes scores.
• Lines 1500–2040: UDG (User Defined Graphic) definition block, loading pixel data for all custom characters.
• Lines 3500–3570: Level selection screen (three difficulty tiers).
• Lines 4010–4499: Crash/death handler — records high scores, offers replay.
• Lines 4500–4560: Mission complete handler — records high scores, offers replay.

Initialization and Variable Layout

Line 11 sets up most game state in a single long LET chain: plane row H, bomb height BH, bomb trigger flag t, bomb column w, score SC, three high-score accumulators SCH1/SCH2/SCH3, level offset L, difficulty value D, lives indicator LI, loop variable j, and level number LE. Line 5 uses POKE 23658,8 to enable CAPS LOCK, ensuring uppercase key reads work reliably without holding CAPS SHIFT.

UDG Definitions (Lines 1500–2040)

Six UDGs are defined by poking pixel data into the UDG area using POKE USR "X"+Z,A loops with inline DATA and RESTORE:

UDG	Purpose
A	Building block (solid rectangle)
B	Airplane body
C	Airplane nose/tail
D	Bomb/explosion marker
e	Left building-top slope
f	Right building-top slope
G	Randomized texture block (each row is the same random byte)

Note that line 1545 uses RESTORE 1550 but is immediately followed by the FOR loop for UDG “e” at line 1550, so the extra RESTORE on line 1545 is redundant. The UDG “G” definition at line 1580 reads a single random value D from a DATA D statement, but since D was computed once before the loop, all eight rows of the UDG receive the same byte — producing a uniform random texture per game session.

Core Gameplay Loop (Lines 110–170)

The main loop iterates column Q from 0 to 31, scrolling the plane across each row. Key mechanics within the loop:

• Plane display: Line 120 prints the plane UDGs (\b\c) at position (H,Q) with a brief BEEP simulating engine noise.
• Bomb drop: Line 140 checks for “Z” keypress; line 141 advances the bomb vertically each column iteration by incrementing BH.
• Bomb hit detection: Line 142 uses ATTR to check whether the cell below the bomb has attribute value 1 (INK 1, PAPER 0 — building top) or 40 (PAPER 5, INK 0 — building body, since 40 = 5×8+0). A hit triggers a flash explosion animation, resets the bomb state, and awards 5 points.
• Bomb ground impact: Line 144 catches the bomb reaching row 20 without hitting a building.
• Collision detection: Line 145 checks ATTR(H, Q+2) for building attributes ahead of the plane; a collision triggers the scrolling destruction animation and branches to line 4000.
• Altitude boost: Line 149 allows a single upward move with “K” when J=0 and H>3, setting J=1 to prevent reuse.
• Mission complete: Line 148 checks for the specific coordinate H=20, Q=15 as a win condition, branching to line 4500.

After each full column sweep, line 160 increments H, moving the plane one row lower, and the loop restarts from column 0.

City Generation (Lines 1000–1020)

Buildings are drawn in pairs of columns stepping by 2 from column 2 to 31. Building height is randomized as INT(RND*8+10+L), where L is the difficulty offset (-3 for hard, 2 for medium, 4 for easy), biasing buildings taller at harder difficulties. Each building cell prints UDG \a (solid block) in INK 0 on PAPER 5; the building top row prints UDGs \e\f (slope characters) in INK 1.

Difficulty and High-Score System

Line 3500 presents three difficulty choices. The selected level sets L (city height bias) and LE (level index 1–3). Three independent high scores (SCH1, SCH2, SCH3) and player name slots (Q$(1), Q$(2), Q$(3)) are maintained for each level. At game-over or mission complete, lines 4041–4043 (or 4522–4526) compare the current score against the stored high score for the active level and prompt for a name if a new record is set. The name array is dimensioned at line 1200 with DIM Q$(Z,13) inside a loop, which reinitializes the array each pass — only the final iteration (Z=3) survives, correctly creating a 3×13 string array.

Notable Techniques and Anomalies

• The intro music loop (lines 40–70) uses RESTORE 60 and reads DATA from line 60 twice via nested NEXT N/NEXT I — note that line 60 is actually a NEXT I statement, not a DATA line; the DATA is at line 70. RESTORE 60 will therefore position the data pointer before line 70’s DATA, which works correctly since RESTORE seeks to the nearest DATA at or after the given line.
• The crash animation at line 145 uses OVER 1 with TAB 31 inside a nested loop over all rows and all INK colors, producing a full-screen XOR stripe effect.
• The high-score display subroutine (lines 1100–1189) uses a character-by-character typing effect: it prints each letter of a string individually with a short BEEP, then re-enters the loop with a new string via GO TO 1110, exploiting LEN A$ checks to sequence through multiple text sections.
• Line 142 prints a “blank” at AT bh-1,w after the explosion, which may erase part of the plane graphic if the bomb detonates very close to the aircraft row.
• The win condition at line 148 (H=20 AND Q=15) is a fixed coordinate trigger rather than a completion-of-all-buildings check, meaning the game ends at a specific point in the plane’s descent regardless of how many buildings remain.
• “COMPLEATED” (line 4510) and “CONTROLES” (line 1175) are spelling errors in the string literals.