New York by Night

“New York By Night” is a Space Invaders-style arcade game in which the player controls a flying disc that destroys descending aliens before they can flatten New York City. The game uses three custom User Defined Graphics (UDGs) — characters A, m, and n/c — whose 8-byte shape data is POKEd directly into the UDG area at startup via READ/DATA statements. Gameplay difficulty is selectable from level 2 to 8 at startup, with the variable `le` controlling the depth range of alien drops. The skyline is generated procedurally using random PLOT calls, and collision detection relies on reading screen attribute bytes with ATTR rather than tracking sprite coordinates, a common Spectrum technique. Attack waves are tracked with variable `aw`, and the game ends when 27 aliens (`i=27`) have been destroyed, triggering a city-destruction animation sequence.

---

Program Analysis

Program Structure

The program is organized into two broad phases: an initialization/setup subroutine starting at line 620, called via GO SUB 620 at line 50, and the main game loop beginning at line 60. Control flow is largely managed through GO TO jumps rather than structured loops, which is typical for action games of this era.

1. Lines 50–80: Call setup, set border/paper/ink, draw the random starfield and city skyline.
2. Lines 90–120: Build the buildings column by column using UDG characters printed at incrementing column z.
3. Lines 130–320: Main game loop — player movement, alien drop, collision detection, scoring.
4. Lines 330–550: Hit/miss resolution, wave completion, alien landing animation, and transition logic.
5. Lines 560–610: End-of-game sequence, “another game?” prompt, and port-cycling sound effect.
6. Lines 620–870: Setup subroutine — variable initialization, UDG definition, instructions display, difficulty selection.

User Defined Graphics (UDGs)

Three UDG characters are defined by POKEing 8-byte shape data into the UDG memory area. The setup loop at line 660 reads 32 bytes from the DATA statements at lines 670–700 and POKEs them starting at USR "A", defining UDGs A and B (16 bytes each, covering characters A and B). A second loop at line 710 reads 16 bytes into USR "m", defining UDG m.

UDG	Lines	Used as
\a (A)	670–680	Alien sprite
\c (C) / \b (B)	670–700	Building tiles / disc hit effect
\m (m)	720–730	Player flying disc / ship animation
\n (n)	(shares m block)	Ship animation frame

Note that the DATA at lines 690 and 700 contain the bare variable name s rather than a numeric literal in two positions (e.g., 60,126,153,s,255,...). At READ time, s will hold whatever value it was last assigned in the loop (the previous byte read), so these act as self-referential fill values — an unintentional but functional quirk.

Collision Detection via ATTR

Rather than maintaining sprite coordinate tables, collision detection at line 280 reads the screen attribute byte at the player’s disc position using ATTR (x,y) and ATTR (x,y+1), checking for the value 71 (INK 7, PAPER 0, BRIGHT 1 — the building color). Similarly, line 290 checks ATTR (k,l)=68 to detect when a falling alien lands on the city floor. This attribute-based collision approach avoids any coordinate bookkeeping for the static city geometry.

Key BASIC Idioms and Techniques

• Variable reuse for zero-initialization: Line 630 sets j=0, then reuses j to initialize sc, bh, and k at lines 640–650, saving tokenized bytes.
• Building construction loop: Lines 90–120 increment column z and print UDG characters vertically using a FOR loop, building up the skyline one column at a time until z>=29.
• Port-cycling sound: Line 590 loops OUT 254,b for b=0 to 224, producing a sweeping border-color sound effect by toggling the EAR/MIC bits of the ULA port.
• Starfield generation: Line 70 uses 50 random BRIGHT 0 PLOT calls with random INK colors to simulate a night sky behind the city.
• Alien drop depth: The FOR loop at line 200 runs from 0 to 21 rows, but the building height is influenced by le (difficulty level) at line 100: 21-INT(RND*le) varies how far down building columns are printed, making higher difficulty produce shorter (more exposed) buildings.
• Comma-separated PRINT AT blanking: Line 400 uses PRINT AT 5,0,,,,,,,, to overwrite multiple screen positions with empty strings in a single PRINT statement.

Bugs and Anomalies

• DATA with variable s: Lines 690 and 700 include s as a DATA value. During READ, s holds the most recently read numeric value from the DATA list. This will produce valid (if unintended) sprite byte patterns, but the UDG shapes may not exactly match the original program’s intent if s was meant to be a specific literal.
• Wave counter logic: Line 130 checks IF aw>=0, which is always true after initialization (aw starts at 1), so bh is unconditionally incremented on every pass through this line, potentially causing the player disc’s row x to drift upward unexpectedly over many waves.
• Line 20 is blank: An empty line at 20 with no statement is syntactically harmless but occupies space in the program.
• REM at line 40 contains a stray comment inside another line: Line 40 begins with whitespace before REM, which is valid but unusual formatting likely from the original magazine typesetting.
• UDG \n (char n) is used at lines 430 and 540 but is never explicitly defined in a dedicated DATA/POKE block. It falls within the 16-byte block POKEd to USR "m" (which covers m and n), so it does receive data — but this is implicit rather than clearly documented in the listing.

Game Flow Summary

After setup and the skyline drawing phase, the main loop repeatedly drops a single alien from the top of the screen while allowing left/right player movement via Q and P. A counter i tracks aliens that reach the city floor; reaching 27 triggers the “city destroyed” ending. A counter c tracks successful interceptions; reaching 20 advances the attack wave. After each wave, an animation sequence at lines 420–540 shows the aliens departing, and the game loops back to the skyline drawing phase for the next wave.