Hydrofool: Disassembly

8x8 grid (row-major, offset = row*8+col), cleared to 0 then populated by 62A2 from a shared room-type template (72D1 family, selected by $612A via the 72B1 pointer table), plus any per-room extra pairs from the room description itself (see 6CCF). Each entry's grid cell address is $612B+index (i.e. grid_offset = index-1); the stored value is either a plain content code (see table below), or one of $66/$67/$68/$69/$6A/$6B which additionally triggers a dedicated object-spawn routine (8EA7/8EF2/8F1E/8F4C/8E3F) -- these special values do NOT persist in the finished grid; they spawn a dynamic object instead (see 84AE) and the grid cell they occupied stays part of the static terrain layout only incidentally.

Static object codes: $01=small seaweed, $02=flat rock, $03=clam shell (no pearl), $04=small rock, $09=rock, $0D=seaweed, $7F=solid wall (seen as a contiguous 3x3 corner block), $0A-$10=display cubes/cases with varying item glyphs (seen in Plug Rooms). Creatures, pickups (spoon/ball/horseshoe/etc), and air-bubble sources are NEVER on the grid -- they're separate dynamic objects (see 84AE), not static terrain.

Resolved 5-bit input mask, produced every frame by 7EBE from whichever control method $617B selects. Bit0=Right, bit1=Left, bit2=Down, bit3=Up (Kempston-port convention: reading Kempston directly copies its byte here unmodified), bit4=Fire/pick-up. Consumed by 8968 (movement -- resolved to a single direction via the table at 88F0) and 8AFB (fire button). Masked against a "previously pressed" copy at $6188 by 7EBE itself (edge-detection), and accumulated into a repeat counter at $617C.

Used by 983C to call a dynamic object's per-frame behaviour handler

Re-reads room description byte1 (at room_base+1), merges bit4 into bit0 and bit7 into bit3 (via AND $90, RRCA x4, OR), writes the result back into the room description itself AND into $612B. Bits 0-3 of the result are then tested by 6344/6377 to conditionally draw door graphics at fixed screen positions -- one bit per exit direction: bit0=North, bit1=East, bit2=South, bit3=West (see 67F1).

Tests bit 0 of $612B (North), drawing one door-graphic piece via 8128 at a fixed screen position if set; then bit 3 (West), drawing a different fixed-position piece if set.

Tests bit 1 of $612B (East), drawing three door-graphic pieces via 8128 (three fixed screen positions) if set; then bit 2 (South), drawing three different fixed-position pieces if set. Calls 6344 first.

Uses $6129 (0 or 1) to index a 2-entry pointer table at $63DE, selecting one of two fixed layout lists. Each list has two parts: a sequence of 4-byte records (count, screen Y, screen X -- drawn via 8128) terminated by $FF, immediately followed by a sequence of single bytes (grid indices) terminated by $FF, each poked into the room grid ($612B+index, i.e. grid_offset=index-1) as solid wall ($7F). This is the source of the 3x3 solid-wall corner block seen in every room grid -- it is not part of the room-type template; it is this fixed, $6129-selected layout.

This entry point is used by the routine at 6470.

Sets $6199=1, resets the rust/oil timer $6501 to 0 (full), decrements oil-can count $6198 (BCD), calls $6646 (unidentified), plays sound effect $09.

This entry point is used by the routine at 6622.

Fires during room build. Passes IX=$8DEF (the creature insertion point -- see 8DB6) into 84AE, so the creature is spliced into the active object list right after the fixed records, i.e. processed after the player. Handler is 9341.

Draw the full room (walls, doors, message window, creatures/objects) -- or the reduced special-room variant for rooms $01/$02

Rooms $01 and $02 are the only two type $E rooms, and are special "no walls" rooms (see 6CCF -- room $01 is the ending/winning room). At 67AB, this routine checks if the current room ($6126) is 1 or 2 and, if so, skips straight to 67E0, bypassing: the wall/layout draw (642F), door-graphic draw (6377), the message window (65DB), and several creature/object placement calls (6593/$655E/$663B/$6743/$8F82/$6895/$885A). The room's grid contents (rocks/seaweed etc, from its type $E template) still get drawn via a separate, non-skipped path -- consistent with the "just floating rocks and seaweed, no walls" appearance of room $01. Room $01 additionally gets one extra call, 86CC (CALL Z at 67E8, gated on room==1 specifically, not room==2) -- draws the "DEATHBOWL DIVINED" end-game stats overlay (see 86CC).

Special-room path for rooms $01/$02: skips walls/doors/message-window/most creature calls; room $01 additionally calls 86CC (likely the end-game stats overlay)

Reads a direction code from ($8DC1) -- 1, 2, 4, or else (fallback case) -- and for each, tests one bit of the door bitfield at 612B via HL (set to $612B just before this dispatch) before allowing the move: bit 0 (direction code 1) gates "room number - 6" (row-1, NORTH); bit 1 (direction code 4) gates "room number + 1" (col+1, EAST); bit 2 (direction code 2) gates "room number + 6" (row+1, SOUTH); bit 3 (the fallback case) gates "room number - 1" (col-1, WEST). Also does on-screen player-position bounds checks (against D/E, likely screen row/col) before allowing the move, presumably to require the player to be near the room edge on that side. 97FC is called with the new room number to actually perform the transition.

Draws the sprite from the held-item record (6110, offset +3) at fixed HUD position $D4F8 via 8128, then checks (via 88E3) whether it's a weapon; if so also prints its ammo count (619E, BCD) via 854F.

This entry point is used by the routine at 68C1.

Decrements 619E (ammo, BCD); if still nonzero, just redraws the HUD ammo count. If it reached 0: clears the HUD digits, resets 6110 (held item) to the "empty hands" sentinel 788A, and redraws the HUD icon via 6895.

The world is a 6x6x6 cube of room slots (6 levels, each a 6x6 grid), per an external game map. The highest room number in this table is $D7=215=6*6*6-1, and the table has 216 records total ($00-$D7) -- one per cube slot, including ~15 unused/vacant ones (no room actually there). Horizontal (same-level) neighbours connect via doors (612B); vertical neighbours connect via whirlpools (down, 8A87) and bubbles (up, also 8A87).

The room number decodes to its cube position via n=room_number-1, then level=n/36, row=(n%36)/6, col=n%6 (0-based). Cross-checked against the 4 menu entry points (A/B/C/D) and an external game map (see x-docs/Room-Format.md).

Room description format (consumed by 6269/62BB):

