Artic Explorer

Arctic Explorer is a scrolling arcade game in which the player guides a character across an icy landscape, avoiding obstacles and collecting bonuses while managing a countdown timer.

The game uses UDG (User-Defined Graphics) characters defined via POKE into USR addresses to render the player sprite and terrain elements. Screen scrolling is simulated by rotating string arrays — for example, line 1100 rebuilds a 224-character string by reordering 32-character segments to shift the background left.

Seven distinct level subroutines (1100–1900, dispatched via GO SUB 1000+(s*100)) each vary the obstacle pattern and movement style, providing increasing difficulty.

Sound effects use BEEP with DATA-driven note sequences read via RESTORE/READ, and a high-score table persists in memory across playthroughs within the same session.

Controls:

• O=Left
• P=Right
• O+CS (capshift) = Jump Left
• P+CS = Jump Right

---

Program Analysis

Program Structure

The program is organized into a set of functional blocks spread across the line-number space:

• Lines 1–7: Initialization, title screen, and key-wait loop.
• Lines 10–100: Main game loop — calls level setup and game-state subroutines, processes input, detects collisions, handles screen advance.
• Lines 1100–1900: Level-specific scrolling subroutines (dispatched by GO SUB 1000+(s*100)).
• Lines 2000–2550: Boundary detection, bonus scoring, and level-end animation.
• Lines 3000–3840: Death handling, lives management, game-over screen, and high-score logic.
• Lines 4000–5000: Jump mechanics subroutines.
• Lines 8010–8100: Level initialization subroutines — set up a$ string layout and border graphics.
• Lines 9000–9999: UDG loader, variable initialization, screen setup, and DATA blocks.

Level Dispatch Idiom

Level selection uses a computed GO SUB: GO SUB 1000+(s*100) at line 40. As the stage variable s increments from 1 to 9, this dispatches to subroutines at 1100, 1200, …, 1900. Similarly, GO SUB 8000+(s*10) at line 25 calls the corresponding level-setup routine (8010, 8020, …, 8090). This avoids a chain of IF statements and compactly encodes the level table.

String-Rotation Scrolling

The background is stored in the string a$ rather than directly on the display. Each frame, segments of the string are permuted to simulate leftward or rightward scrolling, then printed with PRINT AT 0,0 or PRINT AT 5,0. For example, line 1100 does:

LET a$=a$(193 TO 224)+a$(1 TO 32)+a$(33 TO 64)+...+a$(161 TO 192)

This rotates the last 32 characters to the front of a 224-character (7 × 32) string, scrolling seven rows of 32 columns simultaneously. Line 1200 instead uses a two-row, 64-character string scrolled one character at a time.

UDG Sprite Definitions

Line 9000 loads UDG data from line 9920–9940 into memory using POKE f,a iterating from USR "a" to USR "p"+7, defining 16 UDG characters (a–p). The player sprite is \a (UDG ‘a’), referenced as part of the two-character string b$="\a\b". Terrain and obstacle elements use further UDGs including \g–\o.

Collision Detection

Collision is checked using ATTR (a+1,b) — reading the attribute byte of the cell below the player. A value of 56 corresponds to PAPER 7, INK 0 (white background, black ink), which marks solid ground or obstacle tiles. A non-space character at the player’s column in the scroll string also triggers a collision. Both conditions route via GO TO n, where n=3000 is the death handler — using a variable rather than a literal line number.

Jump Mechanic

Jumping is handled by subroutine 4000. It reads a sequence of six (x, y, m) tuples from DATA at line 9950:

DATA 16,-1,0,18,-1,0,20,0,q,22,0,q,22,1,q,20,1,0

Each iteration plays a short BEEP, erases the player, adjusts row by y and column by m (where q is the jump direction set before the call), and redraws the sprite. This produces a small arc. The direction variable q is set to +1 (right jump, key “P”) or -1 (left jump, key “O”) before calling GO SUB 4000.

Sound Design

Music and sound effects are driven by RESTORE/READ loops over three DATA lines:

Line	Purpose
9900	Background tune (32 notes, used for bonus/death fanfares)
9910	Game-over melody (25 notes)
9950	Jump arc coordinates (6 triples)

The game-over tune at line 3820 uses fractional durations (a/4) for a smoother tempo. Death sound at 3010 uses a/2 and at 3800 uses a/1.5, creating distinct audio feedback for different events using the same data.

Timer and Scoring

A countdown timer t starts at 100 for each stage. Line 40 decrements it each main loop iteration via LET t=t-(t>0) — the boolean expression (t>0) evaluates to 1 or 0, preventing t from going negative without an IF statement. On stage completion, sc is increased by t+100 plus any bonuses. A separate 500-point bonus is awarded at line 2500 if the player reaches column 25 or beyond.

Notable Anomalies

• Line 9050 is referenced via GO SUB 9050 at line 10, but line 9051 is the actual first executable line of that subroutine. GO SUB targeting a non-existent line falls through to the next higher line — a known and intentional BASIC technique.
• Line 8081 contains PRINT ;7,0;n$ — the semicolon before 7,0 appears to be a syntax anomaly; it likely should be PRINT AT 7,0;n$, possibly a typo in the original listing.
• Line 9510 is defined but the label GO SUB 9500 at line 25 would fall through to 9510. It clears lines 12–21 with PAPER 0 and calls RESTORE to reset the DATA pointer.
• Line 20 is referenced by GO TO 20 at line 2550 but does not exist; execution falls to line 25, which is the level-restart logic — intentional use of non-existent target line.
• The DATA at line 9960 appears to be unused by any READ loop in the visible code, suggesting either dead data or a removed display-setup routine.
• Line 9970 contains what appear to be sine-table values (±45, ±53, etc.) and a final value of 200, also unreferenced — possibly a remnant of a removed circular animation feature.