Snaker

Snaker is a snake-movement game where the player steers a growing snake around a playfield, eating dots while avoiding collisions with the snake’s own body and managing a countdown timer. The playfield is generated with randomly placed food dots using INK, PAPER, and FLASH attributes, and collision detection relies on reading screen attributes via the ATTR function rather than tracking object positions in arrays. Two custom UDG characters are defined—one for the snake body and one for the food dots—using POKE USR with bitmap data read from DATA statements. A 55-byte machine code routine is loaded into RAM at address 65200 via POKE, called through USR, and handles sound effects (writing to port 254) and screen operations using direct Z80 instructions. The game tracks waves, score accumulation based on remaining time and wave number, and maintains a top-10 high score table with four-character initials, stored in arrays across sessions within a single run.

---

Program Structure

The program is organized into functional blocks across its line numbers. Lines 20–27 form an initialization routine: setting screen attributes, defining UDGs, poking machine code, and seeding the high score table. Lines 1–9 are the core game loop handling movement, collision, and display. Lines 10–13 generate the playfield and advance the wave. Lines 14–19 handle death, the high score screen, and the instructions screen. Line 30 is a cleanup/quit routine, and lines 35, 110, and 9990 form a tape-loading subroutine.

UDG Definition

Two UDG characters are defined in lines 21–23. The program reads each character name ("\\o" for the snake body, a filled circle shape; "\\a" for the food dot, a smaller square) and eight bytes of bitmap data, then POKEs them into USR b$—the standard Spectrum method for writing UDG pixel patterns. This allows the playfield and snake to use readable, distinctive glyphs rather than standard character set symbols.

Machine Code Routines

Two machine code entry points are embedded at addresses 65200 and 65232 within a 55-byte block poked in line 24 from DATA at line 25. Both are invoked via USR assigned to a dummy variable u. The routine at 65200 appears to produce a sound effect by writing to I/O port 254 (OUT 254, opcode D3 FE), looping with a counter. The routine at 65232 is called during normal snake movement and food consumption. Because USR returns a value, assigning it to u is the standard BASIC idiom for calling machine code as a statement without losing the return value.

Collision Detection via ATTR

Rather than maintaining a full collision map or checking coordinate arrays, the game uses ATTR (x,y) to read the screen attribute byte at the snake’s new head position. A result of 242 identifies a food dot cell (INK 2, PAPER 6, FLASH 1, BRIGHT 0 encodes to this value), while 67 identifies the snake’s own body (INK 3, PAPER 0 encodes accordingly). This is a compact and efficient technique that offloads collision state entirely to the display file.

Snake Position Tracking

The snake’s segment positions are stored in parallel arrays x() and y(), dimensioned to 1005 elements each at line 2. The variable a is an index that advances by 2 each step (line 5), storing both a midpoint and the new head. The tail is erased by printing a space at position x(a-l), y(a-l), where l tracks the effective length. This sliding-window approach avoids shifting array contents on each move.

Movement and Direction Logic

Direction is encoded in c$ (a single INKEY$ character). At line 3, the deltas xt and yt are computed using Boolean arithmetic: 2*(c$="6")-2*(c$="7") gives horizontal movement, and 2*(c$="8")-2*(c$="5") gives vertical movement, corresponding to the Spectrum’s cursor keys. The step size of 2 is used because the playfield uses even-numbered columns (the food is placed at even coordinates in line 11), keeping the snake aligned to the grid.

Playfield Generation

Line 11 scatters food dots on even rows (0, 2, 4 … 18) using random even column positions. A mild collision-avoidance check LET q=q-2*(q=o) shifts one dot if both would land on the same column. Line 12 prints a row of UDG-A characters on odd rows to create a textured background pattern. The score display line at row 21 shows the countdown timer t, accumulated score s, current wave w, and remaining lives represented as snake-body glyphs conditionally printed based on sl.

Scoring and Wave Progression

Score is accumulated at two points: on completing a wave (s=s+t*w at line 10, rewarding speed and wave depth) and on losing a life (s=s+w*(550-t) at line 14). The food counter p is checked against 20 at line 6; eating 20 dots advances to the next wave. The snake starting length bl increases by 3 each wave up to a cap of 31, and the time limit t decreases as 550-10*a where a=bl+1, making each wave harder.

High Score Table

Lines 15–16 implement a 10-entry high score table using numeric array h(10) and string array h$(10,4) for four-character initials. A reverse loop from 10 to 2 shifts entries downward using the Boolean expression h(f-(h(f-1)<s)), a compact insertion-sort idiom. The table is pre-seeded in line 26 with scores 10000 down to 1000 and initials "MF ".

Instructions and Menu Loop

Line 17 draws a shrinking rectangular border using OVER 1 (XOR plotting), looping by re-executing itself: GO TO 17+(yl=-1 OR INKEY$="Y")-16*(INKEY$="N")+13*(INKEY$="Q"). This single-line conditional branch dispatches to line 18 (instructions), line 1 (new game), or line 30 (quit) depending on keypress, without any explicit IF statement. Line 19 similarly busy-waits for a keypress with GO TO 19*(INKEY$=""), branching to line 0 (falling through to start) when any key is pressed.

Notable Anomalies

• Line 6 checks p=20 after incrementing p, but p is initialized only at line 10 (wave start), not at line 2 (life start), so a player resuming after a lost life retains the previous food count — potentially a minor bug.
• Line 8 prints both the tail-erase and two snake segments in a single PRINT statement using multiple AT items, which is efficient but means the display update is not atomic with the movement logic.
• The subroutine at line 100 (called from line 20) and the related code at lines 35 and 110 suggest a tape-loading wrapper that was part of the distribution mechanism; line 35 prompts to start the tape and performs a LOAD "".
• Line 9999 saves the program with LINE 20, auto-starting at the initialization block rather than line 1.