Bat Cage

Bat Cage is an action game in which the player catches a falling egg and then traps a bat inside a cage. The program is driven almost entirely by machine code embedded in the REM statement at line 1, with BASIC serving only as a loader that calls the routine via USR 17387 at line 10. The machine code handles all gameplay logic, graphics rendering, collision detection, and input processing directly. A SAVE command at line 20 preserves the program, and RUN 10 at line 30 restarts the game loop.

---

Program Analysis

Program Structure

The BASIC listing is minimal by design, consisting of just three lines:

1. 1 REM — contains the entire machine code payload (several hundred bytes) embedded as the body of the remark.
2. 10 LET K=USR 17387 — transfers control to the machine code. The address 17387 (decimal) corresponds to the start of the machine code bytes stored in the REM line’s data area.
3. 20 SAVE "CAGE" — saves the program to tape.
4. 30 RUN 10 — restarts the program by jumping to line 10.

All game logic — movement, collision detection, graphics, timing, and scoring — is implemented entirely in the machine code within the REM statement. BASIC is used solely as a vehicle to load and launch that code.

Machine Code Embedding via REM

Storing machine code in a REM statement is a well-established technique. The BASIC interpreter skips REM line content entirely, so arbitrary binary data can be placed there without interference. The USR function at line 10 computes the Z80 entry point address (17387) and performs a CALL to it, handing control to the machine code. The return value is stored in K, though the game does not use it in BASIC.

Machine Code Analysis

The REM data is a dense Z80 routine. Notable structural features visible in the hex stream include:

• CB-prefixed instructions — extensive use of CB opcodes indicates heavy reliance on bit manipulation instructions (BIT, SET, RES, RLC, etc.), consistent with sprite/character-level graphics and flag-based state machines.
• ED-prefixed instructions — ED opcodes appear frequently, covering 16-bit loads (LD BC,(nn), LD DE,(nn)), block moves (LDIR), and LD A,R / LD A,I used for pseudo-random number generation or timing.
• Block memory operations — sequences ending in \ED\B0 (LDIR) suggest bulk copying of sprite or screen data.
• Internal subroutine calls — numerous CD xx xx (CALL) instructions with targets within the REM block point to a well-structured internal subroutine architecture covering rendering, input reading, collision, and movement.
• Address constants — repeated references to addresses in the 43xx and 44xx hex range (roughly 17000–17600 decimal) indicate game-state variables stored within or just after the REM block itself.

Key Address Map (inferred)

Hex Address	Decimal	Inferred Role
43CB	17355	Sprite/object X or position low byte
43CC	17356	Sprite/object Y or position high byte
43CD	17357	Secondary object coordinate
43D0	17360	Game state / direction flag
43D1	17361	Velocity or delta counter
43D2	17362	Additional state variable
44B6	17590	Screen buffer or sprite data table
44D8	17624	Graphics/shape data

Notable Techniques

• LD A,R (ED 5F) — used as a source of pseudo-randomness by reading the Z80 refresh register, a common technique for seeding movement or timing variation without a dedicated RNG.
• Bit-field state machine — the heavy use of BIT, SET, and RES on single bytes (visible in the CB 4x, CB 5x, CB 6x, CB 7x ranges) suggests individual bits of state bytes encode direction, phase, and collision flags compactly.
• Self-contained variable storage — game variables are stored at fixed offsets within the REM block’s memory region rather than in BASIC variables, avoiding BASIC overhead entirely.
• Loop unrolling with DJNZ — several 10 Fx byte pairs (DJNZ with negative offset) implement tight delay or drawing loops without BASIC’s overhead.
• Exx / DI shadow registers — D9 (EXX) appears in the code, indicating use of the Z80 alternate register set for temporary storage during interrupt-sensitive sections.

BASIC Idioms

The use of LET K=USR 17387 rather than a bare RAND USR is a minor stylistic choice; both transfer control identically. The RUN 10 at line 30 provides a simple restart mechanism: if the machine code ever returns to BASIC (e.g., after a game over), the program loops back to re-invoke the machine code rather than halting.

Bugs and Anomalies

No significant BASIC-level bugs are present. The program is straightforward as a loader. Any bugs would reside entirely within the machine code and cannot be fully assessed from a static hex listing alone.