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

Chains B records of 24 bytes each, starting at DE, writing each record's own first word as the address of the next. The last record links onto the existing free-list head at $618B instead of another new record, then $618B is updated to point at the chain's own start, prepending it to the free list.

Clears the free/active-list pointers, then initializes two object-record free lists, at $5B00 and $A900, 8 records each, via 61A8.

Resets oil/rust state, restocks the item table from a master template, clears per-level Plug Room progress and per-room flags, and zeroes the score/end-game counters.

A -= 1 first, then column = (A AND $F8) + 4 becomes X (+5); the original A AND $07 rotated left 3 (*8) + 4 becomes Y (+6). Converts a raw 0-63 grid index into the screen-position centre of that cell.

Stores the room number to $6126, walks the room-description chain from room 0 (each record's own length-byte offsets to the next) to find record A, storing its address at $6127. Extracts byte1 (door/exit bitfield) to $612B, byte2's high nibble (room-type template index into 72B1) to $612A, and byte3 bit 6 (shape selector) to $6129. Clears the 64-byte room grid at $612C, stamps in the room-type template via 62C8, then overlays this room's own extra (index,value) pairs, if its description is longer than the base 4 bytes, via the same 62C8 grid-writer.

Via the per-level table at $7287; returns Z if so, with HL pointing at the entry's state byte.

For each of 4 slots in this level's delivery-state nibble, pokes marker $13 into the corresponding room-grid cell listed at $72AC when the slot's bit is set.

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.

Zeroes the entire shadow screen buffer, $E390 through $17FF bytes, via a single-byte seed plus LDIR fill.

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.

Called by 9745 (occlusion redraw) and 9341 (Plug Room item delivery). Looks up the cell's grid value in the 7556 shape table, then falls into 64BB's draw loop.

For a grid cell whose terrain value (A) resolves via 9AAB/$750B to a sprite/column entry, computes a screen sub-position threshold against $D0 to pick between adjacent sprite variants, then draws it via 8128 with colour 0, adjusting the returned D (screen row-delta) via a small per-entry table before looping across the row, count B, called by 6470 for each terrain cell.

This entry point is used by the routine at 6470.

This entry point is used by the routine at 6470.

Loops A from 0 up to $3F, all 64 grid cells, with B fixed at $17, calling 6470 once per cell to redraw it.

Does nothing if a game-over flag ($617A) is set, or in rooms 1/2 (ending/menu). If the oil-used flag ($6199) is set, just calls 6580 to tick the gauge display. Otherwise decrements a countdown at $6501, and every time it wraps, decrements a cycle counter at $6500; when that hits zero, reloads it from $64FF and increments the rust level at $6502. Once rust reaches $52, the player is killed: switches the player's per-frame handler to $8C48 and sets the game-over flag.

Screen column comes from A rotated into a fixed base ($AD, masked to 4-pixel steps); the sprite number is looked up in a 4-entry table at $653F, indexed by (A+1) AND $03, so the segment's appearance cycles through 4 sprite variants as the gauge fills. Draws via 8128 with a fixed row/mask setup (B=C=the looked-up sprite, colour 5).

Draws a fixed base icon, sprite $C5 colour 3, at $FCD4, then repeated rust-gauge segments via 6543 at increasing positions, A stepping by 3, up to the rust timer $6502, finishing with one more segment at the timer's exact value unless it's already zero.

Decrements timer $6502 by up to 2 and redraws via 655E, or when already zero, clears the oil-used flag $6199.

Draws the window's top-left corner icon at $EC2C, then two 8-wide edge strips: the top edge starting at $C408 stepping +8,+16 per tile, and the bottom edge starting at $C4F8 stepping +8,-16 per tile, all via 8128.

Prints the fixed "DEATHBOWL" banner via 65CF's prefix, then computes and prints this room's title string, looked up in a table at $73B5 indexed by the room description's byte3 low 6 bits (title index) times 8. Follows with a second, rotating clue/joke message line from a pointer at $65D7 (wrapping to $7441 at the $FF terminator), advancing that pointer by $14, one entry, each call so successive room visits cycle through the message list.

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.

Draws the fixed oil-can icon, sprite $6E colour 5, at screen position $D408 via 8128, then prints the remaining oil-can count from $6198 as a BCD number via 854F.

This entry point is used by the routine at 6622.

Sets colour to 0 and jumps into 69AC to draw the room's background.

Reads byte3 of the current room description ($6127+3), masks to the low nibble, colour, ignoring the size bits, and stores it to $6175.

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.

Insertion-sorts DE into the queue, keeping it ordered by each record's offset+2 byte (normally the "owning room" field elsewhere -- its role as a sort key here isn't confirmed). Shifts later entries down to make room; consumed by 9900.

Saves and clears a global "building" flag byte at $8DB8 for the duration. For each active object (count $60EB, records at $60EC), calls 6663 to spawn/refresh it, then settles its height field (+0x07) toward the ground: decrements by 4 with a 9BF0 collision test each step while above $18, or increments by 4 while blocked below $18, clamping to whichever bound clears the test. Clears bit 7 of the flags byte (+0x0D) and writes the settled height into the record's linked height-shadow field (offset+2 via +0x0E/+0x0F), then restores $8DB8 on completion. Called after 6728 queues the room's items.

Scans the item table at $788A for entries in the current room, inserting each via 6692, then builds the room.

Tests bit 7 of the room description's byte3 (a "room already visited" flag, distinct from bit 6's shape selector and bits 0-5's title index -- see Room-Format.md section 4). If not yet set: marks it, draws the title via 88D7, and adds 5 (BCD) to a counter at $6120/$6121. If already visited, just draws the title via 88DD (no bonus).

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.

Walks the item table at $788A (count from $7C81, entry stride 8), counting entries whose room byte equals A, returning the count in A. Used to check how many of a room's dropped items remain.

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.

Fills the diamond floor/border with the room colour, special-cased for room 1 (ending screen) and room 2 (menu screen).

Increments the ROM frame counter $5C78, and unless sound is disabled ($61A0), drives the 128K AY sound chip via port $7FFD and the ROM's PLAY_SOUND routines ($F424/$F427) to advance the music. Calls 6AFB for the actual per-frame game update, then restores everything and re-enables interrupts.

Pops the return address off the stack and stores it to the self-modified jump target at $6AF9, clears the frame-ready flag byte at $6AFB, then re-enables interrupts and returns.

Loops forever: enables interrupts, calls 8445 to step the currently-playing sound effect, then repeats.

Trampoline: jumps to 6B05 to start a new game.

Currently a bare RET, self-modified in by 6AFC; called every frame by the ISR 6AAA as the main per-frame game-logic hook.

Writes the RET opcode ($C9) into 6AFB, disabling it, then re-enables interrupts and jumps to 6AF8 to start a new game.

Sets up the player object, global state, and 128K sound, draws the starting room, then enters the main loop.

Frame-rate pacing, per-frame updates (redraw flush, oil timer, screen flip), game-over restart check, and pause/menu key handling.

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)