Ocean Defense

Ocean Defense is a submarine warfare game in which the player maneuvers a ship across the top of the screen, dropping depth charges to destroy enemy subs while intercepting missiles they launch at the home base. The program uses 17 custom UDG (User Defined Graphics) characters, stored from USR “A” onward, which are saved and loaded separately as a CODE block. Scrolling sea-lane rows are implemented by rotating string arrays — A$(1) and A$(3) shift left by one character per frame, while A$(2) shifts right — creating a parallax effect across three rows. Difficulty selection sets the variable SK, which modifies missile evasion probability in the subroutine at line 1615 and affects scoring. The end-of-mission statistics screen at line 3000 renders icons for destroyed subs, missed missiles, and depth charge counts in a tabular layout, and computes a percentage rating using a formula combining raw score, accuracy, and mission number.

---

Program Structure

The program is organized into a set of functional blocks separated by line number ranges:

• Lines 10–200: Initialization, setup, and main intro/title screen.
• Lines 690–790: Main game loop — scrolls sea rows, draws sprites, checks input, dispatches to subroutines.
• Lines 800–830 (GO SUB 800): Draws the player’s ship moving across the screen.
• Lines 900–930 (GO SUB 900): Status bar update; checks home base destruction condition.
• Lines 1000–1040 (GO SUB 1000): Fires a depth charge (if charges remain).
• Lines 1100–1160 (GO SUB 1100): Moves the depth charge downward; detects collisions via SCREEN$ and ATTR.
• Lines 1400–1470: Submarine destruction sequence with animated explosion using INK cycling.
• Lines 1500–1570: Handles depth charge hitting sea-row graphics (near-miss/sea damage logic).
• Lines 1600–1650 (GO SUB 1600): Randomly generates a missile launch from a submarine row.
• Lines 1700–1840 (GO SUB 1700): Moves missile upward toward the home base ship.
• Lines 1900–1920: Missile misses — increments MM (missiles missed).
• Lines 2000–2030: Wave completion — flash effect via RANDOMIZE USR 23769, advance to next stage.
• Lines 2100–2140: Missile hits ship; ship loss logic, game-over if ships depleted.
• Lines 3040–3300: End-of-mission debrief screen with statistics, rating calculation, and graphical tallying.
• Lines 4010–4150 (GO SUB 4000): Title/intro screen with difficulty selection loop.
• Lines 7005–7070: UDG definition utility (not called during normal gameplay; used to create the custom character set).
• Lines 8010–8040: SAVE/LOAD bootstrap for game code and UDG CODE block.

Scrolling Sea Rows

Three rows of sea graphics are stored as 32-character strings in the array A$. Each game loop iteration, the strings are rotated in-place:

• A$(1) and A$(3) scroll left: LET A$(1)=A$(1,2 TO )+A$(1,1)
• A$(2) scrolls right: LET A$(2)=A$(2,32)+A$(2, TO 31)

This gives a simple but effective parallax impression across the three submarine lanes, printed at rows 8, 13, and L (a randomly chosen row between 15 and 19). The three lanes are printed in different INK colors based on the stage number (ST), so later waves appear in different colors.

Custom UDG Characters

The game relies on 17 custom UDGs (characters A through Q, codes 144–160), loaded at startup from a separately saved CODE block starting at USR "A". The utility at lines 7005–7070 was used to define each glyph by POKEing 8 bytes per character. In-game, these UDGs represent ship parts, sub graphics, missile sprites, explosion tiles, and sea-wave block graphics. The ship display at line 180 uses a 32-character string of UDG references to render the home base across the bottom of the play area.

Collision Detection

The game uses two Spectrum BASIC collision methods:

• SCREEN$ (X,Y)<>" " — detects whether the depth charge has hit any visible character at its current position (line 1130).
• ATTR (X,Y)=78 — checks the attribute byte at the collision cell; value 78 corresponds to BRIGHT 0, PAPER 1, INK 6, which identifies submarine cells specifically, routing to the destroy sequence at line 1400 rather than the near-miss handler (line 1510).

Machine Code Usage