byte 0: record length (offset to the next room's description);

byte 1: door/exit bitfield, stored to $612B (bit0=North, bit1=East, bit2=South, bit3=West -- see 6329/67F1);

byte 2 bits 4-7: room type index (0-15), stored to $612A -- selects the grid template from the 72B1 pointer table AND the room's creature/inhabitant (via the same value used again below);

byte 3 bit 6: wall/decoration layout selector, stored to $6129 (selects one of 2 fixed layouts drawn by 642F);

byte 3 bits 0-5: a 6-bit index (byte3 AND $3F) into the 73B5 room/creature title table -- selects the message-window title text (DEATHBOWL/PIRANHA/SEAHORSE/etc), printed by 65FD. NOT door/exit flags -- exits are encoded in byte1 (see 6329).

bytes 4+ (if record length > 4): extra (index,value) pairs specific to this room, laid out and consumed identically to a room-type template (see 72D1) -- appended on top of the shared room-type template when the room grid is built. The loop counter B starts at (length-4), but a special-value pair (value in $66/$67/$68/$69/$6A/$6B) makes its spawn routine (e.g. 8EA7) decrement B as a side effect, ending the loop early. Example: room $52 (6ECF) has 3 trailing bytes $37/$6A/$20 -- its single special pair ($37,$6A) consumes 2, and the double-decrement ends the loop before the last byte ($20) is read. Odd leftover-byte counts are therefore normal whenever a special-value entry is present.

The "Room $XX" labels below match the in-game room number as read from $6126 (i.e. 1-based: the first record is room $01).

Level 1 of 6 (room numbers $01-$24, cube rows/cols 0-5 -- see x-docs/Room-Format.md) -- entry point 'C' lands in this level (room $1A)

Level 2 of 6 (room numbers $25-$48)

Level 3 of 6 (room numbers $49-$6C) -- entry point 'A' lands in this level (room $52)

Level 4 of 6 (room numbers $6D-$90) -- entry point 'D' lands in this level (room $84)

Level 5 of 6 (room numbers $91-$B4)

Level 6 of 6 (room numbers $B5-$D8) -- entry point 'B' lands in this level (room $C0)

Per-level Plug Room table: 6 entries (levels 1-6), 6 bytes each. byte0 = the level's Plug Room number ($00 = none; $32/$65/$9B/$D8 for levels 2/3/5/6), byte1 = state byte (low nibble checked against $0F by 8F4C/94F4 to suppress the plug spawn -- plug already pulled?), bytes 2-5 = purpose not yet known. Looked up by 62F9.

16 words, indexed by $612A (room type 0-15, from room description byte2 bits 4-7); each points to a template block below. Types 9-14 all share the same template ($73A0).

Each template starts with a byte0 giving the total byte count of that template block (not a pair count -- matches the gap to the next template's pointer exactly), followed by (index,value) pairs consumed by 62C8 to populate the room grid (see 612C).

Room type $0 (19 bytes)

Room type $1 (15 bytes)

Room type $2 (39 bytes)

Room type $3 (15 bytes)

Room type $4 (21 bytes)

Room type $5 (17 bytes)

Room type $6 (19 bytes)

Room type $7 (39 bytes)

Room type $8 (23 bytes)

Room type $9..$E (19 bytes)

Room type $F (2 bytes) -- used by exactly 4 rooms in the whole table -- $32, $65, $9B, $D8 (cube positions level2/row2/col1, level3/row4/col4, level5/row1/col4, level6/row5/col5 respectively) -- all four "PLUG ROOM" (title index 8). Per the game's own instructions text (x-docs/Instructions.txt): "the gigantic planetary aquarium... is now so polluted that the only remedy is to completely empty it of water by pulling each of the four main plugs" -- these 4 rooms are the win-condition rooms: pulling all four plugs completes the game. The template itself (2 bytes: length + 1 more) is too short to hold any real (index,value) pair, consistent with Plug Rooms being a distinct, mostly-static-content-free category built around the plug-placement mechanic rather than normal terrain.

10 entries, 14 bytes each, terminated by $5E. Indexed by room type (see 72D1); printed as the message window's title line by 65DB and restored by 9808. Entries $A onward (from 7441) are reused as the rotating clue/joke message table printed by 65DB via 65D7.

7 entries, 20 bytes each, terminated by $FF; alias into the tail of the 73B5 table.

Per-terrain-code shape/behaviour pointer table, indexed by grid content code * 2 (code $00, unused since a $00 grid cell means "empty" and is never looked up, has a dummy entry). Read by 9ABC (player/object collision -- looks up the pointer, then reads further bytes for shape data) and 8E6E (creature/object setup, same table). 21 entries (codes $00-$14) pointing into the shape-record area starting at $7580; codes above $14 are never used as static grid content and have no entry.

Prints the char/control code in A by jumping through the vector at (7CE8).

Prints char A as a font glyph at (7CEA), or switches mode for control codes $14/$16.

This entry point is used by the routine at 7D3F.

This entry point is used by the routines at 7D32, 7D3F and 7D48.

Self-modifies the LD A at 7D12 to CPL/NOP for subsequent chars.

This entry point is used by the routine at 7D57.

Control code $16 switches mode to 7D48 (set cursor row); else return.

Sets print cursor row from A (row*256 + shadow screen base).

Sets print cursor column from A, then switches back to default char-printing mode.

Prints the string at (HL) to the shadow screen until terminator $5E; handles control codes $16 (set row+col) and $2B (newline, +8 rows).

Looks up the A5DC record for sprite L (L*4 -- see A5DC), takes its data address (record[0..1]) and masked height (record[2]&$7F, in 8px rows) and width (record[3]&$7F, in 8px columns, toggling record[3] bit 7 in place each call so alternating calls flip between drawing the normal and mirrored image). For each of height*8 pixel rows, copies ceil(width/2) bytes from the front of the row to the back (and vice versa via HL/DE working inward from both ends), bit-reversing each byte with the RLA/RR chain at 7E83 -- the standard trick for mirroring a monochrome bitmap left-to-right. Used to derive a sprite's mirror-image facing from a single stored copy.

Dispatches on the device selector $617B: keyboard (scans 6 half-rows into $6186's bits, some duplicated -- e.g. both $617D and $6184 set bit 4/fire), Kempston (port $001F, used as the mask directly), Sinclair (port $EFFE, bit-rotated into the mask), or Cursor keys (ports $EFFE/$F7FE). Result is masked against the previous frame's value at $6188 and stored to $6186; also accumulates a held-key counter at $617C. See 6186 for the bit layout.

This entry point is used by the routine at 8128.

This entry point is used by the routine at 82DB.

This entry point is used by the routine at 82A6.

This entry point is used by the routine at 82DB.

This entry point is used by the routine at 8230.

This entry point is used by the routine at 8128.

Allocates one entry from a free-list of object records (creatures, bubble sources, snakes, whirlpools, plugs -- anything not baked into the static room grid; see 612C). Every caller has 2 embedded bytes immediately after its CALL instruction, holding the little-endian address of that call site's per-object behaviour handler (marked with a W-line at each site, e.g. 666C). On the early-exit path ($618C is 0): pops the return address and skips exactly those 2 bytes (INC HL twice, then JP (HL)) -- no object is allocated, and the handler address is discarded unread. On the success path: pops the SAME return address into HL, then LDIs those same 2 bytes as literal data into the new record's offset $03/$04 (the handler-pointer field), pushes the now-advanced HL (pointing just past the 2 bytes) back onto the stack, copies a fixed 19-byte block from $5C92 (ZX system-variable area, reused as a default object state template) into the rest of the record, then RETs -- popping that pushed address, so execution resumes 2 bytes past the CALL either way. The 2 bytes are never executed as code on either path. Allocation + list insertion: pops the next free record off the free-list head at $618B (each free record's first 2 bytes point to the next free record; the free list can extend outside the A900 pool, e.g. into scratch at $5B00). Then head-inserts the new record into the active object list at the insertion point given by IX: copies the old head word from (IX+0/1) into the new record's +0/+1 link field, then writes the new record's address back to (IX+0/1). IX is usually 610E (the global list head), but can be any record's own link field (e.g. $8DEF for creatures -- see 6663), which splices the object into the middle of the list instead. Switches IX to the new record's address, stores the current room number ($6126) at record offset $02. Sets a flag bit (A=1) and returns with IX = the new record's address. Object pool starts at A900.

Looks up the A5DC record for sprite L (L*4), then copies all 4 raw bytes (data address, height, and width -- the width byte copied unmasked, flip-flop bit 7 and all) into 618D/618F/6190. Called by 8128 before it draws a sprite by number.

Loops over bytes at HL, printing each one via 7CEC (the print engine, which also interprets embedded control codes like $14/$16 seen at 8623/861A), until it reads a terminator byte ($5E or $2B) -- returns with HL pointing just past the terminator. Called directly with HL already pointing at a string (e.g. from 8513), and via 850E for inline strings embedded right after a CALL.

Pops the return address off the stack into HL -- since the caller used CALL $850E, this is the address of the string bytes immediately following that CALL. Calls 8501 to print the string (advancing HL past it), then JP (HL) to resume execution right after the embedded string, i.e. normal code flow continues past the inline text.

4 bytes, one per starting location, in order A/B/C/D: $52 (level 3, row 1, col 4), $C0 (level 6, row 2, col 0), $1A (level 1, row 4, col 2), $84 (level 4, row 4, col 0). See x-docs/Room-Format.md for the full cube-position table and cross-check against an external game map.

"1 KEYBOARD 2 KEMPSTON 3 SINCLAIR 4 CURSOR", printed by 8617 via the 7CEC print engine.

End-game stats overlay labels (see 676D: called only when room==1)

End-game message, shown on an early/partial completion outcome

End-game message, shown on full completion (all 4 plugs pulled)

Whether the $5C92 fallback is a genuine "reset score" or coincidentally reuses the same default-state bytes seen elsewhere (see A900) is unconfirmed.

Input-mask -> direction-code priority table, scanned by 8968: (mask,direction) byte pairs, tried in order, first whose mask bits overlap ($6186's mask OR $80) wins. $08,$01 (Up bit -> direction $01); $04,$02 (Down bit -> $02); $02,$06 (Left bit -> $06); $01,$04 (Right bit -> $04); $80,$00 (default/no-input catch-all -- mask bit 7 always matches since 8968 ORs $80 into the scan key -- resolves to direction $00, i.e. no movement).

This is the handler address held in the player object record's +3/+4 field ($8DB9 -- see 8DB6), called every frame from 983C's dispatcher like any other object handler. Explains its many special cases: room $01 check (ending room), the vertical room transitions (8A87), etc. The player's handler pointer is swappable for state changes: 955A tests ($8DB9)==$8968 ("normal state?"), 9564 swaps in 8D11.

MOVEMENT: reads the input mask at 6186 (OR $80, a wildcard sentinel), then scans the (mask,direction) pair table at 88F0 for the first entry whose mask overlaps -- this resolves the raw multi-button input into a single prioritized direction code (0/1=Up, 2/3=Down, 4/5=Right, 6/7=Left; the low bit distinguishes sub-states, masked off by 8ABB's AND $0E). If the resolved direction equals the player's current facing ((IX+$0B)), calls 8AD9 immediately to take a step; if it differs and is nonzero, just updates the pending-direction latch at $8DC1 (turning takes one frame before the first step); if it resolves to 0 (no input), no movement happens this frame.

This entry point is used by the routine at 8D11.

Computes the room number one level down ($6126 - $24, i.e. -36 -- a whirlpool) or one level up ($6126 + $24, i.e. +36 -- a bubble), the 6x6x6 cube level-stride (see x-docs/Room-Format.md). Has special-case handling when the current room number is exactly 1 (down) or 2 (up) -- overrides the computed value instead of using the generic +-36 arithmetic; not yet understood why. The upward case also bounds-checks the result against $D9 before allowing it (JP C,97FC), falling back to a different path (through $8C83) if out of range. 97FC is called with the new room number to actually perform the transition, same as the horizontal case (67F1).

Looks up (IX+$0B) AND $0E in the delta table at 8AB3 and adds it to the object's position (+5/+6) in place. Screen deltas are +-2px along one axis per direction (Up/Down move dx, Right/Left move dy) -- the isometric-diamond room layout means each cardinal game direction is a diagonal-looking step on screen along a single axis. Used by 8AD9 (player movement) and 9923.

This entry point is used by the routine at 9923.

CALLs 8ABB to move (IX+5/+6) by the facing delta (old position saved in BC), then 67F1 (door/room-transition check) and 9BF0 (grid + object collision check). If 9BF0 reports no collision (NC), the new position is kept as-is. If it reports a collision (C): if also Z, pokes $FF into offset +9 of the colliding object's record (DE, from 9BF0/9ABC) -- disables it; either way, the position is then reverted to the saved BC (blocked), and the animation countdown (+0x0E) is reset.

Gated on the fire/pick-up key (bit 4 of 6186); if a weapon is currently held ($619E), jumps to 8D8D (attack) instead. Otherwise plays a "reach out" animation, then continues at $8B2B: if the held-item pointer 6110 currently equals the fixed "empty hands" sentinel record at $788A (i.e. nothing held), attempts to PICK UP something nearby; otherwise DROPS the currently-held item.

PICK UP ($8B2B, nothing currently held): walks nearby objects via 9B5D (proximity/collision helper, same one used by movement collision), skipping any whose kind byte (offset +8 from the found record) is $44 (the shared "vulnerable creature" pose -- not pickupable). For the first valid candidate: if its kind is $6E, calls 6622 (unidentified -- likely a special pickup, e.g. a key or weapon-specific item); if its kind is $36, treats it as a GNOME -- calls 888E, increments the "Gnomes Gnabbed" counter at $6122 (BCD), then plays sound effect $04 and finalizes via 9A60 (the gnome object is consumed). For any other kind, searches a weapon lookup buffer at $7C83 (via 88E3) -- if found, sets the Weapon-held flag $619E (and possibly a variant at $619F depending on a $3C check) instead of picking the object straight up; either way, the found record's pointer is stored into 6110 (now "held") and 6895 is called (equip/HUD update?), then sound effect $04 plays.

DROP ($8BC4, something currently held): writes the CURRENT ROOM into the held item's table record (byte0), restoring it to the world -- the same field that item-table entries have their room zeroed on pickup (see Room-Format.md). Re-derives the item's stored Y/X (record bytes 1/2) from the player's own position ($8DBB/$8DBC, grid-aligned) -- i.e. the item is dropped at the player's feet. Exact bit-packing of the combined Y/X byte not fully resolved.

This entry point is used by the routine at 8AFB.

Calls 9923 (spawns the weapon projectile); if it returns Carry (meaning not fully confirmed -- possibly "could not spawn"), jumps to 8C35 (hit-response/reward text) directly. Otherwise calls 68C1 (consume ammo, auto-drop if empty), plays a firing animation via the $8956 table, then restores the normal player handler 8968. The actual hit detection happens later, asynchronously, in the projectile's own per-frame handler (9963).

The player is an object record with the same layout as the dynamic pool records (see A900), statically allocated here. Fields: +0/+1 = $8DCF (link to the next record in the active object list); +2 = current room number (mirrors $6126); +3/+4 = $8968 -- the player's per-frame behaviour handler (8968), SWAPPABLE: 955A tests it against $8968 ("is the player in the normal state?") and 9564 swaps it to 8D11 (an alternate player state); +5/+6 = player Y/X position -- these are the $8DBB/$8DBC bytes referenced by proximity checks all over the code; +16..+19 = previous/target position pair (unconfirmed). The active object list runs: ($610E head) -> newest spawned objects ... -> $8DB6 (player) -> $8DCF -> $8DEF -> $0000 end.

Second fixed object record (purpose not yet identified). Link points to $8DEF. Its state block (+2 onward, at $8DD1) is re-initialized with 22 bytes from $5C92 by 8F82 during room setup.

Third fixed object record -- also the CREATURE insertion point: 6663 passes IX=$8DEF into 84AE, so the room's creature gets spliced into the list right after this record. Link field is $0000 (list end) when the room has no creature. State block (+2 onward, at $8DF1) re-initialized from $5C92 by 8F82.

Same allocator mechanism as 8EA7; its handler is 9684 (see there for the full state machine).

This entry point is used by the routine at 8E3F.

Called from 62C8 with A=the special value ($66 or $6A) and HL pointing just past it in the template/extras stream. Self-modifies its own 8EC3 operand with A (so the spawned object's initial "kind" byte matches whichever of $66/$6A triggered it). Clears the grid cell to 0 (so the special value never appears in the finished grid -- see 612C). Reads 2 more bytes from the template beyond the normal (index,value) pair -- these are NOT accounted for by the outer 62C8 loop's own HL advancement; instead the routine forces two extra DEC B's (at $8EE8/$8EE9), ending that loop one iteration early to compensate (see 6CCF). Sets up IX=$610E (the active-object list head) as the insertion point, then CALLs 84AE to allocate an object record -- its handler address (8EB9) is 957C. Populates further record fields (offset $07=$18, $0A=$06, $09=triggering value, $0B and $0E=first extra byte, $14=second extra byte), then CALLs 9A60 to finalize. The two extra bytes' exact meaning (screen position? direction?) is not yet confirmed. Offset $09 (the triggering value) reads back as $00 afterward, suggesting it's consumed during finalization.

Same allocator mechanism as 8EA7; its handler is 94EE.

$67 is rare: only 2 occurrences in the whole room table (rooms $9C and $A3).

This entry point is used by the routines at 8F1E and 8F4C.

This entry point is used by the routine at 8F4C.

Every Plug Room's extras end with $25,$6B,$25,$69 -- a Plug and a $69 object co-located at the same grid cell -- and $69 also appears 23x across the room table (not plug-exclusive, unlike $6B). Same allocator mechanism as 8EA7; its handler is 952D.

$6B appears in exactly 4 rooms' extras in the whole room table, and they are precisely the 4 Plug Rooms (73B3) -- never in any of the 11 shared room-type templates, only introduced per-room. Same allocator mechanism as 8EA7; its handler is 94F4.

This entry point is used by the routines at 9085 and 9232.

This entry point is used by the routine at 9208.

This entry point is used by the routines at 9021 and 90A8.

PLUG ROOM BRANCH (taken when 62F9 confirms the current room is this level's Plug Room): compares this object's own sprite number (+0x08) against each of the 4 required item sprites in the level's 7287 table (bytes 2-5), gated by the corresponding undelivered bit in the level's state nibble (byte1, CPL'd so unset/undelivered bits read as 1). On a match: sets that delivery bit in the state byte, repositions itself at the matching corner-cube grid cell (6254), increments the "Goodies Gathered" counter at $6123 (BCD), plays sound effect $01, runs a short animation via the 919A table, then re-pokes the grid cell to the "delivered" marker $13 and self-destructs ((IX+$02)=$FF). This strongly implies the object's sprite (+0x08) is set elsewhere to track whichever item the player is currently carrying/delivering -- that link is not yet found. If the state nibble is already fully clear (all delivered), falls through to the normal branch below.

NORMAL-ROOM BRANCH (93C1): settle/float physics -- the height/Z field (+0x07) decays by 4 each frame toward a rest value $18 (clamped), tested each step via 9BF0 (collision); if blocked, the height is bounced back up by 4 instead. Also checks bit 2 of (IX+$0D) (a "just hit by a weapon" flag set elsewhere, not yet traced) and calls 9401 if set.

This entry point is used by the routine at 9401.

CONFIRMED structure (trigger not yet traced): clears the hit flag, then only proceeds if the creature's current sprite (+0x08) is $44 (a shared "vulnerable" pose -- creatures presumably must be in this pose to register a hit). Searches a (room, position, reward-sprite) triple table at $7C89 (count from $7C97) for an entry matching the current room and this object's position field (+0x09); on a match, swaps the reward sprite into +0x09 and into offset +3 of a linked record (via +0x0E/+0x0F), plays sound effect $01 (the same "success" sound as item delivery), steps through the 919A animation table to transform the sprite, then finalizes (+0x08 = reward sprite, 9AAB kind lookup into +0x0A, 9A60) and resumes normal behaviour at 93C1. Likely how a creature is "defeated" and turns into a collectible (a Gnome?).

Sprites $4E,$4E,$50,$50 (see A714/A71C, both labeled "Plant/coral"), terminated by $FF -- a simple 2-frame swaying decoration.

Its 99D5 animation table (94E9) is sprites $4E,$4E,$50,$50, both "Plant/coral" sprites -- a simple 2-frame swaying decoration.

CONFIRMED: re-checks (every frame, via 62F9 + AND $0F/CP $0F) whether this level's Plug Room state nibble has reached $0F (all 4 items delivered -- see 9341). Once it has: increments the "Plugs Pulled" counter at $6124 (BCD), plays sound effect $09, and animates the plug popping out (+0x07 += 8 per frame, gated by bit 4 of +0x0D so this only fires once), then self-destructs on the following frame (bit 6 of +0x0D check). This is the actual win-condition trigger for a single Plug Room.

Its 99D5 animation table (9526) is sprites $4C,$4C,$4D,$4D, both "Whirlpool, animation phase" sprites.

Sprites $68,$68,$69,$69 (see C38E/C39E, both relabeled "Bubble"), terminated by $FF.

Its 99D5 animation table (9577) is sprites $68,$68,$69,$69, the 16x8 bubble sprites at C38E/C39E.

At $9622-$962D, branches on the inherited trigger value at (IX+$0B) -- only if it's $6A does it SET bit 4 of (IX+$0D) and switch to movement table $95E2 (steps +0x07 by $04/frame) instead of the default 95C9 (steps by $02/frame): the $6A bubble rises at double the rate. That bit 4 flag is later tested at 97E6 (in the sprite-draw wrapper, right after 8128 draws it); only if set does it SET bit 6 of (IX+$0D). Back here at $961B, bit 6 being set causes immediate self-destruct ((IX+$02)=$FF). So only $6A-triggered bubbles can ever reach that clean completion state -- $66 bubbles never do: a full-strength bubble stream that completes its rise ($6A) vs. a weak one that never does ($66), matching gameplay where some bubble sources cannot lift the player all the way. Whether bit 6 specifically means "reached the surface" is unconfirmed.

Handler for 8E3F's objects (its handler-address bytes at 8E50 -- see 84AE), called from 983C's dispatcher.

Sprite starts at $23 (set by 8EA1 on spawn) and cycles through $23,$24,$25,$26 -- the "Snake, rearing phase" sprites at B56E/B57E/B59E/B5CE, with increasing sprite height (16x8 -> 16x16 -> 16x24 -> 16x32) as it rises, i.e. more of the snake's body becomes visible each frame. Full cycle: phase 0 = idle countdown at (IX+$0E) (decrements while nonzero); phase 1 = seed position (IX+$16)/(IX+$17) at $FC/$FE then jump +8; phase 2 = each call, INC sprite number (IX+$08) and jump position +8 again, repeating until sprite reaches $26 (fully reared), then sets a long countdown ($24) and advances to phase 3+; phase 3+ (default case) = each call, if sprite isn't back down to $23 yet, DEC sprite and retract position by -8; once back at $23, reset position to 0, set bit 7 of (IX+$0D) (purpose not traced), set another countdown, and restart the cycle at phase 1. A full rise-pause-retract-pause loop.

For each object record (IX) in the list (record +0/+1 links to the next; the list includes the pool records at A900, the PLAYER record at 8DB6, and the room's creature), checks if its room number (offset $02) matches the current room ($6126); if so, loads a function pointer from offset $03/$04 and CALLs 61A7 (a JP (HL) trampoline) to invoke the object's own per-frame behaviour handler (e.g. 9684 for a snake, 8968 for the player). Also checks bit 7 of offset $0D and computes into offset $0C from offsets $10/$11 -- purpose not yet confirmed.

Plays sound effect $08, allocates an object at the active list head, sets its sprite to the weapon's own sprite (A), position from the player, kind $0D, and facing from $8DC1, then calls 9A60 to finalize.

Applies the facing delta twice via 8ABE (see 8ABB), testing collision (9BF0) after each step -- a fast-moving shot. On collision with terrain (no target object, DE unset): just stops. On collision with another object (DE = that object's record): SETS bit 2 of its (+0x0D) -- the "just hit" flag consumed by 9341/9401 -- and writes the projectile's own sprite (masked to 7 bits) into that object's offset +9, presumably so 9401's reward lookup can identify which weapon scored the hit. Animates briefly via the 995E table, then self-destructs.

HL = (IX+$1D)/(IX+$1E), a pointer to a table of 4 sub-table addresses. Selects one by facing direction ((IX+$0B), mapped 1->0/2->1/... via a small comparison chain, then AND $03), loads that sub-table's address, and falls into 99D5's shared byte-code interpreter ($FD/$FC/$FE/$FB position-delta markers, otherwise a sprite number) -- this is how the player's (and other directional objects') walk-cycle animation is driven per-facing.

This entry point is used by the routines at 8968, 8AFB, 8D8D and 9471.

Called with HL = a small table of raw sprite numbers (see 9526/9577/94E9 for examples). Indexes the table by (IX+$0F) (a per-object phase counter), reads the byte there into A, then INCs (IX+$0F) for next time. $FF in the table means "wrap to start" (resets (IX+$0F) to 0 and re-reads from the table's first byte); $FD is a second special marker (purpose not yet traced past 9A01). Otherwise A is the next sprite number to display for this object -- this is how 957C/952D/94EE (and others) drive their objects' animation frames.

This entry point is used by the routine at 99A1.

Role still open: the handler-address write into record +3/+4 and the list insertion both happen inside 84AE, so neither is this routine's job. Observed effect: record offset $09 (the triggering grid value) reads back as $00 after this call. Internals not yet traced.

Converts screen coordinates (B=X,C=Y) to a room-grid cell: (Y AND $F8)>>3 * 8 + (X AND $F8)>>3 -- confirms the 612C grid's row*8+col indexing operates on 8px-aligned screen tiles. Reads the grid cell; $00 = passable (no collision). $7F = solid wall, hard block (see 9B56). Any other nonzero code is looked up in a per-terrain-code shape/behaviour table at $7556 (the same table 8E6E reads) -- individual terrain codes may have different collision shapes rather than being uniformly solid.

This entry point is used by the routine at 9ABC.

This entry point is used by the routines at 8AFB, 9602, 9684 and 9BD4.

This entry point is used by the routine at 9B5A.

Tests all 4 corners of the object's bounding box (screen-coordinate pairs at +0x10/+0x11, +0x10/+0x13, +0x12/+0x13, +0x12/+0x11 -- i.e. (left,top)/(left,bottom)/(right,bottom)/(right,top)) via 9ABC, returning early (C) if any corner hits solid terrain. If all 4 corners are clear, finishes with 9B5A (object-vs-object overlap scan). Also calls 9A60 first and returns early if it reports collision (purpose of that specific pre-check not fully traced).

Copy shadow screen to ZX screen

Record format (read by 84ED/7E4F with the sprite number in L): record[0..1] = sprite data address (LE word); record[2] = height in 8px rows, top bit masked off before use ($7F) -- meaning of that bit not yet confirmed, may just be unused/reserved; record[3] = width in 8px columns, but bit 7 here is a live flip-flop flag: 7E4F XORs it in place (self-modifying table entry) on every call, toggling it between the two calls needed to draw a sprite's normal and mirrored/second-buffer image, then masks it off ($7F) to get the actual width.

Records allocated/freed via a linked list managed by 84AE (free-list head at $618B; the free list can extend outside this pool, e.g. into scratch at $5B00). Record layout (24 bytes, offsets from record start): +0/+1 = link to the next object record in the active object list (head at 610E; the list ends via the fixed records at 8DB6 -- the player record uses this same layout); +2 = room number the object belongs to; +3/+4 = per-object behaviour-handler function pointer, copied by 84AE from the 2 bytes embedded after the spawner's CALL; +5/+6 = Y/X position; +8 = current sprite number; +5..+23 initially a fixed 19-byte default state block copied from $5C92; +7=$18 and +0xA=$06 (constants set by 8EA7-style spawn routines); +9 = triggering grid value (e.g. $66), cleared to 0 by 9A60; +0xB and +0xE = a duplicated "extra" byte from the template; +0xF = animation phase counter (used by 99D5); +0x14 = a second "extra" byte. The exact meaning of the two "extra" bytes (position? direction?) is not yet confirmed.

Sets up the melody-table pointers ($FBAB=$FC99, $FBAF=$FE33), then loops: disable interrupts, play one note via FBD7 (which reads/advances through the melody-index table and produces the tone), scan the keyboard via the ROM KEY-SCAN routine at $028E, and repeat until a key is pressed; then re-enable interrupts and return.

Reads the next byte of the melody-index table (via the pointer at (HL)), advances the pointer, and returns it in A. If the byte is $40 (end-of-tune marker), jumps to FBCF to reload the pointer from a loop-restart address instead.

This entry point is used by the routine at FBCF.

Converts a melody-index byte (from FBB4, at (HL)) into an actual tone period by adding $0C and indexing into the period table at FC64; returns the period in H, with L fixed at $01. E.g. index $29 (+$0C=$35) -> FC64+$35 = $FC99 = $01.

Calls FBB4 twice (storing results at $FBA8/$FBA9), then FBC1 twice to check them; if neither matches, falls into the tone-generator loop at $FC04, continuing through $FC15/$FC17/$FC25 into FC34, which toggles the speaker/border via OUT ($FE),A (bit 4 = speaker) in a tight DJNZ-timed square-wave loop -- this is the music heard while the menu waits for input. If both checks match, jumps to the plain delay loop at FC46 instead.

This entry point is used by the routine at FC34.

Literal ASCII "adam" embedded as data/padding between code paths; possibly a programmer's signature.

Toggles the speaker bit via OUT ($FE),A, timed by DJNZ.

This entry point is used by the routine at FBD7.

Decrements a counter via $FBB3, with no OUT ($FE) calls.

54 bytes: 53 descending values (= ascending pitch), indexed by FBC1 as (melody-index byte + $0C), plus a trailing byte at $FC99 that is never actually read as a melody index (see FC9A).

Each byte, +$0C then indexed into FC64, gives the tone period for one note. Terminated by $40. FBB4 stores the pointer as $FC99 but always increments before reading, so the first byte actually consumed is here at $FC9A ($29); +$0C=$35, and FC64+$35=$FC99=$01. This table also happens to be reachable as code via FBF1 (JP C,$FC9A -- 12x ADD HL,HL, a rarely/never-taken branch that reuses these bytes as opcodes; not its primary purpose).


60C2	DEFB $58,$27,$20,$FB,$6C,$F8,$2B,$2D
60CA	DEFB $65,$33,$FF,$FF,$ED,$10,$0D,$00
60D2	DEFB $09,$00,$85,$1C,$10,$1C,$52,$1B
60DA	DEFB $76,$1B,$03,$13,$00,$3E,$C3,$3C
60E2	DEFB $9D,$E0,$60,$18,$3E,$23,$5E
60E9	DEFW $5D42	Saved SP
60EB	DEFB $05	Draw-queue length (number of object-record pointers at $60EC; see 9900)
60EC	DEFW $8E0F,$A900,$8DB6,$8E27	Draw queue: object-record pointers, drawn by 9900
60F4	DEFW $A918	Draw queue: object-record pointers, drawn by 9900
60F6	DEFB $00,$00,$00,$00,$00,$00,$00,$00
60FE	DEFB $00,$00,$00,$00,$00,$00,$00,$00
6106	DEFB $00,$00,$00,$00
610A	DEFW $70E0
610C	DEFW $8FEF
610E	DEFW $A918	Active object list HEAD pointer: points at the most recently spawned object record; each record's +0/+1 links to the next, ending in the fixed records 8DB6 (player) -> $8DCF -> $8DEF -> $0000. Passed as IX into 84AE, which head-inserts the new object here. Other insertion points exist (e.g. $8DEF for creatures -- see 6663), placing objects later in the list.
6110	DEFW $788A	Currently-held item: pointer to its 4-byte item-table record (room,Y,X,sprite). Equals the fixed "empty hands" sentinel record at $788A when nothing is held. Set by 8AFB on pickup; the pointed-to record's room byte is zeroed on pickup and restored (to the current room, at the player's position) on drop.
6112	DEFB $00,$00,$00,$00,$00,$00,$00,$04
611A	DEFB $05
611B	DEFB $00,$00,$00,$00,$00	SCORE (5-digit BCD, most-significant byte first). Added to by 8879, subtracted by 8894, displayed (last 4 digits) by 885A via 8523.
6120	DEFB $00,$00
6122	DEFB $00	"Gnomes Gnabbed" end-game stat counter (BCD), printed by 86CC via 854F
6123	DEFB $00	"Goodies Gathered" end-game stat counter (BCD), printed by 86CC via 854F; incremented by 9341 on each successful item delivery to a Plug Room corner cube
6124	DEFB $00	"Plugs Pulled" end-game stat counter (BCD), printed by 86CC via 854F
6125	DEFB $00	Entry-point room number choosen selecting A/B/C/D in menu, see table 8567
6126	DEFB $02	Room number
6127	DEFW $6CD6	Room description address
6129	DEFB $00	Room shape/layout selector (0 or 1; bit 6 from byte 3 of Room description, shifted to bit 0). Selects one of 2 fixed wall/decoration layouts drawn by 642F.
612A	DEFB $0E	Bits 4-7 from byte 2 of Room description, shifted to bits 0-3
612B	DEFB $00	Room exit/door bitfield (from room description byte1; see 6329). Also reused throughout the code as a numeric base address for room-grid cell addressing ($612B+index, grid starting at $612C) -- these are two unrelated uses of the same address, not a conflict.
8x8 grid (row-major, offset = row*8+col), cleared to 0 then populated by 62A2 from a shared room-type template (72D1 family, selected by $612A via the 72B1 pointer table), plus any per-room extra pairs from the room description itself (see 6CCF). Each entry's grid cell address is $612B+index (i.e. grid_offset = index-1); the stored value is either a plain content code (see table below), or one of $66/$67/$68/$69/$6A/$6B which additionally triggers a dedicated object-spawn routine (8EA7/8EF2/8F1E/8F4C/8E3F) -- these special values do NOT persist in the finished grid; they spawn a dynamic object instead (see 84AE) and the grid cell they occupied stays part of the static terrain layout only incidentally. Static object codes: $01=small seaweed, $02=flat rock, $03=clam shell (no pearl), $04=small rock, $09=rock, $0D=seaweed, $7F=solid wall (seen as a contiguous 3x3 corner block), $0A-$10=display cubes/cases with varying item glyphs (seen in Plug Rooms). Creatures, pickups (spoon/ball/horseshoe/etc), and air-bubble sources are NEVER on the grid -- they're separate dynamic objects (see 84AE), not static terrain.
612C	DEFB $00,$00,$00,$00,$00,$00,$00,$00	Room grid 8x8
6134	DEFB $00,$00,$00,$00,$00,$00,$00,$00
613C	DEFB $00,$00,$00,$00,$00,$01,$00,$00
6144	DEFB $00,$00,$00,$00,$00,$00,$00,$01
614C	DEFB $00,$02,$00,$00,$00,$01,$00,$00
6154	DEFB $00,$00,$00,$00,$02,$00,$00,$00
615C	DEFB $00,$04,$04,$00,$00,$00,$00,$00
6164	DEFB $00,$00,$00,$00,$00,$00,$00,$00
616C	DEFB $00,$00,$00,$00,$00,$00,$00,$00
6174	DEFB $00
6175	DEFB $43	Room color 0..15
6176	DEFB $40,$40,$40
6179	DEFB $00
617A	DEFB $00
617B	DEFB $00	Input device selector, read by 7EBE: 0=keyboard, 1=Kempston joystick, 2=Sinclair joystick, else=Cursor keys
617C	DEFB $00	Cumulative input-held counter, incremented each frame by 6186's mask value (used for key-repeat timing)
617D	DEFB $BF	Keyboard row snapshot (contributes bit 4 -- fire/pick-up -- to 6186 via 7EBE)
617E	DEFB $BF	Keyboard row snapshot (contributes bit 2 to 6186 via 7EBE)
617F	DEFB $BF	Keyboard row snapshot (contributes bit 1 to 6186 via 7EBE)
6180	DEFB $BF,$BF
6182	DEFB $BF	Keyboard row snapshot (contributes bit 3 to 6186 via 7EBE)
6183	DEFB $BF	Keyboard row snapshot (contributes bit 0 to 6186 via 7EBE)
6184	DEFB $BF	Keyboard row snapshot (also contributes bit 4 -- fire/pick-up -- to 6186 via 7EBE)
6185	DEFB $00
Resolved 5-bit input mask, produced every frame by 7EBE from whichever control method $617B selects. Bit0=Right, bit1=Left, bit2=Down, bit3=Up (Kempston-port convention: reading Kempston directly copies its byte here unmodified), bit4=Fire/pick-up. Consumed by 8968 (movement -- resolved to a single direction via the table at 88F0) and 8AFB (fire button). Masked against a "previously pressed" copy at $6188 by 7EBE itself (edge-detection), and accumulated into a repeat counter at $617C.
6186	DEFB $00	Resolved input mask (bit0=Right, bit1=Left, bit2=Down, bit3=Up, bit4=Fire/pick-up) -- see N-line
6187	DEFB $00
6188	DEFB $FF	Previous frame's 6186 value, used by 7EBE for key-repeat/edge detection
6189	DEFB $01
618A	DEFB $00	Message-window restore timer (counts down in 9808; the room/creature title is redrawn when it expires)
618B	DEFW $A930	Free-list head pointer for the dynamic object pool (A900), consumed/updated by 84AE. Its high byte (at $618C) is also read standalone as an empty/enabled check.
618D	DEFW $BDAE	Current sprite: data address (copied from a A5DC record by 84ED)
618F	DEFB $10	Current sprite: height, in 8px rows (copied from a A5DC record by 84ED)
6190	DEFB $04,$00,$00	Current sprite: width, in 8px columns, bit 7 = flip-flop flag (copied from a A5DC record by 84ED, unmasked)
6193	DEFB $FF
6194	DEFW $0000
6196	DEFW $FFB9
6198	DEFB $42	Oil cans remaining (BCD), decremented by 6622 on pickup/use
6199	DEFB $00	Flag, set to 1 by 6622 (oil can used) -- purpose of the flag itself not confirmed
619A	DEFB $1C	Room number copy
619B	DEFW $1C34
619D	DEFB $04
619E	DEFB $00	Weapon ammo count (BCD-ish, decremented by 68C1 per shot), also acts as the weapon-held flag: tested by 8AFB on fire/pick-up to decide attack vs. pick-up/drop; hitting 0 auto-drops the weapon
619F	DEFB $00
61A0	DEFB $01
61A1	DEFB $00
61A2	DEFB $7F
61A3	DEFB $04
61A4	DEFB $3A,$5C
61A6	DEFB $00

Used by the routine at 61C1.
61A8	PUSH DE
61A9	DEC B
61AA	LD HL,$0018
61AD	ADD HL,DE
61AE	EX DE,HL
61AF	LD (HL),E
61B0	INC HL
61B1	LD (HL),D
61B2	DJNZ $61AA
61B4	EX DE,HL
61B5	LD DE,($618B)
61B9	LD (HL),E
61BA	INC HL
61BB	LD (HL),D
61BC	POP HL
61BD	LD ($618B),HL
61C0	RET

Used by the routine at 676D.
61C1	LD HL,$0000
61C4	LD ($9D3C),HL
61C7	LD ($8DEF),HL
61CA	LD ($618B),HL
61CD	LD HL,$8DB6
61D0	LD ($610E),HL	set Active object list HEAD pointer
61D3	LD DE,$5B00
61D6	LD B,$08
61D8	CALL $61A8	Initialize the object free list
61DB	LD DE,$A900
61DE	LD B,$08
61E0	JP $61A8

Used by the routine at 6B05.
61E3	XOR A
61E4	LD ($6502),A
61E7	LD ($6199),A
61EA	LD A,$42
61EC	LD ($6198),A
61EF	LD DE,$788A
61F2	LD A,($7C82)
61F5	PUSH AF
61F6	LD HL,$0004
61F9	ADD HL,DE
61FA	LD BC,$0004
61FD	LDIR
61FF	EX DE,HL
6200	POP AF
6201	DEC A
6202	JR NZ,$61F5
6204	LD DE,$75B6
6207	LD A,(DE)
6208	CP $01
620A	JR Z,$6219
620C	LD HL,$0001
620F	ADD HL,DE
6210	LD (HL),$01
6212	LD L,A
6213	LD H,$00
6215	ADD HL,DE
6216	EX DE,HL
6217	JR $6207
6219	LD HL,$5C92
621C	LD DE,$611B
621F	LD BC,$000A
6222	LDIR
6224	LD DE,$6CCF	Room descriptions start address
6227	LD HL,$0001
622A	ADD HL,DE
622B	LD A,(HL)
622C	RRCA
622D	RRCA
622E	RRCA
622F	RRCA
6230	CPL
6231	OR $F6
6233	AND (HL)
6234	LD (HL),A
6235	INC HL
6236	INC HL
6237	RES 7,(HL)
6239	LD A,(DE)
623A	LD L,A
623B	LD H,$00
623D	ADD HL,DE
623E	EX DE,HL
623F	LD A,(DE)
6240	CP $01
6242	JR NZ,$6227
6244	LD HL,$7288
6247	LD A,($72AB)
624A	LD B,A
624B	LD DE,$0006
624E	LD (HL),$00
6250	ADD HL,DE
6251	DJNZ $624E
6253	RET

Used by the routines at 6663, 6B05, 8E3F, 8EA7, 8EF2, 8F1E and 9341.
6254	DEC A
6255	PUSH AF
6256	AND $F8
6258	OR $04
625A	LD (IX+$05),A
625D	POP AF
625E	AND $07
6260	RLCA
6261	RLCA
6262	RLCA
6263	OR $04
6265	LD (IX+$06),A
6268	RET

Used by the routine at 983C.
Used by 983C to call a dynamic object's per-frame behaviour handler
61A7	JP (HL)

Used by the routine at 676D.
6269	LD ($6126),A	set room number
626C	LD B,A
626D	LD HL,$6CCF	Room descriptions start address
6270	LD DE,$0000
6273	JR $6277
6275	LD E,(HL)	get offset to the next room description
6276	ADD HL,DE
6277	DJNZ $6275
6279	LD ($6127),HL	Store room description address
627C	INC HL
627D	LD A,(HL)
627E	LD ($612B),A
6281	INC HL
6282	LD A,(HL)
6283	RRCA
6284	RRCA
6285	RRCA
6286	RRCA
6287	AND $0F
6289	LD ($612A),A
628C	INC HL
628D	LD A,(HL)
628E	RLCA
628F	RLCA
6290	AND $01
6292	LD ($6129),A
6295	LD HL,$612C	Clear room grid - 64 bytes at 612C
6298	LD DE,$612D
629B	LD BC,$003F
629E	LD (HL),$00
62A0	LDIR
62A2	LD HL,($612A)	place the room-type template ($612A indexes the 72B1 pointer table) into the grid via 62C8
62A5	LD H,$00
62A7	ADD HL,HL
62A8	LD DE,$72B1
62AB	ADD HL,DE
62AC	LD E,(HL)
62AD	INC HL
62AE	LD D,(HL)
62AF	EX DE,HL
62B0	LD B,(HL)
62B1	DEC B
62B2	JR Z,$62BB
62B4	JP M,$62BB
62B7	INC HL
62B8	CALL $62C8
62BB	LD HL,($6127)	place this room's own extra (index,value) pairs (if its description is longer than 4 bytes) into the grid via 62C8
62BE	LD A,(HL)
62BF	SUB $04
62C1	JR Z,$62F8
62C3	LD DE,$0004
62C6	ADD HL,DE
62C7	LD B,A
62C8	LD E,(HL)	Grid-entry writer. E=(HL)=index, IX=$612B+E=target address, A=(HL+1)=value; stores A at (IX+0), then checks A against $66/$67/$68/$69/$6A/$6B to also trigger a dedicated object-spawn routine. Loops B times (DJNZ), consuming 2 bytes/iteration; a special-value spawn routine can decrement B as a side effect, ending the loop earlier than the byte count alone would suggest (see 8EA7).
62C9	LD D,$00
62CB	LD IX,$612B
62CF	ADD IX,DE
62D1	INC HL
62D2	LD A,(HL)
62D3	LD (IX+$00),A
62D6	CP $66
62D8	CALL Z,$8EA7
62DB	CP $6A
62DD	CALL Z,$8EA7
62E0	CP $67
62E2	CALL Z,$8EF2
62E5	CP $69
62E7	CALL Z,$8F1E
62EA	CP $6B
62EC	CALL Z,$8F4C
62EF	CP $68
62F1	CALL Z,$8E3F
62F4	INC HL
62F5	DEC B
62F6	DJNZ $62C8
62F8	RET

Used by the routines at 630D, 8F1E, 8F4C, 9341, 94F4 and 952D.
62F9	LD A,($6126)	get room number
62FC	LD B,A
62FD	DEC A
62FE	LD HL,$7281
6301	LD DE,$0006
6304	ADD HL,DE
6305	SUB $24
6307	JR NC,$6304
6309	LD A,(HL)
630A	INC HL
630B	CP B
630C	RET

Used by the routine at 676D.
630D	CALL $62F9
6310	RET NZ
6311	LD A,(HL)
6312	LD HL,$72AC
6315	LD BC,$612B
6318	AND $0F
631A	RET Z
631B	RRCA
631C	JR NC,$6326
631E	LD E,(HL)
631F	LD D,$00
6321	EX DE,HL
6322	ADD HL,BC
6323	LD (HL),$13
6325	EX DE,HL
6326	INC HL
6327	JR $6318

Used by the routine at 91A6.
Re-reads room description byte1 (at room_base+1), merges bit4 into bit0 and bit7 into bit3 (via AND $90, RRCA x4, OR), writes the result back into the room description itself AND into $612B. Bits 0-3 of the result are then tested by 6344/6377 to conditionally draw door graphics at fixed screen positions -- one bit per exit direction: bit0=North, bit1=East, bit2=South, bit3=West (see 67F1).
6329	PUSH BC
632A	PUSH DE
632B	PUSH HL
632C	LD HL,($6127)
632F	INC HL
6330	LD A,(HL)
6331	AND $90
6333	RRCA
6334	RRCA
6335	RRCA
6336	RRCA
6337	OR (HL)
6338	CP (HL)
6339	LD (HL),A
633A	LD ($612B),A
633D	CALL NZ,$6344	Draw door graphics for $612B bits 0 and 3
6340	POP HL
6341	POP DE
6342	POP BC
6343	RET

Used by the routines at 6329 and 6377.
Tests bit 0 of $612B (North), drawing one door-graphic piece via 8128 at a fixed screen position if set; then bit 3 (West), drawing a different fixed-position piece if set.
6344	LD BC,$C7C7
6347	LD A,($612B)
634A	BIT 0,A
634C	JR NZ,$6355
634E	LD BC,$BBBB
6351	BIT 4,A
6353	JR Z,$635E
6355	LD A,$83
6357	LD D,$6C
6359	LD E,$B8
635B	CALL $8128	Draw sprite C with its mask at screen position DE
635E	LD BC,$C7C7
6361	LD A,($612B)
6364	BIT 3,A
6366	JR NZ,$636E
6368	LD BC,$BBBB
636B	BIT 7,A
636D	RET Z
636E	LD A,$03
6370	LD D,$6C
6372	LD E,$48
6374	JP $8128

Used by the routine at 676D.
Tests bit 1 of $612B (East), drawing three door-graphic pieces via 8128 (three fixed screen positions) if set; then bit 2 (South), drawing three different fixed-position pieces if set. Calls 6344 first.
6377	CALL $6344
637A	LD A,($612B)
637D	BIT 1,A
637F	JR Z,$63A8
6381	LD A,$02
6383	LD D,$DC
6385	LD E,$C8
6387	LD BC,$BEBE
638A	CALL $8128	Draw sprite C with its mask at screen position DE
638D	LD A,$02
638F	LD D,$D4
6391	LD E,$D8
6393	LD BC,$C1C1
6396	CALL $8128	Draw sprite C with its mask at screen position DE
6399	LD A,$02
639B	LD D,$CC
639D	LD E,$E8
639F	LD BC,$BFBF
63A2	CALL $8128	Draw sprite C with its mask at screen position DE
63A5	LD A,($612B)
63A8	BIT 2,A
63AA	RET Z
63AB	LD A,$02
63AD	LD D,$CC
63AF	LD E,$18
63B1	LD BC,$BCBC
63B4	CALL $8128	Draw sprite C with its mask at screen position DE
63B7	LD A,$02
63B9	LD D,$D4
63BB	LD E,$28
63BD	LD BC,$C0C0
63C0	CALL $8128	Draw sprite C with its mask at screen position DE
63C3	LD A,$02
63C5	LD D,$DC
63C7	LD E,$38
63C9	LD BC,$BDBD
63CC	CALL $8128	Draw sprite C with its mask at screen position DE
63CF	RET

Used by the routine at 676D.
63D0	LD HL,$E390	Shadow screen address
63D3	LD DE,$E391
63D6	LD BC,$17FF
63D9	LD (HL),$00
63DB	LDIR
63DD	RET


63DE	DEFB $E2,$63,$04,$64,$02,$7C,$14,$4C
63E6	DEFB $02,$7E,$40,$4C,$02,$7F,$6C,$4C
63EE	DEFB $02,$7D,$14,$64,$82,$7C,$EC,$4C
63F6	DEFB $82,$7E,$C0,$4C,$82,$7F,$94,$4C
63FE	DEFB $82,$7D,$EC,$64,$FF,$FF,$02,$7C
6406	DEFB $14,$4C,$02,$7E,$40,$4C,$82,$7D
640E	DEFB $6C,$4C,$02,$7D,$14,$64,$82,$7C
6416	DEFB $EC,$4C,$82,$7E,$C0,$4C,$02,$7D
641E	DEFB $94,$4C,$82,$7D,$EC,$64,$FF,$01
6426	DEFB $02,$03,$09,$0A,$0B,$11,$12,$13
642E	DEFB $FF

Used by the routine at 676D.
Uses $6129 (0 or 1) to index a 2-entry pointer table at $63DE, selecting one of two fixed layout lists. Each list has two parts: a sequence of 4-byte records (count, screen Y, screen X -- drawn via 8128) terminated by $FF, immediately followed by a sequence of single bytes (grid indices) terminated by $FF, each poked into the room grid ($612B+index, i.e. grid_offset=index-1) as solid wall ($7F). This is the source of the 3x3 solid-wall corner block seen in every room grid -- it is not part of the room-type template; it is this fixed, $6129-selected layout.
642F	LD A,($6129)
6432	AND $01
6434	ADD A,A
6435	LD L,A
6436	LD H,$00
6438	LD DE,$63DE
643B	ADD HL,DE
643C	LD E,(HL)
643D	INC HL
643E	LD D,(HL)
643F	PUSH DE
6440	POP IX
6442	LD A,(IX+$00)
6445	CP $FF
6447	JR Z,$645D
6449	LD C,(IX+$01)
644C	LD B,C
644D	LD E,(IX+$02)
6450	LD D,(IX+$03)
6453	CALL $8128	Draw sprite C with its mask at screen position DE
6456	LD DE,$0004
6459	ADD IX,DE
645B	JR $6442
645D	INC IX
645F	LD A,(IX+$00)
6462	CP $FF
6464	RET Z
6465	LD C,A
6466	LD B,$00
6468	LD HL,$612B
646B	ADD HL,BC
646C	LD (HL),$7F
646E	JR $645D

Used by the routines at 64F3, 9341 and 9745.
6470	PUSH AF
6471	LD C,A
6472	LD A,B
6473	LD ($649A),A
6476	LD B,$00
6478	LD HL,$612C	Room grid address
647B	ADD HL,BC
647C	LD A,(HL)
647D	CP $7F
647F	JP Z,$64EB
6482	AND $7F
6484	JP Z,$64EB
6487	LD A,C
6488	AND $07
648A	RLA
648B	RLA
648C	RLA
648D	LD D,A
648E	RLA
648F	ADD A,$80
6491	LD E,A
6492	LD A,C
6493	AND $F8
6495	ADD A,D
6496	ADD A,$88
6498	LD D,A
6499	SUB $18
649B	ADD A,$18
649D	JR NC,$64A1
649F	LD A,D
64A0	INC A
64A1	LD ($64CE),A
64A4	LD A,C
64A5	AND $F8
64A7	RLA
64A8	NEG
64AA	ADD A,E
64AB	LD E,A
64AC	LD L,(HL)


64BB	PUSH BC
64BC	PUSH HL
64BD	LD A,(HL)
64BE	CALL $9AAB	Search the (key,data) pair table at $74CE for key A
64C1	LD C,(HL)
64C2	LD B,$00
64C4	LD HL,$750B
64C7	ADD HL,BC
64C8	ADD HL,BC
64C9	ADD HL,BC
64CA	LD C,A
64CB	LD A,D
64CC	SUB (HL)
64CD	CP $D0
64CF	JR NC,$64E5
64D1	LD A,C
64D2	AND A
64D3	LD A,D
64D4	JR Z,$64E4
64D6	INC HL
64D7	LD A,D
64D8	SUB (HL)
64D9	LD D,A
64DA	LD A,$00
64DC	CALL $8128	Draw sprite C with its mask at screen position DE
64DF	JR C,$64ED
64E1	LD A,D
64E2	ADD A,(HL)
64E3	DEC HL
64E4	SUB (HL)
64E5	LD D,A
64E6	POP HL
64E7	POP BC
This entry point is used by the routine at 6470.
64E8	INC HL
64E9	DJNZ $64BB
This entry point is used by the routine at 6470.
64EB	POP AF
64EC	RET

Used by the routine at 676D.
64F3	XOR A
64F4	LD B,$17
64F6	CALL $6470
64F9	INC A
64FA	CP $40
64FC	JR C,$64F4
64FE	RET

Used by the routine at 6B71.
6503	LD A,($617A)
6506	AND A
6507	RET NZ	POKE 201 (RET) here for infinite Oil
6508	LD A,($6126)	get room number
650B	CP $01
650D	RET Z
650E	CP $02
6510	RET Z
6511	LD A,($6199)
6514	AND A
6515	JP NZ,$6580
6518	LD HL,$6501
651B	DEC (HL)
651C	JP P,$6529
651F	INC (HL)
6520	LD HL,$6500
6523	DEC (HL)
6524	RET NZ
6525	LD A,($64FF)
6528	LD (HL),A
6529	LD HL,$6502
652C	INC (HL)
652D	LD A,(HL)
652E	CP $52
6530	JR C,$6543
6532	DEC (HL)
6533	LD HL,$8C48
6536	LD ($8DB9),HL	set player behaviour-handler pointer
6539	LD A,$01
653B	LD ($617A),A
653E	RET


64FF	DEFB $32
6500	DEFB $01	Oil level??
6501	DEFB $00	Rust/oil timer -- reset to 0 (full oil) by 6622 on using an oil can; per the game instructions, rust accumulates on contact with water and is reversed by oil
6502	DEFB $00	Oil level??

Used by the routines at 6503 and 655E.
6543	LD B,A
6544	ADD A,$AD
6546	AND $FC
6548	LD E,A
6549	LD D,$FC
654B	LD A,B
654C	ADD A,$01
654E	AND $03
6550	LD C,A
6551	LD B,$00
6553	LD HL,$653F
6556	ADD HL,BC
6557	LD C,(HL)
6558	LD B,C
6559	LD A,$05
655B	JP $8128

Used by the routines at 6580 and 676D.
655E	LD DE,$FCD4
6561	LD B,$C5
6563	LD C,B
6564	LD A,$03
6566	CALL $8128	Draw sprite C with its mask at screen position DE
6569	LD A,$01
656B	LD HL,$6502
656E	CP (HL)
656F	JR NC,$657A
6571	PUSH AF
6572	CALL $6543
6575	POP AF
6576	ADD A,$03
6578	JR $656B
657A	LD A,(HL)
657B	AND A
657C	RET Z
657D	JP $6543

Used by the routine at 6503.
6580	LD HL,$6502
6583	LD A,(HL)
6584	AND A
6585	JR Z,$658F
6587	DEC (HL)
6588	JP Z,$655E
658B	DEC (HL)
658C	JP $655E
658F	LD ($6199),A
6592	RET

Used by the routine at 676D.
6593	LD DE,$EC2C
6596	LD B,$C8
6598	LD C,B
6599	LD A,$02
659B	CALL $8128	Draw sprite C with its mask at screen position DE
659E	LD DE,$C408
65A1	LD B,$C3
65A3	LD C,B
65A4	LD H,$08
65A6	LD A,$02
65A8	CALL $8128	Draw sprite C with its mask at screen position DE
65AB	LD A,D
65AC	ADD A,$08
65AE	LD D,A
65AF	LD A,E
65B0	ADD A,$10
65B2	LD E,A
65B3	DEC H
65B4	JR NZ,$65A6
65B6	LD DE,$C4F8
65B9	LD B,$C4
65BB	LD C,B
65BC	LD H,$08
65BE	LD A,$02
65C0	CALL $8128	Draw sprite C with its mask at screen position DE
65C3	LD A,D
65C4	ADD A,$08
65C6	LD D,A
65C7	LD A,E
65C8	SUB $10
65CA	LD E,A
65CB	DEC H
65CC	JR NZ,$65BE
65CE	RET


65CF	DEFB $16,$01,$A4,$5E
65D3	DEFB $16,$01,$B4,$5E
65D7	DEFW $7441
65D9	DEFW $0000

Used by the routine at 676D.
65DB	LD HL,$65CF
65DE	CALL $7D68	Print string: position cursor for message window line 1 (row $A4)
65E1	LD HL,($6127)
65E4	LD DE,$0003
65E7	ADD HL,DE
65E8	LD A,(HL)
65E9	AND $3F
65EB	LD L,A
65EC	LD H,$00
65EE	ADD HL,HL
65EF	LD C,L
65F0	LD B,H
65F1	ADD HL,HL
65F2	ADD HL,HL
65F3	ADD HL,BC
65F4	ADD HL,BC
65F5	ADD HL,BC
65F6	LD DE,$73B5	" DEATHBOWL "
65F9	ADD HL,DE
65FA	LD ($65D9),HL
65FD	CALL $7D68	Print string: room/creature title, indexed by room type (73B5 table)
6600	LD HL,$65D3
6603	CALL $7D68	Print string: position cursor for message window line 2 (row $B4)
6606	LD HL,($65D7)
6609	LD A,$FF
660B	CP (HL)
660C	JR NZ,$6614
660E	LD HL,$7441
6611	LD ($65D7),HL
6614	CALL $7D68	Print string: current clue/joke message, rotating through the 7441 table
6617	LD HL,($65D7)
661A	LD DE,$0014
661D	ADD HL,DE
661E	LD ($65D7),HL
6621	RET

Used by the routine at 8AFB.
Sets $6199=1, resets the rust/oil timer $6501 to 0 (full), decrements oil-can count $6198 (BCD), calls $6646 (unidentified), plays sound effect $09.
6622	LD A,$01
6624	LD ($6199),A
6627	XOR A
6628	LD ($6501),A
662B	LD HL,$6198
662E	LD A,(HL)
662F	SUB $01
6631	DAA
6632	LD (HL),A
6633	CALL $6646
6636	LD A,$09
6638	JP $848E

Used by the routine at 676D.
663B	LD DE,$D408
663E	LD B,$6E
6640	LD C,B
6641	LD A,$05
6643	CALL $8128	Draw sprite C with its mask at screen position DE
This entry point is used by the routine at 6622.
6646	CALL $850E	print inline string, then resume after it
6649	DEFM $16,$13,$03,$5E	cursor position only, no visible text
664D	LD A,($6198)
6650	JP $854F

Used by the routine at 676D.
6653	XOR A
6654	JP $69AC	Prepare the Room with color A

Used by the routine at 676D.
6657	LD HL,($6127)	get room description address
665A	INC HL
665B	INC HL
665C	LD A,(HL)	get Byte 3: Room colour and Room Size
665D	AND $0F	color only
665F	LD ($6175),A	Store room color
6662	RET

Used by the routines at 66CE and 8AFB.
Fires during room build. Passes IX=$8DEF (the creature insertion point -- see 8DB6) into 84AE, so the creature is spliced into the active object list right after the fixed records, i.e. processed after the player. Handler is 9341.
6663	PUSH BC
6664	PUSH HL
6665	LD IX,$8DEF
6669	CALL $84AE	Dynamic object allocator
666C	DEFW $9341	Dynamic object handler address (9341)
666E	POP HL
666F	PUSH HL
6670	LD (IX+$0E),L
6673	LD (IX+$0F),H
6676	INC HL
6677	LD A,(HL)
6678	INC HL
6679	CALL $6254	Set object position (IX+5/+6) from grid index A
667C	LD A,(HL)
667D	INC HL
667E	LD (IX+$07),A
6681	LD A,(HL)
6682	LD (IX+$08),A
6685	CALL $9AAB	Search the (key,data) pair table at $74CE for key A
6688	LD A,(HL)
6689	LD (IX+$0A),A
668C	CALL $9A60	Dynamic object finalizer
668F	POP HL
6690	POP BC
6691	RET

Used by the routine at 6728.
6692	PUSH BC
6693	PUSH HL
6694	EX DE,HL
6695	LD IX,$60EC
6699	LD A,($60EB)
669C	AND A
669D	JR Z,$66C1
669F	PUSH AF
66A0	LD L,(IX+$00)
66A3	LD H,(IX+$01)
66A6	INC HL
66A7	INC HL
66A8	INC DE
66A9	INC DE
66AA	LD A,(DE)
66AB	CP (HL)
66AC	DEC DE
66AD	DEC DE
66AE	DEC HL
66AF	DEC HL
66B0	JR NC,$66B9
66B2	EX DE,HL
66B3	LD (IX+$00),L
66B6	LD (IX+$01),H
66B9	INC IX
66BB	INC IX
66BD	POP AF
66BE	DEC A
66BF	JR NZ,$669F
66C1	LD (IX+$00),E
66C4	LD (IX+$01),D
66C7	LD HL,$60EB
66CA	INC (HL)
66CB	POP HL
66CC	POP BC
66CD	RET

Used by the routine at 6728.
66CE	LD HL,$8DB8
66D1	LD A,(HL)
66D2	PUSH AF
66D3	LD (HL),$00
66D5	LD A,($60EB)
66D8	AND A
66D9	JR Z,$6723
66DB	LD B,A
66DC	LD IX,$60EC
66E0	PUSH BC
66E1	PUSH IX
66E3	LD L,(IX+$00)
66E6	LD H,(IX+$01)
66E9	CALL $6663	Spawn the room's creature
66EC	LD A,(IX+$07)
66EF	SUB $04
66F1	LD (IX+$07),A
66F4	CP $18
66F6	JR C,$66FD
66F8	CALL $9BF0	Collision test
66FB	JR NC,$66EC
66FD	LD A,(IX+$07)
6700	ADD A,$04
6702	LD (IX+$07),A
6705	CALL $9BF0	Collision test
6708	JR C,$66FD
670A	LD (IX+$0D),$00
670E	LD L,(IX+$0E)
6711	LD H,(IX+$0F)
6714	INC HL
6715	INC HL
6716	LD A,(IX+$07)
6719	LD (HL),A
671A	POP IX
671C	INC IX
671E	INC IX
6720	POP BC
6721	DJNZ $66E0
6723	POP AF
6724	LD ($8DB8),A
6727	RET

Used by the routine at 676D.
6728	XOR A
6729	LD ($60EB),A
672C	LD HL,$788A
672F	LD BC,($7C81)
6733	LD A,($6126)	get room number
6736	CP (HL)
6737	CALL Z,$6692
673A	LD DE,$0008
673D	ADD HL,DE
673E	DJNZ $6733
6740	JP $66CE

Used by the routine at 676D.
6743	LD HL,($6127)
6746	INC HL
6747	INC HL
6748	INC HL
6749	BIT 7,(HL)
674B	JR NZ,$6765
674D	SET 7,(HL)
674F	LD IY,$7C9A
6753	CALL $88D7
6756	LD HL,$6120
6759	LD A,(HL)
675A	ADD A,$05
675C	DAA
675D	LD (HL),A
675E	INC HL
675F	LD A,(HL)
6760	ADC A,$00
6762	DAA
6763	LD (HL),A
6764	RET
6765	LD IY,$7C9A
6769	CALL $88DD
676C	RET

Used by the routines at 6B05 and 97FC.
Draw the full room (walls, doors, message window, creatures/objects) -- or the reduced special-room variant for rooms $01/$02 Rooms $01 and $02 are the only two type $E rooms, and are special "no walls" rooms (see 6CCF -- room $01 is the ending/winning room). At 67AB, this routine checks if the current room ($6126) is 1 or 2 and, if so, skips straight to 67E0, bypassing: the wall/layout draw (642F), door-graphic draw (6377), the message window (65DB), and several creature/object placement calls (6593/$655E/$663B/$6743/$8F82/$6895/$885A). The room's grid contents (rocks/seaweed etc, from its type $E template) still get drawn via a separate, non-skipped path -- consistent with the "just floating rocks and seaweed, no walls" appearance of room $01. Room $01 additionally gets one extra call, 86CC (CALL Z at 67E8, gated on room==1 specifically, not room==2) -- draws the "DEATHBOWL DIVINED" end-game stats overlay (see 86CC).
676D	LD ($8DB8),A
6770	LD ($8E11),A
6773	LD ($8E29),A
6776	LD A,($6126)	get room number
6779	LD ($619A),A
677C	LD A,($8DC1)
677F	LD ($619D),A
6782	XOR A
6783	LD ($6193),A
6786	LD ($618A),A
6789	LD IX,$8DB6
678D	CALL $9A49
6790	LD HL,($8DBB)
6793	LD ($619B),HL
6796	CALL $61C1
6799	LD A,($8DB8)
679C	CALL $6269	Set current room to A
679F	CALL $630D
67A2	CALL $7FC0
67A5	CALL $7F8E
67A8	CALL $63D0	Clear shadow screen
67AB	LD A,($6126)	get Room number
67AE	CP $01	if room $6126 is 1 or 2, skip to 67E0 (special "no walls" room -- see 676D)
67B0	JR Z,$67E0
67B2	CP $02
67B4	JR Z,$67E0
67B6	CALL $642F	Draw the fixed wall/decoration layout selected by $6129
67B9	CALL $64F3
67BC	CALL $6593
67BF	CALL $6377	Draw three-piece doors, for $612B bits 1 and 2
67C2	CALL $655E
67C5	CALL $65DB	Draw message window
67C8	CALL $663B
67CB	CALL $6743
67CE	CALL $6653	Prepare room with color 0
67D1	CALL $6657	Get room color from room description and store to 6175
67D4	CALL $8F82	Re-initialize the state blocks of the two fixed object records at $8DCF and $8DEF
67D7	CALL $6895	HUD
67DA	CALL $885A	HUD
67DD	JP $6728
Special-room path for rooms $01/$02: skips walls/doors/message-window/most creature calls; room $01 additionally calls 86CC (likely the end-game stats overlay)
67E0	CALL $64F3
67E3	LD A,($6126)	get Room number
67E6	CP $01
67E8	CALL Z,$86CC	Draw the end-game stats screen
67EB	CALL $6653	Prepare room with color 0
67EE	JP $6657	Get room color from room description and store to 6175

Used by the routine at 8AD9.
Reads a direction code from ($8DC1) -- 1, 2, 4, or else (fallback case) -- and for each, tests one bit of the door bitfield at 612B via HL (set to $612B just before this dispatch) before allowing the move: bit 0 (direction code 1) gates "room number - 6" (row-1, NORTH); bit 1 (direction code 4) gates "room number + 1" (col+1, EAST); bit 2 (direction code 2) gates "room number + 6" (row+1, SOUTH); bit 3 (the fallback case) gates "room number - 1" (col-1, WEST). Also does on-screen player-position bounds checks (against D/E, likely screen row/col) before allowing the move, presumably to require the player to be near the room edge on that side. 97FC is called with the new room number to actually perform the transition.
67F1	LD A,($8DBD)
67F4	CP $29
67F6	JP NC,$687E
67F9	LD HL,$612B
67FC	LD DE,($8DBB)
6800	LD A,($8DC1)
6803	CP $01
6805	JR NZ,$6827
6807	BIT 0,(HL)
6809	JR Z,$687E
680B	LD A,E
680C	CP $03
680E	JR NC,$687E
6810	LD A,D
6811	CP $18
6813	JR C,$687E
6815	CP $20
6817	JR NC,$687E
6819	LD A,($6126)	get room number
681C	SUB $06	change room number: -6 (row-1, move NORTH)
681E	LD E,$3C
6820	LD ($8DBB),DE
6824	JP $97FC	Change current room to A
6827	CP $04
6829	JR NZ,$6845
682B	BIT 1,(HL)
682D	JR Z,$687E
682F	LD A,D
6830	CP $3D
6832	JR C,$687E
6834	LD A,E
6835	CP $18
6837	JR C,$687E
6839	CP $20
683B	JR NC,$687E
683D	LD A,($6126)	get room number
6840	INC A	change room number: +1 (col+1, move EAST)
6841	LD D,$04
6843	JR $6820
6845	CP $02
6847	JR NZ,$6864
6849	BIT 2,(HL)
684B	JR Z,$687E
684D	LD A,E
684E	CP $3D
6850	JR C,$687E
6852	LD A,D
6853	CP $18
6855	JR C,$687E
6857	CP $20
6859	JR NC,$687E
685B	LD A,($6126)	get room number
685E	ADD A,$06	change room number: +6 (row+1, move SOUTH)
6860	LD E,$04
6862	JR $6820
6864	BIT 3,(HL)
6866	JR Z,$687E
6868	LD A,D
6869	CP $03
686B	JR NC,$687E
686D	LD A,E
686E	CP $18
6870	JR C,$687E
6872	CP $20
6874	JR NC,$687E
6876	LD A,($6126)	get room number
6879	DEC A	change room number: -1 (col-1, move WEST)
687A	LD D,$3C
687C	JR $6820
687E	AND A
687F	RET

Used by the routine at 8AFB.
6880	LD HL,$788A
6883	LD DE,$0008
6886	LD BC,($7C81)
688A	LD C,$00
688C	CP (HL)
688D	JR NZ,$6890
688F	INC C
6890	ADD HL,DE
6891	DJNZ $688C
6893	LD A,C
6894	RET

Used by the routines at 676D, 68C1 and 8AFB.
Draws the sprite from the held-item record (6110, offset +3) at fixed HUD position $D4F8 via 8128, then checks (via 88E3) whether it's a weapon; if so also prints its ammo count (619E, BCD) via 854F.
6895	LD HL,($6110)
6898	LD DE,$D4F8
689B	LD BC,$0003
689E	ADD HL,BC
689F	LD C,(HL)
68A0	LD B,C
68A1	LD A,B
68A2	LD A,$05
68A4	CALL $8128	Draw sprite C with its mask at screen position DE
68A7	LD A,(HL)
68A8	CALL $88E3	Search the buffer at $7C83 for byte A
68AB	RET NZ
68AC	JP $68AF
This entry point is used by the routine at 68C1.
68AF	PUSH HL
68B0	PUSH BC
68B1	CALL $850E	print inline string, then resume after it
68B4	DEFM $16,$13,$1C,$5E	cursor position only, no visible text
68B8	LD A,($619E)	get Weapon-held flag
68BB	CALL $854F	Print BCD byte A as two digits, high digit blanked to a space if zero
68BE	POP BC
68BF	POP HL
68C0	RET