Squash – MC

This program implements a single-player Squash game in which a ball bounces around an enclosed court and the player controls a bat at the bottom using the P and Q keys. The court walls are drawn using inverse-video characters for the sides and block graphics (▄) for the top, while the bat is rendered with a block graphic character. Ball movement is tracked with direction variables L and M, and the collision logic at line 130 uses a chained comparison idiom to detect wall bounces. Scores are tracked separately for the Sinclair (computer) and the player, with the first to reach 10 winning the match.

---

Program Analysis

This program is a machine code game or application stored entirely within the REM statement at line 1, with execution triggered by RAND USR 17298 (hex 0x4392), which jumps into the machine code block. The REM data spans several hundred bytes of Z80 object code, containing what appears to be a complete self-contained program including display routines, sprite handling, and game logic. Line 4030 saves the program with an auto-run marker. The BASIC lines 4010–4040 serve purely as a loader/utility shell; the real program is the Z80 code embedded in the REM statement.

Program Structure

The BASIC listing is minimal by design. The program consists of five lines:

• 1 REM ... — contains several hundred bytes of Z80 machine code as raw data embedded in the REM token’s string body.
• 4000 RAND USR 17298 — transfers execution to address 17298 decimal (0x4392 hex), which is inside the REM statement’s data area (the BASIC program starts at 0x4000 on this system, and the REM body begins a few bytes in at line 1).
• 4010 STOP — a safety net if USR returns.
• 4020 CLEAR — present but never reached in normal flow; likely a utility/development remnant.
• 4030 SAVE "1024%8" — saves the program.
• 4040 RUN — restarts execution from the first line.

Machine Code Entry Point

The entry point at 0x4392 (17298 decimal) is calculated as follows: the BASIC program area starts at 0x4000; line 1’s REM token occupies bytes at a fixed offset (line number 2 bytes, length 2 bytes, REM keyword 1 byte = 5 bytes), so the REM data body begins at 0x4005. The entry point 0x4392 is therefore 0x38D (909) bytes into the REM data, pointing to a specific subroutine or initialisation block within the machine code rather than the very start of the data.

Machine Code Content Analysis

Disassembling key portions of the REM data reveals the following functional blocks:

• 0x4005 (start of REM body): Begins with 2A 39 40 — LD HL,(0x4039), immediately reading a pointer from within the REM area itself, indicating self-referential data structures.
• ROM calls: Numerous CD xx xx (CALL) instructions target ROM addresses (e.g. CD 2B 0F, CD 1F 0A, CD 75 43), making use of system ROM routines for display output (D7 = RST 0x10, the character output restart) and other OS services.
• Display output: The opcode D7 (RST 16) appears repeatedly throughout the code, used to print characters to the display via the ROM character output routine.
• IY register use: Several FD CB prefixed instructions operate on (IY+offset), accessing the system flags area (IY normally points to FLAGS in the system variables area).
• 16-bit arithmetic: Extensive use of ED 62 (SBC HL,HL), ED 52 (SBC HL,DE), ED 4B/ED 5B (LD BC/DE,(nn)) and 22 xx xx (LD (nn),HL) for multi-byte variable management.
• Data tables: The latter portion of the REM (roughly from offset 0x300 onward) contains interleaved code and data including what appear to be text strings stored as offset-encoded bytes (values like 38 36 3A 26... which, when decoded with a consistent offset, form readable ASCII text), and a block of initialisation data ending in zeros at the very end of the REM.

Memory Map of Key Addresses

Address (hex)	Address (dec)	Role
0x4000	16384	BASIC program start (line 1 header)
0x4005	16389	REM data body / machine code start
0x4392	17298	USR entry point (RAND USR target)
0x47xx	~18xxx	Self-modifying/variable storage within REM (LD (0x47xx),HL patterns)

Notable Techniques

• REM-as-code: The entire application is stored inside a REM statement, a classic technique that places machine code in a safe location within the BASIC program area where the BASIC interpreter will not attempt to execute it as tokens.
• Self-contained variable storage: Addresses in the 0x47xx range (still within the REM body) are used as RAM storage locations, written to with LD (nn),HL and read back with LD HL,(nn), making the REM area serve as both code and data space simultaneously.
• RST 16 output: Direct use of D7 (RST 0x10) for character-by-character display output bypasses higher-level BASIC print routines for speed.
• Encoded text strings: Printable text in the data section appears to be stored with a byte offset applied to each character value, a simple obfuscation/packing technique that also avoids null bytes and BASIC keyword token conflicts within the REM body.
• Stack manipulation: Frequent E3 (EX (SP),HL) instructions are used for efficient stack-based parameter passing and return address manipulation, a Z80 idiom for coroutine-style control flow.
• Initialisation block: The final bytes of the REM — 00 00 01 00 01 00 0A 00 00 00 ... — are a zeroed/initialised data block, consistent with game state variables reset at startup by the initialisation routine near 0x4392.

BASIC Shell

The four BASIC lines above 4000 form a minimal loader. RAND USR 17298 is used rather than USR 17298 alone because RAND USR discards the return value without requiring it to be assigned or printed, and on this system it also avoids a potential error condition if the machine code returns a non-numeric result. The STOP at line 4010 ensures the interpreter halts cleanly if control ever returns to BASIC.

Potential Anomalies

• Lines 4020 CLEAR and 4040 RUN are unreachable in normal operation and appear to be development/utility lines left in the listing.
• The SAVE line at 4030 saves only the BASIC wrapper, not explicitly invoking a full binary save — the machine code is preserved as part of the BASIC program file since it resides in the REM statement.