Two ROM addresses are called via RANDOMIZE USR:

• RANDOMIZE USR 23769 — calls the Spectrum’s TV interrupt handler / frame flash routine, used to create rapid screen flash effects during wave completion (line 2010) and missile hits (line 2120, 2140).
• RANDOMIZE USR 23792 — called in the home-base destruction sequence (line 2140), producing a different visual effect.

POKE 23779,N writes to the BORDCR system variable, changing the border and lower screen paper color directly, used for flash effects at line 2010.

POKE 23658,8 at line 10 sets FLAGS2 to disable the lower-case shift lock, ensuring consistent keyboard input.

Difficulty System

The variable SK (1 = Admiral, 2 = Sea Cadet) is set at line 4120 via INKEY$ key detection using the Boolean arithmetic idiom. SK affects gameplay in several places:

• Line 40: DD=44+(11 AND SK=2) — Sea Cadets start with 55 depth charges; Admirals get 44.
• Line 1615: IF R<0+(.66 AND SK=1)+(.83 AND SK=2) THEN RETURN — At Admiral difficulty, missiles fire 34% of the time; at Cadet, only 17%.
• Line 920: Home base is destroyed after (SK+1)*3 missiles reach it — 6 for Admiral, 9 for Cadet.
• Lines 3050, 3290: Difficulty label displayed on debrief screen.

Boolean Arithmetic Idiom

The program makes extensive use of the Sinclair BASIC convention that logical expressions evaluate to 1 (true) or 0 (false), enabling compact conditional assignment without IF statements. Examples:

• LET DD=44+(11 AND SK=2) — adds 11 depth charges for Cadet mode.
• LET S=S+(1 AND X=8)+(2 AND X=13)+(3 AND X=L) — awards different scores depending on which sub row was hit.
• LET XX=1+(1 AND X=13)+(2 AND X=L) — identifies which sea row array to damage.
• (" \q" AND DD<>0) — prints a depth charge icon only if charges remain.

Rating Calculation

The end-of-mission percentage rating at lines 3240–3250 uses a multi-factor formula:

• K1 = S * 0.267 — score contribution.
• O = (DC-(SU+MD))/(SU+MD)^0.5 — accuracy penalty based on depth charges used versus kills.
• K2 = 20 - (O*3) — accuracy component.
• K3 = 20 - MM — penalty for missiles that reached home base.
• K4 = ST*6 — bonus for completing more waves.

The final rating K = INT(K1+K2+K3+K4) is displayed as a percentage. Note that negative values of O or MM exceeding 20 can push K2 or K3 negative, naturally penalizing poor play.

Bugs and Anomalies

• Line 2020 contains the typo "MISSION COMPLEATED" (should be “COMPLETED”). This appears in the win condition message.
• Lines 50 and 130 are referenced by GO TO 50 (line 2030) and GO TO 130 (line 2130) but are not present in the listing. Line 30 and line 140 are the closest existing lines; this likely causes a “Line does not exist” error on wave advance or ship loss, unless these lines exist in the actual loaded program but were omitted from this listing.
• Line 1110 contains IF P=1 THEN LET X=X+1, but P is also used as the loop variable in the FOR P=0 TO 20 at line 2010, which will overwrite the depth charge direction variable. This could cause incorrect depth charge behavior if lines 2010 and 1110 interact.
• The missile movement at line 1705 uses LET X1=X1-.5 and line 1710 checks IF X1=3. Since X1 decrements by 0.5, it will pass through 3.0 correctly if it started at an odd integer plus 0.5, but may skip the value 3 exactly depending on initial conditions — a potential off-by-one in missile arrival detection.
• Line 3050 has a trailing ' character after the closing quote, which in Spectrum BASIC is a newline token within a PRINT statement. This is likely a spurious character but is harmless.

Save/Load Architecture

The program is designed to be saved as two separate blocks: the BASIC program saved with LINE 8040 to auto-run, and the UDG data saved as a 136-byte CODE block (17*8 bytes from USR "A"). Line 8040 loads the CODE block before running, ensuring the custom characters are in place before the title screen displays.