;;; $8000..807E: Data: initial animation tile pointers ;;;
;; Pointers (24-bit, bank $7E) to the first frame of the three scrolling tiles: $B480, $B498, $B4B0.
$04:8000 .db $80,$B4,$98,$B4,$B0,$B4 ; Initial animation tile frames: $7E:B480, $7E:B498, $7E:B4B0
$04:8006 .db $00,$B3,$18,$B3,$30,$B3,$48,$B3 ; Animated tile 0, frames 0-3: pointers into $7E:B300-B8E8
$04:800E .db $60,$B3,$78,$B3,$90,$B3,$A8,$B3 ; Animated tile 0, frames 4-7: pointers into $7E:B300-B8E8
$04:8016 .db $C0,$B3,$D8,$B3,$F0,$B3,$08,$B4 ; Animated tile 1, frames 0-3: pointers into $7E:B300-B8E8
$04:801E .db $20,$B4,$38,$B4,$50,$B4,$68,$B4 ; Animated tile 1, frames 4-7: pointers into $7E:B300-B8E8
$04:8026 .db $80,$B4,$98,$B4,$B0,$B4,$C8,$B4 ; Animated tile 2, frames 0-3: pointers into $7E:B300-B8E8
$04:802E .db $E0,$B4,$F8,$B4,$10,$B5,$28,$B5 ; Animated tile 2, frames 4-7: pointers into $7E:B300-B8E8
$04:8036 .db $40,$B5,$58,$B5,$70,$B5,$88,$B5 ; Animated tile 3, frames 0-3: pointers into $7E:B300-B8E8
$04:803E .db $A0,$B5,$B8,$B5,$D0,$B5,$E8,$B5 ; Animated tile 3, frames 4-7: pointers into $7E:B300-B8E8
$04:8046 .db $00,$B6,$18,$B6,$30,$B6,$48,$B6 ; Animated tile 4, frames 0-3: pointers into $7E:B300-B8E8
$04:804E .db $60,$B6,$78,$B6,$90,$B6,$A8,$B6 ; Animated tile 4, frames 4-7: pointers into $7E:B300-B8E8
$04:8056 .db $C0,$B6,$D8,$B6,$F0,$B6,$08,$B7 ; Animated tile 5, frames 0-3: pointers into $7E:B300-B8E8
$04:805E .db $20,$B7,$38,$B7,$50,$B7,$68,$B7 ; Animated tile 5, frames 4-7: pointers into $7E:B300-B8E8
$04:8066 .db $80,$B7,$98,$B7,$B0,$B7,$C8,$B7 ; Animated tile 6, frames 0-3: pointers into $7E:B300-B8E8
$04:806E .db $E0,$B7,$F8,$B7,$10,$B8,$28,$B8 ; Animated tile 6, frames 4-7: pointers into $7E:B300-B8E8
$04:8076 .db $40,$B8,$58,$B8,$70,$B8,$88,$B8 ; Animated tile 7, frames 0-3: pointers into $7E:B300-B8E8
$04:807E .db $A0,$B8,$B8,$B8,$D0,$B8,$E8,$B8 ; Animated tile 7, frames 4-7: pointers into $7E:B300-B8E8
;;; $8086: Load initial overworld animation tiles ;;;
;; Copies three animation tiles (via $80B9) into the buffer at $0AF6, slots 0-2, from $8000.
;; The buffer ($0160 bytes, 11 tiles) is DMAed to VRAM $0750 by NMI.
;; Called by:
;; $04:8EEB: Overworld setup and process 0 (level exit)
$04:8086 C2 30 REP #$30 ; A, X and Y 16-bit
$04:8088 64 03 STZ $03 ; [$03] = 0: index into $8000
$04:808A 64 05 STZ $05 ; [$05] = 0: offset into the tile buffer at $0AF6
$04:808C A6 03 LDX $03 ; \
$04:808E BD 00 80 LDA.W $8000,X ; } [$00] = pointer to the tile's first frame
$04:8091 85 00 STA $00 ; /
$04:8093 E2 10 SEP #$10 ; \
$04:8095 A0 7E LDY.B #$7E ; } [$02] = $7E: bank of the 24-bit source pointer
$04:8097 84 02 STY $02 ; /
$04:8099 C2 10 REP #$10 ; Index 16-bit
$04:809B A6 05 LDX $05 ; X = destination offset in the $0AF6 buffer
$04:809D 20 B9 80 JSR.W $80B9 ; Copy one 3bpp tile as a 4bpp tile
$04:80A0 A5 05 LDA $05 ; \
$04:80A2 18 CLC ; |
$04:80A3 69 20 00 ADC.W #$0020 ; } [$05] += $20: next tile slot
$04:80A6 85 05 STA $05 ; /
$04:80A8 A5 03 LDA $03 ; \
$04:80AA 1A INC A ; |
$04:80AB 1A INC A ; } [$03] += 2: next pointer
$04:80AC 85 03 STA $03 ; /
$04:80AE 29 FF 00 AND.W #$00FF ; \
$04:80B1 C9 06 00 CMP.W #$0006 ; } Loop for 3 tiles (pointer index != 6)
$04:80B4 D0 D6 BNE $808C ; /
$04:80B6 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:80B8 60 RTS ; Return
$04:80B9 A0 00 00 LDY.W #$0000 ; Y = 0: offset into the source tile
$04:80BC A9 08 00 LDA.W #$0008 ; \
$04:80BF 85 07 STA $07 ; } [$07] = [$09] = 8 (row counters)
$04:80C1 85 09 STA $09 ; /
$04:80C3 B7 00 LDA [$00],Y ; Load a word of bitplanes 0/1 (one row)
$04:80C5 9D F6 0A STA.W $0AF6,X ; Store it in the buffer at $0AF6
$04:80C8 C8 INY ; \
$04:80C9 C8 INY ; |
$04:80CA E8 INX ; } Source and destination += 2
$04:80CB E8 INX ; /
$04:80CC C6 07 DEC $07 ; \
$04:80CE D0 F3 BNE $80C3 ; / Copy 8 words (16 bytes, bitplanes 0 and 1)
$04:80D0 B7 00 LDA [$00],Y ; Load a byte (one row of bitplane 2)
$04:80D2 29 FF 00 AND.W #$00FF ; Clear the high byte: bitplane 3 = 0
$04:80D5 9D F6 0A STA.W $0AF6,X ; Store as a word (planes 2/3)
$04:80D8 C8 INY ; Source offset += 1
$04:80D9 E8 INX ; \
$04:80DA E8 INX ; / Destination += 2
$04:80DB C6 09 DEC $09 ; \
$04:80DD D0 F1 BNE $80D0 ; / Copy 8 rows (16 bytes, bitplanes 2 and 3)
$04:80DF 60 RTS ; Return
;;; $80E0: Animate overworld water tiles (OW_Tile_Animation) ;;;
;; Every 8 frames rotates the bits of animated tile 0 and tile 2 in the $0AF6 buffer, and scrolls tile 1 and 2
;; vertically.
;; Then selects the current frame for eight further tiles from $8006 (8 frames each; the first two
;; change every 16 frames, the others every 8) and copies them in.
;; Subroutines: $0480B9 copies a 24-byte 3bpp tile as 4bpp; $048172 scrolls a tile's rows by one.
;; Called by:
;; $04:8267: Game mode 0E: overworld (GameMode_0E_Prim)
;; $04:8EEE: Overworld setup and process 0 (level exit)
$04:80E0 A5 13 LDA RAM_FrameCounter ; \
$04:80E2 29 07 AND.B #$07 ; } Skip the tile 0 animation unless [$13] is a multiple of 8
$04:80E4 D0 1B BNE $8101 ; /
$04:80E6 A2 1F LDX.B #$1F ; X = $1F: last byte of tile 0 at $0AF6
$04:80E8 BD F6 0A LDA.W $0AF6,X ; Read one byte of the tile
$04:80EB 85 00 STA $00 ; Copy it to [$00] (carry source for the rotate)
$04:80ED 8A TXA ; \
$04:80EE 29 08 AND.B #$08 ; } Bytes with bit 3 of the index clear rotate left, others right
$04:80F0 D0 07 BNE $80F9 ; /
$04:80F2 06 00 ASL $00 ; \
$04:80F4 3E F6 0A ROL.W $0AF6,X ; / Rotate the byte left by one bit
$04:80F7 80 05 BRA $80FE ; Skip the right rotate
$04:80F9 46 00 LSR $00 ; \
$04:80FB 7E F6 0A ROR.W $0AF6,X ; / Rotate the byte right by one bit
$04:80FE CA DEX ; \
$04:80FF 10 E7 BPL $80E8 ; / Next byte; loop for all 32 bytes
$04:8101 A5 13 LDA RAM_FrameCounter ; \
$04:8103 29 07 AND.B #$07 ; } Skip tile 1 unless [$13] is a multiple of 8
$04:8105 D0 05 BNE $810C ; /
$04:8107 A2 20 LDX.B #$20 ; X = $20: tile 1 at $0AF6+$20
$04:8109 20 72 81 JSR.W $8172 ; Scroll the tile's rows by one
$04:810C A5 13 LDA RAM_FrameCounter ; \
$04:810E 29 07 AND.B #$07 ; } Skip tile 2 unless [$13] is a multiple of 8
$04:8110 D0 11 BNE $8123 ; /
$04:8112 A2 1F LDX.B #$1F ; X = $1F: last byte of tile 2 at $0B36
$04:8114 BD 36 0B LDA.W $0B36,X ; Read one byte of tile 2
$04:8117 0A ASL ; \
$04:8118 3E 36 0B ROL.W $0B36,X ; / Rotate the byte left by one bit
$04:811B CA DEX ; \
$04:811C 10 F6 BPL $8114 ; / Next byte; loop for all 32 bytes
$04:811E A2 40 LDX.B #$40 ; X = $40: tile 2
$04:8120 20 72 81 JSR.W $8172 ; Scroll the tile's rows by one
$04:8123 C2 30 REP #$30 ; A, X and Y 16-bit
$04:8125 A9 60 00 LDA.W #$0060 ; \
$04:8128 85 0D STA $0D ; / [$0D] = $60: destination offset of tile 3 in the $0AF6 buffer
$04:812A 64 0B STZ $0B ; [$0B] = 0: pointer table offset (16 bytes per tile)
$04:812C A2 38 00 LDX.W #$0038 ; X = $38: frame counter mask (8 frames, changes every 8 frames)
$04:812F A5 0B LDA $0B ; \
$04:8131 C9 20 00 CMP.W #$0020 ; } Tiles 3-4 (first two) use the slower mask
$04:8134 B0 03 BCS $8139 ; /
$04:8136 A2 70 00 LDX.W #$0070 ; X = $70: mask for 8 frames changing every 16 frames
$04:8139 8A TXA ; \
$04:813A 25 13 AND RAM_FrameCounter ; |
$04:813C 4A LSR ; } A = (frame counter AND mask) as a word index 0-14
$04:813D 4A LSR ; /
$04:813E E0 38 00 CPX.W #$0038 ; \
$04:8141 F0 01 BEQ $8144 ; } Shift once more for the $70 mask so both give the same range
$04:8143 4A LSR ; /
$04:8144 18 CLC ; \
$04:8145 65 0B ADC $0B ; } X = [$0B] + frame offset: index into $8006
$04:8147 AA TAX ; /
$04:8148 BD 06 80 LDA.W $8006,X ; \
$04:814B 85 00 STA $00 ; / [$00] = pointer to the current frame of this tile
$04:814D E2 10 SEP #$10 ; \
$04:814F A0 7E LDY.B #$7E ; } [$02] = $7E: bank of the source pointer
$04:8151 84 02 STY $02 ; /
$04:8153 C2 10 REP #$10 ; Index 16-bit
$04:8155 A6 0D LDX $0D ; X = destination offset
$04:8157 20 B9 80 JSR.W $80B9 ; Copy the tile into the buffer
$04:815A A5 0D LDA $0D ; \
$04:815C 18 CLC ; |
$04:815D 69 20 00 ADC.W #$0020 ; } [$0D] += $20: next destination tile
$04:8160 85 0D STA $0D ; /
$04:8162 A5 0B LDA $0B ; \
$04:8164 18 CLC ; |
$04:8165 69 10 00 ADC.W #$0010 ; } [$0B] += $10: next tile's pointer row
$04:8168 85 0B STA $0B ; /
$04:816A C9 80 00 CMP.W #$0080 ; \
$04:816D D0 BD BNE $812C ; / Loop for 8 tiles
$04:816F E2 30 SEP #$30 ; A, X and Y 8-bit
$04:8171 60 RTS ; Return
$04:8172 C2 20 REP #$20 ; A 16-bit
$04:8174 A0 00 LDY.B #$00 ; Y = 0: rows done
$04:8176 DA PHX ; Save the start of this 8-row half
$04:8177 8A TXA ; \
$04:8178 18 CLC ; |
$04:8179 69 0E 00 ADC.W #$000E ; } X += $0E: last row of the half
$04:817C AA TAX ; /
$04:817D BD F6 0A LDA.W $0AF6,X ; \
$04:8180 85 00 STA $00 ; / [$00] = last row (wraps to the top)
$04:8182 FA PLX ; Restore X to the first row
$04:8183 BD F6 0A LDA.W $0AF6,X ; \
$04:8186 85 02 STA $02 ; / [$02] = this row
$04:8188 A5 00 LDA $00 ; \
$04:818A 9D F6 0A STA.W $0AF6,X ; / Row = previous row (shifted down by one)
$04:818D A5 02 LDA $02 ; \
$04:818F 85 00 STA $00 ; / Carry this row to the next
$04:8191 E8 INX ; \
$04:8192 E8 INX ; / X += 2: next row
$04:8193 C8 INY ; Rows done++
$04:8194 C0 08 CPY.B #$08 ; \
$04:8196 F0 DE BEQ $8176 ; / After 8 rows, start the second half (planes 2/3)
$04:8198 C0 10 CPY.B #$10 ; \
$04:819A D0 E7 BNE $8183 ; / Loop until 16 rows are done
$04:819C E2 20 SEP #$20 ; A 8-bit
$04:819E 60 RTS ; Return
;;; $819F..81DF: Stripe image: overworld scroll arrows ;;;
;; Stripe image 15 (see ImagePointers): draws the look-around arrows with BG3 tilemap records at VRAM $50CF...
$04:819F .db $50,$CF,$00,$03,$7E,$78,$7E,$38 ; Arrow 0: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81A7 .db $50,$EF,$00,$03,$7F,$38,$7F,$78 ; Arrow 1: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81AF .db $51,$C3,$00,$03,$7E,$78,$7D,$78 ; Arrow 2: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81B7 .db $51,$E3,$00,$03,$7E,$F8,$7D,$F8 ; Arrow 3: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81BF .db $51,$DB,$00,$03,$7D,$38,$7E,$38 ; Arrow 4: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81C7 .db $51,$FB,$00,$03,$7D,$B8,$7E,$B8 ; Arrow 5: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81CF .db $52,$EF,$00,$03,$7F,$B8,$7F,$F8 ; Arrow 6: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81D7 .db $53,$0F,$00,$03,$7E,$F8,$7E,$B8 ; Arrow 7: VRAM address, 2 tiles ($0003 = 4 bytes), tile+attribute words
$04:81DF .db $FF ; End of image
;;; $81E0..8210: Stripe image: remove scroll arrows ;;;
;; Stripe image 18: fills the arrow positions with the blank tile $FC.
$04:81E0 .db $50,$CF,$40,$02,$FC,$00,$50,$EF ; Records: VRAM address, RLE ($4002 = 3 tiles), tile $FC, attr $00
$04:81E8 .db $40,$02,$FC,$00,$51,$C3,$40,$02
$04:81F0 .db $FC,$00,$51,$E3,$40,$02,$FC,$00
$04:81F8 .db $51,$DB,$40,$02,$FC,$00,$51,$FB
$04:8200 .db $40,$02,$FC,$00,$52,$EF,$40,$02
$04:8208 .db $FC,$00,$53,$0F,$40,$02,$FC,$00
$04:8210 .db $FF ; End of image
;;; $8211..8219: Table: look-around scroll step ;;;
;; Words indexed by (d-pad bits * 2); 0, +2, -2, +2 for X (first row) and again for Y (second row, indices
;; 8-14).
$04:8211 .db $00,$00,$02,$00,$FE,$FF,$02,$00 ; Scroll step X: none, +2, -2, +2
$04:8219 .db $00,$00,$02,$00,$FE,$FF,$02,$00 ; Scroll step Y: none, +2, -2, +2
;;; $8221..8229: Table: look-around scroll limits ;;;
;; Words: scroll limits per direction. X: $0111 / -$11. Y: $0132 / -$29.
$04:8221 .db $00,$00,$11,$01,$EF,$FF,$11,$01 ; Limit X: -, $0111, -$11, $0111
$04:8229 .db $00,$00,$32,$01,$D7,$FF,$32,$01 ; Limit Y: -, $0132, -$29, $0132
;;; $8231..8239: Table: ground shake masks ;;;
;; AND masks with the frame counter, indexed by [$1BA0] >> 4; smaller mask = more frequent shaking.
$04:8231 .db $0F,$0F,$07,$07,$07,$03,$03,$03 ; Shake masks for [$1BA0] >> 4 = 0-7 (more shaking at higher values)
$04:8239 .db $01,$01,$03,$03,$03,$07,$07,$07 ; Shake masks for [$1BA0] >> 4 = 8-15
;;; $8241: Game mode 0E: overworld (GameMode_0E_Prim) ;;;
;; Runs every frame in the overworld. Positions Mario, animates tiles, then runs one of: switch blocks flying
;; away, Continue/End message, player switch,
;; look-around scrolling (Start on the main map) or the Bowser's valley reveal shake, otherwise the overworld
;; process for [$13D9] via $8576.
;; [$13D4]: 0 = normal, odd = looking around, >= 2 = returning the screen to the saved position ([$1DF0],
;; [$1DF2]).
;; Called by:
;; $00:A1C7: Clear RAM; game mode 0E: overworld (Clear_1A_13D3)
$04:8241 8B PHB ; \
$04:8242 4B PHK ; } Data bank = program bank ($04)
$04:8243 AB PLB ; /
$04:8244 A2 01 LDX.B #$01 ; X = 1: loop over both players
$04:8246 BD A6 0D LDA.W RAM_OWControllerA,X ; Read the player's overworld controller
$04:8249 29 20 AND.B #$20 ; Select button pressed?
$04:824B 80 14 BRA $8261 ; Always branch: the debug code below is disabled
$04:824D BD BA 0D LDA.W RAM_PlyrYoshiColor,X ; \
$04:8250 1A INC A ; |
$04:8251 1A INC A ; |
$04:8252 C9 04 CMP.B #$04 ; |
$04:8254 B0 02 BCS $8258 ; |
$04:8256 A9 04 LDA.B #$04 ; |
$04:8258 C9 0B CMP.B #$0B ; |
$04:825A 90 02 BCC $825E ; |
$04:825C A9 00 LDA.B #$00 ; } Unused debug code: cycle the Yoshi color on Select (colors 4-$0A, else 0)
$04:825E 9D BA 0D STA.W RAM_PlyrYoshiColor,X ; /
$04:8261 CA DEX ; \
$04:8262 10 E2 BPL $8246 ; / Next player
$04:8264 20 A7 85 JSR.W $85A7 ; Position Mario on the border and run its code
$04:8267 20 E0 80 JSR.W OW_Tile_Animation ; Animate the overworld water/waterfall tiles
$04:826A AD D2 13 LDA.W $13D2 ; \
$04:826D F0 06 BEQ $8275 ; / [$13D2] = 0: no switch-block flying away animation
$04:826F 20 90 F2 JSR.W $F290 ; Run the switch palace blocks flying away animation
$04:8272 4C 0D 84 JMP.W $840D ; Finish the frame
$04:8275 AD C9 13 LDA.W $13C9 ; \
$04:8278 F0 07 BEQ $8281 ; / [$13C9] = 0: no Continue/End message
$04:827A 22 80 9B 00 JSL.L $9B80 ; Run the Continue/End message
$04:827E 4C 10 84 JMP.W $8410 ; Finish (skip border drawing call)
$04:8281 AD 87 1B LDA.W $1B87 ; \
$04:8284 F0 0F BEQ $8295 ; / [$1B87] = 0: no player switch in progress
$04:8286 C9 05 CMP.B #$05 ; \
$04:8288 B0 05 BCS $828F ; / [$1B87] >= 5: run it regardless
$04:828A AC B2 0D LDY.W $0DB2 ; \
$04:828D F0 06 BEQ $8295 ; / [$0DB2] = 0 (one player): ignore the switch
$04:828F 20 E5 F3 JSR.W $F3E5 ; Run the player switch animation
$04:8292 4C 13 84 JMP.W $8413 ; Exit
$04:8295 AD D4 13 LDA.W $13D4 ; \
$04:8298 4A LSR ; } Look-around mode ([$13D4] >> 1) active? (first press = 1 is not)
$04:8299 D0 03 BNE $829E ; /
$04:829B 4C 56 83 JMP.W $8356 ; Not returning: go handle normal input
$04:829E C2 20 REP #$20 ; A 16-bit
$04:82A0 AD F2 1D LDA.W $1DF2 ; \
$04:82A3 38 SEC ; |
$04:82A4 E5 1C SBC RAM_ScreenBndryYLo ; } [$01] = saved Y scroll [$1DF2] - current Y scroll
$04:82A6 85 01 STA $01 ; /
$04:82A8 10 04 BPL $82AE ; \
$04:82AA 49 FF FF EOR.W #$FFFF ; |
$04:82AD 1A INC A ; } A = |delta Y| / 2
$04:82AE 4A LSR ; /
$04:82AF E2 20 SEP #$20 ; A 8-bit
$04:82B1 85 05 STA $05 ; [$05] = |delta Y| / 2
$04:82B3 C2 20 REP #$20 ; A 16-bit
$04:82B5 AD F0 1D LDA.W $1DF0 ; \
$04:82B8 38 SEC ; |
$04:82B9 E5 1A SBC RAM_ScreenBndryXLo ; } [$00] = saved X scroll [$1DF0] - current X scroll
$04:82BB 85 00 STA $00 ; /
$04:82BD 10 04 BPL $82C3 ; \
$04:82BF 49 FF FF EOR.W #$FFFF ; |
$04:82C2 1A INC A ; } A = |delta X| / 2
$04:82C3 4A LSR ; /
$04:82C4 E2 20 SEP #$20 ; A 8-bit
$04:82C6 85 04 STA $04 ; [$04] = |delta X| / 2
$04:82C8 A2 01 LDX.B #$01 ; \
$04:82CA C5 05 CMP $05 ; } X = 1 if X distance >= Y distance (A = larger distance)
$04:82CC B0 03 BCS $82D1 ; /
$04:82CE CA DEX ; \
$04:82CF A5 05 LDA $05 ; / Else X = 0, A = Y distance
$04:82D1 C9 02 CMP.B #$02 ; \
$04:82D3 B0 18 BCS $82ED ; / Distance < 2: close enough, snap back to the saved position
$04:82D5 C2 20 REP #$20 ; A 16-bit
$04:82D7 AD F0 1D LDA.W $1DF0 ; \
$04:82DA 85 1A STA RAM_ScreenBndryXLo ; } Screen X = saved X scroll (and BG2 mirror [$1E])
$04:82DC 85 1E STA $1E ; /
$04:82DE AD F2 1D LDA.W $1DF2 ; \
$04:82E1 85 1C STA RAM_ScreenBndryYLo ; } Screen Y = saved Y scroll (and BG2 mirror [$20])
$04:82E3 85 20 STA $20 ; /
$04:82E5 E2 20 SEP #$20 ; A 8-bit
$04:82E7 9C D4 13 STZ.W $13D4 ; [$13D4] = 0: leave look-around mode
$04:82EA 4C BD 83 JMP.W $83BD ; Remove the scroll arrows ($12 = $18) and finish
$04:82ED 9C 04 42 STZ.W $4204 ; \
$04:82F0 B4 04 LDY $04,X ; |
$04:82F2 8C 05 42 STY.W $4205 ; } Divide: [smaller distance] * 256 / [larger distance]
$04:82F5 8D 06 42 STA.W $4206 ; /
$04:82F8 EA NOP ; \
$04:82F9 EA NOP ; |
$04:82FA EA NOP ; |
$04:82FB EA NOP ; |
$04:82FC EA NOP ; } Wait for the hardware division to finish
$04:82FD EA NOP ; /
$04:82FE C2 20 REP #$20 ; \
$04:8300 AD 14 42 LDA.W $4214 ; |
$04:8303 4A LSR ; } A = quotient / 4: speed of the shorter axis (max $40)
$04:8304 4A LSR ; /
$04:8305 E2 20 SEP #$20 ; A 8-bit
$04:8307 B4 01 LDY $01,X ; \
$04:8309 10 03 BPL $830E ; |
$04:830B 49 FF EOR.B #$FF ; } Apply the sign of that axis' delta
$04:830D 1A INC A ; /
$04:830E 95 01 STA $01,X ; Store the speed of the shorter axis in [$01,X]
$04:8310 8A TXA ; \
$04:8311 49 01 EOR.B #$01 ; } X ^= 1: the other (longer) axis
$04:8313 AA TAX ; /
$04:8314 A9 40 LDA.B #$40 ; \
$04:8316 B4 01 LDY $01,X ; |
$04:8318 10 02 BPL $831C ; } Longer axis speed = +$40 or -$40 by sign of its delta
$04:831A A9 C0 LDA.B #$C0 ; /
$04:831C 95 01 STA $01,X ; Store the speed in [$01,X]
$04:831E A0 01 LDY.B #$01 ; Y = 1: loop over Y axis then X axis
$04:8320 98 TYA ; \
$04:8321 0A ASL ; } X = Y * 2 (index into screen scroll words)
$04:8322 AA TAX ; /
$04:8323 B9 01 00 LDA.W $0001,Y ; \
$04:8326 0A ASL ; |
$04:8327 0A ASL ; |
$04:8328 0A ASL ; } A = speed * 16: fractional part
$04:8329 0A ASL ; /
$04:832A 18 CLC ; \
$04:832B 79 7C 1B ADC.W $1B7C,Y ; } Add to fraction accumulator [$1B7C+Y], carry = pixel step
$04:832E 99 7C 1B STA.W $1B7C,Y ; /
$04:8331 B9 01 00 LDA.W $0001,Y ; A = speed
$04:8334 5A PHY ; \
$04:8335 08 PHP ; / Save Y and the carry flag
$04:8336 4A LSR ; \
$04:8337 4A LSR ; |
$04:8338 4A LSR ; } A = speed >> 4: whole pixels
$04:8339 4A LSR ; /
$04:833A A0 00 LDY.B #$00 ; Y = 0: high byte of the move
$04:833C 28 PLP ; \
$04:833D 10 03 BPL $8342 ; |
$04:833F 09 F0 ORA.B #$F0 ; } Sign-extend negative speeds (high byte = $FF)
$04:8341 88 DEY ; /
$04:8342 75 1A ADC RAM_ScreenBndryXLo,X ; \
$04:8344 95 1A STA RAM_ScreenBndryXLo,X ; } Screen X/Y position low += pixels + carry (and BG2 mirror)
$04:8346 95 1E STA $1E,X ; /
$04:8348 98 TYA ; \
$04:8349 75 1B ADC RAM_ScreenBndryXHi,X ; |
$04:834B 95 1B STA RAM_ScreenBndryXHi,X ; } Screen position high byte += sign extension + carry (and mirror)
$04:834D 95 1F STA $1F,X ; /
$04:834F 7A PLY ; \
$04:8350 88 DEY ; } Next axis
$04:8351 10 CD BPL $8320 ; /
$04:8353 4C 0D 84 JMP.W $840D ; Finish the frame
$04:8356 AD D9 13 LDA.W $13D9 ; \
$04:8359 C9 03 CMP.B #$03 ; } [$13D9] = 3: player idle, accept input
$04:835B F0 09 BEQ $8366 ; /
$04:835D C9 04 CMP.B #$04 ; \
$04:835F D0 39 BNE $839A ; / [$13D9] = 4: only when [$0DD8] = 0
$04:8361 AD D8 0D LDA.W $0DD8 ; [$0DD8] != 0: ignore input
$04:8364 D0 34 BNE $839A
$04:8366 AD A8 0D LDA.W $0DA8 ; \
$04:8369 0D A9 0D ORA.W $0DA9 ; |
$04:836C 29 30 AND.B #$30 ; } L or R pressed (both controllers)?
$04:836E F0 05 BEQ $8375 ; /
$04:8370 A9 01 LDA.B #$01 ; \
$04:8372 8D 87 1B STA.W $1B87 ; / [$1B87] = 1: start the player switch
$04:8375 AE B3 0D LDX.W $0DB3 ; X = current player
$04:8378 BD 11 1F LDA.W $1F11,X ; \
$04:837B D0 1D BNE $839A ; / Not on the main map (submap non-zero): no look-around
$04:837D A5 16 LDA $16 ; \
$04:837F 29 10 AND.B #$10 ; } Start button pressed?
$04:8381 F0 17 BEQ $839A ; /
$04:8383 EE D4 13 INC.W $13D4 ; [$13D4]++: toggle look-around mode
$04:8386 AD D4 13 LDA.W $13D4 ; \
$04:8389 4A LSR ; } Not the first press (already looking, now leaving)? skip saving
$04:838A D0 0E BNE $839A ; /
$04:838C C2 20 REP #$20 ; A 16-bit
$04:838E A5 1A LDA RAM_ScreenBndryXLo ; \
$04:8390 8D F0 1D STA.W $1DF0 ; / Save current X scroll in [$1DF0]
$04:8393 A5 1C LDA RAM_ScreenBndryYLo ; \
$04:8395 8D F2 1D STA.W $1DF2 ; / Save current Y scroll in [$1DF2]
$04:8398 E2 20 SEP #$20 ; A 8-bit
$04:839A AD D4 13 LDA.W $13D4 ; \
$04:839D F0 24 BEQ $83C3 ; / Not looking around: go handle other events
$04:839F A2 00 LDX.B #$00 ; X = 0: horizontal axis
$04:83A1 A5 15 LDA RAM_ControllerA ; \
$04:83A3 29 03 AND.B #$03 ; } A = left/right bits * 2: table index
$04:83A5 0A ASL ; /
$04:83A6 20 15 84 JSR.W $8415 ; Scroll the screen horizontally
$04:83A9 A2 02 LDX.B #$02 ; X = 2: vertical axis
$04:83AB A5 15 LDA RAM_ControllerA ; \
$04:83AD 29 0C AND.B #$0C ; |
$04:83AF 09 10 ORA.B #$10 ; } A = (up/down bits | $10) / 2: table index 8-14
$04:83B1 4A LSR ; /
$04:83B2 20 15 84 JSR.W $8415 ; Scroll the screen vertically
$04:83B5 A0 15 LDY.B #$15 ; Y = $15: image 'draw scroll arrows'
$04:83B7 A5 13 LDA RAM_FrameCounter ; \
$04:83B9 29 18 AND.B #$18 ; } Blink: every 8th frame of 32
$04:83BB D0 02 BNE $83BF ; /
$04:83BD A0 18 LDY.B #$18 ; Y = $18: image 'remove scroll arrows'
$04:83BF 84 12 STY $12 ; Request the arrows stripe image
$04:83C1 80 4A BRA $840D ; Finish the frame
$04:83C3 AE A0 1B LDX.W $1BA0 ; \
$04:83C6 F0 42 BEQ $840A ; / [$1BA0] = 0: no ground shake, run the overworld process
$04:83C8 E0 FE CPX.B #$FE ; \
$04:83CA D0 0A BNE $83D6 ; / [$1BA0] = $FE: first frame of the Bowser's valley reveal
$04:83CC A9 21 LDA.B #$21 ; \
$04:83CE 8D F9 1D STA.W $1DF9 ; / Play sound effect $21
$04:83D1 A9 08 LDA.B #$08 ; \
$04:83D3 8D FB 1D STA.W $1DFB ; / Request music $08 (probably the Bowser's valley reveal)
$04:83D6 8A TXA ; \
$04:83D7 4A LSR ; |
$04:83D8 4A LSR ; |
$04:83D9 4A LSR ; |
$04:83DA 4A LSR ; } Y = [$1BA0] >> 4
$04:83DB A8 TAY ; /
$04:83DC A5 13 LDA RAM_FrameCounter ; \
$04:83DE 39 31 82 AND.W $8231,Y ; } Shake only on frames where [$13] AND mask is 0
$04:83E1 D0 10 BNE $83F3 ; /
$04:83E3 A5 1A LDA RAM_ScreenBndryXLo ; \
$04:83E5 49 01 EOR.B #$01 ; |
$04:83E7 85 1A STA RAM_ScreenBndryXLo ; } Toggle bit 0 of screen X (and BG2 mirror)
$04:83E9 85 1E STA $1E ; /
$04:83EB A5 1C LDA RAM_ScreenBndryYLo ; \
$04:83ED 49 01 EOR.B #$01 ; |
$04:83EF 85 1C STA RAM_ScreenBndryYLo ; } Toggle bit 0 of screen Y (and BG2 mirror)
$04:83F1 85 20 STA $20 ; /
$04:83F3 E0 80 CPX.B #$80 ; \
$04:83F5 B0 07 BCS $83FE ; / [$1BA0] >= $80: count down regardless
$04:83F7 AD D9 13 LDA.W $13D9 ; \
$04:83FA C9 02 CMP.B #$02 ; } Below $80: only count down when [$13D9] = 2, else process
$04:83FC D0 0C BNE $840A ; /
$04:83FE CE A0 1B DEC.W $1BA0 ; \
$04:8401 D0 0A BNE $840D ; / [$1BA0]--; still running: finish the frame
$04:8403 A9 22 LDA.B #$22 ; \
$04:8405 8D F9 1D STA.W $1DF9 ; / Timer ended: play sound effect $22
$04:8408 80 03 BRA $840D ; Finish the frame
$04:840A 20 76 85 JSR.W $8576 ; Run the overworld process for [$13D9]
$04:840D 20 08 F7 JSR.W $F708 ; Run the overworld sprites/animation code (probably)
$04:8410 20 2E 86 JSR.W $862E ; Draw/update the overworld border (probably)
$04:8413 AB PLB ; Restore the data bank
$04:8414 6B RTL ; Return
$04:8415 A8 TAY ; Y = table index
$04:8416 C2 20 REP #$20 ; A 16-bit
$04:8418 B5 1A LDA RAM_ScreenBndryXLo,X ; A = current screen position [$1A,X]
$04:841A 18 CLC ; \
$04:841B 79 11 82 ADC.W $8211,Y ; / + step from $8211
$04:841E 48 PHA ; Save the new position
$04:841F 38 SEC ; \
$04:8420 F9 21 82 SBC.W $8221,Y ; / - limit from $8221
$04:8423 59 11 82 EOR.W $8211,Y ; \
$04:8426 0A ASL ; / Carry = sign of (new - limit) differs from sign of step
$04:8427 68 PLA ; Restore the new position
$04:8428 90 04 BCC $842E ; \
$04:842A 95 1A STA RAM_ScreenBndryXLo,X ; } Within the limit: store the scroll position (and BG2 mirror)
$04:842C 95 1E STA $1E,X ; /
$04:842E E2 20 SEP #$20 ; A 8-bit
$04:8430 60 RTS ; Return
;;; $8431..8461: Table: warp tile X positions ;;;
;; 27 words: X tile of each overworld warp (bits 0-7), submap in the high byte. Compared with [$1F1F,X].
$04:8431 .db $11,$00,$0A,$00,$09,$00,$0B,$00 ; Warp tile X (bits 0-8), submap in high byte: warps 0-3
$04:8439 .db $12,$00,$0A,$00,$07,$00,$0A,$02 ; Warp tile X (bits 0-8), submap in high byte: warps 4-7
$04:8441 .db $03,$02,$10,$04,$12,$04,$1C,$04 ; Warp tile X (bits 0-8), submap in high byte: warps 8-11
$04:8449 .db $14,$04,$12,$06,$00,$02,$12,$06 ; Warp tile X (bits 0-8), submap in high byte: warps 12-15
$04:8451 .db $10,$00,$17,$06,$14,$00,$1C,$06 ; Warp tile X (bits 0-8), submap in high byte: warps 16-19
$04:8459 .db $14,$00,$1C,$06,$17,$06,$11,$05 ; Warp tile X (bits 0-8), submap in high byte: warps 20-23
$04:8461 .db $11,$05,$14,$04,$06,$01 ; Warp tile X: warps 24-26
;;; $8467..8497: Table: warp tile Y positions ;;;
;; 27 words: Y tile of each warp. Compared with [$1F21,X].
$04:8467 .db $07,$00,$03,$00,$10,$00,$0E,$00 ; Warp tile Y: warps 0-3
$04:846F .db $17,$00,$18,$00,$12,$00,$14,$00 ; Warp tile Y: warps 4-7
$04:8477 .db $0B,$00,$03,$00,$01,$00,$09,$00 ; Warp tile Y: warps 8-11
$04:847F .db $09,$00,$1D,$00,$0E,$00,$18,$00 ; Warp tile Y: warps 12-15
$04:8487 .db $0F,$00,$16,$00,$10,$00,$18,$00 ; Warp tile Y: warps 16-19
$04:848F .db $02,$00,$1D,$00,$18,$00,$13,$00 ; Warp tile Y: warps 20-23
$04:8497 .db $11,$00,$03,$00,$07,$00 ; Warp tile Y: warps 24-26
;;; $849D..84CD: Table: warp destination X and submap ;;;
;; 27 words: bits 0-8 = X pixel position, bits 9-12 = destination submap (probably).
$04:849D .db $A8,$04,$38,$04,$08,$09,$28,$09 ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 0-3
$04:84A5 .db $C8,$09,$48,$09,$28,$0D,$18,$01 ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 4-7
$04:84AD .db $A8,$00,$98,$00,$B8,$00,$28,$01 ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 8-11
$04:84B5 .db $A8,$00,$78,$00,$28,$0D,$08,$04 ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 12-15
$04:84BD .db $78,$0D,$08,$01,$C8,$0D,$48,$01 ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 16-19
$04:84C5 .db $C8,$0D,$48,$09,$18,$0B,$78,$0D ; Destination X pixel (bits 0-8), submap (bits 9-12): warps 20-23
$04:84CD .db $68,$02,$C8,$0D,$28,$0D ; Destination X, submap: warps 24-26
;;; $84D3..8503: Table: warp destination Y positions ;;;
;; 27 words: Y pixel position after the warp.
$04:84D3 .db $48,$01,$B8,$00,$38,$00,$18,$00 ; Destination Y pixel: warps 0-3
$04:84DB .db $98,$00,$98,$00,$D8,$01,$78,$00 ; Destination Y pixel: warps 4-7
$04:84E3 .db $38,$00,$08,$01,$E8,$00,$78,$01 ; Destination Y pixel: warps 8-11
$04:84EB .db $88,$01,$28,$01,$88,$01,$E8,$00 ; Destination Y pixel: warps 12-15
$04:84F3 .db $68,$01,$F8,$00,$88,$01,$08,$01 ; Destination Y pixel: warps 16-19
$04:84FB .db $D8,$01,$38,$00,$38,$01,$88,$01 ; Destination Y pixel: warps 20-23
$04:8503 .db $78,$00,$D8,$01,$D8,$01 ; Destination Y: warps 24-26
;;; $8509: Find warp and run overworld process ;;;
;; $048509: finds the warp tile under the player (tables at $8431). Returns: [$1DF6] = index * 2, or
;; negative if none.
;; $04853B (RTL): moves the player to the destination of warp [$1DF6].
;; $048576: runs overworld process [$13D9] through PtrsLong04857D.
;; Called by:
;; $04:9165: Overworld: button pressed on a tile (OWPU_ABXY)
;; $04:9188: Overworld: enter pipe (OWPU_IsOnPipe)
$04:8509 AC B3 0D LDY.W $0DB3 ; \
$04:850C B9 11 1F LDA.W $1F11,Y ; } [$01] = player's submap (high byte of the compare value)
$04:850F 85 01 STA $01 ; /
$04:8511 64 00 STZ $00 ; [$00] = 0
$04:8513 C2 20 REP #$20 ; A 16-bit
$04:8515 AE D6 0D LDX.W $0DD6 ; X = current character * 4 (player position slot)
$04:8518 A0 34 LDY.B #$34 ; Y = $34: last warp index * 2 (27 entries)
$04:851A B9 31 84 LDA.W $8431,Y ; \
$04:851D 45 00 EOR $00 ; / A = warp X tile EOR (submap << 8)
$04:851F C9 00 02 CMP.W #$0200 ; \
$04:8522 B0 0D BCS $8531 ; / Skip if the submap differs (result >= $200)
$04:8524 DD 1F 1F CMP.W $1F1F,X ; \
$04:8527 D0 08 BNE $8531 ; / Warp X tile != player's X tile [$1F1F]: next
$04:8529 BD 21 1F LDA.W $1F21,X ; \
$04:852C D9 67 84 CMP.W $8467,Y ; } Warp Y tile == player's Y tile [$1F21]: found
$04:852F F0 04 BEQ $8535 ; /
$04:8531 88 DEY ; \
$04:8532 88 DEY ; } Next warp; loop until Y < 0
$04:8533 10 E5 BPL $851A ; /
$04:8535 8C F6 1D STY.W $1DF6 ; [$1DF6] = warp index * 2 (negative if none)
$04:8538 E2 20 SEP #$20 ; A 8-bit
$04:853A 60 RTS ; Return
$04:853B 8B PHB ; \
$04:853C 4B PHK ; } Data bank = program bank ($04)
$04:853D AB PLB ; /
$04:853E C2 20 REP #$20 ; A 16-bit
$04:8540 AE D6 0D LDX.W $0DD6 ; X = current character * 4
$04:8543 AC F6 1D LDY.W $1DF6 ; Y = [$1DF6]: warp index * 2
$04:8546 B9 9D 84 LDA.W $849D,Y ; A = destination X word
$04:8549 48 PHA ; Save it for the submap bits
$04:854A 29 FF 01 AND.W #$01FF ; \
$04:854D 9D 17 1F STA.W $1F17,X ; / Player X position = destination X (low 9 bits)
$04:8550 4A LSR ; \
$04:8551 4A LSR ; |
$04:8552 4A LSR ; |
$04:8553 4A LSR ; } Player X tile = X / 16
$04:8554 9D 1F 1F STA.W $1F1F,X ; /
$04:8557 B9 D3 84 LDA.W $84D3,Y ; \
$04:855A 9D 19 1F STA.W $1F19,X ; / Player Y position = destination Y
$04:855D 4A LSR ; \
$04:855E 4A LSR ; |
$04:855F 4A LSR ; |
$04:8560 4A LSR ; } Player Y tile = Y / 16
$04:8561 9D 21 1F STA.W $1F21,X ; /
$04:8564 68 PLA ; Restore the destination word
$04:8565 4A LSR ; \
$04:8566 EB XBA ; |
$04:8567 29 0F 00 AND.W #$000F ; } [$13C3] = bits 9-12 (probably the destination submap)
$04:856A 8D C3 13 STA.W $13C3 ; /
$04:856D C2 10 REP #$10 ; Index 16-bit
$04:856F 20 93 9A JSR.W $9A93 ; Reload position-related data for the new location ($9A93)
$04:8572 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:8574 AB PLB ; Restore the data bank
$04:8575 6B RTL ; Return long
$04:8576 AD D9 13 LDA.W $13D9 ; A = [$13D9]: overworld process number
$04:8579 22 FA 86 00 JSL.L ExecutePtrLong ; Jump to the routine from PtrsLong04857D
;;; $857D: Pointer table: overworld processes (PtrsLong04857D) ;;;
;; 13 long pointers indexed by [$13D9]. The JSR at $0485A4 after the table starts the border code.
$04:857D F1 8E 04 .dw $8EF1 .db :$CODE_048EF1 ; Process 00: $8EF1
$04:8580 70 E5 04 .dw $E570 .db :$CODE_04E570 ; Process 01: $E570
$04:8583 87 8F 04 .dw $8F87 .db :$CODE_048F87 ; Process 02: $8F87
$04:8586 20 91 04 .dw $9120 .db :$CODE_049120 ; Process 03: $9120
$04:8589 5D 94 04 .dw $945D .db :$CODE_04945D ; Process 04: $945D
$04:858C 9A 9D 04 .dw $9D9A .db :$CODE_049D9A ; Process 05: $9D9A
$04:858F 22 9E 04 .dw $9E22 .db :$CODE_049E22 ; Process 06: $9E22
$04:8592 D1 9D 04 .dw $9DD1 .db :$CODE_049DD1 ; Process 07: $9DD1
$04:8595 22 9E 04 .dw $9E22 .db :$CODE_049E22 ; Process 08: $9E22
$04:8598 4C 9E 04 .dw $9E4C .db :$CODE_049E4C ; Process 09: $9E4C
$04:859B EF DA 04 .dw $DAEF .db :$CODE_04DAEF ; Process 0A: $DAEF
$04:859E 52 9E 04 .dw $9E52 .db :$CODE_049E52 ; Process 0B: $9E52
$04:85A1 C6 98 04 .dw $98C6 .db :$CODE_0498C6 ; Process 0C: $98C6
;;; $85A4: Draw border icon and player map sprites (DrawOWBoarder?) ;;;
;; Per-frame overworld sprite drawing. First computes both players' screen positions ($862E), then draws
;; Mario's regular
;; sprite at a fixed spot in the border (probably the player icon) plus a 4x4 block of 8x8 tiles ($7E,
;; property $36) at (24,7),
;; probably its backdrop. The Mario routine is the level one ($E2BD).
;; $04862E: hides off-screen players (Y = $F0), applies the sprite offsets (-8, -9; walking poses 5 pixels
;; higher than swimming
;; ones), draws the current player and, in a two player game on the same submap, the other one with
;; $894F, and clears their
;; OAM size bits. $048789: if the player's lives are negative (out of lives), draws a 2-tile marker above the
;; map sprite.
;; Parameters of $048789: X = OAM offset (0 or $20), [$04] = palette offset, [$8A]/[$8B] = sprite position.
;; Called by:
;; $04:8EE8: Overworld setup and process 0 (level exit)
$04:85A4 20 2E 86 JSR.W $862E ; Compute screen positions and draw both players' map sprites ($862E)
$04:85A7 C2 20 REP #$20 ; A = 16-bit
$04:85A9 A9 1E 00 LDA.W #$001E ; \
$04:85AC 18 CLC ; |
$04:85AD 65 1A ADC RAM_ScreenBndryXLo ; } Mario X = screen X + $1E (fixed spot in the border)
$04:85AF 85 94 STA RAM_MarioXPos ; /
$04:85B1 A9 06 00 LDA.W #$0006 ; \
$04:85B4 18 CLC ; |
$04:85B5 65 1C ADC RAM_ScreenBndryYLo ; } Mario Y = screen Y + 6
$04:85B7 85 96 STA RAM_MarioYPos ; /
$04:85B9 E2 20 SEP #$20 ; A = 8-bit
$04:85BB A9 08 LDA.B #$08 ; \
$04:85BD 8D 7B 00 STA.W RAM_MarioSpeedX ; / Mario X speed = 8 (probably sets the walk animation rate)
$04:85C0 8B PHB ; \
$04:85C1 A9 00 LDA.B #$00 ; |
$04:85C3 48 PHA ; } Data bank = $00 (old bank saved)
$04:85C4 AB PLB ; /
$04:85C5 22 B1 CE 00 JSL.L $CEB1 ; Update Mario's pose/cape animation ($CEB1)
$04:85C9 AB PLB ; Restore the data bank
$04:85CA A9 03 LDA.B #$03 ; \
$04:85CC 8D F9 13 STA.W RAM_IsBehindScenery ; / [$13F9] = 3: Mario sprite priority flags (probably so he draws over the border)
$04:85CF 22 BD E2 00 JSL.L $E2BD ; Draw Mario's sprite at that spot ($E2BD)
$04:85D3 A9 06 LDA.B #$06 ; \
$04:85D5 8D 84 0D STA.W $0D84 ; / [$0D84] = 6: Mario GFX DMA segment count (probably)
$04:85D8 AD 96 14 LDA.W $1496 ; \
$04:85DB F0 03 BEQ $85E0 ; } Count down the Mario animation timer [$1496] if non-zero
$04:85DD CE 96 14 DEC.W $1496 ; /
$04:85E0 AD A2 14 LDA.W $14A2 ; \
$04:85E3 F0 03 BEQ $85E8 ; } Count down [$14A2] (cape animation timer) if non-zero
$04:85E5 CE A2 14 DEC.W $14A2 ; /
$04:85E8 A9 18 LDA.B #$18 ; \
$04:85EA 85 00 STA $00 ; / [$00] = $18: X of the first backdrop tile
$04:85EC A9 07 LDA.B #$07 ; \
$04:85EE 85 01 STA $01 ; / [$01] = $07: Y of the first backdrop tile
$04:85F0 A0 00 LDY.B #$00 ; Y = 0: tile counter (16 tiles in a 4x4 block)
$04:85F2 BB TYX ; X = 0: OAM offset, starting at sprite slot 0
$04:85F3 A5 00 LDA $00 ; \
$04:85F5 9D 00 02 STA.W OAM_ExtendedDispX,X ; / OAM X = [$00]
$04:85F8 18 CLC ; \
$04:85F9 69 08 ADC.B #$08 ; } [$00] += 8: next tile to the right
$04:85FB 85 00 STA $00 ; /
$04:85FD A5 01 LDA $01 ; \
$04:85FF 9D 01 02 STA.W OAM_ExtendedDispY,X ; / OAM Y = [$01]
$04:8602 A9 7E LDA.B #$7E ; \
$04:8604 9D 02 02 STA.W OAM_ExtendedTile,X ; / OAM tile = $7E
$04:8607 A9 36 LDA.B #$36 ; \
$04:8609 9D 03 02 STA.W OAM_ExtendedProp,X ; / OAM property = $36 (priority 3, palette 3)
$04:860C DA PHX ; \
$04:860D BB TYX ; |
$04:860E A9 00 LDA.B #$00 ; |
$04:8610 9D 20 04 STA.W $0420,X ; } Size/X-high entry [$0420+tile counter] = 0 (8x8, X < 256)
$04:8613 FA PLX ; /
$04:8614 C8 INY ; Next tile
$04:8615 98 TYA ; \
$04:8616 29 03 AND.B #$03 ; } If not at the end of a row of 4, skip the row advance
$04:8618 D0 0B BNE $8625 ; /
$04:861A A9 18 LDA.B #$18 ; \
$04:861C 85 00 STA $00 ; / [$00] = $18: X back to the left edge
$04:861E A5 01 LDA $01 ; \
$04:8620 18 CLC ; |
$04:8621 69 08 ADC.B #$08 ; } [$01] += 8: next row down
$04:8623 85 01 STA $01 ; /
$04:8625 E8 INX ; \
$04:8626 E8 INX ; |
$04:8627 E8 INX ; } X += 4: next OAM slot
$04:8628 E8 INX ; /
$04:8629 C0 10 CPY.B #$10 ; \
$04:862B D0 C6 BNE $85F3 ; / Loop for all 16 tiles
$04:862D 60 RTS ; Return
$04:862E C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8630 AE D6 0D LDX.W $0DD6 ; \
$04:8633 BD 17 1F LDA.W $1F17,X ; / A = current player's map X ([$1F17], X = [$0DD6]: 0 Mario, 4 Luigi)
$04:8636 38 SEC ; \
$04:8637 E5 1A SBC RAM_ScreenBndryXLo ; / A = map X - screen X
$04:8639 C9 00 01 CMP.W #$0100 ; \
$04:863C B0 0F BCS $864D ; / If >= $100 (off-screen), go hide the sprite at $04864D
$04:863E 85 00 STA $00 ; \
$04:8640 85 08 STA $08 ; / Store the screen X in [$00] and [$08]
$04:8642 BD 19 1F LDA.W $1F19,X ; \
$04:8645 38 SEC ; |
$04:8646 E5 1C SBC RAM_ScreenBndryYLo ; |
$04:8648 C9 00 01 CMP.W #$0100 ; } A = map Y - screen Y; if >= $100 go hide it, else keep it
$04:864B 90 03 BCC $8650 ; /
$04:864D A9 F0 00 LDA.W #$00F0 ; Off-screen: Y = $F0 (hides the sprite)
$04:8650 85 02 STA $02 ; \
$04:8652 85 0A STA $0A ; / Store the screen Y in [$02] and [$0A]
$04:8654 8A TXA ; \
$04:8655 49 04 00 EOR.W #$0004 ; } X = other player's index (0 <-> 4)
$04:8658 AA TAX ; /
$04:8659 BD 17 1F LDA.W $1F17,X ; \
$04:865C 38 SEC ; |
$04:865D E5 1A SBC RAM_ScreenBndryXLo ; |
$04:865F C9 00 01 CMP.W #$0100 ; } A = other player's screen X; if >= $100 go hide it at $048673
$04:8662 B0 0F BCS $8673 ; /
$04:8664 85 04 STA $04 ; \
$04:8666 85 0C STA $0C ; / Store the screen X in [$04] and [$0C]
$04:8668 BD 19 1F LDA.W $1F19,X ; \
$04:866B 38 SEC ; |
$04:866C E5 1C SBC RAM_ScreenBndryYLo ; |
$04:866E C9 00 01 CMP.W #$0100 ; } A = other player's screen Y; if >= $100 go hide it
$04:8671 90 03 BCC $8676 ; /
$04:8673 A9 F0 00 LDA.W #$00F0 ; Off-screen: Y = $F0
$04:8676 85 06 STA $06 ; \
$04:8678 85 0E STA $0E ; / Store the screen Y in [$06] and [$0E]
$04:867A E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:867C A5 00 LDA $00 ; \
$04:867E 38 SEC ; |
$04:867F E9 08 SBC.B #$08 ; } [$00] = player sprite X = screen X - 8
$04:8681 85 00 STA $00 ; /
$04:8683 A5 02 LDA $02 ; \
$04:8685 38 SEC ; |
$04:8686 E9 09 SBC.B #$09 ; } [$01] = player sprite Y = screen Y - 9
$04:8688 85 01 STA $01 ; /
$04:868A A5 04 LDA $04 ; \
$04:868C 38 SEC ; |
$04:868D E9 08 SBC.B #$08 ; } [$02] = other player's sprite X = screen X - 8
$04:868F 85 02 STA $02 ; /
$04:8691 A5 06 LDA $06 ; \
$04:8693 38 SEC ; |
$04:8694 E9 09 SBC.B #$09 ; } [$03] = other player's sprite Y = screen Y - 9
$04:8696 85 03 STA $03 ; /
$04:8698 A9 03 LDA.B #$03 ; \
$04:869A 85 8C STA $8C ; / [$8C] = 3: tile counter for a 2x2 sprite
$04:869C A5 00 LDA $00 ; \
$04:869E 85 06 STA $06 ; } [$06] and [$8A] = X of the first tile
$04:86A0 85 8A STA $8A ; /
$04:86A2 A5 01 LDA $01 ; \
$04:86A4 85 07 STA $07 ; } [$07] and [$8B] = Y of the first tile
$04:86A6 85 8B STA $8B ; /
$04:86A8 AD D6 0D LDA.W $0DD6 ; \
$04:86AB 4A LSR ; |
$04:86AC A8 TAY ; } A = current player's pose ([$1F13] or [$1F15])
$04:86AD B9 13 1F LDA.W $1F13,Y ; /
$04:86B0 C9 12 CMP.B #$12 ; \
$04:86B2 F0 11 BEQ $86C5 ; / Pose $12 (swimming): no Y shift, go to $0486C5
$04:86B4 C9 07 CMP.B #$07 ; \
$04:86B6 90 04 BCC $86BC ; / Pose < 7 (walking): go shift Y
$04:86B8 C9 0F CMP.B #$0F ; \
$04:86BA 90 09 BCC $86C5 ; / Poses 7-$0E (swimming): no Y shift, go to $0486C5
$04:86BC A5 8B LDA $8B ; \
$04:86BE 38 SEC ; |
$04:86BF E9 05 SBC.B #$05 ; |
$04:86C1 85 8B STA $8B ; } Walking poses are drawn 5 pixels higher: [$8B] and [$07] -= 5
$04:86C3 85 07 STA $07 ; /
$04:86C5 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:86C7 AD D6 0D LDA.W $0DD6 ; \
$04:86CA EB XBA ; |
$04:86CB 4A LSR ; } [$04] = $0000 for Mario, $0200 for Luigi (+1 to the OAM palette)
$04:86CC 85 04 STA $04 ; /
$04:86CE A2 00 00 LDX.W #$0000 ; X = 0: OAM offset of the first player's sprites (slot 39)
$04:86D1 20 89 87 JSR.W $8789 ; Draw the out-of-lives marker if needed ($8789)
$04:86D4 AD D6 0D LDA.W $0DD6 ; \
$04:86D7 4A LSR ; } Y = player index * 2 (pose table index)
$04:86D8 A8 TAY ; /
$04:86D9 A2 00 00 LDX.W #$0000 ; X = 0: OAM offset
$04:86DC 20 4F 89 JSR.W $894F ; Draw the player's map sprite ($894F)
$04:86DF E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:86E1 9C 47 04 STZ.W $0447 ; \
$04:86E4 9C 48 04 STZ.W $0448 ; |
$04:86E7 9C 49 04 STZ.W $0449 ; |
$04:86EA 9C 4A 04 STZ.W $044A ; |
$04:86ED 9C 4B 04 STZ.W $044B ; |
$04:86F0 9C 4C 04 STZ.W $044C ; |
$04:86F3 9C 4D 04 STZ.W $044D ; } Size/X-high entries of OAM slots 39-46 = 0 (8x8, X < 256)
$04:86F6 9C 4E 04 STZ.W $044E ; /
$04:86F9 A9 03 LDA.B #$03 ; \
$04:86FB 85 8C STA $8C ; / [$8C] = 3: tile counter for a 2x2 sprite
$04:86FD AD 11 1F LDA.W $1F11 ; A = Mario's submap [$1F11]
$04:8700 AC D9 13 LDY.W $13D9 ; \
$04:8703 C0 0A CPY.B #$0A ; } If OW process [$13D9] = $0A (player switch) do the next line
$04:8705 D0 02 BNE $8709 ; /
$04:8707 49 01 EOR.B #$01 ; Flip bit 0 of the submap (probably accounts for the player switch)
$04:8709 CD 12 1F CMP.W $1F12 ; \
$04:870C D0 78 BNE $8786 ; / Draw the second player only if both are on the same submap
$04:870E A5 02 LDA $02 ; \
$04:8710 85 06 STA $06 ; } [$06] and [$8A] = second player's sprite X
$04:8712 85 8A STA $8A ; /
$04:8714 A5 03 LDA $03 ; \
$04:8716 85 07 STA $07 ; } [$07] and [$8B] = second player's sprite Y
$04:8718 85 8B STA $8B ; /
$04:871A AD D6 0D LDA.W $0DD6 ; \
$04:871D 4A LSR ; |
$04:871E 49 02 EOR.B #$02 ; } Y = other player's index * 2
$04:8720 A8 TAY ; /
$04:8721 B9 13 1F LDA.W $1F13,Y ; \
$04:8724 C9 12 CMP.B #$12 ; } A = other player's pose; pose $12 (swimming): no Y shift
$04:8726 F0 11 BEQ $8739 ; /
$04:8728 C9 07 CMP.B #$07 ; \
$04:872A 90 04 BCC $8730 ; / Pose < 7 (walking): go shift Y
$04:872C C9 0F CMP.B #$0F ; \
$04:872E 90 09 BCC $8739 ; / Poses 7-$0E (swimming): no Y shift
$04:8730 A5 8B LDA $8B ; \
$04:8732 38 SEC ; |
$04:8733 E9 05 SBC.B #$05 ; |
$04:8735 85 8B STA $8B ; } Walking poses are drawn 5 pixels higher: [$8B] and [$07] -= 5
$04:8737 85 07 STA $07 ; /
$04:8739 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:873B AD B2 0D LDA.W $0DB2 ; \
$04:873E 29 FF 00 AND.W #$00FF ; } [$0DB2] = 0 (one player game): skip the second player
$04:8741 F0 43 BEQ $8786 ; /
$04:8743 A5 0C LDA $0C ; \
$04:8745 C9 F0 00 CMP.W #$00F0 ; } Second player's X >= $F0 (off-screen): skip
$04:8748 B0 3C BCS $8786 ; /
$04:874A A5 0E LDA $0E ; \
$04:874C C9 F0 00 CMP.W #$00F0 ; } Second player's Y >= $F0 (off-screen): skip
$04:874F B0 35 BCS $8786 ; /
$04:8751 A5 04 LDA $04 ; \
$04:8753 49 00 02 EOR.W #$0200 ; } [$04] ^= $0200: palette offset of the other player
$04:8756 85 04 STA $04 ; /
$04:8758 A2 20 00 LDX.W #$0020 ; X = $20: OAM offset of the second player's sprites (slot 47)
$04:875B 20 89 87 JSR.W $8789 ; Draw the out-of-lives marker if needed ($8789)
$04:875E AD D6 0D LDA.W $0DD6 ; \
$04:8761 4A LSR ; |
$04:8762 49 02 00 EOR.W #$0002 ; } Y = other player's index * 2
$04:8765 A8 TAY ; /
$04:8766 A2 20 00 LDX.W #$0020 ; X = $20: OAM offset
$04:8769 20 4F 89 JSR.W $894F ; Draw the player's map sprite ($894F)
$04:876C E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:876E 9C 4F 04 STZ.W $044F ; \
$04:8771 9C 50 04 STZ.W $0450 ; |
$04:8774 9C 51 04 STZ.W $0451 ; |
$04:8777 9C 52 04 STZ.W $0452 ; |
$04:877A 9C 53 04 STZ.W $0453 ; |
$04:877D 9C 54 04 STZ.W $0454 ; |
$04:8780 9C 55 04 STZ.W $0455 ; } Size/X-high entries of OAM slots 47-54 = 0 (8x8, X < 256)
$04:8783 9C 56 04 STZ.W $0456 ; /
$04:8786 E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8788 60 RTS ; Return
$04:8789 A5 8A LDA $8A ; \
$04:878B 48 PHA ; / Save [$8A] (sprite X)
$04:878C DA PHX ; Save X (OAM offset)
$04:878D A5 04 LDA $04 ; \
$04:878F EB XBA ; |
$04:8790 4A LSR ; } X = player index (0 Mario, 1 Luigi) from the palette offset [$04]
$04:8791 AA TAX ; /
$04:8792 BD B3 0D LDA.W $0DB3,X ; Read the player's lives byte ([$0DB4]/[$0DB5]) into the high byte
$04:8795 FA PLX ; Restore X
$04:8796 29 00 FF AND.W #$FF00 ; \
$04:8799 10 2C BPL $87C7 ; / Lives >= 0: no marker, go to $0487C7
$04:879B E2 20 SEP #$20 ; A = 8-bit
$04:879D A5 8A LDA $8A ; \
$04:879F 9D B4 02 STA.W $02B4,X ; / Marker 1 X = [$8A]
$04:87A2 18 CLC ; \
$04:87A3 69 08 ADC.B #$08 ; } Marker 2 X = [$8A] + 8
$04:87A5 9D B8 02 STA.W $02B8,X ; /
$04:87A8 A5 8B LDA $8B ; \
$04:87AA 18 CLC ; |
$04:87AB 69 F9 ADC.B #$F9 ; |
$04:87AD 9D B5 02 STA.W $02B5,X ; } Both markers: Y = [$8B] - 7
$04:87B0 9D B9 02 STA.W $02B9,X ; /
$04:87B3 A9 7C LDA.B #$7C ; \
$04:87B5 9D B6 02 STA.W $02B6,X ; } Both markers: tile $7C
$04:87B8 9D BA 02 STA.W $02BA,X ; /
$04:87BB A9 20 LDA.B #$20 ; \
$04:87BD 9D B7 02 STA.W $02B7,X ; / Marker 1 property = $20 (priority 2, palette 0)
$04:87C0 A9 60 LDA.B #$60 ; \
$04:87C2 9D BB 02 STA.W $02BB,X ; / Marker 2 property = $60 (same, X-flipped)
$04:87C5 C2 20 REP #$20 ; A = 16-bit
$04:87C7 68 PLA ; \
$04:87C8 85 8A STA $8A ; / Restore [$8A]
$04:87CA 60 RTS ; Return
;;; $87CB..8943: Table: player map sprite tiles ;;;
;; 12 poses of $20 bytes: 4 animation frames x 4 tiles (top-left, top-right, bottom-left, bottom-right), each
;; tile = tile number,
;; property. Index = pose ([$1F13]/[$1F15], always even) * 16 + frame * 8, frame = [$13] bits 3-4. Poses $08,
;; $0A, $0C, $0E and $12
;; have water tiles $38/$39 instead of legs (swimming). Property $24 = palette 2, priority 2; bit 6 = X flip.
$04:87CB .db $0E,$24,$0F,$24,$1E,$24,$1F,$24 ; Pose $00, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:87D3 .db $20,$24,$21,$24,$30,$24,$31,$24 ; Pose $00, frame 1
$04:87DB .db $0E,$24,$0F,$24,$1E,$24,$1F,$24 ; Pose $00, frame 2
$04:87E3 .db $20,$24,$21,$24,$31,$64,$30,$64 ; Pose $00, frame 3
$04:87EB .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $02, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:87F3 .db $0C,$24,$0D,$24,$1C,$24,$1D,$24 ; Pose $02, frame 1
$04:87FB .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $02, frame 2
$04:8803 .db $0C,$24,$0D,$24,$1D,$64,$1C,$64 ; Pose $02, frame 3
$04:880B .db $08,$24,$09,$24,$18,$24,$19,$24 ; Pose $04, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:8813 .db $06,$24,$07,$24,$16,$24,$17,$24 ; Pose $04, frame 1
$04:881B .db $08,$24,$09,$24,$18,$24,$19,$24 ; Pose $04, frame 2
$04:8823 .db $06,$24,$07,$24,$16,$24,$17,$24 ; Pose $04, frame 3
$04:882B .db $09,$64,$08,$64,$19,$64,$18,$64 ; Pose $06, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:8833 .db $07,$64,$06,$64,$17,$64,$16,$64 ; Pose $06, frame 1
$04:883B .db $09,$64,$08,$64,$19,$64,$18,$64 ; Pose $06, frame 2
$04:8843 .db $07,$64,$06,$64,$17,$64,$16,$64 ; Pose $06, frame 3
$04:884B .db $0E,$24,$0F,$24,$38,$24,$38,$64 ; Pose $08, frame 0 (swimming): tiles TL, TR, BL, BR (tile, property)
$04:8853 .db $20,$24,$21,$24,$39,$24,$39,$64 ; Pose $08, frame 1 (swimming)
$04:885B .db $0E,$24,$0F,$24,$38,$24,$38,$64 ; Pose $08, frame 2 (swimming)
$04:8863 .db $20,$24,$21,$24,$39,$24,$39,$64 ; Pose $08, frame 3 (swimming)
$04:886B .db $0A,$24,$0B,$24,$38,$24,$38,$64 ; Pose $0A, frame 0 (swimming): tiles TL, TR, BL, BR (tile, property)
$04:8873 .db $0C,$24,$0D,$24,$39,$24,$39,$64 ; Pose $0A, frame 1 (swimming)
$04:887B .db $0A,$24,$0B,$24,$38,$24,$38,$64 ; Pose $0A, frame 2 (swimming)
$04:8883 .db $0C,$24,$0D,$24,$39,$24,$39,$64 ; Pose $0A, frame 3 (swimming)
$04:888B .db $08,$24,$09,$24,$38,$24,$38,$64 ; Pose $0C, frame 0 (swimming): tiles TL, TR, BL, BR (tile, property)
$04:8893 .db $06,$24,$07,$24,$39,$24,$39,$64 ; Pose $0C, frame 1 (swimming)
$04:889B .db $08,$24,$09,$24,$38,$24,$38,$64 ; Pose $0C, frame 2 (swimming)
$04:88A3 .db $06,$24,$07,$24,$39,$24,$39,$64 ; Pose $0C, frame 3 (swimming)
$04:88AB .db $09,$64,$08,$64,$38,$24,$38,$64 ; Pose $0E, frame 0 (swimming): tiles TL, TR, BL, BR (tile, property)
$04:88B3 .db $07,$64,$06,$64,$39,$24,$39,$64 ; Pose $0E, frame 1 (swimming)
$04:88BB .db $09,$64,$08,$64,$38,$24,$38,$64 ; Pose $0E, frame 2 (swimming)
$04:88C3 .db $07,$64,$06,$64,$39,$24,$39,$64 ; Pose $0E, frame 3 (swimming)
$04:88CB .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:88D3 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 1
$04:88DB .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 2
$04:88E3 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 3
$04:88EB .db $24,$24,$25,$24,$38,$24,$38,$64 ; Pose $12, frame 0 (swimming): tiles TL, TR, BL, BR (tile, property)
$04:88F3 .db $24,$24,$25,$24,$38,$24,$38,$64 ; Pose $12, frame 1 (swimming)
$04:88FB .db $24,$24,$25,$24,$38,$24,$38,$64 ; Pose $12, frame 2 (swimming)
$04:8903 .db $24,$24,$25,$24,$38,$24,$38,$64 ; Pose $12, frame 3 (swimming)
$04:890B .db $46,$24,$47,$24,$56,$24,$57,$24 ; Pose $14, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:8913 .db $47,$64,$46,$64,$57,$64,$56,$64 ; Pose $14, frame 1
$04:891B .db $46,$24,$47,$24,$56,$24,$57,$24 ; Pose $14, frame 2
$04:8923 .db $47,$64,$46,$64,$57,$64,$56,$64 ; Pose $14, frame 3
$04:892B .db $46,$24,$47,$24,$56,$24,$57,$24 ; Pose $16, frame 0: tiles TL, TR, BL, BR (tile, property)
$04:8933 .db $47,$64,$46,$64,$57,$64,$56,$64 ; Pose $16, frame 1
$04:893B .db $46,$24,$47,$24,$56,$24,$57,$24 ; Pose $16, frame 2
$04:8943 .db $47,$64,$46,$64,$57,$64,$56,$64 ; Pose $16, frame 3
;;; $894B..894B: Table: facing cycle offsets ;;;
;; Offsets into the tile tables used while OW process [$13D9] = $0B: pose $02, $06, $00, $04 (index = [$13]
;; bits 2-3).
$04:894B .db $20,$60,$00,$40 ; Pose offsets $20, $60, $00, $40 (poses $02, $06, $00, $04): facing cycle
;;; $894F: Draw player map sprite (2x2 tiles) ;;;
;; Draws one player's 4-tile map sprite into OAM from $87CB, or jumps to $8CE6 if the player has a
;; Yoshi.
;; Parameters: Y = player index * 2, X = OAM offset into $029C (0 first player, $20 second), [$04] =
;; $0000/$0200 palette offset
;; (Luigi = +1), [$8A]/[$8B] = sprite X/Y, [$06] = X of the left edge. A player out of lives is not animated.
;; Called by:
;; $04:86DC: Draw border icon and player map sprites (DrawOWBoarder?)
;; $04:8769: Draw border icon and player map sprites (DrawOWBoarder?)
$04:894F E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8951 5A PHY ; Save Y (pose table index)
$04:8952 98 TYA ; \
$04:8953 4A LSR ; } Y = player index (0 Mario, 1 Luigi)
$04:8954 A8 TAY ; /
$04:8955 B9 BA 0D LDA.W RAM_PlyrYoshiColor,Y ; \
$04:8958 F0 08 BEQ $8962 ; / A = Yoshi color for this player; 0 = no Yoshi, go to $048962
$04:895A 85 0E STA $0E ; \
$04:895C 64 0F STZ $0F ; / [$0E] = Yoshi color (16-bit)
$04:895E 7A PLY ; Restore Y
$04:895F 4C E6 8C JMP.W $8CE6 ; Draw the player riding Yoshi ($8CE6)
$04:8962 7A PLY ; Restore Y
$04:8963 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8965 B9 13 1F LDA.W $1F13,Y ; \
$04:8968 0A ASL ; |
$04:8969 0A ASL ; |
$04:896A 0A ASL ; |
$04:896B 0A ASL ; } [$00] = pose * 16: offset of this pose in the tile table
$04:896C 85 00 STA $00 ; /
$04:896E A5 13 LDA RAM_FrameCounter ; \
$04:8970 29 18 00 AND.W #$0018 ; |
$04:8973 18 CLC ; |
$04:8974 65 00 ADC $00 ; } Y = pose offset + animation frame * 8 (frame advances every 8 frames)
$04:8976 A8 TAY ; /
$04:8977 DA PHX ; Save X (OAM offset)
$04:8978 A5 04 LDA $04 ; \
$04:897A EB XBA ; |
$04:897B 4A LSR ; } X = player index from the palette offset [$04]
$04:897C AA TAX ; /
$04:897D BD B3 0D LDA.W $0DB3,X ; Read the player's lives byte into the high byte
$04:8980 FA PLX ; Restore X
$04:8981 29 00 FF AND.W #$FF00 ; \
$04:8984 10 05 BPL $898B ; / Lives >= 0: animate normally, go to $04898B
$04:8986 A5 00 LDA $00 ; \
$04:8988 A8 TAY ; } Out of lives: Y = pose * 16, no animation
$04:8989 80 1C BRA $89A7 ; /
$04:898B E0 00 00 CPX.W #$0000 ; \
$04:898E D0 17 BNE $89A7 ; / Only for the first player's sprite (X = 0)
$04:8990 AD D9 13 LDA.W $13D9 ; \
$04:8993 C9 0B 00 CMP.W #$000B ; } Only while OW process [$13D9] = $0B (probably a turn-around spin)
$04:8996 D0 0F BNE $89A7 ; /
$04:8998 A5 13 LDA RAM_FrameCounter ; \
$04:899A 29 0C 00 AND.W #$000C ; |
$04:899D 4A LSR ; |
$04:899E 4A LSR ; |
$04:899F A8 TAY ; |
$04:89A0 B9 4B 89 LDA.W $894B,Y ; |
$04:89A3 29 FF 00 AND.W #$00FF ; } Y = facing offset from $894B, changes every 4 frames
$04:89A6 A8 TAY ; /
$04:89A7 C2 20 REP #$20 ; A = 16-bit
$04:89A9 A5 8A LDA $8A ; \
$04:89AB 9D 9C 02 STA.W $029C,X ; / OAM X and Y of this tile = [$8A] and [$8B]
$04:89AE B9 CB 87 LDA.W $87CB,Y ; \
$04:89B1 18 CLC ; |
$04:89B2 65 04 ADC $04 ; } OAM tile and property = [DATA_0487CB+Y] + [$04] (Luigi palette)
$04:89B4 9D 9E 02 STA.W $029E,X ; /
$04:89B7 E2 20 SEP #$20 ; A = 8-bit
$04:89B9 E8 INX ; \
$04:89BA E8 INX ; |
$04:89BB E8 INX ; } X += 4: next OAM slot
$04:89BC E8 INX ; /
$04:89BD C8 INY ; \
$04:89BE C8 INY ; / Y += 2: next tile word
$04:89BF A5 8A LDA $8A ; \
$04:89C1 18 CLC ; |
$04:89C2 69 08 ADC.B #$08 ; } [$8A] += 8: next tile to the right
$04:89C4 85 8A STA $8A ; /
$04:89C6 C6 8C DEC $8C ; \
$04:89C8 A5 8C LDA $8C ; |
$04:89CA 29 01 AND.B #$01 ; } Tile counter--; after every second tile start a new row
$04:89CC F0 0B BEQ $89D9 ; /
$04:89CE A5 06 LDA $06 ; \
$04:89D0 85 8A STA $8A ; / [$8A] = [$06]: back to the left edge
$04:89D2 A5 8B LDA $8B ; \
$04:89D4 18 CLC ; |
$04:89D5 69 08 ADC.B #$08 ; } [$8B] += 8: next row down
$04:89D7 85 8B STA $8B ; /
$04:89D9 A5 8C LDA $8C ; \
$04:89DB 10 CA BPL $89A7 ; / Loop until all 4 tiles are drawn
$04:89DD 60 RTS ; Return
;;; $89DE..8B56: Table: Yoshi rider sprite tiles ;;;
;; 12 poses x 2 frames x 8 tiles (tile number, property): two groups of 4 per frame (rider and Yoshi, order
;; varies by pose).
;; $FFFF = unused slot. Tiles with palette bits 1 ($0200) are Yoshi's and get recolored by $8CDE. Index
;; = pose * 16 + frame * $10.
$04:89DE .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $00, frame 0: tiles 0-3 (tile, property)
$04:89E6 .db $2F,$62,$2E,$62,$3F,$62,$3E,$62 ; Pose $00, frame 0: tiles 4-7 (tile, property)
$04:89EE .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $00, frame 1: tiles 0-3 (tile, property)
$04:89F6 .db $2E,$22,$2F,$22,$3E,$22,$3F,$22 ; Pose $00, frame 1: tiles 4-7 (tile, property)
$04:89FE .db $2F,$62,$2E,$62,$3F,$62,$3E,$62 ; Pose $02, frame 0: tiles 0-3 (tile, property)
$04:8A06 .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $02, frame 0: tiles 4-7 (tile, property)
$04:8A0E .db $2E,$22,$2F,$22,$3E,$22,$3F,$22 ; Pose $02, frame 1: tiles 0-3 (tile, property)
$04:8A16 .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $02, frame 1: tiles 4-7 (tile, property)
$04:8A1E .db $64,$24,$65,$24,$74,$24,$75,$24 ; Pose $04, frame 0: tiles 0-3 (tile, property)
$04:8A26 .db $40,$22,$41,$22,$50,$22,$51,$22 ; Pose $04, frame 0: tiles 4-7 (tile, property)
$04:8A2E .db $64,$24,$65,$24,$74,$24,$75,$24 ; Pose $04, frame 1: tiles 0-3 (tile, property)
$04:8A36 .db $42,$22,$43,$24,$52,$24,$53,$24 ; Pose $04, frame 1: tiles 4-7 (tile, property)
$04:8A3E .db $65,$64,$64,$64,$75,$64,$74,$64 ; Pose $06, frame 0: tiles 0-3 (tile, property)
$04:8A46 .db $41,$62,$40,$62,$51,$62,$50,$62 ; Pose $06, frame 0: tiles 4-7 (tile, property)
$04:8A4E .db $65,$64,$64,$64,$75,$64,$74,$64 ; Pose $06, frame 1: tiles 0-3 (tile, property)
$04:8A56 .db $43,$62,$42,$62,$53,$62,$52,$62 ; Pose $06, frame 1: tiles 4-7 (tile, property)
$04:8A5E .db $38,$24,$38,$64,$66,$24,$67,$24 ; Pose $08, frame 0: tiles 0-3 (tile, property)
$04:8A66 .db $76,$24,$77,$24,$FF,$FF,$FF,$FF ; Pose $08, frame 0: tiles 4-7 (tile, property)
$04:8A6E .db $39,$24,$39,$64,$66,$24,$67,$24 ; Pose $08, frame 1: tiles 0-3 (tile, property)
$04:8A76 .db $76,$24,$77,$24,$FF,$FF,$FF,$FF ; Pose $08, frame 1: tiles 4-7 (tile, property)
$04:8A7E .db $38,$24,$38,$64,$2F,$62,$2E,$62 ; Pose $0A, frame 0: tiles 0-3 (tile, property)
$04:8A86 .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $0A, frame 0: tiles 4-7 (tile, property)
$04:8A8E .db $39,$24,$39,$24,$2E,$22,$2F,$22 ; Pose $0A, frame 1: tiles 0-3 (tile, property)
$04:8A96 .db $0A,$24,$0B,$24,$1A,$24,$1B,$24 ; Pose $0A, frame 1: tiles 4-7 (tile, property)
$04:8A9E .db $38,$24,$38,$64,$64,$24,$65,$24 ; Pose $0C, frame 0: tiles 0-3 (tile, property)
$04:8AA6 .db $74,$24,$75,$24,$40,$22,$41,$22 ; Pose $0C, frame 0: tiles 4-7 (tile, property)
$04:8AAE .db $39,$24,$39,$64,$64,$24,$65,$24 ; Pose $0C, frame 1: tiles 0-3 (tile, property)
$04:8AB6 .db $74,$24,$75,$24,$42,$22,$42,$22 ; Pose $0C, frame 1: tiles 4-7 (tile, property)
$04:8ABE .db $38,$24,$38,$64,$65,$64,$64,$64 ; Pose $0E, frame 0: tiles 0-3 (tile, property)
$04:8AC6 .db $75,$64,$74,$64,$41,$62,$40,$62 ; Pose $0E, frame 0: tiles 4-7 (tile, property)
$04:8ACE .db $39,$24,$39,$64,$65,$64,$64,$64 ; Pose $0E, frame 1: tiles 0-3 (tile, property)
$04:8AD6 .db $75,$64,$74,$64,$43,$62,$42,$62 ; Pose $0E, frame 1: tiles 4-7 (tile, property)
$04:8ADE .db $2F,$62,$2E,$62,$3F,$62,$3E,$62 ; Pose $10, frame 0: tiles 0-3 (tile, property)
$04:8AE6 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 0: tiles 4-7 (tile, property)
$04:8AEE .db $2E,$22,$2F,$22,$3E,$22,$3F,$22 ; Pose $10, frame 1: tiles 0-3 (tile, property)
$04:8AF6 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $10, frame 1: tiles 4-7 (tile, property)
$04:8AFE .db $38,$24,$38,$64,$2F,$62,$2E,$62 ; Pose $12, frame 0: tiles 0-3 (tile, property)
$04:8B06 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $12, frame 0: tiles 4-7 (tile, property)
$04:8B0E .db $39,$24,$39,$64,$2E,$22,$2F,$22 ; Pose $12, frame 1: tiles 0-3 (tile, property)
$04:8B16 .db $24,$24,$25,$24,$34,$24,$35,$24 ; Pose $12, frame 1: tiles 4-7 (tile, property)
$04:8B1E .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $14, frame 0: tiles 0-3 (tile, property)
$04:8B26 .db $2F,$62,$2E,$62,$3F,$62,$3E,$62 ; Pose $14, frame 0: tiles 4-7 (tile, property)
$04:8B2E .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $14, frame 1: tiles 0-3 (tile, property)
$04:8B36 .db $2E,$22,$2F,$22,$3E,$22,$3F,$22 ; Pose $14, frame 1: tiles 4-7 (tile, property)
$04:8B3E .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $16, frame 0: tiles 0-3 (tile, property)
$04:8B46 .db $2F,$62,$2E,$62,$3F,$62,$3E,$62 ; Pose $16, frame 0: tiles 4-7 (tile, property)
$04:8B4E .db $66,$24,$67,$24,$76,$24,$77,$24 ; Pose $16, frame 1: tiles 0-3 (tile, property)
$04:8B56 .db $2E,$22,$2F,$22,$3E,$22,$3F,$22 ; Pose $16, frame 1: tiles 4-7 (tile, property)
;;; $8B5E..8C16: Table: Yoshi sprite X offsets ;;;
;; One byte per tile (8 per frame, 2 frames per pose): X offset added to [$8A]. Index = (pose * 16 + frame *
;; $10) / 2.
$04:8B5E .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $00, frame 0: X offsets of tiles 0-7
$04:8B66 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $00, frame 1: X offsets of tiles 0-7
$04:8B6E .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $02, frame 0: X offsets of tiles 0-7
$04:8B76 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $02, frame 1: X offsets of tiles 0-7
$04:8B7E .db $07,$0F,$07,$0F,$00,$08,$00,$08 ; Pose $04, frame 0: X offsets of tiles 0-7
$04:8B86 .db $07,$0F,$07,$0F,$00,$08,$00,$08 ; Pose $04, frame 1: X offsets of tiles 0-7
$04:8B8E .db $F9,$01,$F9,$01,$00,$08,$00,$08 ; Pose $06, frame 0: X offsets of tiles 0-7
$04:8B96 .db $F9,$01,$F9,$01,$00,$08,$00,$08 ; Pose $06, frame 1: X offsets of tiles 0-7
$04:8B9E .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $08, frame 0: X offsets of tiles 0-7
$04:8BA6 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $08, frame 1: X offsets of tiles 0-7
$04:8BAE .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $0A, frame 0: X offsets of tiles 0-7
$04:8BB6 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $0A, frame 1: X offsets of tiles 0-7
$04:8BBE .db $00,$08,$07,$0F,$07,$0F,$00,$08 ; Pose $0C, frame 0: X offsets of tiles 0-7
$04:8BC6 .db $00,$08,$07,$0F,$07,$0F,$00,$08 ; Pose $0C, frame 1: X offsets of tiles 0-7
$04:8BCE .db $00,$08,$F9,$01,$F9,$01,$00,$08 ; Pose $0E, frame 0: X offsets of tiles 0-7
$04:8BD6 .db $00,$08,$F9,$01,$F9,$01,$00,$08 ; Pose $0E, frame 1: X offsets of tiles 0-7
$04:8BDE .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $10, frame 0: X offsets of tiles 0-7
$04:8BE6 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $10, frame 1: X offsets of tiles 0-7
$04:8BEE .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $12, frame 0: X offsets of tiles 0-7
$04:8BF6 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $12, frame 1: X offsets of tiles 0-7
$04:8BFE .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $14, frame 0: X offsets of tiles 0-7
$04:8C06 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $14, frame 1: X offsets of tiles 0-7
$04:8C0E .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $16, frame 0: X offsets of tiles 0-7
$04:8C16 .db $00,$08,$00,$08,$00,$08,$00,$08 ; Pose $16, frame 1: X offsets of tiles 0-7
;;; $8C1E..8CD6: Table: Yoshi sprite Y offsets ;;;
;; One byte per tile (8 per frame, 2 frames per pose): Y offset added to [$8B]. Same indexing as $8B5E.
$04:8C1E .db $FB,$FB,$03,$03,$00,$00,$08,$08 ; Pose $00, frame 0: Y offsets of tiles 0-7
$04:8C26 .db $FA,$FA,$02,$02,$00,$00,$08,$08 ; Pose $00, frame 1: Y offsets of tiles 0-7
$04:8C2E .db $00,$00,$08,$08,$F8,$F8,$00,$00 ; Pose $02, frame 0: Y offsets of tiles 0-7
$04:8C36 .db $00,$00,$08,$08,$F9,$F9,$01,$01 ; Pose $02, frame 1: Y offsets of tiles 0-7
$04:8C3E .db $FC,$FC,$04,$04,$00,$00,$08,$08 ; Pose $04, frame 0: Y offsets of tiles 0-7
$04:8C46 .db $FB,$FB,$03,$03,$00,$00,$08,$08 ; Pose $04, frame 1: Y offsets of tiles 0-7
$04:8C4E .db $FC,$FC,$04,$04,$00,$00,$08,$08 ; Pose $06, frame 0: Y offsets of tiles 0-7
$04:8C56 .db $FB,$FB,$03,$03,$00,$00,$08,$08 ; Pose $06, frame 1: Y offsets of tiles 0-7
$04:8C5E .db $08,$08,$FB,$FB,$03,$03,$00,$00 ; Pose $08, frame 0: Y offsets of tiles 0-7
$04:8C66 .db $08,$08,$FA,$FA,$02,$02,$00,$00 ; Pose $08, frame 1: Y offsets of tiles 0-7
$04:8C6E .db $08,$08,$00,$00,$F8,$F8,$00,$00 ; Pose $0A, frame 0: Y offsets of tiles 0-7
$04:8C76 .db $08,$08,$00,$00,$F9,$F9,$01,$01 ; Pose $0A, frame 1: Y offsets of tiles 0-7
$04:8C7E .db $08,$08,$FC,$FC,$04,$04,$00,$00 ; Pose $0C, frame 0: Y offsets of tiles 0-7
$04:8C86 .db $08,$08,$FB,$FB,$03,$03,$00,$00 ; Pose $0C, frame 1: Y offsets of tiles 0-7
$04:8C8E .db $08,$08,$FC,$FC,$04,$04,$00,$00 ; Pose $0E, frame 0: Y offsets of tiles 0-7
$04:8C96 .db $08,$08,$FB,$FB,$03,$03,$00,$00 ; Pose $0E, frame 1: Y offsets of tiles 0-7
$04:8C9E .db $00,$00,$08,$08,$F8,$F8,$00,$00 ; Pose $10, frame 0: Y offsets of tiles 0-7
$04:8CA6 .db $00,$00,$08,$08,$F8,$F8,$00,$00 ; Pose $10, frame 1: Y offsets of tiles 0-7
$04:8CAE .db $08,$08,$00,$00,$F8,$F8,$00,$00 ; Pose $12, frame 0: Y offsets of tiles 0-7
$04:8CB6 .db $08,$08,$00,$00,$F8,$F8,$00,$00 ; Pose $12, frame 1: Y offsets of tiles 0-7
$04:8CBE .db $FB,$FB,$03,$03,$00,$00,$08,$08 ; Pose $14, frame 0: Y offsets of tiles 0-7
$04:8CC6 .db $FA,$FA,$02,$02,$00,$00,$08,$08 ; Pose $14, frame 1: Y offsets of tiles 0-7
$04:8CCE .db $FB,$FB,$03,$03,$00,$00,$08,$08 ; Pose $16, frame 0: Y offsets of tiles 0-7
$04:8CD6 .db $FA,$FA,$02,$02,$00,$00,$08,$08 ; Pose $16, frame 1: Y offsets of tiles 0-7
;;; $8CDE..8CDE: Table: Yoshi color to palette bits ;;;
;; Word table indexed by Yoshi color - 4 ($04, $06, $08, $0A): palette bits OR'd into the tile word (palette
;; 0-3).
$04:8CDE .db $00,$00,$00,$02,$00,$04,$00,$06 ; Yoshi color - 4 -> palette bits: $0000, $0200, $0400, $0600
;;; $8CE6: Draw player riding Yoshi (8 tiles) ;;;
;; Draws the rider and Yoshi as 8 OAM tiles from $89DE, with per-tile offsets from
;; $8B5E/$8C1E. Yoshi tiles
;; are recolored from the Yoshi color; the rider gets the player's palette offset.
;; Parameters: Y = player index * 2, X = OAM offset, [$0E] = Yoshi color, [$04] = palette offset, [$8A]/[$8B]
;; = position.
;; Called by:
;; $04:895F: Draw player map sprite (2x2 tiles)
$04:8CE6 A9 07 LDA.B #$07 ; \
$04:8CE8 85 8C STA $8C ; / [$8C] = 7: tile counter for 8 tiles (rider + Yoshi)
$04:8CEA C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8CEC B9 13 1F LDA.W $1F13,Y ; \
$04:8CEF 0A ASL ; |
$04:8CF0 0A ASL ; |
$04:8CF1 0A ASL ; |
$04:8CF2 0A ASL ; } [$00] = pose * 16: offset of this pose in the tile tables
$04:8CF3 85 00 STA $00 ; /
$04:8CF5 A5 13 LDA RAM_FrameCounter ; \
$04:8CF7 29 08 00 AND.W #$0008 ; |
$04:8CFA 0A ASL ; |
$04:8CFB 18 CLC ; |
$04:8CFC 65 00 ADC $00 ; } Y = pose offset + 0 or $10 (2 frames, switching every 8 frames)
$04:8CFE A8 TAY ; /
$04:8CFF E0 00 00 CPX.W #$0000 ; \
$04:8D02 D0 17 BNE $8D1B ; / Only for the first player's sprites (X = 0)
$04:8D04 AD D9 13 LDA.W $13D9 ; \
$04:8D07 C9 0B 00 CMP.W #$000B ; } Only while OW process [$13D9] = $0B (probably a turn-around spin)
$04:8D0A D0 0F BNE $8D1B ; /
$04:8D0C A5 13 LDA RAM_FrameCounter ; \
$04:8D0E 29 0C 00 AND.W #$000C ; |
$04:8D11 4A LSR ; |
$04:8D12 4A LSR ; |
$04:8D13 A8 TAY ; |
$04:8D14 B9 4B 89 LDA.W $894B,Y ; |
$04:8D17 29 FF 00 AND.W #$00FF ; } Y = facing offset from $894B, changes every 4 frames
$04:8D1A A8 TAY ; /
$04:8D1B C2 20 REP #$20 ; A = 16-bit
$04:8D1D 5A PHY ; Save the tile word index
$04:8D1E 98 TYA ; \
$04:8D1F 4A LSR ; } Y = Y / 2: byte index into the per-tile offset tables
$04:8D20 A8 TAY ; /
$04:8D21 E2 20 SEP #$20 ; A = 8-bit
$04:8D23 B9 5E 8B LDA.W $8B5E,Y ; \
$04:8D26 18 CLC ; |
$04:8D27 65 8A ADC $8A ; } OAM X = [DATA_048B5E+Y] + [$8A]
$04:8D29 9D 9C 02 STA.W $029C,X ; /
$04:8D2C B9 1E 8C LDA.W $8C1E,Y ; \
$04:8D2F 18 CLC ; |
$04:8D30 65 8B ADC $8B ; } OAM Y = [DATA_048C1E+Y] + [$8B]
$04:8D32 9D 9D 02 STA.W $029D,X ; /
$04:8D35 7A PLY ; Restore the tile word index
$04:8D36 C2 20 REP #$20 ; A = 16-bit
$04:8D38 B9 DE 89 LDA.W $89DE,Y ; A = tile word (tile number, property) from $89DE
$04:8D3B C9 FF FF CMP.W #$FFFF ; \
$04:8D3E F0 27 BEQ $8D67 ; / $FFFF = unused slot: leave its tile alone
$04:8D40 48 PHA ; Save the tile word
$04:8D41 29 00 0F AND.W #$0F00 ; \
$04:8D44 C9 00 02 CMP.W #$0200 ; } Palette bits = 1 ($0200): this is a Yoshi tile, recolor it
$04:8D47 D0 15 BNE $8D5E ; /
$04:8D49 84 08 STY $08 ; Save the tile word index in [$08]
$04:8D4B A5 0E LDA $0E ; \
$04:8D4D 38 SEC ; |
$04:8D4E E9 04 00 SBC.W #$0004 ; } Y = Yoshi color - 4
$04:8D51 A8 TAY ; /
$04:8D52 68 PLA ; Restore the tile word
$04:8D53 29 FF F0 AND.W #$F0FF ; Clear its palette bits
$04:8D56 19 DE 8C ORA.W $8CDE,Y ; Insert the palette for this Yoshi color ($8CDE)
$04:8D59 48 PHA ; Save the recolored tile word
$04:8D5A A4 08 LDY $08 ; Restore the tile word index
$04:8D5C 80 05 BRA $8D63 ; Go store it ($048D63)
$04:8D5E 68 PLA ; Restore the tile word (rider tile)
$04:8D5F 18 CLC ; \
$04:8D60 65 04 ADC $04 ; / Add the player's palette offset [$04] (Luigi)
$04:8D62 48 PHA ; Save the tile word
$04:8D63 68 PLA ; Restore the tile word
$04:8D64 9D 9E 02 STA.W $029E,X ; Store tile and property in OAM
$04:8D67 E2 20 SEP #$20 ; A = 8-bit
$04:8D69 E8 INX ; \
$04:8D6A E8 INX ; |
$04:8D6B E8 INX ; } X += 4: next OAM slot
$04:8D6C E8 INX ; /
$04:8D6D C8 INY ; \
$04:8D6E C8 INY ; / Y += 2: next tile word
$04:8D6F C6 8C DEC $8C ; \
$04:8D71 10 A8 BPL $8D1B ; / Loop for all 8 tiles
$04:8D73 60 RTS ; Return
;;; $8D74..8D84: Table: translevels that restart map music ;;;
;; Translevel numbers compared against [$13BF] by $8D91 (11 words). Probably levels with a cutscene or
;; event on completion.
$04:8D74 .db $0B,$00,$13,$00,$1A,$00,$1B,$00 ; Translevels $0B, $13, $1A, $1B
$04:8D7C .db $1F,$00,$20,$00,$31,$00,$32,$00 ; Translevels $1F, $20, $31, $32
$04:8D84 .db $34,$00,$35,$00,$40,$00 ; Translevels $34, $35, $40
;;; $8D8A..8D8A: Table: map music per submap ;;;
;; Music number written to [$1DFB], indexed by submap 0-6 (main, Yoshi's Island, Vanilla Dome, Forest of
;; Illusion, Valley of Bowser,
;; Special Zone, Star World).
$04:8D8A .db $02,$03,$04,$06,$07,$09,$05 ; Map music per submap 0-6: main, Yoshi's Is., Vanilla, Forest, Valley, Special, Star
;;; $8D91: Overworld load: reset poses, set music ;;;
;; Called by JSL from the map loader. Resets both players to an idle pose ($02 walking, $0A swimming), runs
;; $8E55, then decides
;; whether to restart the map music: always when no cutscene is pending, else only if the level is beaten or
;; in $8D74.
;; Leaves the music alone after beating translevel $18. Music = $8D8A[submap] written to [$1DFB].
;; Called by:
;; $00:A161: Game mode 0C: load overworld (LoadMapGameMode)
$04:8D91 8B PHB ; \
$04:8D92 4B PHK ; } Data bank = $04
$04:8D93 AB PLB ; /
$04:8D94 9C 9E 1B STZ.W $1B9E ; [$1B9E] = 0 (purpose unclear)
$04:8D97 A9 0F LDA.B #$0F ; \
$04:8D99 8D 4E 14 STA.W $144E ; / [$144E] = $0F (purpose unclear)
$04:8D9C A2 02 LDX.B #$02 ; X = $02: idle walking pose
$04:8D9E AD 13 1F LDA.W $1F13 ; A = Mario's map pose [$1F13]
$04:8DA1 C9 12 CMP.B #$12 ; \
$04:8DA3 F0 04 BEQ $8DA9 ; / Pose $12 (swimming): use the idle swimming pose
$04:8DA5 29 08 AND.B #$08 ; \
$04:8DA7 F0 02 BEQ $8DAB ; / Bit 3 clear (not swimming): keep pose $02
$04:8DA9 A2 0A LDX.B #$0A ; X = $0A: idle swimming pose
$04:8DAB 8E 13 1F STX.W $1F13 ; Mario's pose = X
$04:8DAE A2 02 LDX.B #$02 ; X = $02: idle walking pose
$04:8DB0 AD 15 1F LDA.W $1F15 ; A = Luigi's map pose [$1F15]
$04:8DB3 C9 12 CMP.B #$12 ; \
$04:8DB5 F0 04 BEQ $8DBB ; / Pose $12 (swimming): use the idle swimming pose
$04:8DB7 29 08 AND.B #$08 ; \
$04:8DB9 F0 02 BEQ $8DBD ; / Bit 3 clear (not swimming): keep pose $02
$04:8DBB A2 0A LDX.B #$0A ; X = $0A: idle swimming pose
$04:8DBD 8E 15 1F STX.W $1F15 ; Luigi's pose = X
$04:8DC0 E2 10 SEP #$10 ; Index registers = 8-bit
$04:8DC2 20 55 8E JSR.W $8E55 ; Set up the player's tile, level name and sprites ($8E55)
$04:8DC5 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8DC7 AD D4 0D LDA.W $0DD4 ; \
$04:8DCA 29 00 FF AND.W #$FF00 ; / High byte = [$0DD5] (level exit result)
$04:8DCD F0 10 BEQ $8DDF ; No exit recorded: go to $048DDF
$04:8DCF 30 0E BMI $8DDF ; Bit 7 set: go to $048DDF
$04:8DD1 AD BF 13 LDA.W $13BF ; \
$04:8DD4 29 FF 00 AND.W #$00FF ; |
$04:8DD7 C9 18 00 CMP.W #$0018 ; } Current translevel [$13BF] = $18? If not go to $048DDF
$04:8DDA D0 03 BNE $8DDF ; /
$04:8DDC 82 55 00 BRL $8E34 ; Exit from translevel $18: leave the music alone ($048E34)
$04:8DDF AD C6 13 LDA.W $13C6 ; \
$04:8DE2 29 FF 00 AND.W #$00FF ; } [$13C6] low byte (cutscene) = 0: set the map music ($048E38)
$04:8DE5 F0 51 BEQ $8E38 ; /
$04:8DE7 AD C6 13 LDA.W $13C6 ; \
$04:8DEA 29 00 FF AND.W #$FF00 ; } Clear the low byte of [$13C6]
$04:8DED 8D C6 13 STA.W $13C6 ; /
$04:8DF0 E2 10 SEP #$10 ; Index registers = 8-bit
$04:8DF2 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]: current player index
$04:8DF5 BD 17 1F LDA.W $1F17,X ; \
$04:8DF8 4A LSR ; |
$04:8DF9 4A LSR ; |
$04:8DFA 4A LSR ; |
$04:8DFB 4A LSR ; } [$00] = player map X / 16 (tile column)
$04:8DFC 85 00 STA $00 ; /
$04:8DFE BD 19 1F LDA.W $1F19,X ; \
$04:8E01 4A LSR ; |
$04:8E02 4A LSR ; |
$04:8E03 4A LSR ; |
$04:8E04 4A LSR ; } [$02] = player map Y / 16 (tile row)
$04:8E05 85 02 STA $02 ; /
$04:8E07 8A TXA ; \
$04:8E08 4A LSR ; |
$04:8E09 4A LSR ; } X = player number (0 or 1)
$04:8E0A AA TAX ; /
$04:8E0B 20 85 98 JSR.W OW_TilePos_Calc ; Compute the tile offset [$04] (OW_TilePos_Calc)
$04:8E0E C2 10 REP #$10 ; Index registers = 16-bit
$04:8E10 A6 04 LDX $04 ; X = tile offset
$04:8E12 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:8E16 29 FF 00 AND.W #$00FF ; } X = translevel number of that tile ([$7ED000])
$04:8E19 AA TAX ; /
$04:8E1A BD A2 1E LDA.W $1EA2,X ; \
$04:8E1D 29 80 00 AND.W #$0080 ; } Level already beaten ([$1EA2] bit 7)? Set the map music ($048E38)
$04:8E20 D0 16 BNE $8E38 ; /
$04:8E22 A0 14 00 LDY.W #$0014 ; Y = $14: last entry of the $8D74 list
$04:8E25 AD BF 13 LDA.W $13BF ; \
$04:8E28 29 FF 00 AND.W #$00FF ; |
$04:8E2B D9 74 8D CMP.W $8D74,Y ; } Current translevel in the list? Then set the map music ($048E38)
$04:8E2E F0 08 BEQ $8E38 ; /
$04:8E30 88 DEY ; \
$04:8E31 88 DEY ; } Next list entry
$04:8E32 10 F1 BPL $8E25 ; /
$04:8E34 E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8E36 80 0F BRA $8E47 ; Skip the music change
$04:8E38 E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8E3A AE B3 0D LDX.W $0DB3 ; \
$04:8E3D BD 11 1F LDA.W $1F11,X ; } X = current player's submap ([$1F11] + player)
$04:8E40 AA TAX ; /
$04:8E41 BD 8A 8D LDA.W $8D8A,X ; \
$04:8E44 8D FB 1D STA.W $1DFB ; / Request the map music for that submap ([$1DFB])
$04:8E47 AB PLB ; Restore the data bank
$04:8E48 6B RTL ; Return long
;;; $8E49..8E4F: Unused table: map positions ;;;
;; Words $0128, $0000, $0188 (X) and $01C8, $0000, $01D8 (Y), read only by the unused block in $8E55.
$04:8E49 .db $28,$01,$00,$00,$88,$01 ; Unused: X positions $0128, $0000, $0188
$04:8E4F .db $C8,$01,$00,$00,$D8,$01 ; Unused: Y positions $01C8, $0000, $01D8
;;; $8E55: Overworld setup and process 0 (level exit) ;;;
;; $048E55: sets [$0DD6] = player * 4, converts the player's tile to an offset [$04], writes the level name to
;; the stripe buffer,
;; stores the tile number in [$13C1], then updates the camera, draws the border sprites and runs the tile
;; animation.
;; The [$0EF7] block ($048EA5-$048EDE) is probably unused: [$0EF7] seems never set outside unreferenced code.
;; $048EF1 (OW process 0, first entry of PtrsLong04857D): after a level, sets [$0DB1] = 8; at one map spot
;; goes to process $0C;
;; else marks the level: midway flag if died with [$13CE] set, or beaten (bit 7) and process += 1 on exit.
;; Then updates the camera.
;; Called by:
;; $04:8DC2: Overworld load: reset poses, set music
;; $04:9E03: Overworld level name text and builder (LevelNameStrings)
$04:8E55 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8E57 AD B3 0D LDA.W $0DB3 ; \
$04:8E5A 29 FF 00 AND.W #$00FF ; |
$04:8E5D 0A ASL ; |
$04:8E5E 0A ASL ; } [$0DD6] = current player * 4 (index into per-player tables)
$04:8E5F 8D D6 0D STA.W $0DD6 ; /
$04:8E62 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:8E65 BD 1F 1F LDA.W $1F1F,X ; \
$04:8E68 85 00 STA $00 ; / [$00] = player's tile column ([$1F1F])
$04:8E6A BD 21 1F LDA.W $1F21,X ; \
$04:8E6D 85 02 STA $02 ; / [$02] = player's tile row ([$1F21])
$04:8E6F 8A TXA ; \
$04:8E70 4A LSR ; |
$04:8E71 4A LSR ; } X = player number (0 or 1)
$04:8E72 AA TAX ; /
$04:8E73 20 85 98 JSR.W OW_TilePos_Calc ; Compute the tile offset [$04] (OW_TilePos_Calc)
$04:8E76 64 00 STZ $00 ; [$00] = 0
$04:8E78 A6 04 LDX $04 ; X = tile offset
$04:8E7A BF 00 D0 7E LDA.L $7ED000,X ; \
$04:8E7E 29 FF 00 AND.W #$00FF ; |
$04:8E81 0A ASL ; } X = translevel number at the player's tile * 2 ([$7ED000])
$04:8E82 AA TAX ; /
$04:8E83 BD FC A0 LDA.W LevelNames,X ; \
$04:8E86 85 00 STA $00 ; / [$00] = level name data for that translevel (LevelNames)
$04:8E88 20 07 9D JSR.W $9D07 ; Write the level name to the stripe image buffer ($9D07)
$04:8E8B A6 04 LDX $04 ; \
$04:8E8D 30 0F BMI $8E9E ; / Tile offset negative: no tile number, go to $048E9E
$04:8E8F E0 00 08 CPX.W #$0800 ; \
$04:8E92 B0 0A BCS $8E9E ; / Tile offset >= $0800: out of range, go to $048E9E
$04:8E94 BF 00 C8 7E LDA.L $7EC800,X ; \
$04:8E98 29 FF 00 AND.W #$00FF ; } [$13C1] = OW tile number under the player ([$7EC800])
$04:8E9B 8D C1 13 STA.W $13C1 ; /
$04:8E9E E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8EA0 AE F7 0E LDX.W $0EF7 ; \
$04:8EA3 F0 3C BEQ $8EE1 ; / [$0EF7] = 0 (always, apparently): skip the block below
$04:8EA5 10 32 BPL $8ED9 ; Bit 7 clear: go to $048ED9
$04:8EA7 8A TXA ; \
$04:8EA8 29 7F AND.B #$7F ; } X = [$0EF7] & $7F
$04:8EAA AA TAX ; /
$04:8EAB 9E F5 0D STZ.W $0DF5,X ; Clear [$0DF5+X]
$04:8EAE AD F6 0E LDA.W $0EF6 ; A = [$0EF6]
$04:8EB1 AE D5 0D LDX.W $0DD5 ; \
$04:8EB4 10 17 BPL $8ECD ; / [$0DD5] bit 7 clear: go to $048ECD
$04:8EB6 0A ASL ; \
$04:8EB7 AA TAX ; / X = [$0EF6] * 2
$04:8EB8 C2 20 REP #$20 ; A = 16-bit
$04:8EBA AC D6 0D LDY.W $0DD6 ; Y = [$0DD6]: current player index
$04:8EBD BD 49 8E LDA.W $8E49,X ; \
$04:8EC0 99 17 1F STA.W $1F17,Y ; / Player map X = $8E49[X]
$04:8EC3 BD 4F 8E LDA.W $8E4F,X ; \
$04:8EC6 99 19 1F STA.W $1F19,Y ; / Player map Y = $8E4F[X]
$04:8EC9 E2 20 SEP #$20 ; A = 8-bit
$04:8ECB 80 14 BRA $8EE1 ; Continue at $048EE1
$04:8ECD AA TAX ; X = [$0EF6]
$04:8ECE BD 85 FB LDA.W $FB85,X ; \
$04:8ED1 0D F5 0E ORA.W $0EF5 ; } [$0EF5] |= $FB85[X] ($80, $40 or $20)
$04:8ED4 8D F5 0E STA.W $0EF5 ; /
$04:8ED7 80 08 BRA $8EE1 ; Continue at $048EE1
$04:8ED9 AD D5 0D LDA.W $0DD5 ; \
$04:8EDC 30 03 BMI $8EE1 ; / [$0DD5] negative: skip
$04:8EDE 9E E5 0D STZ.W $0DE5,X ; Clear [$0DE5+X]
$04:8EE1 C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8EE3 20 31 98 JSR.W $9831 ; Update the map camera to follow the player ($9831)
$04:8EE6 E2 30 SEP #$30 ; A, X and Y = 8-bit
$04:8EE8 20 A4 85 JSR.W DrawOWBoarder? ; Draw the border icon and the players' map sprites (DrawOWBoarder?)
$04:8EEB 20 86 80 JSR.W $8086 ; Copy animated OW tile graphics to the buffer at $0AF6 ($8086)
$04:8EEE 4C E0 80 JMP.W OW_Tile_Animation ; Run the OW tile animation (OW_Tile_Animation) and return
$04:8EF1 A9 08 LDA.B #$08 ; \
$04:8EF3 8D B1 0D STA.W $0DB1 ; / [$0DB1] = 8 (OW mode timer, probably keeps the mode running)
$04:8EF6 AD 11 1F LDA.W $1F11 ; \
$04:8EF9 C9 01 CMP.B #$01 ; } Mario's submap [$1F11] = 1? If not, go to $048F13
$04:8EFB D0 16 BNE $8F13 ; /
$04:8EFD AD 17 1F LDA.W $1F17 ; \
$04:8F00 C9 68 CMP.B #$68 ; } Mario's map X low byte = $68? If not, go to $048F13
$04:8F02 D0 0F BNE $8F13 ; /
$04:8F04 AD 19 1F LDA.W $1F19 ; \
$04:8F07 C9 8E CMP.B #$8E ; } Mario's map Y low byte = $8E? If not, go to $048F13
$04:8F09 D0 08 BNE $8F13 ; /
$04:8F0B A9 0C LDA.B #$0C ; \
$04:8F0D 8D D9 13 STA.W $13D9 ; / OW process [$13D9] = $0C (a special event at this spot)
$04:8F10 82 67 00 BRL $8F7A ; Skip the exit handling, go to $048F7A
$04:8F13 C2 20 REP #$20 ; A = 16-bit
$04:8F15 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]: current player index
$04:8F18 BD 17 1F LDA.W $1F17,X ; \
$04:8F1B 4A LSR ; |
$04:8F1C 4A LSR ; |
$04:8F1D 4A LSR ; |
$04:8F1E 4A LSR ; } [$00] = player map X / 16 (tile column)
$04:8F1F 85 00 STA $00 ; /
$04:8F21 BD 19 1F LDA.W $1F19,X ; \
$04:8F24 4A LSR ; |
$04:8F25 4A LSR ; |
$04:8F26 4A LSR ; |
$04:8F27 4A LSR ; } [$02] = player map Y / 16 (tile row)
$04:8F28 85 02 STA $02 ; /
$04:8F2A 8A TXA ; \
$04:8F2B 4A LSR ; |
$04:8F2C 4A LSR ; } X = player number (0 or 1)
$04:8F2D AA TAX ; /
$04:8F2E 20 85 98 JSR.W OW_TilePos_Calc ; Compute the tile offset [$04] (OW_TilePos_Calc)
$04:8F31 C2 10 REP #$10 ; Index registers = 16-bit
$04:8F33 E2 20 SEP #$20 ; A = 8-bit
$04:8F35 AD CE 13 LDA.W $13CE ; \
$04:8F38 F0 1C BEQ $8F56 ; / Midway flag [$13CE] = 0: go to $048F56
$04:8F3A AD D5 0D LDA.W $0DD5 ; \
$04:8F3D F0 17 BEQ $8F56 ; / [$0DD5] = 0 (no exit taken): go to $048F56
$04:8F3F 10 1E BPL $8F5F ; Positive (level beaten): go to $048F5F
$04:8F41 C2 20 REP #$20 ; A = 16-bit
$04:8F43 A6 04 LDX $04 ; X = tile offset
$04:8F45 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:8F49 29 FF 00 AND.W #$00FF ; |
$04:8F4C AA TAX ; } A = level flags of the translevel at the player's tile ([$1EA2])
$04:8F4D BD A2 1E LDA.W $1EA2,X ; /
$04:8F50 09 40 00 ORA.W #$0040 ; \
$04:8F53 9D A2 1E STA.W $1EA2,X ; / Set bit 6 (midway point reached) in the level flags
$04:8F56 E2 20 SEP #$20 ; A = 8-bit
$04:8F58 A9 05 LDA.B #$05 ; \
$04:8F5A 8D D9 13 STA.W $13D9 ; / OW process [$13D9] = 5 (player does nothing)
$04:8F5D 80 1B BRA $8F7A ; Go to $048F7A
$04:8F5F C2 20 REP #$20 ; A = 16-bit
$04:8F61 A6 04 LDX $04 ; X = tile offset
$04:8F63 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:8F67 29 FF 00 AND.W #$00FF ; |
$04:8F6A AA TAX ; } A = level flags of the translevel at the player's tile ([$1EA2])
$04:8F6B BD A2 1E LDA.W $1EA2,X ; /
$04:8F6E 09 80 00 ORA.W #$0080 ; \
$04:8F71 29 BF FF AND.W #$FFBF ; } Set bit 7 (level beaten) and clear bit 6 (midway point)
$04:8F74 9D A2 1E STA.W $1EA2,X ; /
$04:8F77 EE D9 13 INC.W $13D9 ; OW process [$13D9] += 1 (next: path reveal and events)
$04:8F7A C2 30 REP #$30 ; A, X and Y = 16-bit
$04:8F7C 4C 31 98 JMP.W $9831 ; Update the map camera and return ($9831)
;;; $8F7F..8F7F: Unused table: OW tile numbers ;;;
;; Same bytes as $E5E6 (yellow-dot water level tiles); nothing references this copy.
$04:8F7F .db $58,$59,$5D,$63,$77,$79,$7E,$80 ; Unused: OW tile numbers $58, $59, $5D, $63, $77, $79, $7E, $80
;;; $8F87: Overworld state 2: after level, save data ;;;
;; Overworld state 2 ([$13D9] = 2, entry in PtrsLong04857D). Sets up the auto-walk from the level just cleared
;; ($9903).
;; If the tile under the player is one of 8 in $8F7F (probably the ones that offer a save), copies the
;; player data to the
;; save buffer at $1FA9 and mirrors the current player's position, tile and submap into the other player's
;; slot.
;; Exit type [$0DD5] = $E0: waits for [$0DB1] to run out, then saves the level flags and sets [$13D9] = 4
;; (becomes 5).
;; Finally reads the tile number under the player into [$13C1] and advances [$13D9].
;; $049037: if [$13CA] is set, copies the 96 level flag bytes $1EA2 to $1F49, clears [$13CA] and sets [$1B87]
;; = 5. Preserves X, Y, P.
$04:8F87 20 03 99 JSR.W $9903 ; Compute auto-walk direction from exit type [$0DD5] ($9903); no-op if 0 or negative
$04:8F8A A2 07 LDX.B #$07 ; X = 7: last entry of $8F7F
$04:8F8C AD C1 13 LDA.W $13C1 ; A = [$13C1]: tile number the player stands on
$04:8F8F DD 7F 8F CMP.W $8F7F,X ; Compare with $8F7F[X] (8 special level tiles)
$04:8F92 D0 6C BNE $9000 ; No match: try the next entry
$04:8F94 A2 2C LDX.B #$2C ; X = $2C: copy 45 bytes
$04:8F96 BD 02 1F LDA.W $1F02,X ; \
$04:8F99 9D A9 1F STA.W $1FA9,X ; |
$04:8F9C CA DEX ; } Copy [$1F02]-[$1F2E] to the save buffer $1FA9-$1FD5
$04:8F9D 10 F7 BPL $8F96 ; /
$04:8F9F C2 30 REP #$30 ; A, X and Y 16-bit
$04:8FA1 AE D6 0D LDX.W $0DD6 ; X = [$0DD6] (current player * 4)
$04:8FA4 8A TXA ; \
$04:8FA5 49 04 00 EOR.W #$0004 ; } Y = X xor 4: the other player's slot
$04:8FA8 A8 TAY ; /
$04:8FA9 BD BE 1F LDA.W $1FBE,X ; \
$04:8FAC 99 BE 1F STA.W $1FBE,Y ; / Save buffer: copy player X position ($1FBE) to the other player
$04:8FAF BD C0 1F LDA.W $1FC0,X ; \
$04:8FB2 99 C0 1F STA.W $1FC0,Y ; / Save buffer: copy player Y position ($1FC0) to the other player
$04:8FB5 BD C6 1F LDA.W $1FC6,X ; \
$04:8FB8 99 C6 1F STA.W $1FC6,Y ; / Save buffer: copy tile X position ($1FC6) to the other player
$04:8FBB BD C8 1F LDA.W $1FC8,X ; \
$04:8FBE 99 C8 1F STA.W $1FC8,Y ; / Save buffer: copy tile Y position ($1FC8) to the other player
$04:8FC1 8A TXA ; \
$04:8FC2 4A LSR ; } X = [$0DD6] / 2
$04:8FC3 AA TAX ; /
$04:8FC4 49 02 00 EOR.W #$0002 ; \
$04:8FC7 A8 TAY ; / Y = X xor 2: the other player's slot
$04:8FC8 BD BA 1F LDA.W $1FBA,X ; \
$04:8FCB 99 BA 1F STA.W $1FBA,Y ; / Save buffer: copy animation/facing ($1FBA) to the other player
$04:8FCE 8A TXA ; \
$04:8FCF E2 30 SEP #$30 ; |
$04:8FD1 4A LSR ; } A, X and Y 8-bit; X = player number (0 or 1)
$04:8FD2 AA TAX ; /
$04:8FD3 49 01 EOR.B #$01 ; \
$04:8FD5 A8 TAY ; / Y = X xor 1: the other player
$04:8FD6 BD B8 1F LDA.W $1FB8,X ; \
$04:8FD9 99 B8 1F STA.W $1FB8,Y ; / Save buffer: copy submap ($1FB8) to the other player
$04:8FDC AD D5 0D LDA.W $0DD5 ; A = [$0DD5] (exit type)
$04:8FDF C9 E0 CMP.B #$E0 ; \
$04:8FE1 D0 18 BNE $8FFB ; / Not $E0: just flag a pending save and go on
$04:8FE3 CE B1 0D DEC.W $0DB1 ; [$0DB1]-- (delay counter)
$04:8FE6 30 01 BMI $8FE9 ; Went below 0: continue below
$04:8FE8 60 RTS ; Still counting: stay in this state until next frame
$04:8FE9 EE CA 13 INC.W $13CA ; Flag a save as pending ([$13CA]++)
$04:8FEC 20 37 90 JSR.W $9037 ; Copy the level flags to the save buffer ($9037)
$04:8FEF A9 02 LDA.B #$02 ; \
$04:8FF1 8D B1 0D STA.W $0DB1 ; / [$0DB1] = 2
$04:8FF4 A9 04 LDA.B #$04 ; \
$04:8FF6 8D D9 13 STA.W $13D9 ; / [$13D9] = 4 (INC at $049033 makes it 5)
$04:8FF9 80 08 BRA $9003 ; Go find the tile under the player
$04:8FFB EE CA 13 INC.W $13CA ; Flag a save as pending ([$13CA]++)
$04:8FFE 80 03 BRA $9003 ; Go find the tile under the player
$04:9000 CA DEX ; Next entry of $8F7F
$04:9001 10 89 BPL $8F8C ; Loop for X = 7..0
$04:9003 C2 20 REP #$20 ; A 16-bit
$04:9005 64 06 STZ $06 ; [$06] = 0
$04:9007 AE D6 0D LDX.W $0DD6 ; X = [$0DD6] (current player * 4)
$04:900A BD 17 1F LDA.W $1F17,X ; \
$04:900D 4A LSR ; |
$04:900E 4A LSR ; |
$04:900F 4A LSR ; } A = player X position / 16 (tile column)
$04:9010 4A LSR ; /
$04:9011 85 00 STA $00 ; [$00] = tile column
$04:9013 BD 19 1F LDA.W $1F19,X ; \
$04:9016 4A LSR ; |
$04:9017 4A LSR ; |
$04:9018 4A LSR ; } A = player Y position / 16 (tile row)
$04:9019 4A LSR ; /
$04:901A 85 02 STA $02 ; [$02] = tile row
$04:901C 8A TXA ; \
$04:901D 4A LSR ; |
$04:901E 4A LSR ; } X = [$0DD6] / 4 (player number)
$04:901F AA TAX ; /
$04:9020 20 85 98 JSR.W OW_TilePos_Calc ; Compute the tile offset into [$04] (OW_TilePos_Calc)
$04:9023 C2 10 REP #$10 ; X and Y 16-bit
$04:9025 A6 04 LDX $04 ; X = [$04] (tile offset)
$04:9027 BF 00 C8 7E LDA.L $7EC800,X ; A = overworld tile number at $7E:C800 + offset
$04:902B 29 FF 00 AND.W #$00FF ; Keep the low byte
$04:902E 8D C1 13 STA.W $13C1 ; [$13C1] = tile number under the player
$04:9031 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:9033 EE D9 13 INC.W $13D9 ; Next overworld state: [$13D9]++
$04:9036 60 RTS ; Return
$04:9037 DA PHX ; Save X
$04:9038 5A PHY ; Save Y
$04:9039 08 PHP ; Save processor flags
$04:903A E2 30 SEP #$30 ; A, X and Y 8-bit
$04:903C AD CA 13 LDA.W $13CA ; A = [$13CA] (save pending flag)
$04:903F F0 13 BEQ $9054 ; Not pending: skip
$04:9041 A2 5F LDX.B #$5F ; X = $5F: copy 96 bytes
$04:9043 BD A2 1E LDA.W $1EA2,X ; \
$04:9046 9D 49 1F STA.W $1F49,X ; |
$04:9049 CA DEX ; } Copy level flags $1EA2-$1F01 to the save buffer $1F49-$1FA8
$04:904A 10 F7 BPL $9043 ; /
$04:904C 9C CA 13 STZ.W $13CA ; Clear the save pending flag [$13CA]
$04:904F A9 05 LDA.B #$05 ; \
$04:9051 8D 87 1B STA.W $1B87 ; / [$1B87] = 5 (probably tells a later state to show the save prompt)
$04:9054 28 PLP ; Restore processor flags
$04:9055 7A PLY ; Restore Y
$04:9056 FA PLX ; Restore X
$04:9057 60 RTS ; Return
;;; $9058..9074: Tables: direction steps and auto-walk fields ;;;
;; $049058: tile step per direction. $049060: shift counts for the 2-bit direction field in $7E:D800 (one
;; field per exit type 1-4).
;; $049064: direction index per field value. $04906C: level numbers at which auto-walk ends.
$04:9058 .db $FF,$FF,$01,$00,$FF,$FF,$01,$00 ; Words -1, +1, -1, +1: tile step for direction Y (0 up, 2 down, 4 left, 6 right)
$04:9060 .db $05,$03,$01,$00 ; Shift counts - 1 for exit type [$0DD5] = 1..4: which 2-bit field of $7E:D800
$04:9064 .db $00,$00,$02,$00,$04,$00,$06,$00 ; Words 0, 2, 4, 6: direction index (0 up, 2 down, 4 left, 6 right) from the field
$04:906C .db $28,$00,$08,$00,$14,$00,$36,$00 ; Level numbers where auto-walk ends and the next event starts: $28, $08, $14, $36
$04:9074 .db $3F,$00,$45,$00 ; Level numbers: $3F, $45 (end of the list)
;;; $9078: Hardcoded overworld paths and state 3 entry (HardCodedOWPaths) ;;;
;; Data ($049078-$04911F): paths for levels that leave the map without path tiles: level numbers, pipe
;; position ($0178/$0128),
;; tile lists ($049086), direction lists ($0490CA) and offsets of each path in them ($04910E).
;; Code at $049120 is overworld state 3 ([$13D9] = 3): clears [$0DD8]; with auto-walk active goes straight to
;; the walking code.
;; Otherwise reads Select and falls into OW_Player_Update (debug star-warp code after it is unreachable).
$04:9078 .db $09,$15,$23,$1B,$43,$44,$24,$FF ; Level numbers that have hardcoded paths ($FF = pipe, matched by position)
$04:9080 .db $30,$31 ; Level numbers $30, $31 (last two paths)
$04:9082 .db $78,$01 ; Pipe Y position $0178 (compared with [$1F19])
$04:9084 .db $28,$01 ; Pipe X position $0128 (compared with [$1F17])
$04:9086 .db $10,$10,$1E,$19,$16,$66,$16,$19 ; Path 0 tiles $10,$10,$1E,$19,$16,$66; path 1 starts $16,$19
$04:908E .db $1E,$10,$10,$66,$04,$04,$04,$58 ; Path 1 ends $1E,$10,$10,$66; path 2: $04,$04,$04,$58
$04:9096 .db $04,$04,$04,$66,$04,$04,$04,$04 ; Path 3: $04,$04,$04,$66; path 4 starts $04 x4
$04:909E .db $04,$6A,$04,$04,$04,$04,$04,$66 ; Path 4 ends $04,$6A; path 5: $04 x5,$66
$04:90A6 .db $1E,$19,$06,$09,$0F,$20,$1A,$21 ; Path 6 tiles (from level $24 to the pipe) start
$04:90AE .db $1A,$14,$19,$18,$1F,$17,$82,$17 ; Path 6 ends with the pipe tile $82; path 7 (pipe back to $24) starts $17
$04:90B6 .db $1F,$18,$19,$14,$1A,$21,$1A,$20 ; Path 7 tiles
$04:90BE .db $0F,$09,$06,$19,$1E,$66,$04,$04 ; Path 7 ends $66; path 8 starts $04,$04
$04:90C6 .db $58,$04,$04,$5F ; Path 8 ends $58; path 9: $04,$04,$5F
$04:90CA .db $02,$02,$02,$02,$06,$06,$04,$04 ; Path directions (0 up, 2 down, 4 left, 6 right), same offsets as the tile list; path 0
$04:90D2 .db $00,$00,$00,$00,$04,$04,$04,$04 ; Path directions (continued)
$04:90DA .db $06,$06,$06,$06,$06,$06,$06,$06 ; Path directions (continued)
$04:90E2 .db $06,$06,$04,$04,$04,$04,$04,$04 ; Path directions (continued)
$04:90EA .db $02,$02,$06,$06,$00,$00,$00,$04 ; Path directions (continued)
$04:90F2 .db $00,$04,$04,$00,$04,$00,$04,$06 ; Path directions (continued)
$04:90FA .db $02,$06,$02,$06,$06,$02,$06,$02 ; Path directions (continued)
$04:9102 .db $02,$02,$04,$04,$00,$00,$06,$06 ; Path directions (continued)
$04:910A .db $06,$04,$04,$04 ; Path directions (end)
$04:910E .db $00,$06,$0C,$10,$14,$1A,$20,$2F ; Offset of paths 0-7 in the tile and direction lists
$04:9116 .db $3E,$41,$08,$00,$04,$00,$02,$00 ; Offsets of paths 8 and 9; then words 8, 4, 2, 1 (direction bits, apparently unused)
$04:911E .db $01,$00 ; Words 8, 4, 2, 1 (cont.)
$04:9120 9C D8 0D STZ.W $0DD8 ; [$0DD8] = 0
$04:9123 AC F7 0E LDY.W $0EF7 ; Y = [$0EF7]
$04:9126 30 71 BMI OWPU_NotOnPipe ; Negative: skip the button checks (OWPU_NotOnPipe)
$04:9128 AD D5 0D LDA.W $0DD5 ; A = [$0DD5] (exit type / auto-walk)
$04:912B 30 05 BMI $9132 ; Negative: read buttons
$04:912D F0 03 BEQ $9132 ; Zero: read buttons
$04:912F 82 B7 00 BRL $91E9 ; Auto-walk active: skip buttons, go walk ($0491E9)
$04:9132 A5 16 LDA $16 ; A = [$16] (buttons newly pressed)
$04:9134 29 20 AND.B #$20 ; Isolate Select
$04:9136 80 09 BRA OW_Player_Update ; Always continue at OW_Player_Update (BEQ here would enable the debug code)
$04:9138 AD C1 13 LDA.W $13C1 ; Unreachable debug: A = [$13C1] (tile under player)
$04:913B F0 28 BEQ $9165 ; Tile 0: warp to Star Road
$04:913D C9 56 CMP.B #$56 ; Tile $56?
$04:913F F0 24 BEQ $9165 ; Yes: warp to Star Road
;;; $9141: Overworld: L+R on Destroyed Castle (OW_Player_Update) ;;;
;; If L and R are both held and the player is on tile $81 (Destroyed Castle), enters the level; otherwise
;; falls into OWPU_NoLR.
$04:9141 A5 17 LDA RAM_ControllerB ; \
$04:9143 29 30 AND.B #$30 ; |
$04:9145 C9 30 CMP.B #$30 ; } If L and R are not both held, go to OWPU_NoLR
$04:9147 D0 07 BNE OWPU_NoLR ; /
$04:9149 AD C1 13 LDA.W $13C1 ; \
$04:914C C9 81 CMP.B #$81 ; } If standing on tile $81 (Destroyed Castle), enter the level
$04:914E F0 4F BEQ OWPU_EnterLevel ; /
;;; $9150: Overworld: check A/B/X/Y pressed (OWPU_NoLR) ;;;
;; If A, B, X or Y was newly pressed go to OWPU_ABXY, otherwise go to the walking code at $0491E9.
$04:9150 A5 16 LDA $16 ; \
$04:9152 05 18 ORA $18 ; |
$04:9154 29 C0 AND.B #$C0 ; } If A, B, X or Y newly pressed, go to OWPU_ABXY
$04:9156 D0 03 BNE OWPU_ABXY ; /
$04:9158 82 8E 00 BRL $91E9 ; Otherwise go to the walking code at $0491E9
;;; $915B: Overworld: button pressed on a tile (OWPU_ABXY) ;;;
;; Clears [$1B9E]. On a star tile ($5F) starts the star warp ([$13D9] = $0B, sound $0D). Otherwise tests for
;; pipes and level tiles.
$04:915B 9C 9E 1B STZ.W $1B9E ; [$1B9E] = 0
$04:915E AD C1 13 LDA.W $13C1 ; \
$04:9161 C9 5F CMP.B #$5F ; } If not on a star tile ($5F), go to OWPU_NotOnStar
$04:9163 D0 18 BNE OWPU_NotOnStar ; /
$04:9165 20 09 85 JSR.W $8509 ; Check the player is exactly on the star/pipe spot ($8509); Z set if so
$04:9168 D0 2E BNE OWPU_IsOnPipeRTS ; Not there: return
$04:916A 9C F7 1D STZ.W $1DF7 ; Star fly-away speed [$1DF7] = 0
$04:916D 9C F8 1D STZ.W $1DF8 ; Star ground timer [$1DF8] = 0
$04:9170 A9 0D LDA.B #$0D ; \
$04:9172 8D F9 1D STA.W $1DF9 ; / Sound effect [$1DF9] = $0D (Star Road warp)
$04:9175 A9 0B LDA.B #$0B ; \
$04:9177 8D D9 13 STA.W $13D9 ; / [$13D9] = $0B: start the star warp
$04:917A 4C 52 9E JMP.W $9E52 ; Run the star warp code ($9E52)
;;; $917D: Overworld: check for pipe tiles (OWPU_NotOnStar) ;;;
;; Tile $82 (unused pipe 1) goes to OWPU_IsOnPipe, tile $5B (pipe 2) falls into it, anything else to
;; OWPU_NotOnPipe.
$04:917D AD C1 13 LDA.W $13C1 ; \
$04:9180 C9 82 CMP.B #$82 ; } If on tile $82 (unused pipe 1), go to OWPU_IsOnPipe
$04:9182 F0 04 BEQ OWPU_IsOnPipe ; /
$04:9184 C9 5B CMP.B #$5B ; \
$04:9186 D0 11 BNE OWPU_NotOnPipe ; / If not on tile $5B (pipe 2), go to OWPU_NotOnPipe
;;; $9188: Overworld: enter pipe (OWPU_IsOnPipe) ;;;
;; If exactly on the pipe spot ($8509): [$1B9C]++, exit type [$0DD5] = 0 and game mode = $0B (fade to
;; overworld, loads the other submap).
$04:9188 20 09 85 JSR.W $8509 ; Check the player is exactly on the pipe spot ($8509)
$04:918B D0 0B BNE OWPU_IsOnPipeRTS ; Not there: return
$04:918D EE 9C 1B INC.W $1B9C ; [$1B9C]++ (entered a pipe)
$04:9190 9C D5 0D STZ.W $0DD5 ; Exit type [$0DD5] = 0
$04:9193 A9 0B LDA.B #$0B ; \
$04:9195 8D 00 01 STA.W RAM_GameMode ; / Game mode = $0B: fade to overworld (loads the other submap)
;;; $9198: Return (OWPU_IsOnPipeRTS) ;;;
$04:9198 60 RTS ; Return
;;; $9199: Overworld: tiles that cannot be entered (OWPU_NotOnPipe) ;;;
;; Tile >= $81: no level to enter, go walk ($0491E9). Lower tiles fall into OWPU_EnterLevel.
$04:9199 C9 81 CMP.B #$81 ; \
$04:919B F0 4C BEQ $91E9 ; } Tile >= $81: cannot enter, go walk ($0491E9)
$04:919D B0 4A BCS $91E9 ; /
;;; $919F: Overworld: enter level, then walk (OWPU_EnterLevel) ;;;
;; $04919F: starts a level. Sets the raise-hand animation, copies the current player's coins, lives, power-up,
;; Yoshi color and
;; reserve item into the in-level RAM, requests the music fade ([$1DFB] = $80) and increments the game mode
;; (fade to level).
;; $0491E9: walking code. Converts the player's X/Y to tile coordinates, computes the tile offset into [$04].
;; With auto-walk active,
;; ends on the levels in $906C ([$13D9] = 5) or takes the direction from the $7E:D800 field and jumps to
;; $0492BC.
$04:919F AD D6 0D LDA.W $0DD6 ; \
$04:91A2 4A LSR ; |
$04:91A3 29 02 AND.B #$02 ; } X = player number * 2 (0 Mario, 2 Luigi)
$04:91A5 AA TAX ; /
$04:91A6 A0 10 LDY.B #$10 ; Y = $10: 'raise hand' animation
$04:91A8 BD 13 1F LDA.W $1F13,X ; A = [$1F13,X] (player animation)
$04:91AB 29 08 AND.B #$08 ; Isolate the swimming bit
$04:91AD F0 02 BEQ $91B1 ; Not swimming: keep Y = $10
$04:91AF A0 12 LDY.B #$12 ; Swimming: Y = $12 ('raise hand' in water)
$04:91B1 98 TYA ; \
$04:91B2 9D 13 1F STA.W $1F13,X ; / Store the animation in [$1F13,X]
$04:91B5 AE B3 0D LDX.W $0DB3 ; X = [$0DB3] (current player)
$04:91B8 BD B6 0D LDA.W RAM_PlayerCoins,X ; \
$04:91BB 8D BF 0D STA.W RAM_StatusCoins ; / Status bar coins = this player's coins
$04:91BE BD B4 0D LDA.W RAM_PlayerLives,X ; \
$04:91C1 8D BE 0D STA.W RAM_StatusLives ; / Status bar lives = this player's lives
$04:91C4 BD B8 0D LDA.W RAM_PlayerPowerUp,X ; \
$04:91C7 85 19 STA RAM_MarioPowerUp ; / Mario power-up = this player's power-up
$04:91C9 BD BA 0D LDA.W RAM_PlyrYoshiColor,X ; \
$04:91CC 8D C1 0D STA.W RAM_OWHasYoshi ; |
$04:91CF 8D C7 13 STA.W RAM_YoshiColor ; } Yoshi color for the map and the level = this player's Yoshi color
$04:91D2 8D 7A 18 STA.W RAM_OnYoshi ; /
$04:91D5 BD BC 0D LDA.W $0DBC,X ; \
$04:91D8 8D C2 0D STA.W $0DC2 ; / Reserve item [$0DC2] = this player's reserve item [$0DBC,X]
$04:91DB A9 02 LDA.B #$02 ; \
$04:91DD 8D B1 0D STA.W $0DB1 ; / [$0DB1] = 2 (fade speed)
$04:91E0 A9 80 LDA.B #$80 ; \
$04:91E2 8D FB 1D STA.W $1DFB ; / [$1DFB] = $80: fade out the music
$04:91E5 EE 00 01 INC.W RAM_GameMode ; Game mode++: fade to level
$04:91E8 60 RTS ; Return
$04:91E9 C2 20 REP #$20 ; A 16-bit
$04:91EB AE D6 0D LDX.W $0DD6 ; X = [$0DD6] (current player * 4)
$04:91EE BD 17 1F LDA.W $1F17,X ; A = player X position
$04:91F1 4A LSR ; \
$04:91F2 4A LSR ; |
$04:91F3 4A LSR ; } A = X position / 16
$04:91F4 4A LSR ; /
$04:91F5 85 00 STA $00 ; \
$04:91F7 9D 1F 1F STA.W $1F1F,X ; / [$00] and [$1F1F,X] = tile column
$04:91FA BD 19 1F LDA.W $1F19,X ; A = player Y position
$04:91FD 4A LSR ; \
$04:91FE 4A LSR ; |
$04:91FF 4A LSR ; } A = Y position / 16
$04:9200 4A LSR ; /
$04:9201 85 02 STA $02 ; \
$04:9203 9D 21 1F STA.W $1F21,X ; / [$02] and [$1F21,X] = tile row
$04:9206 8A TXA ; \
$04:9207 4A LSR ; |
$04:9208 4A LSR ; } X = player number
$04:9209 AA TAX ; /
$04:920A 20 85 98 JSR.W OW_TilePos_Calc ; Compute the tile offset into [$04] (OW_TilePos_Calc)
$04:920D E2 20 SEP #$20 ; A 8-bit
$04:920F AE D5 0D LDX.W $0DD5 ; \
$04:9212 F0 46 BEQ OWPU_NotAutoWalk ; / If no auto-walk ([$0DD5] = 0), go to OWPU_NotAutoWalk
$04:9214 CA DEX ; X = exit type - 1
$04:9215 BD 60 90 LDA.W $9060,X ; A = shift count for this exit type ($9060)
$04:9218 85 08 STA $08 ; [$08] = shift count
$04:921A 64 09 STZ $09 ; [$09] = 0
$04:921C C2 30 REP #$30 ; A, X and Y 16-bit
$04:921E A6 04 LDX $04 ; X = [$04] (tile offset)
$04:9220 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:9224 29 FF 00 AND.W #$00FF ; / A = level number of this tile ($7E:D000)
$04:9227 A0 0A 00 LDY.W #$000A ; Y = $0A: last word of $906C
$04:922A D9 6C 90 CMP.W $906C,Y ; Compare with the level numbers where auto-walk ends
$04:922D D0 0C BNE $923B ; No match: try next
$04:922F A9 05 00 LDA.W #$0005 ; A = 5
$04:9232 8D D9 13 STA.W $13D9 ; [$13D9] = 5: next overworld event
$04:9235 20 37 90 JSR.W $9037 ; Copy the level flags to the save buffer ($9037)
$04:9238 82 D6 01 BRL $9411 ; Leave through $049411
$04:923B 88 DEY ; Y -= 2
$04:923C 88 DEY ; (second DEY)
$04:923D 10 EB BPL $922A ; Loop over the 6 level numbers
$04:923F BF 00 D8 7E LDA.L $7ED800,X ; \
$04:9243 29 FF 00 AND.W #$00FF ; / A = path-direction byte of this tile ($7E:D800)
$04:9246 A6 08 LDX $08 ; \
$04:9248 F0 04 BEQ $924E ; / X = [$08]; if 0, skip the shifting
$04:924A 4A LSR ; \
$04:924B CA DEX ; } Shift the byte right by [$08] + 1 bits
$04:924C 10 FC BPL $924A ; /
$04:924E 29 03 00 AND.W #$0003 ; \
$04:9251 0A ASL ; / A = (2-bit field) * 2: direction index
$04:9252 AA TAX ; X = direction index
$04:9253 BD 64 90 LDA.W $9064,X ; A = direction (0 up, 2 down, 4 left, 6 right) from $9064
$04:9256 A8 TAY ; Y = direction
$04:9257 4C BC 92 JMP.W $92BC ; Continue as if that direction was pressed ($0492BC)
; |
; V This routine was commented by Nicol Bolas. The spacing is weird, but you get the idea.
; Parameters:
; $00: 16-bit Overworld X position.
; $02: 16-bit Overworld Y position.
; $04: 16-bit offset to the current tile we are standing on.
; Workspace (temporary memory that is overwritten)
; $06. Cleared, for no apparent reason. May mean something to later code.
; $08. Used to store $04 temporarily, as it calls a routine that bashes $04.
;;; $925A: Overworld: start walking from a level tile (OWPU_NotAutoWalk) ;;;
;; Reads the d-pad. No direction: after [$144E] frames makes the player face down. Direction: allowed only if
;; the level's flags
;; ([$1EA2]) enable it (tile $82 always allows). Checks the neighboring tile: tiles $01-$86 are walked onto,
;; otherwise tries the
;; hardcoded paths ($9078). Sets target position [$0DC7], facing, [$144E] = $0F, advances [$13D9] (state
;; 4) and exits to $049831.
;; Comments in the source describe this routine in detail (Nicol Bolas). Corner tiles ($A03C) use custom
;; offsets instead of 8 pixels.
$04:925A E2 30 SEP #$30 ; A, X and Y 8-bit
$04:925C 9C D5 0D STZ.W $0DD5 ; Exit type [$0DD5] = 0
$04:925F A5 16 LDA $16 ; A = [$16] (buttons newly pressed)
$04:9261 29 0F AND.B #$0F ; Isolate the d-pad
$04:9263 F0 09 BEQ $926E ; None pressed: go to the idle facing code
$04:9265 AE C1 13 LDX.W $13C1 ; X = [$13C1] (tile under player)
$04:9268 E0 82 CPX.B #$82 ; Pipe tile $82?
$04:926A F0 41 BEQ $92AD ; Yes: all directions allowed, skip the flag check
$04:926C 80 1E BRA $928C ; Check this level's exit flags
; Logic: If the player stands on a tile motionless for long enough,
; change the character's facing to "down".
$04:926E CE 4E 14 DEC.W $144E ; Idle timer [$144E]--
$04:9271 10 14 BPL $9287 ; Still positive: leave
$04:9273 9C 4E 14 STZ.W $144E ; [$144E] = 0
$04:9276 AD D6 0D LDA.W $0DD6 ; \
$04:9279 4A LSR ; |
$04:927A 29 02 AND.B #$02 ; } X = player number * 2
$04:927C AA TAX ; /
$04:927D BD 13 1F LDA.W $1F13,X ; A = animation of this player
$04:9280 29 08 AND.B #$08 ; Keep the swimming bit
$04:9282 09 02 ORA.B #$02 ; Add facing 2 (down)
$04:9284 9D 13 1F STA.W $1F13,X ; Store: character faces down
$04:9287 C2 30 REP #$30 ; A, X and Y 16-bit
$04:9289 4C 31 98 JMP.W $9831 ; Exit through $049831 (next phase of overworld processing)
; Logic: The user is on a level tile and has pressed a direction.
; We must now determine whether to move in that direction. We can only do so if
; the level has been passed. This code detects that.
; The directional input is in register A.
$04:928C C2 30 REP #$30 ; A, X and Y 16-bit
$04:928E 29 FF 00 AND.W #$00FF ; A = d-pad bits only
$04:9291 EA NOP ; \
$04:9292 EA NOP ; } Padding NOPs (room for a removed JMP $92AF debug skip)
$04:9293 EA NOP ; /
$04:9294 48 PHA ; Save the d-pad bits
$04:9295 64 06 STZ $06 ; [$06] = 0
$04:9297 A6 04 LDX $04 ; X = [$04] (tile offset of the level)
$04:9299 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:929D 29 FF 00 AND.W #$00FF ; / A = level number of this tile
$04:92A0 AA TAX ; X = level number
$04:92A1 68 PLA ; Restore the d-pad bits
$04:92A2 3D A2 1E AND.W $1EA2,X ; \
$04:92A5 29 0F 00 AND.W #$000F ; / A = d-pad bits that are enabled in this level's flags [$1EA2,X]
$04:92A8 D0 03 BNE $92AD ; At least one allowed: move
$04:92AA 4C 11 94 JMP.W $9411 ; Blocked: leave through $049411
; Logic: If we're here, then the level does not prevent movement in that direction.
; Now we must check the tile in that direction to see if it is an appropriate path.
; The direction to travel in is still in register A.
; Note: Level tile 0x82 (a Pipe tile) always allows movement in any direction,
; so it jumps directly here.
$04:92AD C2 30 REP #$30 ; A, X and Y 16-bit
$04:92AF 29 FF 00 AND.W #$00FF ; A = d-pad bits only
$04:92B2 A0 06 00 LDY.W #$0006 ; \
$04:92B5 4A LSR ; |
$04:92B6 B0 04 BCS $92BC ; |
$04:92B8 88 DEY ; |
$04:92B9 88 DEY ; } Y = direction of the pressed d-pad bit: 0 up, 2 down, 4 left, 6 right
$04:92BA 10 F9 BPL $92B5 ; /
$04:92BC 98 TYA ; A = direction
$04:92BD 8D D3 0D STA.W $0DD3 ; [$0DD3] = direction
$04:92C0 A2 00 00 LDX.W #$0000 ; \
$04:92C3 C0 04 00 CPY.W #$0004 ; |
$04:92C6 B0 03 BCS $92CB ; } X = 0 if moving horizontally ($00 = X), 2 if vertically ($02 = Y)
$04:92C8 A2 02 00 LDX.W #$0002 ; /
$04:92CB A5 04 LDA $04 ; \
$04:92CD 85 08 STA $08 ; / [$08] = current tile offset (saved, [$04] will change)
$04:92CF B5 00 LDA $00,X ; \
$04:92D1 18 CLC ; |
$04:92D2 79 58 90 ADC.W $9058,Y ; } Move [$00] or [$02] one tile in the pressed direction
$04:92D5 95 00 STA $00,X ; /
$04:92D7 AD D6 0D LDA.W $0DD6 ; \
$04:92DA 4A LSR ; |
$04:92DB 4A LSR ; } X = player number
$04:92DC AA TAX ; /
$04:92DD 20 85 98 JSR.W $9885 ; Compute the neighboring tile offset into [$04] (OW_TilePos_Calc)
$04:92E0 A6 04 LDX $04 ; X = [$04]; negative: no tile there
$04:92E2 30 1D BMI $9301 ; Negative offset: check the hardcoded paths
$04:92E4 C9 00 08 CMP.W #$0800 ; Offset >= $0800?
$04:92E7 B0 18 BCS $9301 ; Yes: off the map, check the hardcoded paths
$04:92E9 BF 00 C8 7E LDA.L $7EC800,X ; \
$04:92ED 29 FF 00 AND.W #$00FF ; / A = tile number of the neighboring tile
$04:92F0 F0 0F BEQ $9301 ; Empty tile (0): check the hardcoded paths
$04:92F2 C9 56 00 CMP.W #$0056 ; Tile < $56 (path tile)?
$04:92F5 90 07 BCC $92FE ; Yes: walk onto it
$04:92F7 C9 87 00 CMP.W #$0087 ; Tile < $87 (level tile)?
$04:92FA 90 02 BCC $92FE ; Yes: walk onto it
$04:92FC 80 03 BRA $9301 ; Anything else: check the hardcoded paths
$04:92FE 82 83 00 BRL $9384 ; Walk to the new tile ($049384)
; Logic: There is no tile in the direction the user pressed. Even so, this level may have a
; hardcoded path. Check for this. If it does, get the first tile for that path and make sure
; that it matches with the direction we pressed.
; This section is one big loop over the array at $9078. That is a byte array of level
; numbers that have hardcoded paths.
$04:9301 9C 78 1B STZ.W $1B78 ; [$1B78] = 0 (not on a hardcoded path)
$04:9304 9C 7A 1B STZ.W $1B7A ; [$1B7A] = 0
$04:9307 A6 08 LDX $08 ; X = [$08] (the level's tile offset)
$04:9309 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:930D 29 FF 00 AND.W #$00FF ; / A = level number of the tile we stand on
$04:9310 85 00 STA $00 ; [$00] = level number
$04:9312 A2 09 00 LDX.W #$0009 ; X = 9: loop over 10 paths
$04:9315 BD 78 90 LDA.W $9078,X ; \
$04:9318 29 FF 00 AND.W #$00FF ; / A = level number of path X ($9078)
$04:931B C9 FF 00 CMP.W #$00FF ; \
$04:931E D0 29 BNE $9349 ; / Not $FF: compare with our level at $049349
$04:9320 DA PHX ; Save X
$04:9321 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9324 BD 19 1F LDA.W $1F19,X ; A = player Y position
$04:9327 CD 82 90 CMP.W $9082 ; \
$04:932A D0 1A BNE $9346 ; / Not the pipe's Y position: next path
$04:932C BD 17 1F LDA.W $1F17,X ; A = player X position
$04:932F CD 84 90 CMP.W $9084 ; \
$04:9332 D0 12 BNE $9346 ; / Not the pipe's X position: next path
$04:9334 AD B3 0D LDA.W $0DB3 ; \
$04:9337 29 FF 00 AND.W #$00FF ; } X = [$0DB3] (current player)
$04:933A AA TAX ; /
$04:933B BD 11 1F LDA.W $1F11,X ; \
$04:933E 29 FF 00 AND.W #$00FF ; } Not on the main map (submap [$1F11,X] != 0): next path
$04:9341 D0 03 BNE $9346 ; /
$04:9343 FA PLX ; Restore X
$04:9344 80 07 BRA $934D ; Pipe matched: use this path
$04:9346 FA PLX ; Restore X
$04:9347 80 2B BRA $9374 ; Next path
$04:9349 C5 00 CMP $00 ; \
$04:934B D0 27 BNE $9374 ; / Level number matches [$00]? Otherwise next path
; We have a match for a hardcoded path, either through level number or through character position.
; Now we have to see if the first tile of this path is appropriate for us to move though.
$04:934D 86 00 STX $00 ; [$00] = path index
$04:934F BD 0E 91 LDA.W $910E,X ; \
$04:9352 29 FF 00 AND.W #$00FF ; } X = offset of this path in the tile lists ($910E)
$04:9355 AA TAX ; /
$04:9356 3A DEC A ; \
$04:9357 8D 7A 1B STA.W $1B7A ; / [$1B7A] = offset - 1 (index of the last tile walked)
$04:935A 84 02 STY $02 ; [$02] = pressed direction (Y)
$04:935C BD CA 90 LDA.W $90CA,X ; \
$04:935F 29 FF 00 AND.W #$00FF ; } A = direction of the path's first tile ($90CA)
$04:9362 C5 02 CMP $02 ; /
$04:9364 D0 14 BNE $937A ; Differs from the pressed direction: no path, give up
$04:9366 A9 01 00 LDA.W #$0001 ; \
$04:9369 8D 78 1B STA.W $1B78 ; / [$1B78] = 1: committed to a hardcoded path
$04:936C BD 86 90 LDA.W $9086,X ; \
$04:936F 29 FF 00 AND.W #$00FF ; / A = first tile of the path ($9086)
$04:9372 80 10 BRA $9384 ; Walk to that tile
$04:9374 CA DEX ; \
$04:9375 30 03 BMI $937A ; / Next path: X--, stop below 0
$04:9377 82 9B FF BRL $9315 ; Loop
$04:937A E2 20 SEP #$20 ; \
$04:937C 9C D5 0D STZ.W $0DD5 ; } No path found: exit type [$0DD5] = 0
$04:937F C2 20 REP #$20 ; /
$04:9381 4C 11 94 JMP.W $9411 ; Leave through $049411
; Logic: Register A has the actual next tile in it, whether it came from a hardcoded path or
; from the overwrold.
; This section computes the offset values for the character to move. This matters because
; the current tile is a level tile; it doesn't have intrinsic path data. So we have to generate
; some. in $00 and $02, but which dimension is X and Y is determined by the contents of Register X.
$04:9384 8D C1 13 STA.W $13C1 ; [$13C1] = tile number we walk onto
$04:9387 85 00 STA $00 ; [$00] = tile number
$04:9389 64 02 STZ $02 ; [$02] = 0
$04:938B A2 17 00 LDX.W #$0017 ; X = $17: loop over 24 corner tiles
$04:938E BD 3C A0 LDA.W $A03C,X ; \
$04:9391 29 FF 00 AND.W #$00FF ; / A = corner tile number ($A03C)
$04:9394 C5 00 CMP $00 ; Compare with the destination tile
$04:9396 D0 1D BNE $93B5 ; No match: next corner tile
$04:9398 BD E4 A0 LDA.W $A0E4,X ; \
$04:939B 18 CLC ; } A = flags for this corner ($A0E4) + [$0DD6] (bit 2 = Luigi)
$04:939C 6D D6 0D ADC.W $0DD6 ; /
$04:939F 48 PHA ; Save the flags
$04:93A0 8A TXA ; \
$04:93A1 0A ASL ; |
$04:93A2 0A ASL ; } X = X * 4: index into the 4-byte offset table
$04:93A3 AA TAX ; /
$04:93A4 BD 84 A0 LDA.W $A084,X ; A = first offset ($A084)
$04:93A7 85 00 STA $00 ; [$00] = first offset
$04:93A9 BD 86 A0 LDA.W $A086,X ; A = second offset ($A086)
$04:93AC 85 02 STA $02 ; [$02] = second offset
$04:93AE 68 PLA ; Restore the flags
$04:93AF 29 FF 00 AND.W #$00FF ; Keep the low byte
$04:93B2 AA TAX ; X = flags
$04:93B3 80 25 BRA $93DA ; Go store the offsets
$04:93B5 CA DEX ; \
$04:93B6 10 D6 BPL $938E ; / Next corner tile
$04:93B8 A2 08 00 LDX.W #$0008 ; X = 8: plain step of 8 pixels
$04:93BB 98 TYA ; \
$04:93BC 29 02 00 AND.W #$0002 ; } Down and right keep +8
$04:93BF D0 06 BNE $93C7 ; /
$04:93C1 8A TXA ; \
$04:93C2 49 FF FF EOR.W #$FFFF ; |
$04:93C5 1A INC A ; } Up and left: X = -8
$04:93C6 AA TAX ; /
$04:93C7 86 00 STX $00 ; [$00] = +8 or -8
$04:93C9 A2 00 00 LDX.W #$0000 ; X = 0 if moving horizontally
$04:93CC C0 04 00 CPY.W #$0004 ; Y >= 4 (left/right)?
$04:93CF B0 03 BCS $93D4 ; Yes: X = 0
$04:93D1 A2 02 00 LDX.W #$0002 ; No: X = 2 (vertical)
$04:93D4 8A TXA ; \
$04:93D5 18 CLC ; |
$04:93D6 6D D6 0D ADC.W $0DD6 ; } X = X + [$0DD6]: index into this player's X/Y position
$04:93D9 AA TAX ; /
; Logic: The offsets have been computed, and in Register X is the switch that tells us
; which offset is horizontal and which is vertical, as well as which character to use.
; Apply those offsets now, set the character's sprite appropriately.
; Remember: Y still has the direction the user pressed.
$04:93DA A5 00 LDA $00 ; \
$04:93DC 18 CLC ; |
$04:93DD 7D 17 1F ADC.W $1F17,X ; } Target position (first axis) = position + [$00]; stored in [$0DC7,X]
$04:93E0 9D C7 0D STA.W $0DC7,X ; /
$04:93E3 8A TXA ; \
$04:93E4 49 02 00 EOR.W #$0002 ; } X = X xor 2: the other axis
$04:93E7 AA TAX ; /
$04:93E8 A5 02 LDA $02 ; \
$04:93EA 18 CLC ; |
$04:93EB 7D 17 1F ADC.W $1F17,X ; } Target position (second axis) = position + [$02]
$04:93EE 9D C7 0D STA.W $0DC7,X ; /
$04:93F1 8A TXA ; \
$04:93F2 4A LSR ; |
$04:93F3 29 02 00 AND.W #$0002 ; } X = player number * 2
$04:93F6 AA TAX ; /
$04:93F7 98 TYA ; A = direction
$04:93F8 85 00 STA $00 ; [$00] = direction
$04:93FA BD 13 1F LDA.W $1F13,X ; A = player animation
$04:93FD 29 08 00 AND.W #$0008 ; Keep the swimming bit
$04:9400 05 00 ORA $00 ; Add the facing direction
$04:9402 9D 13 1F STA.W $1F13,X ; Player now faces the way he walks
$04:9405 A9 0F 00 LDA.W #$000F ; \
$04:9408 8D 4E 14 STA.W $144E ; / [$144E] = $0F (idle timer)
$04:940B EE D9 13 INC.W $13D9 ; Next overworld state: [$13D9]++ (player moves)
$04:940E 9C 44 14 STZ.W $1444 ; [$1444] = 0
$04:9411 4C 31 98 JMP.W $9831 ; Go to the next phase of overworld processing ($049831)
;;; $9414..942E: Data: overworld movement tables ;;;
;; Tables used by the movement code after this chunk. Meaning only partly known: scale bytes, word offsets and
;; the d-pad direction bits.
$04:9414 .db $0D,$08 ; Bytes $0D, $08 (indexed by [$1B80], used for scaling in the move code)
$04:9416 .db $EF,$FF,$D7,$FF ; Words $FFEF, $FFD7 (-17, -41)
$04:941A .db $11,$01,$31,$01 ; Words $0111, $0131
$04:941E .db $08,$00,$04,$00,$02,$00,$01,$00 ; Words 8, 4, 2, 1: d-pad direction bits (up, down, left, right) as level flags
$04:9426 .db $44,$43,$45,$46,$47,$48,$25,$40 ; Tile numbers: $44,$43,$45,$46,$47,$48,$25,$40
$04:942E .db $42,$4D ; Tile numbers: $42,$4D
;;; $9430..9449: Data: tile/direction pairs and flags ;;;
;; Table of (value, direction) pairs scanned from X = $1C down; a matching pair picks a flag from the table at
;; $04944E.
$04:9430 .db $0C ; (Tile or value, direction) pairs, 15 entries; first value $0C
$04:9431 .db $00,$0E,$00,$10,$06,$12,$00,$18 ; Pairs: (00),$0E,00,$10,06,$12,00,$18
$04:9439 .db $04,$1A,$02,$20,$06,$42,$06,$4E ; Pairs: 04,$1A,02,$20,06,$42,06,$4E
$04:9441 .db $04,$50,$02,$58,$06,$5A,$00,$70 ; Pairs: 04,$50,02,$58,06,$5A,00,$70
$04:9449 .db $06,$90,$00,$A0,$06 ; Pairs: 06,$90,00,$A0,06
;;; $944E..9456: Data: flags per tile/direction pair ;;;
$04:944E .db $01,$01,$00,$01,$01,$00,$00,$00 ; Flags per pair above (0 or 1), indexed by pair number
$04:9456 .db $01,$00,$00,$01,$00,$01,$00 ; Flags per pair above (cont.)
;;; $945D: OW process 4: Mario walks along the path ;;;
;; Overworld process [$13D9] = 4 (entry 4 of PtrsLong04857D). Moves the current player ([$0DD6] = 0 Mario, 4
;; Luigi) from tile to tile.
;; Destination [$0DC7]/[$0DC9] is the corner of the next path piece. The speed is split between the axes so
;; the walk is straight: major axis
;; speed from $9414 (set [$1B80]), minor = major * minor distance / major distance; 8.8 fixed point,
;; fraction kept in [$13D5]/[$13D7].
;; On arrival it picks the next direction (0 up, 2 down, 4 left, 6 right, never reversing) from the tile map
;; $7EC800 or the hardcoded path
;; ([$1B78]), rejects empty and non-walkable (>= $87) tiles, sets the sound, the exit flags in [$1EA2] and the
;; walking animation [$1F13].
;; Level tile reached (tile step already begun, [$1444] set): writes the level name and advances to process 5.
;; Special tiles start a submap
;; transition (process $0A).
;; $049831: shared tail, centers the BG1/BG2 scroll on the player (main map only), clamped to
;; $9416/$941A. $04983F: entry for the camera only.
;; Called by:
;; $04:97FE: OW process 4: Mario walks along the path
$04:945D AD D8 0D LDA.W $0DD8 ; [$0DD8] (probably a submap/transition pending flag) non-zero?
$04:9460 F0 06 BEQ $9468 ; Zero: walk normally
$04:9462 A9 08 LDA.B #$08 ; \
$04:9464 8D D9 13 STA.W $13D9 ; / OW process [$13D9] = 8
$04:9467 60 RTS ; Return
$04:9468 C2 30 REP #$30 ; A, X and Y 16-bit
$04:946A AD D6 0D LDA.W $0DD6 ; \
$04:946D 18 CLC ; |
$04:946E 69 02 00 ADC.W #$0002 ; } Y = [$0DD6] + 2: Y-axis entry of the current player (Mario 0, Luigi 4)
$04:9471 A8 TAY ; /
$04:9472 A2 02 00 LDX.W #$0002 ; X = 2: axis index (2 = Y, 0 = X)
$04:9475 B9 C7 0D LDA.W $0DC7,Y ; \
$04:9478 38 SEC ; |
$04:9479 F9 17 1F SBC.W $1F17,Y ; } [$00+X] = destination [$0DC7+Y] - current position [$1F17+Y] (signed distance left)
$04:947C 95 00 STA $00,X ; /
$04:947E 10 04 BPL $9484 ; Positive: keep it
$04:9480 49 FF FF EOR.W #$FFFF ; \
$04:9483 1A INC A ; / Negative: A = -A
$04:9484 95 04 STA $04,X ; [$04+X] = |distance| on this axis ([$04] = X, [$06] = Y)
$04:9486 88 DEY ; \
$04:9487 88 DEY ; |
$04:9488 CA DEX ; } Y -= 2, X -= 2
$04:9489 CA DEX ; /
$04:948A 10 E9 BPL $9475 ; Loop for the X axis, then done
$04:948C A0 FF FF LDY.W #$FFFF ; Y = -1: assume X is the major (longer) axis
$04:948F A5 04 LDA $04 ; \
$04:9491 85 0A STA $0A ; |
$04:9493 A5 06 LDA $06 ; } [$0A] = |dX| (major), [$0C] = |dY| (minor)
$04:9495 85 0C STA $0C ; /
$04:9497 C5 04 CMP $04 ; Compare |dY| with |dX|
$04:9499 90 09 BCC $94A4 ; |dY| < |dX|: X is the major axis
$04:949B 85 0A STA $0A ; \
$04:949D A5 04 LDA $04 ; } Otherwise swap: [$0A] = |dY| (major), [$0C] = |dX| (minor)
$04:949F 85 0C STA $0C ; /
$04:94A1 A0 01 00 LDY.W #$0001 ; Y = 1: Y is the major axis
$04:94A4 84 08 STY $08 ; [$08] = -1 (X major) or 1 (Y major)
$04:94A6 E2 20 SEP #$20 ; A 8-bit
$04:94A8 AE 80 1B LDX.W $1B80 ; X = [$1B80]: speed set (1 on tiles with property $14, else 0)
$04:94AB BD 14 94 LDA.W $9414,X ; \
$04:94AE 0A ASL ; |
$04:94AF 0A ASL ; } A = $9414[X] * 16 (speed 13 or 8, scaled by 16)
$04:94B0 0A ASL ; |
$04:94B1 0A ASL ; /
$04:94B2 8D 02 42 STA.W $4202 ; Hardware multiplicand = speed * 16
$04:94B5 A5 0C LDA $0C ; A = minor axis distance
$04:94B7 F0 21 BEQ $94DA ; Zero: minor axis speed is 0
$04:94B9 8D 03 42 STA.W $4203 ; Hardware multiplier = minor distance
$04:94BC EA NOP ; \
$04:94BD EA NOP ; |
$04:94BE EA NOP ; } Wait for the multiplier
$04:94BF EA NOP ; /
$04:94C0 C2 20 REP #$20 ; A 16-bit
$04:94C2 AD 16 42 LDA.W $4216 ; \
$04:94C5 8D 04 42 STA.W $4204 ; / Hardware dividend = speed * 16 * minor distance
$04:94C8 E2 20 SEP #$20 ; A 8-bit
$04:94CA A5 0A LDA $0A ; \
$04:94CC 8D 06 42 STA.W $4206 ; / Hardware divisor = major distance
$04:94CF EA NOP ; \
$04:94D0 EA NOP ; |
$04:94D1 EA NOP ; |
$04:94D2 EA NOP ; } Wait for the divider
$04:94D3 EA NOP ; |
$04:94D4 EA NOP ; /
$04:94D5 C2 20 REP #$20 ; A 16-bit
$04:94D7 AD 14 42 LDA.W $4214 ; A = minor axis speed = major speed * minor / major (8.8 fixed point)
$04:94DA C2 20 REP #$20 ; A 16-bit
$04:94DC 85 0E STA $0E ; [$0E] = minor axis speed
$04:94DE AE 80 1B LDX.W $1B80 ; X = [$1B80]
$04:94E1 BD 14 94 LDA.W $9414,X ; \
$04:94E4 29 FF 00 AND.W #$00FF ; |
$04:94E7 0A ASL ; |
$04:94E8 0A ASL ; } A = $9414[X] * 16 (major axis speed, 8.8 fixed point)
$04:94E9 0A ASL ; |
$04:94EA 0A ASL ; /
$04:94EB 85 0A STA $0A ; [$0A] = major axis speed
$04:94ED A2 02 00 LDX.W #$0002 ; X = 2: start with the Y axis
$04:94F0 A5 08 LDA $08 ; \
$04:94F2 30 04 BMI $94F8 ; / A = [$08]; negative means X is the major axis
$04:94F4 A5 0A LDA $0A ; \
$04:94F6 80 02 BRA $94FA ; / Y is major: this axis gets the major speed
$04:94F8 A5 0E LDA $0E ; X is major: the Y axis gets the minor speed
$04:94FA 34 00 BIT $00,X ; Test the sign of the distance on this axis
$04:94FC 10 04 BPL $9502 ; Distance positive: keep the speed
$04:94FE 49 FF FF EOR.W #$FFFF ; \
$04:9501 1A INC A ; / Distance negative: A = -A
$04:9502 9D CF 0D STA.W $0DCF,X ; [$0DCF+X] = signed speed on this axis (X = 0: X speed, X = 2: Y speed)
$04:9505 A5 08 LDA $08 ; \
$04:9507 49 FF FF EOR.W #$FFFF ; |
$04:950A 1A INC A ; } [$08] = -[$08]: swap the roles for the other axis
$04:950B 85 08 STA $08 ; /
$04:950D CA DEX ; \
$04:950E CA DEX ; / X -= 2
$04:950F 10 DF BPL $94F0 ; Loop for the X axis too
$04:9511 A2 00 00 LDX.W #$0000 ; X = 0
$04:9514 A5 08 LDA $08 ; \
$04:9516 30 03 BMI $951B ; / [$08] < 0 (X major): keep X = 0
$04:9518 A2 02 00 LDX.W #$0002 ; Y major: X = 2
$04:951B B5 00 LDA $00,X ; A = remaining distance on the major axis
$04:951D F0 03 BEQ $9522 ; Zero: reached the destination, handle arrival
$04:951F 4C 01 98 JMP.W $9801 ; Not there yet: move this frame
$04:9522 AD 44 14 LDA.W $1444 ; [$1444] (a tile step has been started) non-zero?
$04:9525 F0 35 BEQ $955C ; Zero: choose the next step
$04:9527 9C 78 1B STZ.W $1B78 ; Arrived: [$1B78] = 0 (no longer on the hardcoded path)
$04:952A AE D6 0D LDX.W $0DD6 ; X = [$0DD6]: current player * 4
$04:952D BD 1F 1F LDA.W $1F1F,X ; \
$04:9530 85 00 STA $00 ; / [$00] = player tile X ([$1F1F+X])
$04:9532 BD 21 1F LDA.W $1F21,X ; \
$04:9535 85 02 STA $02 ; / [$02] = player tile Y ([$1F21+X])
$04:9537 8A TXA ; \
$04:9538 4A LSR ; |
$04:9539 4A LSR ; } X = player index (0 Mario, 1 Luigi)
$04:953A AA TAX ; /
$04:953B 20 85 98 JSR.W OW_TilePos_Calc ; Calculate map tile position into [$04] (OW_TilePos_Calc)
$04:953E 64 00 STZ $00 ; [$00] = 0
$04:9540 A6 04 LDX $04 ; X = tile position
$04:9542 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:9546 29 FF 00 AND.W #$00FF ; / A = level number of this tile ($7ED000)
$04:9549 0A ASL ; \
$04:954A AA TAX ; / X = level number * 2
$04:954B BD FC A0 LDA.W LevelNames,X ; A = LevelNames[level number]: level name string index
$04:954E 85 00 STA $00 ; [$00] = name index
$04:9550 20 07 9D JSR.W $9D07 ; Write the level name to the stripe image buffer ($9D07)
$04:9553 EE D9 13 INC.W $13D9 ; OW process [$13D9]++ (next: level name display)
$04:9556 20 37 90 JSR.W $9037 ; Save the level flags copy if [$13CA] is set ($9037)
$04:9559 4C 31 98 JMP.W $9831 ; Go to the camera update
$04:955C AD C1 13 LDA.W $13C1 ; Not arrived at a tile yet: A = current OW tile [$13C1]
$04:955F 8D 7E 1B STA.W $1B7E ; [$1B7E] = previous OW tile
$04:9562 A9 08 00 LDA.W #$0008 ; \
$04:9565 85 08 STA $08 ; / [$08] = 8: direction candidate counter
$04:9567 AC D3 0D LDY.W $0DD3 ; Y = [$0DD3]: current direction (0 up, 2 down, 4 left, 6 right)
$04:956A 98 TYA ; \
$04:956B 29 FF 00 AND.W #$00FF ; |
$04:956E 49 02 00 EOR.W #$0002 ; } [$0A] = Y XOR 2: the reverse direction
$04:9571 85 0A STA $0A ; /
$04:9573 80 0D BRA $9582 ; Try the current direction first
$04:9575 A5 08 LDA $08 ; \
$04:9577 38 SEC ; |
$04:9578 E9 02 00 SBC.W #$0002 ; } [$08] -= 2: next candidate direction (6, 4, 2, 0)
$04:957B 85 08 STA $08 ; /
$04:957D C5 0A CMP $0A ; \
$04:957F F0 F4 BEQ $9575 ; / Skip the reverse direction
$04:9581 A8 TAY ; Y = candidate direction
$04:9582 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9585 BD 1F 1F LDA.W $1F1F,X ; \
$04:9588 85 00 STA $00 ; |
$04:958A BD 21 1F LDA.W $1F21,X ; } [$00] = player tile X, [$02] = player tile Y
$04:958D 85 02 STA $02 ; /
$04:958F A2 00 00 LDX.W #$0000 ; X = 0: change tile X
$04:9592 C0 04 00 CPY.W #$0004 ; \
$04:9595 B0 03 BCS $959A ; / Direction left or right (Y >= 4): keep X = 0
$04:9597 A2 02 00 LDX.W #$0002 ; Direction up or down: X = 2 (change tile Y)
$04:959A B5 00 LDA $00,X ; \
$04:959C 18 CLC ; |
$04:959D 79 58 90 ADC.W $9058,Y ; } Tile coordinate += $9058[Y] (-1 or +1): the neighbour tile in that direction
$04:95A0 95 00 STA $00,X ; /
$04:95A2 AD D6 0D LDA.W $0DD6 ; \
$04:95A5 4A LSR ; |
$04:95A6 4A LSR ; } X = player index
$04:95A7 AA TAX ; /
$04:95A8 20 85 98 JSR.W OW_TilePos_Calc ; Calculate tile position of that neighbour into [$04] (OW_TilePos_Calc)
$04:95AB AD 78 1B LDA.W $1B78 ; Following the hardcoded path ([$1B78] non-zero)?
$04:95AE F0 1E BEQ $95CE ; No: read the tile from the map
$04:95B0 84 06 STY $06 ; [$06] = direction
$04:95B2 AE 7A 1B LDX.W $1B7A ; \
$04:95B5 E8 INX ; / X = [$1B7A] + 1: next step of the hardcoded path
$04:95B6 BD CA 90 LDA.W $90CA,X ; \
$04:95B9 29 FF 00 AND.W #$00FF ; } Does the path step's direction ($90CA) equal the candidate direction?
$04:95BC C5 06 CMP $06 ; /
$04:95BE D0 B5 BNE $9575 ; No: try the next direction
$04:95C0 8E 7A 1B STX.W $1B7A ; [$1B7A] = path step
$04:95C3 BD 86 90 LDA.W $9086,X ; \
$04:95C6 29 FF 00 AND.W #$00FF ; / A = tile number of the path step ($9086)
$04:95C9 C9 58 00 CMP.W #$0058 ; \
$04:95CC D0 10 BNE $95DE ; / Tile $58 (path end): read the real tile from the map, else use A
$04:95CE A6 04 LDX $04 ; X = tile position
$04:95D0 30 A3 BMI $9575 ; Off the map: try the next direction
$04:95D2 C9 00 08 CMP.W #$0800 ; \
$04:95D5 B0 9E BCS $9575 ; / Position out of range: try the next direction
$04:95D7 BF 00 C8 7E LDA.L $7EC800,X ; \
$04:95DB 29 FF 00 AND.W #$00FF ; / Load OW tile number from the map ($7EC800)
$04:95DE 8D C1 13 STA.W $13C1 ; Set "Current OW tile"
$04:95E1 F0 92 BEQ $9575 ; No tile: try the next direction
$04:95E3 C9 87 00 CMP.W #$0087 ; \
$04:95E6 B0 8D BCS $9575 ; / Tile >= $87: not walkable, try the next direction
$04:95E8 48 PHA ; Save tile number
$04:95E9 5A PHY ; Save direction
$04:95EA AA TAX ; \
$04:95EB CA DEX ; / X = tile number - 1
$04:95EC A0 00 00 LDY.W #$0000 ; Y = 0
$04:95EF BD EB 9F LDA.W $9FEB,X ; A = tile property byte ($9FEB)
$04:95F2 85 0E STA $0E ; [$0E] = tile property (used for the walking animation)
$04:95F4 29 FF 00 AND.W #$00FF ; \
$04:95F7 C9 14 00 CMP.W #$0014 ; / Property low byte = $14?
$04:95FA D0 03 BNE $95FF ; No: speed set 0
$04:95FC A0 01 00 LDY.W #$0001 ; Yes: speed set 1 (slower walking speed, $9414)
$04:95FF 8C 80 1B STY.W $1B80 ; [$1B80] = speed set
$04:9602 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9605 A5 00 LDA $00 ; \
$04:9607 9D 1F 1F STA.W $1F1F,X ; / Player tile X = new tile X
$04:960A A5 02 LDA $02 ; \
$04:960C 9D 21 1F STA.W $1F21,X ; / Player tile Y = new tile Y
$04:960F 7A PLY ; Restore direction
$04:9610 68 PLA ; \
$04:9611 48 PHA ; / Restore tile number (kept on the stack)
$04:9612 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:9614 A2 09 LDX.B #$09 ; X = 9: 10 submap transition tiles
$04:9616 DD 26 94 CMP.W $9426,X ; \
$04:9619 D0 2A BNE $9645 ; / Is the tile $9426[X]? No: next entry
$04:961B 5A PHY ; Match: save direction
$04:961C 20 24 9A JSR.W $9A24 ; Look up the submap transition for the current position ($9A24)
$04:961F 7A PLY ; Restore direction
$04:9620 A9 01 LDA.B #$01 ; \
$04:9622 8D 9E 1B STA.W $1B9E ; / [$1B9E] = 1
$04:9625 20 07 F4 JSR.W $F407 ; Clear window mirrors [$41]-[$43] and HDMA enable ($F407)
$04:9628 9C 8C 1B STZ.W $1B8C ; [$1B8C] = 0
$04:962B C2 20 REP #$20 ; A 16-bit
$04:962D 9C 01 07 STZ.W $0701 ; [$0701] = 0 (backdrop color)
$04:9630 A9 00 70 LDA.W #$7000 ; \
$04:9633 8D 8D 1B STA.W $1B8D ; / [$1B8D] = $7000
$04:9636 A9 00 54 LDA.W #$5400 ; \
$04:9639 8D 8F 1B STA.W $1B8F ; / [$1B8F] = $5400
$04:963C E2 20 SEP #$20 ; A 8-bit
$04:963E A9 0A LDA.B #$0A ; \
$04:9640 8D D9 13 STA.W $13D9 ; / OW process [$13D9] = $0A (submap transition)
$04:9643 80 03 BRA $9648 ; Skip the rest of the search
$04:9645 CA DEX ; \
$04:9646 10 CE BPL $9616 ; / Next table entry
$04:9648 C2 30 REP #$30 ; A, X and Y 16-bit
$04:964A 68 PLA ; \
$04:964B 48 PHA ; / Peek at the tile number
$04:964C C9 56 00 CMP.W #$0056 ; \
$04:964F B0 03 BCS $9654 ; / Tile >= $56 (level or special tile)? Yes: continue
$04:9651 4C 1D 97 JMP.W $971D ; Tile < $56 (plain path piece): use its path data
$04:9654 C9 80 00 CMP.W #$0080 ; \
$04:9657 F0 0A BEQ $9663 ; / Tile $80: treat as a special tile
$04:9659 C9 6A 00 CMP.W #$006A ; \
$04:965C 90 18 BCC $9676 ; / Tile < $6A: not special
$04:965E C9 6E 00 CMP.W #$006E ; \
$04:9661 B0 13 BCS $9676 ; / Tile >= $6E: not special
$04:9663 AD D6 0D LDA.W $0DD6 ; \
$04:9666 4A LSR ; |
$04:9667 29 02 00 AND.W #$0002 ; } X = player index * 2 (word index into [$1F13])
$04:966A AA TAX ; /
$04:966B BD 13 1F LDA.W $1F13,X ; \
$04:966E 09 08 00 ORA.W #$0008 ; } Set bit 3 of the player animation [$1F13+X]
$04:9671 9D 13 1F STA.W $1F13,X ; /
$04:9674 80 11 BRA $9687 ; Continue
$04:9676 AD D6 0D LDA.W $0DD6 ; \
$04:9679 4A LSR ; |
$04:967A 29 02 00 AND.W #$0002 ; } X = player index * 2
$04:967D AA TAX ; /
$04:967E BD 13 1F LDA.W $1F13,X ; \
$04:9681 29 F7 00 AND.W #$00F7 ; } Clear bit 3 of the player animation [$1F13+X]
$04:9684 9D 13 1F STA.W $1F13,X ; /
$04:9687 A9 01 00 LDA.W #$0001 ; \
$04:968A 8D 44 14 STA.W $1444 ; / [$1444] = 1: a tile step is in progress
$04:968D AD C1 13 LDA.W $13C1 ; \
$04:9690 C9 5F 00 CMP.W #$005F ; } Tile $5F: no sound
$04:9693 F0 10 BEQ $96A5 ; /
$04:9695 C9 5B 00 CMP.W #$005B ; \
$04:9698 F0 0B BEQ $96A5 ; / Tile $5B: no sound
$04:969A C9 82 00 CMP.W #$0082 ; \
$04:969D F0 06 BEQ $96A5 ; / Tile $82: no sound
$04:969F A9 23 00 LDA.W #$0023 ; \
$04:96A2 8D FC 1D STA.W $1DFC ; / Play sound effect $23
$04:96A5 EA NOP ; \
$04:96A6 EA NOP ; } Padding NOPs (probably a removed instruction)
$04:96A7 EA NOP ; /
$04:96A8 AD C1 13 LDA.W $13C1 ; \
$04:96AB 29 FF 00 AND.W #$00FF ; / A = current OW tile
$04:96AE C9 82 00 CMP.W #$0082 ; \
$04:96B1 F0 1F BEQ $96D2 ; / Tile $82: do not mark an exit
$04:96B3 5A PHY ; Save direction
$04:96B4 98 TYA ; \
$04:96B5 29 FF 00 AND.W #$00FF ; |
$04:96B8 49 02 00 EOR.W #$0002 ; } Y = reverse direction (the side we entered the tile from)
$04:96BB A8 TAY ; /
$04:96BC 64 06 STZ $06 ; [$06] = 0
$04:96BE A6 04 LDX $04 ; X = tile position
$04:96C0 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:96C4 29 FF 00 AND.W #$00FF ; / A = level number of the new tile
$04:96C7 AA TAX ; X = level number
$04:96C8 B9 1E 94 LDA.W $941E,Y ; \
$04:96CB 1D A2 1E ORA.W $1EA2,X ; } Set the exit bit of the entry side in [$1EA2+X] (bits from $941E)
$04:96CE 9D A2 1E STA.W $1EA2,X ; /
$04:96D1 7A PLY ; Restore direction
$04:96D2 AD D6 0D LDA.W $0DD6 ; \
$04:96D5 4A LSR ; |
$04:96D6 29 02 00 AND.W #$0002 ; } X = player index * 2
$04:96D9 AA TAX ; /
$04:96DA BD 13 1F LDA.W $1F13,X ; \
$04:96DD 29 0C 00 AND.W #$000C ; } [$0E] = [$1F13+X] & $0C: keep animation bits 2-3
$04:96E0 85 0E STA $0E ; /
$04:96E2 A9 01 00 LDA.W #$0001 ; \
$04:96E5 85 04 STA $04 ; / [$04] = 1: reverse flag for the table lookup below
$04:96E7 AD 7E 1B LDA.W $1B7E ; \
$04:96EA 29 FF 00 AND.W #$00FF ; } [$00] = previous OW tile number
$04:96ED 85 00 STA $00 ; /
$04:96EF A2 17 00 LDX.W #$0017 ; X = $17: search the 24 tiles in $A03C
$04:96F2 BD 3C A0 LDA.W $A03C,X ; \
$04:96F5 29 FF 00 AND.W #$00FF ; } Is $A03C[X] the previous tile?
$04:96F8 C5 00 CMP $00 ; /
$04:96FA D0 08 BNE $9704 ; No: next entry
$04:96FC 8A TXA ; \
$04:96FD 0A ASL ; } X *= 2
$04:96FE AA TAX ; /
$04:96FF BD 54 A0 LDA.W $A054,X ; A = $A054[X]: movement offset word for leaving that tile
$04:9702 80 14 BRA $9718 ; Go store it
$04:9704 CA DEX ; \
$04:9705 10 EB BPL $96F2 ; / Next entry
$04:9707 A9 00 00 LDA.W #$0000 ; \
$04:970A 09 00 08 ORA.W #$0800 ; / Default offset: A = $0800 (dx = 0, dy = +8)
$04:970D C0 04 00 CPY.W #$0004 ; \
$04:9710 90 06 BCC $9718 ; / Direction up or down: keep it
$04:9712 A9 00 00 LDA.W #$0000 ; \
$04:9715 09 08 00 ORA.W #$0008 ; / Direction left or right: A = $0008 (dx = +8, dy = 0)
$04:9718 A2 00 00 LDX.W #$0000 ; X = 0
$04:971B 80 0B BRA $9728 ; Go store the offset
$04:971D 3A DEC A ; \
$04:971E 0A ASL ; } X = (tile - 1) * 2: index into the path piece tables
$04:971F AA TAX ; /
$04:9720 BD 49 9F LDA.W $9F49,X ; \
$04:9723 85 04 STA $04 ; / [$04] = $9F49[X]: reverse flags (byte [$04] up/left, [$05] down/right)
$04:9725 BD A7 9E LDA.W $9EA7,X ; A = $9EA7[X]: movement offset (dx byte, dy byte)
$04:9728 85 00 STA $00 ; [$00] = movement offset ([$00] = dx, [$01] = dy)
$04:972A 8A TXA ; A = X (table index)
$04:972B E2 20 SEP #$20 ; A 8-bit
$04:972D A2 1C 00 LDX.W #$001C ; X = $1C
$04:9730 DD 30 94 CMP.W $9430,X ; \
$04:9733 F0 06 BEQ $973B ; / Is the index one of the special entries in DATA_049430?
$04:9735 CA DEX ; \
$04:9736 CA DEX ; } Next entry
$04:9737 10 F7 BPL $9730 ; /
$04:9739 80 0F BRA $974A ; Not in the list
$04:973B 98 TYA ; In the list: A = direction
$04:973C DD 31 94 CMP.W $9431,X ; \
$04:973F F0 09 BEQ $974A ; / Direction equals the one listed? Then use the default flag selection
$04:9741 8A TXA ; \
$04:9742 4A LSR ; |
$04:9743 AA TAX ; } X = $944E[entry]: which reverse flag to use
$04:9744 BD 4E 94 LDA.W $944E,X ; |
$04:9747 AA TAX ; /
$04:9748 80 0B BRA $9755 ; Go to the flag test
$04:974A A2 00 00 LDX.W #$0000 ; X = 0: flag for up/left
$04:974D 98 TYA ; \
$04:974E 29 02 AND.B #$02 ; } Direction up/left: keep X = 0
$04:9750 F0 03 BEQ $9755 ; /
$04:9752 A2 01 00 LDX.W #$0001 ; Direction down/right: X = 1
$04:9755 B5 04 LDA $04,X ; A = reverse flag [$04+X]
$04:9757 F0 0E BEQ $9767 ; Zero: leave the movement offset as it is
$04:9759 A5 00 LDA $00 ; \
$04:975B 49 FF EOR.B #$FF ; |
$04:975D 1A INC A ; } Negate dx
$04:975E 85 00 STA $00 ; /
$04:9760 A5 01 LDA $01 ; \
$04:9762 49 FF EOR.B #$FF ; |
$04:9764 1A INC A ; } Negate dy
$04:9765 85 01 STA $01 ; /
$04:9767 C2 20 REP #$20 ; A 16-bit
$04:9769 68 PLA ; Restore tile number
$04:976A A2 00 00 LDX.W #$0000 ; X = 0
$04:976D A5 0E LDA $0E ; \
$04:976F 29 07 00 AND.W #$0007 ; } [$0E] & 7 non-zero: test dx
$04:9772 D0 03 BNE $9777 ; /
$04:9774 A2 01 00 LDX.W #$0001 ; Zero: test dy (X = 1)
$04:9777 A5 0E LDA $0E ; \
$04:9779 29 FF 00 AND.W #$00FF ; } [$04] = [$0E] low byte (walking animation base)
$04:977C 85 04 STA $04 ; /
$04:977E B5 00 LDA $00,X ; \
$04:9780 29 FF 00 AND.W #$00FF ; |
$04:9783 C9 80 00 CMP.W #$0080 ; } Is the movement on that axis positive (< $80)?
$04:9786 B0 08 BCS $9790 ; /
$04:9788 A5 04 LDA $04 ; \
$04:978A 18 CLC ; |
$04:978B 69 02 00 ADC.W #$0002 ; } Yes: [$04] += 2 (animation faces the positive direction)
$04:978E 85 04 STA $04 ; /
$04:9790 AD D6 0D LDA.W $0DD6 ; \
$04:9793 4A LSR ; |
$04:9794 29 02 00 AND.W #$0002 ; } X = player index * 2
$04:9797 AA TAX ; /
$04:9798 A5 04 LDA $04 ; \
$04:979A 9D 13 1F STA.W $1F13,X ; / Player animation [$1F13+X] = [$04]
$04:979D AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:97A0 A5 00 LDA $00 ; \
$04:97A2 29 FF 00 AND.W #$00FF ; |
$04:97A5 C9 80 00 CMP.W #$0080 ; } A = dx sign-extended to 16 bits
$04:97A8 90 03 BCC $97AD ; |
$04:97AA 09 00 FF ORA.W #$FF00 ; /
$04:97AD 18 CLC ; \
$04:97AE 7D 17 1F ADC.W $1F17,X ; |
$04:97B1 29 FC FF AND.W #$FFFC ; } [$0DC7+X] = (X position + dx) rounded down to a multiple of 4: destination X
$04:97B4 9D C7 0D STA.W $0DC7,X ; /
$04:97B7 A5 01 LDA $01 ; \
$04:97B9 29 FF 00 AND.W #$00FF ; |
$04:97BC C9 80 00 CMP.W #$0080 ; } A = dy sign-extended to 16 bits
$04:97BF 90 03 BCC $97C4 ; |
$04:97C1 09 00 FF ORA.W #$FF00 ; /
$04:97C4 18 CLC ; \
$04:97C5 7D 19 1F ADC.W $1F19,X ; |
$04:97C8 29 FC FF AND.W #$FFFC ; } [$0DC9+X] = (Y position + dy) rounded down to a multiple of 4: destination Y
$04:97CB 9D C9 0D STA.W $0DC9,X ; /
$04:97CE E2 20 SEP #$20 ; A 8-bit
$04:97D0 BD C7 0D LDA.W $0DC7,X ; \
$04:97D3 29 0F AND.B #$0F ; / Destination X on a tile boundary?
$04:97D5 D0 0C BNE $97E3 ; No: check Y
$04:97D7 A0 04 00 LDY.W #$0004 ; Y = 4 (left)
$04:97DA A5 00 LDA $00 ; \
$04:97DC 30 03 BMI $97E1 ; / dx negative: keep left
$04:97DE A0 06 00 LDY.W #$0006 ; dx positive: Y = 6 (right)
$04:97E1 80 11 BRA $97F4 ; Go store the direction
$04:97E3 BD C9 0D LDA.W $0DC9,X ; \
$04:97E6 29 0F AND.B #$0F ; / Destination Y on a tile boundary?
$04:97E8 D0 0A BNE $97F4 ; No: keep the current direction in Y
$04:97EA A0 00 00 LDY.W #$0000 ; Y = 0 (up)
$04:97ED A5 01 LDA $01 ; \
$04:97EF 30 03 BMI $97F4 ; / dy negative: keep up
$04:97F1 A0 02 00 LDY.W #$0002 ; dy positive: Y = 2 (down)
$04:97F4 8C D3 0D STY.W $0DD3 ; Current direction [$0DD3] = Y
$04:97F7 AD D9 13 LDA.W $13D9 ; \
$04:97FA C9 0A CMP.B #$0A ; / OW process $0A (submap transition)?
$04:97FC F0 33 BEQ $9831 ; Yes: stop here
$04:97FE 4C 5D 94 JMP.W $945D ; No: continue with the new destination
$04:9801 C2 20 REP #$20 ; A 16-bit
$04:9803 AD D6 0D LDA.W $0DD6 ; \
$04:9806 18 CLC ; |
$04:9807 69 02 00 ADC.W #$0002 ; } X = [$0DD6] + 2: Y position entry of this player
$04:980A AA TAX ; /
$04:980B A0 02 00 LDY.W #$0002 ; Y = 2: start with the Y axis
$04:980E B9 D5 13 LDA.W $13D5,Y ; \
$04:9811 29 FF 00 AND.W #$00FF ; |
$04:9814 18 CLC ; } [$13D5+Y] = fraction + axis speed [$0DCF+Y]
$04:9815 79 CF 0D ADC.W $0DCF,Y ; |
$04:9818 99 D5 13 STA.W $13D5,Y ; /
$04:981B 29 00 FF AND.W #$FF00 ; \
$04:981E 10 03 BPL $9823 ; |
$04:9820 09 FF 00 ORA.W #$00FF ; } A = whole pixels moved (high byte), sign-extended
$04:9823 EB XBA ; /
$04:9824 18 CLC ; \
$04:9825 7D 17 1F ADC.W $1F17,X ; } Player position [$1F17+X] += whole pixels
$04:9828 9D 17 1F STA.W $1F17,X ; /
$04:982B CA DEX ; \
$04:982C CA DEX ; |
$04:982D 88 DEY ; } X -= 2, Y -= 2
$04:982E 88 DEY ; /
$04:982F 10 DD BPL $980E ; Loop for the X axis too
$04:9831 E2 20 SEP #$20 ; A 8-bit
$04:9833 AD D9 13 LDA.W $13D9 ; \
$04:9836 C9 0A CMP.B #$0A ; / OW process $0A (submap transition)? Then no camera update
$04:9838 F0 48 BEQ $9882 ; Yes: return
$04:983A AD A0 1B LDA.W $1BA0 ; \
$04:983D D0 43 BNE $9882 ; / [$1BA0] non-zero: no camera update
$04:983F C2 30 REP #$30 ; A, X and Y 16-bit
$04:9841 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9844 BD 17 1F LDA.W $1F17,X ; \
$04:9847 85 00 STA $00 ; / [$00] = player X position
$04:9849 BD 19 1F LDA.W $1F19,X ; \
$04:984C 85 02 STA $02 ; / [$02] = player Y position
$04:984E 8A TXA ; \
$04:984F 4A LSR ; |
$04:9850 4A LSR ; } X = player index
$04:9851 AA TAX ; /
$04:9852 BD 11 1F LDA.W $1F11,X ; \
$04:9855 29 FF 00 AND.W #$00FF ; / A = player's submap [$1F11+X]
$04:9858 D0 28 BNE $9882 ; Not 0 (on a submap): no scrolling
$04:985A A2 02 00 LDX.W #$0002 ; X = 2: start with the Y axis
$04:985D 9B TXY ; Y = 2: index into the limit tables
$04:985E B5 00 LDA $00,X ; \
$04:9860 38 SEC ; } A = position - $80 (center the player on the screen)
$04:9861 E9 80 00 SBC.W #$0080 ; /
$04:9864 10 0A BPL $9870 ; Positive: check the upper limit
$04:9866 D9 16 94 CMP.W $9416,Y ; \
$04:9869 B0 0D BCS $9878 ; / At or above the lower limit (DATA_049416+Y)? Then use it
$04:986B B9 16 94 LDA.W $9416,Y ; Clamp to the lower limit
$04:986E 80 08 BRA $9878 ; Done clamping
$04:9870 D9 1A 94 CMP.W $941A,Y ; \
$04:9873 90 03 BCC $9878 ; / Below the upper limit (DATA_04941A+Y)? Then use it
$04:9875 B9 1A 94 LDA.W $941A,Y ; Clamp to the upper limit
$04:9878 95 1A STA RAM_ScreenBndryXLo,X ; BG1 scroll ([$1A] X, [$1C] Y) = A
$04:987A 95 1E STA $1E,X ; BG2 scroll ([$1E] X, [$20] Y) = A
$04:987C 88 DEY ; \
$04:987D 88 DEY ; |
$04:987E CA DEX ; } Y -= 2, X -= 2
$04:987F CA DEX ; /
$04:9880 10 DC BPL $985E ; Loop for the X axis too
$04:9882 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:9884 60 RTS ; Return
;;; $9885: Calculate OW tile position; process $0C (OW_TilePos_Calc) ;;;
;; OW_TilePos_Calc: converts tile coordinates to an offset into the 32x32 tile map arrays ($7EC800 tiles,
;; $7ED000 level numbers).
;; The map is 2 screens wide and 2 high: offset = (X & $F) + ((X & $10) << 4) + ((Y << 4) & $FF) + (Y & $10 ?
;; $200 : 0) + (submap ? $400 : 0).
;; Parameters: [$00] = tile X, [$02] = tile Y (16-bit), X = player index (0 Mario, 1 Luigi). Returns: [$04] =
;; offset.
;; $0498C6 (separate routine): overworld process $0C. Mario rises 1 pixel every second frame until [$1F19] low
;; = $78, then process 0 and the
;; game is saved ($9BC9). Probably the end-of-game or cutscene finish.
;; Called by:
;; $04:8E0B: Overworld load: reset poses, set music
;; $04:8E73: Overworld setup and process 0 (level exit)
;; $04:8F2E: Overworld setup and process 0 (level exit)
;; $04:9020: Overworld state 2: after level, save data
;; $04:920A: Overworld: enter level, then walk (OWPU_EnterLevel)
;; $04:92DD: Overworld: start walking from a level tile (OWPU_NotAutoWalk)
;; $04:953B: OW process 4: Mario walks along the path
;; $04:95A8: OW process 4: Mario walks along the path
;; $04:9933: Set level exit flag from tile exit data
$04:9885 A5 00 LDA $00 ; \
$04:9887 29 0F 00 AND.W #$000F ; |
$04:988A 85 04 STA $04 ; |
$04:988C A5 00 LDA $00 ; |
$04:988E 29 10 00 AND.W #$0010 ; |
$04:9891 0A ASL ; } [$04] = (X & $F) + ((X & $10) << 4): tile X part of the offset
$04:9892 0A ASL ; |
$04:9893 0A ASL ; |
$04:9894 0A ASL ; |
$04:9895 65 04 ADC $04 ; |
$04:9897 85 04 STA $04 ; /
$04:9899 A5 02 LDA $02 ; \
$04:989B 0A ASL ; |
$04:989C 0A ASL ; |
$04:989D 0A ASL ; |
$04:989E 0A ASL ; } [$04] += (Y << 4) & $FF
$04:989F 29 FF 00 AND.W #$00FF ; |
$04:98A2 65 04 ADC $04 ; |
$04:98A4 85 04 STA $04 ; /
$04:98A6 A5 02 LDA $02 ; \
$04:98A8 29 10 00 AND.W #$0010 ; } Bit 4 of Y clear: skip
$04:98AB F0 08 BEQ $98B5 ; /
$04:98AD A5 04 LDA $04 ; \
$04:98AF 18 CLC ; |
$04:98B0 69 00 02 ADC.W #$0200 ; } [$04] += $200 (lower screen of the map)
$04:98B3 85 04 STA $04 ; /
$04:98B5 BD 11 1F LDA.W $1F11,X ; \
$04:98B8 29 FF 00 AND.W #$00FF ; } X = player index; A = [$1F11+X] (submap); main map (0): done
$04:98BB F0 08 BEQ $98C5 ; /
$04:98BD A5 04 LDA $04 ; \
$04:98BF 18 CLC ; |
$04:98C0 69 00 04 ADC.W #$0400 ; } On a submap: [$04] += $400
$04:98C3 85 04 STA $04 ; /
$04:98C5 60 RTS ; Return
$04:98C6 9C 13 1F STZ.W $1F13 ; [$1F13] = 0 (Mario animation: standing)
$04:98C9 A9 80 LDA.B #$80 ; \
$04:98CB 18 CLC ; |
$04:98CC 6D D7 13 ADC.W $13D7 ; } Sub-pixel accumulator [$13D7] += $80
$04:98CF 8D D7 13 STA.W $13D7 ; /
$04:98D2 08 PHP ; Save carry
$04:98D3 A9 0F LDA.B #$0F ; \
$04:98D5 C9 08 CMP.B #$08 ; / A = $0F; compare with 8 (carry set)
$04:98D7 A0 00 LDY.B #$00 ; Y = 0
$04:98D9 90 03 BCC $98DE ; Carry clear: skip
$04:98DB 09 F0 ORA.B #$F0 ; A = $FF (-1)
$04:98DD 88 DEY ; Y = $FF (high byte of -1)
$04:98DE 28 PLP ; Restore the carry from the sub-pixel add
$04:98DF 6D 19 1F ADC.W $1F19 ; \
$04:98E2 8D 19 1F STA.W $1F19 ; / Mario Y position low [$1F19] += -1 + carry
$04:98E5 98 TYA ; \
$04:98E6 6D 1A 1F ADC.W $1F1A ; } Mario Y position high [$1F1A] += $FF + carry (so Mario moves up 1 pixel every second frame)
$04:98E9 8D 1A 1F STA.W $1F1A ; /
$04:98EC AD 19 1F LDA.W $1F19 ; \
$04:98EF C9 78 CMP.B #$78 ; / Mario Y low = $78?
$04:98F1 D0 07 BNE $98FA ; No: keep moving
$04:98F3 9C D9 13 STZ.W $13D9 ; OW process [$13D9] = 0
$04:98F6 22 C9 9B 00 JSL.L $9BC9 ; Save the game ($9BC9)
$04:98FA 60 RTS ; Return
;;; $98FB..98FB: Unused: exit direction bit table ;;;
$04:98FB .db $08,$00,$04,$00,$02,$00,$01,$00 ; $08, $04, $02, $01 as words (copy of $941E, unused)
;;; $9903: Set level exit flag from tile exit data ;;;
;; Called by overworld process 2 ($8F87). If [$0DD5] is a positive step count, takes the player's tile
;; and reads a 2-bit field of the
;; byte at $7ED800 (shift count from $9060), then sets the matching direction bit ($941E: 8 up, 4
;; down, 2 left, 1 right)
;; in the level flags [$1EA2 + level number of the tile]. Also stores the player's tile coordinates in
;; [$1F1F]/[$1F21].
;; Called by:
;; $04:8F87: Overworld state 2: after level, save data
$04:9903 AE D5 0D LDX.W $0DD5 ; X = [$0DD5] (auto-walk / event direction)
$04:9906 F0 BD BEQ $98C5 ; Zero: return
$04:9908 30 BB BMI $98C5 ; Negative: return
$04:990A CA DEX ; X--
$04:990B BD 60 90 LDA.W $9060,X ; A = $9060[X]: bit shift count (5, 3, 1, 0)
$04:990E 85 08 STA $08 ; [$08] = shift count
$04:9910 64 09 STZ $09 ; [$09] = 0
$04:9912 C2 20 REP #$20 ; A 16-bit
$04:9914 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9917 BD 17 1F LDA.W $1F17,X ; \
$04:991A 4A LSR ; |
$04:991B 4A LSR ; |
$04:991C 4A LSR ; } [$00] = player X position / 16 (tile X)
$04:991D 4A LSR ; |
$04:991E 85 00 STA $00 ; /
$04:9920 9D 1F 1F STA.W $1F1F,X ; [$1F1F+X] = tile X
$04:9923 BD 19 1F LDA.W $1F19,X ; \
$04:9926 4A LSR ; |
$04:9927 4A LSR ; |
$04:9928 4A LSR ; } [$02] = player Y position / 16 (tile Y)
$04:9929 4A LSR ; |
$04:992A 85 02 STA $02 ; /
$04:992C 9D 21 1F STA.W $1F21,X ; [$1F21+X] = tile Y
$04:992F 8A TXA ; \
$04:9930 4A LSR ; |
$04:9931 4A LSR ; } X = player index
$04:9932 AA TAX ; /
$04:9933 20 85 98 JSR.W OW_TilePos_Calc ; Calculate map tile position into [$04] (OW_TilePos_Calc)
$04:9936 C2 10 REP #$10 ; Index 16-bit
$04:9938 A6 04 LDX $04 ; X = tile position
$04:993A BF 00 D8 7E LDA.L $7ED800,X ; \
$04:993E 29 FF 00 AND.W #$00FF ; / A = [$7ED800+X]: packed 2-bit fields per tile (exit info)
$04:9941 A6 08 LDX $08 ; X = shift count
$04:9943 F0 04 BEQ $9949 ; Zero: no shift
$04:9945 4A LSR ; \
$04:9946 CA DEX ; } A >>= [$08]
$04:9947 10 FC BPL $9945 ; /
$04:9949 29 03 00 AND.W #$0003 ; \
$04:994C 0A ASL ; } Y = (A & 3) * 2: selects an exit direction bit
$04:994D A8 TAY ; /
$04:994E A6 04 LDX $04 ; X = tile position
$04:9950 BF 00 D0 7E LDA.L $7ED000,X ; \
$04:9954 29 FF 00 AND.W #$00FF ; / A = level number of this tile ($7ED000)
$04:9957 AA TAX ; X = level number
$04:9958 B9 1E 94 LDA.W $941E,Y ; \
$04:995B 1D A2 1E ORA.W $1EA2,X ; } Set the exit bit in [$1EA2+X] (bits from $941E)
$04:995E 9D A2 1E STA.W $1EA2,X ; /
$04:9961 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:9963 60 RTS ; Return
;;; $9964..99A8: Table: submap transition trigger positions ;;;
;; 14 entries of 5 bytes: Y position (word), X position (word), submap number. Read by $9A24 with the
;; matching entries of
;; $99AA (destination) and $99F0 (destination tile).
$04:9964 .db $40,$01 ; e0: Y=$0140 X=$0028 submap 0
$04:9966 .db $28,$00 ; (continuation of the previous entry)
$04:9968 .db $00,$50,$01,$58,$00,$00,$10,$00 ; e1: Y=$0150 X=$0058 submap 0; e2: Y=$0010 X=$0048 submap 1
$04:9970 .db $48,$00,$01,$10,$00,$98,$00,$01 ; e3: Y=$0010 X=$0098 submap 1
$04:9978 .db $A0,$00,$D8,$00,$00,$40,$01,$58 ; e4: Y=$00A0 X=$00D8 submap 0; e5: Y=$0140 X=$0058 submap 2
$04:9980 .db $00,$02,$90,$00,$E8,$01,$04,$60 ; e6: Y=$0090 X=$01E8 submap 4; e7: Y=$0160 X=$00E8 submap 0
$04:9988 .db $01,$E8,$00,$00,$A0,$00,$C8,$01 ; e8: Y=$00A0 X=$01C8 submap 0
$04:9990 .db $00,$60,$01,$88,$00,$03,$08,$01 ; e9: Y=$0160 X=$0088 submap 3; e10: Y=$0108 X=$0190 submap 0
$04:9998 .db $90,$01,$00,$E8,$01,$10,$00,$03 ; e11: Y=$01E8 X=$0010 submap 3
$04:99A0 .db $10,$01,$C8,$01,$00,$F0,$01,$88 ; e12: Y=$0110 X=$01C8 submap 0; e13: Y=$01F0 X=$0088 submap 3
$04:99A8 .db $00,$03 ; (continuation of the previous entry)
;;; $99AA..99EE: Table: submap transition destinations ;;;
;; 14 entries of 5 bytes: new Y position (word), new X position (word), new submap number.
$04:99AA .db $00,$00 ; e0: Y=$0000 X=$0048 submap 1
$04:99AC .db $48,$00 ; (continuation of the previous entry)
$04:99AE .db $01,$00,$00,$98,$00,$01,$50,$01 ; e1: Y=$0000 X=$0098 submap 1; e2: Y=$0150 X=$0028 submap 0
$04:99B6 .db $28,$00,$00,$60,$01,$58,$00,$00 ; e3: Y=$0160 X=$0058 submap 0
$04:99BE .db $50,$01,$58,$00,$02,$90,$00,$D8 ; e4: Y=$0150 X=$0058 submap 2; e5: Y=$0090 X=$00D8 submap 0
$04:99C6 .db $00,$00,$50,$01,$E8,$00,$00,$A0 ; e6: Y=$0150 X=$00E8 submap 0; e7: Y=$00A0 X=$01E8 submap 4
$04:99CE .db $00,$E8,$01,$04,$50,$01,$88,$00 ; e8: Y=$0150 X=$0088 submap 3
$04:99D6 .db $03,$B0,$00,$C8,$01,$00,$E8,$01 ; e9: Y=$00B0 X=$01C8 submap 0; e10: Y=$01E8 X=$0000 submap 3
$04:99DE .db $00,$00,$03,$08,$01,$A0,$01,$00 ; e11: Y=$0108 X=$01A0 submap 0
$04:99E6 .db $00,$02,$88,$00,$03,$00,$01,$C8 ; e12: Y=$0200 X=$0088 submap 3; e13: Y=$0100 X=$01C8 submap 0
$04:99EE .db $01,$00 ; (continuation of the previous entry)
;;; $99F0..9A09: Table: submap transition destination tiles ;;;
;; 14 entries of 2 bytes: tile Y, tile X of the destination, stored in [$1F21] and [$1F1F].
$04:99F0 .db $00 ; e0: tile Y=$00 X=$04
$04:99F1 .db $04,$00,$09,$14,$02,$15,$05,$14 ; e1: tile Y=$00 X=$09; e2: tile Y=$14 X=$02; e3: tile Y=$15 X=$05; e4: tile Y=$14 X=$05
$04:99F9 .db $05,$09,$0D,$15,$0E,$09,$1E,$15 ; e5: tile Y=$09 X=$0D; e6: tile Y=$15 X=$0E; e7: tile Y=$09 X=$1E; e8: tile Y=$15 X=$08
$04:9A01 .db $08,$0A,$1C,$1E,$00,$10,$19,$1F ; e9: tile Y=$0A X=$1C; e10: tile Y=$1E X=$00; e11: tile Y=$10 X=$19; e12: tile Y=$1F X=$08
$04:9A09 .db $08,$10,$1C ; e13: tile Y=$10 X=$1C
;;; $9A0C..9A1E: Table: submap scroll boundaries ;;;
;; Six entries of 4 bytes, for submaps 1 to 6: BG1/BG2 X scroll (word), Y scroll (word). Indexed by (submap -
;; 1) * 4 in $9A93.
$04:9A0C .db $EF,$FF ; submap 1 X=$FFEF
$04:9A0E .db $D8,$FF,$EF,$FF,$80,$00,$EF,$FF ; submap 1 Y=$FFD8; submap 2 X=$FFEF; submap 2 Y=$0080; submap 3 X=$FFEF
$04:9A16 .db $28,$01,$F0,$00,$D8,$FF,$F0,$00 ; submap 3 Y=$0128; submap 4 X=$00F0; submap 4 Y=$FFD8; submap 5 X=$00F0
$04:9A1E .db $80,$00,$F0,$00,$28,$01 ; submap 5 Y=$0080; submap 6 X=$00F0; submap 6 Y=$0128
;;; $9A24: Submap transition: warp and set scroll ;;;
;; $9A24: looks the player's Y position, X position and submap up in the 14 entries of $9964. On a
;; match it moves the player to
;; the destination position, tile coordinates and submap [$13C3] from $99AA/AC/AE and $99F0/F1.
;; $049A93: stores [$13C3] as the player's submap [$1F11] and loads the BG1/BG2 scroll from $9A0C
;; (submap 0: updates the
;; camera from the player position via $04983F instead). Called from $856F and $DB5C.
;; Called by:
;; $04:961C: OW process 4: Mario walks along the path
$04:9A24 C2 20 REP #$20 ; A 16-bit
$04:9A26 AD D6 0D LDA.W $0DD6 ; \
$04:9A29 4A LSR ; |
$04:9A2A 4A LSR ; } X = player index
$04:9A2B AA TAX ; /
$04:9A2C BD 11 1F LDA.W $1F11,X ; \
$04:9A2F 29 FF 00 AND.W #$00FF ; } [$13C3] = player's current submap
$04:9A32 8D C3 13 STA.W $13C3 ; /
$04:9A35 A9 1A 00 LDA.W #$001A ; \
$04:9A38 85 02 STA $02 ; / [$02] = $1A: index of the last entry in the tile table ($99F0)
$04:9A3A A0 41 LDY.B #$41 ; Y = $41: index of the last entry in the five-byte tables (14 entries)
$04:9A3C AE D6 0D LDX.W $0DD6 ; X = [$0DD6]
$04:9A3F BD 19 1F LDA.W $1F19,X ; \
$04:9A42 D9 64 99 CMP.W $9964,Y ; / Player Y position = entry Y position ($9964)?
$04:9A45 D0 3E BNE $9A85 ; No: next entry
$04:9A47 BD 17 1F LDA.W $1F17,X ; \
$04:9A4A D9 66 99 CMP.W $9966,Y ; / Player X position = entry X position ($9966)?
$04:9A4D D0 36 BNE $9A85 ; No: next entry
$04:9A4F B9 68 99 LDA.W $9968,Y ; \
$04:9A52 29 FF 00 AND.W #$00FF ; } Entry's submap ($9968) = current submap?
$04:9A55 CD C3 13 CMP.W $13C3 ; /
$04:9A58 D0 2B BNE $9A85 ; No: next entry
$04:9A5A B9 AA 99 LDA.W $99AA,Y ; \
$04:9A5D 9D 19 1F STA.W $1F19,X ; / Player Y position = destination Y ($99AA)
$04:9A60 B9 AC 99 LDA.W $99AC,Y ; \
$04:9A63 9D 17 1F STA.W $1F17,X ; / Player X position = destination X ($99AC)
$04:9A66 B9 AE 99 LDA.W $99AE,Y ; \
$04:9A69 29 FF 00 AND.W #$00FF ; } [$13C3] = destination submap ($99AE)
$04:9A6C 8D C3 13 STA.W $13C3 ; /
$04:9A6F A4 02 LDY $02 ; Y = [$02]: index into the tile table
$04:9A71 B9 F0 99 LDA.W $99F0,Y ; \
$04:9A74 29 FF 00 AND.W #$00FF ; } Player tile Y [$1F21+X] = $99F0[Y]
$04:9A77 9D 21 1F STA.W $1F21,X ; /
$04:9A7A B9 F1 99 LDA.W $99F1,Y ; \
$04:9A7D 29 FF 00 AND.W #$00FF ; } Player tile X [$1F1F+X] = $99F1[Y]
$04:9A80 9D 1F 1F STA.W $1F1F,X ; /
$04:9A83 80 0B BRA $9A90 ; Done
$04:9A85 C6 02 DEC $02 ; \
$04:9A87 C6 02 DEC $02 ; / [$02] -= 2
$04:9A89 88 DEY ; \
$04:9A8A 88 DEY ; |
$04:9A8B 88 DEY ; } Y -= 5: previous entry
$04:9A8C 88 DEY ; |
$04:9A8D 88 DEY ; /
$04:9A8E 10 AF BPL $9A3F ; Loop over all 14 entries
$04:9A90 E2 20 SEP #$20 ; A 8-bit
$04:9A92 60 RTS ; Return
$04:9A93 AD D6 0D LDA.W $0DD6 ; \
$04:9A96 29 FF 00 AND.W #$00FF ; |
$04:9A99 4A LSR ; } A = player index; X = index of the player's submap byte
$04:9A9A 4A LSR ; |
$04:9A9B AA TAX ; /
$04:9A9C BD 11 1F LDA.W $1F11,X ; \
$04:9A9F 29 00 FF AND.W #$FF00 ; |
$04:9AA2 0D C3 13 ORA.W $13C3 ; } [$1F11+X] low byte (submap) = [$13C3]
$04:9AA5 9D 11 1F STA.W $1F11,X ; /
$04:9AA8 29 FF 00 AND.W #$00FF ; \
$04:9AAB D0 03 BNE $9AB0 ; / Submap non-zero?
$04:9AAD 4C 3F 98 JMP.W $983F ; Main map: update the camera ($983F)
$04:9AB0 3A DEC A ; \
$04:9AB1 0A ASL ; |
$04:9AB2 0A ASL ; } Y = (submap - 1) * 4: index into the scroll boundary table
$04:9AB3 A8 TAY ; /
$04:9AB4 B9 0C 9A LDA.W $9A0C,Y ; \
$04:9AB7 85 1A STA RAM_ScreenBndryXLo ; } BG1/BG2 X scroll [$1A], [$1E] = $9A0C[Y]
$04:9AB9 85 1E STA $1E ; /
$04:9ABB B9 0E 9A LDA.W $9A0E,Y ; \
$04:9ABE 85 1C STA RAM_ScreenBndryYLo ; } BG1/BG2 Y scroll [$1C], [$20] = $9A0E[Y]
$04:9AC0 85 20 STA $20 ; /
$04:9AC2 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:9AC4 60 RTS ; Return
;;; $9AC5: Overworld level name text and builder (LevelNameStrings) ;;;
;; Word-based level name text: names are three words picked by [$00]/[$01]. Characters: A-Z = $00-$19, $1F =
;; space, $5D = apostrophe, $5A = # (digits probably $64+);
;; bit 7 marks the last character of a word. Three pointer tables ($9C91, $9CCF, $9CED) give
;; each word's offset; $01CB is the blank word.
;; $049D07: writes a stripe image record for the name into the buffer at $7F:837B (VRAM $508B, 19 tiles,
;; attribute $39), blank-padded and $FF-terminated.
;; Parameters: [$00]-[$01]: name code. [$01] & $7F = word 1, [$00] high nibble = word 2, [$00] low nibble =
;; word 3.
;; $049D9A, $049DD1, $049E22, $049E4C: overworld processes for switching between Mario and Luigi (fade out,
;; swap player state, fade in).
;; $049E52: star warp lift-off (player flies up the screen). $049E9B: unused divide-by-10 loop.
$04:9AC5 .db $18,$0E,$12,$07,$08,$5D,$12,$9F ; Text: YOSHI'S |
$04:9ACD .db $12,$13,$00,$11,$9F,$5A,$64,$1F ; Text: STAR |#1
$04:9AD5 .db $08,$06,$06,$18,$5D,$12,$9F,$5A ; Text: IGGY'S |#
$04:9ADD .db $65,$1F,$0C,$0E,$11,$13,$0E,$0D ; Text: 2 MORTON
$04:9AE5 .db $5D,$12,$9F,$5A,$66,$1F,$0B,$04 ; Text: 'S |#3 LE
$04:9AED .db $0C,$0C,$18,$5D,$12,$9F,$5A,$67 ; Text: MMY'S |#4
$04:9AF5 .db $1F,$0B,$14,$03,$16,$08,$06,$5D ; Text: LUDWIG'
$04:9AFD .db $12,$9F,$5A,$68,$1F,$11,$0E,$18 ; Text: S |#5 ROY
$04:9B05 .db $5D,$12,$9F,$5A,$69,$1F,$16,$04 ; Text: 'S |#6 WE
$04:9B0D .db $0D,$03,$18,$5D,$12,$9F,$5A,$6A ; Text: NDY'S |#7
$04:9B15 .db $1F,$0B,$00,$11,$11,$18,$5D,$12 ; Text: LARRY'S
$04:9B1D .db $9F,$03,$0E,$0D,$14,$13,$9F,$06 ; Text: |DONUT |G
$04:9B25 .db $11,$04,$04,$0D,$9F,$13,$0E,$0F ; Text: REEN |TOP
$04:9B2D .db $1F,$12,$04,$02,$11,$04,$13,$1F ; Text: SECRET
$04:9B35 .db $00,$11,$04,$00,$9F,$15,$00,$0D ; Text: AREA |VAN
$04:9B3D .db $08,$0B,$0B,$00,$9F,$38,$39,$3A ; Text: ILLA |{38}{39}{3A}
$04:9B45 .db $3B,$3C,$9F,$11,$04,$03,$9F,$01 ; Text: {3B}{3C} |RED |B
$04:9B4D .db $0B,$14,$04,$9F,$01,$14,$13,$13 ; Text: LUE |BUTT
$04:9B55 .db $04,$11,$1F,$01,$11,$08,$03,$06 ; Text: ER BRIDG
$04:9B5D .db $04,$9F,$02,$07,$04,$04,$12,$04 ; Text: E |CHEESE
$04:9B65 .db $1F,$01,$11,$08,$03,$06,$04,$9F ; Text: BRIDGE |
$04:9B6D .db $12,$0E,$03,$00,$1F,$0B,$00,$0A ; Text: SODA LAK
$04:9B75 .db $04,$9F,$02,$0E,$0E,$0A,$08,$04 ; Text: E |COOKIE
$04:9B7D .db $1F,$0C,$0E,$14,$0D,$13,$00,$08 ; Text: MOUNTAI
$04:9B85 .db $0D,$9F,$05,$0E,$11,$04,$12,$13 ; Text: N |FOREST
$04:9B8D .db $9F,$02,$07,$0E,$02,$0E,$0B,$00 ; Text: |CHOCOLA
$04:9B95 .db $13,$04,$9F,$02,$07,$0E,$02,$0E ; Text: TE |CHOCO
$04:9B9D .db $1C,$06,$07,$0E,$12,$13,$1F,$07 ; Text: {1C}GHOST H
$04:9BA5 .db $0E,$14,$12,$04,$9F,$12,$14,$0D ; Text: OUSE |SUN
$04:9BAD .db $0A,$04,$0D,$1F,$06,$07,$0E,$12 ; Text: KEN GHOS
$04:9BB5 .db $13,$1F,$12,$07,$08,$0F,$9F,$15 ; Text: T SHIP |V
$04:9BBD .db $00,$0B,$0B,$04,$18,$9F,$01,$00 ; Text: ALLEY |BA
$04:9BC5 .db $02,$0A,$1F,$03,$0E,$0E,$11,$9F ; Text: CK DOOR |
$04:9BCD .db $05,$11,$0E,$0D,$13,$1F,$03,$0E ; Text: FRONT DO
$04:9BD5 .db $0E,$11,$9F,$06,$0D,$00,$11,$0B ; Text: OR |GNARL
$04:9BDD .db $18,$9F,$13,$14,$01,$14,$0B,$00 ; Text: Y |TUBULA
$04:9BE5 .db $11,$9F,$16,$00,$18,$1F,$02,$0E ; Text: R |WAY CO
$04:9BED .db $0E,$0B,$9F,$07,$0E,$14,$12,$04 ; Text: OL |HOUSE
$04:9BF5 .db $9F,$08,$12,$0B,$00,$0D,$03,$9F ; Text: |ISLAND |
$04:9BFD .db $12,$16,$08,$13,$02,$07,$1F,$0F ; Text: SWITCH P
$04:9C05 .db $00,$0B,$00,$02,$04,$9F,$02,$00 ; Text: ALACE |CA
$04:9C0D .db $12,$13,$0B,$04,$9F,$0F,$0B,$00 ; Text: STLE |PLA
$04:9C15 .db $08,$0D,$12,$9F,$06,$07,$0E,$12 ; Text: INS |GHOS
$04:9C1D .db $13,$1F,$07,$0E,$14,$12,$04,$9F ; Text: T HOUSE |
$04:9C25 .db $12,$04,$02,$11,$04,$13,$9F,$03 ; Text: SECRET |D
$04:9C2D .db $0E,$0C,$04,$9F,$05,$0E,$11,$13 ; Text: OME |FORT
$04:9C35 .db $11,$04,$12,$12,$9F,$0E,$05,$32 ; Text: RESS |OF{32}
$04:9C3D .db $33,$34,$35,$36,$37,$0E,$0D,$9F ; Text: {33}{34}{35}{36}{37}ON |
$04:9C45 .db $0E,$05,$1F,$01,$0E,$16,$12,$04 ; Text: OF BOWSE
$04:9C4D .db $11,$9F,$11,$0E,$00,$03,$9F,$16 ; Text: R |ROAD |W
$04:9C55 .db $0E,$11,$0B,$03,$9F,$00,$16,$04 ; Text: ORLD |AWE
$04:9C5D .db $12,$0E,$0C,$04,$9F,$E4,$E5,$E6 ; Text: SOME |1|2|3|
$04:9C65 .db $E7,$E8,$0F,$00,$0B,$00,$02,$84 ; Text: 4|5|PALACE|
$04:9C6D .db $00,$11,$04,$80,$06,$11,$0E,$0E ; Text: AREA|GROO
$04:9C75 .db $15,$98,$0C,$0E,$0D,$03,$8E,$0E ; Text: VY|MONDO|O
$04:9C7D .db $14,$13,$11,$00,$06,$04,$0E,$14 ; Text: UTRAGEOU
$04:9C85 .db $92,$05,$14,$0D,$0A,$98,$07,$0E ; Text: S|FUNKY|HO
$04:9C8D .db $14,$12,$84,$9F ; Text: USE| |
$04:9C91 .db $CB,$01,$00,$00,$08,$00,$0D,$00 ; Word first offsets: 0=(blank), 1=YOSHI'S, 2=STAR, 3=#1 IGGY'S
$04:9C99 .db $17,$00,$23,$00,$2E,$00,$3A,$00 ; Word first offsets: 4=#2 MORTON'S, 5=#3 LEMMY'S, 6=#4 LUDWIG'S, 7=#5 ROY'S
$04:9CA1 .db $43,$00,$4E,$00,$59,$00,$5F,$00 ; Word first offsets: 8=#6 WENDY'S, 9=#7 LARRY'S, A=DONUT, B=GREEN
$04:9CA9 .db $65,$00,$75,$00,$7D,$00,$83,$00 ; Word first offsets: C=TOP SECRET AREA, D=VANILLA, E={38}{39}{3A}{3B}{3C}, F=RED
$04:9CB1 .db $87,$00,$8C,$00,$9A,$00,$A8,$00 ; Word first offsets: 10=BLUE, 11=BUTTER BRIDGE, 12=CHEESE BRIDGE, 13=SODA LAKE
$04:9CB9 .db $B2,$00,$C2,$00,$C9,$00,$D3,$00 ; Word first offsets: 14=COOKIE MOUNTAIN, 15=FOREST, 16=CHOCOLATE, 17=CHOCO{1C}GHOST HOUSE
$04:9CC1 .db $E5,$00,$F7,$00,$FE,$00,$08,$01 ; Word first offsets: 18=SUNKEN GHOST SHIP, 19=VALLEY, 1A=BACK DOOR, 1B=FRONT DOOR
$04:9CC9 .db $13,$01,$1A,$01,$22,$01 ; Word first offsets: 1C=GNARLY, 1D=TUBULAR, 1E=WAY COOL
$04:9CCF .db $CB,$01,$2B,$01,$31,$01,$38,$01 ; Word second offsets: 0=(blank), 1=HOUSE, 2=ISLAND, 3=SWITCH PALACE
$04:9CD7 .db $46,$01,$4D,$01,$54,$01,$60,$01 ; Word second offsets: 4=CASTLE, 5=PLAINS, 6=GHOST HOUSE, 7=SECRET
$04:9CDF .db $67,$01,$6C,$01,$75,$01,$80,$01 ; Word second offsets: 8=DOME, 9=FORTRESS, A=OF{32}{33}{34}{35}{36}{37}ON, B=OF BOWSER
$04:9CE7 .db $8A,$01,$8F,$01,$95,$01 ; Word second offsets: C=ROAD, D=WORLD, E=AWESOME
$04:9CED .db $CB,$01,$9D,$01,$9E,$01,$9F,$01 ; Word third offsets: 0=(blank), 1=1, 2=2, 3=3
$04:9CF5 .db $A0,$01,$A1,$01,$A2,$01,$A8,$01 ; Word third offsets: 4=4, 5=5, 6=PALACE, 7=AREA
$04:9CFD .db $AC,$01,$B2,$01,$B7,$01,$C1,$01 ; Word third offsets: 8=GROOVY, 9=MONDO, A=OUTRAGEOUS, B=FUNKY
$04:9D05 .db $C6,$01 ; Word third offsets: C=HOUSE
$04:9D07 AF 7B 83 7F LDA.L $7F837B ; A = stripe image buffer write index [$7F:837B]
$04:9D0B AA TAX ; X = write index
$04:9D0C 18 CLC ; \
$04:9D0D 69 26 00 ADC.W #$0026 ; } [$02] = [X] + $26: end limit of the 19-tile name field
$04:9D10 85 02 STA $02 ; /
$04:9D12 18 CLC ; \
$04:9D13 69 04 00 ADC.W #$0004 ; } Buffer write index [$7F:837B] = [X] + $2A (4 header bytes + $26 data)
$04:9D16 8F 7B 83 7F STA.L $7F837B ; /
$04:9D1A A9 00 25 LDA.W #$2500 ; \
$04:9D1D 9F 7F 83 7F STA.L $7F837F,X ; / Record length word = $0025: $26 bytes of tile data
$04:9D21 A9 50 8B LDA.W #$8B50 ; \
$04:9D24 9F 7D 83 7F STA.L $7F837D,X ; / Record VRAM address = $508B (BG3 tilemap, level name line)
$04:9D28 A5 01 LDA $01 ; \
$04:9D2A 29 7F 00 AND.W #$007F ; |
$04:9D2D 0A ASL ; } Y = ([$01] & $7F) * 2: index of the first word
$04:9D2E A8 TAY ; /
$04:9D2F B9 91 9C LDA.W $9C91,Y ; \
$04:9D32 A8 TAY ; / Y = string offset of word 1 ($9C91)
$04:9D33 E2 20 SEP #$20 ; A 8-bit
$04:9D35 B9 C5 9A LDA.W LevelNameStrings,Y ; \
$04:9D38 30 03 BMI $9D3D ; / Word 1 starts with an end marker (bit 7 set): empty, skip it
$04:9D3A 20 7F 9D JSR.W $9D7F ; Copy word 1 to the buffer
$04:9D3D C2 20 REP #$20 ; A 16-bit
$04:9D3F A5 00 LDA $00 ; \
$04:9D41 29 F0 00 AND.W #$00F0 ; |
$04:9D44 4A LSR ; |
$04:9D45 4A LSR ; |
$04:9D46 4A LSR ; } Y = ([$00] & $F0) >> 3: 2 * high nibble of [$00], index of word 2
$04:9D47 A8 TAY ; /
$04:9D48 B9 CF 9C LDA.W $9CCF,Y ; \
$04:9D4B A8 TAY ; / Y = string offset of word 2 ($9CCF)
$04:9D4C E2 20 SEP #$20 ; A 8-bit
$04:9D4E B9 C5 9A LDA.W LevelNameStrings,Y ; \
$04:9D51 C9 9F CMP.B #$9F ; } Word 2 is just a blank ($9F): skip it
$04:9D53 F0 03 BEQ $9D58 ; /
$04:9D55 20 7F 9D JSR.W $9D7F ; Copy word 2 to the buffer
$04:9D58 C2 20 REP #$20 ; A 16-bit
$04:9D5A A5 00 LDA $00 ; \
$04:9D5C 29 0F 00 AND.W #$000F ; |
$04:9D5F 0A ASL ; } Y = ([$00] & $0F) * 2: index of word 3
$04:9D60 A8 TAY ; /
$04:9D61 B9 ED 9C LDA.W $9CED,Y ; \
$04:9D64 A8 TAY ; / Y = string offset of word 3 ($9CED)
$04:9D65 E2 20 SEP #$20 ; A 8-bit
$04:9D67 20 7F 9D JSR.W $9D7F ; Copy word 3 to the buffer
$04:9D6A E4 02 CPX $02 ; \
$04:9D6C B0 08 BCS $9D76 ; / Name field full ([X] >= [$02])? Then finish
$04:9D6E A0 CB 01 LDY.W #$01CB ; Y = $01CB: offset of the blank word
$04:9D71 20 7F 9D JSR.W $9D7F ; Pad the field with a blank tile
$04:9D74 80 F4 BRA $9D6A ; Repeat until the field is full
$04:9D76 A9 FF LDA.B #$FF ; \
$04:9D78 9F 81 83 7F STA.L $7F8381,X ; / Stripe image end marker $FF after the name
$04:9D7C C2 20 REP #$20 ; A 16-bit
$04:9D7E 60 RTS ; Return
$04:9D7F B9 C5 9A LDA.W LevelNameStrings,Y ; A = next character of the word (bit 7 = last character)
$04:9D82 08 PHP ; Save its end bit (N flag)
$04:9D83 E4 02 CPX $02 ; \
$04:9D85 B0 0E BCS $9D95 ; / Field full: skip the store, keep reading to the end of the word
$04:9D87 29 7F AND.B #$7F ; \
$04:9D89 9F 81 83 7F STA.L $7F8381,X ; / Store the tile number (end bit cleared)
$04:9D8D A9 39 LDA.B #$39 ; \
$04:9D8F 9F 82 83 7F STA.L $7F8382,X ; / Store the tile attributes $39 (palette 6, high priority)
$04:9D93 E8 INX ; \
$04:9D94 E8 INX ; / X += 2: next tile slot
$04:9D95 C8 INY ; Next character
$04:9D96 28 PLP ; Restore the end bit
$04:9D97 10 E6 BPL $9D7F ; More characters in this word: loop
$04:9D99 60 RTS ; Return
$04:9D9A AD B2 0D LDA.W $0DB2 ; A = [$0DB2] (2 player game flag)
$04:9D9D F0 10 BEQ $9DAF ; One player: nothing to switch, go to $049DAF
$04:9D9F AD B3 0D LDA.W $0DB3 ; \
$04:9DA2 49 01 EOR.B #$01 ; } X = the other player (current player [$0DB3] EOR 1)
$04:9DA4 AA TAX ; /
$04:9DA5 BD B4 0D LDA.W RAM_PlayerLives,X ; \
$04:9DA8 30 05 BMI $9DAF ; / Other player's lives negative (game over): no switch
$04:9DAA AD D5 0D LDA.W $0DD5 ; \
$04:9DAD D0 0D BNE $9DBC ; / [$0DD5] non-zero (probably a player switch is requested): go to $049DBC
$04:9DAF A9 03 LDA.B #$03 ; \
$04:9DB1 8D D9 13 STA.W $13D9 ; / Overworld process [$13D9] = 3 (probably normal overworld control)
$04:9DB4 9C D5 0D STZ.W $0DD5 ; Clear [$0DD5]
$04:9DB7 C2 30 REP #$30 ; A, X and Y 16-bit
$04:9DB9 4C 31 98 JMP.W $9831 ; Continue the overworld process ($049831)
$04:9DBC CE B1 0D DEC.W $0DB1 ; \
$04:9DBF 10 0B BPL $9DCC ; / Timer [$0DB1]--; still >= 0: skip to $049DCC
$04:9DC1 A9 02 LDA.B #$02 ; \
$04:9DC3 8D B1 0D STA.W $0DB1 ; / Timer [$0DB1] = 2
$04:9DC6 9C D5 0D STZ.W $0DD5 ; Clear [$0DD5]
$04:9DC9 EE D9 13 INC.W $13D9 ; Next overworld process (fade out)
$04:9DCC C2 30 REP #$30 ; A, X and Y 16-bit
$04:9DCE 4C 31 98 JMP.W $9831 ; Continue the overworld process ($049831)
$04:9DD1 AD B3 0D LDA.W $0DB3 ; \
$04:9DD4 49 01 EOR.B #$01 ; } Toggle current player [$0DB3] (0 = Mario, 1 = Luigi)
$04:9DD6 8D B3 0D STA.W $0DB3 ; /
$04:9DD9 AA TAX ; X = new current player
$04:9DDA BD B6 0D LDA.W RAM_PlayerCoins,X ; \
$04:9DDD 8D BF 0D STA.W RAM_StatusCoins ; / Status bar coins = this player's coins
$04:9DE0 BD B4 0D LDA.W RAM_PlayerLives,X ; \
$04:9DE3 8D BE 0D STA.W RAM_StatusLives ; / Status bar lives = this player's lives
$04:9DE6 BD B8 0D LDA.W RAM_PlayerPowerUp,X ; \
$04:9DE9 85 19 STA RAM_MarioPowerUp ; / Mario power-up [$19] = this player's power-up
$04:9DEB BD BA 0D LDA.W RAM_PlyrYoshiColor,X ; \
$04:9DEE 8D C1 0D STA.W RAM_OWHasYoshi ; |
$04:9DF1 8D C7 13 STA.W RAM_YoshiColor ; } Yoshi color -> overworld has-Yoshi flag, Yoshi color and on-Yoshi flag
$04:9DF4 8D 7A 18 STA.W RAM_OnYoshi ; /
$04:9DF7 BD BC 0D LDA.W $0DBC,X ; \
$04:9DFA 8D C2 0D STA.W $0DC2 ; / Reserve item [$0DC2] = this player's reserve item [$0DBC]
$04:9DFD 22 F2 DB 05 JSL.L $DBF2 ; Queue a stripe image at $7F:837D ($DBF2, probably the player name text)
$04:9E01 C2 20 REP #$20 ; A 16-bit
$04:9E03 20 55 8E JSR.W $8E55 ; Set [$0DD6] = player * 4 and load that player's map position ($8E55)
$04:9E06 E2 20 SEP #$20 ; A 8-bit
$04:9E08 AE B3 0D LDX.W $0DB3 ; \
$04:9E0B BD 11 1F LDA.W $1F11,X ; |
$04:9E0E 8D C3 13 STA.W $13C3 ; / [$13C3] = new player's submap [$1F11+X]
$04:9E11 9C C4 13 STZ.W $13C4 ; Clear [$13C4]
$04:9E14 A9 02 LDA.B #$02 ; \
$04:9E16 8D B1 0D STA.W $0DB1 ; / Timer [$0DB1] = 2
$04:9E19 A9 0A LDA.B #$0A ; \
$04:9E1B 8D D9 13 STA.W $13D9 ; / Overworld process [$13D9] = $0A
$04:9E1E EE D8 0D INC.W $0DD8 ; [$0DD8]++ (probably counts player switches)
$04:9E21 60 RTS ; Return
$04:9E22 CE B1 0D DEC.W $0DB1 ; \
$04:9E25 10 24 BPL $9E4B ; / Timer [$0DB1]--; return until it goes negative
$04:9E27 A9 02 LDA.B #$02 ; \
$04:9E29 8D B1 0D STA.W $0DB1 ; / Timer [$0DB1] = 2 (step every 3 frames)
$04:9E2C AE AF 0D LDX.W $0DAF ; X = [$0DAF]: fade direction (0 = in, 1 = out)
$04:9E2F AD AE 0D LDA.W $0DAE ; \
$04:9E32 18 CLC ; |
$04:9E33 7F 2F 9F 00 ADC.L $9F2F,X ; } Brightness [$0DAE] += step (+1 / -1, $9F2F)
$04:9E37 8D AE 0D STA.W $0DAE ; /
$04:9E3A DF 33 9F 00 CMP.L $9F33,X ; \
$04:9E3E D0 0B BNE $9E4B ; / Not at the target yet ($0F in, $00 out, $9F33): return
$04:9E40 EE D9 13 INC.W $13D9 ; Fade done: next overworld process
$04:9E43 AD AF 0D LDA.W $0DAF ; \
$04:9E46 49 01 EOR.B #$01 ; } Toggle fade direction [$0DAF]
$04:9E48 8D AF 0D STA.W $0DAF ; /
$04:9E4B 60 RTS ; Return
$04:9E4C A9 03 LDA.B #$03 ; \
$04:9E4E 8D D9 13 STA.W $13D9 ; / Overworld process [$13D9] = 3 (probably normal overworld control)
$04:9E51 60 RTS ; Return
$04:9E52 AD F7 1D LDA.W $1DF7 ; A = [$1DF7]: star warp fly speed
$04:9E55 D0 0C BNE $9E63 ; Already flying: go to $049E63
$04:9E57 EE F8 1D INC.W $1DF8 ; \
$04:9E5A AD F8 1D LDA.W $1DF8 ; |
$04:9E5D C9 31 CMP.B #$31 ; } Ground timer [$1DF8]++ ($31 = take off)
$04:9E5F D0 32 BNE $9E93 ; /
$04:9E61 80 06 BRA $9E69 ; Timer expired: start flying ($049E69)
$04:9E63 A5 13 LDA RAM_FrameCounter ; \
$04:9E65 29 07 AND.B #$07 ; } Speed up only every 8th frame, else go to $049E78
$04:9E67 D0 0F BNE $9E78 ; /
$04:9E69 EE F7 1D INC.W $1DF7 ; \
$04:9E6C AD F7 1D LDA.W $1DF7 ; |
$04:9E6F C9 05 CMP.B #$05 ; |
$04:9E71 D0 05 BNE $9E78 ; |
$04:9E73 A9 04 LDA.B #$04 ; } Fly speed [$1DF7]++, wrapped back to 4 when it reaches 5
$04:9E75 8D F7 1D STA.W $1DF7 ; /
$04:9E78 C2 20 REP #$20 ; A 16-bit
$04:9E7A AD F7 1D LDA.W $1DF7 ; \
$04:9E7D 29 FF 00 AND.W #$00FF ; } [$00] = fly speed [$1DF7]
$04:9E80 85 00 STA $00 ; /
$04:9E82 AE D6 0D LDX.W $0DD6 ; X = [$0DD6]: player * 4
$04:9E85 BD 19 1F LDA.W $1F19,X ; \
$04:9E88 38 SEC ; |
$04:9E89 E5 00 SBC $00 ; } Player's map Y position [$1F19+X] -= fly speed (moves up)
$04:9E8B 9D 19 1F STA.W $1F19,X ; /
$04:9E8E 38 SEC ; \
$04:9E8F E5 1C SBC RAM_ScreenBndryYLo ; } Position - screen top [$1C]; negative: flew off the screen
$04:9E91 30 03 BMI $9E96 ; /
$04:9E93 E2 20 SEP #$20 ; A 8-bit
$04:9E95 60 RTS ; Return
$04:9E96 E2 20 SEP #$20 ; A 8-bit
$04:9E98 4C 8D 91 JMP.W $918D ; Finish the star warp ($918D)
$04:9E9B A0 00 LDY.B #$00 ; Unused. Y = 0
$04:9E9D C9 0A CMP.B #$0A ; \
$04:9E9F 90 05 BCC $9EA6 ; |
$04:9EA1 E9 0A SBC.B #$0A ; } While A >= $0A: A -= $0A, Y++ (A = A mod 10, Y = A / 10)
$04:9EA3 C8 INY ; |
$04:9EA4 80 F7 BRA $9E9D ; /
$04:9EA6 60 RTS ; Return
;;; $9EA7..9F47: Table: path tile movement offsets ;;;
;; Two bytes per overworld tile (tile number - 1), loaded into [$00]/[$01] by the path movement code at
;; $049725. Exact meaning (per-tile step distances) inferred.
$04:9EA7 .db $10,$F8,$10,$00,$10,$FC,$10,$00 ; (Y,X) offset pairs, tiles $01-$04
$04:9EAF .db $10,$FC,$10,$00,$08,$FC,$0C,$F4 ; (Y,X) offset pairs, tiles $05-$08
$04:9EB7 .db $FC,$04,$04,$FC,$F8,$10,$00,$10 ; (Y,X) offset pairs, tiles $09-$0C
$04:9EBF .db $FC,$08,$FC,$08,$FC,$10,$00,$10 ; (Y,X) offset pairs, tiles $0D-$10
$04:9EC7 .db $F8,$04,$FC,$10,$00,$10,$10,$08 ; (Y,X) offset pairs, tiles $11-$14
$04:9ECF .db $10,$04,$10,$04,$08,$04,$0C,$0C ; (Y,X) offset pairs, tiles $15-$18
$04:9ED7 .db $04,$04,$04,$04,$08,$10,$FC,$F8 ; (Y,X) offset pairs, tiles $19-$1C
$04:9EDF .db $FC,$F8,$04,$10,$F8,$FC,$04,$10 ; (Y,X) offset pairs, tiles $1D-$20
$04:9EE7 .db $F4,$F4,$0C,$F4,$10,$00,$00,$10 ; (Y,X) offset pairs, tiles $21-$24
$04:9EEF .db $00,$10,$10,$00,$10,$00,$FC,$08 ; (Y,X) offset pairs, tiles $25-$28
$04:9EF7 .db $FC,$08,$00,$10,$10,$FC,$10,$FC ; (Y,X) offset pairs, tiles $29-$2C
$04:9EFF .db $FC,$04,$04,$FC,$F8,$10,$00,$10 ; (Y,X) offset pairs, tiles $2D-$30
$04:9F07 .db $FC,$10,$10,$04,$10,$00,$04,$10 ; (Y,X) offset pairs, tiles $31-$34
$04:9F0F .db $04,$04,$FC,$F8,$04,$04,$10,$08 ; (Y,X) offset pairs, tiles $35-$38
$04:9F17 .db $0C,$F4,$00,$10,$FC,$10,$10,$00 ; (Y,X) offset pairs, tiles $39-$3C
$04:9F1F .db $04,$10,$10,$F8,$00,$10,$00,$10 ; (Y,X) offset pairs, tiles $3D-$40
$04:9F27 .db $FC,$10,$10,$00,$00,$10,$00,$10 ; (Y,X) offset pairs, tiles $41-$44
$04:9F2F .db $00,$10,$00,$10,$00,$10,$00,$10 ; (Y,X) offset pairs, tiles $45-$48
$04:9F37 .db $04,$FC,$04,$04,$04,$04,$00,$10 ; (Y,X) offset pairs, tiles $49-$4C
$04:9F3F .db $00,$10,$10,$00,$10,$00,$FC,$10 ; (Y,X) offset pairs, tiles $4D-$50
$04:9F47 .db $FC,$04 ; (Y,X) offset pairs, tiles $51-$51
;;; $9F49..9FE9: Table: path tile flags ;;;
;; Two bytes (0 or 1) per overworld tile (tile number - 1), loaded into [$04]/[$05] by the path movement code
;; at $049720. Probably marks which axis is used.
$04:9F49 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $01-$04
$04:9F51 .db $01,$00,$01,$00,$00,$01,$00,$01 ; Word 0/1 flag pairs, tiles $05-$08
$04:9F59 .db $00,$01,$00,$01,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $09-$0C
$04:9F61 .db $00,$01,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $0D-$10
$04:9F69 .db $00,$01,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $11-$14
$04:9F71 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $15-$18
$04:9F79 .db $01,$00,$01,$00,$01,$00,$00,$01 ; Word 0/1 flag pairs, tiles $19-$1C
$04:9F81 .db $00,$01,$01,$00,$00,$01,$01,$00 ; Word 0/1 flag pairs, tiles $1D-$20
$04:9F89 .db $00,$01,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $21-$24
$04:9F91 .db $01,$00,$01,$00,$01,$00,$00,$01 ; Word 0/1 flag pairs, tiles $25-$28
$04:9F99 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $29-$2C
$04:9FA1 .db $00,$01,$00,$01,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $2D-$30
$04:9FA9 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $31-$34
$04:9FB1 .db $01,$00,$00,$01,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $35-$38
$04:9FB9 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $39-$3C
$04:9FC1 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $3D-$40
$04:9FC9 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $41-$44
$04:9FD1 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $45-$48
$04:9FD9 .db $00,$01,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $49-$4C
$04:9FE1 .db $01,$00,$01,$00,$01,$00,$01,$00 ; Word 0/1 flag pairs, tiles $4D-$50
$04:9FE9 .db $00,$01 ; Word 0/1 flag pairs, tiles $51-$51
;;; $9FEB..A03B: Table: overworld tile properties ;;;
;; One byte per overworld tile (tile number - 1), read into [$0E] at $0495EF. Value $14 sets [$1B80] = 1.
;; Meaning of the other values (0, 4, 8, $C) not verified.
$04:9FEB .db $04,$04,$04,$04,$04,$04,$04,$00 ; Property bytes, tiles $01-$08
$04:9FF3 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Property bytes, tiles $09-$10
$04:9FFB .db $04,$00,$00,$04,$04,$04,$04,$00 ; Property bytes, tiles $11-$18
$04:A003 .db $00,$00,$00,$00,$00,$00,$04,$00 ; Property bytes, tiles $19-$20
$04:A00B .db $00,$00,$04,$00,$00,$04,$04,$08 ; Property bytes, tiles $21-$28
$04:A013 .db $08,$08,$0C,$0C,$08,$08,$08,$08 ; Property bytes, tiles $29-$30
$04:A01B .db $08,$0C,$0C,$08,$08,$08,$08,$0C ; Property bytes, tiles $31-$38
$04:A023 .db $08,$08,$08,$0C,$08,$0C,$14,$14 ; Property bytes, tiles $39-$40
$04:A02B .db $14,$04,$00,$00,$00,$00,$00,$00 ; Property bytes, tiles $41-$48
$04:A033 .db $00,$00,$00,$00,$00,$04,$04,$08 ; Property bytes, tiles $49-$50
$04:A03B .db $00 ; Property bytes, tiles $51-$51
;;; $A03C..A04C: Table: corner path tile numbers ;;;
;; 24 tile numbers, mostly path corners ($4D is the bridge exit). Searched when leaving a level tile. Entry
;; index selects rows of the tables at $04A054, $04A084 and $04A0E4.
$04:A03C .db $07,$09,$0A,$0D,$0E,$11,$17,$19 ; Tile numbers, entries 0-7
$04:A044 .db $1A,$1C,$1D,$1F,$28,$29,$2D,$2E ; Tile numbers, entries 8-15
$04:A04C .db $35,$36,$37,$49,$4A,$4B,$4D,$51 ; Tile numbers, entries 16-23
;;; $A054..A07C: Table: corner tile step bytes ;;;
;; Byte pairs per entry of the corner tile table at $04A03C, read at $0496FF. Exact meaning not verified.
$04:A054 .db $08,$FC,$FC,$08,$FC,$08,$FC,$08 ; Byte pairs, entries 0-3
$04:A05C .db $FC,$08,$04,$00,$08,$04,$04,$08 ; Byte pairs, entries 4-7
$04:A064 .db $04,$08,$04,$00,$04,$08,$04,$00 ; Byte pairs, entries 8-11
$04:A06C .db $FC,$08,$00,$00,$FC,$08,$FC,$08 ; Byte pairs, entries 12-15
$04:A074 .db $04,$00,$04,$00,$00,$00,$08,$FC ; Byte pairs, entries 16-19
$04:A07C .db $08,$04,$08,$04,$FC,$08,$08,$FC ; Byte pairs, entries 20-23
;;; $A084..A0DE: Table: corner tile X/Y offsets ;;;
;; 24 entries of two signed 16-bit values (X offset, Y offset), 4 bytes each, indexed by entry * 4 in the
;; corner tile table at $04A03C (read at $0493A4). Label $04A086 starts at the second word of entry 0.
$04:A084 .db $04,$00 ; Entry 0 word 1: X offset +4
$04:A086 .db $F8,$FF,$08,$00,$FC,$FF,$F8,$FF ; 16-bit offsets (signed), words 1-4 from entry 0
$04:A08E .db $04,$00,$F8,$FF,$04,$00,$08,$00 ; 16-bit offsets (signed), words 5-8 from entry 0
$04:A096 .db $FC,$FF,$04,$00,$04,$00,$04,$00 ; 16-bit offsets (signed), words 9-12 from entry 0
$04:A09E .db $08,$00,$08,$00,$04,$00,$F8,$FF ; 16-bit offsets (signed), words 13-16 from entry 0
$04:A0A6 .db $FC,$FF,$00,$00,$00,$00,$08,$00 ; 16-bit offsets (signed), words 17-20 from entry 0
$04:A0AE .db $04,$00,$04,$00,$04,$00,$F8,$FF ; 16-bit offsets (signed), words 21-24 from entry 0
$04:A0B6 .db $04,$00,$04,$00,$04,$00,$08,$00 ; 16-bit offsets (signed), words 25-28 from entry 0
$04:A0BE .db $FC,$FF,$F8,$FF,$04,$00,$04,$00 ; 16-bit offsets (signed), words 29-32 from entry 0
$04:A0C6 .db $04,$00,$00,$00,$00,$00,$04,$00 ; 16-bit offsets (signed), words 33-36 from entry 0
$04:A0CE .db $04,$00,$04,$00,$F8,$FF,$04,$00 ; 16-bit offsets (signed), words 37-40 from entry 0
$04:A0D6 .db $08,$00,$FC,$FF,$F8,$FF,$F8,$FF ; 16-bit offsets (signed), words 41-44 from entry 0
$04:A0DE .db $04,$00,$FC,$FF,$08,$00 ; 16-bit offsets (signed), words 45-47 from entry 0
;;; $A0E4..A0F4: Table: corner tile direction flags ;;;
;; One byte per corner tile entry. Bit 1 set means the first offset is used as the Y offset instead of X; the
;; sum with [$0DD6] picks the player.
$04:A0E4 .db $02,$02,$02,$02,$02,$00,$02,$02 ; Direction flags (bit 1 = Y offset), entries 0-7
$04:A0EC .db $02,$00,$02,$00,$02,$00,$02,$02 ; Direction flags (bit 1 = Y offset), entries 8-15
$04:A0F4 .db $00,$00,$00,$02,$02,$02,$02,$02 ; Direction flags (bit 1 = Y offset), entries 16-23
;;; $A0FC: Level names, OW border, OW map setup (LevelNames) ;;;
;; Overworld data followed by the routines that use it. Parts, in order:
;; $04A0FC: level name codes, one 16-bit word per level number ($7E:D000 map value, $00-$5C, then $FFFF
;; padding up to $04A3FF).
;; Probably: high byte (bits 0-6) = index into $9C91 for the first name word, low byte high/low nibbles
;; = $9CCF / $9CED entries.
;; $04A400: stripe image #6 (overworld border; see ImagePointers) in LoadScrnImage record format, ends with
;; $FF at $04A532.
;; $04A533: RLE-compressed overworld tilemaps: tile number bytes ($04A533-$04C02A) then tile property bytes
;; ($04C02B-$04D677), each
;; decoded by $DABA to every other byte of $7F:4000 (header bit 7 clear: n+1 literal bytes, set: one
;; byte repeated n+1 times).
;; $04D678: per-level byte table copied to $7E:D800 by $D7F2 (index = level number, entry 0 unused).
;; $04D6E9 (long call, from $00:A165 during overworld load): renders the overworld layer 1 tilemap row by row
;; with the level renderer,
;; then DMAs the decompressed map from $7F:4000 (submap: $7F:6000) to VRAM $3000. Quirk: the submap flag is
;; [$1F11 + player].
;; $04D770: stores A at index X in 31 tables of $1B0 bytes each starting at $7F:C800 (strides of $1B0), then
;; X++.
;; $04D7F2: builds the level number map $7E:D000 (each tile $56-$80 of $7E:C800 gets the next number, from 1)
;; and the byte table $7E:D800,
;; then calls $DA49 for every level $00-$6E so beaten levels show their cleared tiles.
$04:A0FC .db $00,$00,$72,$0D,$73,$0D,$00,$0C ; Levels $00-$03: name code per level (see section summary)
$04:A104 .db $60,$0A,$53,$0A,$54,$0A,$40,$04 ; Levels $04-$07
$04:A10C .db $30,$0B,$52,$0A,$71,$0A,$90,$0D ; Levels $08-$0B
$04:A114 .db $01,$11,$02,$11,$40,$06,$07,$12 ; Levels $0C-$0F
$04:A11C .db $00,$14,$00,$13,$C0,$02,$7C,$0A ; Levels $10-$13
$04:A124 .db $33,$0E,$51,$0A,$C0,$02,$53,$04 ; Levels $14-$17
$04:A12C .db $00,$18,$53,$04,$40,$08,$90,$16 ; Levels $18-$1B
$04:A134 .db $25,$16,$24,$16,$C0,$02,$90,$15 ; Levels $1C-$1F
$04:A13C .db $40,$07,$00,$17,$21,$16,$23,$16 ; Levels $20-$23
$04:A144 .db $22,$16,$40,$03,$24,$01,$23,$01 ; Levels $24-$27
$04:A14C .db $10,$01,$21,$01,$22,$01,$60,$0D ; Levels $28-$2B
$04:A154 .db $C0,$02,$71,$0D,$83,$0D,$72,$0A ; Levels $2C-$2F
$04:A15C .db $C0,$02,$00,$1B,$00,$1A,$B4,$19 ; Levels $30-$33
$04:A164 .db $40,$09,$90,$19,$00,$00,$B3,$19 ; Levels $34-$37
$04:A16C .db $60,$19,$B2,$19,$B1,$19,$70,$16 ; Levels $38-$3B
$04:A174 .db $82,$0D,$84,$0D,$81,$0D,$30,$0F ; Levels $3C-$3F
$04:A17C .db $40,$05,$60,$15,$A1,$15,$A4,$15 ; Levels $40-$43
$04:A184 .db $A2,$15,$30,$10,$77,$15,$A3,$15 ; Levels $44-$47
$04:A18C .db $C0,$02,$0B,$00,$0A,$00,$09,$00 ; Levels $48-$4B
$04:A194 .db $08,$00,$C0,$02,$00,$1C,$00,$1D ; Levels $4C-$4F
$04:A19C .db $00,$1E,$E0,$00,$C0,$02,$C0,$02 ; Levels $50-$53
$04:A1A4 .db $D2,$02,$C0,$02,$D3,$02,$C0,$02 ; Levels $54-$57
$04:A1AC .db $D1,$02,$D4,$02,$D5,$02,$C0,$02 ; Levels $58-$5B
$04:A1B4 .db $C0,$02,$FF,$FF,$FF,$FF,$FF,$FF ; Level $5C name code, then $FFFF padding (unused level numbers)
$04:A1BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A1FC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A204 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A20C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A214 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A21C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A224 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A22C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A234 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A23C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A244 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A24C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A254 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A25C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A264 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A26C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A274 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A27C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A284 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A28C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A294 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A29C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A2FC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A304 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A30C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A314 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A31C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A324 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A32C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A334 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A33C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A344 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A34C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A354 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A35C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A364 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A36C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A374 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A37C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A384 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A38C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A394 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A39C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:A3FC .db $FF,$FF,$FF,$FF
$04:A400 .db $50,$00,$41,$3E,$FE,$38,$50,$A0 ; VRAM $5000 RLE 319B (record: addr hi/lo, flags+length, data; ends at $FF)
$04:A408 .db $C0,$28,$FE,$38,$50,$A1,$C0,$28 ; VRAM $50A1 vertical RLE 41B
$04:A410 .db $FE,$38,$50,$BE,$C0,$28,$FE,$38 ; VRAM $50BE vertical RLE 41B
$04:A418 .db $50,$BF,$C0,$28,$FE,$38,$53,$40 ; VRAM $50BF vertical RLE 41B; $5340 RLE 383B
$04:A420 .db $41,$7E,$FE,$38,$50,$A2,$00,$01 ; VRAM $50A2 raw 2B
$04:A428 .db $92,$3C,$50,$A3,$40,$32,$93,$3C ; VRAM $50A3 RLE 51B
$04:A430 .db $50,$BD,$00,$01,$92,$7C,$50,$C2 ; VRAM $50BD raw 2B; $50C2 vertical RLE 37B
$04:A438 .db $C0,$24,$94,$7C,$50,$DD,$C0,$24 ; VRAM $50DD vertical RLE 37B
$04:A440 .db $94,$3C,$53,$22,$00,$01,$92,$BC ; VRAM $5322 raw 2B
$04:A448 .db $53,$23,$40,$32,$93,$BC,$53,$3D ; VRAM $5323 RLE 51B; $533D raw 2B
$04:A450 .db $00,$01,$92,$FC,$50,$FE,$C0,$24 ; VRAM $50FE vertical RLE 37B
$04:A458 .db $D6,$2C,$53,$44,$40,$32,$D5,$2C ; VRAM $5344 RLE 51B
$04:A460 .db $50,$DE,$00,$01,$D4,$2C,$53,$43 ; VRAM $50DE raw 2B; $5343 raw 2B
$04:A468 .db $00,$01,$D4,$EC,$53,$5E,$00,$01 ; VRAM $535E raw 2B
$04:A470 .db $D4,$AC,$50,$02,$00,$01,$95,$38 ; VRAM $5002 raw 2B
$04:A478 .db $50,$09,$00,$01,$97,$38,$50,$0E ; VRAM $5009 raw 2B; $500E raw 2B
$04:A480 .db $00,$01,$96,$38,$50,$33,$00,$01 ; VRAM $5033 raw 2B
$04:A488 .db $97,$38,$50,$37,$00,$01,$95,$38 ; VRAM $5037 raw 2B
$04:A490 .db $50,$3B,$00,$01,$96,$38,$50,$42 ; VRAM $503B raw 2B; $5042 raw 2B
$04:A498 .db $00,$01,$96,$38,$50,$50,$00,$01 ; VRAM $5050 raw 2B
$04:A4A0 .db $95,$38,$50,$55,$00,$01,$96,$38 ; VRAM $5055 raw 2B
$04:A4A8 .db $50,$5E,$00,$01,$95,$38,$51,$01 ; VRAM $505E raw 2B; $5101 raw 2B
$04:A4B0 .db $00,$01,$97,$38,$51,$5F,$00,$01 ; VRAM $515F raw 2B
$04:A4B8 .db $96,$38,$51,$81,$00,$01,$95,$38 ; VRAM $5181 raw 2B
$04:A4C0 .db $51,$C0,$00,$01,$96,$38,$51,$FF ; VRAM $51C0 raw 2B; $51FF raw 2B
$04:A4C8 .db $00,$01,$97,$38,$52,$60,$00,$01 ; VRAM $5260 raw 2B
$04:A4D0 .db $95,$38,$52,$7F,$00,$01,$95,$38 ; VRAM $527F raw 2B
$04:A4D8 .db $53,$00,$00,$01,$97,$38,$53,$1F ; VRAM $5300 raw 2B; $531F raw 2B
$04:A4E0 .db $00,$01,$96,$38,$53,$61,$00,$01 ; VRAM $5361 raw 2B
$04:A4E8 .db $95,$38,$53,$6A,$00,$01,$95,$38 ; VRAM $536A raw 2B
$04:A4F0 .db $53,$73,$00,$01,$96,$38,$53,$76 ; VRAM $5373 raw 2B; $5376 raw 2B
$04:A4F8 .db $00,$01,$95,$38,$53,$86,$00,$01 ; VRAM $5386 raw 2B
$04:A500 .db $96,$38,$53,$91,$00,$01,$95,$38 ; VRAM $5391 raw 2B
$04:A508 .db $53,$9A,$00,$01,$97,$38,$53,$9E ; VRAM $539A raw 2B; $539E raw 2B
$04:A510 .db $00,$01,$95,$38,$50,$23,$C0,$06 ; VRAM $5023 vertical RLE 7B
$04:A518 .db $FC,$2C,$50,$24,$C0,$06,$FC,$2C ; VRAM $5024 vertical RLE 7B
$04:A520 .db $50,$25,$C0,$06,$FC,$2C,$50,$26 ; VRAM $5025 vertical RLE 7B; $5026 vertical RLE 7B
$04:A528 .db $C0,$06,$FC,$2C,$50,$87,$00,$01 ; VRAM $5087 raw 2B
$04:A530 .db $8F,$38,$FF,$9B,$75,$81,$20,$01 ; End of stripe image ($FF at $A532); $A533: start of compressed tile number stream
$04:A538 .db $76,$20,$9B,$75,$81,$20,$01,$76
$04:A540 .db $20,$9A,$75,$00,$10,$81,$20,$01
$04:A548 .db $76,$20,$94,$75,$00,$01,$81,$02
$04:A550 .db $81,$01,$05,$02,$11,$50,$20,$7D
$04:A558 .db $20,$92,$75,$02,$10,$03,$11,$81
$04:A560 .db $71,$81,$11,$81,$71,$03,$11,$43
$04:A568 .db $10,$9C,$91,$75,$01,$10,$11,$89
$04:A570 .db $71,$01,$11,$10,$89,$75,$04,$01
$04:A578 .db $02,$03,$02,$01,$82,$75,$01,$3D
$04:A580 .db $71,$83,$AD,$81,$8A,$81,$AD,$81
$04:A588 .db $8A,$01,$11,$10,$89,$75,$00,$3D
$04:A590 .db $82,$71,$00,$3D,$82,$75,$01,$3D
$04:A598 .db $71,$83,$AD,$81,$8A,$81,$AD,$81
$04:A5A0 .db $8A,$01,$3D,$3F,$89,$75,$00,$00
$04:A5A8 .db $81,$43,$01,$42,$40,$81,$75,$01
$04:A5B0 .db $10,$00,$83,$43,$00,$11,$85,$71
$04:A5B8 .db $01,$11,$10,$88,$75,$01,$11,$20
$04:A5C0 .db $82,$69,$03,$20,$11,$75,$3D,$81
$04:A5C8 .db $20,$82,$69,$00,$00,$81,$43,$00
$04:A5D0 .db $11,$83,$71,$00,$3D,$88,$75,$01
$04:A5D8 .db $11,$50,$81,$69,$04,$41,$42,$11
$04:A5E0 .db $75,$3D,$81,$20,$81,$69,$01,$20
$04:A5E8 .db $69,$81,$20,$00,$50,$83,$43,$00
$04:A5F0 .db $10,$89,$75,$00,$11,$81,$43,$00
$04:A5F8 .db $11,$82,$75,$02,$3D,$50,$20,$82
$04:A600 .db $69,$81,$20,$01,$69,$20,$82,$69
$04:A608 .db $01,$20,$76,$86,$75,$01,$54,$55
$04:A610 .db $87,$75,$01,$00,$11,$83,$43,$00
$04:A618 .db $50,$81,$20,$83,$69,$01,$20,$76
$04:A620 .db $86,$75,$03,$9E,$9F,$06,$05,$85
$04:A628 .db $03,$01,$20,$50,$83,$43,$00,$11
$04:A630 .db $81,$43,$00,$50,$82,$69,$01,$20
$04:A638 .db $7D,$84,$75,$04,$01,$02,$9E,$9F
$04:A640 .db $58,$81,$71,$02,$BA,$BD,$BF,$81
$04:A648 .db $71,$81,$20,$83,$69,$03,$50,$11
$04:A650 .db $71,$11,$82,$43,$01,$9C,$10,$84
$04:A658 .db $75,$0E,$3D,$71,$9E,$9F,$71,$58
$04:A660 .db $71,$BD,$BF,$BA,$71,$11,$20,$69
$04:A668 .db $20,$83,$69,$00,$50,$83,$43,$02
$04:A670 .db $10,$9C,$43,$84,$75,$04,$3D,$58
$04:A678 .db $9E,$9F,$71,$81,$58,$06,$BF,$71
$04:A680 .db $BD,$71,$11,$50,$20,$84,$69,$00
$04:A688 .db $20,$82,$69,$03,$20,$76,$20,$69
$04:A690 .db $83,$75,$05,$10,$11,$58,$9E,$9F
$04:A698 .db $58,$81,$71,$07,$58,$BA,$BD,$BF
$04:A6A0 .db $71,$11,$50,$20,$84,$69,$00,$20
$04:A6A8 .db $81,$69,$03,$20,$76,$20,$69,$82
$04:A6B0 .db $75,$06,$10,$11,$56,$57,$9E,$9F
$04:A6B8 .db $58,$82,$71,$02,$BD,$71,$BA,$81
$04:A6C0 .db $71,$81,$58,$04,$43,$58,$43,$50
$04:A6C8 .db $20,$82,$69,$03,$20,$76,$20,$69
$04:A6D0 .db $82,$75,$05,$3D,$58,$9E,$9F,$64
$04:A6D8 .db $65,$84,$71,$81,$BD,$00,$BF,$83
$04:A6E0 .db $58,$04,$71,$58,$11,$50,$20,$81
$04:A6E8 .db $69,$03,$20,$76,$20,$69,$82,$75
$04:A6F0 .db $03,$3D,$71,$64,$65,$81,$71,$00
$04:A6F8 .db $6E,$81,$6B,$05,$6E,$BD,$BF,$BA
$04:A700 .db $BD,$58,$81,$8A,$01,$AD,$8E,$81
$04:A708 .db $58,$07,$11,$43,$BC,$3D,$20,$7D
$04:A710 .db $20,$69,$82,$75,$01,$00,$11,$81
$04:A718 .db $71,$01,$AE,$BC,$83,$68,$04,$BA
$04:A720 .db $BD,$11,$43,$11,$81,$8A,$09,$AD
$04:A728 .db $8A,$8F,$53,$52,$71,$BC,$3D,$43
$04:A730 .db $3F,$81,$43,$82,$75,$06,$20,$50
$04:A738 .db $11,$8F,$9B,$71,$6E,$81,$6B,$05
$04:A740 .db $6E,$11,$43,$00,$69,$00,$81,$43
$04:A748 .db $08,$58,$8F,$9B,$63,$62,$71,$BC
$04:A750 .db $71,$10,$82,$3F,$82,$75,$02,$20
$04:A758 .db $50,$11,$81,$AC,$01,$58,$11,$82
$04:A760 .db $43,$04,$00,$69,$50,$43,$50,$81
$04:A768 .db $20,$04,$50,$58,$9B,$8F,$6C,$81
$04:A770 .db $68,$01,$6C,$3D,$82,$3F,$82,$75
$04:A778 .db $02,$00,$11,$58,$81,$AC,$09,$11
$04:A780 .db $50,$20,$69,$20,$50,$43,$11,$3F
$04:A788 .db $11,$81,$43,$03,$50,$3D,$8A,$BC
$04:A790 .db $83,$68,$00,$6C,$82,$03,$81,$75
$04:A798 .db $03,$10,$11,$56,$57,$81,$AC,$01
$04:A7A0 .db $3D,$50,$82,$43,$00,$11,$85,$3F
$04:A7A8 .db $03,$10,$11,$8A,$BC,$84,$68,$81
$04:A7B0 .db $71,$00,$43,$81,$75,$03,$3D,$58
$04:A7B8 .db $64,$65,$81,$8A,$01,$11,$10,$87
$04:A7C0 .db $3F,$03,$10,$03,$52,$53,$81,$71
$04:A7C8 .db $00,$6C,$82,$68,$03,$6C,$11,$00
$04:A7D0 .db $69,$81,$75,$03,$3D,$71,$56,$57
$04:A7D8 .db $81,$8A,$01,$58,$3D,$86,$3F,$00
$04:A7E0 .db $10,$81,$8F,$0B,$62,$63,$52,$53
$04:A7E8 .db $71,$52,$53,$71,$11,$50,$69,$20
$04:A7F0 .db $81,$75,$03,$00,$11,$64,$65,$81
$04:A7F8 .db $AC,$02,$11,$00,$11,$84,$3F,$0F
$04:A800 .db $10,$52,$53,$71,$8E,$71,$62,$63
$04:A808 .db $52,$51,$63,$11,$50,$69,$20,$69
$04:A810 .db $81,$75,$03,$20,$3D,$71,$58,$81
$04:A818 .db $AC,$02,$3D,$50,$11,$84,$3F,$04
$04:A820 .db $3D,$62,$63,$71,$8E,$82,$71,$03
$04:A828 .db $62,$63,$42,$41,$82,$69,$00,$20
$04:A830 .db $81,$75,$03,$20,$3D,$58,$71,$81
$04:A838 .db $AC,$00,$3D,$83,$3F,$00,$10,$81
$04:A840 .db $03,$0A,$11,$52,$53,$52,$53,$71
$04:A848 .db $52,$53,$11,$50,$20,$82,$69,$07
$04:A850 .db $50,$43,$75,$11,$20,$00,$11,$71
$04:A858 .db $81,$AC,$01,$11,$10,$82,$3F,$00
$04:A860 .db $3D,$81,$71,$09,$52,$51,$63,$62
$04:A868 .db $63,$52,$51,$63,$3A,$20,$82,$69
$04:A870 .db $03,$50,$11,$75,$20,$9E,$75,$00
$04:A878 .db $20,$9E,$75,$01,$20,$10,$95,$75
$04:A880 .db $03,$E2,$E5,$F5,$F6,$83,$75,$02
$04:A888 .db $50,$11,$10,$90,$75,$07,$01,$02
$04:A890 .db $03,$05,$84,$32,$33,$C4,$83,$75
$04:A898 .db $03,$11,$71,$11,$10,$8D,$75,$02
$04:A8A0 .db $01,$02,$11,$82,$71,$04,$35,$36
$04:A8A8 .db $37,$38,$01,$82,$75,$01,$10,$03
$04:A8B0 .db $81,$11,$00,$10,$8B,$75,$01,$10
$04:A8B8 .db $11,$84,$71,$05,$49,$4A,$59,$5A
$04:A8C0 .db $11,$10,$81,$75,$81,$3F,$02,$10
$04:A8C8 .db $71,$3D,$8B,$75,$02,$3D,$AD,$5D
$04:A8D0 .db $84,$68,$00,$5D,$82,$71,$00,$3D
$04:A8D8 .db $81,$75,$82,$3F,$81,$3D,$8B,$75
$04:A8E0 .db $01,$3D,$AD,$86,$68,$81,$71,$01
$04:A8E8 .db $11,$00,$81,$75,$81,$3F,$02,$10
$04:A8F0 .db $11,$00,$87,$75,$01,$01,$02,$81
$04:A8F8 .db $03,$02,$00,$11,$5D,$84,$68,$04
$04:A900 .db $5D,$71,$11,$50,$20,$81,$75,$05
$04:A908 .db $3F,$10,$11,$50,$20,$10,$85,$75
$04:A910 .db $01,$10,$11,$82,$71,$04,$20,$50
$04:A918 .db $44,$43,$44,$81,$43,$05,$44,$43
$04:A920 .db $42,$40,$69,$20,$81,$75,$05,$9C
$04:A928 .db $43,$50,$69,$20,$3D,$85,$A4,$01
$04:A930 .db $3D,$AD,$81,$8A,$03,$11,$20,$69
$04:A938 .db $20,$87,$69,$81,$20,$81,$75,$81
$04:A940 .db $20,$81,$69,$01,$50,$3D,$81,$B4
$04:A948 .db $01,$B5,$A5,$81,$B4,$01,$3D,$AD
$04:A950 .db $81,$8A,$02,$11,$50,$20,$87,$69
$04:A958 .db $0A,$20,$69,$20,$10,$75,$20,$69
$04:A960 .db $20,$50,$11,$4D,$85,$75,$01,$4D
$04:A968 .db $71,$81,$AC,$03,$71,$11,$50,$20
$04:A970 .db $87,$69,$81,$20,$01,$11,$10,$81
$04:A978 .db $20,$00,$50,$81,$11,$01,$00,$02
$04:A980 .db $82,$03,$05,$02,$01,$3D,$71,$8F
$04:A988 .db $9B,$81,$71,$01,$11,$44,$81,$43
$04:A990 .db $00,$60,$83,$69,$04,$20,$69,$20
$04:A998 .db $71,$3D,$81,$43,$81,$11,$02,$50
$04:A9A0 .db $20,$11,$82,$43,$81,$11,$03,$00
$04:A9A8 .db $11,$71,$AE,$83,$BC,$02,$AE,$11
$04:A9B0 .db $00,$84,$69,$0A,$20,$50,$58,$4D
$04:A9B8 .db $43,$11,$71,$3D,$69,$20,$41,$82
$04:A9C0 .db $69,$07,$41,$42,$20,$41,$42,$44
$04:A9C8 .db $43,$44,$81,$43,$02,$44,$50,$20
$04:A9D0 .db $83,$69,$0B,$20,$50,$11,$71,$3D
$04:A9D8 .db $20,$50,$43,$00,$69,$20,$42,$82
$04:A9E0 .db $43,$02,$42,$41,$20,$81,$69,$00
$04:A9E8 .db $20,$84,$69,$81,$20,$82,$69,$0B
$04:A9F0 .db $41,$42,$11,$58,$71,$4D,$69,$20
$04:A9F8 .db $69,$20,$69,$20,$85,$73,$02,$20
$04:AA00 .db $69,$20,$84,$69,$02,$20,$69,$20
$04:AA08 .db $82,$43,$00,$11,$81,$58,$03,$71
$04:AA10 .db $58,$3D,$20,$81,$69,$03,$20,$69
$04:AA18 .db $50,$11,$83,$3F,$01,$11,$20,$81
$04:AA20 .db $69,$00,$20,$84,$69,$02,$20,$50
$04:AA28 .db $58,$81,$AC,$81,$89,$81,$58,$07
$04:AA30 .db $11,$00,$69,$20,$69,$20,$50,$11
$04:AA38 .db $84,$3F,$03,$11,$50,$69,$20,$84
$04:AA40 .db $69,$01,$20,$50,$81,$89,$81,$AC
$04:AA48 .db $81,$99,$81,$89,$00,$3D,$81,$20
$04:AA50 .db $81,$69,$01,$20,$11,$86,$3F,$04
$04:AA58 .db $11,$42,$41,$20,$60,$83,$43,$00
$04:AA60 .db $11,$81,$99,$81,$AC,$81,$89,$81
$04:AA68 .db $99,$06,$3D,$20,$43,$50,$69,$50
$04:AA70 .db $11,$88,$3F,$03,$11,$43,$3D,$71
$04:AA78 .db $81,$89,$01,$71,$58,$81,$89,$81
$04:AA80 .db $8F,$09,$99,$98,$89,$71,$3D,$20
$04:AA88 .db $3F,$11,$43,$11,$8A,$3F,$02,$10
$04:AA90 .db $11,$58,$81,$99,$81,$89,$01,$99
$04:AA98 .db $98,$82,$89,$81,$99,$02,$58,$3D
$04:AAA0 .db $50,$82,$3F,$81,$10,$83,$3F,$81
$04:AAA8 .db $10,$82,$3F,$01,$10,$11,$81,$89
$04:AAB0 .db $04,$58,$89,$98,$99,$89,$82,$98
$04:AAB8 .db $00,$99,$81,$89,$02,$58,$4D,$11
$04:AAC0 .db $82,$03,$02,$11,$00,$11,$81,$3F
$04:AAC8 .db $00,$10,$81,$11,$82,$03,$04,$11
$04:AAD0 .db $58,$99,$98,$89,$81,$99,$00,$89
$04:AAD8 .db $83,$98,$00,$89,$81,$99,$02,$71
$04:AAE0 .db $4D,$75,$82,$43,$81,$50,$02,$11
$04:AAE8 .db $3F,$9C,$82,$43,$02,$11,$71,$58
$04:AAF0 .db $82,$89,$01,$98,$99,$81,$89,$85
$04:AAF8 .db $99,$00,$58,$81,$89,$01,$11,$10
$04:AB00 .db $81,$69,$81,$20,$82,$76,$00,$20
$04:AB08 .db $81,$69,$03,$20,$50,$11,$71,$82
$04:AB10 .db $99,$03,$98,$89,$99,$98,$86,$89
$04:AB18 .db $81,$99,$01,$58,$3D,$81,$69,$81
$04:AB20 .db $20,$82,$76,$00,$20,$82,$69,$03
$04:AB28 .db $20,$41,$42,$11,$81,$89,$81,$99
$04:AB30 .db $01,$89,$98,$81,$99,$81,$98,$82
$04:AB38 .db $99,$81,$89,$01,$58,$3D,$81,$69
$04:AB40 .db $81,$20,$82,$7D,$00,$20,$81,$69
$04:AB48 .db $00,$20,$82,$69,$00,$3D,$81,$99
$04:AB50 .db $81,$89,$01,$99,$98,$81,$89,$81
$04:AB58 .db $98,$06,$89,$3B,$89,$98,$99,$11
$04:AB60 .db $00,$81,$69,$05,$20,$50,$11,$3F
$04:AB68 .db $11,$20,$82,$69,$00,$20,$81,$69
$04:AB70 .db $06,$3D,$71,$58,$99,$98,$89,$99
$04:AB78 .db $83,$98,$01,$99,$89,$81,$98,$02
$04:AB80 .db $89,$3D,$20,$82,$43,$00,$11,$81
$04:AB88 .db $3F,$00,$11,$83,$43,$03,$50,$41
$04:AB90 .db $42,$11,$82,$89,$82,$98,$82,$99
$04:AB98 .db $01,$98,$89,$83,$99,$01,$3D,$20
$04:ABA0 .db $87,$75,$04,$08,$07,$06,$05,$11
$04:ABA8 .db $81,$58,$84,$99,$00,$98,$82,$89
$04:ABB0 .db $81,$99,$81,$89,$09,$58,$71,$3D
$04:ABB8 .db $20,$75,$11,$50,$20,$3D,$71,$81
$04:ABC0 .db $AC,$01,$71,$11,$82,$03,$00,$11
$04:ABC8 .db $81,$71,$01,$62,$63,$82,$71,$08
$04:ABD0 .db $62,$63,$11,$2A,$69,$20,$69,$50
$04:ABD8 .db $11,$83,$75,$05,$11,$20,$00,$11
$04:ABE0 .db $8F,$9B,$84,$71,$00,$5D,$81,$68
$04:ABE8 .db $00,$5D,$82,$71,$03,$58,$71,$11
$04:ABF0 .db $50,$81,$20,$02,$41,$42,$11,$85
$04:ABF8 .db $75,$06,$00,$43,$23,$30,$AE,$AF
$04:AC00 .db $AD,$81,$8A,$01,$71,$5D,$81,$68
$04:AC08 .db $00,$5D,$83,$71,$05,$11,$50,$20
$04:AC10 .db $69,$2A,$11,$86,$75,$01,$10,$11
$04:AC18 .db $81,$71,$03,$11,$30,$8E,$AD,$81
$04:AC20 .db $8A,$01,$52,$53,$81,$71,$81,$58
$04:AC28 .db $03,$71,$58,$11,$50,$81,$69,$01
$04:AC30 .db $20,$3A,$81,$75,$01,$A6,$A7,$83
$04:AC38 .db $75,$01,$00,$11,$81,$71,$03,$11
$04:AC40 .db $00,$52,$53,$81,$AC,$02,$62,$63
$04:AC48 .db $71,$81,$58,$03,$11,$43,$42,$41
$04:AC50 .db $81,$69,$08,$20,$50,$11,$A6,$A7
$04:AC58 .db $B6,$B7,$A6,$A7,$81,$75,$01,$20
$04:AC60 .db $50,$81,$43,$03,$50,$20,$62,$63
$04:AC68 .db $81,$AC,$00,$71,$81,$58,$03,$71
$04:AC70 .db $11,$50,$20,$83,$69,$04,$50,$11
$04:AC78 .db $75,$B6,$B7,$81,$3F,$01,$B6,$B7
$04:AC80 .db $81,$75,$01,$20,$69,$81,$3E,$0C
$04:AC88 .db $69,$20,$42,$44,$43,$44,$43,$44
$04:AC90 .db $43,$42,$41,$69,$20,$82,$69,$03
$04:AC98 .db $50,$11,$A6,$A7,$85,$3F,$81,$75
$04:ACA0 .db $01,$20,$69,$81,$3E,$00,$69,$82
$04:ACA8 .db $20,$84,$69,$00,$20,$81,$69,$00
$04:ACB0 .db $20,$81,$69,$04,$50,$11,$75,$B6
$04:ACB8 .db $B7,$85,$3F,$81,$75,$01,$20,$69
$04:ACC0 .db $81,$3E,$03,$69,$20,$69,$20,$83
$04:ACC8 .db $69,$00,$20,$82,$69,$05,$20,$41
$04:ACD0 .db $42,$11,$A6,$A7,$87,$3F,$81,$75
$04:ACD8 .db $01,$20,$69,$81,$3E,$00,$69,$81
$04:ACE0 .db $20,$85,$69,$04,$20,$69,$50,$43
$04:ACE8 .db $11,$81,$75,$01,$B6,$B7,$87,$3F
$04:ACF0 .db $81,$75,$01,$20,$69,$81,$3E,$03
$04:ACF8 .db $69,$20,$41,$20,$83,$69,$03,$20
$04:AD00 .db $41,$42,$11,$83,$75,$01,$A6,$A7
$04:AD08 .db $87,$3F,$81,$75,$01,$20,$69,$81
$04:AD10 .db $3E,$02,$69,$20,$11,$85,$43,$00
$04:AD18 .db $11,$85,$75,$01,$B6,$B7,$87,$3F
$04:AD20 .db $81,$75,$01,$20,$69,$81,$3E,$08
$04:AD28 .db $69,$20,$03,$04,$03,$04,$03,$02
$04:AD30 .db $01,$87,$75,$01,$A6,$A7,$86,$3F
$04:AD38 .db $03,$75,$10,$20,$C2,$81,$C3,$03
$04:AD40 .db $C2,$20,$56,$57,$82,$71,$02,$56
$04:AD48 .db $57,$10,$86,$75,$03,$B6,$B7,$A6
$04:AD50 .db $A7,$83,$3F,$04,$A6,$75,$4D,$50
$04:AD58 .db $D2,$81,$D3,$03,$D2,$50,$9E,$9F
$04:AD60 .db $82,$71,$02,$9E,$9F,$3D,$88,$75
$04:AD68 .db $0A,$B6,$B7,$3F,$A6,$A7,$3F,$B6
$04:AD70 .db $75,$3D,$11,$20,$81,$3E,$03,$20
$04:AD78 .db $11,$9E,$9F,$82,$71,$02,$64,$65
$04:AD80 .db $4D,$8B,$75,$01,$B6,$B7,$82,$75
$04:AD88 .db $02,$4D,$11,$50,$81,$3E,$05,$50
$04:AD90 .db $11,$9E,$9F,$56,$57,$81,$71,$01
$04:AD98 .db $58,$3D,$90,$75,$02,$3D,$58,$11
$04:ADA0 .db $81,$43,$06,$11,$58,$64,$65,$9E
$04:ADA8 .db $9F,$71,$81,$58,$00,$3D,$83,$75
$04:ADB0 .db $81,$60,$8A,$75,$00,$00,$81,$43
$04:ADB8 .db $00,$11,$83,$71,$03,$58,$64,$65
$04:ADC0 .db $11,$81,$43,$00,$00,$83,$75,$02
$04:ADC8 .db $3D,$11,$60,$83,$75,$02,$60,$03
$04:ADD0 .db $60,$82,$75,$81,$20,$01,$69,$3D
$04:ADD8 .db $86,$71,$00,$3D,$81,$69,$00,$20
$04:ADE0 .db $83,$75,$00,$60,$81,$11,$00,$60
$04:ADE8 .db $81,$75,$03,$60,$11,$A6,$A7,$81
$04:ADF0 .db $03,$00,$75,$81,$20,$01,$69,$00
$04:ADF8 .db $81,$43,$05,$44,$43,$44,$43,$44
$04:AE00 .db $00,$81,$69,$00,$20,$83,$75,$03
$04:AE08 .db $20,$3D,$A6,$A7,$81,$03,$06,$11
$04:AE10 .db $A6,$A9,$B7,$A6,$A7,$11,$81,$20
$04:AE18 .db $00,$69,$81,$20,$84,$69,$81,$20
$04:AE20 .db $81,$69,$01,$20,$11,$82,$75,$03
$04:AE28 .db $60,$11,$B6,$B7,$82,$71,$08,$B6
$04:AE30 .db $A8,$A7,$B6,$A8,$11,$50,$20,$69
$04:AE38 .db $81,$20,$84,$69,$81,$20,$81,$69
$04:AE40 .db $01,$50,$11,$81,$75,$01,$60,$11
$04:AE48 .db $84,$71,$07,$A6,$A7,$B6,$B7,$71
$04:AE50 .db $B6,$75,$11,$81,$43,$81,$20,$84
$04:AE58 .db $69,$81,$20,$81,$43,$00,$11,$82
$04:AE60 .db $75,$02,$60,$11,$58,$83,$71,$02
$04:AE68 .db $B6,$B7,$58,$82,$71,$82,$75,$02
$04:AE70 .db $11,$50,$20,$84,$69,$02,$20,$50
$04:AE78 .db $11,$84,$75,$0C,$20,$3D,$58,$A6
$04:AE80 .db $A7,$A6,$A7,$A6,$A7,$A6,$A7,$A6
$04:AE88 .db $A7,$83,$75,$00,$11,$86,$43,$00
$04:AE90 .db $11,$85,$75,$0C,$60,$11,$A6,$A9
$04:AE98 .db $B7,$B6,$B7,$B6,$B7,$B6,$B7,$B6
$04:AEA0 .db $B7,$92,$75,$04,$60,$11,$B6,$A8
$04:AEA8 .db $A7,$81,$71,$05,$A6,$A7,$A6,$A7
$04:AEB0 .db $A6,$A7,$8D,$75,$11,$A6,$A7,$75
$04:AEB8 .db $A6,$A7,$20,$60,$11,$B6,$A8,$A7
$04:AEC0 .db $71,$B6,$B7,$B6,$B7,$B6,$B7,$8D
$04:AEC8 .db $75,$04,$B6,$B7,$A6,$A9,$B7,$81
$04:AED0 .db $20,$05,$60,$11,$B6,$B7,$11,$43
$04:AED8 .db $81,$11,$81,$43,$00,$11,$8C,$75
$04:AEE0 .db $05,$A6,$A7,$A6,$A9,$B7,$3F,$82
$04:AEE8 .db $20,$00,$60,$81,$43,$01,$60,$69
$04:AEF0 .db $81,$3D,$81,$69,$00,$3D,$89,$75
$04:AEF8 .db $08,$A6,$A7,$75,$B6,$B7,$B6,$B7
$04:AF00 .db $A6,$A7,$83,$20,$81,$69,$01,$20
$04:AF08 .db $69,$81,$60,$81,$69,$00,$60,$89
$04:AF10 .db $75,$01,$B6,$B7,$84,$75,$02,$B6
$04:AF18 .db $B7,$43,$82,$20,$81,$69,$01,$20
$04:AF20 .db $69,$81,$20,$81,$69,$00,$20,$86
$04:AF28 .db $75,$04,$10,$11,$71,$58,$6E,$82
$04:AF30 .db $6B,$83,$AD,$01,$8E,$99,$81,$98
$04:AF38 .db $00,$99,$81,$8F,$05,$99,$98,$89
$04:AF40 .db $58,$3D,$50,$86,$75,$03,$3D,$71
$04:AF48 .db $58,$71,$83,$68,$83,$AD,$01,$8E
$04:AF50 .db $89,$81,$98,$00,$89,$81,$AC,$05
$04:AF58 .db $89,$98,$99,$11,$00,$11,$86,$75
$04:AF60 .db $04,$4D,$58,$71,$58,$5D,$81,$68
$04:AF68 .db $00,$5D,$84,$89,$82,$98,$00,$99
$04:AF70 .db $81,$AC,$81,$99,$02,$11,$50,$20
$04:AF78 .db $87,$75,$03,$3D,$71,$00,$50,$81
$04:AF80 .db $43,$81,$71,$87,$99,$02,$71,$9B
$04:AF88 .db $8F,$81,$89,$02,$3D,$69,$20,$87
$04:AF90 .db $75,$01,$4D,$3D,$81,$50,$81,$20
$04:AF98 .db $02,$50,$71,$6E,$82,$6B,$83,$AD
$04:AFA0 .db $08,$AF,$AE,$89,$98,$99,$3D,$69
$04:AFA8 .db $20,$11,$86,$75,$03,$00,$11,$10
$04:AFB0 .db $11,$81,$43,$01,$50,$3D,$83,$68
$04:AFB8 .db $83,$AD,$0A,$8E,$89,$98,$99,$11
$04:AFC0 .db $00,$69,$50,$11,$A6,$A7,$84,$75
$04:AFC8 .db $03,$20,$50,$11,$10,$81,$3F,$02
$04:AFD0 .db $11,$3D,$5D,$81,$68,$01,$5D,$58
$04:AFD8 .db $82,$89,$00,$98,$81,$99,$07,$71
$04:AFE0 .db $3A,$20,$50,$11,$75,$B6,$B7,$84
$04:AFE8 .db $75,$04,$20,$69,$50,$11,$03,$81
$04:AFF0 .db $10,$01,$58,$71,$81,$AC,$01,$58
$04:AFF8 .db $89,$82,$98,$00,$99,$81,$71,$03
$04:B000 .db $11,$2A,$20,$11,$81,$75,$81,$3F
$04:B008 .db $01,$A6,$A7,$81,$75,$01,$11,$20
$04:B010 .db $81,$69,$00,$50,$82,$11,$01,$71
$04:B018 .db $58,$81,$AC,$00,$71,$83,$99,$03
$04:B020 .db $71,$11,$42,$41,$81,$20,$00,$11
$04:B028 .db $81,$75,$81,$3F,$01,$B6,$B7,$81
$04:B030 .db $75,$01,$11,$50,$82,$69,$01,$41
$04:B038 .db $42,$89,$43,$06,$42,$41,$69,$20
$04:B040 .db $69,$50,$11,$81,$75,$81,$3F,$01
$04:B048 .db $A6,$A7,$82,$75,$01,$11,$50,$83
$04:B050 .db $69,$00,$20,$87,$69,$00,$20,$82
$04:B058 .db $69,$02,$20,$2A,$11,$82,$75,$81
$04:B060 .db $3F,$01,$B6,$B7,$83,$75,$00,$60
$04:B068 .db $83,$43,$02,$50,$69,$50,$81,$43
$04:B070 .db $00,$50,$83,$69,$00,$20,$81,$69
$04:B078 .db $01,$20,$3A,$83,$75,$02,$3F,$A6
$04:B080 .db $A7,$84,$75,$00,$3D,$82,$71,$03
$04:B088 .db $AD,$DA,$69,$DA,$81,$8A,$00,$3D
$04:B090 .db $82,$69,$00,$20,$82,$69,$01,$50
$04:B098 .db $11,$83,$75,$02,$A7,$B6,$B7,$84
$04:B0A0 .db $75,$01,$3D,$58,$81,$71,$03,$AD
$04:B0A8 .db $DA,$69,$DA,$81,$8A,$00,$3D,$81
$04:B0B0 .db $69,$07,$50,$43,$50,$41,$42,$10
$04:B0B8 .db $03,$10,$82,$75,$00,$B7,$81,$75
$04:B0C0 .db $02,$60,$03,$60,$81,$75,$07,$60
$04:B0C8 .db $11,$A6,$A7,$58,$3D,$43,$00,$81
$04:B0D0 .db $43,$00,$00,$81,$43,$07,$00,$43
$04:B0D8 .db $00,$11,$75,$00,$43,$00,$85,$75
$04:B0E0 .db $0B,$3D,$71,$11,$03,$60,$20,$3D
$04:B0E8 .db $B6,$B7,$11,$60,$75,$83,$20,$81
$04:B0F0 .db $75,$82,$20,$81,$75,$02,$20,$69
$04:B0F8 .db $20,$85,$75,$0B,$3D,$A6,$A7,$A6
$04:B100 .db $A7,$43,$11,$A6,$A7,$3D,$20,$75
$04:B108 .db $83,$20,$81,$75,$82,$20,$81,$75
$04:B110 .db $02,$20,$69,$20,$82,$75,$00,$60
$04:B118 .db $81,$03,$0B,$A6,$A9,$A8,$A9,$B7
$04:B120 .db $71,$58,$B6,$B7,$3D,$20,$11,$83
$04:B128 .db $20,$01,$11,$75,$82,$20,$05,$75
$04:B130 .db $11,$20,$69,$20,$11,$81,$75,$0F
$04:B138 .db $3D,$A6,$A7,$B6,$B7,$B6,$A8,$A7
$04:B140 .db $A6,$A7,$A6,$A7,$3D,$20,$11,$50
$04:B148 .db $81,$20,$00,$50,$81,$11,$82,$20
$04:B150 .db $81,$11,$03,$50,$69,$50,$11,$81
$04:B158 .db $75,$0F,$11,$B6,$B7,$A6,$A7,$71
$04:B160 .db $B6,$A8,$A9,$B7,$B6,$B7,$11,$60
$04:B168 .db $75,$11,$81,$43,$0A,$11,$75,$11
$04:B170 .db $50,$20,$50,$11,$75,$11,$43,$11
$04:B178 .db $82,$75,$0D,$58,$A6,$A7,$B6,$A8
$04:B180 .db $A7,$A6,$A9,$A8,$A7,$A6,$A7,$71
$04:B188 .db $11,$81,$03,$00,$60,$83,$75,$02
$04:B190 .db $11,$43,$11,$87,$75,$11,$A7,$B6
$04:B198 .db $B7,$71,$B6,$B7,$B6,$B7,$B6,$A8
$04:B1A0 .db $A9,$A8,$A7,$71,$A6,$A7,$11,$60
$04:B1A8 .db $8D,$75,$13,$A8,$A7,$A6,$A7,$A6
$04:B1B0 .db $A7,$A6,$A7,$A6,$A9,$B7,$B6,$A8
$04:B1B8 .db $A7,$B6,$A8,$A7,$11,$03,$60,$8B
$04:B1C0 .db $75,$13,$B6,$B7,$B6,$B7,$B6,$B7
$04:B1C8 .db $B6,$B7,$B6,$B7,$A6,$A7,$B6,$B7
$04:B1D0 .db $71,$B6,$A8,$A7,$11,$60,$81,$75
$04:B1D8 .db $01,$A6,$A7,$87,$75,$17,$A6,$A7
$04:B1E0 .db $A6,$A7,$A6,$A7,$A6,$A7,$A6,$A7
$04:B1E8 .db $B6,$B7,$A6,$A7,$71,$A6,$A9,$B7
$04:B1F0 .db $3D,$20,$75,$A6,$A9,$B7,$87,$75
$04:B1F8 .db $16,$B6,$A8,$A9,$B7,$B6,$B7,$B6
$04:B200 .db $B7,$B6,$A8,$A7,$A6,$A9,$A8,$A7
$04:B208 .db $B6,$A8,$A7,$11,$60,$75,$B6,$B7
$04:B210 .db $88,$75,$13,$A6,$A9,$B7,$A6,$A7
$04:B218 .db $A6,$A7,$A6,$A7,$B6,$B7,$B6,$B7
$04:B220 .db $B6,$B7,$A6,$A9,$B7,$11,$60,$8B
$04:B228 .db $75,$09,$B6,$B7,$A6,$A9,$A8,$A9
$04:B230 .db $A8,$A9,$B7,$11,$83,$43,$07,$11
$04:B238 .db $B6,$B7,$11,$60,$20,$A6,$A7,$82
$04:B240 .db $75,$01,$A6,$A7,$84,$75,$09,$A6
$04:B248 .db $A7,$B6,$B7,$B6,$B7,$B6,$B7,$58
$04:B250 .db $3D,$83,$69,$00,$60,$81,$11,$00
$04:B258 .db $60,$81,$20,$06,$B6,$A8,$A7,$A6
$04:B260 .db $A7,$B6,$B7,$84,$75,$01,$B6,$B7
$04:B268 .db $81,$43,$81,$11,$03,$43,$11,$71
$04:B270 .db $3D,$83,$69,$00,$20,$81,$60,$82
$04:B278 .db $20,$04,$3F,$B6,$A8,$A9,$B7,$86
$04:B280 .db $75,$01,$43,$60,$81,$69,$81,$60
$04:B288 .db $03,$69,$3D,$58,$3D,$83,$69,$85
$04:B290 .db $20,$03,$A6,$A7,$B6,$B7,$87,$75
$04:B298 .db $01,$69,$20,$81,$69,$81,$20,$03
$04:B2A0 .db $69,$60,$43,$60,$83,$69,$84,$20
$04:B2A8 .db $02,$43,$B6,$B7,$89,$75,$83,$75
$04:B2B0 .db $03,$20,$69,$20,$B8,$81,$B9,$06
$04:B2B8 .db $B8,$20,$69,$20,$75,$54,$55,$8C
$04:B2C0 .db $75,$81,$4F,$83,$75,$03,$20,$69
$04:B2C8 .db $20,$B8,$81,$B9,$06,$B8,$20,$69
$04:B2D0 .db $20,$04,$9E,$9F,$82,$03,$04,$05
$04:B2D8 .db $06,$07,$54,$55,$84,$75,$81,$4F
$04:B2E0 .db $81,$75,$05,$54,$55,$20,$69,$20
$04:B2E8 .db $B8,$81,$B9,$07,$B8,$20,$69,$20
$04:B2F0 .db $71,$9E,$9F,$71,$81,$AC,$04,$71
$04:B2F8 .db $56,$57,$9E,$9F,$84,$75,$81,$4F
$04:B300 .db $81,$75,$05,$9E,$9F,$20,$C6,$C7
$04:B308 .db $C8,$81,$C9,$07,$C8,$C7,$C6,$20
$04:B310 .db $71,$9E,$9F,$71,$81,$AC,$04,$71
$04:B318 .db $64,$65,$9E,$9F,$84,$75,$81,$4F
$04:B320 .db $81,$75,$05,$9E,$9F,$20,$D6,$D7
$04:B328 .db $AA,$81,$AB,$07,$AA,$D7,$D6,$20
$04:B330 .db $11,$9E,$67,$57,$81,$AC,$82,$71
$04:B338 .db $02,$64,$67,$55,$83,$75,$81,$4F
$04:B340 .db $07,$75,$0A,$9E,$9F,$50,$E6,$E7
$04:B348 .db $AA,$81,$AB,$07,$AA,$E7,$E6,$50
$04:B350 .db $11,$64,$9E,$9F,$81,$71,$81,$BC
$04:B358 .db $04,$AE,$71,$64,$65,$0A,$82,$75
$04:B360 .db $81,$4F,$07,$75,$1A,$64,$65,$11
$04:B368 .db $50,$F7,$F8,$81,$F9,$10,$F8,$F7
$04:B370 .db $50,$11,$71,$56,$66,$9F,$71,$53
$04:B378 .db $52,$71,$9B,$8F,$52,$53,$1A,$82
$04:B380 .db $75,$81,$4F,$02,$75,$00,$11,$81
$04:B388 .db $71,$02,$11,$20,$B8,$81,$B9,$0B
$04:B390 .db $B8,$20,$11,$56,$57,$9E,$9F,$67
$04:B398 .db $57,$63,$51,$52,$81,$AC,$02,$62
$04:B3A0 .db $63,$3D,$82,$75,$81,$4F,$07,$75
$04:B3A8 .db $20,$3D,$56,$57,$11,$20,$B8,$81
$04:B3B0 .db $B9,$0B,$B8,$20,$11,$9E,$67,$66
$04:B3B8 .db $9F,$9E,$9F,$3C,$63,$62,$81,$8A
$04:B3C0 .db $02,$71,$11,$00,$82,$75,$81,$4F
$04:B3C8 .db $07,$75,$20,$3D,$64,$65,$11,$50
$04:B3D0 .db $B8,$81,$B9,$02,$B8,$50,$11,$81
$04:B3D8 .db $9E,$06,$9F,$67,$66,$9F,$58,$52
$04:B3E0 .db $53,$81,$8A,$02,$11,$50,$20,$82
$04:B3E8 .db $75,$81,$4F,$07,$11,$20,$3D,$71
$04:B3F0 .db $BF,$71,$11,$43,$81,$AC,$0B,$43
$04:B3F8 .db $56,$57,$64,$9E,$9F,$9E,$9F,$65
$04:B400 .db $58,$62,$63,$81,$AC,$02,$11,$50
$04:B408 .db $20,$82,$75,$81,$4F,$11,$11,$50
$04:B410 .db $3D,$BD,$BA,$BD,$BF,$71,$9B,$8F
$04:B418 .db $58,$64,$65,$71,$64,$65,$9E,$9F
$04:B420 .db $81,$58,$07,$3C,$58,$9B,$8F,$58
$04:B428 .db $3D,$20,$11,$81,$75,$81,$4F,$08
$04:B430 .db $75,$11,$3D,$BF,$BD,$BF,$71,$8F
$04:B438 .db $9B,$81,$58,$84,$2C,$01,$9E,$9F
$04:B440 .db $81,$8A,$07,$AD,$AF,$AE,$58,$3C
$04:B448 .db $3D,$50,$11,$81,$75,$81,$4F,$81
$04:B450 .db $75,$09,$4D,$BA,$BF,$BD,$71,$9B
$04:B458 .db $8F,$58,$71,$2C,$82,$71,$02,$2C
$04:B460 .db $9E,$9F,$81,$8A,$06,$AD,$8E,$58
$04:B468 .db $3C,$58,$4D,$11,$82,$75,$81,$43
$04:B470 .db $81,$75,$08,$40,$42,$43,$11,$8F
$04:B478 .db $9B,$56,$57,$2C,$83,$71,$02,$2C
$04:B480 .db $9E,$9F,$81,$AC,$81,$58,$03,$43
$04:B488 .db $44,$42,$40,$83,$75,$81,$69,$81
$04:B490 .db $75,$00,$20,$81,$69,$00,$3D,$81
$04:B498 .db $AC,$03,$64,$65,$6E,$5D,$81,$68
$04:B4A0 .db $03,$5D,$6E,$64,$65,$81,$AC,$01
$04:B4A8 .db $3C,$3D,$82,$69,$00,$20,$83,$75
$04:B4B0 .db $81,$69,$81,$75,$00,$20,$81,$69
$04:B4B8 .db $00,$3D,$81,$5D,$00,$6B,$81,$6D
$04:B4C0 .db $83,$6B,$81,$6D,$00,$6B,$81,$5D
$04:B4C8 .db $01,$58,$3D,$82,$69,$00,$20,$83
$04:B4D0 .db $75,$81,$69,$02,$75,$11,$20,$81
$04:B4D8 .db $69,$00,$3D,$81,$5D,$01,$6B,$6E
$04:B4E0 .db $84,$2C,$02,$71,$6E,$6B,$81,$5D
$04:B4E8 .db $01,$71,$3D,$82,$69,$01,$20,$11
$04:B4F0 .db $82,$75,$81,$69,$09,$75,$11,$42
$04:B4F8 .db $41,$69,$00,$43,$44,$43,$44,$81
$04:B500 .db $43,$81,$44,$81,$43,$05,$44,$43
$04:B508 .db $44,$43,$44,$00,$81,$69,$02,$41
$04:B510 .db $42,$11,$82,$75,$81,$69,$82,$75
$04:B518 .db $01,$11,$43,$81,$20,$8C,$69,$81
$04:B520 .db $20,$81,$43,$00,$11,$84,$75,$81
$04:B528 .db $69,$84,$75,$81,$20,$8C,$69,$81
$04:B530 .db $20,$87,$75,$82,$69,$81,$20,$00
$04:B538 .db $3D,$85,$71,$04,$3D,$69,$20,$69
$04:B540 .db $20,$84,$69,$02,$20,$69,$20,$81
$04:B548 .db $69,$81,$20,$82,$69,$81,$71,$81
$04:B550 .db $20,$01,$69,$3D,$85,$71,$02,$3D
$04:B558 .db $69,$20,$81,$69,$00,$00,$83,$43
$04:B560 .db $02,$46,$47,$48,$81,$20,$81,$69
$04:B568 .db $00,$20,$81,$69,$81,$71,$81,$20
$04:B570 .db $02,$2A,$00,$11,$83,$71,$06,$11
$04:B578 .db $00,$2A,$69,$20,$2A,$11,$85,$71
$04:B580 .db $02,$11,$42,$41,$81,$20,$82,$69
$04:B588 .db $81,$71,$81,$20,$03,$3A,$20,$40
$04:B590 .db $42,$81,$43,$07,$42,$40,$20,$3A
$04:B598 .db $20,$69,$3A,$71,$81,$8A,$83,$AD
$04:B5A0 .db $04,$8E,$71,$11,$50,$20,$82,$69
$04:B5A8 .db $81,$71,$02,$69,$00,$11,$82,$20
$04:B5B0 .db $81,$69,$82,$20,$04,$3D,$20,$69
$04:B5B8 .db $3D,$71,$81,$8A,$83,$AD,$81,$AF
$04:B5C0 .db $03,$8E,$11,$50,$20,$81,$69,$81
$04:B5C8 .db $71,$00,$43,$81,$11,$00,$50,$81
$04:B5D0 .db $20,$81,$69,$81,$20,$01,$50,$3D
$04:B5D8 .db $81,$43,$00,$3D,$87,$71,$04,$8E
$04:B5E0 .db $8A,$8F,$11,$0F,$81,$69,$81,$71
$04:B5E8 .db $05,$A6,$A7,$3C,$11,$42,$40,$81
$04:B5F0 .db $69,$03,$40,$42,$11,$00,$81,$71
$04:B5F8 .db $01,$40,$42,$83,$43,$00,$11,$82
$04:B600 .db $71,$81,$AC,$01,$71,$1F,$81,$69
$04:B608 .db $81,$71,$05,$B6,$B7,$A6,$A7,$3C
$04:B610 .db $11,$81,$43,$81,$11,$04,$00,$20
$04:B618 .db $71,$11,$20,$84,$69,$03,$40,$42
$04:B620 .db $11,$71,$81,$8A,$01,$71,$2F,$81
$04:B628 .db $69,$81,$71,$04,$A6,$A7,$B6,$B7
$04:B630 .db $11,$82,$43,$01,$42,$40,$81,$20
$04:B638 .db $02,$11,$50,$20,$83,$69,$04,$20
$04:B640 .db $69,$20,$50,$11,$81,$8A,$01,$71
$04:B648 .db $11,$83,$71,$04,$B6,$B7,$3C,$11
$04:B650 .db $00,$83,$69,$82,$20,$02,$3D,$50
$04:B658 .db $20,$84,$69,$03,$20,$69,$20,$3D
$04:B660 .db $81,$AC,$85,$71,$81,$3C,$02,$11
$04:B668 .db $50,$20,$84,$69,$05,$20,$00,$3D
$04:B670 .db $11,$42,$41,$82,$69,$04,$20,$69
$04:B678 .db $20,$69,$3D,$81,$AC,$85,$71,$03
$04:B680 .db $4F,$3C,$4F,$3C,$81,$4F,$00,$3D
$04:B688 .db $96,$3F,$81,$75,$83,$4F,$81,$3C
$04:B690 .db $01,$11,$0A,$95,$3F,$81,$75,$81
$04:B698 .db $8A,$81,$AD,$81,$4F,$01,$3C,$1A
$04:B6A0 .db $95,$3F,$81,$75,$81,$8A,$81,$AD
$04:B6A8 .db $03,$4F,$3C,$4F,$3D,$8E,$3F,$00
$04:B6B0 .db $0A,$81,$03,$01,$02,$01,$81,$3F
$04:B6B8 .db $81,$75,$81,$AC,$81,$4F,$03,$11
$04:B6C0 .db $43,$42,$40,$8E,$3F,$00,$1A,$81
$04:B6C8 .db $4F,$01,$3C,$11,$81,$23,$81,$75
$04:B6D0 .db $81,$AC,$81,$4F,$00,$3A,$82,$20
$04:B6D8 .db $8E,$43,$04,$3D,$4F,$3C,$4F,$3C
$04:B6E0 .db $81,$4F,$81,$75,$82,$4F,$01,$11
$04:B6E8 .db $2A,$82,$20,$00,$4F,$81,$3C,$01
$04:B6F0 .db $4F,$3C,$87,$4F,$81,$3C,$03,$00
$04:B6F8 .db $11,$4F,$3C,$82,$4F,$81,$75,$81
$04:B700 .db $4F,$01,$11,$50,$81,$20,$06,$69
$04:B708 .db $20,$3C,$4F,$3C,$4F,$3C,$88,$4F
$04:B710 .db $04,$3C,$20,$40,$42,$11,$82,$4F
$04:B718 .db $81,$75,$81,$4F,$01,$3D,$69,$81
$04:B720 .db $20,$05,$69,$20,$4F,$3C,$4F,$3C
$04:B728 .db $81,$4F,$81,$AC,$01,$4F,$3C,$81
$04:B730 .db $4F,$02,$3C,$11,$43,$81,$20,$01
$04:B738 .db $69,$50,$82,$43,$81,$75,$81,$4F
$04:B740 .db $01,$3D,$69,$81,$20,$03,$69,$20
$04:B748 .db $3C,$4F,$81,$3C,$01,$4F,$3C,$81
$04:B750 .db $AC,$00,$3C,$82,$4F,$02,$11,$50
$04:B758 .db $69,$81,$20,$84,$69,$81,$75,$03
$04:B760 .db $4F,$3C,$11,$50,$81,$20,$01,$69
$04:B768 .db $20,$81,$8A,$83,$AD,$81,$5D,$01
$04:B770 .db $4F,$3C,$81,$5D,$02,$3D,$50,$43
$04:B778 .db $81,$20,$84,$69,$81,$75,$03,$3C
$04:B780 .db $4F,$3C,$3D,$81,$20,$01,$69,$20
$04:B788 .db $81,$8A,$83,$AD,$81,$68,$01,$3C
$04:B790 .db $4F,$81,$68,$00,$3D,$81,$11,$01
$04:B798 .db $50,$20,$84,$69,$81,$75,$07,$4F
$04:B7A0 .db $3C,$11,$00,$69,$20,$40,$42,$81
$04:B7A8 .db $AC,$03,$3C,$4F,$3C,$4F,$81,$5D
$04:B7B0 .db $81,$3C,$81,$5D,$05,$11,$10,$3F
$04:B7B8 .db $10,$42,$41,$83,$69,$81,$75,$81
$04:B7C0 .db $43,$05,$50,$20,$2A,$43,$11,$3C
$04:B7C8 .db $81,$AC,$00,$4F,$84,$3C,$00,$4F
$04:B7D0 .db $83,$3C,$05,$11,$03,$11,$3C,$4F
$04:B7D8 .db $50,$82,$69,$81,$75,$81,$69,$81
$04:B7E0 .db $20,$00,$3A,$82,$3C,$81,$8A,$83
$04:B7E8 .db $AD,$81,$5D,$81,$AD,$81,$8A,$81
$04:B7F0 .db $AD,$81,$8A,$81,$AD,$00,$8E,$82
$04:B7F8 .db $43,$81,$75,$07,$69,$20,$69,$20
$04:B800 .db $43,$11,$3C,$4F,$81,$8A,$83,$AD
$04:B808 .db $81,$68,$81,$AD,$81,$8A,$81,$AD
$04:B810 .db $81,$8A,$81,$AD,$81,$AF,$01,$8E
$04:B818 .db $4F,$81,$75,$07,$69,$20,$69,$20
$04:B820 .db $69,$50,$11,$3C,$82,$4F,$00,$3C
$04:B828 .db $81,$4F,$81,$5D,$00,$3C,$83,$4F
$04:B830 .db $00,$3C,$81,$4F,$81,$3C,$03,$4F
$04:B838 .db $8E,$AF,$4F,$81,$75,$81,$69,$81
$04:B840 .db $20,$00,$43,$81,$50,$01,$43,$11
$04:B848 .db $81,$60,$82,$3C,$03,$4F,$3C,$4F
$04:B850 .db $3C,$81,$60,$81,$3C,$81,$60,$00
$04:B858 .db $3C,$81,$60,$82,$3C,$81,$75,$08
$04:B860 .db $69,$20,$69,$20,$3F,$11,$50,$69
$04:B868 .db $60,$81,$11,$00,$60,$81,$3C,$00
$04:B870 .db $60,$82,$23,$81,$11,$81,$23,$81
$04:B878 .db $11,$02,$23,$11,$3D,$82,$3C,$81
$04:B880 .db $75,$81,$69,$81,$20,$04,$11,$3F
$04:B888 .db $11,$60,$11,$81,$4F,$00,$11,$81
$04:B890 .db $23,$00,$11,$8A,$4F,$00,$11,$82
$04:B898 .db $23,$81,$75,$07,$69,$20,$69,$50
$04:B8A0 .db $11,$3F,$60,$11,$95,$4F,$81,$75
$04:B8A8 .db $9D,$71,$81,$69,$9D,$71,$81,$69
$04:B8B0 .db $9D,$71,$81,$69,$9D,$71,$81,$69
$04:B8B8 .db $9D,$71,$81,$69,$82,$71,$00,$7C
$04:B8C0 .db $81,$71,$81,$7C,$81,$71,$82,$7C
$04:B8C8 .db $81,$71,$00,$7C,$81,$71,$00,$7C
$04:B8D0 .db $81,$71,$00,$7C,$81,$71,$00,$7C
$04:B8D8 .db $84,$71,$81,$43,$81,$71,$08,$7C
$04:B8E0 .db $71,$7C,$71,$7C,$71,$7C,$71,$7C
$04:B8E8 .db $82,$71,$0A,$7C,$71,$7C,$71,$7C
$04:B8F0 .db $71,$7C,$71,$7C,$71,$7C,$88,$71
$04:B8F8 .db $00,$7C,$82,$71,$04,$7C,$71,$7C
$04:B900 .db $71,$7C,$82,$71,$00,$7C,$82,$71
$04:B908 .db $06,$7C,$71,$7C,$71,$7C,$71,$7C
$04:B910 .db $89,$71,$00,$7C,$81,$71,$03,$7C
$04:B918 .db $71,$7C,$71,$82,$7C,$01,$71,$7C
$04:B920 .db $82,$71,$01,$7C,$71,$82,$7C,$01
$04:B928 .db $71,$7C,$8A,$71,$01,$7C,$71,$81
$04:B930 .db $7C,$81,$71,$00,$7C,$82,$71,$00
$04:B938 .db $7C,$82,$71,$06,$7C,$71,$7C,$71
$04:B940 .db $7C,$71,$7C,$88,$71,$04,$7C,$71
$04:B948 .db $7C,$71,$7C,$82,$71,$00,$7C,$82
$04:B950 .db $71,$0A,$7C,$71,$7C,$71,$7C,$71
$04:B958 .db $7C,$71,$7C,$71,$7C,$86,$71,$81
$04:B960 .db $43,$02,$00,$69,$20,$83,$69,$06
$04:B968 .db $20,$50,$11,$71,$02,$01,$11,$83
$04:B970 .db $43,$03,$42,$41,$20,$3D,$81,$8A
$04:B978 .db $85,$71,$82,$69,$81,$20,$82,$69
$04:B980 .db $06,$41,$42,$A6,$A7,$A6,$A7,$3D
$04:B988 .db $85,$3F,$02,$11,$50,$3D,$81,$8A
$04:B990 .db $85,$71,$81,$43,$02,$60,$20,$50
$04:B998 .db $82,$43,$07,$11,$A6,$A9,$B7,$B6
$04:B9A0 .db $B7,$00,$11,$85,$3F,$01,$60,$11
$04:B9A8 .db $81,$AC,$87,$71,$04,$11,$60,$11
$04:B9B0 .db $A6,$A7,$81,$71,$01,$B6,$B7,$81
$04:B9B8 .db $71,$02,$3D,$50,$11,$85,$3F,$01
$04:B9C0 .db $3D,$71,$81,$AC,$88,$71,$06,$11
$04:B9C8 .db $60,$B6,$B7,$A6,$A7,$71,$81,$8A
$04:B9D0 .db $02,$AD,$3D,$11,$85,$3F,$02,$10
$04:B9D8 .db $3D,$71,$81,$AC,$89,$71,$05,$11
$04:B9E0 .db $60,$71,$B6,$B7,$71,$81,$8A,$01
$04:B9E8 .db $AD,$3D,$84,$3F,$04,$10,$03,$11
$04:B9F0 .db $3D,$5D,$81,$68,$00,$5D,$86,$71
$04:B9F8 .db $00,$3C,$81,$71,$01,$3D,$71,$81
$04:BA00 .db $60,$00,$71,$81,$AC,$02,$71,$11
$04:BA08 .db $10,$83,$3F,$00,$3D,$81,$71,$01
$04:BA10 .db $3D,$5D,$81,$68,$00,$5D,$85,$71
$04:BA18 .db $05,$3C,$71,$3C,$71,$11,$43,$81
$04:BA20 .db $11,$00,$60,$81,$AC,$00,$71,$81
$04:BA28 .db $60,$00,$10,$81,$3F,$00,$60,$82
$04:BA30 .db $43,$03,$11,$71,$9B,$8F,$87,$71
$04:BA38 .db $00,$3C,$85,$71,$00,$11,$82,$43
$04:BA40 .db $81,$11,$00,$43,$81,$03,$00,$11
$04:BA48 .db $81,$71,$81,$AD,$01,$AF,$AE,$9B
$04:BA50 .db $71,$81,$AD,$00,$8E,$87,$71,$00
$04:BA58 .db $87,$81,$88,$00,$97,$81,$86,$81
$04:BA60 .db $85,$81,$86,$02,$85,$71,$85,$81
$04:BA68 .db $86,$00,$85,$81,$89,$00,$87,$81
$04:BA70 .db $88,$01,$87,$85,$81,$86,$00,$85
$04:BA78 .db $81,$89,$81,$71,$81,$BB,$03,$58
$04:BA80 .db $71,$58,$95,$81,$96,$81,$95,$81
$04:BA88 .db $96,$02,$95,$71,$95,$81,$96,$00
$04:BA90 .db $95,$81,$99,$00,$85,$81,$86,$01
$04:BA98 .db $85,$95,$81,$96,$00,$95,$81,$99
$04:BAA0 .db $81,$71,$81,$BB,$00,$85,$81,$86
$04:BAA8 .db $00,$97,$81,$88,$81,$87,$81,$88
$04:BAB0 .db $02,$87,$58,$87,$81,$88,$00,$87
$04:BAB8 .db $81,$89,$00,$95,$81,$96,$01,$95
$04:BAC0 .db $87,$81,$88,$00,$97,$81,$86,$01
$04:BAC8 .db $85,$71,$81,$BB,$00,$95,$81,$96
$04:BAD0 .db $01,$95,$58,$81,$71,$00,$58,$81
$04:BAD8 .db $89,$85,$71,$81,$99,$00,$87,$81
$04:BAE0 .db $88,$04,$87,$71,$58,$71,$95,$81
$04:BAE8 .db $96,$01,$95,$71,$81,$BB,$00,$87
$04:BAF0 .db $81,$88,$01,$87,$85,$81,$86,$00
$04:BAF8 .db $85,$81,$99,$81,$71,$83,$89,$81
$04:BB00 .db $5D,$81,$89,$81,$71,$00,$85,$81
$04:BB08 .db $86,$00,$97,$81,$88,$01,$97,$71
$04:BB10 .db $81,$BB,$00,$85,$81,$86,$01,$85
$04:BB18 .db $95,$81,$96,$00,$95,$83,$71,$83
$04:BB20 .db $99,$81,$5D,$81,$99,$81,$89,$00
$04:BB28 .db $95,$81,$96,$00,$95,$81,$58,$81
$04:BB30 .db $71,$81,$BB,$00,$95,$81,$96,$01
$04:BB38 .db $95,$87,$81,$88,$00,$87,$81,$71
$04:BB40 .db $83,$89,$02,$58,$71,$58,$82,$71
$04:BB48 .db $81,$99,$00,$87,$81,$88,$01,$87
$04:BB50 .db $85,$81,$86,$00,$71,$81,$BB,$00
$04:BB58 .db $87,$81,$88,$01,$87,$85,$81,$86
$04:BB60 .db $00,$85,$81,$71,$83,$99,$00,$85
$04:BB68 .db $81,$86,$00,$85,$83,$89,$00,$85
$04:BB70 .db $81,$86,$01,$85,$95,$81,$96,$00
$04:BB78 .db $71,$81,$BB,$00,$85,$81,$86,$01
$04:BB80 .db $85,$95,$81,$96,$00,$95,$81,$71
$04:BB88 .db $83,$89,$00,$95,$81,$96,$00,$95
$04:BB90 .db $83,$99,$00,$95,$81,$96,$01,$95
$04:BB98 .db $87,$81,$88,$00,$71,$81,$BB,$00
$04:BBA0 .db $95,$81,$96,$01,$95,$87,$81,$88
$04:BBA8 .db $00,$87,$81,$71,$83,$99,$00,$87
$04:BBB0 .db $81,$88,$01,$87,$58,$82,$71,$00
$04:BBB8 .db $87,$81,$88,$00,$87,$83,$71,$81
$04:BBC0 .db $BB,$00,$87,$81,$88,$00,$97,$81
$04:BBC8 .db $86,$01,$85,$71,$81,$89,$81,$71
$04:BBD0 .db $83,$89,$00,$71,$81,$89,$00,$71
$04:BBD8 .db $81,$2B,$85,$89,$81,$71,$81,$BB
$04:BBE0 .db $00,$71,$81,$58,$00,$95,$81,$96
$04:BBE8 .db $01,$95,$71,$81,$99,$81,$71,$83
$04:BBF0 .db $99,$00,$58,$81,$99,$00,$58,$81
$04:BBF8 .db $2B,$85,$99,$81,$71,$81,$E8,$00
$04:BC00 .db $85,$81,$86,$00,$97,$81,$88,$00
$04:BC08 .db $87,$82,$71,$81,$89,$82,$71,$81
$04:BC10 .db $89,$00,$71,$81,$89,$81,$71,$81
$04:BC18 .db $89,$00,$85,$81,$86,$00,$85,$81
$04:BC20 .db $71,$81,$3F,$00,$95,$81,$96,$00
$04:BC28 .db $95,$81,$89,$83,$71,$81,$99,$00
$04:BC30 .db $71,$81,$89,$81,$99,$00,$71,$81
$04:BC38 .db $99,$81,$71,$81,$99,$00,$95,$81
$04:BC40 .db $96,$00,$95,$81,$71,$81,$3F,$00
$04:BC48 .db $87,$81,$88,$00,$87,$81,$99,$83
$04:BC50 .db $89,$02,$58,$71,$58,$81,$99,$00
$04:BC58 .db $71,$81,$89,$00,$71,$81,$89,$00
$04:BC60 .db $85,$81,$86,$00,$97,$81,$88,$00
$04:BC68 .db $87,$81,$71,$81,$D8,$81,$89,$00
$04:BC70 .db $85,$81,$86,$00,$85,$83,$99,$00
$04:BC78 .db $85,$81,$86,$00,$85,$81,$71,$81
$04:BC80 .db $99,$00,$71,$81,$99,$00,$95,$81
$04:BC88 .db $96,$01,$95,$71,$81,$89,$81,$71
$04:BC90 .db $81,$3F,$81,$99,$00,$95,$81,$96
$04:BC98 .db $00,$95,$83,$89,$00,$95,$81,$96
$04:BCA0 .db $00,$95,$83,$89,$00,$85,$81,$86
$04:BCA8 .db $00,$97,$81,$88,$01,$87,$58,$81
$04:BCB0 .db $99,$81,$71,$81,$3F,$81,$71,$00
$04:BCB8 .db $87,$81,$88,$00,$87,$83,$99,$00
$04:BCC0 .db $87,$81,$88,$00,$87,$83,$99,$00
$04:BCC8 .db $95,$81,$96,$00,$95,$81,$89,$00
$04:BCD0 .db $85,$81,$86,$00,$85,$81,$71,$81
$04:BCD8 .db $3F,$00,$71,$81,$89,$01,$71,$58
$04:BCE0 .db $83,$89,$00,$71,$81,$89,$00,$85
$04:BCE8 .db $81,$86,$00,$85,$81,$58,$00,$87
$04:BCF0 .db $81,$88,$00,$87,$81,$99,$00,$95
$04:BCF8 .db $81,$96,$00,$95,$81,$71,$81,$D9
$04:BD00 .db $00,$71,$81,$99,$01,$58,$71,$83
$04:BD08 .db $99,$00,$58,$81,$99,$00,$95,$81
$04:BD10 .db $96,$00,$95,$81,$89,$00,$85,$81
$04:BD18 .db $86,$00,$85,$81,$89,$00,$87,$81
$04:BD20 .db $88,$00,$87,$81,$71,$81,$D8,$01
$04:BD28 .db $71,$85,$81,$86,$03,$85,$71,$58
$04:BD30 .db $85,$81,$86,$02,$85,$71,$87,$81
$04:BD38 .db $88,$00,$87,$81,$99,$00,$95,$81
$04:BD40 .db $96,$00,$95,$81,$99,$85,$71,$81
$04:BD48 .db $3F,$83,$75,$03,$20,$69,$20,$B8
$04:BD50 .db $81,$B9,$03,$B8,$20,$69,$20,$8F
$04:BD58 .db $75,$81,$4F,$82,$71,$00,$7C,$81
$04:BD60 .db $71,$00,$7C,$82,$71,$82,$7C,$81
$04:BD68 .db $71,$00,$7C,$81,$71,$05,$7C,$71
$04:BD70 .db $7C,$71,$7C,$71,$82,$7C,$82,$71
$04:BD78 .db $81,$43,$9D,$71,$81,$69,$85,$71
$04:BD80 .db $81,$7B,$83,$71,$81,$7B,$83,$71
$04:BD88 .db $81,$7B,$83,$71,$81,$7B,$83,$71
$04:BD90 .db $81,$43,$85,$71,$81,$7B,$83,$71
$04:BD98 .db $81,$7B,$83,$71,$81,$7B,$83,$71
$04:BDA0 .db $81,$7B,$C7,$71,$81,$5D,$81,$6B
$04:BDA8 .db $81,$5D,$83,$71,$81,$7B,$83,$71
$04:BDB0 .db $81,$7B,$83,$71,$81,$7B,$87,$71
$04:BDB8 .db $81,$5D,$81,$6B,$81,$5D,$83,$71
$04:BDC0 .db $81,$7B,$83,$71,$81,$7B,$83,$71
$04:BDC8 .db $81,$7B,$C5,$71,$83,$BB,$00,$7C
$04:BDD0 .db $88,$BB,$81,$10,$81,$BB,$81,$7B
$04:BDD8 .db $89,$BB,$81,$71,$81,$BB,$01,$B0
$04:BDE0 .db $B1,$86,$BB,$02,$7C,$BB,$10,$81
$04:BDE8 .db $11,$01,$10,$BB,$81,$7B,$82,$BB
$04:BDF0 .db $00,$7C,$85,$BB,$81,$71,$03,$BB
$04:BDF8 .db $E0,$C0,$C1,$82,$BB,$81,$7B,$82
$04:BE00 .db $BB,$01,$10,$11,$81,$5D,$01,$11
$04:BE08 .db $10,$8B,$BB,$81,$71,$03,$BB,$E1
$04:BE10 .db $D0,$D1,$82,$BB,$81,$7B,$82,$BB
$04:BE18 .db $08,$3D,$4F,$5D,$68,$4F,$11,$10
$04:BE20 .db $BB,$7C,$83,$BB,$81,$7B,$82,$BB
$04:BE28 .db $81,$71,$8A,$BB,$00,$10,$82,$4F
$04:BE30 .db $81,$6C,$01,$4F,$3D,$85,$BB,$81
$04:BE38 .db $7B,$82,$BB,$81,$71,$82,$BB,$00
$04:BE40 .db $10,$86,$03,$84,$4F,$81,$6C,$04
$04:BE48 .db $11,$03,$04,$03,$04,$82,$03,$00
$04:BE50 .db $10,$82,$BB,$81,$71,$81,$7B,$01
$04:BE58 .db $BB,$3D,$81,$5D,$83,$6B,$81,$5D
$04:BE60 .db $84,$4F,$02,$6C,$68,$5D,$83,$4F
$04:BE68 .db $81,$5D,$00,$3D,$82,$BB,$81,$71
$04:BE70 .db $81,$7B,$01,$BB,$3D,$81,$5D,$83
$04:BE78 .db $6B,$81,$5D,$05,$4F,$12,$13,$14
$04:BE80 .db $15,$4F,$81,$5D,$83,$4F,$02,$68
$04:BE88 .db $5D,$3D,$82,$BB,$81,$71,$82,$BB
$04:BE90 .db $00,$00,$87,$4F,$05,$58,$31,$32
$04:BE98 .db $33,$34,$58,$84,$4F,$81,$6C,$01
$04:BEA0 .db $11,$00,$82,$BB,$81,$71,$04,$BB
$04:BEA8 .db $7C,$BB,$20,$50,$85,$4F,$07,$58
$04:BEB0 .db $4F,$35,$36,$37,$38,$4F,$58,$82
$04:BEB8 .db $4F,$81,$6C,$02,$11,$50,$20,$82
$04:BEC0 .db $BB,$81,$71,$82,$BB,$02,$20,$69
$04:BEC8 .db $00,$81,$4F,$81,$5D,$10,$4F,$58
$04:BED0 .db $4F,$35,$36,$37,$38,$4F,$58,$4F
$04:BED8 .db $5D,$68,$6C,$11,$00,$69,$20,$82
$04:BEE0 .db $BB,$81,$71,$02,$E8,$E9,$E8,$81
$04:BEE8 .db $20,$04,$69,$50,$4F,$68,$5D,$81
$04:BEF0 .db $4F,$05,$58,$49,$4A,$59,$5A,$58
$04:BEF8 .db $81,$4F,$81,$5D,$02,$4F,$3D,$69
$04:BF00 .db $81,$20,$82,$E8,$81,$71,$82,$3F
$04:BF08 .db $05,$20,$69,$20,$50,$4F,$68,$84
$04:BF10 .db $4F,$81,$5D,$86,$4F,$03,$3D,$20
$04:BF18 .db $69,$20,$82,$D8,$81,$71,$81,$3F
$04:BF20 .db $04,$D8,$20,$69,$00,$11,$81,$6C
$04:BF28 .db $84,$4F,$03,$5D,$68,$6D,$6E,$84
$04:BF30 .db $4F,$03,$11,$00,$69,$20,$82,$3F
$04:BF38 .db $81,$71,$05,$D8,$D9,$3F,$20,$50
$04:BF40 .db $11,$81,$6C,$85,$4F,$81,$11,$00
$04:BF48 .db $6E,$81,$6D,$00,$6E,$83,$4F,$02
$04:BF50 .db $11,$50,$20,$82,$D9,$81,$71,$04
$04:BF58 .db $3F,$D8,$D9,$00,$11,$81,$6C,$85
$04:BF60 .db $4F,$05,$11,$00,$50,$43,$11,$6E
$04:BF68 .db $81,$6D,$00,$6E,$83,$4F,$00,$00
$04:BF70 .db $82,$3F,$81,$71,$81,$3F,$03,$10
$04:BF78 .db $11,$5D,$68,$84,$4F,$09,$11,$43
$04:BF80 .db $50,$69,$20,$69,$50,$11,$4F,$6E
$04:BF88 .db $81,$6D,$00,$6E,$81,$5D,$01,$4F
$04:BF90 .db $10,$81,$3F,$81,$71,$81,$3F,$01
$04:BF98 .db $3D,$4F,$81,$5D,$81,$4F,$00,$11
$04:BFA0 .db $81,$43,$00,$00,$82,$69,$00,$20
$04:BFA8 .db $81,$69,$01,$00,$18,$81,$4F,$05
$04:BFB0 .db $6E,$6D,$68,$5D,$4F,$3D,$81,$3F
$04:BFB8 .db $81,$71,$02,$D9,$3F,$3D,$82,$4F
$04:BFC0 .db $02,$11,$43,$50,$82,$69,$00,$20
$04:BFC8 .db $81,$69,$08,$20,$69,$20,$69,$48
$04:BFD0 .db $47,$46,$45,$11,$82,$4F,$00,$00
$04:BFD8 .db $81,$3F,$81,$71,$03,$D8,$D9,$40
$04:BFE0 .db $42,$81,$43,$02,$50,$69,$20,$82
$04:BFE8 .db $69,$02,$20,$69,$20,$82,$69,$00
$04:BFF0 .db $20,$83,$69,$00,$00,$81,$43,$01
$04:BFF8 .db $50,$20,$81,$3F,$81,$71,$81,$3F
$04:C000 .db $02,$20,$69,$20,$81,$69,$00,$20
$04:C008 .db $83,$69,$00,$20,$81,$69,$02,$20
$04:C010 .db $69,$20,$84,$69,$04,$20,$69,$20
$04:C018 .db $69,$20,$81,$3F,$81,$71,$03,$4F
$04:C020 .db $3C,$4F,$3C,$81,$4F,$00,$3D,$96
$04:C028 .db $3F,$81,$75,$9B,$1C,$03,$58,$18 ; End of tile number stream ($C02B: start of compressed tile property stream)
$04:C030 .db $1C,$58,$9B,$1C,$03,$58,$18,$1C
$04:C038 .db $58,$9A,$1C,$04,$10,$58,$18,$1C
$04:C040 .db $58,$94,$1C,$81,$10,$81,$50,$82
$04:C048 .db $10,$03,$50,$18,$14,$58,$90,$1C
$04:C050 .db $81,$5C,$84,$10,$00,$50,$82,$10
$04:C058 .db $03,$50,$10,$50,$90,$90,$1C,$00
$04:C060 .db $5C,$81,$10,$8B,$50,$89,$1C,$82
$04:C068 .db $10,$81,$50,$81,$1C,$00,$5C,$86
$04:C070 .db $10,$00,$50,$82,$10,$00,$50,$81
$04:C078 .db $D0,$89,$1C,$83,$10,$00,$50,$81
$04:C080 .db $1C,$00,$5C,$81,$10,$84,$90,$00
$04:C088 .db $D0,$82,$90,$02,$D0,$50,$18,$89
$04:C090 .db $1C,$00,$50,$81,$90,$81,$D0,$81
$04:C098 .db $1C,$01,$18,$50,$84,$90,$85,$10
$04:C0A0 .db $81,$50,$88,$1C,$01,$D4,$58,$82
$04:C0A8 .db $1C,$03,$18,$94,$1C,$18,$81,$58
$04:C0B0 .db $82,$5C,$00,$50,$82,$90,$84,$50
$04:C0B8 .db $88,$1C,$81,$54,$81,$1C,$82,$14
$04:C0C0 .db $01,$1C,$18,$81,$58,$81,$5C,$03
$04:C0C8 .db $18,$5C,$58,$18,$84,$90,$00,$D0
$04:C0D0 .db $89,$1C,$00,$54,$82,$14,$82,$1C
$04:C0D8 .db $00,$18,$81,$58,$82,$5C,$81,$58
$04:C0E0 .db $01,$5C,$58,$82,$5C,$01,$18,$14
$04:C0E8 .db $86,$1C,$81,$10,$87,$1C,$01,$58
$04:C0F0 .db $98,$83,$18,$81,$58,$00,$18,$83
$04:C0F8 .db $5C,$01,$18,$14,$86,$1C,$81,$10
$04:C100 .db $81,$50,$85,$10,$00,$58,$85,$98
$04:C108 .db $81,$18,$00,$58,$82,$5C,$01,$18
$04:C110 .db $14,$84,$1C,$84,$10,$81,$50,$06
$04:C118 .db $10,$50,$10,$50,$10,$58,$18,$83
$04:C120 .db $5C,$81,$98,$01,$18,$58,$82,$18
$04:C128 .db $01,$D8,$18,$84,$1C,$01,$10,$50
$04:C130 .db $81,$10,$02,$50,$10,$50,$81,$10
$04:C138 .db $05,$D0,$50,$D0,$58,$5C,$58,$83
$04:C140 .db $5C,$84,$98,$02,$D8,$18,$98,$84
$04:C148 .db $1C,$83,$10,$00,$50,$82,$10,$84
$04:C150 .db $50,$00,$18,$84,$5C,$00,$18,$82
$04:C158 .db $5C,$03,$18,$14,$58,$5C,$83,$1C
$04:C160 .db $85,$10,$00,$50,$81,$10,$81,$50
$04:C168 .db $00,$90,$82,$50,$00,$58,$84,$5C
$04:C170 .db $00,$58,$81,$5C,$03,$18,$14,$58
$04:C178 .db $5C,$82,$1C,$8A,$10,$83,$50,$84
$04:C180 .db $10,$01,$50,$18,$82,$5C,$03,$18
$04:C188 .db $14,$58,$5C,$82,$1C,$89,$10,$81
$04:C190 .db $50,$81,$90,$85,$10,$81,$50,$00
$04:C198 .db $58,$81,$5C,$03,$18,$14,$58,$5C
$04:C1A0 .db $82,$1C,$85,$10,$00,$50,$84,$10
$04:C1A8 .db $01,$50,$D0,$81,$10,$00,$50,$83
$04:C1B0 .db $10,$00,$50,$81,$10,$04,$50,$18
$04:C1B8 .db $14,$58,$5C,$82,$1C,$01,$50,$90
$04:C1C0 .db $81,$10,$01,$50,$10,$83,$18,$02
$04:C1C8 .db $10,$50,$D0,$82,$90,$00,$D0,$81
$04:C1D0 .db $90,$00,$10,$81,$50,$81,$10,$02
$04:C1D8 .db $50,$14,$58,$81,$14,$82,$1C,$00
$04:C1E0 .db $58,$81,$90,$03,$50,$90,$10,$D0
$04:C1E8 .db $82,$90,$04,$D0,$90,$10,$5C,$50
$04:C1F0 .db $81,$90,$02,$10,$D0,$10,$81,$50
$04:C1F8 .db $82,$10,$00,$50,$82,$58,$82,$1C
$04:C200 .db $00,$58,$82,$10,$02,$50,$10,$D0
$04:C208 .db $82,$90,$01,$10,$5C,$81,$14,$07
$04:C210 .db $54,$58,$18,$90,$10,$D0,$10,$50
$04:C218 .db $81,$18,$01,$10,$50,$82,$58,$82
$04:C220 .db $1C,$00,$D0,$82,$10,$00,$50,$81
$04:C228 .db $D0,$02,$58,$5C,$18,$82,$14,$01
$04:C230 .db $58,$54,$81,$14,$00,$54,$82,$10
$04:C238 .db $83,$18,$00,$10,$82,$50,$81,$1C
$04:C240 .db $84,$10,$81,$50,$84,$14,$85,$58
$04:C248 .db $81,$10,$01,$90,$10,$84,$18,$81
$04:C250 .db $10,$00,$90,$81,$1C,$84,$10,$82
$04:C258 .db $50,$87,$58,$01,$10,$50,$83,$10
$04:C260 .db $00,$D0,$82,$18,$02,$90,$D0,$10
$04:C268 .db $82,$1C,$83,$10,$03,$90,$D0,$10
$04:C270 .db $50,$86,$58,$01,$10,$50,$88,$10
$04:C278 .db $81,$D0,$01,$1C,$58,$81,$1C,$01
$04:C280 .db $50,$90,$82,$10,$03,$50,$D0,$10
$04:C288 .db $94,$84,$58,$83,$10,$00,$50,$83
$04:C290 .db $10,$01,$18,$10,$81,$D0,$01,$1C
$04:C298 .db $18,$82,$1C,$00,$58,$83,$10,$81
$04:C2A0 .db $50,$81,$14,$84,$58,$83,$10,$00
$04:C2A8 .db $D0,$84,$10,$81,$D0,$82,$1C,$00
$04:C2B0 .db $58,$81,$1C,$00,$58,$83,$10,$81
$04:C2B8 .db $50,$83,$58,$00,$10,$81,$50,$87
$04:C2C0 .db $10,$81,$D0,$00,$58,$82,$1C,$81
$04:C2C8 .db $14,$04,$1C,$D4,$58,$50,$90,$81
$04:C2D0 .db $10,$82,$50,$82,$58,$83,$10,$00
$04:C2D8 .db $18,$83,$10,$03,$18,$10,$D0,$18
$04:C2E0 .db $82,$1C,$81,$14,$01,$1C,$18,$9E
$04:C2E8 .db $1C,$00,$18,$9E,$1C,$01,$18,$50
$04:C2F0 .db $95,$1C,$83,$10,$83,$1C,$00,$10
$04:C2F8 .db $81,$50,$90,$1C,$87,$10,$83,$1C
$04:C300 .db $01,$90,$10,$81,$50,$8D,$1C,$89
$04:C308 .db $10,$01,$50,$5C,$81,$1C,$82,$90
$04:C310 .db $81,$50,$8B,$1C,$81,$10,$84,$50
$04:C318 .db $83,$10,$81,$50,$81,$1C,$81,$58
$04:C320 .db $02,$90,$10,$50,$8B,$1C,$82,$10
$04:C328 .db $84,$18,$00,$50,$82,$10,$00,$50
$04:C330 .db $81,$1C,$82,$58,$01,$10,$50,$8B
$04:C338 .db $1C,$01,$10,$90,$85,$18,$00,$58
$04:C340 .db $81,$50,$01,$D0,$10,$81,$1C,$81
$04:C348 .db $58,$02,$10,$D0,$10,$87,$1C,$83
$04:C350 .db $18,$00,$50,$81,$90,$84,$18,$01
$04:C358 .db $D0,$10,$81,$D0,$00,$18,$81,$1C
$04:C360 .db $01,$58,$10,$81,$D0,$01,$18,$58
$04:C368 .db $85,$1C,$84,$18,$00,$58,$87,$90
$04:C370 .db $81,$D0,$01,$5C,$18,$81,$1C,$05
$04:C378 .db $10,$90,$D0,$5C,$18,$58,$88,$18
$04:C380 .db $04,$58,$D8,$58,$5C,$58,$81,$1C
$04:C388 .db $85,$5C,$01,$58,$18,$81,$1C,$01
$04:C390 .db $58,$18,$81,$5C,$01,$18,$58,$86
$04:C398 .db $18,$81,$98,$00,$D8,$81,$58,$01
$04:C3A0 .db $18,$5C,$81,$1C,$84,$5C,$07,$18
$04:C3A8 .db $5C,$18,$50,$1C,$58,$5C,$58,$81
$04:C3B0 .db $18,$00,$58,$85,$1C,$82,$18,$01
$04:C3B8 .db $58,$18,$82,$58,$81,$1C,$85,$5C
$04:C3C0 .db $01,$58,$18,$81,$50,$00,$58,$82
$04:C3C8 .db $18,$01,$D8,$18,$83,$10,$81,$50
$04:C3D0 .db $81,$18,$00,$D8,$82,$18,$00,$58
$04:C3D8 .db $82,$18,$00,$58,$83,$5C,$04,$18
$04:C3E0 .db $5C,$18,$10,$50,$82,$18,$81,$D8
$04:C3E8 .db $01,$18,$D0,$83,$90,$04,$50,$58
$04:C3F0 .db $98,$18,$D8,$83,$18,$02,$98,$D8
$04:C3F8 .db $18,$84,$5C,$00,$58,$81,$10,$00
$04:C400 .db $50,$81,$98,$04,$18,$58,$5C,$18
$04:C408 .db $D0,$82,$5C,$81,$90,$00,$58,$87
$04:C410 .db $98,$01,$D8,$18,$83,$5C,$00,$18
$04:C418 .db $82,$10,$01,$50,$18,$81,$98,$02
$04:C420 .db $18,$5C,$18,$83,$14,$81,$54,$00
$04:C428 .db $58,$81,$5C,$00,$58,$84,$5C,$01
$04:C430 .db $58,$18,$82,$5C,$83,$10,$81,$50
$04:C438 .db $05,$5C,$58,$5C,$18,$5C,$18,$85
$04:C440 .db $1C,$02,$58,$5C,$18,$84,$5C,$02
$04:C448 .db $18,$5C,$18,$87,$10,$01,$50,$18
$04:C450 .db $81,$5C,$01,$18,$5C,$81,$14,$83
$04:C458 .db $58,$01,$D4,$58,$81,$5C,$00,$58
$04:C460 .db $84,$5C,$00,$58,$82,$10,$02,$50
$04:C468 .db $10,$50,$81,$10,$05,$D0,$10,$5C
$04:C470 .db $58,$5C,$18,$81,$14,$00,$18,$83
$04:C478 .db $58,$81,$54,$01,$5C,$18,$84,$5C
$04:C480 .db $00,$18,$81,$10,$05,$50,$10,$50
$04:C488 .db $10,$50,$10,$81,$50,$81,$18,$81
$04:C490 .db $5C,$01,$18,$94,$86,$58,$82,$54
$04:C498 .db $00,$58,$86,$10,$05,$50,$10,$50
$04:C4A0 .db $10,$50,$10,$81,$50,$03,$18,$14
$04:C4A8 .db $54,$5C,$81,$14,$01,$58,$18,$85
$04:C4B0 .db $58,$02,$18,$54,$14,$82,$10,$00
$04:C4B8 .db $50,$82,$10,$02,$50,$D0,$90,$81
$04:C4C0 .db $10,$82,$50,$02,$18,$58,$54,$81
$04:C4C8 .db $14,$81,$58,$84,$18,$83,$58,$83
$04:C4D0 .db $10,$02,$50,$10,$50,$81,$10,$07
$04:C4D8 .db $50,$10,$50,$10,$50,$10,$50,$14
$04:C4E0 .db $82,$58,$02,$10,$50,$58,$82,$18
$04:C4E8 .db $01,$10,$50,$82,$58,$82,$10,$00
$04:C4F0 .db $50,$81,$10,$81,$50,$02,$10,$50
$04:C4F8 .db $10,$81,$50,$04,$10,$50,$10,$50
$04:C500 .db $14,$82,$50,$81,$10,$00,$94,$81
$04:C508 .db $18,$81,$10,$01,$50,$10,$81,$50
$04:C510 .db $83,$10,$0D,$50,$10,$50,$10,$50
$04:C518 .db $10,$50,$10,$50,$10,$50,$10,$50
$04:C520 .db $1C,$82,$90,$00,$D0,$81,$14,$01
$04:C528 .db $18,$10,$83,$90,$82,$10,$01,$50
$04:C530 .db $10,$81,$50,$07,$10,$50,$10,$50
$04:C538 .db $10,$50,$10,$50,$81,$10,$82,$50
$04:C540 .db $81,$1C,$81,$18,$82,$14,$00,$58
$04:C548 .db $81,$1C,$00,$18,$81,$90,$81,$10
$04:C550 .db $00,$50,$81,$10,$00,$50,$81,$10
$04:C558 .db $0A,$50,$10,$50,$10,$50,$10,$50
$04:C560 .db $10,$50,$10,$50,$81,$1C,$81,$18
$04:C568 .db $82,$14,$00,$58,$82,$1C,$00,$58
$04:C570 .db $82,$90,$04,$10,$50,$10,$50,$10
$04:C578 .db $81,$50,$81,$10,$81,$50,$05,$10
$04:C580 .db $50,$10,$50,$10,$50,$81,$1C,$81
$04:C588 .db $18,$82,$14,$00,$58,$81,$1C,$00
$04:C590 .db $18,$82,$1C,$81,$10,$02,$50,$10
$04:C598 .db $50,$81,$10,$06,$50,$10,$50,$10
$04:C5A0 .db $50,$14,$10,$81,$50,$01,$D0,$10
$04:C5A8 .db $82,$1C,$81,$14,$02,$18,$D4,$58
$04:C5B0 .db $82,$1C,$00,$58,$81,$1C,$84,$10
$04:C5B8 .db $00,$50,$81,$10,$01,$50,$10,$81
$04:C5C0 .db $50,$02,$10,$50,$10,$81,$50,$02
$04:C5C8 .db $18,$14,$54,$81,$14,$01,$18,$58
$04:C5D0 .db $85,$54,$83,$10,$06,$50,$10,$50
$04:C5D8 .db $10,$50,$10,$50,$81,$10,$03,$50
$04:C5E0 .db $10,$50,$10,$81,$50,$00,$18,$87
$04:C5E8 .db $1C,$83,$50,$83,$10,$02,$50,$10
$04:C5F0 .db $50,$81,$10,$06,$50,$10,$50,$10
$04:C5F8 .db $50,$10,$50,$81,$10,$02,$50,$18
$04:C600 .db $1C,$81,$54,$00,$58,$82,$10,$01
$04:C608 .db $50,$10,$83,$50,$89,$10,$81,$D0
$04:C610 .db $02,$1C,$58,$1C,$81,$14,$83,$1C
$04:C618 .db $04,$54,$58,$50,$90,$D0,$86,$10
$04:C620 .db $81,$18,$00,$50,$84,$10,$81,$D0
$04:C628 .db $01,$58,$18,$82,$14,$85,$1C,$00
$04:C630 .db $D0,$81,$10,$01,$50,$D0,$82,$10
$04:C638 .db $02,$50,$10,$90,$81,$18,$00,$D0
$04:C640 .db $83,$10,$81,$D0,$01,$18,$1C,$81
$04:C648 .db $14,$86,$1C,$83,$10,$81,$50,$00
$04:C650 .db $D0,$81,$90,$00,$D0,$87,$10,$81
$04:C658 .db $D0,$81,$1C,$01,$58,$14,$81,$1C
$04:C660 .db $81,$14,$83,$1C,$01,$50,$90,$81
$04:C668 .db $10,$00,$D0,$83,$10,$00,$50,$84
$04:C670 .db $10,$01,$D0,$90,$81,$D0,$81,$1C
$04:C678 .db $00,$18,$87,$14,$81,$1C,$00,$58
$04:C680 .db $82,$90,$01,$D0,$18,$82,$10,$00
$04:C688 .db $50,$83,$10,$81,$D0,$00,$58,$83
$04:C690 .db $1C,$81,$14,$00,$1C,$81,$14,$81
$04:C698 .db $58,$81,$14,$81,$1C,$05,$58,$1C
$04:C6A0 .db $18,$58,$1C,$18,$86,$90,$81,$D0
$04:C6A8 .db $02,$1C,$58,$5C,$81,$1C,$83,$14
$04:C6B0 .db $85,$58,$81,$1C,$04,$58,$1C,$18
$04:C6B8 .db $58,$1C,$81,$18,$00,$58,$84,$1C
$04:C6C0 .db $00,$58,$81,$1C,$00,$58,$81,$1C
$04:C6C8 .db $81,$14,$00,$1C,$81,$14,$85,$58
$04:C6D0 .db $81,$1C,$07,$58,$1C,$18,$58,$1C
$04:C6D8 .db $18,$1C,$58,$83,$1C,$01,$18,$5C
$04:C6E0 .db $81,$1C,$00,$58,$84,$14,$87,$58
$04:C6E8 .db $81,$1C,$04,$58,$1C,$18,$58,$1C
$04:C6F0 .db $81,$18,$01,$1C,$5C,$83,$1C,$01
$04:C6F8 .db $58,$1C,$82,$14,$81,$1C,$81,$14
$04:C700 .db $87,$58,$81,$1C,$07,$58,$1C,$18
$04:C708 .db $58,$1C,$18,$54,$58,$83,$1C,$00
$04:C710 .db $18,$82,$14,$83,$1C,$81,$14,$87
$04:C718 .db $58,$81,$1C,$06,$58,$1C,$18,$58
$04:C720 .db $1C,$18,$54,$86,$14,$85,$1C,$81
$04:C728 .db $14,$87,$58,$81,$1C,$05,$58,$1C
$04:C730 .db $18,$58,$1C,$18,$84,$10,$81,$50
$04:C738 .db $87,$1C,$81,$14,$86,$58,$02,$1C
$04:C740 .db $10,$58,$81,$10,$81,$50,$00,$18
$04:C748 .db $86,$10,$00,$50,$86,$1C,$83,$14
$04:C750 .db $83,$58,$03,$14,$1C,$10,$50,$81
$04:C758 .db $10,$81,$50,$87,$10,$00,$50,$88
$04:C760 .db $1C,$81,$14,$00,$58,$81,$14,$09
$04:C768 .db $58,$14,$1C,$10,$D0,$58,$18,$58
$04:C770 .db $18,$90,$86,$10,$00,$50,$8B,$1C
$04:C778 .db $81,$14,$82,$1C,$00,$10,$81,$50
$04:C780 .db $01,$18,$58,$88,$10,$00,$50,$90
$04:C788 .db $1C,$81,$10,$00,$50,$8A,$10,$00
$04:C790 .db $50,$83,$1C,$01,$18,$58,$8A,$1C
$04:C798 .db $00,$50,$82,$90,$86,$10,$00,$D0
$04:C7A0 .db $81,$90,$00,$10,$83,$1C,$00,$18
$04:C7A8 .db $81,$58,$83,$1C,$81,$18,$00,$58
$04:C7B0 .db $82,$1C,$81,$58,$00,$1C,$87,$10
$04:C7B8 .db $00,$50,$81,$1C,$00,$18,$83,$1C
$04:C7C0 .db $81,$98,$81,$58,$81,$1C,$85,$18
$04:C7C8 .db $00,$1C,$81,$58,$01,$1C,$50,$86
$04:C7D0 .db $90,$00,$10,$81,$1C,$00,$18,$83
$04:C7D8 .db $1C,$00,$58,$8A,$18,$00,$D4,$81
$04:C7E0 .db $58,$00,$1C,$81,$58,$84,$1C,$81
$04:C7E8 .db $18,$81,$1C,$01,$18,$94,$82,$1C
$04:C7F0 .db $8B,$18,$81,$54,$01,$58,$1C,$81
$04:C7F8 .db $58,$84,$1C,$81,$18,$81,$1C,$81
$04:C800 .db $14,$81,$1C,$8C,$18,$01,$1C,$54
$04:C808 .db $81,$14,$81,$58,$84,$1C,$81,$18
$04:C810 .db $82,$14,$82,$1C,$81,$98,$8A,$18
$04:C818 .db $82,$1C,$81,$54,$00,$58,$84,$1C
$04:C820 .db $00,$18,$81,$14,$84,$1C,$00,$58
$04:C828 .db $8B,$18,$83,$1C,$00,$54,$87,$14
$04:C830 .db $85,$1C,$8C,$18,$92,$1C,$81,$98
$04:C838 .db $8A,$18,$8D,$1C,$81,$14,$00,$1C
$04:C840 .db $81,$14,$00,$58,$81,$98,$89,$18
$04:C848 .db $8D,$1C,$84,$14,$81,$58,$81,$98
$04:C850 .db $81,$18,$00,$D8,$81,$98,$00,$D8
$04:C858 .db $82,$98,$8C,$1C,$84,$14,$83,$58
$04:C860 .db $82,$98,$03,$D8,$1C,$18,$58,$81
$04:C868 .db $1C,$00,$18,$89,$1C,$81,$14,$00
$04:C870 .db $1C,$85,$14,$83,$58,$81,$1C,$03
$04:C878 .db $18,$1C,$98,$D8,$81,$1C,$00,$98
$04:C880 .db $89,$1C,$81,$14,$84,$1C,$82,$14
$04:C888 .db $82,$58,$81,$1C,$03,$18,$1C,$58
$04:C890 .db $18,$81,$1C,$00,$58,$86,$1C,$83
$04:C898 .db $10,$83,$50,$86,$10,$82,$50,$82
$04:C8A0 .db $10,$03,$50,$10,$50,$14,$86,$1C
$04:C8A8 .db $83,$10,$83,$18,$84,$90,$06,$10
$04:C8B0 .db $50,$10,$50,$10,$50,$10,$81,$50
$04:C8B8 .db $02,$D0,$10,$14,$86,$1C,$83,$10
$04:C8C0 .db $00,$90,$81,$18,$07,$D0,$10,$50
$04:C8C8 .db $10,$50,$10,$50,$10,$81,$50,$03
$04:C8D0 .db $10,$50,$10,$50,$81,$D0,$00,$18
$04:C8D8 .db $87,$1C,$82,$10,$82,$90,$82,$10
$04:C8E0 .db $0A,$50,$10,$50,$10,$50,$10,$50
$04:C8E8 .db $10,$50,$90,$10,$81,$50,$01,$1C
$04:C8F0 .db $18,$87,$1C,$07,$10,$50,$14,$54
$04:C8F8 .db $58,$18,$90,$10,$83,$50,$83,$10
$04:C900 .db $02,$50,$90,$10,$82,$50,$02,$1C
$04:C908 .db $18,$94,$86,$1C,$03,$50,$90,$50
$04:C910 .db $54,$81,$14,$01,$54,$10,$83,$18
$04:C918 .db $84,$90,$00,$10,$81,$50,$02,$D0
$04:C920 .db $10,$1C,$83,$14,$84,$1C,$00,$58
$04:C928 .db $81,$90,$00,$50,$81,$58,$02,$54
$04:C930 .db $10,$90,$81,$18,$00,$D0,$81,$10
$04:C938 .db $07,$50,$10,$50,$10,$50,$10,$D0
$04:C940 .db $18,$81,$14,$00,$1C,$81,$14,$84
$04:C948 .db $1C,$01,$58,$1C,$81,$90,$81,$50
$04:C950 .db $83,$10,$00,$50,$81,$10,$01,$50
$04:C958 .db $10,$81,$50,$81,$10,$81,$D0,$01
$04:C960 .db $18,$14,$81,$1C,$81,$58,$81,$14
$04:C968 .db $81,$1C,$01,$D4,$58,$81,$1C,$81
$04:C970 .db $90,$00,$50,$83,$10,$00,$50,$81
$04:C978 .db $10,$03,$50,$10,$50,$10,$82,$D0
$04:C980 .db $02,$58,$18,$94,$81,$1C,$81,$58
$04:C988 .db $81,$14,$81,$1C,$81,$54,$82,$1C
$04:C990 .db $8B,$90,$81,$D0,$02,$1C,$18,$1C
$04:C998 .db $81,$14,$81,$1C,$81,$58,$81,$14
$04:C9A0 .db $82,$1C,$81,$54,$83,$1C,$00,$58
$04:C9A8 .db $87,$1C,$00,$18,$82,$1C,$00,$18
$04:C9B0 .db $81,$14,$82,$1C,$81,$58,$81,$14
$04:C9B8 .db $83,$1C,$84,$18,$01,$58,$1C,$82
$04:C9C0 .db $10,$00,$50,$83,$1C,$00,$58,$81
$04:C9C8 .db $1C,$01,$18,$14,$83,$1C,$00,$58
$04:C9D0 .db $81,$14,$84,$1C,$84,$18,$01,$58
$04:C9D8 .db $1C,$81,$10,$81,$50,$82,$1C,$00
$04:C9E0 .db $18,$82,$1C,$81,$14,$83,$1C,$82
$04:C9E8 .db $14,$84,$1C,$83,$18,$02,$98,$D8
$04:C9F0 .db $1C,$81,$90,$01,$D0,$50,$81,$1C
$04:C9F8 .db $81,$18,$00,$58,$81,$14,$81,$10
$04:CA00 .db $00,$50,$82,$1C,$00,$14,$81,$1C
$04:CA08 .db $81,$18,$00,$58,$81,$1C,$81,$98
$04:CA10 .db $82,$18,$02,$58,$14,$50,$81,$90
$04:CA18 .db $00,$10,$81,$14,$07,$58,$98,$18
$04:CA20 .db $14,$1C,$50,$90,$10,$85,$1C,$81
$04:CA28 .db $18,$01,$58,$18,$81,$58,$82,$18
$04:CA30 .db $81,$D8,$00,$1C,$81,$58,$81,$18
$04:CA38 .db $81,$1C,$81,$58,$00,$18,$81,$1C
$04:CA40 .db $02,$58,$1C,$18,$85,$1C,$88,$18
$04:CA48 .db $02,$58,$18,$1C,$81,$58,$81,$18
$04:CA50 .db $81,$1C,$81,$58,$00,$18,$81,$1C
$04:CA58 .db $02,$58,$1C,$18,$82,$1C,$8B,$18
$04:CA60 .db $02,$58,$18,$D4,$81,$58,$81,$18
$04:CA68 .db $01,$94,$1C,$81,$58,$06,$18,$1C
$04:CA70 .db $D4,$58,$1C,$18,$94,$81,$1C,$8B
$04:CA78 .db $18,$01,$58,$18,$81,$54,$01,$58
$04:CA80 .db $18,$81,$14,$00,$D4,$81,$58,$01
$04:CA88 .db $18,$94,$81,$54,$00,$1C,$81,$14
$04:CA90 .db $81,$1C,$8B,$18,$81,$58,$01,$1C
$04:CA98 .db $54,$82,$14,$00,$1C,$81,$54,$00
$04:CAA0 .db $58,$81,$14,$01,$1C,$54,$81,$14
$04:CAA8 .db $82,$1C,$8C,$18,$00,$58,$81,$18
$04:CAB0 .db $00,$58,$83,$1C,$00,$54,$81,$14
$04:CAB8 .db $87,$1C,$8F,$18,$81,$58,$8D,$1C
$04:CAC0 .db $90,$18,$02,$58,$18,$58,$8B,$1C
$04:CAC8 .db $91,$18,$81,$D8,$81,$1C,$81,$14
$04:CAD0 .db $87,$1C,$91,$18,$02,$58,$18,$1C
$04:CAD8 .db $82,$14,$87,$1C,$91,$18,$81,$58
$04:CAE0 .db $00,$1C,$81,$14,$88,$1C,$91,$18
$04:CAE8 .db $81,$D8,$8B,$1C,$88,$18,$00,$D8
$04:CAF0 .db $84,$98,$81,$18,$81,$D8,$00,$18
$04:CAF8 .db $81,$14,$82,$1C,$81,$14,$84,$1C
$04:CB00 .db $88,$18,$00,$58,$83,$1C,$81,$98
$04:CB08 .db $81,$D8,$81,$18,$86,$14,$84,$1C
$04:CB10 .db $81,$18,$82,$98,$00,$D8,$81,$98
$04:CB18 .db $01,$18,$58,$83,$1C,$02,$58,$98
$04:CB20 .db $D8,$82,$18,$00,$58,$83,$14,$86
$04:CB28 .db $1C,$01,$98,$D8,$81,$1C,$02,$98
$04:CB30 .db $D8,$1C,$81,$18,$00,$58,$83,$1C
$04:CB38 .db $81,$58,$83,$18,$83,$14,$88,$1C
$04:CB40 .db $00,$18,$81,$1C,$02,$58,$18,$1C
$04:CB48 .db $81,$98,$00,$D8,$83,$1C,$81,$58
$04:CB50 .db $82,$18,$82,$14,$89,$1C,$83,$14
$04:CB58 .db $00,$50,$83,$10,$82,$50,$81,$10
$04:CB60 .db $00,$14,$81,$18,$8C,$14,$81,$10
$04:CB68 .db $83,$14,$00,$50,$83,$10,$82,$50
$04:CB70 .db $82,$10,$81,$18,$85,$10,$81,$18
$04:CB78 .db $84,$14,$81,$10,$81,$14,$81,$18
$04:CB80 .db $00,$50,$83,$10,$82,$50,$82,$10
$04:CB88 .db $81,$18,$81,$10,$01,$50,$10,$83
$04:CB90 .db $18,$84,$14,$81,$10,$81,$14,$81
$04:CB98 .db $18,$00,$50,$83,$10,$83,$50,$81
$04:CBA0 .db $10,$81,$18,$81,$10,$01,$50,$10
$04:CBA8 .db $83,$18,$84,$14,$81,$10,$81,$14
$04:CBB0 .db $81,$18,$00,$50,$83,$10,$81,$50
$04:CBB8 .db $03,$10,$50,$10,$90,$82,$18,$01
$04:CBC0 .db $10,$50,$82,$10,$82,$18,$83,$14
$04:CBC8 .db $81,$10,$01,$14,$10,$81,$18,$00
$04:CBD0 .db $50,$81,$10,$81,$90,$81,$D0,$81
$04:CBD8 .db $50,$81,$10,$82,$18,$85,$10,$81
$04:CBE0 .db $18,$00,$50,$82,$14,$81,$10,$01
$04:CBE8 .db $14,$10,$81,$18,$81,$50,$82,$10
$04:CBF0 .db $82,$50,$82,$10,$82,$18,$00,$10
$04:CBF8 .db $81,$50,$01,$10,$D0,$82,$10,$00
$04:CC00 .db $50,$82,$14,$81,$10,$02,$14,$50
$04:CC08 .db $90,$81,$10,$81,$50,$81,$10,$81
$04:CC10 .db $50,$81,$10,$85,$18,$82,$50,$01
$04:CC18 .db $10,$50,$81,$10,$00,$50,$82,$14
$04:CC20 .db $81,$10,$02,$14,$54,$10,$81,$18
$04:CC28 .db $01,$D0,$50,$81,$10,$81,$50,$01
$04:CC30 .db $10,$90,$86,$18,$81,$50,$04,$10
$04:CC38 .db $50,$10,$D0,$10,$82,$14,$81,$10
$04:CC40 .db $02,$14,$54,$10,$81,$18,$81,$50
$04:CC48 .db $81,$10,$81,$50,$81,$10,$85,$18
$04:CC50 .db $82,$10,$00,$90,$82,$D0,$83,$14
$04:CC58 .db $81,$10,$01,$D4,$54,$83,$10,$00
$04:CC60 .db $50,$81,$10,$01,$50,$10,$87,$18
$04:CC68 .db $83,$10,$82,$50,$83,$14,$81,$10
$04:CC70 .db $81,$54,$82,$10,$00,$50,$81,$10
$04:CC78 .db $02,$50,$90,$10,$81,$18,$00,$10
$04:CC80 .db $83,$18,$81,$10,$07,$18,$10,$50
$04:CC88 .db $90,$10,$50,$14,$94,$81,$14,$81
$04:CC90 .db $10,$08,$14,$54,$10,$50,$10,$90
$04:CC98 .db $10,$50,$90,$81,$10,$84,$50,$81
$04:CCA0 .db $18,$07,$10,$50,$10,$50,$90,$10
$04:CCA8 .db $18,$50,$83,$14,$81,$10,$81,$14
$04:CCB0 .db $81,$10,$04,$90,$50,$10,$50,$90
$04:CCB8 .db $85,$10,$00,$50,$81,$18,$01,$90
$04:CCC0 .db $D0,$81,$90,$03,$10,$18,$10,$50
$04:CCC8 .db $83,$14,$81,$D0,$81,$14,$83,$90
$04:CCD0 .db $01,$50,$90,$81,$18,$00,$50,$84
$04:CCD8 .db $10,$81,$18,$01,$10,$50,$81,$10
$04:CCE0 .db $81,$90,$81,$D0,$83,$14,$81,$50
$04:CCE8 .db $81,$14,$00,$54,$81,$14,$81,$10
$04:CCF0 .db $00,$50,$81,$18,$00,$50,$82,$10
$04:CCF8 .db $01,$50,$10,$81,$18,$03,$10,$50
$04:CD00 .db $18,$50,$87,$14,$81,$50,$81,$14
$04:CD08 .db $00,$54,$81,$14,$81,$10,$05,$50
$04:CD10 .db $10,$50,$90,$D0,$90,$82,$D0,$05
$04:CD18 .db $10,$50,$10,$50,$10,$50,$87,$14
$04:CD20 .db $81,$50,$02,$14,$D4,$54,$81,$14
$04:CD28 .db $02,$10,$90,$D0,$81,$90,$85,$10
$04:CD30 .db $81,$D0,$03,$90,$D0,$10,$50,$83
$04:CD38 .db $14,$00,$94,$82,$14,$81,$50,$00
$04:CD40 .db $14,$82,$54,$01,$14,$50,$8E,$90
$04:CD48 .db $00,$10,$87,$14,$81,$50,$82,$14
$04:CD50 .db $01,$54,$14,$81,$50,$8E,$10,$87
$04:CD58 .db $14,$81,$50,$84,$14,$81,$50,$8E
$04:CD60 .db $10,$87,$14,$81,$50,$00,$10,$81
$04:CD68 .db $50,$86,$10,$00,$50,$88,$10,$00
$04:CD70 .db $50,$83,$10,$00,$50,$81,$10,$81
$04:CD78 .db $50,$8B,$10,$00,$50,$83,$10,$00
$04:CD80 .db $D0,$86,$10,$00,$50,$82,$10,$82
$04:CD88 .db $50,$84,$10,$01,$50,$90,$83,$10
$04:CD90 .db $04,$D0,$10,$50,$10,$50,$87,$10
$04:CD98 .db $83,$50,$81,$10,$81,$50,$84,$10
$04:CDA0 .db $00,$50,$83,$90,$81,$D0,$01,$10
$04:CDA8 .db $50,$84,$10,$00,$50,$85,$10,$81
$04:CDB0 .db $50,$81,$10,$81,$50,$82,$10,$01
$04:CDB8 .db $D0,$10,$81,$50,$82,$10,$00,$50
$04:CDC0 .db $81,$10,$00,$50,$83,$10,$01,$90
$04:CDC8 .db $D0,$83,$90,$00,$D0,$81,$10,$84
$04:CDD0 .db $50,$83,$10,$82,$50,$82,$10,$00
$04:CDD8 .db $50,$81,$10,$00,$50,$81,$18,$88
$04:CDE0 .db $10,$02,$D0,$90,$10,$83,$50,$84
$04:CDE8 .db $10,$82,$50,$85,$10,$81,$18,$86
$04:CDF0 .db $90,$83,$10,$01,$50,$10,$82,$50
$04:CDF8 .db $86,$10,$00,$50,$82,$10,$00,$D0
$04:CE00 .db $81,$10,$02,$18,$D8,$50,$84,$10
$04:CE08 .db $82,$90,$81,$10,$01,$50,$10,$82
$04:CE10 .db $50,$85,$10,$00,$D0,$82,$90,$81
$04:CE18 .db $D0,$81,$10,$81,$D8,$00,$50,$86
$04:CE20 .db $10,$82,$90,$02,$D0,$10,$50,$86
$04:CE28 .db $10,$00,$D0,$87,$10,$02,$58,$14
$04:CE30 .db $50,$84,$10,$02,$50,$10,$50,$81
$04:CE38 .db $10,$00,$50,$87,$10,$81,$D0,$85
$04:CE40 .db $10,$03,$50,$D8,$58,$14,$81,$54
$04:CE48 .db $88,$10,$00,$50,$8B,$10,$00,$50
$04:CE50 .db $96,$10,$81,$14,$85,$10,$81,$50
$04:CE58 .db $95,$10,$81,$14,$01,$10,$50,$84
$04:CE60 .db $10,$00,$50,$95,$10,$81,$14,$01
$04:CE68 .db $90,$D0,$81,$90,$82,$10,$00,$50
$04:CE70 .db $91,$10,$81,$50,$81,$10,$81,$14
$04:CE78 .db $01,$10,$50,$81,$10,$83,$D0,$92
$04:CE80 .db $10,$00,$50,$81,$10,$81,$14,$01
$04:CE88 .db $10,$50,$81,$10,$00,$D0,$81,$50
$04:CE90 .db $00,$10,$8E,$18,$86,$10,$81,$14
$04:CE98 .db $82,$10,$81,$D0,$81,$50,$00,$10
$04:CEA0 .db $8E,$18,$01,$50,$90,$84,$10,$81
$04:CEA8 .db $14,$81,$10,$81,$D0,$81,$10,$01
$04:CEB0 .db $50,$10,$8E,$18,$00,$50,$82,$90
$04:CEB8 .db $82,$10,$81,$14,$81,$10,$81,$50
$04:CEC0 .db $81,$10,$01,$50,$10,$86,$18,$00
$04:CEC8 .db $58,$84,$18,$01,$D8,$98,$82,$50
$04:CED0 .db $00,$90,$82,$D0,$81,$14,$81,$10
$04:CED8 .db $81,$50,$81,$10,$01,$50,$10,$86
$04:CEE0 .db $18,$00,$58,$83,$18,$81,$D8,$87
$04:CEE8 .db $50,$81,$14,$81,$10,$81,$50,$81
$04:CEF0 .db $10,$03,$50,$10,$18,$58,$84,$18
$04:CEF8 .db $00,$58,$82,$18,$81,$58,$81,$14
$04:CF00 .db $86,$50,$81,$14,$82,$10,$00,$50
$04:CF08 .db $81,$10,$03,$50,$10,$98,$D8,$83
$04:CF10 .db $98,$85,$18,$01,$58,$14,$81,$54
$04:CF18 .db $85,$50,$81,$14,$81,$10,$01,$D0
$04:CF20 .db $10,$81,$50,$82,$18,$00,$58,$83
$04:CF28 .db $18,$01,$98,$D8,$81,$18,$01,$98
$04:CF30 .db $D8,$81,$58,$81,$18,$81,$58,$83
$04:CF38 .db $50,$81,$14,$82,$D0,$00,$10,$84
$04:CF40 .db $18,$00,$58,$8A,$18,$00,$58,$83
$04:CF48 .db $18,$00,$58,$82,$50,$81,$14,$82
$04:CF50 .db $50,$00,$10,$84,$18,$00,$58,$84
$04:CF58 .db $18,$00,$58,$82,$18,$00,$58,$82
$04:CF60 .db $18,$00,$58,$85,$18,$81,$14,$03
$04:CF68 .db $50,$10,$50,$10,$81,$98,$81,$18
$04:CF70 .db $01,$98,$D8,$83,$98,$81,$18,$82
$04:CF78 .db $98,$00,$D8,$82,$98,$00,$D8,$81
$04:CF80 .db $98,$00,$D8,$82,$18,$81,$14,$04
$04:CF88 .db $50,$10,$50,$10,$50,$81,$98,$86
$04:CF90 .db $18,$01,$98,$D8,$8A,$18,$81,$D8
$04:CF98 .db $00,$18,$81,$14,$82,$50,$02,$10
$04:CFA0 .db $14,$54,$82,$98,$01,$10,$50,$86
$04:CFA8 .db $18,$01,$10,$50,$81,$18,$04,$10
$04:CFB0 .db $50,$18,$10,$50,$82,$18,$81,$14
$04:CFB8 .db $04,$50,$10,$50,$10,$18,$81,$54
$04:CFC0 .db $00,$50,$81,$10,$81,$50,$81,$18
$04:CFC8 .db $84,$10,$00,$50,$82,$10,$00,$50
$04:CFD0 .db $81,$10,$00,$50,$82,$18,$81,$14
$04:CFD8 .db $82,$50,$03,$10,$94,$18,$54,$83
$04:CFE0 .db $10,$00,$50,$8D,$10,$00,$50,$82
$04:CFE8 .db $10,$81,$14,$02,$50,$10,$50,$81
$04:CFF0 .db $14,$00,$18,$97,$10,$81,$14,$9D
$04:CFF8 .db $10,$81,$50,$9D,$10,$81,$50,$9D
$04:D000 .db $10,$81,$50,$9D,$10,$81,$50,$9D
$04:D008 .db $10,$81,$50,$82,$10,$00,$14,$81
$04:D010 .db $10,$81,$14,$81,$10,$82,$14,$81
$04:D018 .db $10,$00,$14,$81,$10,$00,$14,$81
$04:D020 .db $10,$00,$14,$81,$10,$00,$14,$88
$04:D028 .db $10,$08,$14,$10,$14,$10,$14,$10
$04:D030 .db $14,$10,$14,$82,$10,$0A,$14,$10
$04:D038 .db $14,$10,$14,$10,$14,$10,$14,$10
$04:D040 .db $14,$88,$10,$00,$14,$82,$10,$04
$04:D048 .db $14,$10,$14,$10,$14,$82,$10,$00
$04:D050 .db $14,$82,$10,$06,$14,$10,$14,$10
$04:D058 .db $14,$10,$14,$89,$10,$00,$14,$81
$04:D060 .db $10,$03,$14,$10,$14,$10,$82,$14
$04:D068 .db $01,$10,$14,$82,$10,$01,$14,$10
$04:D070 .db $82,$14,$01,$10,$14,$8A,$10,$01
$04:D078 .db $14,$10,$81,$14,$81,$10,$00,$14
$04:D080 .db $82,$10,$00,$14,$82,$10,$06,$14
$04:D088 .db $10,$14,$10,$14,$10,$14,$88,$10
$04:D090 .db $04,$14,$10,$14,$10,$14,$82,$10
$04:D098 .db $00,$14,$82,$10,$0A,$14,$10,$14
$04:D0A0 .db $10,$14,$10,$14,$10,$14,$10,$14
$04:D0A8 .db $86,$10,$81,$90,$87,$10,$82,$18
$04:D0B0 .db $81,$58,$00,$54,$83,$14,$81,$54
$04:D0B8 .db $00,$50,$81,$10,$00,$50,$88,$10
$04:D0C0 .db $00,$50,$83,$10,$85,$18,$00,$58
$04:D0C8 .db $85,$18,$81,$54,$02,$10,$90,$D0
$04:D0D0 .db $87,$10,$81,$50,$8A,$18,$00,$94
$04:D0D8 .db $85,$18,$82,$10,$00,$50,$87,$10
$04:D0E0 .db $81,$50,$88,$18,$00,$58,$81,$14
$04:D0E8 .db $85,$18,$82,$10,$00,$50,$88,$10
$04:D0F0 .db $81,$50,$85,$18,$03,$58,$18,$58
$04:D0F8 .db $14,$86,$18,$82,$10,$00,$50,$89
$04:D100 .db $10,$81,$50,$83,$18,$03,$98,$D8
$04:D108 .db $98,$58,$87,$18,$83,$10,$00,$50
$04:D110 .db $89,$10,$03,$50,$18,$10,$50,$81
$04:D118 .db $18,$01,$58,$18,$81,$58,$86,$18
$04:D120 .db $01,$10,$90,$81,$10,$00,$D0,$89
$04:D128 .db $10,$00,$50,$81,$10,$81,$50,$05
$04:D130 .db $18,$58,$18,$10,$50,$58,$81,$18
$04:D138 .db $85,$10,$01,$50,$90,$8E,$10,$00
$04:D140 .db $50,$83,$10,$00,$50,$87,$10,$01
$04:D148 .db $50,$90,$9B,$10,$82,$90,$87,$10
$04:D150 .db $81,$1C,$00,$5C,$81,$1C,$81,$5C
$04:D158 .db $81,$1C,$81,$5C,$00,$10,$81,$1C
$04:D160 .db $81,$5C,$01,$10,$50,$81,$1C,$81
$04:D168 .db $5C,$81,$1C,$81,$5C,$01,$10,$50
$04:D170 .db $81,$10,$81,$1C,$82,$10,$81,$1C
$04:D178 .db $81,$5C,$81,$1C,$81,$5C,$00,$10
$04:D180 .db $81,$1C,$81,$5C,$01,$10,$50,$81
$04:D188 .db $1C,$81,$5C,$81,$1C,$81,$5C,$01
$04:D190 .db $10,$50,$81,$10,$83,$1C,$81,$5C
$04:D198 .db $00,$1C,$81,$5C,$81,$1C,$81,$5C
$04:D1A0 .db $00,$10,$81,$1C,$81,$5C,$01,$10
$04:D1A8 .db $50,$81,$1C,$81,$5C,$81,$1C,$00
$04:D1B0 .db $5C,$81,$1C,$81,$5C,$00,$10,$83
$04:D1B8 .db $1C,$81,$5C,$84,$10,$00,$50,$86
$04:D1C0 .db $10,$00,$50,$81,$1C,$81,$5C,$82
$04:D1C8 .db $10,$81,$1C,$81,$5C,$00,$10,$83
$04:D1D0 .db $1C,$81,$5C,$81,$1C,$81,$5C,$01
$04:D1D8 .db $10,$50,$82,$10,$06,$50,$10,$50
$04:D1E0 .db $10,$50,$10,$50,$81,$10,$81,$1C
$04:D1E8 .db $81,$5C,$03,$1C,$5C,$1C,$10,$83
$04:D1F0 .db $1C,$81,$5C,$81,$1C,$81,$5C,$84
$04:D1F8 .db $10,$08,$50,$10,$50,$90,$D0,$10
$04:D200 .db $50,$10,$50,$81,$1C,$81,$5C,$83
$04:D208 .db $10,$83,$1C,$81,$5C,$81,$1C,$81
$04:D210 .db $5C,$82,$10,$02,$50,$10,$50,$86
$04:D218 .db $10,$00,$50,$81,$1C,$81,$5C,$81
$04:D220 .db $1C,$01,$5C,$10,$83,$1C,$81,$5C
$04:D228 .db $81,$1C,$81,$5C,$82,$10,$02,$50
$04:D230 .db $10,$50,$81,$1C,$81,$5C,$03,$10
$04:D238 .db $50,$10,$50,$81,$1C,$81,$5C,$81
$04:D240 .db $1C,$01,$5C,$10,$83,$1C,$81,$5C
$04:D248 .db $81,$1C,$81,$5C,$82,$10,$02,$50
$04:D250 .db $10,$50,$81,$1C,$81,$5C,$03,$10
$04:D258 .db $50,$10,$50,$81,$1C,$81,$5C,$81
$04:D260 .db $1C,$01,$5C,$10,$83,$1C,$81,$5C
$04:D268 .db $81,$1C,$81,$5C,$82,$10,$02,$50
$04:D270 .db $10,$50,$81,$1C,$81,$5C,$83,$10
$04:D278 .db $81,$1C,$81,$5C,$83,$10,$83,$1C
$04:D280 .db $00,$5C,$81,$1C,$81,$5C,$81,$10
$04:D288 .db $00,$50,$82,$10,$02,$50,$10,$50
$04:D290 .db $81,$10,$09,$50,$10,$14,$54,$10
$04:D298 .db $50,$10,$50,$10,$50,$81,$10,$81
$04:D2A0 .db $1C,$82,$10,$81,$1C,$81,$5C,$81
$04:D2A8 .db $10,$00,$50,$82,$10,$02,$50,$10
$04:D2B0 .db $50,$81,$10,$09,$50,$10,$94,$D4
$04:D2B8 .db $10,$50,$10,$50,$10,$50,$81,$10
$04:D2C0 .db $81,$18,$81,$1C,$81,$5C,$00,$1C
$04:D2C8 .db $81,$5C,$83,$10,$00,$50,$83,$10
$04:D2D0 .db $00,$50,$81,$10,$00,$50,$82,$10
$04:D2D8 .db $00,$50,$81,$1C,$81,$5C,$83,$10
$04:D2E0 .db $81,$1C,$81,$5C,$01,$10,$50,$84
$04:D2E8 .db $10,$00,$50,$81,$10,$02,$50,$10
$04:D2F0 .db $50,$81,$10,$00,$50,$82,$10,$00
$04:D2F8 .db $50,$81,$1C,$81,$5C,$83,$10,$81
$04:D300 .db $1C,$81,$5C,$05,$10,$50,$10,$50
$04:D308 .db $10,$50,$83,$10,$00,$50,$81,$10
$04:D310 .db $00,$50,$81,$10,$00,$50,$81,$1C
$04:D318 .db $81,$5C,$00,$1C,$81,$5C,$81,$10
$04:D320 .db $81,$18,$01,$10,$50,$81,$1C,$81
$04:D328 .db $5C,$03,$10,$50,$10,$50,$81,$1C
$04:D330 .db $81,$5C,$82,$10,$00,$50,$81,$10
$04:D338 .db $00,$50,$81,$1C,$81,$5C,$81,$10
$04:D340 .db $00,$50,$84,$10,$00,$50,$81,$1C
$04:D348 .db $81,$5C,$03,$10,$50,$10,$50,$81
$04:D350 .db $1C,$81,$5C,$03,$10,$50,$10,$50
$04:D358 .db $81,$1C,$81,$5C,$00,$1C,$81,$5C
$04:D360 .db $81,$10,$00,$50,$85,$10,$81,$1C
$04:D368 .db $81,$5C,$03,$10,$50,$10,$50,$81
$04:D370 .db $1C,$81,$5C,$03,$10,$50,$10,$50
$04:D378 .db $81,$1C,$81,$5C,$01,$10,$50,$81
$04:D380 .db $1C,$81,$5C,$85,$10,$00,$50,$82
$04:D388 .db $10,$02,$50,$10,$50,$81,$10,$00
$04:D390 .db $50,$81,$1C,$81,$5C,$81,$10,$81
$04:D398 .db $1C,$81,$5C,$01,$10,$50,$81,$1C
$04:D3A0 .db $81,$5C,$81,$10,$81,$18,$81,$10
$04:D3A8 .db $00,$50,$82,$10,$02,$50,$10,$50
$04:D3B0 .db $81,$10,$00,$50,$81,$1C,$81,$5C
$04:D3B8 .db $01,$10,$50,$81,$1C,$81,$5C,$01
$04:D3C0 .db $10,$50,$81,$1C,$81,$5C,$81,$10
$04:D3C8 .db $81,$18,$00,$10,$81,$1C,$81,$5C
$04:D3D0 .db $81,$10,$81,$1C,$81,$5C,$00,$10
$04:D3D8 .db $81,$1C,$81,$5C,$01,$10,$50,$81
$04:D3E0 .db $1C,$81,$5C,$01,$10,$50,$87,$10
$04:D3E8 .db $83,$14,$00,$50,$83,$10,$82,$50
$04:D3F0 .db $81,$10,$8F,$14,$84,$10,$00,$14
$04:D3F8 .db $81,$10,$00,$14,$82,$10,$82,$14
$04:D400 .db $81,$10,$00,$14,$81,$10,$05,$14
$04:D408 .db $10,$14,$10,$14,$10,$82,$14,$82
$04:D410 .db $10,$81,$90,$A5,$10,$01,$54,$14
$04:D418 .db $83,$10,$01,$54,$14,$83,$10,$01
$04:D420 .db $54,$14,$83,$10,$01,$54,$14,$8B
$04:D428 .db $10,$01,$D4,$94,$83,$10,$01,$D4
$04:D430 .db $94,$83,$10,$01,$D4,$94,$83,$10
$04:D438 .db $01,$D4,$94,$C8,$10,$82,$50,$01
$04:D440 .db $10,$50,$83,$10,$01,$54,$14,$83
$04:D448 .db $10,$01,$54,$14,$83,$10,$01,$54
$04:D450 .db $14,$87,$10,$00,$90,$82,$D0,$01
$04:D458 .db $90,$D0,$83,$10,$01,$D4,$94,$83
$04:D460 .db $10,$01,$D4,$94,$83,$10,$01,$D4
$04:D468 .db $94,$C5,$10,$83,$1C,$00,$14,$88
$04:D470 .db $1C,$01,$18,$58,$81,$1C,$01,$54
$04:D478 .db $14,$89,$1C,$81,$10,$81,$1C,$81
$04:D480 .db $14,$86,$1C,$08,$14,$1C,$18,$10
$04:D488 .db $50,$58,$1C,$D4,$94,$82,$1C,$00
$04:D490 .db $14,$85,$1C,$81,$10,$00,$1C,$82
$04:D498 .db $14,$82,$1C,$01,$54,$14,$82,$1C
$04:D4A0 .db $00,$18,$81,$10,$81,$50,$00,$58
$04:D4A8 .db $8B,$1C,$81,$10,$00,$1C,$82,$14
$04:D4B0 .db $82,$1C,$01,$D4,$94,$82,$1C,$81
$04:D4B8 .db $10,$00,$90,$81,$10,$03,$50,$58
$04:D4C0 .db $1C,$14,$83,$1C,$01,$54,$14,$82
$04:D4C8 .db $1C,$81,$10,$8A,$1C,$00,$18,$82
$04:D4D0 .db $10,$00,$D0,$81,$10,$00,$50,$85
$04:D4D8 .db $1C,$01,$D4,$94,$82,$1C,$81,$10
$04:D4E0 .db $82,$1C,$87,$18,$84,$10,$02,$D0
$04:D4E8 .db $10,$50,$86,$18,$00,$58,$82,$1C
$04:D4F0 .db $81,$10,$02,$54,$14,$1C,$81,$10
$04:D4F8 .db $00,$50,$84,$10,$00,$50,$84,$10
$04:D500 .db $02,$D0,$10,$50,$84,$10,$81,$50
$04:D508 .db $82,$1C,$81,$10,$05,$D4,$94,$1C
$04:D510 .db $10,$90,$D0,$84,$90,$00,$D0,$85
$04:D518 .db $10,$01,$90,$D0,$84,$10,$01,$D0
$04:D520 .db $50,$82,$1C,$81,$10,$82,$1C,$00
$04:D528 .db $50,$87,$10,$00,$18,$83,$10,$00
$04:D530 .db $18,$84,$10,$02,$50,$90,$D0,$83
$04:D538 .db $1C,$81,$10,$04,$1C,$14,$1C,$50
$04:D540 .db $90,$85,$10,$00,$18,$85,$10,$00
$04:D548 .db $18,$82,$10,$03,$50,$90,$D0,$DC
$04:D550 .db $83,$1C,$81,$10,$82,$1C,$02,$50
$04:D558 .db $10,$50,$82,$10,$02,$50,$10,$18
$04:D560 .db $85,$10,$00,$18,$82,$10,$01,$90
$04:D568 .db $D0,$85,$1C,$81,$10,$82,$18,$00
$04:D570 .db $50,$81,$10,$00,$90,$81,$10,$00
$04:D578 .db $D0,$81,$10,$00,$18,$83,$10,$00
$04:D580 .db $18,$81,$10,$06,$90,$D0,$10,$5C
$04:D588 .db $1C,$5C,$1C,$82,$18,$84,$10,$02
$04:D590 .db $50,$10,$50,$88,$10,$00,$50,$83
$04:D598 .db $10,$00,$50,$81,$10,$00,$5C,$82
$04:D5A0 .db $1C,$82,$18,$83,$10,$06,$18,$50
$04:D5A8 .db $10,$D0,$10,$50,$90,$84,$10,$00
$04:D5B0 .db $90,$84,$10,$00,$50,$81,$10,$01
$04:D5B8 .db $50,$9C,$81,$1C,$84,$10,$81,$18
$04:D5C0 .db $01,$10,$50,$81,$10,$01,$50,$90
$04:D5C8 .db $85,$10,$01,$D0,$90,$81,$D0,$85
$04:D5D0 .db $10,$02,$50,$5C,$1C,$82,$18,$82
$04:D5D8 .db $10,$81,$18,$03,$D0,$10,$50,$90
$04:D5E0 .db $85,$10,$01,$D0,$1C,$82,$90,$81
$04:D5E8 .db $D0,$85,$10,$00,$9C,$8F,$10,$05
$04:D5F0 .db $D0,$9C,$DC,$1C,$50,$10,$81,$90
$04:D5F8 .db $00,$10,$81,$D0,$82,$10,$02,$50
$04:D600 .db $10,$50,$87,$10,$01,$90,$D0,$81
$04:D608 .db $10,$00,$D0,$81,$9C,$83,$1C,$00
$04:D610 .db $50,$81,$10,$01,$50,$D0,$81,$10
$04:D618 .db $81,$D0,$03,$10,$D0,$10,$50,$83
$04:D620 .db $10,$00,$18,$84,$10,$02,$D0,$9C
$04:D628 .db $DC,$82,$1C,$00,$5C,$81,$1C,$00
$04:D630 .db $50,$82,$10,$83,$D0,$00,$90,$82
$04:D638 .db $10,$00,$1C,$83,$10,$81,$18,$81
$04:D640 .db $90,$81,$9C,$02,$DC,$1C,$5C,$82
$04:D648 .db $1C,$00,$5C,$81,$1C,$82,$10,$00
$04:D650 .db $50,$83,$10,$00,$50,$81,$90,$01
$04:D658 .db $DC,$1C,$85,$10,$02,$50,$10,$5C
$04:D660 .db $86,$1C,$00,$5C,$81,$1C,$00,$50
$04:D668 .db $86,$10,$00,$50,$81,$10,$81,$1C
$04:D670 .db $89,$10,$00,$50,$96,$10,$81,$14 ; End of tile property stream
$04:D678 .db $00,$C0,$C0,$C0,$30,$C0,$C0,$00 ; Levels $00-$07: byte copied to $7E:D800 (index 0 unused; probably path direction bits)
$04:D680 .db $C0,$20,$30,$C0,$C0,$C0,$C0,$D0 ; Levels $08-$0F
$04:D688 .db $40,$40,$40,$D0,$40,$80,$80,$00 ; Levels $10-$17
$04:D690 .db $00,$00,$00,$40,$00,$80,$20,$80 ; Levels $18-$1F
$04:D698 .db $40,$40,$80,$60,$90,$00,$00,$C0 ; Levels $20-$27
$04:D6A0 .db $00,$00,$00,$C0,$40,$20,$40,$C0 ; Levels $28-$2F
$04:D6A8 .db $E0,$C0,$00,$C0,$00,$00,$C0,$20 ; Levels $30-$37
$04:D6B0 .db $80,$80,$80,$80,$30,$40,$E0,$00 ; Levels $38-$3F
$04:D6B8 .db $40,$E0,$E0,$D0,$70,$FF,$40,$90 ; Levels $40-$47
$04:D6C0 .db $55,$80,$80,$80,$80,$00,$C0,$C0 ; Levels $48-$4F
$04:D6C8 .db $C0,$C0,$40,$00,$80,$A0,$30,$AA ; Levels $50-$57
$04:D6D0 .db $60,$D0,$80,$00,$55,$55,$00,$00 ; Levels $58-$5F
$04:D6D8 .db $AA,$55,$FF,$FF,$00,$00,$00,$00 ; Levels $60-$67
$04:D6E0 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Levels $68-$6F
$04:D6E8 .db $00 ; Level $70
$04:D6E9 C2 30 REP #$30 ; A, X and Y 16-bit
$04:D6EB 64 1C STZ RAM_ScreenBndryYLo ; Layer 1 Y position = 0
$04:D6ED A9 FF FF LDA.W #$FFFF ; \
$04:D6F0 85 4D STA $4D ; } [$4D] = [$4F] = $FFFF (probably invalidates the cached layer 1 update positions)
$04:D6F2 85 4F STA $4F ; /
$04:D6F4 A9 02 02 LDA.W #$0202 ; \
$04:D6F7 85 55 STA $55 ; / [$55]-[$56] = $0202 (purpose unclear)
$04:D6F9 AD D6 0D LDA.W $0DD6 ; \
$04:D6FC 4A LSR ; |
$04:D6FD 4A LSR ; |
$04:D6FE 29 FF 00 AND.W #$00FF ; } X = [$0DD6] / 4 = current player (0 = Mario, 1 = Luigi)
$04:D701 AA TAX ; /
$04:D702 BD 11 1F LDA.W $1F11,X ; \
$04:D705 29 0F 00 AND.W #$000F ; / A = submap the player is on ([$1F11+X] & $0F, 0 = main map)
$04:D708 F0 0A BEQ $D714 ; On the main map: keep Y position 0
$04:D70A A9 20 00 LDA.W #$0020 ; \
$04:D70D 85 47 STA $47 ; / [$47] = $20 (starting value of the row counter for the submap)
$04:D70F A9 00 02 LDA.W #$0200 ; \
$04:D712 85 1C STA RAM_ScreenBndryYLo ; / Layer 1 Y position = $0200 (submap tiles start at row $200)
$04:D714 22 1A 88 05 JSL.L $881A ; Build the layer 1 tilemap row for position [$1C] with the level renderer ($881A)
$04:D718 22 AD 87 00 JSL.L $87AD ; Upload the pending layer 1 tilemap update to VRAM ($87AD)
$04:D71C C2 30 REP #$30 ; A, X and Y 16-bit
$04:D71E E6 47 INC $47 ; Row counter [$47]++
$04:D720 A5 1C LDA RAM_ScreenBndryYLo ; \
$04:D722 18 CLC ; |
$04:D723 69 10 00 ADC.W #$0010 ; } Layer 1 Y position += $10 (next row of map16 blocks)
$04:D726 85 1C STA RAM_ScreenBndryYLo ; /
$04:D728 29 FF 01 AND.W #$01FF ; \
$04:D72B D0 E7 BNE $D714 ; / Loop until the Y position wraps to a multiple of $200 (32 rows)
$04:D72D A5 20 LDA $20 ; \
$04:D72F 85 1C STA RAM_ScreenBndryYLo ; / Layer 1 Y position = [$20] (restore it)
$04:D731 64 47 STZ $47 ; Row counter [$47] = 0
$04:D733 9C 25 19 STZ.W $1925 ; Level mode [$1925] = 0
$04:D736 64 5B STZ RAM_IsVerticalLvl ; Not a vertical level
$04:D738 A9 FF FF LDA.W #$FFFF ; \
$04:D73B 85 4D STA $4D ; } [$4D] = [$4F] = $FFFF (probably invalidates the cached update positions)
$04:D73D 85 4F STA $4F ; /
$04:D73F E2 30 SEP #$30 ; A, X and Y 8-bit
$04:D741 A9 80 LDA.B #$80 ; \
$04:D743 8D 15 21 STA.W $2115 ; / VMAIN = $80: VRAM address increments after high-byte writes
$04:D746 9C 16 21 STZ.W $2116 ; \
$04:D749 A9 30 LDA.B #$30 ; } VRAM address = $3000 (overworld map tilemap)
$04:D74B 8D 17 21 STA.W $2117 ; /
$04:D74E A2 06 LDX.B #$06 ; X = 6: copy 7 bytes
$04:D750 BF B3 DA 04 LDA.L $DAB3,X ; \
$04:D754 9D 10 43 STA.W $4310,X ; |
$04:D757 CA DEX ; } Copy DMA setup from $DAB3 to $4310-$4316: $7F:4000 to VRAM, $2000 bytes
$04:D758 10 F6 BPL $D750 ; /
$04:D75A AD D6 0D LDA.W $0DD6 ; \
$04:D75D 4A LSR ; |
$04:D75E 4A LSR ; } X = [$0DD6] / 4 = current player
$04:D75F AA TAX ; /
$04:D760 BD 11 1F LDA.W $1F11,X ; A = submap the player is on
$04:D763 F0 05 BEQ $D76A ; Main map: keep source address $7F:4000
$04:D765 A9 60 LDA.B #$60 ; \
$04:D767 8D 13 43 STA.W $4313 ; / Submap: DMA source = $7F:6000
$04:D76A A9 02 LDA.B #$02 ; \
$04:D76C 8D 0B 42 STA.W $420B ; / Start DMA channel 1: copy the decompressed map to VRAM $3000
$04:D76F 6B RTL ; Return
$04:D770 9F 00 C8 7F STA.L $7FC800,X ; Table 0: [$7F:C800 + X] = A
$04:D774 9F B0 C9 7F STA.L $7FC9B0,X ; Table 1: [$7F:C9B0 + X] = A
$04:D778 9F 60 CB 7F STA.L $7FCB60,X ; Table 2: [$7F:CB60 + X] = A
$04:D77C 9F 10 CD 7F STA.L $7FCD10,X ; Table 3: [$7F:CD10 + X] = A
$04:D780 9F C0 CE 7F STA.L $7FCEC0,X ; Table 4: [$7F:CEC0 + X] = A
$04:D784 9F 70 D0 7F STA.L $7FD070,X ; Table 5: [$7F:D070 + X] = A
$04:D788 9F 20 D2 7F STA.L $7FD220,X ; Table 6: [$7F:D220 + X] = A
$04:D78C 9F D0 D3 7F STA.L $7FD3D0,X ; Table 7: [$7F:D3D0 + X] = A
$04:D790 9F 80 D5 7F STA.L $7FD580,X ; Table 8: [$7F:D580 + X] = A
$04:D794 9F 30 D7 7F STA.L $7FD730,X ; Table 9: [$7F:D730 + X] = A
$04:D798 9F E0 D8 7F STA.L $7FD8E0,X ; Table 10: [$7F:D8E0 + X] = A
$04:D79C 9F 90 DA 7F STA.L $7FDA90,X ; Table 11: [$7F:DA90 + X] = A
$04:D7A0 9F 40 DC 7F STA.L $7FDC40,X ; Table 12: [$7F:DC40 + X] = A
$04:D7A4 9F F0 DD 7F STA.L $7FDDF0,X ; Table 13: [$7F:DDF0 + X] = A
$04:D7A8 9F A0 DF 7F STA.L $7FDFA0,X ; Table 14: [$7F:DFA0 + X] = A
$04:D7AC 9F 50 E1 7F STA.L $7FE150,X ; Table 15: [$7F:E150 + X] = A
$04:D7B0 9F 00 E3 7F STA.L $7FE300,X ; Table 16: [$7F:E300 + X] = A
$04:D7B4 9F B0 E4 7F STA.L $7FE4B0,X ; Table 17: [$7F:E4B0 + X] = A
$04:D7B8 9F 60 E6 7F STA.L $7FE660,X ; Table 18: [$7F:E660 + X] = A
$04:D7BC 9F 10 E8 7F STA.L $7FE810,X ; Table 19: [$7F:E810 + X] = A
$04:D7C0 9F C0 E9 7F STA.L $7FE9C0,X ; Table 20: [$7F:E9C0 + X] = A
$04:D7C4 9F 70 EB 7F STA.L $7FEB70,X ; Table 21: [$7F:EB70 + X] = A
$04:D7C8 9F 20 ED 7F STA.L $7FED20,X ; Table 22: [$7F:ED20 + X] = A
$04:D7CC 9F D0 EE 7F STA.L $7FEED0,X ; Table 23: [$7F:EED0 + X] = A
$04:D7D0 9F 80 F0 7F STA.L $7FF080,X ; Table 24: [$7F:F080 + X] = A
$04:D7D4 9F 30 F2 7F STA.L $7FF230,X ; Table 25: [$7F:F230 + X] = A
$04:D7D8 9F E0 F3 7F STA.L $7FF3E0,X ; Table 26: [$7F:F3E0 + X] = A
$04:D7DC 9F 90 F5 7F STA.L $7FF590,X ; Table 27: [$7F:F590 + X] = A
$04:D7E0 9F 40 F7 7F STA.L $7FF740,X ; Table 28: [$7F:F740 + X] = A
$04:D7E4 9F F0 F8 7F STA.L $7FF8F0,X ; Table 29: [$7F:F8F0 + X] = A
$04:D7E8 9F A0 FA 7F STA.L $7FFAA0,X ; Table 30: [$7F:FAA0 + X] = A
$04:D7EC 9F 50 FC 7F STA.L $7FFC50,X
$04:D7F0 E8 INX ; X++ (next index)
$04:D7F1 60 RTS ; Return
$04:D7F2 C2 30 REP #$30 ; A, X and Y 16-bit
$04:D7F4 A9 00 00 LDA.W #$0000 ; A = 0 (B stays 0, so the later TAX is clean)
$04:D7F7 E2 20 SEP #$20 ; A 8-bit
$04:D7F9 A9 00 LDA.B #$00 ; \
$04:D7FB 85 0D STA $0D ; |
$04:D7FD A9 D0 LDA.B #$D0 ; |
$04:D7FF 85 0E STA $0E ; |
$04:D801 A9 7E LDA.B #$7E ; } [$0D] = $7E:D000 (24-bit pointer to the level number map)
$04:D803 85 0F STA $0F ; /
$04:D805 A9 00 LDA.B #$00 ; \
$04:D807 85 0A STA $0A ; |
$04:D809 A9 D8 LDA.B #$D8 ; |
$04:D80B 85 0B STA $0B ; |
$04:D80D A9 7E LDA.B #$7E ; } [$0A] = $7E:D800 (24-bit pointer to the per-level byte table)
$04:D80F 85 0C STA $0C ; /
$04:D811 A9 00 LDA.B #$00 ; \
$04:D813 85 04 STA $04 ; |
$04:D815 A9 C8 LDA.B #$C8 ; |
$04:D817 85 05 STA $05 ; |
$04:D819 A9 7E LDA.B #$7E ; } [$04] = $7E:C800 (24-bit pointer to the overworld layer 1 tile numbers)
$04:D81B 85 06 STA $06 ; /
$04:D81D A0 01 00 LDY.W #$0001 ; \
$04:D820 84 00 STY $00 ; / [$00] = 1: first level number to hand out
$04:D822 A0 FF 07 LDY.W #$07FF ; Y = $07FF: clear $800 bytes of each map
$04:D825 A9 00 LDA.B #$00 ; A = 0
$04:D827 97 0A STA [$0A],Y ; Clear byte Y of the per-level byte table ($7E:D800)
$04:D829 97 0D STA [$0D],Y ; Clear byte Y of the level number map ($7E:D000)
$04:D82B 88 DEY ; \
$04:D82C 10 F9 BPL $D827 ; / Y--, loop until Y < 0
$04:D82E A0 00 00 LDY.W #$0000 ; Y = 0: map position
$04:D831 BB TYX ; X = 0
$04:D832 B7 04 LDA [$04],Y ; A = layer 1 tile number at map position Y
$04:D834 C9 56 CMP.B #$56 ; \
$04:D836 90 11 BCC $D849 ; / Tile < $56: not a level tile, skip
$04:D838 C9 81 CMP.B #$81 ; \
$04:D83A B0 0D BCS $D849 ; / Tile >= $81: not a level tile, skip
$04:D83C A5 00 LDA $00 ; A = next level number
$04:D83E 97 0D STA [$0D],Y ; Level number map[Y] = level number
$04:D840 AA TAX ; X = level number
$04:D841 BF 78 D6 04 LDA.L $D678,X ; A = $D678[level number]
$04:D845 97 0A STA [$0A],Y ; Per-level byte table[Y] = A
$04:D847 E6 00 INC $00 ; Next level number
$04:D849 C8 INY ; Next map position
$04:D84A C0 00 08 CPY.W #$0800 ; \
$04:D84D D0 E3 BNE $D832 ; / Loop for all $800 map positions
$04:D84F 64 0F STZ $0F ; [$0F] = 0 (first level)
$04:D851 20 49 DA JSR.W $DA49 ; If level [$0F] is beaten, update its map tiles ($DA49)
$04:D854 E6 0F INC $0F ; Next level
$04:D856 A5 0F LDA $0F ; \
$04:D858 C9 6F CMP.B #$6F ; } Loop for levels $00-$6E
$04:D85A D0 F5 BNE $D851 ; /
$04:D85C 60 RTS ; Return
;;; $D85D..D935: Table: event layer 1 map offsets ;;;
;; $70 words indexed by event number * 2: offset into the layer 1 map at $7E:C800 where the event's path tile
;; lives (0 = none).
$04:D85D .db $00,$00,$00,$00,$00,$00,$69,$04 ; Events $00-$03
$04:D865 .db $4B,$04,$29,$04,$09,$04,$D3,$00 ; Events $04-$07
$04:D86D .db $E5,$00,$A5,$00,$D1,$00,$85,$00 ; Events $08-$0B
$04:D875 .db $A9,$00,$CB,$00,$BD,$00,$9D,$00 ; Events $0C-$0F
$04:D87D .db $A5,$00,$07,$02,$00,$00,$27,$02 ; Events $10-$13
$04:D885 .db $12,$05,$08,$06,$E3,$04,$C8,$04 ; Events $14-$17
$04:D88D .db $2A,$06,$EC,$04,$0C,$06,$1C,$06 ; Events $18-$1B
$04:D895 .db $4A,$06,$00,$00,$E0,$04,$3E,$00 ; Events $1C-$1F
$04:D89D .db $30,$01,$34,$01,$36,$01,$3A,$01 ; Events $20-$23
$04:D8A5 .db $00,$00,$57,$01,$84,$01,$3A,$01 ; Events $24-$27
$04:D8AD .db $00,$00,$00,$00,$AA,$06,$76,$06 ; Events $28-$2B
$04:D8B5 .db $C8,$06,$AC,$06,$76,$06,$00,$00 ; Events $2C-$2F
$04:D8BD .db $00,$00,$A4,$06,$AA,$06,$C4,$06 ; Events $30-$33
$04:D8C5 .db $00,$00,$04,$03,$00,$00,$00,$00 ; Events $34-$37
$04:D8CD .db $79,$05,$77,$05,$59,$05,$74,$05 ; Events $38-$3B
$04:D8D5 .db $00,$00,$54,$05,$00,$00,$34,$05 ; Events $3C-$3F
$04:D8DD .db $00,$00,$00,$00,$00,$00,$00,$00 ; Events $40-$43
$04:D8E5 .db $00,$00,$00,$00,$B3,$03,$00,$00 ; Events $44-$47
$04:D8ED .db $00,$00,$00,$00,$DF,$02,$DC,$02 ; Events $48-$4B
$04:D8F5 .db $00,$00,$7E,$02,$00,$00,$00,$00 ; Events $4C-$4F
$04:D8FD .db $00,$00,$E0,$04,$E0,$04,$00,$00 ; Events $50-$53
$04:D905 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Events $54-$57
$04:D90D .db $00,$00,$00,$00,$34,$05,$34,$05 ; Events $58-$5B
$04:D915 .db $00,$00,$00,$00,$87,$07,$00,$00 ; Events $5C-$5F
$04:D91D .db $F0,$01,$68,$03,$65,$03,$B5,$03 ; Events $60-$63
$04:D925 .db $00,$00,$36,$07,$39,$07,$3C,$07 ; Events $64-$67
$04:D92D .db $1C,$07,$19,$07,$16,$07,$13,$07 ; Events $68-$6B
$04:D935 .db $11,$07,$00,$00,$00,$00,$00,$00 ; Events $6C-$6F
;;; $D93D..DA15: Table: event second map offsets ;;;
;; $70 words indexed by event number * 2, parallel to the previous table. Values are probably offsets into the
;; layer 1 tile buffer; purpose not verified (read by code in the next chunk).
$04:D93D .db $00,$00,$00,$00,$00,$00,$21,$92 ; Events $00-$03
$04:D945 .db $21,$16,$20,$92,$20,$12,$23,$46 ; Events $04-$07
$04:D94D .db $23,$8A,$22,$8A,$23,$42,$22,$0A ; Events $08-$0B
$04:D955 .db $22,$92,$23,$16,$22,$DA,$22,$5A ; Events $0C-$0F
$04:D95D .db $22,$8A,$28,$0E,$00,$00,$28,$8E ; Events $10-$13
$04:D965 .db $24,$04,$28,$10,$23,$86,$23,$10 ; Events $14-$17
$04:D96D .db $28,$94,$23,$98,$28,$18,$28,$58 ; Events $18-$1B
$04:D975 .db $29,$14,$00,$00,$23,$80,$20,$DC ; Events $1C-$1F
$04:D97D .db $24,$C0,$24,$C8,$24,$CC,$24,$D4 ; Events $20-$23
$04:D985 .db $00,$00,$25,$4E,$26,$08,$24,$D4 ; Events $24-$27
$04:D98D .db $00,$00,$00,$00,$2A,$94,$29,$CC ; Events $28-$2B
$04:D995 .db $2B,$10,$2A,$98,$29,$CC,$00,$00 ; Events $2C-$2F
$04:D99D .db $00,$00,$2A,$88,$2A,$94,$2B,$08 ; Events $30-$33
$04:D9A5 .db $00,$00,$2C,$08,$00,$00,$00,$00 ; Events $34-$37
$04:D9AD .db $25,$D2,$25,$CE,$25,$52,$25,$C8 ; Events $38-$3B
$04:D9B5 .db $00,$00,$25,$48,$00,$00,$24,$C8 ; Events $3C-$3F
$04:D9BD .db $00,$00,$00,$00,$00,$00,$00,$00 ; Events $40-$43
$04:D9C5 .db $00,$00,$00,$00,$2E,$C6,$00,$00 ; Events $44-$47
$04:D9CD .db $00,$00,$00,$00,$2B,$5E,$2B,$58 ; Events $48-$4B
$04:D9D5 .db $00,$00,$29,$DC,$00,$00,$00,$00 ; Events $4C-$4F
$04:D9DD .db $00,$00,$23,$80,$23,$80,$00,$00 ; Events $50-$53
$04:D9E5 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Events $54-$57
$04:D9ED .db $00,$00,$00,$00,$24,$C8,$24,$C8 ; Events $58-$5B
$04:D9F5 .db $00,$00,$00,$00,$2E,$0E,$00,$00 ; Events $5C-$5F
$04:D9FD .db $27,$C0,$2D,$90,$2D,$8A,$2E,$CA ; Events $60-$63
$04:DA05 .db $00,$00,$2C,$CC,$2C,$D2,$2C,$D8 ; Events $64-$67
$04:DA0D .db $2C,$58,$2C,$52,$2C,$4C,$2C,$46 ; Events $68-$6B
$04:DA15 .db $2C,$42,$00,$00,$00,$00,$00,$00 ; Events $6C-$6F
;;; $DA1D..DA2D: Table: tiles replaced by events ;;;
;; 22 layer 1 tile numbers that DA49 recognises; entry n is replaced by entry n of the next table.
$04:DA1D .db $6E,$6F,$70,$71,$72,$73,$74,$75 ; Old tiles, entries $00-$07
$04:DA25 .db $59,$53,$52,$83,$4D,$57,$5A,$76 ; Old tiles, entries $08-$0F
$04:DA2D .db $78,$7A,$7B,$7D,$7F,$54 ; Old tiles, entries $10-$15
;;; $DA33..DA43: Table: replacement tiles for events ;;;
;; Replacement tile for each entry of the previous table.
$04:DA33 .db $66,$67,$68,$69,$6A,$6B,$6C,$6D ; New tiles, entries $00-$07
$04:DA3B .db $58,$43,$44,$45,$25,$5E,$5F,$77 ; New tiles, entries $08-$0F
$04:DA43 .db $79,$63,$7C,$7E,$80,$23 ; New tiles, entries $10-$15
;;; $DA49: Apply completed event to layer 1 map ;;;
;; If event [$0F] is flagged complete in [$1F02+], swaps the tile at its layer 1 map offset ($D85D) for
;; the matching $DA33 tile.
;; If the match was table entry $15 the next tile is replaced as well. Then runs $E677 and $E9F1
;; for the event (path/tile setup), with [$1B86] = 0.
;; Parameters: [$0F]: event number. $04DAAD: long wrapper (PHP/PLP) around $DC6A, called from bank $00.
;; Called by:
;; $04:D851: Level names, OW border, OW map setup (LevelNames)
$04:DA49 C2 30 REP #$30 ; \
$04:DA4B A5 0F LDA $0F ; |
$04:DA4D 29 F8 00 AND.W #$00F8 ; |
$04:DA50 4A LSR ; |
$04:DA51 4A LSR ; |
$04:DA52 4A LSR ; |
$04:DA53 A8 TAY ; } Y = [$0F] / 8: byte index into the event flags
$04:DA54 A5 0F LDA $0F ; \
$04:DA56 29 07 00 AND.W #$0007 ; |
$04:DA59 AA TAX ; / X = [$0F] AND 7: bit number
$04:DA5A E2 20 SEP #$20 ; A 8-bit
$04:DA5C B9 02 1F LDA.W $1F02,Y ; \
$04:DA5F 3F 4B E4 04 AND.L $E44B,X ; } Test the event's flag in [$1F02+Y]
$04:DA63 F0 47 BEQ $DAAC ; Event not complete: return
$04:DA65 C2 20 REP #$20 ; A 16-bit
$04:DA67 A9 00 C8 LDA.W #$C800 ; \
$04:DA6A 85 04 STA $04 ; / [$04]/[$05] = $C800, pointer to layer 1 map at $7E:C800
$04:DA6C A5 0F LDA $0F ; \
$04:DA6E 29 FF 00 AND.W #$00FF ; |
$04:DA71 0A ASL ; |
$04:DA72 AA TAX ; } X = [$0F] * 2
$04:DA73 BF 5D D8 04 LDA.L $D85D,X ; \
$04:DA77 A8 TAY ; / Y = offset of the event's tile in the layer 1 map
$04:DA78 A2 15 00 LDX.W #$0015 ; X = $15: search the replace table from the end
$04:DA7B E2 20 SEP #$20 ; A 8-bit
$04:DA7D A9 7E LDA.B #$7E ; \
$04:DA7F 85 06 STA $06 ; / [$06] = $7E: bank of the map pointer
$04:DA81 B7 04 LDA [$04],Y ; Load the tile
$04:DA83 DF 1D DA 04 CMP.L $DA1D,X ; Is it in DATA_04DA1D?
$04:DA87 F0 06 BEQ $DA8F ; Yes: replace it
$04:DA89 CA DEX ; \
$04:DA8A 10 F7 BPL $DA83 ; / Try the next table entry
$04:DA8C 4C 9D DA JMP.W $DA9D ; Not found: skip replacing
$04:DA8F BF 33 DA 04 LDA.L $DA33,X ; Replacement tile for table entry X
$04:DA93 97 04 STA [$04],Y ; Store it in the layer 1 map
$04:DA95 E0 15 00 CPX.W #$0015 ; \
$04:DA98 D0 03 BNE $DA9D ; / Entry $15 only: also replace the next tile
$04:DA9A C8 INY ; \
$04:DA9B 97 04 STA [$04],Y ; / Store the same tile in the next map position
$04:DA9D A5 0F LDA $0F ; \
$04:DA9F 20 77 E6 JSR.W $E677 ; / Set up the event's path tiles ($E677)
$04:DAA2 E2 10 SEP #$10 ; A 8-bit, X and Y 8-bit
$04:DAA4 9C 86 1B STZ.W $1B86 ; [$1B86] = 0
$04:DAA7 A5 0F LDA $0F ; \
$04:DAA9 20 F1 E9 JSR.W $E9F1 ; / Finish setting up the event ($E9F1)
$04:DAAC 60 RTS ; Return
$04:DAAD 08 PHP ; Save flags
$04:DAAE 20 6A DC JSR.W $DC6A ; Load layer 2 map and apply completed events
$04:DAB1 28 PLP ; Restore flags
$04:DAB2 6B RTL ; Return long
;;; $DAB3..DAB3: Table: DMA setup for layer 2 tilemap ;;;
;; 7 bytes copied to $4310-$4316: DMAP $01, B-bus $18, source $7F:4000, size $2000 (source high byte becomes
;; $60 for submaps other than 0).
$04:DAB3 .db $01,$18,$00,$40,$7F,$00,$20 ; DMAP $01, B-bus $18, source $7F:4000, size $2000
;;; $DABA: Decompress interleaved map; submap switch entry ;;;
;; $04DABA: RLE decompressor writing every other byte of $7F:4000+X. Header byte: bit 7 clear = copy (n+1)
;; literal bytes, set = repeat next byte (n AND $7F)+1 times.
;; Parameters: [$00]-[$02]: source pointer, Y: source offset, X: first dest offset, [$0E]: stop when X >=
;; this.
;; $04DAEF: overworld submap switch state machine entry, dispatches on [$1DE8].
;; Called by:
;; $04:DC87: Load all layers of overworld map
;; $04:DC99: Load all layers of overworld map
$04:DABA E2 20 SEP #$20 ; \
$04:DABC C2 10 REP #$10 ; / A 8-bit, X and Y 16-bit
$04:DABE B7 00 LDA [$00],Y ; \
$04:DAC0 85 03 STA $03 ; |
$04:DAC2 29 80 AND.B #$80 ; |
$04:DAC4 D0 10 BNE $DAD6 ; } [$03] = header byte; bit 7 set means repeat
$04:DAC6 C8 INY ; Y++ (skip header)
$04:DAC7 B7 00 LDA [$00],Y ; \
$04:DAC9 9F 00 40 7F STA.L $7F4000,X ; / Copy literal byte to $7F:4000+X
$04:DACD E8 INX ; \
$04:DACE E8 INX ; / X += 2 (every other byte)
$04:DACF C6 03 DEC $03 ; \
$04:DAD1 10 F3 BPL $DAC6 ; / Repeat (count + 1) times
$04:DAD3 4C E9 DA JMP.W $DAE9 ; Done with this run
$04:DAD6 A5 03 LDA $03 ; \
$04:DAD8 29 7F AND.B #$7F ; |
$04:DADA 85 03 STA $03 ; } [$03] = repeat count - 1
$04:DADC C8 INY ; Y++ (skip header)
$04:DADD B7 00 LDA [$00],Y ; Fetch the byte to repeat
$04:DADF 9F 00 40 7F STA.L $7F4000,X ; Store it at $7F:4000+X
$04:DAE3 E8 INX ; \
$04:DAE4 E8 INX ; / X += 2
$04:DAE5 C6 03 DEC $03 ; \
$04:DAE7 10 F6 BPL $DADF ; / Repeat until the count underflows
$04:DAE9 C8 INY ; Y++ (next header or data)
$04:DAEA E4 0E CPX $0E ; \
$04:DAEC 90 CC BCC $DABA ; / Continue until X >= [$0E]
$04:DAEE 60 RTS ; Return
$04:DAEF E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DAF1 AD E8 1D LDA.W $1DE8 ; \
$04:DAF4 22 DF 86 00 JSL.L ExecutePtr ; } Run the state for [$1DE8]
;;; $DAF8: Submap switch states and iris effect (Ptrs04DAF8) ;;;
;; Pointers by [$1DE8]: 0 and 6 = iris window close/open ($DB18), 1-4 = redraw layer 1 pages
;; ($DCB6), 5 = load tileset ($DB9D), 7 = finish ($DBCF).
;; DB18: moves a box-shaped window ([$1B8D]/[$1B8F] steps, limits from the tables at DB08-DB14), fills the
;; HDMA table at $0598/$04EE with its left/right edges, sets window masks [$41]/[$43], enables HDMA ch 7.
;; When the close finishes, $9A93 switches the player's submap. DB9D: sets Mario Start tileset [$1931]
;; for the new submap and reloads graphics.
$04:DAF8 18 DB .dw $DB18 ; 0 - Iris closes
$04:DAFA B6 DC .dw $DCB6 ; 1 - Draw layer 1 page 0
$04:DAFC B6 DC .dw $DCB6 ; 2 - Draw layer 1 page 1
$04:DAFE B6 DC .dw $DCB6 ; 3 - Draw layer 1 page 2
$04:DB00 B6 DC .dw $DCB6 ; 4 - Draw layer 1 page 3
$04:DB02 9D DB .dw $DB9D ; 5 - Load tileset and graphics
$04:DB04 18 DB .dw $DB18 ; 6 - Iris opens
$04:DB06 CF DB .dw $DBCF ; 7 - Finish, change music
$04:DB08 .db $00,$F9,$00,$07 ; Window box width step per frame (X = 0: close, X = 2: open)
$04:DB0C .db $00,$00,$00,$70 ; Window box width limit
$04:DB10 .db $C0,$FA,$40,$05 ; Window box height step per frame
$04:DB14 .db $00,$00,$00,$54 ; Window box height limit
$04:DB18 C2 20 REP #$20 ; A 16-bit
$04:DB1A AE 8C 1B LDX.W $1B8C ; X = [$1B8C]: 0 closing, 2 opening
$04:DB1D AD 8D 1B LDA.W $1B8D ; \
$04:DB20 18 CLC ; |
$04:DB21 7D 08 DB ADC.W $DB08,X ; |
$04:DB24 8D 8D 1B STA.W $1B8D ; } [$1B8D] += width step
$04:DB27 38 SEC ; \
$04:DB28 FD 0C DB SBC.W $DB0C,X ; |
$04:DB2B 5D 08 DB EOR.W $DB08,X ; } Has [$1B8D] reached its limit?
$04:DB2E 10 13 BPL $DB43 ; Not yet: leave the height alone
$04:DB30 AD 8F 1B LDA.W $1B8F ; \
$04:DB33 18 CLC ; |
$04:DB34 7D 10 DB ADC.W $DB10,X ; |
$04:DB37 8D 8F 1B STA.W $1B8F ; } [$1B8F] += height step
$04:DB3A 38 SEC ; \
$04:DB3B FD 14 DB SBC.W $DB14,X ; |
$04:DB3E 5D 10 DB EOR.W $DB10,X ; } Has [$1B8F] reached its limit?
$04:DB41 30 1C BMI $DB5F ; Not yet: draw the window
$04:DB43 BD 0C DB LDA.W $DB0C,X ; \
$04:DB46 8D 8D 1B STA.W $1B8D ; / Clamp [$1B8D] to its limit
$04:DB49 BD 14 DB LDA.W $DB14,X ; \
$04:DB4C 8D 8F 1B STA.W $1B8F ; / Clamp [$1B8F] to its limit
$04:DB4F EE E8 1D INC.W $1DE8 ; Next submap switch state
$04:DB52 8A TXA ; \
$04:DB53 49 02 00 EOR.W #$0002 ; |
$04:DB56 AA TAX ; } Toggle [$1B8C] between 0 and 2
$04:DB57 8E 8C 1B STX.W $1B8C ; Save it
$04:DB5A F0 03 BEQ $DB5F ; Now 0: nothing more to do
$04:DB5C 20 93 9A JSR.W $9A93 ; Closed: switch the player's submap ($9A93)
$04:DB5F E2 20 SEP #$20 ; A 8-bit
$04:DB61 AD 90 1B LDA.W $1B90 ; \
$04:DB64 0A ASL ; / [$00] = [$1B90] * 2: box half-height in table bytes
$04:DB65 85 00 STA $00 ; Store it
$04:DB67 AD 8E 1B LDA.W $1B8E ; \
$04:DB6A 18 CLC ; |
$04:DB6B 69 80 ADC.B #$80 ; } Right edge = $80 + [$1B8E], into the high byte
$04:DB6D EB XBA ; Swap
$04:DB6E A9 80 LDA.B #$80 ; \
$04:DB70 38 SEC ; |
$04:DB71 ED 8E 1B SBC.W $1B8E ; } Left edge = $80 - [$1B8E]
$04:DB74 C2 20 REP #$20 ; A 16-bit: A = right edge, left edge
$04:DB76 A2 00 LDX.B #$00 ; X = 0: line offset from the top
$04:DB78 A0 A8 LDY.B #$A8 ; Y = $A8: line offset from the bottom
$04:DB7A E4 00 CPX $00 ; \
$04:DB7C 90 03 BCC $DB81 ; / Beyond the box height?
$04:DB7E A9 FF 00 LDA.W #$00FF ; Yes: empty window (left $FF, right $00)
$04:DB81 99 EE 04 STA.W $04EE,Y ; \
$04:DB84 9D 98 05 STA.W $0598,X ; } Write edges to the bottom table ($04EE+Y) and the top table ($0598+X)
$04:DB87 E8 INX ; \
$04:DB88 E8 INX ; |
$04:DB89 88 DEY ; |
$04:DB8A 88 DEY ; / X += 2, Y -= 2
$04:DB8B D0 ED BNE $DB7A ; Loop over all lines
$04:DB8D E2 20 SEP #$20 ; A 8-bit
$04:DB8F A9 33 LDA.B #$33 ; \
$04:DB91 85 41 STA $41 ; / Window 1 enabled on BG1 and BG2 [$41] = $33
$04:DB93 A9 33 LDA.B #$33 ; \
$04:DB95 85 43 STA $43 ; / Window mask for OBJ and color [$43] = $33
$04:DB97 A9 80 LDA.B #$80 ; \
$04:DB99 8D 9F 0D STA.W $0D9F ; / Enable HDMA channel 7 (window table)
$04:DB9C 60 RTS ; Return
$04:DB9D AD D6 0D LDA.W $0DD6 ; \
$04:DBA0 4A LSR ; |
$04:DBA1 4A LSR ; |
$04:DBA2 AA TAX ; } X = current player
$04:DBA3 BD 11 1F LDA.W $1F11,X ; \
$04:DBA6 AA TAX ; / X = current player's submap
$04:DBA7 BF 02 DC 04 LDA.L $DC02,X ; \
$04:DBAB 8D 31 19 STA.W $1931 ; / Mario Start tileset for the submap
$04:DBAE 22 94 A5 00 JSL.L $A594 ; Reload graphics ($A594)
$04:DBB2 A9 FE LDA.B #$FE ; \
$04:DBB4 8D 03 07 STA.W $0703 ; / [$0703] = $FE
$04:DBB7 A9 01 LDA.B #$01 ; \
$04:DBB9 8D 04 07 STA.W $0704 ; / [$0704] = $01 (probably background color mirror $01FE)
$04:DBBC 9C 03 08 STZ.W $0803 ; [$0803] = 0
$04:DBBF A9 06 LDA.B #$06 ; \
$04:DBC1 8D 80 06 STA.W $0680 ; / [$0680] = 6
$04:DBC4 EE E8 1D INC.W $1DE8 ; Next submap switch state
$04:DBC7 60 RTS ; Return
;;; $DBC8..DBC8: Table: music per submap ;;;
;; One music number per submap, written to [$1DFB].
$04:DBC8 .db $02,$03,$04,$06,$07,$09,$05 ; Music per submap
;;; $DBCF: Submap switch: finish and change music ;;;
;; Resets [$1DE8] to 0, sets overworld process [$13D9] = 4. Starts the new submap's music unless two players
;; share the same submap and the music is already playing.
$04:DBCF 9C E8 1D STZ.W $1DE8 ; Reset submap switch state
$04:DBD2 A9 04 LDA.B #$04 ; \
$04:DBD4 8D D9 13 STA.W $13D9 ; / Overworld process [$13D9] = 4 (normal)
$04:DBD7 AD D6 0D LDA.W $0DD6 ; \
$04:DBDA 4A LSR ; |
$04:DBDB 4A LSR ; |
$04:DBDC A8 TAY ; } Y = current player
$04:DBDD AD B2 0D LDA.W $0DB2 ; \
$04:DBE0 F0 11 BEQ $DBF3 ; / Single player: change music
$04:DBE2 AD 9E 1B LDA.W $1B9E ; \
$04:DBE5 D0 0C BNE $DBF3 ; / [$1B9E] non-zero: change music
$04:DBE7 98 TYA ; \
$04:DBE8 49 01 EOR.B #$01 ; |
$04:DBEA AA TAX ; } X = other player
$04:DBEB B9 11 1F LDA.W $1F11,Y ; \
$04:DBEE DD 11 1F CMP.W $1F11,X ; |
$04:DBF1 F0 0E BEQ $DC01 ; } Same submap as the other player: keep the music
$04:DBF3 B9 11 1F LDA.W $1F11,Y ; \
$04:DBF6 AA TAX ; / X = this player's submap
$04:DBF7 BF C8 DB 04 LDA.L $DBC8,X ; \
$04:DBFB 8D FB 1D STA.W $1DFB ; / Request the submap's music
$04:DBFE 9C 9E 1B STZ.W $1B9E ; [$1B9E] = 0
$04:DC01 60 RTS ; Return
;;; $DC02..DC02: Table: Mario Start tileset per submap ;;;
;; Value stored in [$1931] for each submap (tileset $11-$17).
$04:DC02 .db $11,$12,$13,$14,$15,$16,$17 ; Mario Start tileset per submap
;;; $DC09: Load all layers of overworld map ;;;
;; Long routine (JSL) used when the overworld or Mario Start is loaded. Selects the tileset for the current
;; player's submap, clears the $7F:C800 attribute tables, builds the pointer table at $0FBE, copies the layer
;; 1 map from $0C:F7DF to $7E:C800, indexes event tiles ($D7F2).
;; $04DC6A: loads layer 2: decompresses the layer 2 tile data and then applies every completed event to it.
;; Called by:
;; $00:96E5: Game mode 11: Mario Start, level music (MarioStartGameMode)
;; $00:A126: Game mode 0C: load overworld (LoadMapGameMode)
$04:DC09 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DC0B AD D6 0D LDA.W $0DD6 ; \
$04:DC0E 4A LSR ; |
$04:DC0F 4A LSR ; |
$04:DC10 AA TAX ; } X = current player
$04:DC11 BD 11 1F LDA.W $1F11,X ; \
$04:DC14 AA TAX ; / X = current submap
$04:DC15 BF 02 DC 04 LDA.L $DC02,X ; \
$04:DC19 8D 31 19 STA.W $1931 ; / Set the tileset for this submap
$04:DC1C A9 11 LDA.B #$11 ; \
$04:DC1E 8D 2B 19 STA.W $192B ; / Sprite graphics set [$192B] = $11
$04:DC21 A9 07 LDA.B #$07 ; \
$04:DC23 8D 25 19 STA.W $1925 ; / [$1925] = 7 (overworld level mode)
$04:DC26 A9 03 LDA.B #$03 ; \
$04:DC28 85 5B STA RAM_IsVerticalLvl ; / Level mode flag = 3
$04:DC2A C2 10 REP #$10 ; X and Y 16-bit
$04:DC2C A2 00 00 LDX.W #$0000 ; X = 0
$04:DC2F 8A TXA ; A = 0
$04:DC30 20 70 D7 JSR.W $D770 ; Clear byte X of the 32 tables at $7F:C800+n*$1B0 ($D770)
$04:DC33 E0 B0 01 CPX.W #$01B0 ; \
$04:DC36 D0 F8 BNE $DC30 ; / Loop for $1B0 bytes
$04:DC38 C2 30 REP #$30 ; A, X and Y 16-bit
$04:DC3A A9 00 D0 LDA.W #$D000 ; \
$04:DC3D 85 00 STA $00 ; / [$00] = $D000
$04:DC3F A2 00 00 LDX.W #$0000 ; X = 0
$04:DC42 A5 00 LDA $00 ; \
$04:DC44 9D BE 0F STA.W $0FBE,X ; / Pointer to tile definition at $0FBE+X
$04:DC47 A5 00 LDA $00 ; \
$04:DC49 18 CLC ; |
$04:DC4A 69 08 00 ADC.W #$0008 ; |
$04:DC4D 85 00 STA $00 ; } Next tile definition: [$00] += 8
$04:DC4F E8 INX ; \
$04:DC50 E8 INX ; / X += 2
$04:DC51 E0 00 04 CPX.W #$0400 ; \
$04:DC54 D0 EC BNE $DC42 ; / Repeat for 512 tiles
$04:DC56 8B PHB ; Save data bank
$04:DC57 A9 FF 07 LDA.W #$07FF ; \
$04:DC5A A2 DF F7 LDX.W #$F7DF ; |
$04:DC5D A0 00 C8 LDY.W #$C800 ; |
$04:DC60 54 7E 0C MVN $7E,$0C ; } Copy $0800 bytes from $0C:F7DF to $7E:C800 (layer 1 map)
$04:DC63 AB PLB ; Restore data bank
$04:DC64 20 F2 D7 JSR.W $D7F2 ; Index event tiles ($D7F2)
$04:DC67 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DC69 6B RTL ; Return long
$04:DC6A E2 30 SEP #$30 ; \
$04:DC6C 20 40 DD JSR.W $DD40 ; / Decompress layer 2 attributes to $7F:0000 ($DD40)
$04:DC6F C2 20 REP #$20 ; A 16-bit
$04:DC71 A9 33 A5 LDA.W #$A533 ; \
$04:DC74 85 00 STA $00 ; / [$00] = $A533
$04:DC76 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DC78 A9 04 LDA.B #$04 ; \
$04:DC7A 85 02 STA $02 ; / [$02] = $04: source is $04:A533 (layer 2 tile numbers)
$04:DC7C C2 10 REP #$10 ; X and Y 16-bit
$04:DC7E A0 00 40 LDY.W #$4000 ; \
$04:DC81 84 0E STY $0E ; / [$0E] = $4000: stop here
$04:DC83 A0 00 00 LDY.W #$0000 ; \
$04:DC86 BB TYX ; / Y = X = 0
$04:DC87 20 BA DA JSR.W $DABA ; Decompress to the even bytes of $7F:4000
$04:DC8A C2 20 REP #$20 ; A 16-bit
$04:DC8C A9 2B C0 LDA.W #$C02B ; \
$04:DC8F 85 00 STA $00 ; / [$00] = $C02B: source $04:C02B (layer 2 properties)
$04:DC91 E2 20 SEP #$20 ; A 8-bit
$04:DC93 A2 01 00 LDX.W #$0001 ; X = 1: odd bytes
$04:DC96 A0 00 00 LDY.W #$0000 ; Y = 0
$04:DC99 20 BA DA JSR.W $DABA ; Decompress to the odd bytes of $7F:4000
$04:DC9C E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DC9E A9 00 LDA.B #$00 ; \
$04:DCA0 85 0F STA $0F ; / Start with event 0
$04:DCA2 20 53 E4 JSR.W $E453 ; Apply this event to layer 2 if complete ($E453)
$04:DCA5 E6 0F INC $0F ; Next event
$04:DCA7 A5 0F LDA $0F ; \
$04:DCA9 C9 6F CMP.B #$6F ; |
$04:DCAB D0 F5 BNE $DCA2 ; } Loop for events 0 to $6E
$04:DCAD 60 RTS ; Return
;;; $DCAE..DCAE: Table: bit masks 80 to 01 ;;;
;; Bit masks for event flags. Probably an unused duplicate of $E44B.
$04:DCAE .db $80,$40,$20,$10,$08,$04,$02,$01 ; Bit masks
;;; $DCB6: Draw layer 1 map page to tilemap buffer ;;;
;; Submap switch states 1-4. Expands 256 map16 tiles of the layer 1 map into 8x8 tiles in the tilemap buffer
;; $7E:E400. Page = [$1DE8] - 1 (plus 4 if the player's submap is not 0).
;; $04DD40/$04DD57: RLE decompressor used to unpack the layer 2 attribute data from $0C:8D00 to $7F:0000
;; (header bit 7 set = repeat; ends at a $FFFF word).
$04:DCB6 08 PHP ; Save flags
$04:DCB7 C2 10 REP #$10 ; \
$04:DCB9 E2 20 SEP #$20 ; / X and Y 16-bit, A 8-bit
$04:DCBB A2 00 D0 LDX.W #$D000 ; \
$04:DCBE 86 65 STX $65 ; / [$65] = $D000
$04:DCC0 A9 05 LDA.B #$05 ; \
$04:DCC2 85 67 STA $67 ; / [$67] = $05 (placeholder bank)
$04:DCC4 A2 00 00 LDX.W #$0000 ; \
$04:DCC7 86 00 STX $00 ; / [$00] = 0: tile counter
$04:DCC9 AD E8 1D LDA.W $1DE8 ; \
$04:DCCC 3A DEC A ; |
$04:DCCD 85 01 STA $01 ; } [$01] = [$1DE8] - 1: map page
$04:DCCF C2 20 REP #$20 ; A 16-bit
$04:DCD1 AD D6 0D LDA.W $0DD6 ; \
$04:DCD4 4A LSR ; |
$04:DCD5 4A LSR ; |
$04:DCD6 29 FF 00 AND.W #$00FF ; |
$04:DCD9 AA TAX ; } X = current player
$04:DCDA E2 20 SEP #$20 ; A 8-bit
$04:DCDC BD 11 1F LDA.W $1F11,X ; \
$04:DCDF F0 07 BEQ $DCE8 ; / Submap 0: keep the page
$04:DCE1 A5 01 LDA $01 ; \
$04:DCE3 18 CLC ; |
$04:DCE4 69 04 ADC.B #$04 ; |
$04:DCE6 85 01 STA $01 ; } Other submap: page += 4
$04:DCE8 A6 00 LDX $00 ; X = map index (page * 256 + counter)
$04:DCEA BF 00 C8 7E LDA.L $7EC800,X ; \
$04:DCEE 85 02 STA $02 ; / [$02] = tile number from $7E:C800
$04:DCF0 C2 20 REP #$20 ; A 16-bit
$04:DCF2 BF 00 C8 7F LDA.L $7FC800,X ; \
$04:DCF6 85 03 STA $03 ; / [$03] = tile high bit from $7F:C800
$04:DCF8 A5 02 LDA $02 ; \
$04:DCFA 0A ASL ; |
$04:DCFB 0A ASL ; |
$04:DCFC 0A ASL ; |
$04:DCFD A8 TAY ; } Y = tile * 8: offset of its four 8x8 tiles
$04:DCFE A5 00 LDA $00 ; \
$04:DD00 29 FF 00 AND.W #$00FF ; |
$04:DD03 0A ASL ; |
$04:DD04 0A ASL ; } A = (counter AND $FF) * 4
$04:DD05 48 PHA ; \
$04:DD06 29 3F 00 AND.W #$003F ; |
$04:DD09 85 02 STA $02 ; } [$02] = column byte offset
$04:DD0B 68 PLA ; \
$04:DD0C 0A ASL ; |
$04:DD0D 29 80 0F AND.W #$0F80 ; |
$04:DD10 05 02 ORA $02 ; } Add row offset
$04:DD12 AA TAX ; X = tilemap byte offset in $7E:E400
$04:DD13 B7 65 LDA [$65],Y ; \
$04:DD15 9F 00 E4 7E STA.L $7EE400,X ; / Top left 8x8 tile
$04:DD19 C8 INY ; \
$04:DD1A C8 INY ; |
$04:DD1B B7 65 LDA [$65],Y ; |
$04:DD1D 9F 40 E4 7E STA.L $7EE440,X ; } Bottom left tile (next tile row, +$40)
$04:DD21 C8 INY ; \
$04:DD22 C8 INY ; |
$04:DD23 B7 65 LDA [$65],Y ; |
$04:DD25 9F 02 E4 7E STA.L $7EE402,X ; } Top right tile (+2)
$04:DD29 C8 INY ; \
$04:DD2A C8 INY ; |
$04:DD2B B7 65 LDA [$65],Y ; |
$04:DD2D 9F 42 E4 7E STA.L $7EE442,X ; } Bottom right tile (+$42)
$04:DD31 E2 20 SEP #$20 ; A 8-bit
$04:DD33 E6 00 INC $00 ; Next tile
$04:DD35 A5 00 LDA $00 ; \
$04:DD37 29 FF AND.B #$FF ; |
$04:DD39 D0 AD BNE $DCE8 ; } Loop for 256 tiles
$04:DD3B EE E8 1D INC.W $1DE8 ; Next submap switch state
$04:DD3E 28 PLP ; Restore flags
$04:DD3F 60 RTS ; Return
$04:DD40 C2 10 REP #$10 ; \
$04:DD42 E2 20 SEP #$20 ; / X and Y 16-bit, A 8-bit
$04:DD44 A0 00 8D LDY.W #$8D00 ; \
$04:DD47 84 02 STY $02 ; / [$02] = $8D00
$04:DD49 A9 0C LDA.B #$0C ; \
$04:DD4B 85 04 STA $04 ; / [$04] = $0C: source is $0C:8D00
$04:DD4D A2 00 00 LDX.W #$0000 ; \
$04:DD50 9B TXY ; / X = Y = 0
$04:DD51 20 57 DD JSR.W $DD57 ; Decompress to $7F:0000
$04:DD54 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:DD56 60 RTS ; Return
$04:DD57 E2 20 SEP #$20 ; A 8-bit
$04:DD59 B7 02 LDA [$02],Y ; \
$04:DD5B C8 INY ; |
$04:DD5C 85 05 STA $05 ; |
$04:DD5E 29 80 AND.B #$80 ; } [$05] = header byte
$04:DD60 D0 0F BNE $DD71 ; Bit 7 set: repeat
$04:DD62 B7 02 LDA [$02],Y ; \
$04:DD64 9F 00 00 7F STA.L $7F0000,X ; / Copy a literal byte
$04:DD68 C8 INY ; \
$04:DD69 E8 INX ; / Y++, X++
$04:DD6A C6 05 DEC $05 ; \
$04:DD6C 10 F4 BPL $DD62 ; / Repeat (count + 1) times
$04:DD6E 4C 83 DD JMP.W $DD83 ; Run done
$04:DD71 A5 05 LDA $05 ; \
$04:DD73 29 7F AND.B #$7F ; |
$04:DD75 85 05 STA $05 ; } [$05] = repeat count - 1
$04:DD77 B7 02 LDA [$02],Y ; Fetch the byte to repeat
$04:DD79 9F 00 00 7F STA.L $7F0000,X ; Store it at $7F:0000+X
$04:DD7D E8 INX ; X++
$04:DD7E C6 05 DEC $05 ; \
$04:DD80 10 F7 BPL $DD79 ; / Repeat until the count underflows
$04:DD82 C8 INY ; Skip the repeated byte
$04:DD83 C2 20 REP #$20 ; A 16-bit
$04:DD85 B7 02 LDA [$02],Y ; \
$04:DD87 C9 FF FF CMP.W #$FFFF ; |
$04:DD8A D0 CB BNE $DD57 ; } Loop until the next word is $FFFF
$04:DD8C 60 RTS ; Return
; Ending early because the next part is a big table
;;; $DD8D..E357: Table: layer 2 block copies for events ;;;
;; 4-byte records: source offset (into $0C:8000 tile numbers and $7F:0000 attributes), destination offset into
;; the $7F:4000 layer 2 tilemap. Selected per event via $E359. A source offset >= $0900 means a 2x2
;; block, otherwise 6x6.
$04:DD8D .db $00,$09
$04:DD8F .db $CC,$23,$04,$09,$8C,$23,$08,$09
$04:DD97 .db $4E,$23,$0C,$09,$0E,$23,$10,$09
$04:DD9F .db $D0,$22,$14,$09,$90,$22,$8C,$01
$04:DDA7 .db $02,$22,$B0,$01,$02,$22,$D4,$01
$04:DDAF .db $02,$22,$44,$0A,$C6,$21,$48,$0A
$04:DDB7 .db $44,$20,$4C,$0A,$86,$21,$48,$0A
$04:DDBF .db $04,$20,$00,$09,$E4,$23,$38,$09
$04:DDC7 .db $A4,$23,$28,$09,$24,$23,$18,$09
$04:DDCF .db $26,$23,$1C,$09,$28,$23,$20,$09
$04:DDD7 .db $EC,$22,$24,$09,$AC,$22,$0C,$0B
$04:DDDF .db $2C,$22,$10,$0B,$EC,$21,$30,$09
$04:DDE7 .db $6C,$21,$34,$09,$68,$21,$38,$09
$04:DDEF .db $E4,$20,$38,$09,$A4,$20,$3C,$09
$04:DDF7 .db $90,$10,$40,$09,$4C,$10,$44,$09
$04:DDFF .db $0C,$10,$38,$09,$8C,$07,$38,$09
$04:DE07 .db $0C,$07,$28,$09,$8C,$06,$48,$09
$04:DE0F .db $14,$10,$4C,$09,$94,$07,$50,$09
$04:DE17 .db $54,$07,$38,$09,$0C,$06,$04,$09
$04:DE1F .db $8C,$05,$54,$09,$0E,$05,$E8,$09
$04:DE27 .db $48,$06,$E8,$09,$C8,$06,$98,$09
$04:DE2F .db $88,$06,$EC,$09,$12,$05,$F0,$09
$04:DE37 .db $D2,$04,$F4,$09,$92,$04,$00,$00
$04:DE3F .db $D8,$04,$24,$00,$98,$04,$48,$00
$04:DE47 .db $D8,$03,$6C,$00,$56,$03,$90,$00
$04:DE4F .db $56,$03,$B4,$00,$56,$03,$10,$05
$04:DE57 .db $18,$05,$28,$09,$24,$05,$38,$0B
$04:DE5F .db $14,$07,$60,$09,$28,$05,$64,$09
$04:DE67 .db $6A,$05,$68,$09,$AC,$05,$6C,$09
$04:DE6F .db $2C,$06,$70,$09,$30,$06,$74,$09
$04:DE77 .db $B2,$05,$78,$09,$32,$05,$68,$01
$04:DE7F .db $FC,$07,$50,$0A,$C0,$0F,$D8,$00
$04:DE87 .db $7C,$07,$FC,$00,$7C,$07,$20,$01
$04:DE8F .db $7C,$07,$44,$01,$7C,$07,$50,$09
$04:DE97 .db $D4,$06,$4C,$09,$94,$06,$7C,$09
$04:DE9F .db $14,$06,$80,$09,$94,$05,$84,$09
$04:DEA7 .db $18,$07,$88,$09,$1A,$07,$48,$09
$04:DEAF .db $9C,$07,$8C,$09,$1C,$10,$90,$09
$04:DEB7 .db $60,$10,$94,$09,$64,$10,$38,$09
$04:DEBF .db $DC,$10,$98,$09,$84,$28,$A4,$09
$04:DEC7 .db $18,$31,$84,$09,$1C,$31,$A8,$09
$04:DECF .db $E0,$30,$4C,$09,$60,$30,$A0,$09
$04:DED7 .db $CA,$30,$A0,$09,$0E,$31,$B0,$09
$04:DEDF .db $10,$31,$B4,$09,$CC,$30,$B8,$09
$04:DEE7 .db $8C,$30,$BC,$09,$0C,$30,$BC,$09
$04:DEEF .db $8C,$27,$BC,$09,$A0,$27,$BC,$09
$04:DEF7 .db $20,$27,$AC,$09,$A0,$26,$28,$09
$04:DEFF .db $20,$26,$00,$0A,$64,$30,$04,$0A
$04:DF07 .db $A8,$30,$08,$0A,$28,$31,$18,$09
$04:DF0F .db $22,$26,$98,$09,$26,$26,$C0,$09
$04:DF17 .db $2A,$26,$C4,$09,$6C,$26,$C8,$09
$04:DF1F .db $70,$26,$CC,$09,$B0,$26,$28,$09
$04:DF27 .db $30,$27,$D0,$09,$70,$27,$38,$09
$04:DF2F .db $B0,$27,$28,$09,$30,$30,$38,$09
$04:DF37 .db $B0,$30,$38,$09,$F0,$30,$D4,$09
$04:DF3F .db $B0,$31,$D8,$09,$2E,$32,$98,$09
$04:DF47 .db $2A,$32,$E0,$09,$CC,$26,$BC,$09
$04:DF4F .db $8C,$26,$E4,$09,$0C,$26,$DC,$09
$04:DF57 .db $04,$27,$DC,$09,$C0,$26,$DC,$09
$04:DF5F .db $40,$27,$98,$09,$B4,$01,$0C,$0B
$04:DF67 .db $B8,$01,$30,$0B,$88,$09,$34,$0B
$04:DF6F .db $A0,$09,$10,$0A,$8A,$09,$10,$0A
$04:DF77 .db $9E,$09,$0C,$0A,$8C,$09,$0C,$0A
$04:DF7F .db $9C,$09,$10,$0A,$8E,$09,$10,$0A
$04:DF87 .db $9A,$09,$0C,$0A,$90,$09,$0C,$0A
$04:DF8F .db $98,$09,$10,$0A,$92,$09,$10,$0A
$04:DF97 .db $96,$09,$14,$0A,$A4,$09,$A8,$03
$04:DF9F .db $30,$08,$18,$0A,$AC,$09,$1C,$0A
$04:DFA7 .db $F0,$09,$9C,$09,$70,$0A,$20,$0A
$04:DFAF .db $F0,$0A,$20,$0A,$70,$0B,$20,$0A
$04:DFB7 .db $F0,$0B,$24,$0A,$70,$0C,$38,$09
$04:DFBF .db $F0,$0C,$28,$0A,$30,$0D,$2C,$0A
$04:DFC7 .db $98,$0A,$30,$0A,$9C,$0A,$14,$0B
$04:DFCF .db $10,$0B,$18,$0B,$90,$0B,$34,$0A
$04:DFD7 .db $1C,$0B,$38,$0A,$5E,$0B,$3C,$0A
$04:DFDF .db $62,$0B,$40,$0A,$66,$0B,$20,$0A
$04:DFE7 .db $E8,$0A,$9C,$09,$68,$0A,$7C,$0A
$04:DFEF .db $A4,$33,$7C,$0A,$E8,$33,$7C,$0A
$04:DFF7 .db $68,$34,$18,$09,$A2,$33,$C0,$09
$04:DFFF .db $A4,$33,$30,$09,$E8,$33,$54,$0A
$04:E007 .db $28,$34,$38,$09,$A8,$34,$7C,$0A
$04:E00F .db $98,$33,$7C,$0A,$9C,$33,$58,$0A
$04:E017 .db $9E,$33,$98,$09,$9C,$33,$28,$09
$04:E01F .db $98,$33,$7C,$0A,$26,$36,$7C,$0A
$04:E027 .db $20,$36,$5C,$0A,$68,$35,$14,$09
$04:E02F .db $A8,$35,$D8,$09,$26,$36,$1C,$09
$04:E037 .db $24,$36,$28,$09,$20,$36,$7C,$0A
$04:E03F .db $2C,$35,$7C,$0A,$30,$35,$60,$0A
$04:E047 .db $2A,$35,$98,$09,$2C,$35,$98,$09
$04:E04F .db $2E,$35,$98,$09,$30,$35,$7C,$0A
$04:E057 .db $DA,$35,$7C,$0A,$98,$34,$7C,$0A
$04:E05F .db $18,$34,$58,$0A,$1E,$36,$3C,$09
$04:E067 .db $1C,$36,$64,$0A,$D8,$35,$44,$09
$04:E06F .db $98,$35,$28,$09,$18,$35,$38,$09
$04:E077 .db $98,$34,$38,$09,$18,$34,$28,$09
$04:E07F .db $98,$33,$7C,$0A,$A0,$36,$7C,$0A
$04:E087 .db $60,$37,$D0,$09,$60,$36,$38,$09
$04:E08F .db $E0,$36,$38,$09,$60,$37,$7C,$0A
$04:E097 .db $9C,$33,$18,$09,$9A,$33,$98,$09
$04:E09F .db $9C,$33,$7C,$0A,$10,$35,$58,$0A
$04:E0A7 .db $96,$33,$6C,$0A,$92,$33,$70,$0A
$04:E0AF .db $D0,$33,$74,$0A,$10,$34,$38,$09
$04:E0B7 .db $90,$34,$28,$09,$10,$35,$7C,$0A
$04:E0BF .db $1C,$35,$7C,$0A,$22,$35,$98,$09
$04:E0C7 .db $14,$35,$28,$09,$18,$35,$98,$09
$04:E0CF .db $1C,$35,$98,$09,$20,$35,$98,$09
$04:E0D7 .db $24,$35,$7C,$0A,$10,$36,$D0,$09
$04:E0DF .db $50,$35,$38,$09,$90,$35,$28,$09
$04:E0E7 .db $10,$36,$7C,$0A,$90,$36,$7C,$0A
$04:E0EF .db $0E,$37,$7C,$0A,$0A,$37,$7C,$0A
$04:E0F7 .db $02,$37,$D0,$09,$50,$36,$78,$0A
$04:E0FF .db $D0,$36,$1C,$09,$0C,$37,$98,$09
$04:E107 .db $08,$37,$98,$09,$04,$37,$98,$09
$04:E10F .db $00,$37,$90,$0A,$12,$18,$94,$0A
$04:E117 .db $AA,$2B,$98,$0A,$A8,$2B,$9C,$0A
$04:E11F .db $A4,$2B,$94,$0A,$A2,$2B,$98,$0A
$04:E127 .db $A0,$2B,$A0,$0A,$64,$2B,$A4,$0A
$04:E12F .db $9A,$2B,$98,$0A,$98,$2B,$98,$0A
$04:E137 .db $96,$2B,$98,$0A,$94,$2B,$9C,$0A
$04:E13F .db $90,$2B,$A0,$0A,$5C,$2B,$A0,$0A
$04:E147 .db $50,$2B,$A8,$0A,$10,$2B,$9C,$0A
$04:E14F .db $90,$2A,$AC,$0A,$92,$2A,$98,$0A
$04:E157 .db $94,$2A,$98,$0A,$96,$2A,$98,$0A
$04:E15F .db $98,$2A,$A0,$0A,$50,$2A,$A8,$0A
$04:E167 .db $10,$2A,$3C,$0B,$90,$29,$40,$0B
$04:E16F .db $94,$29,$40,$0B,$98,$29,$A0,$0A
$04:E177 .db $5C,$2A,$A8,$0A,$1C,$2A,$A8,$0A
$04:E17F .db $DC,$29,$A0,$0A,$64,$2A,$A8,$0A
$04:E187 .db $24,$2A,$A8,$0A,$E4,$29,$B0,$0A
$04:E18F .db $90,$1D,$A0,$09,$8C,$1D,$B0,$0A
$04:E197 .db $56,$1E,$B4,$0A,$5A,$1E,$B8,$0A
$04:E19F .db $5C,$1D,$A0,$09,$18,$1D,$BC,$0A
$04:E1A7 .db $90,$1C,$BC,$0A,$0C,$1C,$A0,$09
$04:E1AF .db $0C,$1E,$C0,$0A,$8A,$1E,$C0,$0A
$04:E1B7 .db $86,$1E,$BC,$0A,$04,$1E,$A0,$09
$04:E1BF .db $84,$1D,$B8,$0A,$C6,$1C,$B0,$0A
$04:E1C7 .db $0C,$1D,$A0,$09,$88,$1D,$A0,$09
$04:E1CF .db $84,$1D,$B4,$0A,$80,$1D,$A0,$09
$04:E1D7 .db $3C,$16,$A0,$09,$BC,$16,$A0,$09
$04:E1DF .db $B8,$16,$A0,$09,$B4,$16,$A0,$09
$04:E1E7 .db $30,$16,$A8,$0A,$70,$15,$C4,$0A
$04:E1EF .db $30,$15,$D8,$0A,$B8,$13,$4C,$09
$04:E1F7 .db $B0,$14,$C8,$0A,$32,$14,$CC,$0A
$04:E1FF .db $F4,$13,$D0,$0A,$B8,$13,$D4,$0A
$04:E207 .db $B8,$12,$F8,$01,$F4,$11,$1C,$02
$04:E20F .db $F4,$11,$40,$02,$F4,$11,$64,$02
$04:E217 .db $F4,$11,$88,$02,$F4,$11,$AC,$02
$04:E21F .db $F4,$11,$D0,$02,$F4,$11,$F4,$02
$04:E227 .db $F4,$11,$18,$03,$F4,$11,$3C,$03
$04:E22F .db $B4,$11,$60,$03,$B4,$11,$3C,$03
$04:E237 .db $B4,$11,$DC,$0A,$10,$3D,$E0,$0A
$04:E23F .db $CE,$3C,$E4,$0A,$8C,$3C,$E8,$0A
$04:E247 .db $48,$3C,$EC,$0A,$14,$3C,$F0,$0A
$04:E24F .db $D6,$3B,$F4,$0A,$98,$3B,$F8,$0A
$04:E257 .db $5A,$3B,$18,$09,$26,$3C,$98,$09
$04:E25F .db $28,$3C,$98,$09,$2A,$3C,$98,$09
$04:E267 .db $2C,$3C,$6C,$09,$28,$3D,$FC,$0A
$04:E26F .db $68,$3D,$00,$0B,$AA,$3D,$E4,$0A
$04:E277 .db $EC,$3D,$E4,$0A,$2E,$3E,$DC,$0A
$04:E27F .db $B0,$3E,$3C,$0B,$90,$29,$40,$0B
$04:E287 .db $94,$29,$40,$0B,$98,$29,$04,$0B
$04:E28F .db $9C,$3D,$08,$0B,$D8,$3D,$08,$0B
$04:E297 .db $14,$3E,$08,$0B,$50,$3E,$08,$0B
$04:E29F .db $8C,$3E,$6C,$09,$88,$3E,$44,$01
$04:E2A7 .db $7C,$07,$38,$09,$E0,$19,$1C,$0B
$04:E2AF .db $20,$1A,$CC,$03,$DC,$1A,$F0,$03
$04:E2B7 .db $DC,$1A,$14,$04,$DC,$1A,$38,$04
$04:E2BF .db $9C,$1B,$5C,$04,$9C,$1B,$80,$04
$04:E2C7 .db $5C,$1B,$A4,$04,$1C,$1B,$C8,$04
$04:E2CF .db $DC,$1A,$EC,$04,$9C,$1A,$58,$0A
$04:E2D7 .db $1E,$1B,$20,$0B,$1C,$1B,$24,$0B
$04:E2DF .db $1A,$1B,$28,$0B,$18,$1B,$A0,$09
$04:E2E7 .db $94,$1B,$A0,$09,$14,$1C,$A0,$09
$04:E2EF .db $94,$1C,$C0,$0A,$14,$1D,$2C,$0B
$04:E2F7 .db $56,$1D,$A0,$09,$D4,$1D,$98,$09
$04:E2FF .db $90,$39,$98,$09,$94,$39,$28,$09
$04:E307 .db $98,$39,$98,$09,$9C,$39,$98,$09
$04:E30F .db $A0,$39,$28,$09,$A4,$39,$98,$09
$04:E317 .db $A8,$39,$98,$09,$AC,$39,$28,$09
$04:E31F .db $B0,$39,$98,$09,$B4,$39,$98,$09
$04:E327 .db $B4,$38,$28,$09,$B0,$38,$98,$09
$04:E32F .db $AC,$38,$98,$09,$A8,$38,$28,$09
$04:E337 .db $A4,$38,$98,$09,$A0,$38,$98,$09
$04:E33F .db $9C,$38,$28,$09,$98,$38,$98,$09
$04:E347 .db $94,$38,$98,$09,$90,$38,$28,$09
$04:E34F .db $8C,$38,$98,$09,$88,$38,$28,$09
$04:E357 .db $84,$38
;;; $E359..E443: Table: first block copy index per event ;;;
;; Word per event: index of its first record in the previous table. The next event's entry is the end index
;; (see $E453).
$04:E359 .db $00,$00
$04:E35B .db $00,$00,$0D,$00,$0D,$00,$10,$00
$04:E363 .db $15,$00,$18,$00,$1A,$00,$20,$00
$04:E36B .db $23,$00,$26,$00,$29,$00,$2C,$00
$04:E373 .db $35,$00,$39,$00,$3A,$00,$42,$00
$04:E37B .db $46,$00,$4A,$00,$4C,$00,$4D,$00
$04:E383 .db $4E,$00,$52,$00,$59,$00,$5D,$00
$04:E38B .db $60,$00,$67,$00,$6A,$00,$6C,$00
$04:E393 .db $6F,$00,$72,$00,$75,$00,$77,$00
$04:E39B .db $77,$00,$83,$00,$83,$00,$84,$00
$04:E3A3 .db $8E,$00,$90,$00,$92,$00,$98,$00
$04:E3AB .db $98,$00,$98,$00,$A0,$00,$A5,$00
$04:E3B3 .db $AC,$00,$B2,$00,$BD,$00,$C2,$00
$04:E3BB .db $C5,$00,$CC,$00,$D3,$00,$D7,$00
$04:E3C3 .db $E1,$00,$E2,$00,$E2,$00,$E2,$00
$04:E3CB .db $E5,$00,$E7,$00,$E8,$00,$ED,$00
$04:E3D3 .db $EE,$00,$F1,$00,$F5,$00,$FA,$00
$04:E3DB .db $FD,$00,$00,$01,$00,$01,$00,$01
$04:E3E3 .db $00,$01,$00,$01,$02,$01,$08,$01
$04:E3EB .db $0F,$01,$12,$01,$14,$01,$16,$01
$04:E3F3 .db $17,$01,$1E,$01,$2B,$01,$2B,$01
$04:E3FB .db $2B,$01,$2B,$01,$2F,$01,$2F,$01
$04:E403 .db $2F,$01,$33,$01,$33,$01,$33,$01
$04:E40B .db $37,$01,$37,$01,$37,$01,$40,$01
$04:E413 .db $40,$01,$46,$01,$46,$01,$46,$01
$04:E41B .db $47,$01,$52,$01,$56,$01,$5C,$01
$04:E423 .db $5C,$01,$5F,$01,$62,$01,$65,$01
$04:E42B .db $68,$01,$6B,$01,$6E,$01,$71,$01
$04:E433 .db $73,$01,$73,$01,$73,$01,$73,$01
$04:E43B .db $73,$01,$73,$01,$73,$01,$73,$01
$04:E443 .db $73,$01,$73,$01,$73,$01,$73,$01
;;; $E44B..E44B: Table: bit masks 80 to 01 ;;;
;; Bit masks for testing event flags in [$1F02+].
$04:E44B .db $80,$40,$20,$10,$08,$04,$02,$01 ; Bit masks
;;; $E453: Apply completed event to layer 2 map ;;;
;; If event [$0F] is complete, runs every block copy record for it ($DD8D) via $E496.
;; E496: reads one record and copies the block with E4D0 (2x2) or E520 (6x6), alternating tile byte from
;; $0C:8000+Y and attribute byte from $7F:0000+Y into $7F:4000+X. The 32-tile row wrap is handled by AND #$3F
;; tests.
;; Called by:
;; $04:DCA2: Load all layers of overworld map
$04:E453 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E455 A5 0F LDA $0F ; \
$04:E457 29 07 AND.B #$07 ; |
$04:E459 AA TAX ; } X = [$0F] AND 7: bit number
$04:E45A A5 0F LDA $0F ; \
$04:E45C 4A LSR ; |
$04:E45D 4A LSR ; |
$04:E45E 4A LSR ; |
$04:E45F A8 TAY ; } Y = [$0F] / 8: flag byte
$04:E460 B9 02 1F LDA.W $1F02,Y ; \
$04:E463 3F 4B E4 04 AND.L $E44B,X ; } Test the event's flag in [$1F02+Y]
$04:E467 D0 01 BNE $E46A ; Complete: apply it
$04:E469 60 RTS ; Return
$04:E46A A5 0F LDA $0F ; \
$04:E46C 0A ASL ; |
$04:E46D AA TAX ; } X = [$0F] * 2
$04:E46E C2 20 REP #$20 ; A 16-bit
$04:E470 BF 59 E3 04 LDA.L $E359,X ; \
$04:E474 8D EB 1D STA.W $1DEB ; / [$1DEB] = first record index for this event
$04:E477 BF 5B E3 04 LDA.L $E35B,X ; \
$04:E47B 8D ED 1D STA.W $1DED ; / [$1DED] = end index (next event's first)
$04:E47E CD EB 1D CMP.W $1DEB ; \
$04:E481 F0 10 BEQ $E493 ; / No records: done
$04:E483 20 96 E4 JSR.W $E496 ; Copy block for record [$1DEB] ($E496)
$04:E486 C2 20 REP #$20 ; A 16-bit
$04:E488 EE EB 1D INC.W $1DEB ; Next record
$04:E48B AD EB 1D LDA.W $1DEB ; \
$04:E48E CD ED 1D CMP.W $1DED ; |
$04:E491 D0 F0 BNE $E483 ; } Loop until [$1DEB] = [$1DED]
$04:E493 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E495 60 RTS ; Return
$04:E496 C2 30 REP #$30 ; A, X and Y 16-bit
$04:E498 AD EB 1D LDA.W $1DEB ; \
$04:E49B 0A ASL ; |
$04:E49C 0A ASL ; |
$04:E49D AA TAX ; } X = record * 4
$04:E49E BF 8D DD 04 LDA.L $DD8D,X ; \
$04:E4A2 A8 TAY ; / Y = source offset
$04:E4A3 BF 8F DD 04 LDA.L $DD8F,X ; \
$04:E4A7 85 04 STA $04 ; / [$04] = destination offset in $7F:4000
$04:E4A9 E2 20 SEP #$20 ; A 8-bit
$04:E4AB A9 7F LDA.B #$7F ; \
$04:E4AD 85 08 STA $08 ; / [$08] = $7F
$04:E4AF A9 0C LDA.B #$0C ; \
$04:E4B1 85 0B STA $0B ; / [$0B] = $0C
$04:E4B3 C2 20 REP #$20 ; A 16-bit
$04:E4B5 A9 00 00 LDA.W #$0000 ; \
$04:E4B8 85 06 STA $06 ; / [$06] = $0000: pointer to $7F:0000 (attributes)
$04:E4BA A9 00 80 LDA.W #$8000 ; \
$04:E4BD 85 09 STA $09 ; / [$09] = $8000: pointer to $0C:8000 (tile numbers)
$04:E4BF C0 00 09 CPY.W #$0900 ; \
$04:E4C2 90 06 BCC $E4CA ; / Source offset < $0900: 6x6 block
$04:E4C4 20 D0 E4 JSR.W $E4D0 ; Copy a 2x2 block
$04:E4C7 4C CD E4 JMP.W $E4CD ; Done
$04:E4CA 20 20 E5 JSR.W $E520 ; Copy a 6x6 block
$04:E4CD E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E4CF 60 RTS ; Return
$04:E4D0 A9 01 00 LDA.W #$0001 ; \
$04:E4D3 85 00 STA $00 ; / [$00] = 1: 2 rows
$04:E4D5 A6 04 LDX $04 ; X = destination offset
$04:E4D7 A9 01 00 LDA.W #$0001 ; \
$04:E4DA 85 0C STA $0C ; / [$0C] = 1: 2 tiles per row
$04:E4DC E2 20 SEP #$20 ; A 8-bit
$04:E4DE B7 09 LDA [$09],Y ; \
$04:E4E0 9F 00 40 7F STA.L $7F4000,X ; / Copy tile number to the layer 2 tilemap
$04:E4E4 E8 INX ; X++
$04:E4E5 B7 06 LDA [$06],Y ; \
$04:E4E7 9F 00 40 7F STA.L $7F4000,X ; / Copy tile attributes
$04:E4EB C8 INY ; \
$04:E4EC E8 INX ; / Y++, X++
$04:E4ED C2 20 REP #$20 ; A 16-bit
$04:E4EF 8A TXA ; \
$04:E4F0 29 3F 00 AND.W #$003F ; |
$04:E4F3 D0 0A BNE $E4FF ; } At the right edge of a 32-tile row?
$04:E4F5 CA DEX ; \
$04:E4F6 8A TXA ; |
$04:E4F7 29 C0 FF AND.W #$FFC0 ; |
$04:E4FA 18 CLC ; |
$04:E4FB 69 00 08 ADC.W #$0800 ; |
$04:E4FE AA TAX ; } Wrap into the next $800-byte screen page
$04:E4FF C6 0C DEC $0C ; \
$04:E501 10 D9 BPL $E4DC ; / Next tile in the row
$04:E503 A5 04 LDA $04 ; \
$04:E505 AA TAX ; |
$04:E506 18 CLC ; |
$04:E507 69 40 00 ADC.W #$0040 ; |
$04:E50A 85 04 STA $04 ; } Next row: [$04] += $40
$04:E50C 29 C0 07 AND.W #$07C0 ; \
$04:E50F D0 0A BNE $E51B ; / Crossed a page boundary?
$04:E511 8A TXA ; \
$04:E512 29 3F F8 AND.W #$F83F ; |
$04:E515 18 CLC ; |
$04:E516 69 00 10 ADC.W #$1000 ; |
$04:E519 85 04 STA $04 ; } Next page: [$04] += $1000
$04:E51B C6 00 DEC $00 ; \
$04:E51D 10 B6 BPL $E4D5 ; / Next row
$04:E51F 60 RTS ; Return
$04:E520 A9 05 00 LDA.W #$0005 ; \
$04:E523 85 00 STA $00 ; / [$00] = 5: 6 rows
$04:E525 A6 04 LDX $04 ; X = destination offset
$04:E527 A9 05 00 LDA.W #$0005 ; \
$04:E52A 85 0C STA $0C ; / [$0C] = 5: 6 tiles per row
$04:E52C E2 20 SEP #$20 ; A 8-bit
$04:E52E B7 09 LDA [$09],Y ; \
$04:E530 9F 00 40 7F STA.L $7F4000,X ; / Copy tile number to the layer 2 tilemap
$04:E534 E8 INX ; X++
$04:E535 B7 06 LDA [$06],Y ; \
$04:E537 9F 00 40 7F STA.L $7F4000,X ; / Copy tile attributes
$04:E53B C8 INY ; \
$04:E53C E8 INX ; / Y++, X++
$04:E53D C2 20 REP #$20 ; A 16-bit
$04:E53F 8A TXA ; \
$04:E540 29 3F 00 AND.W #$003F ; |
$04:E543 D0 0A BNE $E54F ; } At the right edge of a 32-tile row?
$04:E545 CA DEX ; \
$04:E546 8A TXA ; |
$04:E547 29 C0 FF AND.W #$FFC0 ; |
$04:E54A 18 CLC ; |
$04:E54B 69 00 08 ADC.W #$0800 ; |
$04:E54E AA TAX ; } Wrap into the next $800-byte screen page
$04:E54F C6 0C DEC $0C ; \
$04:E551 10 D9 BPL $E52C ; / Next tile in the row
$04:E553 A5 04 LDA $04 ; \
$04:E555 AA TAX ; |
$04:E556 18 CLC ; |
$04:E557 69 40 00 ADC.W #$0040 ; |
$04:E55A 85 04 STA $04 ; } Next row: [$04] += $40
$04:E55C 29 C0 07 AND.W #$07C0 ; \
$04:E55F D0 0A BNE $E56B ; / Crossed a page boundary?
$04:E561 8A TXA ; \
$04:E562 29 3F F8 AND.W #$F83F ; |
$04:E565 18 CLC ; |
$04:E566 69 00 10 ADC.W #$1000 ; |
$04:E569 85 04 STA $04 ; } Next page: [$04] += $1000
$04:E56B C6 00 DEC $00 ; \
$04:E56D 10 B6 BPL $E525 ; / Next row
$04:E56F 60 RTS ; Return
$04:E570 AD 86 1B LDA.W $1B86
$04:E573 22 DF 86 00 JSL.L ExecutePtr
;;; $E577: Overworld event: state machine and tiles (Ptrs04E577) ;;;
;; Second half of the overworld event handler that $E570 enters through ExecutePtr with state [$1B86] (8
;; states).
;; Runs when the player beats a level that triggers an overworld event ([$1DE9] set, event number [$1DEA]):
;; smoke puff, new level tile,
;; event path tiles in the layer 2 map, then a final step that applies direct map edits and records the event
;; in [$1F02].
;; Contains the pointer table, small tables, state 0-4 code and the stripe image builders for 2x2 and 6x6 tile
;; blocks.
$04:E577 EE E5 .dw $E5EE ; State 0: check event, start it ($04E5EE)
$04:E579 EB EB .dw $EBEB ; State 1: smoke puff before level tile appears ($04EBEB)
$04:E57B D3 E6 .dw $E6D3 ; State 2: find event tile range ($04E6D3)
$04:E57D F9 E6 .dw $E6F9 ; State 3: lay down event tiles ($04E6F9)
$04:E57F A4 EA .dw $EAA4 ; State 4: fade in, next tile or continue ($04EAA4)
$04:E581 78 EC .dw $EC78 ; State 5: check level tile to reveal ($04EC78)
$04:E583 EB EB .dw $EBEB ; State 6: smoke puff at level tile ($04EBEB)
$04:E585 EC E9 .dw $E9EC ; State 7: finish event, apply map edits ($04E9EC)
$04:E587 .db $20,$52,$22,$DA,$28,$58,$24,$C0 ; Table of 16 words indexed by [$13D1] * 2 (read by $EEAA)
$04:E58F .db $24,$94,$23,$42,$28,$94,$2A,$98 ; (continued)
$04:E597 .db $25,$0E,$25,$52,$25,$C4,$2A,$DE ; (continued)
$04:E59F .db $2A,$98,$28,$44,$2C,$50,$2C,$0C ; (continued)
$04:E5A7 .db $77,$79,$58,$4C,$A6 ; Layer 1 tile numbers that may sit at the position being replaced
$04:E5AC .db $85,$86,$00,$10,$00 ; Replacement tile written at the position (index >= 3 only): $10, $00
$04:E5B1 .db $85,$86,$81,$81,$81 ; Replacement tile written below it / for index 0-2: $85,$86,$81...
$04:E5B6 .db $19,$04,$BD,$00,$1C,$06,$30,$01 ; Word offsets into the layer 1 map ($7E:C800), 16 entries x 2 bytes
$04:E5BE .db $2A,$01,$D1,$00,$2A,$06,$AC,$06 ; (continued)
$04:E5C6 .db $47,$05,$59,$05,$72,$05,$BF,$02 ; (continued)
$04:E5CE .db $AC,$02,$12,$02,$18,$03,$06,$03 ; (continued)
$04:E5D6 .db $06,$0F,$1C,$21,$24,$28,$29,$37 ; Event numbers whose level tile is replaced (entries 0-15)
$04:E5DE .db $40,$41,$43,$4A,$4D,$02,$61,$35 ; (continued)
$04:E5E6 .db $58,$59,$5D,$63,$77,$79,$7E,$80 ; Event numbers (entries 16-23); also OW tile numbers checked against [$13C1]
$04:E5EE AD D5 0D LDA.W $0DD5 ; \
$04:E5F1 C9 02 CMP.B #$02 ; |
$04:E5F3 D0 03 BNE $E5F8 ; } Secret exit ([$0DD5] = 2): next event number [$1DEA]++
$04:E5F5 EE EA 1D INC.W $1DEA ; /
$04:E5F8 AD E9 1D LDA.W $1DE9 ; A = [$1DE9] (event pending flag)
$04:E5FB F0 1D BEQ $E61A ; No event pending: skip to the tile check at $04E61A
$04:E5FD AD EA 1D LDA.W $1DEA ; A = event number [$1DEA]
$04:E600 C9 FF CMP.B #$FF ; \
$04:E602 F0 16 BEQ $E61A ; / [$1DEA] = $FF (no event): skip to $04E61A
$04:E604 AD EA 1D LDA.W $1DEA ; \
$04:E607 29 07 AND.B #$07 ; } X = [$1DEA] AND 7 (bit within the byte)
$04:E609 AA TAX ; /
$04:E60A AD EA 1D LDA.W $1DEA ; \
$04:E60D 4A LSR ; |
$04:E60E 4A LSR ; |
$04:E60F 4A LSR ; } Y = [$1DEA] / 8 (byte in the event-passed flags)
$04:E610 A8 TAY ; /
$04:E611 B9 02 1F LDA.W $1F02,Y ; A = event-passed flags [$1F02+Y]
$04:E614 3F 4B E4 04 AND.L $E44B,X ; Isolate this event's bit ($E44B: $80,$40,...)
$04:E618 F0 26 BEQ $E640 ; Bit clear (event not seen yet): go start it ($04E640)
$04:E61A A2 07 LDX.B #$07 ; X = 7: loop over the 8 OW tile numbers in $E5E6
$04:E61C BD E6 E5 LDA.W $E5E6,X ; A = tile number to compare
$04:E61F CD C1 13 CMP.W $13C1 ; Compare with [$13C1] (probably OW tile Mario stands on)
$04:E622 D0 0E BNE $E632 ; No match: try the next one
$04:E624 EE D9 13 INC.W $13D9 ; Match: advance the OW process [$13D9]++
$04:E627 A9 E0 LDA.B #$E0 ; A = $E0
$04:E629 8D D5 0D STA.W $0DD5 ; [$0DD5] = $E0
$04:E62C A9 0F LDA.B #$0F ; A = $0F
$04:E62E 8D B1 0D STA.W $0DB1 ; [$0DB1] = $0F (probably keeps the OW game mode active)
$04:E631 60 RTS ; Return
$04:E632 CA DEX ; Next table entry
$04:E633 10 E7 BPL $E61C ; Loop for X = 7..0
$04:E635 A9 05 LDA.B #$05 ; A = 5
$04:E637 8D D9 13 STA.W $13D9 ; [$13D9] = 5: back to normal OW processing (Mario idle)
$04:E63A A9 80 LDA.B #$80 ; A = $80
$04:E63C 8D D5 0D STA.W $0DD5 ; [$0DD5] = $80
$04:E63F 60 RTS ; Return
$04:E640 EE 86 1B INC.W $1B86 ; Go to state 1: [$1B86]++
$04:E643 AD EA 1D LDA.W $1DEA ; A = event number [$1DEA]
$04:E646 20 77 E6 JSR.W $E677 ; Find its level tile ($E677); returns Y = map position
$04:E649 98 TYA ; \
$04:E64A 0A ASL ; |
$04:E64B 0A ASL ; |
$04:E64C 0A ASL ; } A = Y << 4
$04:E64D 0A ASL ; /
$04:E64E 8D 82 1B STA.W $1B82 ; [$1B82] = effect X position (low nibble of map position * 16)
$04:E651 98 TYA ; \
$04:E652 29 F0 AND.B #$F0 ; } A = Y AND $F0
$04:E654 8D 83 1B STA.W $1B83 ; [$1B83] = effect Y position
$04:E657 A9 28 LDA.B #$28 ; A = $28
$04:E659 8D 84 1B STA.W $1B84 ; [$1B84] = $28 (smoke puff timer)
$04:E65C AD BF 13 LDA.W $13BF ; A = [$13BF] (level number just beaten)
$04:E65F C9 18 CMP.B #$18 ; Level $18 (Sunken Ghost Ship) triggers the earthquake?
$04:E661 D0 05 BNE $E668 ; No: skip
$04:E663 A9 FF LDA.B #$FF ; A = $FF
$04:E665 8D A0 1B STA.W $1BA0 ; [$1BA0] = $FF (overworld earthquake timer, per the original note)
$04:E668 AD 86 1B LDA.W $1B86 ; A = [$1B86]
$04:E66B C9 02 CMP.B #$02 ; State 2 (no level tile to reveal)?
$04:E66D F0 05 BEQ $E674 ; Yes: skip the sound
$04:E66F A9 16 LDA.B #$16 ; A = $16
$04:E671 8D FC 1D STA.W $1DFC ; Play sound effect $16
$04:E674 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E676 60 RTS ; Return
$04:E677 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E679 A2 17 LDX.B #$17 ; X = $17: search 24 entries
$04:E67B DF D6 E5 04 CMP.L $E5D6,X ; Compare A (event number) with the list entry
$04:E67F F0 09 BEQ $E68A ; Found: go to $04E68A
$04:E681 CA DEX ; Next entry
$04:E682 10 F7 BPL $E67B ; Loop for X = $17..0
$04:E684 A9 02 LDA.B #$02 ; A = 2
$04:E686 8D 86 1B STA.W $1B86 ; [$1B86] = 2: no level tile, skip to the event tiles
$04:E689 60 RTS ; Return
$04:E68A 8E D1 13 STX.W $13D1 ; [$13D1] = list index of this event
$04:E68D 8A TXA ; A = X
$04:E68E 0A ASL ; A = X * 2
$04:E68F AA TAX ; X = word offset
$04:E690 A9 7E LDA.B #$7E ; A = $7E
$04:E692 85 0C STA $0C ; [$0C] = $7E (bank of the pointer)
$04:E694 C2 30 REP #$30 ; A, X and Y 16-bit
$04:E696 A9 00 C8 LDA.W #$C800 ; A = $C800
$04:E699 85 0A STA $0A ; [$0A] = $7EC800 (OW layer 1 map)
$04:E69B BF B6 E5 04 LDA.L $E5B6,X ; A = map offset from $E5B6
$04:E69F A8 TAY ; Y = map offset
$04:E6A0 E2 20 SEP #$20 ; A 8-bit
$04:E6A2 A2 04 00 LDX.W #$0004 ; X = 4: loop over $E5A7
$04:E6A5 B7 0A LDA [$0A],Y ; A = tile currently at that map position
$04:E6A7 DF A7 E5 04 CMP.L $E5A7,X ; Compare with the expected tile number
$04:E6AB F0 06 BEQ $E6B3 ; Match: go to $04E6B3
$04:E6AD CA DEX ; Next candidate
$04:E6AE 10 F7 BPL $E6A7 ; Loop for X = 4..0
$04:E6B0 4C 84 E6 JMP.W $E684 ; No match: skip this level tile ($04E684)
$04:E6B3 8A TXA ; A = X (tile kind)
$04:E6B4 8D D0 13 STA.W $13D0 ; [$13D0] = tile kind
$04:E6B7 E0 03 00 CPX.W #$0003 ; Kind >= 3?
$04:E6BA 30 0E BMI $E6CA ; No: just write the single tile ($04E6CA)
$04:E6BC BF AC E5 04 LDA.L $E5AC,X ; A = $E5AC[X]
$04:E6C0 97 0A STA [$0A],Y ; Write it at the map position
$04:E6C2 C2 20 REP #$20 ; A 16-bit
$04:E6C4 98 TYA ; \
$04:E6C5 18 CLC ; |
$04:E6C6 69 10 00 ADC.W #$0010 ; } Y += $10 (next row down)
$04:E6C9 A8 TAY ; /
$04:E6CA E2 20 SEP #$20 ; A 8-bit
$04:E6CC BF B1 E5 04 LDA.L $E5B1,X ; A = $E5B1[X]
$04:E6D0 97 0A STA [$0A],Y ; Write the tile (replaces the old one)
$04:E6D2 60 RTS ; Return
$04:E6D3 EE 86 1B INC.W $1B86 ; Go to state 3: [$1B86]++
$04:E6D6 AD EA 1D LDA.W $1DEA ; A = event number
$04:E6D9 0A ASL ; A *= 2
$04:E6DA AA TAX ; X = word offset
$04:E6DB C2 20 REP #$20 ; A 16-bit
$04:E6DD BF 59 E3 04 LDA.L $E359,X ; A = first event tile index for this event ($E359)
$04:E6E1 8D EB 1D STA.W $1DEB ; [$1DEB] = current event tile index
$04:E6E4 BF 5B E3 04 LDA.L $E35B,X ; A = first tile index of the next event ($E35B)
$04:E6E8 8D ED 1D STA.W $1DED ; [$1DED] = end index
$04:E6EB CD EB 1D CMP.W $1DEB ; Same as [$1DEB]? (event has no tiles)
$04:E6EE E2 20 SEP #$20 ; A 8-bit
$04:E6F0 D0 06 BNE $E6F8 ; Has tiles: return
$04:E6F2 EE 86 1B INC.W $1B86 ; No tiles: skip state 3
$04:E6F5 EE 86 1B INC.W $1B86 ; and state 4
$04:E6F8 60 RTS ; Return
$04:E6F9 20 62 EA JSR.W $EA62 ; Set up the palette upload buffer ($EA62)
$04:E6FC A9 7F LDA.B #$7F ; A = $7F
$04:E6FE 85 0E STA $0E ; [$0E] = $7F (bank for the [$0C] pointer)
$04:E700 C2 30 REP #$30 ; A, X and Y 16-bit
$04:E702 AD EB 1D LDA.W $1DEB ; A = current event tile index
$04:E705 0A ASL ; \
$04:E706 0A ASL ; } X = index * 4 (4 bytes per tile entry)
$04:E707 AA TAX ; /
$04:E708 BF 8D DD 04 LDA.L $DD8D,X ; A = $DD8D[X]: tile source index
$04:E70C 8D 84 1B STA.W $1B84 ; [$1B84] = source index (also selects 2x2 or 6x6 below)
$04:E70F BF 8F DD 04 LDA.L $DD8F,X ; A = $DD8F[X]: tile position in the layer 2 map
$04:E713 85 00 STA $00 ; [$00] = map offset
$04:E715 29 FF 1F AND.W #$1FFF ; Keep 13 bits
$04:E718 4A LSR ; / 2
$04:E719 18 CLC ; Clear carry
$04:E71A 69 00 30 ADC.W #$3000 ; + $3000: VRAM word address of the layer 2 tilemap
$04:E71D EB XBA ; Swap to big-endian for the stripe image
$04:E71E 85 02 STA $02 ; [$02] = VRAM address
$04:E720 A5 00 LDA $00 ; A = map offset
$04:E722 4A LSR ; \
$04:E723 4A LSR ; |
$04:E724 4A LSR ; } A = offset / 8
$04:E725 E2 20 SEP #$20 ; /
$04:E727 29 F8 AND.B #$F8 ; Keep bits 3-7
$04:E729 8D 83 1B STA.W $1B83 ; [$1B83] = effect Y position (pixels)
$04:E72C A5 00 LDA $00 ; A = map offset
$04:E72E 29 3E AND.B #$3E ; Keep column bits
$04:E730 0A ASL ; \
$04:E731 0A ASL ; / A <<= 2
$04:E732 8D 82 1B STA.W $1B82 ; [$1B82] = effect X position (pixels)
$04:E735 C2 20 REP #$20 ; A 16-bit
$04:E737 A9 00 40 LDA.W #$4000 ; A = $4000
$04:E73A 85 0C STA $0C ; [$0C] = $7F4000 (layer 2 tilemap in RAM)
$04:E73C A9 FF EF LDA.W #$EFFF ; A = $EFFF
$04:E73F 85 0A STA $0A ; [$0A] = mask applied to each tile word
$04:E741 AD 84 1B LDA.W $1B84 ; A = [$1B84]
$04:E744 C9 00 09 CMP.W #$0900 ; Source index >= $0900?
$04:E747 90 06 BCC $E74F ; No: 6x6 tiles ($04E824)
$04:E749 20 6C E7 JSR.W $E76C ; Yes: build a 2x2 tile stripe image
$04:E74C 4C 52 E7 JMP.W $E752 ; Continue at $04E752
$04:E74F 20 24 E8 JSR.W $E824 ; Build a 6x6 tile stripe image
$04:E752 A9 FF 00 LDA.W #$00FF ; A = $00FF
$04:E755 9F 7D 83 7F STA.L $7F837D,X ; Terminate the stripe image with $FF
$04:E759 8A TXA ; A = buffer write index
$04:E75A 8F 7B 83 7F STA.L $7F837B ; Save the new write index in $7F:837B
$04:E75E 20 96 E4 JSR.W $E496 ; Copy the tile into the layer 2 map ($E496)
$04:E761 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:E763 A9 15 LDA.B #$15 ; A = $15
$04:E765 8D FC 1D STA.W $1DFC ; Play sound effect $15 (laying event tiles)
$04:E768 EE 86 1B INC.W $1B86 ; Go to state 4: [$1B86]++
$04:E76B 60 RTS ; Return
$04:E76C A9 01 00 LDA.W #$0001 ; A = 1
$04:E76F 85 06 STA $06 ; [$06] = 1: two rows
$04:E771 AF 7B 83 7F LDA.L $7F837B ; A = current write index into the stripe buffer
$04:E775 AA TAX ; X = index
$04:E776 A5 02 LDA $02 ; A = VRAM address
$04:E778 9F 7D 83 7F STA.L $7F837D,X ; Stripe record: VRAM address
$04:E77C E8 INX ; \
$04:E77D E8 INX ; / X += 2
$04:E77E A0 00 03 LDY.W #$0300 ; Y = $0300: record length-1 = 3 (4 bytes, 2 tiles), big-endian
$04:E781 A5 03 LDA $03 ; A = VRAM address low byte (column)
$04:E783 29 1F 00 AND.W #$001F ; Keep column 0-31
$04:E786 85 08 STA $08 ; [$08] = column
$04:E788 A9 20 00 LDA.W #$0020 ; A = 32
$04:E78B 38 SEC ; Clear carry...
$04:E78C E5 08 SBC $08 ; A = 32 - column: tiles left in this screen row
$04:E78E 85 08 STA $08 ; [$08] = tiles to the screen edge
$04:E790 C9 01 00 CMP.W #$0001 ; Only 1 tile left?
$04:E793 D0 06 BNE $E79B ; No: record fits
$04:E795 A5 08 LDA $08 ; \
$04:E797 0A ASL ; |
$04:E798 3A DEC A ; |
$04:E799 EB XBA ; } Y = (tiles to edge * 2 - 1) << 8: split record length
$04:E79A A8 TAY ; /
$04:E79B 98 TYA ; A = record length
$04:E79C 9F 7D 83 7F STA.L $7F837D,X ; Store the record length
$04:E7A0 E8 INX ; \
$04:E7A1 E8 INX ; / X += 2
$04:E7A2 A9 01 00 LDA.W #$0001 ; A = 1
$04:E7A5 85 04 STA $04 ; [$04] = 1: two columns
$04:E7A7 A4 00 LDY $00 ; Y = offset into the source tilemap
$04:E7A9 B7 0C LDA [$0C],Y ; A = tile word from the layer 2 map
$04:E7AB 25 0A AND $0A ; Mask with [$0A]
$04:E7AD 9F 7D 83 7F STA.L $7F837D,X ; Store the tile in the stripe image
$04:E7B1 E8 INX ; \
$04:E7B2 E8 INX ; / X += 2
$04:E7B3 C8 INY ; \
$04:E7B4 C8 INY ; / Y += 2: next tile
$04:E7B5 98 TYA ; A = Y
$04:E7B6 29 3F 00 AND.W #$003F ; Crossed into the next 32-tile screen?
$04:E7B9 D0 2A BNE $E7E5 ; No: continue
$04:E7BB A5 04 LDA $04 ; Last column already?
$04:E7BD F0 26 BEQ $E7E5 ; Yes: nothing to split
$04:E7BF 88 DEY ; Y -= 1
$04:E7C0 98 TYA ; A = Y
$04:E7C1 29 C0 FF AND.W #$FFC0 ; Round down to a screen row
$04:E7C4 18 CLC ; Clear carry
$04:E7C5 69 00 08 ADC.W #$0800 ; Move to the next screen of the tilemap
$04:E7C8 A8 TAY ; Y = new source offset
$04:E7C9 A5 02 LDA $02 ; A = VRAM address
$04:E7CB EB XBA ; Swap bytes
$04:E7CC 29 E0 3B AND.W #$3BE0 ; Mask to row and column
$04:E7CF 18 CLC ; Clear carry
$04:E7D0 69 00 04 ADC.W #$0400 ; Move to the next VRAM screen (+$0400)
$04:E7D3 EB XBA ; Swap back
$04:E7D4 9F 7D 83 7F STA.L $7F837D,X ; Store the second stripe record: VRAM address
$04:E7D8 E8 INX ; \
$04:E7D9 E8 INX ; / X += 2
$04:E7DA A5 08 LDA $08 ; A = tiles to the screen edge
$04:E7DC 0A ASL ; A *= 2
$04:E7DD 3A DEC A ; A -= 1
$04:E7DE EB XBA ; Swap to big-endian
$04:E7DF 9F 7D 83 7F STA.L $7F837D,X ; Store its length
$04:E7E3 E8 INX ; \
$04:E7E4 E8 INX ; / X += 2
$04:E7E5 C6 04 DEC $04 ; Next column
$04:E7E7 10 C0 BPL $E7A9 ; Loop for both columns
$04:E7E9 A5 02 LDA $02 ; A = VRAM address
$04:E7EB EB XBA ; Swap bytes
$04:E7EC 18 CLC ; Clear carry
$04:E7ED 69 20 00 ADC.W #$0020 ; Next tilemap row (+$20)
$04:E7F0 EB XBA ; Swap back
$04:E7F1 85 02 STA $02 ; [$02] = VRAM address of the next row
$04:E7F3 A5 00 LDA $00 ; A = source offset
$04:E7F5 A8 TAY ; Y = source offset
$04:E7F6 18 CLC ; Clear carry
$04:E7F7 69 40 00 ADC.W #$0040 ; Next source row (+$40 bytes)
$04:E7FA 85 00 STA $00 ; [$00] = source offset
$04:E7FC 29 C0 07 AND.W #$07C0 ; Crossed a 32-row boundary?
$04:E7FF D0 1B BNE $E81C ; No: go on
$04:E801 98 TYA ; A = old offset
$04:E802 29 3F F8 AND.W #$F83F ; Keep column bits
$04:E805 18 CLC ; Clear carry
$04:E806 69 00 10 ADC.W #$1000 ; Next 32x32 block (+$1000)
$04:E809 85 00 STA $00 ; [$00] = source offset
$04:E80B A5 02 LDA $02 ; A = VRAM address
$04:E80D EB XBA ; Swap bytes
$04:E80E 38 SEC ; Set carry
$04:E80F E9 20 00 SBC.W #$0020 ; Back one row (-$20)
$04:E812 29 1F 34 AND.W #$341F ; Mask
$04:E815 18 CLC ; Clear carry
$04:E816 69 00 08 ADC.W #$0800 ; Next VRAM screen (+$0800)
$04:E819 EB XBA ; Swap back
$04:E81A 85 02 STA $02 ; [$02] = VRAM address
$04:E81C C6 06 DEC $06 ; Next row
$04:E81E 30 03 BMI $E823 ; Both rows done: return
$04:E820 4C 76 E7 JMP.W $E776 ; Loop for the next row
$04:E823 60 RTS ; Return
$04:E824 A9 05 00 LDA.W #$0005 ; A = 5
$04:E827 85 06 STA $06 ; [$06] = 5: six rows
$04:E829 AF 7B 83 7F LDA.L $7F837B ; A = current write index into the stripe buffer
$04:E82D AA TAX ; X = index
$04:E82E A5 02 LDA $02 ; A = VRAM address
$04:E830 9F 7D 83 7F STA.L $7F837D,X ; Stripe record: VRAM address
$04:E834 E8 INX ; \
$04:E835 E8 INX ; / X += 2
$04:E836 A0 00 0B LDY.W #$0B00 ; Y = $0B00: record length-1 = 11 (12 bytes, 6 tiles), big-endian
$04:E839 A5 03 LDA $03 ; A = VRAM address low byte (column)
$04:E83B 29 1F 00 AND.W #$001F ; Keep column 0-31
$04:E83E 85 08 STA $08 ; [$08] = column
$04:E840 A9 20 00 LDA.W #$0020 ; A = 32
$04:E843 38 SEC ; Set carry
$04:E844 E5 08 SBC $08 ; A = 32 - column
$04:E846 85 08 STA $08 ; [$08] = tiles to the screen edge
$04:E848 C9 06 00 CMP.W #$0006 ; 6 or more tiles left?
$04:E84B B0 0E BCS $E85B ; Yes: record fits
$04:E84D A5 08 LDA $08 ; A = tiles to the edge
$04:E84F 0A ASL ; A *= 2
$04:E850 3A DEC A ; A -= 1
$04:E851 EB XBA ; Swap to big-endian
$04:E852 A8 TAY ; Y = split record length
$04:E853 A9 06 00 LDA.W #$0006 ; A = 6
$04:E856 38 SEC ; Set carry
$04:E857 E5 08 SBC $08 ; A = 6 - tiles to the edge
$04:E859 85 08 STA $08 ; [$08] = tiles left for the second record
$04:E85B 98 TYA ; A = record length
$04:E85C 9F 7D 83 7F STA.L $7F837D,X ; Store the record length
$04:E860 E8 INX ; \
$04:E861 E8 INX ; / X += 2
$04:E862 A9 05 00 LDA.W #$0005 ; A = 5
$04:E865 85 04 STA $04 ; [$04] = 5: six columns
$04:E867 A4 00 LDY $00 ; Y = offset into the source tilemap
$04:E869 B7 0C LDA [$0C],Y ; A = tile word from the layer 2 map
$04:E86B 25 0A AND $0A ; Mask with [$0A]
$04:E86D 9F 7D 83 7F STA.L $7F837D,X ; Store the tile in the stripe image
$04:E871 E8 INX ; \
$04:E872 E8 INX ; / X += 2
$04:E873 C8 INY ; \
$04:E874 C8 INY ; / Y += 2: next tile
$04:E875 98 TYA ; A = Y
$04:E876 29 3F 00 AND.W #$003F ; Crossed into the next 32-tile screen?
$04:E879 D0 2A BNE $E8A5 ; No: continue
$04:E87B A5 04 LDA $04 ; Last column already?
$04:E87D F0 26 BEQ $E8A5 ; Yes: nothing to split
$04:E87F 88 DEY ; Y -= 1
$04:E880 98 TYA ; A = Y
$04:E881 29 C0 FF AND.W #$FFC0 ; Round down to a screen row
$04:E884 18 CLC ; Clear carry
$04:E885 69 00 08 ADC.W #$0800 ; Move to the next screen of the tilemap
$04:E888 A8 TAY ; Y = new source offset
$04:E889 A5 02 LDA $02 ; A = VRAM address
$04:E88B EB XBA ; Swap bytes
$04:E88C 29 E0 3B AND.W #$3BE0 ; Mask to row and column
$04:E88F 18 CLC ; Clear carry
$04:E890 69 00 04 ADC.W #$0400 ; Move to the next VRAM screen (+$0400)
$04:E893 EB XBA ; Swap back
$04:E894 9F 7D 83 7F STA.L $7F837D,X ; Store the second stripe record: VRAM address
$04:E898 E8 INX ; \
$04:E899 E8 INX ; / X += 2
$04:E89A A5 08 LDA $08 ; A = tiles left for this record
$04:E89C 0A ASL ; A *= 2
$04:E89D 3A DEC A ; A -= 1
$04:E89E EB XBA ; Swap to big-endian
$04:E89F 9F 7D 83 7F STA.L $7F837D,X ; Store its length
$04:E8A3 E8 INX ; \
$04:E8A4 E8 INX ; / X += 2
$04:E8A5 C6 04 DEC $04 ; Next column
$04:E8A7 10 C0 BPL $E869 ; Loop for all columns
$04:E8A9 A5 02 LDA $02 ; A = VRAM address
$04:E8AB EB XBA ; Swap bytes
$04:E8AC 18 CLC ; Clear carry
$04:E8AD 69 20 00 ADC.W #$0020 ; Next tilemap row (+$20)
$04:E8B0 EB XBA ; Swap back
$04:E8B1 85 02 STA $02 ; [$02] = VRAM address of the next row
$04:E8B3 A5 00 LDA $00 ; A = source offset
$04:E8B5 A8 TAY ; Y = source offset
$04:E8B6 18 CLC ; Clear carry
$04:E8B7 69 40 00 ADC.W #$0040 ; Next source row (+$40 bytes)
$04:E8BA 85 00 STA $00 ; [$00] = source offset
$04:E8BC 29 C0 07 AND.W #$07C0 ; Crossed a 32-row boundary?
$04:E8BF D0 1B BNE $E8DC ; No: go on
$04:E8C1 98 TYA ; A = old offset
$04:E8C2 29 3F F8 AND.W #$F83F ; Keep column bits
$04:E8C5 18 CLC ; Clear carry
$04:E8C6 69 00 10 ADC.W #$1000 ; Next 32x32 block (+$1000)
$04:E8C9 85 00 STA $00 ; [$00] = source offset
$04:E8CB A5 02 LDA $02 ; A = VRAM address
$04:E8CD EB XBA ; Swap bytes
$04:E8CE 38 SEC ; Set carry
$04:E8CF E9 20 00 SBC.W #$0020 ; Back one row (-$20)
$04:E8D2 29 1F 34 AND.W #$341F ; Mask
$04:E8D5 18 CLC ; Clear carry
$04:E8D6 69 00 08 ADC.W #$0800 ; Next VRAM screen (+$0800)
$04:E8D9 EB XBA ; Swap back
$04:E8DA 85 02 STA $02 ; [$02] = VRAM address
$04:E8DC C6 06 DEC $06 ; Next row
$04:E8DE 30 03 BMI $E8E3 ; All six rows done: return
$04:E8E0 4C 2E E8 JMP.W $E82E ; Loop for the next row
$04:E8E3 60 RTS ; Return
;;; $E8E4..E90C: Table: event numbers for map edits ;;;
;; 44 entries; each is matched against [$1DEA] by $E9EC.
$04:E8E4 .db $06,$06,$06,$06,$06,$06,$06,$06 ; Event numbers 0-7 ($06 x8)
$04:E8EC .db $14,$14,$14,$14,$14,$1D,$1D,$1D ; Event numbers 8-15
$04:E8F4 .db $1D,$12,$12,$12,$1C,$2F,$2F,$2F ; Event numbers 16-23
$04:E8FC .db $2F,$2F,$34,$34,$34,$47,$4E,$4E ; Event numbers 24-31
$04:E904 .db $01,$0F,$24,$24,$6C,$0F,$0F,$54 ; Event numbers 32-39
$04:E90C .db $55,$57,$58,$5D ; Event numbers 40-43
;;; $E910..E938: Table: map edit type flags ;;;
$04:E910 .db $00,$00,$00,$00,$00,$00,$01,$01 ; Entry type flags 0-7 (bit 0 set: use $E4A9 on layer 2, else write a layer 1 tile)
$04:E918 .db $00,$01,$01,$01,$01,$01,$01,$01 ; Entry type flags 8-15 (bit 0 set: use $E4A9 on layer 2, else write a layer 1 tile)
$04:E920 .db $00,$01,$01,$00,$00,$01,$01,$01 ; Entry type flags 16-23 (bit 0 set: use $E4A9 on layer 2, else write a layer 1 tile)
$04:E928 .db $01,$01,$01,$01,$01,$00,$01,$00 ; Entry type flags 24-31 (bit 0 set: use $E4A9 on layer 2, else write a layer 1 tile)
$04:E930 .db $00,$01,$01,$01,$01,$01,$00,$00 ; Entry type flags 32-39 (bit 0 set: use $E4A9 on layer 2, else write a layer 1 tile)
$04:E938 .db $00,$00,$00,$00 ; Entry type flags 40-43
;;; $E93C..E98C: Table: map edit destination offsets ;;;
$04:E93C .db $15,$02,$35,$02,$45,$02,$55,$02 ; Entry destination offsets 0-3 (words)
$04:E944 .db $65,$02,$75,$02,$14,$11,$94,$10 ; Entry destination offsets 4-7 (words)
$04:E94C .db $A9,$00,$A4,$05,$24,$05,$28,$07 ; Entry destination offsets 8-11 (words)
$04:E954 .db $A4,$06,$A8,$01,$AC,$01,$B0,$01 ; Entry destination offsets 12-15 (words)
$04:E95C .db $3C,$00,$00,$29,$80,$28,$10,$05 ; Entry destination offsets 16-19 (words)
$04:E964 .db $54,$01,$30,$18,$B0,$18,$2E,$19 ; Entry destination offsets 20-23 (words)
$04:E96C .db $2A,$19,$26,$19,$24,$18,$20,$18 ; Entry destination offsets 24-27 (words)
$04:E974 .db $1C,$18,$97,$05,$EC,$2A,$7B,$05 ; Entry destination offsets 28-31 (words)
$04:E97C .db $12,$02,$94,$31,$A0,$32,$20,$33 ; Entry destination offsets 32-35 (words)
$04:E984 .db $16,$1D,$14,$31,$25,$06,$F0,$01 ; Entry destination offsets 36-39 (words)
$04:E98C .db $F0,$01,$04,$03,$04,$03,$27,$02 ; Entry destination offsets 40-43 (words)
;;; $E994..E9E4: Table: map edit values ;;;
$04:E994 .db $68,$00,$24,$00,$24,$00,$25,$00 ; Entry values 0-3 (words: tile number or source index)
$04:E99C .db $00,$00,$81,$00,$38,$09,$28,$09 ; Entry values 4-7 (words: tile number or source index)
$04:E9A4 .db $66,$00,$9C,$09,$28,$09,$F8,$09 ; Entry values 8-11 (words: tile number or source index)
$04:E9AC .db $FC,$09,$98,$09,$98,$09,$28,$09 ; Entry values 12-15 (words: tile number or source index)
$04:E9B4 .db $66,$00,$38,$09,$28,$09,$66,$00 ; Entry values 16-19 (words: tile number or source index)
$04:E9BC .db $68,$00,$80,$0A,$84,$0A,$88,$0A ; Entry values 20-23 (words: tile number or source index)
$04:E9C4 .db $98,$09,$98,$09,$94,$09,$98,$09 ; Entry values 24-27 (words: tile number or source index)
$04:E9CC .db $8C,$0A,$66,$00,$84,$03,$66,$00 ; Entry values 28-31 (words: tile number or source index)
$04:E9D4 .db $79,$00,$A8,$0A,$38,$09,$38,$09 ; Entry values 32-35 (words: tile number or source index)
$04:E9DC .db $A0,$09,$30,$0A,$69,$00,$5F,$00 ; Entry values 36-39 (words: tile number or source index)
$04:E9E4 .db $5F,$00,$5F,$00,$5F,$00,$5F,$00 ; Entry values 40-43 (words: tile number or source index)
;;; $E9EC: Overworld event: apply edits, fade tiles ;;;
;; State 7 ($E9EC): applies every matching map edit from the four tables, then ends the event: [$1B86] =
;; 0, [$13D9]++, marks
;; the event in [$1F02] and clears [$1DE9].
;; $04EA62: builds the palette upload buffer at $0907. $04EAA4: state 4, fades the event tile in as 36 OAM
;; sprites until timer [$1495] reaches $40,
;; then draws the layer 2 tile and moves to the next one.
$04:E9EC AD EA 1D LDA.W $1DEA ; A = event number [$1DEA]
$04:E9EF 85 0F STA $0F ; [$0F] = event number
$04:E9F1 A2 2B LDX.B #$2B ; X = $2B: search the 44 entries
$04:E9F3 DF E4 E8 04 CMP.L $E8E4,X ; Entry belongs to this event?
$04:E9F7 F0 2C BEQ $EA25 ; Yes: apply it ($04EA25)
$04:E9F9 CA DEX ; Next entry
$04:E9FA 10 F7 BPL $E9F3 ; Loop for X = $2B..0
$04:E9FC AD 86 1B LDA.W $1B86 ; A = [$1B86]
$04:E9FF F0 23 BEQ $EA24 ; Already 0: nothing more to do
$04:EA01 9C 86 1B STZ.W $1B86 ; [$1B86] = 0: event state machine finished
$04:EA04 EE D9 13 INC.W $13D9 ; Advance the OW process [$13D9]++
$04:EA07 AD EA 1D LDA.W $1DEA ; A = event number
$04:EA0A 29 07 AND.B #$07 ; Bit within the byte
$04:EA0C AA TAX ; X = bit index
$04:EA0D AD EA 1D LDA.W $1DEA ; A = event number
$04:EA10 4A LSR ; \
$04:EA11 4A LSR ; } A /= 8
$04:EA12 4A LSR ; /
$04:EA13 A8 TAY ; Y = byte index
$04:EA14 B9 02 1F LDA.W $1F02,Y ; A = event-passed flags [$1F02+Y]
$04:EA17 1F 4B E4 04 ORA.L $E44B,X ; Set this event's bit
$04:EA1B 99 02 1F STA.W $1F02,Y ; Save: event is now done
$04:EA1E EE 2E 1F INC.W $1F2E ; [$1F2E]++ (count of events triggered, probably)
$04:EA21 9C E9 1D STZ.W $1DE9 ; [$1DE9] = 0: no event pending
$04:EA24 60 RTS ; Return
$04:EA25 DA PHX ; Save the entry index
$04:EA26 BF 10 E9 04 LDA.L $E910,X ; A = entry type flag
$04:EA2A 85 02 STA $02 ; [$02] = flag
$04:EA2C 8A TXA ; A = X
$04:EA2D 0A ASL ; A *= 2
$04:EA2E AA TAX ; X = word offset
$04:EA2F C2 20 REP #$20 ; A 16-bit
$04:EA31 BF 94 E9 04 LDA.L $E994,X ; A = entry value
$04:EA35 85 00 STA $00 ; [$00] = value
$04:EA37 BF 3C E9 04 LDA.L $E93C,X ; A = entry destination offset
$04:EA3B 85 04 STA $04 ; [$04] = destination
$04:EA3D A5 02 LDA $02 ; A = flag
$04:EA3F 29 01 00 AND.W #$0001 ; Bit 0
$04:EA42 F0 0A BEQ $EA4E ; Clear: write a layer 1 tile ($04EA4E)
$04:EA44 C2 10 REP #$10 ; Index 16-bit
$04:EA46 A4 00 LDY $00 ; Y = [$00] (source index)
$04:EA48 20 A9 E4 JSR.W $E4A9 ; Copy the tile into the layer 2 map ($E4A9)
$04:EA4B 4C 5A EA JMP.W $EA5A ; Continue at $04EA5A
$04:EA4E E2 20 SEP #$20 ; A 8-bit
$04:EA50 C2 10 REP #$10 ; Index 16-bit
$04:EA52 A6 04 LDX $04 ; X = destination offset
$04:EA54 A5 00 LDA $00 ; A = tile number
$04:EA56 9F 00 C8 7E STA.L $7EC800,X ; Write it into the OW layer 1 map ($7E:C800)
$04:EA5A E2 30 SEP #$30 ; A, X and Y 8-bit
$04:EA5C FA PLX ; Restore the entry index
$04:EA5D A5 0F LDA $0F ; A = event number
$04:EA5F 4C F9 E9 JMP.W $E9F9 ; Continue searching
$04:EA62 9C 95 14 STZ.W $1495 ; [$1495] = 0 (event timer)
$04:EA65 9C 94 14 STZ.W $1494 ; [$1494] = 0
$04:EA68 A2 6F LDX.B #$6F ; X = $6F
$04:EA6A BD 03 07 LDA.W $0703,X ; A = palette mirror byte [$0703+X]
$04:EA6D 9D 07 09 STA.W $0907,X ; Copy it to the upload buffer [$0907+X]
$04:EA70 9E 79 09 STZ.W $0979,X ; Clear [$0979+X]
$04:EA73 CA DEX ; X--
$04:EA74 10 F4 BPL $EA6A ; Loop for $70 bytes
$04:EA76 A2 6F LDX.B #$6F ; X = $6F
$04:EA78 A0 10 LDY.B #$10 ; Y = $10: 16 bytes per row
$04:EA7A BD 83 07 LDA.W $0783,X ; A = palette byte [$0783+X]
$04:EA7D 9D 07 09 STA.W $0907,X ; Copy it to [$0907+X] (overwrites with the second palette half)
$04:EA80 CA DEX ; X--
$04:EA81 88 DEY ; Y--
$04:EA82 D0 F6 BNE $EA7A ; Loop for 16 bytes
$04:EA84 8A TXA ; A = X
$04:EA85 38 SEC ; Set carry
$04:EA86 E9 10 SBC.B #$10 ; A -= $10
$04:EA88 AA TAX ; X = A
$04:EA89 10 ED BPL $EA78 ; Loop while X >= 0
$04:EA8B C2 20 REP #$20 ; A 16-bit
$04:EA8D A9 70 00 LDA.W #$0070 ; A = $0070
$04:EA90 8D 05 09 STA.W $0905 ; [$0905] = $0070 (upload record: size)
$04:EA93 A9 70 C0 LDA.W #$C070 ; A = $C070
$04:EA96 8D 77 09 STA.W $0977 ; [$0977] = $C070 (upload record: CGRAM address / flags)
$04:EA99 E2 20 SEP #$20 ; A 8-bit
$04:EA9B 9C E9 09 STZ.W $09E9 ; [$09E9] = 0 (end of upload records)
$04:EA9E A9 03 LDA.B #$03 ; A = 3
$04:EAA0 8D 80 06 STA.W $0680 ; [$0680] = 3: request palette upload (probably)
$04:EAA3 60 RTS ; Return
$04:EAA4 AD 95 14 LDA.W $1495 ; \
$04:EAA7 C9 40 CMP.B #$40 ; } Timer [$1495] < $40: not time for the next tile yet ($04EAC9)
$04:EAA9 90 1E BCC $EAC9 ; /
$04:EAAB EE 86 1B INC.W $1B86 ; Go to state 5: [$1B86]++
$04:EAAE 20 30 EE JSR.W $EE30 ; Draw the layer 2 tile into the map ($EE30)
$04:EAB1 20 96 E4 JSR.W $E496 ; Update the layer 2 map from the event tile ($E496)
$04:EAB4 C2 20 REP #$20 ; A 16-bit
$04:EAB6 EE EB 1D INC.W $1DEB ; [$1DEB]++: next event tile
$04:EAB9 AD EB 1D LDA.W $1DEB ; A = [$1DEB]
$04:EABC CD ED 1D CMP.W $1DED ; \
$04:EABF E2 20 SEP #$20 ; / Reached the end index [$1DED]? A 8-bit
$04:EAC1 B0 05 BCS $EAC8 ; Yes: return, stay in state 5
$04:EAC3 A9 03 LDA.B #$03 ; A = 3
$04:EAC5 8D 86 1B STA.W $1B86 ; [$1B86] = 3: lay the next event tile
$04:EAC8 60 RTS ; Return
$04:EAC9 20 67 EC JSR.W $EC67 ; Compute screen position of the effect ($EC67)
$04:EACC C2 30 REP #$30 ; A, X and Y 16-bit
$04:EACE A0 8C 00 LDY.W #$008C ; Y = $008C: OAM offset for the 6x6 tile sprite set
$04:EAD1 A2 06 00 LDX.W #$0006 ; X = 6: columns
$04:EAD4 AD 84 1B LDA.W $1B84 ; A = [$1B84] (tile source index)
$04:EAD7 C9 00 09 CMP.W #$0900 ; Compare with $0900
$04:EADA 90 06 BCC $EAE2 ; Below: 6x6
$04:EADC A0 0C 00 LDY.W #$000C ; Y = $000C: OAM offset for 2x2
$04:EADF A2 02 00 LDX.W #$0002 ; X = 2: columns
$04:EAE2 86 05 STX $05 ; [$05] = columns
$04:EAE4 AA TAX ; X = tile source index
$04:EAE5 E2 20 SEP #$20 ; A 8-bit
$04:EAE7 A5 05 LDA $05 ; A = columns
$04:EAE9 85 03 STA $03 ; [$03] = column counter
$04:EAEB A5 00 LDA $00 ; A = X position
$04:EAED 85 02 STA $02 ; [$02] = X position of this tile
$04:EAEF A5 01 LDA $01 ; A = Y position
$04:EAF1 99 51 03 STA.W $0351,Y ; OAM Y of the tile ($0351+Y)
$04:EAF4 BF 00 80 0C LDA.L $8000,X ; A = tile number from $8000[X]
$04:EAF8 99 52 03 STA.W $0352,Y ; OAM tile number
$04:EAFB BF 00 00 7F LDA.L $7F0000,X ; A = attribute byte from $7F:0000[X]
$04:EAFF 29 C0 AND.B #$C0 ; Keep flip bits (6-7)
$04:EB01 85 04 STA $04 ; [$04] = flips
$04:EB03 BF 00 00 7F LDA.L $7F0000,X ; A = attribute byte
$04:EB07 29 1C AND.B #$1C ; Keep palette bits (2-4)
$04:EB09 4A LSR ; Palette to bits 1-3
$04:EB0A 05 04 ORA $04 ; Add flips
$04:EB0C 09 11 ORA.B #$11 ; Priority 1 and sprite page 1
$04:EB0E 99 53 03 STA.W $0353,Y ; OAM properties
$04:EB11 A5 02 LDA $02 ; A = X position
$04:EB13 99 50 03 STA.W $0350,Y ; OAM X of the tile ($0350+Y)
$04:EB16 18 CLC ; Clear carry
$04:EB17 69 08 ADC.B #$08 ; X position += 8
$04:EB19 E8 INX ; Next tile in the source
$04:EB1A 88 DEY ; \
$04:EB1B 88 DEY ; |
$04:EB1C 88 DEY ; } Y -= 4: previous OAM slot
$04:EB1D 88 DEY ; /
$04:EB1E C6 03 DEC $03 ; Next column
$04:EB20 D0 CB BNE $EAED ; Loop for the columns
$04:EB22 A5 01 LDA $01 ; A = Y position
$04:EB24 18 CLC ; Clear carry
$04:EB25 69 08 ADC.B #$08 ; Next row: += 8
$04:EB27 85 01 STA $01 ; [$01] = Y position
$04:EB29 C0 FC FF CPY.W #$FFFC ; All OAM slots done (Y wrapped to $FFFC)?
$04:EB2C D0 B9 BNE $EAE7 ; No: next row
$04:EB2E E2 10 SEP #$10 ; Index 8-bit
$04:EB30 A2 23 LDX.B #$23 ; X = $23
$04:EB32 9E 74 04 STZ.W $0474,X ; OAM size bits [$0474+X] = 0 (small)
$04:EB35 CA DEX ; X--
$04:EB36 10 FA BPL $EB32 ; Loop for 36 sprites
$04:EB38 A0 08 LDY.B #$08 ; Y = 8
$04:EB3A AE B3 0D LDX.W $0DB3 ; X = [$0DB3] (current player)
$04:EB3D BD 11 1F LDA.W $1F11,X ; A = OW submap [$1F11+X]
$04:EB40 C9 03 CMP.B #$03 ; Submap 3?
$04:EB42 D0 02 BNE $EB46 ; No: keep Y = 8
$04:EB44 A0 01 LDY.B #$01 ; Y = 1 (one pass on this submap)
$04:EB46 84 8A STY $8A ; [$8A] = pass counter
$04:EB48 AD 95 14 LDA.W $1495 ; A = timer [$1495]
$04:EB4B 22 06 B0 00 JSL.L $B006 ; Run the palette fade step ($B006)
$04:EB4F C6 8A DEC $8A ; Next pass
$04:EB51 D0 F5 BNE $EB48 ; Loop
$04:EB53 4C 8B EA JMP.W $EA8B ; Finish through the palette upload setup ($04EA8B)
;;; $EB56..EB7E: Table: puff sprite X offsets ;;;
$04:EB56 .db $F5,$11,$F2,$15,$F5,$11,$F3,$14 ; Puff sprite X offsets (4 per frame): frames 0-1
$04:EB5E .db $F5,$11,$F3,$14,$F6,$10,$F4,$13 ; Puff sprite X offsets: frames 2-3
$04:EB66 .db $F7,$0F,$F5,$12,$F8,$0E,$F7,$11 ; Puff sprite X offsets: frames 4-5
$04:EB6E .db $FA,$0D,$F9,$10,$FC,$0C,$FB,$0D ; Puff sprite X offsets: frames 6-7
$04:EB76 .db $FF,$0A,$FE,$0B,$01,$07,$01,$07 ; Puff sprite X offsets: frames 8-9
$04:EB7E .db $00,$08,$00,$08 ; Puff sprite X offsets: frames 10
;;; $EB82..EBAA: Table: puff sprite Y offsets ;;;
$04:EB82 .db $F8,$F8,$11,$12,$F8,$F8,$10,$11 ; Puff sprite Y offsets (4 per frame): frames 0-1
$04:EB8A .db $F8,$F8,$10,$11,$F9,$F9,$0F,$10 ; Puff sprite Y offsets: frames 2-3
$04:EB92 .db $FA,$FA,$0E,$0F,$FB,$FB,$0C,$0D ; Puff sprite Y offsets: frames 4-5
$04:EB9A .db $FC,$FC,$0B,$0B,$FE,$FE,$0A,$0A ; Puff sprite Y offsets: frames 6-7
$04:EBA2 .db $00,$00,$08,$08,$01,$01,$07,$07 ; Puff sprite Y offsets: frames 8-9
$04:EBAA .db $00,$00,$08,$08 ; Puff sprite Y offsets: frames 10
;;; $EBAE..EBD6: Table: puff sprite properties ;;;
$04:EBAE .db $F6,$B6,$76,$36,$F6,$B6,$76,$36 ; Puff sprite properties (flip and palette): frames 0-1
$04:EBB6 .db $36,$76,$B6,$F6,$36,$76,$B6,$F6 ; Puff sprite properties: frames 2-3
$04:EBBE .db $36,$36,$36,$36,$36,$36,$36,$36 ; Puff sprite properties: frames 4-5
$04:EBC6 .db $36,$36,$36,$36,$36,$36,$36,$36 ; Puff sprite properties: frames 6-7
$04:EBCE .db $36,$36,$36,$36,$36,$36,$36,$36 ; Puff sprite properties: frames 8-9
$04:EBD6 .db $30,$70,$B0,$F0 ; Puff sprite properties: frames 10
;;; $EBDA..EBE9: Table: puff tile numbers (state 6) ;;;
$04:EBDA .db $22,$23,$32,$33,$32,$23,$22 ; Puff tile numbers for state 6 (indexed by timer / 4)
$04:EBE1 .db $73,$73,$72,$72,$5F,$5F,$28,$28 ; Puff tile numbers for state 1 (indexed by timer / 4)
$04:EBE9 .db $28,$28 ; (continued)
;;; $EBEB: Overworld event: smoke puff, level tile ;;;
;; States 1 and 6: animate a four-sprite smoke puff at ([$1B82],[$1B83]) while timer [$1B84] counts down.
;; State 1 uses $EBE1 tiles,
;; state 6 uses $EBDA. At timer $10 (state 6) the level tile is replaced; at $18 (state 1) $EEAA
;; runs.
;; $04EC67: converts effect position to screen position ([$00],[$01]). $04EC78: state 5, checks the level tile
;; at the event position and starts the reveal.
$04:EBEB CE 84 1B DEC.W $1B84 ; Timer [$1B84]--
$04:EBEE 10 04 BPL $EBF4 ; Still >= 0: animate ($04EBF4)
$04:EBF0 EE 86 1B INC.W $1B86 ; Timer expired: next state [$1B86]++
$04:EBF3 60 RTS ; Return
$04:EBF4 AD 84 1B LDA.W $1B84 ; A = timer
$04:EBF7 AC 86 1B LDY.W $1B86 ; Y = state [$1B86]
$04:EBFA C0 01 CPY.B #$01 ; State 1?
$04:EBFC F0 19 BEQ $EC17 ; Yes: go to $04EC17
$04:EBFE C9 10 CMP.B #$10 ; Timer = $10?
$04:EC00 D0 05 BNE $EC07 ; No
$04:EC02 48 PHA ; Save timer
$04:EC03 20 83 ED JSR.W $ED83 ; Replace the level tile on the map ($ED83)
$04:EC06 68 PLA ; Restore timer
$04:EC07 4A LSR ; \
$04:EC08 4A LSR ; / A = timer / 4
$04:EC09 AA TAX ; X = frame
$04:EC0A BD DA EB LDA.W $EBDA,X ; A = puff tile number
$04:EC0D 85 02 STA $02 ; [$02] = tile
$04:EC0F 20 67 EC JSR.W $EC67 ; Compute the on-screen position ($EC67)
$04:EC12 A2 28 LDX.B #$28 ; X = $28: sprite data offset for this puff
$04:EC14 4C 2E EC JMP.W $EC2E ; Draw it ($04EC2E)
$04:EC17 C9 18 CMP.B #$18 ; Timer = $18?
$04:EC19 D0 05 BNE $EC20 ; No
$04:EC1B 48 PHA ; Save timer
$04:EC1C 20 AA EE JSR.W $EEAA ; Update the tile for the level to reveal ($EEAA)
$04:EC1F 68 PLA ; Restore timer
$04:EC20 29 FC AND.B #$FC ; A = timer AND $FC
$04:EC22 AA TAX ; X = sprite data offset (4 bytes per frame)
$04:EC23 4A LSR ; \
$04:EC24 4A LSR ; / A = timer / 4
$04:EC25 A8 TAY ; Y = frame
$04:EC26 B9 E1 EB LDA.W $EBE1,Y ; A = puff tile number
$04:EC29 85 02 STA $02 ; [$02] = tile
$04:EC2B 20 67 EC JSR.W $EC67 ; Compute the on-screen position ($EC67)
$04:EC2E A9 03 LDA.B #$03 ; A = 3
$04:EC30 85 03 STA $03 ; [$03] = 3: four sprites
$04:EC32 A0 00 LDY.B #$00 ; Y = 0: OAM offset (slots $0280..)
$04:EC34 A5 00 LDA $00 ; A = effect X
$04:EC36 18 CLC ; Clear carry
$04:EC37 7D 56 EB ADC.W $EB56,X ; Add the sprite X offset
$04:EC3A 99 80 02 STA.W $0280,Y ; OAM X
$04:EC3D A5 01 LDA $01 ; A = effect Y
$04:EC3F 18 CLC ; Clear carry
$04:EC40 7D 82 EB ADC.W $EB82,X ; Add the sprite Y offset
$04:EC43 99 81 02 STA.W $0281,Y ; OAM Y
$04:EC46 A5 02 LDA $02 ; A = tile number
$04:EC48 99 82 02 STA.W $0282,Y ; OAM tile
$04:EC4B BD AE EB LDA.W $EBAE,X ; A = properties
$04:EC4E 99 83 02 STA.W $0283,Y ; OAM properties
$04:EC51 C8 INY ; \
$04:EC52 C8 INY ; |
$04:EC53 C8 INY ; } Y += 4: next OAM slot
$04:EC54 C8 INY ; /
$04:EC55 E8 INX ; X++
$04:EC56 C6 03 DEC $03 ; Next sprite
$04:EC58 10 DA BPL $EC34 ; Loop for 4 sprites
$04:EC5A 9C 40 04 STZ.W $0440 ; OAM size bit [$0440] = 0 (small)
$04:EC5D 9C 41 04 STZ.W $0441 ; [$0441] = 0
$04:EC60 9C 42 04 STZ.W $0442 ; [$0442] = 0
$04:EC63 9C 43 04 STZ.W $0443 ; [$0443] = 0
$04:EC66 60 RTS ; Return
$04:EC67 AD 82 1B LDA.W $1B82 ; A = effect X [$1B82]
$04:EC6A 38 SEC ; Set carry
$04:EC6B E5 1E SBC $1E ; Minus layer 1 X scroll [$1E]
$04:EC6D 85 00 STA $00 ; [$00] = screen X
$04:EC6F AD 83 1B LDA.W $1B83 ; A = effect Y [$1B83]
$04:EC72 18 CLC ; Clear carry (subtract one more)
$04:EC73 E5 20 SBC $20 ; Minus layer 1 Y scroll [$20] and 1
$04:EC75 85 01 STA $01 ; [$01] = screen Y
$04:EC77 60 RTS ; Return
$04:EC78 A9 7E LDA.B #$7E ; A = $7E
$04:EC7A 85 0F STA $0F ; [$0F] = $7E
$04:EC7C C2 30 REP #$30 ; A, X and Y 16-bit
$04:EC7E A9 00 C8 LDA.W #$C800 ; A = $C800
$04:EC81 85 0D STA $0D ; [$0D] = $7EC800 (OW layer 1 map)
$04:EC83 AD EA 1D LDA.W $1DEA ; A = event number
$04:EC86 29 FF 00 AND.W #$00FF ; Keep 8 bits
$04:EC89 0A ASL ; A *= 2
$04:EC8A AA TAX ; X = word offset
$04:EC8B BF 5D D8 04 LDA.L $D85D,X ; A = map position of this event's level tile ($D85D)
$04:EC8F A8 TAY ; Y = map position
$04:EC90 A2 15 00 LDX.W #$0015 ; X = $15: search 22 tile numbers
$04:EC93 E2 20 SEP #$20 ; A 8-bit
$04:EC95 B7 0D LDA [$0D],Y ; A = tile currently on the map
$04:EC97 DF 1D DA 04 CMP.L $DA1D,X ; Compare with the table ($DA1D)
$04:EC9B F0 0B BEQ $ECA8 ; Match: reveal it
$04:EC9D CA DEX ; Next entry
$04:EC9E 10 F7 BPL $EC97 ; Loop for X = $15..0
$04:ECA0 E2 10 SEP #$10 ; Index 8-bit
$04:ECA2 A9 07 LDA.B #$07 ; A = 7
$04:ECA4 8D 86 1B STA.W $1B86 ; [$1B86] = 7: no level tile, finish
$04:ECA7 60 RTS ; Return
$04:ECA8 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:ECAA A9 01 LDA.B #$01 ; A = 1
$04:ECAC 8D FC 1D STA.W $1DFC ; Play sound effect 1 (level tile appears)
$04:ECAF EE 86 1B INC.W $1B86 ; Go to state 6: [$1B86]++
$04:ECB2 AD EA 1D LDA.W $1DEA ; A = event number
$04:ECB5 29 FF AND.B #$FF ; Keep 8 bits
$04:ECB7 0A ASL ; A *= 2
$04:ECB8 AA TAX ; X = word offset
$04:ECB9 BF 5D D8 04 LDA.L $D85D,X ; A = map position (low byte)
$04:ECBD 0A ASL ; \
$04:ECBE 0A ASL ; |
$04:ECBF 0A ASL ; } A <<= 4
$04:ECC0 0A ASL ; /
$04:ECC1 8D 82 1B STA.W $1B82 ; [$1B82] = effect X
$04:ECC4 BF 5D D8 04 LDA.L $D85D,X ; A = map position (low byte)
$04:ECC8 29 F0 AND.B #$F0 ; Keep high nibble
$04:ECCA 8D 83 1B STA.W $1B83 ; [$1B83] = effect Y
$04:ECCD A9 1C LDA.B #$1C ; A = $1C
$04:ECCF 8D 84 1B STA.W $1B84 ; [$1B84] = $1C (puff timer)
$04:ECD2 60 RTS ; Return
;;; $ECD3..ED7B: Table: level tile 2x2 graphics ;;;
;; 22 entries of 8 bytes: four tilemap words (tile, properties). Probably indexed like $DA1D by
;; $ED83.
$04:ECD3 .db $86,$99,$86,$19,$86,$D9,$86,$59 ; Tile word pairs for level tile type 0 (4 tiles: tile, properties)
$04:ECDB .db $96,$99,$96,$19,$96,$D9,$96,$59 ; Tile word pairs for level tile type 1 (4 tiles: tile, properties)
$04:ECE3 .db $86,$9D,$86,$1D,$86,$DD,$86,$5D ; Tile word pairs for level tile type 2 (4 tiles: tile, properties)
$04:ECEB .db $96,$9D,$96,$1D,$96,$DD,$96,$5D ; Tile word pairs for level tile type 3 (4 tiles: tile, properties)
$04:ECF3 .db $86,$99,$86,$19,$86,$D9,$86,$59 ; Tile word pairs for level tile type 4 (4 tiles: tile, properties)
$04:ECFB .db $96,$99,$96,$19,$96,$D9,$96,$59 ; Tile word pairs for level tile type 5 (4 tiles: tile, properties)
$04:ED03 .db $86,$9D,$86,$1D,$86,$DD,$86,$5D ; Tile word pairs for level tile type 6 (4 tiles: tile, properties)
$04:ED0B .db $96,$9D,$96,$1D,$96,$DD,$96,$5D ; Tile word pairs for level tile type 7 (4 tiles: tile, properties)
$04:ED13 .db $88,$15,$98,$15,$89,$15,$99,$15 ; Tile word pairs for level tile type 8 (4 tiles: tile, properties)
$04:ED1B .db $A4,$11,$B4,$11,$A5,$11,$B5,$11 ; Tile word pairs for level tile type 9 (4 tiles: tile, properties)
$04:ED23 .db $22,$11,$90,$11,$22,$11,$91,$11 ; Tile word pairs for level tile type 10 (4 tiles: tile, properties)
$04:ED2B .db $C2,$11,$D2,$11,$C3,$11,$D3,$11 ; Tile word pairs for level tile type 11 (4 tiles: tile, properties)
$04:ED33 .db $A6,$11,$B6,$11,$A7,$11,$B7,$11 ; Tile word pairs for level tile type 12 (4 tiles: tile, properties)
$04:ED3B .db $82,$19,$92,$19,$83,$19,$93,$19 ; Tile word pairs for level tile type 13 (4 tiles: tile, properties)
$04:ED43 .db $C8,$19,$F8,$19,$C9,$19,$F9,$19 ; Tile word pairs for level tile type 14 (4 tiles: tile, properties)
$04:ED4B .db $80,$1C,$90,$1C,$81,$1C,$90,$5C ; Tile word pairs for level tile type 15 (4 tiles: tile, properties)
$04:ED53 .db $80,$14,$90,$14,$81,$14,$90,$54 ; Tile word pairs for level tile type 16 (4 tiles: tile, properties)
$04:ED5B .db $A2,$11,$B2,$11,$A3,$11,$B3,$11 ; Tile word pairs for level tile type 17 (4 tiles: tile, properties)
$04:ED63 .db $82,$1D,$92,$1D,$83,$1D,$93,$1D ; Tile word pairs for level tile type 18 (4 tiles: tile, properties)
$04:ED6B .db $86,$99,$86,$19,$86,$D9,$86,$59 ; Tile word pairs for level tile type 19 (4 tiles: tile, properties)
$04:ED73 .db $86,$99,$86,$19,$86,$D9,$86,$59 ; Tile word pairs for level tile type 20 (4 tiles: tile, properties)
$04:ED7B .db $A8,$11,$B8,$11,$A9,$11,$B9,$11 ; Tile word pairs for level tile type 21 (4 tiles: tile, properties)
;;; $ED83: Replace event tile and draw 2x2 stripe ;;;
;; Overworld event: finds the layer 1 tile at the current event position in $DA1D, writes the matching
;; replacement tile ($DA33) into the map at $7E:C800 and queues two stripe records (2x2 tiles) for the
;; new graphic.
;; Second routine at $04EE30: draws a layer 2 event tile run and terminates the stripe buffer. Details of the
;; $1DEA/$1DEB tables are inferred.
;; Called by:
;; $04:EC03: Overworld event: smoke puff, level tile
$04:ED83 A9 7E LDA.B #$7E ; \
$04:ED85 85 0F STA $0F ; / $0F = $7E: bank of the pointer at [$0D] (layer 1 map $7E:C800)
$04:ED87 C2 30 REP #$30 ; \
$04:ED89 A9 00 C8 LDA.W #$C800 ; } [$0D] = $7EC800: 24-bit pointer to the overworld layer 1 tile map
$04:ED8C 85 0D STA $0D ; /
$04:ED8E AD EA 1D LDA.W $1DEA ; \
$04:ED91 29 FF 00 AND.W #$00FF ; |
$04:ED94 0A ASL ; |
$04:ED95 AA TAX ; |
$04:ED96 BF 5D D8 04 LDA.L $D85D,X ; } Y = $D85D[[$1DEA] * 2]: map offset of the current submap tile row
$04:ED9A A8 TAY ; /
$04:ED9B A2 15 00 LDX.W #$0015 ; X = $15: search index into $DA1D (22 tile numbers)
$04:ED9E E2 20 SEP #$20 ; A 8-bit
$04:EDA0 B7 0D LDA [$0D],Y ; A = layer 1 tile currently at this map position
$04:EDA2 DF 1D DA 04 CMP.L $DA1D,X ; Compare with $DA1D[X]
$04:EDA6 F0 03 BEQ $EDAB ; Match found: stop searching
$04:EDA8 CA DEX ; \
$04:EDA9 D0 F7 BNE $EDA2 ; / X--; loop until X = 0 (no match leaves X = 0)
$04:EDAB C2 30 REP #$30 ; A, X and Y 16-bit
$04:EDAD 86 0E STX $0E ; [$0E] = X: index of the tile found (event tile type)
$04:EDAF AD EA 1D LDA.W $1DEA ; \
$04:EDB2 29 FF 00 AND.W #$00FF ; |
$04:EDB5 0A ASL ; |
$04:EDB6 AA TAX ; |
$04:EDB7 BF 3D D9 04 LDA.L $D93D,X ; } [$00] = $D93D[[$1DEA] * 2]: VRAM address of this submap tile
$04:EDBB 85 00 STA $00 ; /
$04:EDBD BF 5D D8 04 LDA.L $D85D,X ; \
$04:EDC1 AA TAX ; } Save X = $D85D[[$1DEA] * 2] (map offset)
$04:EDC2 DA PHX ; /
$04:EDC3 A6 0E LDX $0E ; X = [$0E]
$04:EDC5 E2 20 SEP #$20 ; A 8-bit
$04:EDC7 BF 33 DA 04 LDA.L $DA33,X ; A = $DA33[X]: replacement tile number for this tile type
$04:EDCB FA PLX ; Restore the map offset
$04:EDCC 9F 00 C8 7E STA.L $7EC800,X ; Write the new tile into the layer 1 map at $7E:C800 + offset
$04:EDD0 A9 04 LDA.B #$04 ; \
$04:EDD2 85 0C STA $0C ; / [$0C] = 4: bank of the pointer at [$0A]
$04:EDD4 C2 20 REP #$20 ; A 16-bit
$04:EDD6 A9 D3 EC LDA.W #$ECD3 ; \
$04:EDD9 85 0A STA $0A ; / [$0A] = $04ECD3: table of 4 tile words per tile type
$04:EDDB A5 0E LDA $0E ; \
$04:EDDD 0A ASL ; |
$04:EDDE 0A ASL ; |
$04:EDDF 0A ASL ; } Y = [$0E] * 8: byte offset into that table
$04:EDE0 A8 TAY ; /
$04:EDE1 AF 7B 83 7F LDA.L $7F837B ; \
$04:EDE5 AA TAX ; / X = stripe image write index [$7F:837B]
$04:EDE6 A5 00 LDA $00 ; A = VRAM address (first tile row)
$04:EDE8 9F 7D 83 7F STA.L $7F837D,X ; Stripe record 1: VRAM address
$04:EDEC 18 CLC ; Carry clear for the add
$04:EDED 69 00 20 ADC.W #$2000 ; VRAM address + $2000 (high byte + $20 = next tile row)
$04:EDF0 9F 85 83 7F STA.L $7F8385,X ; Stripe record 2: VRAM address of the second row
$04:EDF4 A9 00 03 LDA.W #$0300 ; A = $0300: record header, 4 data bytes (2 tiles) per row
$04:EDF7 9F 7F 83 7F STA.L $7F837F,X ; Record 1: length word
$04:EDFB 9F 87 83 7F STA.L $7F8387,X ; Record 2: length word
$04:EDFF B7 0A LDA [$0A],Y ; \
$04:EE01 9F 81 83 7F STA.L $7F8381,X ; / Record 1 data: top-left tile and attributes (word 0 of the entry)
$04:EE05 C8 INY ; \
$04:EE06 C8 INY ; |
$04:EE07 B7 0A LDA [$0A],Y ; } Record 2 data: bottom-left tile and attributes (word 1 of the entry)
$04:EE09 9F 89 83 7F STA.L $7F8389,X ; /
$04:EE0D C8 INY ; \
$04:EE0E C8 INY ; |
$04:EE0F B7 0A LDA [$0A],Y ; } Record 1 data: top-right tile and attributes (word 2 of the entry)
$04:EE11 9F 83 83 7F STA.L $7F8383,X ; /
$04:EE15 C8 INY ; \
$04:EE16 C8 INY ; |
$04:EE17 B7 0A LDA [$0A],Y ; } Record 2 data: bottom-right tile and attributes (word 3 of the entry)
$04:EE19 9F 8B 83 7F STA.L $7F838B,X ; /
$04:EE1D A9 FF 00 LDA.W #$00FF ; A = $00FF
$04:EE20 9F 8D 83 7F STA.L $7F838D,X ; Stripe end marker $FF after the two records
$04:EE24 8A TXA ; \
$04:EE25 18 CLC ; |
$04:EE26 69 10 00 ADC.W #$0010 ; } Stripe write index += $10 (two 8-byte records)
$04:EE29 8F 7B 83 7F STA.L $7F837B ; /
$04:EE2D E2 30 SEP #$30 ; A, X and Y 8-bit
$04:EE2F 60 RTS ; Return
$04:EE30 E2 20 SEP #$20 ; A 8-bit
$04:EE32 A9 7F LDA.B #$7F ; \
$04:EE34 85 0E STA $0E ; / [$0E] = $7F: bank of the pointer at [$0C]/[$0A]
$04:EE36 C2 30 REP #$30 ; A, X and Y 16-bit
$04:EE38 AD EB 1D LDA.W $1DEB ; \
$04:EE3B 0A ASL ; |
$04:EE3C 0A ASL ; } X = [$1DEB] * 4: index into the layer 2 event table
$04:EE3D AA TAX ; /
$04:EE3E BF 8F DD 04 LDA.L $DD8F,X ; A = $DD8F[X]: layer 2 position/flags word
$04:EE42 85 00 STA $00 ; [$00] = that word
$04:EE44 29 FF 1F AND.W #$1FFF ; \
$04:EE47 4A LSR ; |
$04:EE48 18 CLC ; |
$04:EE49 69 00 30 ADC.W #$3000 ; } [$02] = $3000 + ((word & $1FFF) / 2) with bytes swapped: VRAM-style address
$04:EE4C EB XBA ; /
$04:EE4D 85 02 STA $02
$04:EE4F A9 00 40 LDA.W #$4000 ; A = $4000
$04:EE52 85 0C STA $0C ; [$0C] = $4000
$04:EE54 A9 FF FF LDA.W #$FFFF ; A = $FFFF
$04:EE57 85 0A STA $0A ; [$0A] = $FFFF
$04:EE59 BF 8D DD 04 LDA.L $DD8D,X ; A = $DD8D[X]: event layer 2 tile/size word
$04:EE5D C9 00 09 CMP.W #$0900 ; Compare with $0900
$04:EE60 90 06 BCC $EE68 ; Below $0900: use the other tile writer at $04EE68
$04:EE62 20 6C E7 JSR.W $E76C ; Draw the layer 2 tile run ($E76C)
$04:EE65 4C 6B EE JMP.W $EE6B ; Skip the other writer
$04:EE68 20 24 E8 JSR.W $E824 ; Draw the layer 2 tile run ($E824)
$04:EE6B A9 FF 00 LDA.W #$00FF ; A = $00FF
$04:EE6E 9F 7D 83 7F STA.L $7F837D,X ; Stripe end marker $FF after the new records
$04:EE72 8A TXA ; A = X: new stripe write index
$04:EE73 8F 7B 83 7F STA.L $7F837B ; Update the stripe write index [$7F:837B]
$04:EE77 E2 30 SEP #$30 ; A, X and Y 8-bit
$04:EE79 60 RTS ; Return
;;; $EE7A..EEA2: Table: 2x2 tile blocks for event drawing ;;;
;; Six blocks of four words (TL, BL, TR, BR); indexed by [$13D0] * 8 in $EEAA.
$04:EE7A .db $22,$01,$82,$1C,$22,$01,$83,$1C ; Block 0 (TL, BL, TR, BR): tiles $22 $82 $22 $83
$04:EE82 .db $22,$01,$82,$14,$22,$01,$83,$14 ; Block 1: tiles $22 $82 $22 $83, palette variant
$04:EE8A .db $EA,$01,$EA,$01,$EA,$C1,$EA,$C1 ; Block 2: tiles $EA $EA $EA $EA (flip bits differ)
$04:EE92 .db $EA,$01,$EA,$01,$EA,$C1,$EA,$C1 ; Block 3: tiles $EA $EA $EA $EA (flip bits differ)
$04:EE9A .db $22,$01,$22,$01,$22,$01,$22,$01 ; Block 4: tiles $22 x4
$04:EEA2 .db $8A,$15,$9A,$15,$8B,$15,$9B,$15 ; Block 5 (used for steps >= 2): tiles $8A $9A $8B $9B
;;; $EEAA: Draw event tile blocks into stripe image ;;;
;; Queues 2x2 tile blocks from the table at $04EE7A as stripe records, one block per row, depending on the
;; event step [$13D0] and event [$13D1]. Jumps back into $ED83 at $04EDE6 to write the last block.
;; Called by:
;; $04:EC1C: Overworld event: smoke puff, level tile
$04:EEAA E2 30 SEP #$30 ; A, X and Y 8-bit
$04:EEAC A9 7E LDA.B #$7E ; \
$04:EEAE 85 0F STA $0F ; / $0F = $7E: bank of the pointer at [$0D]
$04:EEB0 A9 04 LDA.B #$04 ; \
$04:EEB2 85 0C STA $0C ; / [$0C] = 4: bank of the pointer at [$0A]
$04:EEB4 C2 30 REP #$30 ; A, X and Y 16-bit
$04:EEB6 A9 00 C8 LDA.W #$C800 ; \
$04:EEB9 85 0D STA $0D ; / [$0D] = $C800 (layer 1 map $7E:C800)
$04:EEBB A9 7A EE LDA.W #$EE7A ; \
$04:EEBE 85 0A STA $0A ; / [$0A] = $04EE7A: table of 2x2 tile blocks
$04:EEC0 AD D1 13 LDA.W $13D1 ; \
$04:EEC3 29 FF 00 AND.W #$00FF ; |
$04:EEC6 0A ASL ; } X = [$13D1] * 2: index into $E587
$04:EEC7 AA TAX ; /
$04:EEC8 BF 87 E5 04 LDA.L $E587,X ; \
$04:EECC 85 00 STA $00 ; / [$00] = $E587[X]: VRAM address of the first block row
$04:EECE AF 7B 83 7F LDA.L $7F837B ; \
$04:EED2 AA TAX ; / X = stripe image write index [$7F:837B]
$04:EED3 AD D0 13 LDA.W $13D0 ; \
$04:EED6 29 FF 00 AND.W #$00FF ; } Compare [$13D0] (event step) with 3
$04:EED9 C9 03 00 CMP.W #$0003 ; /
$04:EEDC 30 49 BMI $EF27 ; Below 3: skip the first row of blocks
$04:EEDE 0A ASL ; \
$04:EEDF 0A ASL ; |
$04:EEE0 0A ASL ; } Y = [$13D0] * 8: byte offset into the tile block table
$04:EEE1 A8 TAY ; /
$04:EEE2 A5 00 LDA $00 ; A = VRAM address
$04:EEE4 9F 7D 83 7F STA.L $7F837D,X ; Stripe record 1: VRAM address
$04:EEE8 18 CLC ; Carry clear for the add
$04:EEE9 69 00 20 ADC.W #$2000 ; VRAM address + $2000 (next tile row)
$04:EEEC 9F 85 83 7F STA.L $7F8385,X ; Stripe record 2: VRAM address of the second row
$04:EEF0 EB XBA ; \
$04:EEF1 18 CLC ; |
$04:EEF2 69 20 00 ADC.W #$0020 ; } [$00] += $20 in the high byte (VRAM address of the next block position)
$04:EEF5 EB XBA ; /
$04:EEF6 85 00 STA $00
$04:EEF8 A9 00 03 LDA.W #$0300 ; A = $0300: record header, 4 data bytes per row
$04:EEFB 9F 7F 83 7F STA.L $7F837F,X ; Record 1: length word
$04:EEFF 9F 87 83 7F STA.L $7F8387,X ; Record 2: length word
$04:EF03 B7 0A LDA [$0A],Y ; \
$04:EF05 9F 81 83 7F STA.L $7F8381,X ; / Record 1 data: top-left tile
$04:EF09 C8 INY ; \
$04:EF0A C8 INY ; |
$04:EF0B B7 0A LDA [$0A],Y ; } Record 2 data: bottom-left tile
$04:EF0D 9F 89 83 7F STA.L $7F8389,X ; /
$04:EF11 C8 INY ; \
$04:EF12 C8 INY ; |
$04:EF13 B7 0A LDA [$0A],Y ; } Record 1 data: top-right tile
$04:EF15 9F 83 83 7F STA.L $7F8383,X ; /
$04:EF19 C8 INY ; \
$04:EF1A C8 INY ; |
$04:EF1B B7 0A LDA [$0A],Y ; } Record 2 data: bottom-right tile
$04:EF1D 9F 8B 83 7F STA.L $7F838B,X ; /
$04:EF21 8A TXA ; \
$04:EF22 18 CLC ; |
$04:EF23 69 10 00 ADC.W #$0010 ; } Stripe write index += $10
$04:EF26 AA TAX ; /
$04:EF27 AD D0 13 LDA.W $13D0 ; \
$04:EF2A 29 FF 00 AND.W #$00FF ; } Compare [$13D0] with 2
$04:EF2D C9 02 00 CMP.W #$0002 ; /
$04:EF30 10 06 BPL $EF38 ; [$13D0] >= 2: use fixed block offset $28
$04:EF32 0A ASL ; \
$04:EF33 0A ASL ; |
$04:EF34 0A ASL ; } Y = [$13D0] * 8: block table offset
$04:EF35 A8 TAY ; /
$04:EF36 80 03 BRA $EF3B ; Go write the final block
$04:EF38 A0 28 00 LDY.W #$0028 ; Y = $28: block table offset for steps 2 and above
$04:EF3B 4C E6 ED JMP.W $EDE6 ; Write the last block (jump into the middle of $ED83 at $04EDE6)
; Ending early for table of FF's up ahread
;;; $EF3E..F27E: Unused. Padding ($FF fill) ;;;
;; Filler bytes.
$04:EF3E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF46 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF4E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF56 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF5E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF66 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF6E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF76 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF7E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF86 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF8E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF96 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EF9E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFA6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFAE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFB6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFBE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFC6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFCE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFD6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFDE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFE6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFEE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFF6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:EFFE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F006 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F00E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F016 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F01E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F026 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F02E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F036 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F03E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F046 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F04E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F056 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F05E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F066 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F06E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F076 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F07E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F086 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F08E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F096 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F09E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0A6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0AE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0B6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0BE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0C6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0CE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0D6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0DE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0E6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0EE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0F6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F0FE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F106 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F10E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F116 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F11E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F126 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F12E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F136 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F13E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F146 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F14E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F156 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F15E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F166 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F16E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F176 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F17E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F186 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F18E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F196 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F19E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1A6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1AE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1B6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1BE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1C6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1CE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1D6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1DE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1E6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1EE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1F6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F1FE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F206 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F20E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F216 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F21E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F226 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F22E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F236 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F23E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F246 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F24E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F256 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F25E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F266 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F26E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F276 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:F27E .db $FF,$FF
;;; $F280..F288: Table: ! block particle X speeds ;;;
;; Eight X speeds for the switch palace block particles, signed.
$04:F280 .db $00,$D8,$28,$D0,$30,$D8,$28,$00
$04:F288 .db $D0,$D8,$D8,$00,$00,$28,$28,$30
;;; $F290: Switch palace ! block particles ;;;
;; Overworld effect after a switch palace is completed ([$13D2] non-zero): spawns batches of eight ! block
;; particles around the player, moves them (X, Y, height with gravity) and draws them as OAM tile $E6.
;; $04F397: advance one position axis of one particle and convert it to a screen coordinate.
;; $04F3E5: state dispatcher for the overworld two-player lives exchange screen ([$1B87]).
;; Parameters: [$1439] phase, [$1437] timer, [RAM_KeyHolePos1/2] reused as particle count and OAM offset.
;; Called by:
;; $04:826F: Game mode 0E: overworld (GameMode_0E_Prim)
$04:F290 AC 39 14 LDY.W $1439 ; Y = [$1439]: switch palace block effect phase
$04:F293 C0 0C CPY.B #$0C ; Compare with $0C
$04:F295 90 04 BCC $F29B ; Below $0C: effect still running
$04:F297 9C D2 13 STZ.W $13D2 ; Effect finished: [$13D2] = 0
$04:F29A 60 RTS ; Return
$04:F29B AD 37 14 LDA.W $1437 ; A = [$1437] (spawn timer)
$04:F29E D0 74 BNE $F314 ; Timer not expired: skip spawning
$04:F2A0 C0 08 CPY.B #$08 ; Compare phase with 8
$04:F2A2 B0 68 BCS $F30C ; Phase >= 8: no more batches, just reset the timer
$04:F2A4 A9 1C LDA.B #$1C ; \
$04:F2A6 8D FC 1D STA.W $1DFC ; / Play sound effect $1C
$04:F2A9 A9 07 LDA.B #$07 ; \
$04:F2AB 85 00 STA $00 ; / [$00] = 7: eight particles per batch
$04:F2AD AE 36 14 LDX.W RAM_KeyHolePos1 ; X = [RAM_KeyHolePos1]: next free particle slot (reused as spawn counter)
$04:F2B0 AC D6 0D LDY.W $0DD6 ; Y = [$0DD6]: index of the current player on the overworld
$04:F2B3 B9 17 1F LDA.W $1F17,Y ; \
$04:F2B6 9F 78 B9 7E STA.L $7EB978,X ; / Particle X position low = player X on the overworld ([$1F17+Y])
$04:F2BA B9 18 1F LDA.W $1F18,Y ; \
$04:F2BD 9F 00 B9 7E STA.L $7EB900,X ; / Particle X position high ([$1F18+Y])
$04:F2C1 B9 19 1F LDA.W $1F19,Y ; \
$04:F2C4 9F A0 B9 7E STA.L $7EB9A0,X ; / Particle Y position low ([$1F19+Y])
$04:F2C8 B9 1A 1F LDA.W $1F1A,Y ; \
$04:F2CB 9F 28 B9 7E STA.L $7EB928,X ; / Particle Y position high ([$1F1A+Y])
$04:F2CF A9 00 LDA.B #$00 ; A = 0
$04:F2D1 9F C8 B9 7E STA.L $7EB9C8,X ; Particle height (low) = 0
$04:F2D5 9F 50 B9 7E STA.L $7EB950,X ; Particle height (high) = 0
$04:F2D9 A4 00 LDY $00 ; Y = [$00]: direction index 0-7
$04:F2DB B9 80 F2 LDA.W $F280,Y ; \
$04:F2DE 9F F0 B9 7E STA.L $7EB9F0,X ; / Particle X speed = $F280[Y]
$04:F2E2 B9 88 F2 LDA.W $F288,Y ; \
$04:F2E5 9F 18 BA 7E STA.L $7EBA18,X ; / Particle Y speed = $F288[Y]
$04:F2E9 A9 D0 LDA.B #$D0 ; \
$04:F2EB 9F 40 BA 7E STA.L $7EBA40,X ; / Particle height speed = $D0 (launched upward)
$04:F2EF E8 INX ; Next particle slot
$04:F2F0 C6 00 DEC $00 ; Next direction
$04:F2F2 10 BC BPL $F2B0 ; Loop for 8 directions
$04:F2F4 E0 28 CPX.B #$28 ; Compare slot with $28 (40 particles max)
$04:F2F6 90 11 BCC $F309 ; Not full: just save the slot counter
$04:F2F8 AD 38 14 LDA.W RAM_KeyHolePos2 ; \
$04:F2FB 18 CLC ; / OAM offset [RAM_KeyHolePos2] += $20
$04:F2FC 69 20 ADC.B #$20
$04:F2FE C9 A0 CMP.B #$A0 ; \
$04:F300 90 02 BCC $F304 ; / Wrap to 0 when it reaches $A0
$04:F302 A9 00 LDA.B #$00 ; Wrap to 0
$04:F304 8D 38 14 STA.W RAM_KeyHolePos2 ; Save the OAM offset
$04:F307 A2 00 LDX.B #$00 ; Slot counter wraps to 0
$04:F309 8E 36 14 STX.W RAM_KeyHolePos1 ; Save [RAM_KeyHolePos1] = slot counter
$04:F30C A9 10 LDA.B #$10 ; \
$04:F30E 8D 37 14 STA.W $1437 ; / Spawn timer [$1437] = $10 frames until next batch
$04:F311 EE 39 14 INC.W $1439 ; Phase [$1439]++
$04:F314 CE 37 14 DEC.W $1437 ; Spawn timer--
$04:F317 AD 38 14 LDA.W RAM_KeyHolePos2 ; \
$04:F31A 85 0F STA $0F ; / [$0F] = OAM offset [RAM_KeyHolePos2]: where the first sprite goes
$04:F31C A2 00 LDX.B #$00 ; X = 0: first particle
$04:F31E DA PHX ; Save particle index
$04:F31F A0 00 LDY.B #$00 ; Y = 0: offset into direct page positions ([$00] X, [$02] Y, [$04] height)
$04:F321 20 9C F3 JSR.W $F39C ; Update the X position ($F39C)
$04:F324 20 97 F3 JSR.W $F397 ; Update the Y position (X += $28)
$04:F327 20 97 F3 JSR.W $F397 ; Update the height (X += $28)
$04:F32A FA PLX ; Restore particle index
$04:F32B BF 40 BA 7E LDA.L $7EBA40,X ; \
$04:F32F 18 CLC ; } Height speed + 1 (gravity)
$04:F330 69 01 ADC.B #$01 ; /
$04:F332 30 06 BMI $F33A ; Negative (still rising): keep it
$04:F334 C9 40 CMP.B #$40 ; Compare with terminal speed $40
$04:F336 90 02 BCC $F33A ; Below: keep it
$04:F338 A9 40 LDA.B #$40 ; Clamp height speed to $40
$04:F33A 9F 40 BA 7E STA.L $7EBA40,X ; Store the height speed
$04:F33E BF 50 B9 7E LDA.L $7EB950,X ; \
$04:F342 EB XBA ; } A = height ($7EB950/$7EB9C8) as a 16-bit value
$04:F343 BF C8 B9 7E LDA.L $7EB9C8,X ; /
$04:F347 C2 20 REP #$20 ; \
$04:F349 18 CLC ; |
$04:F34A 65 02 ADC $02 ; } [$02] += height: screen Y adjusted for how high the particle is
$04:F34C 85 02 STA $02 ; /
$04:F34E E2 20 SEP #$20 ; A 8-bit
$04:F350 EB XBA ; \
$04:F351 05 01 ORA $01 ; / A = high byte of screen Y | high byte of [$02]: non-zero means off screen
$04:F353 D0 23 BNE $F378 ; Off screen: skip drawing this particle
$04:F355 A4 0F LDY $0F ; Y = [$0F]: OAM offset
$04:F357 EB XBA ; \
$04:F358 99 41 03 STA.W $0341,Y ; / OAM Y = screen Y low byte
$04:F35B A5 00 LDA $00 ; \
$04:F35D 99 40 03 STA.W $0340,Y ; / OAM X = screen X low byte
$04:F360 A9 E6 LDA.B #$E6 ; \
$04:F362 99 42 03 STA.W $0342,Y ; / OAM tile = $E6 (! block)
$04:F365 AD D2 13 LDA.W $13D2 ; \
$04:F368 3A DEC A ; |
$04:F369 0A ASL ; |
$04:F36A 09 30 ORA.B #$30 ; } OAM properties: palette from switch colour [$13D2], priority 3
$04:F36C 99 43 03 STA.W $0343,Y ; /
$04:F36F 98 TYA ; \
$04:F370 4A LSR ; |
$04:F371 4A LSR ; } Y = OAM offset / 4: index into the OAM size table
$04:F372 A8 TAY ; /
$04:F373 A9 02 LDA.B #$02 ; \
$04:F375 99 70 04 STA.W $0470,Y ; / OAM size bit: 16x16 sprite
$04:F378 A5 0F LDA $0F ; \
$04:F37A 18 CLC ; } [$0F] += 4: next OAM slot
$04:F37B 69 04 ADC.B #$04 ; /
$04:F37D C9 A0 CMP.B #$A0 ; \
$04:F37F 90 02 BCC $F383 ; / Wrap to 0 at $A0
$04:F381 A9 00 LDA.B #$00 ; Wrap to 0
$04:F383 85 0F STA $0F ; Save OAM offset
$04:F385 E8 INX ; Next particle
$04:F386 EC 36 14 CPX.W RAM_KeyHolePos1 ; Compare with slot counter
$04:F389 90 93 BCC $F31E ; Loop for all spawned particles
$04:F38B AD 39 14 LDA.W $1439 ; \
$04:F38E C9 05 CMP.B #$05 ; } [$1439] < 5: stop here
$04:F390 90 04 BCC $F396 ; /
$04:F392 E0 28 CPX.B #$28 ; Compare index with $28
$04:F394 90 88 BCC $F31E ; Keep drawing until all 40 slots are done
$04:F396 60 RTS ; Return
$04:F397 8A TXA ; \
$04:F398 18 CLC ; |
$04:F399 69 28 ADC.B #$28 ; } Move to the next array: X += $28 (X, Y, then height)
$04:F39B AA TAX ; /
$04:F39C 5A PHY ; Save Y (direct page offset)
$04:F39D BF F0 B9 7E LDA.L $7EB9F0,X ; \
$04:F3A1 0A ASL ; / Speed * 16: speed low nibble becomes the fractional part
$04:F3A2 0A ASL
$04:F3A3 0A ASL
$04:F3A4 0A ASL
$04:F3A5 18 CLC ; \
$04:F3A6 7F 68 BA 7E ADC.L $7EBA68,X ; } Add to the fractional position ($7EBA68+X)
$04:F3AA 9F 68 BA 7E STA.L $7EBA68,X ; /
$04:F3AE BF F0 B9 7E LDA.L $7EB9F0,X ; A = speed
$04:F3B2 08 PHP ; Save the sign of the speed
$04:F3B3 4A LSR ; \
$04:F3B4 4A LSR ; |
$04:F3B5 4A LSR ; } Speed / 16: integer part
$04:F3B6 4A LSR ; /
$04:F3B7 A0 00 LDY.B #$00 ; Y = 0: high byte of the delta
$04:F3B9 28 PLP ; Restore flags: speed sign
$04:F3BA 10 03 BPL $F3BF ; Positive: skip sign extension
$04:F3BC 09 F0 ORA.B #$F0 ; Negative: set the upper nibble
$04:F3BE 88 DEY ; High byte of the delta = $FF
$04:F3BF 7F 78 B9 7E ADC.L $7EB978,X ; \
$04:F3C3 9F 78 B9 7E STA.L $7EB978,X ; / Position low += delta (+ carry from fraction)
$04:F3C7 EB XBA ; Save low byte
$04:F3C8 98 TYA ; A = delta high byte
$04:F3C9 7F 00 B9 7E ADC.L $7EB900,X ; \
$04:F3CD 9F 00 B9 7E STA.L $7EB900,X ; / Position high += delta high byte (+ carry)
$04:F3D1 EB XBA ; A = position as 16-bit (low in A)
$04:F3D2 7A PLY ; Restore Y
$04:F3D3 C2 20 REP #$20 ; A 16-bit
$04:F3D5 38 SEC ; \
$04:F3D6 F9 1A 00 SBC.W RAM_ScreenBndryXLo,Y ; |
$04:F3D9 38 SEC ; } Screen position = position - [RAM_ScreenBndryXLo,Y] (camera X/Y) - 8
$04:F3DA E9 08 00 SBC.W #$0008 ; /
$04:F3DD 99 00 00 STA.W $0000,Y ; Store in [$00,$02,$04] by Y
$04:F3E0 E2 20 SEP #$20 ; A 8-bit
$04:F3E2 C8 INY ; \
$04:F3E3 C8 INY ; / Y += 2
$04:F3E4 60 RTS ; Return
$04:F3E5 3A DEC A ; A = [$1B87] - 1: lives exchange state 0-7
$04:F3E6 22 DF 86 00 JSL.L ExecutePtr ; Run the state routine from the pointer table
;;; $F3EA: Pointer table: lives exchange states (Ptrs04F3EA) ;;;
;; Eight state routines for the lives exchange screen, indexed by [$1B87] - 1.
$04:F3EA FF F3 .dw $F3FF ; 0: start (play sound, reset windows)
$04:F3EC 15 F4 .dw $F415 ; 1: iris window closes/opens
$04:F3EE 13 F5 .dw $F513 ; 2: lives exchange input
$04:F3F0 15 F4 .dw $F415 ; 3: iris window
$04:F3F2 FF F3 .dw $F3FF ; 4: start
$04:F3F4 15 F4 .dw $F415 ; 5: iris window
$04:F3F6 FA F3 .dw $F3FA ; 6: finish ($F3FA)
$04:F3F8 15 F4 .dw $F415 ; 7: iris window
$04:F3FA 22 A8 9B 00 JSL.L $9BA8 ; Run $9BA8 (probably returns to the overworld after the exchange)
$04:F3FE 60 RTS ; Return
$04:F3FF A9 22 LDA.B #$22 ; \
$04:F401 8D FC 1D STA.W $1DFC ; / Play sound effect $22
$04:F404 EE 87 1B INC.W $1B87 ; Lives exchange state [$1B87]++
$04:F407 64 41 STZ $41 ; \
$04:F409 64 42 STZ $42 ; / Clear window mask mirrors [$41]/[$42]/[$43]
$04:F40B 64 43 STZ $43 ; [$43] = 0 (color window)
$04:F40D 9C 9F 0D STZ.W $0D9F ; HDMA enable mirror = 0
$04:F410 60 RTS ; Return
;;; $F411..F413: Table: iris window step and target ;;;
;; Two bytes each: step per frame (+4/-4) and target radius ($68/$00).
$04:F411 .db $04,$FC ; Radius step per frame: +4 (growing), -4 (shrinking)
$04:F413 .db $68,$00 ; Target radius: $68 (closed) or $00 (open)
;;; $F415: Lives exchange: iris window effect ;;;
;; Closes/opens a circular window on the overworld around the screen centre, one step per frame, and advances
;; [$1B87] when the target radius is reached.
;; State 7 shows the CONTINUE AND SAVE stripe image. Also selects the player with more lives.
$04:F415 A2 00 LDX.B #$00 ; X = 0
$04:F417 AD B4 0D LDA.W RAM_PlayerLives ; \
$04:F41A CD B5 0D CMP.W $0DB5 ; / Compare Mario lives with Luigi lives
$04:F41D 10 01 BPL $F420 ; Mario >= Luigi: select Mario
$04:F41F E8 INX ; Luigi has more lives: X = 1
$04:F420 8E 8A 1B STX.W $1B8A ; [$1B8A] = selected player (the one with more lives)
$04:F423 AE 88 1B LDX.W $1B88 ; X = [$1B88]: iris direction
$04:F426 AD 89 1B LDA.W $1B89 ; A = [$1B89]: current iris radius
$04:F429 DF 13 F4 04 CMP.L $F413,X ; Reached the target radius?
$04:F42D D0 1C BNE $F44B ; No: keep moving it
$04:F42F EE 87 1B INC.W $1B87 ; Radius reached: state [$1B87]++
$04:F432 AD 87 1B LDA.W $1B87 ; A = new state
$04:F435 C9 07 CMP.B #$07 ; State 7?
$04:F437 D0 04 BNE $F43D ; No: skip
$04:F439 A0 1E LDY.B #$1E ; \
$04:F43B 84 12 STY $12 ; / State 7: [$12] = $1E, stripe image CONTINUE AND SAVE
$04:F43D 3A DEC A ; \
$04:F43E 29 03 AND.B #$03 ; / (state - 1) & 3
$04:F440 D0 08 BNE $F44A ; Not a multiple of 4: return
$04:F442 9C 87 1B STZ.W $1B87 ; Sequence over: state [$1B87] = 0
$04:F445 9C 88 1B STZ.W $1B88 ; Iris direction [$1B88] = 0
$04:F448 80 BD BRA $F407 ; Go reset the window registers ($F407)
$04:F44A 60 RTS ; Return
$04:F44B 18 CLC ; \
$04:F44C 7F 11 F4 04 ADC.L $F411,X ; / A = radius + step
$04:F450 8D 89 1B STA.W $1B89 ; Store the new radius [$1B89]
$04:F453 18 CLC ; \
$04:F454 69 80 ADC.B #$80 ; } Window half-width + $80 into the high byte (swap bytes)
$04:F456 EB XBA ; /
$04:F457 C2 10 REP #$10 ; Index 16-bit
$04:F459 A2 6E 01 LDX.W #$016E ; X = $016E: clear the window HDMA table at $04F0
$04:F45C A9 FF LDA.B #$FF ; A = $FF
$04:F45E 9D F0 04 STA.W $04F0,X ; Left edge = $FF (empty window)
$04:F461 9E F1 04 STZ.W $04F1,X ; Right edge = 0
$04:F464 CA DEX ; \
$04:F465 CA DEX ; / X -= 2
$04:F466 10 F6 BPL $F45E ; Loop for the whole table
$04:F468 E2 10 SEP #$10 ; Index 8-bit
$04:F46A AD 89 1B LDA.W $1B89 ; \
$04:F46D 4A LSR ; |
$04:F46E 6D 89 1B ADC.W $1B89 ; |
$04:F471 4A LSR ; |
$04:F472 29 FE AND.B #$FE ; } X = radius * 3/4 rounded to even: number of scanlines to circle edge
$04:F474 AA TAX ; /
$04:F475 A9 80 LDA.B #$80 ; \
$04:F477 38 SEC ; } A = $80 - radius: window left edge
$04:F478 ED 89 1B SBC.W $1B89 ; /
$04:F47B C2 20 REP #$20 ; A 16-bit
$04:F47D A0 48 LDY.B #$48 ; Y = $48
$04:F47F 99 48 05 STA.W $0548,Y ; Store window edge in the lower half of the table
$04:F482 9D 90 05 STA.W $0590,X ; Store window edge in the upper half of the table
$04:F485 88 DEY ; \
$04:F486 88 DEY ; |
$04:F487 CA DEX ; } Y -= 2, X -= 2
$04:F488 CA DEX ; /
$04:F489 10 F4 BPL $F47F ; Loop
$04:F48B 9C 01 07 STZ.W $0701 ; Clear $0701
$04:F48E E2 20 SEP #$20 ; A 8-bit
$04:F490 A9 22 LDA.B #$22 ; \
$04:F492 85 41 STA $41 ; / [$41] = $22: window mask W12SEL (BG1/BG2 window 1)
$04:F494 A9 20 LDA.B #$20 ; A = $20
$04:F496 4C 95 DB JMP.W $DB95 ; Set [$43] = $20 and enable HDMA ($DB95)
;;; $F499..F4B1: Stripe image: blank rows ;;;
;; Used as an image pointer in bank 0 (RLE blank fill of BG3 rows).
$04:F499 .db $51,$C4,$40,$24,$FC,$38,$52,$04 ; Record: VRAM $51C4, RLE, 37 bytes of tile $FC/attr $38 (blank)
$04:F4A1 .db $40,$2C,$FC,$38,$52,$2F,$40,$02 ; Record: VRAM $5204, RLE, 45 bytes blank; record: VRAM $522F, RLE, 3 bytes blank
$04:F4A9 .db $FC,$38,$52,$48,$40,$1C,$FC,$38 ; Record: VRAM $5248, RLE, 29 bytes blank
$04:F4B1 .db $FF ; $FF end marker
;;; $F4B2..F502: Stripe image: MARIO/LUIGI lives screen ;;;
;; Template copied to the stripe buffer: names, lives text, blank cursor slots and marker tiles.
$04:F4B2 .db $52,$49,$00,$09,$16,$28,$0A,$28 ; Record: VRAM $5249, 10 bytes: tiles "M" "A" ...
$04:F4BA .db $1B,$28,$12,$28,$18,$28,$52,$52 ; ... "R" "I" "O"; next record VRAM $5252
$04:F4C2 .db $00,$09,$15,$28,$1E,$28,$12,$28 ; 10 bytes: tiles "L" "U" "I" ...
$04:F4CA .db $10,$28,$12,$28,$52,$0B,$00,$05 ; ... "G" "I" (LUIGI); next record VRAM $520B
$04:F4D2 .db $26,$28,$00,$28,$00,$28,$52,$14 ; Mario lives: "x", tens, ones (placeholders); next record VRAM $5214
$04:F4DA .db $00,$05,$26,$28,$00,$28,$00,$28 ; 6 bytes: Luigi lives "x", tens, ones (placeholders)
$04:F4E2 .db $52,$0F,$00,$03,$FC,$38,$FC,$38 ; Record: VRAM $520F, 2 blank tiles (cursor arrows go here)
$04:F4EA .db $52,$2F,$00,$03,$FC,$38,$FC,$38 ; Record: VRAM $522F, 2 blank tiles (cursor arrows go here)
$04:F4F2 .db $51,$C9,$00,$03,$85,$29,$85,$69 ; Record: VRAM $51C9, 2 tiles $85 (marker next to MARIO)
$04:F4FA .db $51,$D2,$00,$03,$85,$29,$85,$69 ; Record: VRAM $51D2, 2 tiles $85 (marker next to LUIGI)
$04:F502 .db $FF ; $FF end marker
;;; $F503..F50F: Table: lives cursor tiles ;;;
;; Four 4-byte tile sets for the selection cursor.
$04:F503 .db $7D,$38,$7E,$78 ; Cursor tiles, selected Mario (frame 1)
$04:F507 .db $7E,$38,$7D,$78 ; Cursor tiles, selected Luigi (frame 1)
$04:F50B .db $7D,$B8,$7E,$F8 ; Cursor tiles, selected Mario (flipped)
$04:F50F .db $7E,$B8,$7D,$F8 ; Cursor tiles, selected Luigi (flipped)
;;; $F513: Lives exchange: input and drawing ;;;
;; Handles the two-player lives screen: Start continues, the other buttons choose a player and give one life
;; to the other player (cap 98), then draws the player names, lives and blinking cursor.
$04:F513 AD A6 0D LDA.W RAM_OWControllerA ; \
$04:F516 0D A7 0D ORA.W $0DA7 ; / Start pressed on either controller?
$04:F519 29 10 AND.B #$10 ; Mask $10
$04:F51B F0 0E BEQ $F52B ; No: handle left/right selection
$04:F51D AE B3 0D LDX.W $0DB3 ; X = [$0DB3]: current player
$04:F520 BD B4 0D LDA.W RAM_PlayerLives,X ; \
$04:F523 8D BE 0D STA.W RAM_StatusLives ; / Status bar lives = current player lives
$04:F526 22 13 9C 00 JSL.L $9C13 ; Advance to the next state ($9C13: [$1B87]++, [$1B88]++)
$04:F52A 60 RTS ; Return
$04:F52B AD A6 0D LDA.W RAM_OWControllerA ; A = controller 1 buttons
$04:F52E 29 C0 AND.B #$C0 ; Mask $C0
$04:F530 D0 09 BNE $F53B ; Pressed: handle selection
$04:F532 AD A7 0D LDA.W $0DA7 ; A = controller 2 buttons
$04:F535 29 C0 AND.B #$C0 ; Mask $C0
$04:F537 F0 33 BEQ $F56C ; Nothing pressed: just draw the screen
$04:F539 49 C0 EOR.B #$C0 ; Controller 2: invert so the choice matches controller 1
$04:F53B A2 01 LDX.B #$01 ; X = 1
$04:F53D 0A ASL ; Shift bit 7 into carry
$04:F53E B0 01 BCS $F541 ; Bit 7 set: keep X = 1
$04:F540 CA DEX ; Bit 6 set: X = 0
$04:F541 EC 8A 1B CPX.W $1B8A ; Same player as before?
$04:F544 F0 05 BEQ $F54B ; Yes: no change
$04:F546 A9 18 LDA.B #$18 ; \
$04:F548 8D 8B 1B STA.W $1B8B ; / Restart the cursor blink timer [$1B8B] = $18
$04:F54B 8E 8A 1B STX.W $1B8A ; [$1B8A] = chosen player
$04:F54E 8A TXA ; \
$04:F54F 49 01 EOR.B #$01 ; } Y = other player (X xor 1)
$04:F551 A8 TAY ; /
$04:F552 BD B4 0D LDA.W RAM_PlayerLives,X ; A = lives of the chosen player
$04:F555 F0 15 BEQ $F56C ; Zero lives: nothing to give
$04:F557 30 13 BMI $F56C ; Negative (game over): nothing to give
$04:F559 B9 B4 0D LDA.W RAM_PlayerLives,Y ; A = lives of the other player
$04:F55C C9 62 CMP.B #$62 ; Compare with $62 (98 lives)
$04:F55E 10 0C BPL $F56C ; Already at the cap: no transfer
$04:F560 1A INC A ; Other player lives + 1
$04:F561 99 B4 0D STA.W RAM_PlayerLives,Y ; Store
$04:F564 DE B4 0D DEC.W RAM_PlayerLives,X ; Chosen player lives - 1
$04:F567 A9 23 LDA.B #$23 ; \
$04:F569 8D FC 1D STA.W $1DFC ; / Play sound effect $23
$04:F56C C2 20 REP #$20 ; A 16-bit
$04:F56E A9 48 78 LDA.W #$7848 ; \
$04:F571 8D 9C 02 STA.W $029C ; / OAM sprite 39: X = $48, Y = $78
$04:F574 A9 90 78 LDA.W #$7890 ; \
$04:F577 8D A0 02 STA.W $02A0 ; / OAM sprite 40: X = $90, Y = $78
$04:F57A A9 0A 34 LDA.W #$340A ; \
$04:F57D 8D 9E 02 STA.W $029E ; / OAM sprite 39: tile $0A, properties $34
$04:F580 A9 0A 36 LDA.W #$360A ; \
$04:F583 8D A2 02 STA.W $02A2 ; / OAM sprite 40: tile $0A, properties $36
$04:F586 E2 20 SEP #$20 ; A 8-bit
$04:F588 A9 02 LDA.B #$02 ; \
$04:F58A 8D 47 04 STA.W $0447 ; / OAM size bit for sprite 39: large
$04:F58D 8D 48 04 STA.W $0448 ; OAM size bit for sprite 40: large
$04:F590 22 F2 DB 05 JSL.L $DBF2 ; Build the status text/images ($DBF2)
$04:F594 A0 50 LDY.B #$50 ; Y = $50: size of the stripe image - 1
$04:F596 98 TYA ; \
$04:F597 18 CLC ; |
$04:F598 6F 7B 83 7F ADC.L $7F837B ; } Stripe write index += $51; X = new end
$04:F59C 8F 7B 83 7F STA.L $7F837B ; /
$04:F5A0 AA TAX
$04:F5A1 B9 B2 F4 LDA.W $F4B2,Y ; Copy the stripe image $F4B2 backwards into the buffer
$04:F5A4 9F 7D 83 7F STA.L $7F837D,X ; Store byte
$04:F5A8 CA DEX ; \
$04:F5A9 88 DEY ; / X--, Y--
$04:F5AA 10 F5 BPL $F5A1 ; Loop for the whole image
$04:F5AC E8 INX ; X = start of this image in the buffer
$04:F5AD C2 20 REP #$20 ; A 16-bit
$04:F5AF AC B4 0D LDY.W RAM_PlayerLives ; Y = Mario lives
$04:F5B2 30 0B BMI $F5BF ; Negative (out of lives): leave marker tiles
$04:F5B4 A9 FC 38 LDA.W #$38FC ; Blank tile $FC, attr $38
$04:F5B7 9F C1 83 7F STA.L $7F83C1,X ; Erase Mario marker tile 1
$04:F5BB 9F C3 83 7F STA.L $7F83C3,X ; Erase Mario marker tile 2
$04:F5BF AC B5 0D LDY.W $0DB5 ; Y = Luigi lives
$04:F5C2 30 0B BMI $F5CF ; Negative: leave marker tiles
$04:F5C4 A9 FC 38 LDA.W #$38FC ; Blank tile
$04:F5C7 9F C9 83 7F STA.L $7F83C9,X ; Erase Luigi marker tile 1
$04:F5CB 9F CB 83 7F STA.L $7F83CB,X ; Erase Luigi marker tile 2
$04:F5CF E2 20 SEP #$20 ; A 8-bit
$04:F5D1 EE 8B 1B INC.W $1B8B ; Cursor blink timer [$1B8B]++
$04:F5D4 AD 8B 1B LDA.W $1B8B ; \
$04:F5D7 29 18 AND.B #$18 ; / Timer & $18
$04:F5D9 F0 25 BEQ $F600 ; Zero: cursor off this half of the cycle
$04:F5DB AD 8A 1B LDA.W $1B8A ; \
$04:F5DE 0A ASL ; } Y = [$1B8A] * 2: selected player
$04:F5DF A8 TAY ; /
$04:F5E0 C2 20 REP #$20 ; A 16-bit
$04:F5E2 B9 03 F5 LDA.W $F503,Y ; A = cursor tiles for this player
$04:F5E5 9F B1 83 7F STA.L $7F83B1,X ; Write into the stripe (left arrow top)
$04:F5E9 B9 07 F5 LDA.W $F507,Y ; A = next tiles
$04:F5EC 9F B3 83 7F STA.L $7F83B3,X ; Write into the stripe
$04:F5F0 B9 0B F5 LDA.W $F50B,Y ; A = next tiles
$04:F5F3 9F B9 83 7F STA.L $7F83B9,X ; Write into the stripe
$04:F5F7 B9 0F F5 LDA.W $F50F,Y ; A = next tiles
$04:F5FA 9F BB 83 7F STA.L $7F83BB,X ; Write into the stripe
$04:F5FE E2 20 SEP #$20 ; A 8-bit
$04:F600 AD B4 0D LDA.W RAM_PlayerLives ; A = Mario lives
$04:F603 20 0E F6 JSR.W $F60E ; Write Mario lives digits
$04:F606 8A TXA ; \
$04:F607 18 CLC ; |
$04:F608 69 0A ADC.B #$0A ; } X += $0A: Luigi lives digits record
$04:F60A AA TAX ; /
$04:F60B AD B5 0D LDA.W $0DB5 ; A = Luigi lives
$04:F60E 1A INC A ; A = lives + 1 (displayed value)
$04:F60F DA PHX ; Save X
$04:F610 22 4C 97 00 JSL.L $974C ; Convert to decimal (HexToDec): X = tens, A = ones
$04:F614 9B TXY ; Y = tens
$04:F615 D0 02 BNE $F619 ; Tens non-zero: keep it
$04:F617 A2 FC LDX #$FC ; Tens = $FC (blank)
$04:F619 9B TXY ; Y = tens tile
$04:F61A FA PLX ; Restore X
$04:F61B 9F A1 83 7F STA.L $7F83A1,X ; Write ones digit
$04:F61F 98 TYA ; A = tens tile
$04:F620 9F 9F 83 7F STA.L $7F839F,X ; Write tens digit
$04:F624 60 RTS ; Return
;;; $F625..F645: Table: overworld sprite init data ;;;
;; Five bytes per entry, read backwards by $F675.
$04:F625 .db $00,$00,$01,$E0,$00,$00,$00,$01 ; Table: initial overworld sprite data, 5 bytes per entry (13 entries)
$04:F62D .db $60,$00,$06,$70,$01,$20,$00,$07 ; Table: overworld sprite data, continued
$04:F635 .db $38,$00,$8A,$01,$00,$58,$00,$7A ; Table: overworld sprite data, continued
$04:F63D .db $00,$08,$88,$01,$18,$00,$09,$48 ; Table: overworld sprite data, continued
$04:F645 .db $01,$FC,$FF,$00,$80,$00,$00 ; Table: overworld sprite data, continued
;;; $F64C..F662: Table: overworld sprite init data ;;;
;; Continuation of the overworld sprite init table.
$04:F64C .db $01,$00,$50,$00,$40,$01 ; Table: overworld sprite data, continued
$04:F652 .db $03,$00,$00,$00,$00,$0A,$40,$00 ; Table: overworld sprite data, continued
$04:F65A .db $98,$00,$0A,$60,$00,$F8,$00,$0A ; Table: overworld sprite data, continued
$04:F662 .db $40,$01,$58 ; Table: overworld sprite data, last bytes
;;; $F665..F66D: Table: overworld sprite warm-up counts ;;;
;; Number of times to run the sprite routine for each extra slot.
$04:F665 .db $01,$30,$00,$00,$01,$10,$FF,$20 ; Table: warm-up update counts per sprite slot ($0D-$0F)
$04:F66D .db $00,$70,$FF,$10,$00,$01,$40,$80 ; Table: warm-up update counts, continued
;;; $F675: Initialise overworld sprites ;;;
;; Called when loading the title screen. Fills 13 overworld sprite slots from the table at $04F616 and runs
;; the main routine for slots $0D-$0F to warm them up.
;; Interpretation is partial.
;; Called by:
;; $00:9AA4: Detect connected controllers into [$0DA0] (SetUp0DA0GM4)
$04:F675 8B PHB ; Save data bank
$04:F676 4B PHK ; Data bank = program bank ($04)
$04:F677 AB PLB
$04:F678 A2 0C LDX.B #$0C ; X = $0C: 13 overworld sprite slots
$04:F67A A0 4B LDY.B #$4B ; Y = $4B: offset of the last 5-byte entry
$04:F67C B9 16 F6 LDA.W ADDR_04F616,Y ; A = entry byte 0: sprite type
$04:F67F 9D E8 0D STA.W $0DE8,X ; Sprite type [$0DE8+X]
$04:F682 C9 01 CMP.B #$01 ; Type 1?
$04:F684 F0 04 BEQ $F68A ; Yes: set timer
$04:F686 C9 02 CMP.B #$02 ; Type 2?
$04:F688 D0 05 BNE $F68F ; Neither: skip
$04:F68A A9 40 LDA.B #$40 ; A = $40
$04:F68C 9D 58 0E STA.W $0E58,X ; Sprite timer [$0E58+X] = $40
$04:F68F B9 17 F6 LDA.W Instr04F617,Y ; \
$04:F692 9D 38 0E STA.W $0E38,X ; / Entry byte 1: [$0E38+X] (X position low)
$04:F695 B9 18 F6 LDA.W ADDR_04F618,Y ; \
$04:F698 9D 68 0E STA.W $0E68,X ; / Entry byte 2: [$0E68+X]
$04:F69B B9 19 F6 LDA.W $F619,Y ; \
$04:F69E 9D 48 0E STA.W $0E48,X ; / Entry byte 3: [$0E48+X] (Y position low)
$04:F6A1 B9 1A F6 LDA.W $F61A,Y ; \
$04:F6A4 9D 78 0E STA.W $0E78,X ; / Entry byte 4: [$0E78+X]
$04:F6A7 98 TYA ; \
$04:F6A8 38 SEC ; |
$04:F6A9 E9 05 SBC.B #$05 ; } Y -= 5: previous entry
$04:F6AB A8 TAY ; /
$04:F6AC CA DEX ; Next slot
$04:F6AD 10 CD BPL $F67C ; Loop for 13 slots
$04:F6AF A2 0D LDX.B #$0D ; X = $0D: first of the extra slots
$04:F6B1 9E 25 0E STZ.W $0E25,X ; Clear [$0E25+X]
$04:F6B4 AD 22 FD LDA.W $FD22 ; \
$04:F6B7 3A DEC A ; } [$0EB5+X] = $FD22 - 1
$04:F6B8 9D B5 0E STA.W $0EB5,X ; /
$04:F6BB BD 65 F6 LDA.W $F665,X ; A = $F665[X]: number of updates
$04:F6BE 48 PHA ; Save the count
$04:F6BF 8E DE 0D STX.W $0DDE ; Current slot [$0DDE] = X
$04:F6C2 20 53 F8 JSR.W $F853 ; Run the sprite main routine once ($F853)
$04:F6C5 68 PLA ; Restore the count
$04:F6C6 3A DEC A ; Count--
$04:F6C7 D0 F5 BNE $F6BE ; Loop until the sprite has been advanced
$04:F6C9 E8 INX ; Next slot
$04:F6CA E0 10 CPX.B #$10 ; Compare with $10
$04:F6CC 90 E3 BCC $F6B1 ; Loop for slots $0D-$0F
$04:F6CE AB PLB ; Restore data bank
$04:F6CF 6B RTL ; Return long
;;; $F6D0..F6E0: Tables: sprite spawn offsets ;;;
;; Eight values for $0E55 and 16-bit X and Y offsets relative to the screen, used by the sprite code at
;; $04F770.
$04:F6D0 .db $70,$7F,$78,$7F,$70,$7F,$78,$7F ; Table: values copied to $0E55+X for new sprites (8 entries)
$04:F6D8 .db $F0,$FF,$20,$00,$C0,$00,$F0,$FF ; Table: X offsets from the screen, 16-bit signed
$04:F6E0 .db $F0,$FF,$80,$00,$F0,$FF,$00,$00 ; Table: X offsets, continued
;;; $F6E8..F6F0: Table: sprite spawn Y offsets ;;;
;; 16-bit Y offsets relative to the screen.
$04:F6E8 .db $70,$00,$60,$01,$58,$01,$B0,$00 ; Table: Y offsets from the screen, 16-bit
$04:F6F0 .db $60,$01,$60,$01,$70,$00,$60,$01 ; Table: Y offsets, continued
;;; $F6F8..F700: Tables: sprite timers and values ;;;
;; Timer reload values and index values used by the code at $04F708.
$04:F6F8 .db $20,$58,$43,$CF,$18,$34,$A2,$5E ; Table: timer reload values (8 entries)
$04:F700 .db $07,$05,$06,$07,$04,$06,$07,$05 ; Table: values for [$1FFB] (8 entries)
;;; $F708: Process all overworld sprites ;;;
;; Per-frame overworld sprite handler. 1) Valley of Bowser only (hide mask $F7 = submap 4): thunder flash.
;; [$1FFC] counts down to a random
;; flash, [$1FFB] = flash steps; each step copies a color from the palette mirror ([$0753+2*step]) into CGRAM
;; color $47 via the special palette buffer at [$0681].
;; 2) Keeps cloud sprites (type 5) alive in slots 0-2, spawning them just outside the screen edges at a random
;; height.
;; 3) Sorts the slot order list [$0DE0]-[$0DE4] by Y position (slots 0-4), sets [$0DDF] = $30 and [$0EF7] = 0,
;; then runs every slot from 15 to 0.
;; Overworld sprite arrays (index = slot 0-15): [$0DE5] type, [$0DF5]/[$0E05]/[$0E15] state and flags, [$0E25]
;; timer, [$0E35]/[$0E65] X, [$0E45]/[$0E75] Y,
;; [$0E55] height (Z), [$0E95]/[$0EA5]/[$0EB5] X/Y/Z speed. [$0DDE] = slot being run, [$0DDF] = next free OAM
;; offset, [$0EF7] = slot touching Mario.
;; Called by:
;; $04:840D: Game mode 0E: overworld (GameMode_0E_Prim)
$04:F708 A9 F7 LDA.B #$F7 ; \
$04:F70A 20 82 F8 JSR.W $F882 ; |
$04:F70D D0 5F BNE $F76E ; / Hide mask $F7: lightning runs only on submap 4 (Valley of Bowser); else go to clouds
$04:F70F AC FB 1F LDY.W $1FFB ; \
$04:F712 D0 27 BNE $F73B ; / [$1FFB] = flash steps left; non-zero: a flash is running, go to $04F73B
$04:F714 A5 13 LDA RAM_FrameCounter ; \
$04:F716 4A LSR ; |
$04:F717 90 55 BCC $F76E ; / Idle: only count down on odd frames, else go to clouds
$04:F719 CE FC 1F DEC.W $1FFC ; \
$04:F71C D0 50 BNE $F76E ; / [$1FFC]-- (delay to next flash); not zero yet: go to clouds
$04:F71E A8 TAY ; Y = [$13] / 2: frame counter used as a pseudo-random index
$04:F71F B9 08 F7 LDA.W $F708,Y ; \
$04:F722 29 07 AND.B #$07 ; |
$04:F724 AA TAX ; / X = random 0-7: low 3 bits of a byte of this routine's own code at $04F708+Y
$04:F725 BD F8 F6 LDA.W $F6F8,X ; \
$04:F728 8D FC 1F STA.W $1FFC ; / [$1FFC] = $F6F8[X]: delay until the next flash
$04:F72B BC 00 F7 LDY.W $F700,X ; \
$04:F72E 8C FB 1F STY.W $1FFB ; / [$1FFB] = $F700[X]: number of flash steps
$04:F731 A9 08 LDA.B #$08 ; \
$04:F733 8D FD 1F STA.W $1FFD ; / [$1FFD] = 8: frames for the first step
$04:F736 A9 18 LDA.B #$18 ; \
$04:F738 8D FC 1D STA.W $1DFC ; / Play sound effect $18 ([$1DFC]), probably thunder
$04:F73B CE FD 1F DEC.W $1FFD ; \
$04:F73E 10 08 BPL $F748 ; / [$1FFD]--; still >= 0: keep the current step
$04:F740 CE FB 1F DEC.W $1FFB ; [$1FFB]--: next flash step
$04:F743 A9 04 LDA.B #$04 ; \
$04:F745 8D FD 1F STA.W $1FFD ; / [$1FFD] = 4: frames per later step
$04:F748 98 TYA ; \
$04:F749 0A ASL ; |
$04:F74A A8 TAY ; / Y = flash step * 2: word offset into the palette mirror
$04:F74B AE 81 06 LDX.W $0681 ; X = [$0681]: write index of the special palette upload buffer
$04:F74E A9 02 LDA.B #$02 ; \
$04:F750 9D 82 06 STA.W $0682,X ; / Record byte count = 2 (one color)
$04:F753 A9 47 LDA.B #$47 ; \
$04:F755 9D 83 06 STA.W $0683,X ; / CGRAM color index = $47
$04:F758 B9 53 07 LDA.W $0753,Y ; \
$04:F75B 9D 84 06 STA.W $0684,X ; / Color low byte = [$0753+Y]
$04:F75E B9 54 07 LDA.W $0754,Y ; \
$04:F761 9D 85 06 STA.W $0685,X ; / Color high byte = [$0754+Y]
$04:F764 9E 86 06 STZ.W $0686,X ; End of the record list
$04:F767 8A TXA ; \
$04:F768 18 CLC ; |
$04:F769 69 04 ADC.B #$04 ; |
$04:F76B 8D 81 06 STA.W $0681 ; / [$0681] += 4: advance the buffer index
$04:F76E A2 02 LDX.B #$02 ; X = 2: check the three cloud slots 2, 1, 0
$04:F770 BD E5 0D LDA.W $0DE5,X ; \
$04:F773 D0 36 BNE $F7AB ; / Slot in use ([$0DE5+X] != 0): skip to the next slot
$04:F775 A9 05 LDA.B #$05 ; \
$04:F777 9D E5 0D STA.W $0DE5,X ; / Spawn sprite type 5 (cloud) in this slot
$04:F77A 20 5B FE JSR.W $FE5B ; \
$04:F77D 29 07 AND.B #$07 ; |
$04:F77F A8 TAY ; / Y = random 0-7 (frame counter + per-slot offset)
$04:F780 B9 D0 F6 LDA.W $F6D0,Y ; \
$04:F783 9D 55 0E STA.W $0E55,X ; / Cloud height [$0E55+X] = $F6D0[Y]
$04:F786 98 TYA ; \
$04:F787 0A ASL ; |
$04:F788 A8 TAY ; / Y = Y * 2: word index
$04:F789 C2 20 REP #$20 ; \
$04:F78B A5 1A LDA RAM_ScreenBndryXLo ; |
$04:F78D 18 CLC ; |
$04:F78E 79 D8 F6 ADC.W $F6D8,Y ; |
$04:F791 E2 20 SEP #$20 ; / A = screen left edge [$1A] + $F6D8[Y] (X offset, signed word)
$04:F793 9D 35 0E STA.W $0E35,X ; \
$04:F796 EB XBA ; |
$04:F797 9D 65 0E STA.W $0E65,X ; / Cloud X position low/high = A
$04:F79A C2 20 REP #$20 ; \
$04:F79C A5 1C LDA RAM_ScreenBndryYLo ; |
$04:F79E 18 CLC ; |
$04:F79F 79 E8 F6 ADC.W $F6E8,Y ; |
$04:F7A2 E2 20 SEP #$20 ; / A = screen top edge [$1C] + $F6E8[Y] (Y offset)
$04:F7A4 9D 45 0E STA.W $0E45,X ; \
$04:F7A7 EB XBA ; |
$04:F7A8 9D 75 0E STA.W $0E75,X ; / Cloud Y position low/high = A
$04:F7AB CA DEX ; \
$04:F7AC 10 C2 BPL $F770 ; / Next cloud slot
$04:F7AE A2 04 LDX.B #$04 ; X = 4
$04:F7B0 8A TXA ; \
$04:F7B1 9D E0 0D STA.W $0DE0,X ; |
$04:F7B4 CA DEX ; |
$04:F7B5 10 F9 BPL $F7B0 ; / [$0DE0+X] = X: start with slots 0-4 in identity order
$04:F7B7 A2 04 LDX.B #$04 ; X = 4: sort the list [$0DE0]-[$0DE4] by sprite Y position
$04:F7B9 86 00 STX $00 ; [$00] = X: outer loop counter
$04:F7BB 86 01 STX $01 ; [$01] = X: inner loop counter
$04:F7BD A6 00 LDX $00 ; \
$04:F7BF BC E0 0D LDY.W $0DE0,X ; / Y = slot at list position [$00]
$04:F7C2 B9 45 0E LDA.W $0E45,Y ; \
$04:F7C5 85 02 STA $02 ; |
$04:F7C7 B9 75 0E LDA.W $0E75,Y ; |
$04:F7CA 85 03 STA $03 ; / [$02] = Y position of that slot (low, high)
$04:F7CC A6 01 LDX $01 ; \
$04:F7CE BC DF 0D LDY.W $0DDF,X ; / Y = slot at list position [$01] - 1
$04:F7D1 B9 75 0E LDA.W $0E75,Y ; \
$04:F7D4 EB XBA ; |
$04:F7D5 B9 45 0E LDA.W $0E45,Y ; / A = Y position of that slot (16-bit)
$04:F7D8 C2 20 REP #$20 ; \
$04:F7DA C5 02 CMP $02 ; |
$04:F7DC E2 20 SEP #$20 ; |
$04:F7DE 10 0D BPL $F7ED ; / Compare with [$02]; A >= [$02] (signed): keep the order
$04:F7E0 5A PHY ; \
$04:F7E1 A4 00 LDY $00 ; |
$04:F7E3 B9 E0 0D LDA.W $0DE0,Y ; |
$04:F7E6 9D DF 0D STA.W $0DDF,X ; |
$04:F7E9 68 PLA ; |
$04:F7EA 99 E0 0D STA.W $0DE0,Y ; / Swap the list entries at positions [$01] - 1 and [$00]
$04:F7ED CA DEX ; \
$04:F7EE D0 CB BNE $F7BB ; / Inner loop: X--, repeat until X = 0
$04:F7F0 A6 00 LDX $00 ; \
$04:F7F2 CA DEX ; |
$04:F7F3 D0 C4 BNE $F7B9 ; / Outer loop: [$00]--, repeat until 0
$04:F7F5 A9 30 LDA.B #$30 ; \
$04:F7F7 8D DF 0D STA.W $0DDF ; / [$0DDF] = $30: first free OAM offset (from $0240) for dynamically placed tiles
$04:F7FA 9C F7 0E STZ.W $0EF7 ; [$0EF7] = 0: no sprite touching Mario yet
$04:F7FD A2 0F LDX.B #$0F ; X = $0F: loop over the 16 slots from 15 down to 0
$04:F7FF A0 2D LDY.B #$2D ; Y = $2D (not used afterwards)
$04:F801 E0 0D CPX.B #$0D ; \
$04:F803 B0 08 BCS $F80D ; / Slots 13-15 have no timer: skip
$04:F805 BD 25 0E LDA.W $0E25,X ; \
$04:F808 F0 03 BEQ $F80D ; |
$04:F80A DE 25 0E DEC.W $0E25,X ; / If the timer [$0E25+X] is non-zero, decrement it
$04:F80D E0 05 CPX.B #$05 ; \
$04:F80F 90 08 BCC $F819 ; / Slots 0-4 go through the sorted list, 5-15 are used directly
$04:F811 8E DE 0D STX.W $0DDE ; [$0DDE] = X: current sprite slot
$04:F814 20 53 F8 JSR.W $F853 ; Run this sprite ($F853)
$04:F817 80 0C BRA $F825 ; Go to the next slot
$04:F819 DA PHX ; Save the slot counter
$04:F81A BD E0 0D LDA.W $0DE0,X ; \
$04:F81D AA TAX ; / X = [$0DE0+X]: slot in sorted order
$04:F81E 8E DE 0D STX.W $0DDE ; [$0DDE] = X: current sprite slot
$04:F821 20 53 F8 JSR.W $F853 ; Run this sprite ($F853)
$04:F824 FA PLX ; Restore the slot counter
$04:F825 CA DEX ; \
$04:F826 10 D9 BPL $F801 ; / X--, loop until X < 0
$04:F828 60 RTS ; Return
;;; $F829..F831: Table: sprite type hide masks ;;;
;; Indexed by sprite type 1-10. A set bit hides the type on that submap; bit order is $F875 ($80 =
;; submap 0).
$04:F829 .db $7F,$21,$7F,$7F,$7F,$77,$3F,$F7 ; Hide masks for sprite types 1-8 (bit set = hidden on that submap, see $F875)
$04:F831 .db $F7,$00 ; Hide masks for sprite types 9 and 10
;;; $F833..F83B: Table: per-slot random offsets ;;;
;; Added to the frame counter [$13] by $FE5B to get a different pseudo-random value per slot.
$04:F833 .db $00,$52,$31,$19,$45,$2A,$03,$8B ; Per-slot offsets added to [$13] for pseudo-random values, slots 0-7
$04:F83B .db $94,$3C,$78,$0D,$36,$5E,$87,$1F ; Per-slot offsets, slots 8-15
;;; $F843..F84B: Table: OAM offsets per sprite slot ;;;
;; OAM offset (from $0240) used by $FB06 for sprites that own an OAM entry. Slots 0-4 share $F4.
$04:F843 .db $F4,$F4,$F4,$F4,$F4,$9C,$3C,$48 ; OAM offsets (from $0240) for slots 0-7; slots 0-4 all share $F4
$04:F84B .db $C8,$CC,$A0,$A4,$D8,$DC,$E0,$E4 ; OAM offsets (from $0240) for slots 8-15
;;; $F853: Run one overworld sprite ;;;
;; Parameters: X: slot, also [$0DDE]. Skips the sprite when it is hidden on the current submap, else jumps to
;; the routine for its type.
;; Called by:
;; $04:F6C2: Initialise overworld sprites
;; $04:F814: Process all overworld sprites
;; $04:F821: Process all overworld sprites
$04:F853 20 7C F8 JSR.W $F87C ; \
$04:F856 D0 D0 BNE $F828 ; / Return if this sprite type is hidden on the current submap
$04:F858 BD E5 0D LDA.W $0DE5,X ; \
$04:F85B 22 DF 86 00 JSL.L ExecutePtr ; / Run the routine for sprite type [$0DE5+X] (pointer table below)
;;; $F85F: Overworld sprite pointers, submap check (OWSprites?) ;;;
;; Pointer table of the 11 sprite type routines (type 0 = empty), then $F875 (submap bit masks) and the
;; visibility check.
;; $F87C: A = hide mask for the slot's type. Entry $04F882 takes A as the mask directly.
;; Returns: Z set = sprite is shown on the current submap; Z clear = hidden. While [$13D9] = $0A the sprites
;; are hidden unless [$1DE8] = 1.
$04:F85F 28 F8 .dw $F828 ; Type 0: empty slot (RTS)
$04:F861 CC F8 .dw $F8CC ; Type 1: hovering creature with shadow
$04:F863 B8 F9 .dw $F9B8 ; Type 2: chases Mario's X position
$04:F865 3E FA .dw $FA3E ; Type 3: leaping sprite with splash (probably a fish)
$04:F867 F1 FA .dw $FAF1 ; Type 4: piranha plant
$04:F869 37 FB .dw $FB37 ; Type 5: cloud
$04:F86B 98 FB .dw $FB98 ; Type 6: walks in when Mario stands on tiles $49-$4B
$04:F86D 46 FC .dw $FC46 ; Type 7: smoke puffs
$04:F86F E1 FC .dw $FCE1 ; Type 8: Bowser's sign
$04:F871 24 FD .dw $FD24 ; Type 9: bouncing-speed sprite, tile $68 (code in the next chunk)
$04:F873 70 FD .dw $FD70 ; Type 10: sprite with tile $60 (code in the next chunk)
$04:F875 .db $80,$40,$20,$10,$08,$04,$02 ; Submap 0-6 -> bit mask $80, $40, $20, $10, $08, $04, $02
$04:F87C BC E5 0D LDY.W $0DE5,X ; \
$04:F87F B9 28 F8 LDA.W $F828,Y ; / A = hide mask for this sprite type: byte at $04F828 + type ($F829)
$04:F882 85 00 STA $00 ; [$00] = hide mask (the lightning code enters here with its own mask)
$04:F884 AC D9 13 LDY.W $13D9 ; \
$04:F887 C0 0A CPY.B #$0A ; |
$04:F889 D0 07 BNE $F892 ; / [$13D9] = $0A (an overworld process, purpose unclear)? No: normal check at $04F892
$04:F88B AC E8 1D LDY.W $1DE8 ; \
$04:F88E C0 01 CPY.B #$01 ; |
$04:F890 D0 11 BNE $F8A3 ; / In that process sprites only show while [$1DE8] = 1, else hide (A = 1)
$04:F892 AD D6 0D LDA.W $0DD6 ; \
$04:F895 4A LSR ; |
$04:F896 4A LSR ; |
$04:F897 A8 TAY ; / Y = [$0DD6] / 4: player index
$04:F898 B9 11 1F LDA.W $1F11,Y ; \
$04:F89B A8 TAY ; / Y = [$1F11+Y]: submap the player is on
$04:F89C B9 75 F8 LDA.W $F875,Y ; \
$04:F89F 25 00 AND $00 ; |
$04:F8A1 F0 02 BEQ $F8A5 ; / A = $F875[submap] AND mask; zero: visible, return with Z set
$04:F8A3 A9 01 LDA.B #$01 ; A = 1: hidden, return with Z clear
$04:F8A5 60 RTS ; Return: Z set = draw and run the sprite, Z clear = skip it
;;; $F8A6..F8CA: Table: sprite 1 movement parameters ;;;
;; Offsets, turn-around thresholds and speed steps/limits used by sprite 1 (and the steps/limits by sprite 2).
$04:F8A6 .db $01,$01,$03,$01,$01,$01,$01,$02 ; Sprite 1: X offsets between the four small tiles (index 0-7)
$04:F8AE .db $0C,$0C,$12,$12,$12,$12,$0C,$0C ; Sprite 1: Y offsets of the small tiles below the body (index 0-7)
$04:F8B6 .db $10,$00,$08,$00,$20,$00,$20,$00 ; Sprite 1: X distance thresholds for turning around, words indexed by [$0DF5]
$04:F8BE .db $10,$00,$30,$00,$08,$00,$10,$00 ; Sprite 1: Y distance thresholds, words indexed by [$0DF5]
$04:F8C6 .db $01,$FF ; Speed steps: +1, -1
$04:F8C8 .db $10,$F0 ; Speed limits: +$10, -$10
$04:F8CA .db $10,$F0 ; Z speed limits: +$10, -$10 (bobbing turns around here)
;;; $F8CC: Overworld sprite 1: hovering creature ;;;
;; Moves by its speeds, draws a small shadow, four small 8x8 tiles ($28) hanging below a 16x16 body ($26).
;; Z speed bobs between +/-$10. It stays near Mario: when it is heading away on an axis and farther than a
;; random threshold, that axis' direction
;; flag ([$0E05] bit 6 = X, bit 7 = Y) flips; X and Y speeds then accelerate toward the flagged direction up
;; to +/-$10.
;; If [$0E15,X] is non-zero (set elsewhere) it jumps to the homing code at $FF2E. What this creature is
;; in game terms is not clear.
$04:F8CC 20 90 FE JSR.W $FE90 ; Move the sprite: X, Y and Z position += speeds ($FE90)
$04:F8CF 18 CLC ; \
$04:F8D0 20 00 FE JSR.W $FE00 ; / Draw the small ground shadow (carry clear = 8x8 tiles)
$04:F8D3 20 62 FE JSR.W $FE62 ; Screen position: [$00] = X, [$02] = Y - height
$04:F8D6 C2 20 REP #$20 ; \
$04:F8D8 A5 02 LDA $02 ; |
$04:F8DA 85 04 STA $04 ; |
$04:F8DC E2 20 SEP #$20 ; / [$04] = [$02]: base Y for the small tiles
$04:F8DE 20 5B FE JSR.W $FE5B ; \
$04:F8E1 A2 06 LDX.B #$06 ; |
$04:F8E3 29 10 AND.B #$10 ; |
$04:F8E5 F0 01 BEQ $F8E8 ; |
$04:F8E7 E8 INX ; / X = 6, or 7 if bit 4 of the random value is set (makes the tiles jitter)
$04:F8E8 86 06 STX $06 ; [$06] = X: tile loop index
$04:F8EA A5 00 LDA $00 ; \
$04:F8EC 18 CLC ; |
$04:F8ED 7D A6 F8 ADC.W $F8A6,X ; |
$04:F8F0 85 00 STA $00 ; |
$04:F8F2 90 02 BCC $F8F6 ; |
$04:F8F4 E6 01 INC $01 ; / [$00]/[$01] += $F8A6[X] (16-bit, accumulates)
$04:F8F6 A5 04 LDA $04 ; \
$04:F8F8 18 CLC ; |
$04:F8F9 7D AE F8 ADC.W $F8AE,X ; |
$04:F8FC 85 02 STA $02 ; |
$04:F8FE A5 05 LDA $05 ; |
$04:F900 69 00 ADC.B #$00 ; |
$04:F902 85 03 STA $03 ; / [$02]/[$03] = [$04]/[$05] + $F8AE[X]
$04:F904 A9 32 LDA.B #$32 ; \
$04:F906 EB XBA ; |
$04:F907 A9 28 LDA.B #$28 ; |
$04:F909 20 7B FB JSR.W $FB7B ; / Draw 8x8 tile $28, properties $32, at the dynamic OAM slot
$04:F90C A6 06 LDX $06 ; \
$04:F90E CA DEX ; |
$04:F90F CA DEX ; |
$04:F910 10 D6 BPL $F8E8 ; / X = [$06] - 2; repeat until X < 0 (four tiles)
$04:F912 AE DE 0D LDX.W $0DDE ; X = [$0DDE]: current sprite slot
$04:F915 20 62 FE JSR.W $FE62 ; Screen position again: [$00], [$02]
$04:F918 A9 32 LDA.B #$32 ; \
$04:F91A EB XBA ; |
$04:F91B A9 26 LDA.B #$26 ; |
$04:F91D 20 7A FB JSR.W $FB7A ; / Draw 16x16 body tile $26, properties $32
$04:F920 BD 15 0E LDA.W $0E15,X ; \
$04:F923 F0 03 BEQ $F928 ; |
$04:F925 4C 2E FF JMP.W $FF2E ; / [$0E15+X] != 0 (set elsewhere): fly toward Mario instead ($FF2E)
$04:F928 BD 05 0E LDA.W $0E05,X ; \
$04:F92B 29 01 AND.B #$01 ; |
$04:F92D A8 TAY ; / Y = bit 0 of [$0E05+X]: Z speed direction (0 = up)
$04:F92E BD B5 0E LDA.W $0EB5,X ; \
$04:F931 18 CLC ; |
$04:F932 79 C6 F8 ADC.W $F8C6,Y ; |
$04:F935 9D B5 0E STA.W $0EB5,X ; / Z speed [$0EB5+X] += $F8C6[Y] (+1 or -1)
$04:F938 D9 CA F8 CMP.W $F8CA,Y ; \
$04:F93B D0 08 BNE $F945 ; / Reached the Z speed limit?
$04:F93D BD 05 0E LDA.W $0E05,X ; \
$04:F940 49 01 EOR.B #$01 ; |
$04:F942 9D 05 0E STA.W $0E05,X ; / Yes: flip the direction bit [$0E05+X] bit 0
$04:F945 20 EF FE JSR.W $FEEF ; Distance to Mario: [$00], [$02] = signed dx, dy; [$06], [$08] = |dx|, |dy|
$04:F948 BC F5 0D LDY.W $0DF5,X ; Y = [$0DF5+X]: random threshold index (even)
$04:F94B BD 04 0E LDA.W $0E04,X ; \
$04:F94E 0A ASL ; |
$04:F94F 45 00 EOR $00 ; |
$04:F951 10 0A BPL $F95D ; / Word at [$0E04+X]: bit 14 = X direction flag; EOR sign of dx. Same sign: go to Y check
$04:F953 A5 06 LDA $06 ; \
$04:F955 D9 B6 F8 CMP.W $F8B6,Y ; |
$04:F958 A9 40 00 LDA.W #$0040 ; |
$04:F95B B0 10 BCS $F96D ; / Heading away and |dx| >= $F8B6[Y]: A = $0040 (flag to flip), go to $04F96D
$04:F95D BD 04 0E LDA.W $0E04,X ; \
$04:F960 45 02 EOR $02 ; |
$04:F962 0A ASL ; |
$04:F963 90 08 BCC $F96D ; / Y axis: [$0E05+X] bit 7 vs sign of dy; same: nothing to flip
$04:F965 A5 08 LDA $08 ; \
$04:F967 D9 BE F8 CMP.W $F8BE,Y ; |
$04:F96A A9 80 00 LDA.W #$0080 ; / |dy| >= $F8BE[Y]? A = $0080 (flag to flip)
$04:F96D E2 20 SEP #$20 ; A 8-bit; carry set = a direction flag must flip
$04:F96F 90 0E BCC $F97F ; No flip: go to the speed update
$04:F971 5D 05 0E EOR.W $0E05,X ; \
$04:F974 9D 05 0E STA.W $0E05,X ; / [$0E05+X] ^= A: reverse that axis' direction flag
$04:F977 20 5B FE JSR.W $FE5B ; \
$04:F97A 29 06 AND.B #$06 ; |
$04:F97C 9D F5 0D STA.W $0DF5,X ; / [$0DF5+X] = random AND 6: new threshold index
$04:F97F 8A TXA ; \
$04:F980 18 CLC ; |
$04:F981 69 10 ADC.B #$10 ; |
$04:F983 AA TAX ; / X += $10: index of the Y speed array ([$0EA5]) and of [$0DF5+$10] = [$0E05]
$04:F984 BD F5 0D LDA.W $0DF5,X ; \
$04:F987 0A ASL ; / Y direction flag (bit 7 of [$0E05]) -> carry
$04:F988 20 93 F9 JSR.W $F993 ; Accelerate the Y speed ($F993)
$04:F98B AE DE 0D LDX.W $0DDE ; X = [$0DDE]: current sprite slot
$04:F98E BD 05 0E LDA.W $0E05,X ; \
$04:F991 0A ASL ; |
$04:F992 0A ASL ; / X direction flag (bit 6 of [$0E05]) -> carry; falls into the speed update
$04:F993 A0 00 LDY.B #$00 ; \
$04:F995 B0 01 BCS $F998 ; |
$04:F997 C8 INY ; / Y = 0 (step +1) if carry set, else 1 (step -1)
$04:F998 BD 95 0E LDA.W $0E95,X ; \
$04:F99B 18 CLC ; |
$04:F99C 79 C6 F8 ADC.W $F8C6,Y ; |
$04:F99F D9 C8 F8 CMP.W $F8C8,Y ; |
$04:F9A2 F0 03 BEQ $F9A7 ; |
$04:F9A4 9D 95 0E STA.W $0E95,X ; / Speed [$0E95+X] += step, unless it is at the limit ($F8C8)
$04:F9A7 60 RTS ; Return
;;; $F9A8..F9B4: Table: sprite 2 small tile animation ;;;
;; Tile number and X/Y offsets of sprite 2's small part, 4 animation frames.
$04:F9A8 .db $4E,$4F,$5E,$4F ; Sprite 2: tile numbers of the small part, 4 frames
$04:F9AC .db $08,$07,$04,$07 ; Sprite 2: small part X offset when moving left
$04:F9B0 .db $00,$01,$04,$01 ; Sprite 2: small part X offset when moving right
$04:F9B4 .db $01,$07,$09,$07 ; Sprite 2: small part Y offset
;;; $F9B8: Overworld sprite 2: chases Mario's X ;;;
;; Accelerates toward Mario's X position (limit +/-$10), copies Mario's Y position, draws a small shadow, a
;; 16x16 body ($4C, X flipped by direction)
;; and a small 8x8 part that jitters randomly between 4 frames.
$04:F9B8 18 CLC ; \
$04:F9B9 20 00 FE JSR.W $FE00 ; / Draw the small ground shadow
$04:F9BC 20 EF FE JSR.W $FEEF ; Distance to Mario: [$00] = dx, [$06] = |dx| (16-bit)
$04:F9BF E2 20 SEP #$20 ; A 8-bit
$04:F9C1 A0 00 LDY.B #$00 ; \
$04:F9C3 A5 01 LDA $01 ; |
$04:F9C5 30 01 BMI $F9C8 ; |
$04:F9C7 C8 INY ; / Y = 0 if the sprite is left of Mario (dx < 0), else 1
$04:F9C8 BD 95 0E LDA.W $0E95,X ; \
$04:F9CB 18 CLC ; |
$04:F9CC 79 C6 F8 ADC.W $F8C6,Y ; |
$04:F9CF D9 C8 F8 CMP.W $F8C8,Y ; |
$04:F9D2 F0 03 BEQ $F9D7 ; |
$04:F9D4 9D 95 0E STA.W $0E95,X ; / X speed += $F8C6[Y] (accelerate toward Mario), limited to +/-$10
$04:F9D7 AC D6 0D LDY.W $0DD6 ; \
$04:F9DA B9 19 1F LDA.W $1F19,Y ; |
$04:F9DD 9D 45 0E STA.W $0E45,X ; / Sprite Y position low = Mario's Y position low ([$1F19+player*4])
$04:F9E0 B9 1A 1F LDA.W $1F1A,Y ; \
$04:F9E3 9D 75 0E STA.W $0E75,X ; / Sprite Y position high = Mario's Y position high
$04:F9E6 20 90 FE JSR.W $FE90 ; Move the sprite
$04:F9E9 20 62 FE JSR.W $FE62 ; Screen position
$04:F9EC A9 36 LDA.B #$36 ; \
$04:F9EE BC 95 0E LDY.W $0E95,X ; |
$04:F9F1 30 02 BMI $F9F5 ; |
$04:F9F3 09 40 ORA.B #$40 ; / Properties $36, X flipped ($40) when moving right
$04:F9F5 48 PHA ; \
$04:F9F6 EB XBA ; |
$04:F9F7 A9 4C LDA.B #$4C ; |
$04:F9F9 20 7A FB JSR.W $FB7A ; / Save the properties, draw 16x16 body tile $4C at the dynamic OAM slot
$04:F9FC 68 PLA ; \
$04:F9FD EB XBA ; / Restore the properties into B
$04:F9FE 20 5B FE JSR.W $FE5B ; \
$04:FA01 4A LSR ; |
$04:FA02 4A LSR ; |
$04:FA03 4A LSR ; |
$04:FA04 29 03 AND.B #$03 ; |
$04:FA06 A8 TAY ; / Y = random 0-3: animation frame of the small part
$04:FA07 B9 AC F9 LDA.W $F9AC,Y ; \
$04:FA0A 3C 95 0E BIT.W $0E95,X ; |
$04:FA0D 30 03 BMI $FA12 ; |
$04:FA0F B9 B0 F9 LDA.W $F9B0,Y ; / A = X offset: $F9AC[Y] moving left, $F9B0[Y] moving right
$04:FA12 18 CLC ; \
$04:FA13 65 00 ADC $00 ; |
$04:FA15 85 00 STA $00 ; |
$04:FA17 90 02 BCC $FA1B ; |
$04:FA19 E6 01 INC $01 ; / [$00] += A (16-bit)
$04:FA1B B9 B4 F9 LDA.W $F9B4,Y ; \
$04:FA1E 18 CLC ; |
$04:FA1F 65 02 ADC $02 ; |
$04:FA21 85 02 STA $02 ; |
$04:FA23 90 02 BCC $FA27 ; |
$04:FA25 E6 03 INC $03 ; / [$02] += $F9B4[Y] (16-bit)
$04:FA27 B9 A8 F9 LDA.W $F9A8,Y ; \
$04:FA2A 18 CLC ; |
$04:FA2B 4C 7B FB JMP.W $FB7B ; / Draw 8x8 tile $F9A8[Y] at the dynamic OAM slot and return
;;; $FA2E..FA3A: Table: sprite 3 spawn points, splash tiles ;;;
;; Spawn X and Y words for the three trigger tiles $4E-$50, and the splash tile numbers.
$04:FA2E .db $70,$50,$B0 ; Sprite 3: spawn X low for tiles $4E-$50
$04:FA31 .db $00,$01,$00 ; Sprite 3: spawn X high
$04:FA34 .db $CF,$8F,$7F ; Sprite 3: spawn Y low
$04:FA37 .db $00,$00,$01 ; Sprite 3: spawn Y high
$04:FA3A .db $73,$72,$63,$62 ; Sprite 3: splash tile numbers, indexed by timer / 4
;;; $FA3E: Overworld sprites 3-5 and OAM tile draw ;;;
;; Sprite 3 ($FA3E): idle until Mario stands on tile $4E-$50 ([$13C1]), then appears at one of three
;; fixed spots, launched upward (Z speed $24) with sound $0E.
;; Z speed drops by 1 per frame; falling flips the sprite. A 2-tile splash is shown for $0F frames at launch
;; and again at Z speed $E4 (landing). Probably a jumping fish.
;; Sprite 4 ($FAF1): stationary piranha plant, 16x16 tile $2A/$2C swapped every 8 frames, reports
;; touching Mario.
;; $FB06/04FB0A: draws one OAM tile. A = tile, B = properties, Y = OAM offset from $0240, [$00]/[$02] =
;; screen X/Y (16-bit), carry set = 16x16.
;; Skips off-screen positions; returns Y - 4. $FB7A/7B draw at the dynamic offset [$0DDF] and advance
;; it.
;; Sprite 5 ($FB37): cloud, speed (2, -1), two 16x16 tiles ($44, right one X flipped); freed when it
;; leaves the screen.
$04:FA3E BD F5 0D LDA.W $0DF5,X ; \
$04:FA41 D0 40 BNE $FA83 ; / State [$0DF5+X] != 0: active, go to $04FA83
$04:FA43 AD C1 13 LDA.W $13C1 ; \
$04:FA46 38 SEC ; |
$04:FA47 E9 4E SBC.B #$4E ; |
$04:FA49 C9 03 CMP.B #$03 ; |
$04:FA4B B0 35 BCS $FA82 ; / Idle: start only when Mario stands on overworld tile $4E-$50 ([$13C1])
$04:FA4D A8 TAY ; Y = tile - $4E (0-2)
$04:FA4E B9 2E FA LDA.W $FA2E,Y ; \
$04:FA51 9D 35 0E STA.W $0E35,X ; / X position low = $FA2E[Y]
$04:FA54 B9 31 FA LDA.W $FA31,Y ; \
$04:FA57 9D 65 0E STA.W $0E65,X ; / X position high
$04:FA5A B9 34 FA LDA.W $FA34,Y ; \
$04:FA5D 9D 45 0E STA.W $0E45,X ; / Y position low
$04:FA60 B9 37 FA LDA.W $FA37,Y ; \
$04:FA63 9D 75 0E STA.W $0E75,X ; / Y position high
$04:FA66 20 5B FE JSR.W $FE5B ; \
$04:FA69 4A LSR ; |
$04:FA6A 6A ROR ; |
$04:FA6B 4A LSR ; |
$04:FA6C 29 40 AND.B #$40 ; |
$04:FA6E 09 12 ORA.B #$12 ; |
$04:FA70 9D F5 0D STA.W $0DF5,X ; / [$0DF5+X] = $12, plus X flip ($40) at random: active flag and properties
$04:FA73 A9 24 LDA.B #$24 ; \
$04:FA75 9D B5 0E STA.W $0EB5,X ; / Z speed [$0EB5+X] = $24 (launched upward)
$04:FA78 A9 0E LDA.B #$0E ; \
$04:FA7A 8D F9 1D STA.W $1DF9 ; / Play sound effect $0E ([$1DF9])
$04:FA7D A9 0F LDA.B #$0F ; \
$04:FA7F 9D 25 0E STA.W $0E25,X ; / Splash timer [$0E25+X] = $0F (also called when the sprite lands)
$04:FA82 60 RTS ; Return
$04:FA83 DE B5 0E DEC.W $0EB5,X ; \
$04:FA86 BD B5 0E LDA.W $0EB5,X ; |
$04:FA89 C9 E4 CMP.B #$E4 ; |
$04:FA8B D0 03 BNE $FA90 ; / Z speed-- (gravity); not $E4 yet: go on
$04:FA8D 20 7D FA JSR.W $FA7D ; Z speed hit $E4 (landing): start the landing splash
$04:FA90 20 90 FE JSR.W $FE90 ; Move the sprite
$04:FA93 BD 55 0E LDA.W $0E55,X ; \
$04:FA96 1D 25 0E ORA.W $0E25,X ; |
$04:FA99 D0 03 BNE $FA9E ; |
$04:FA9B 9E F5 0D STZ.W $0DF5,X ; / Height and splash timer both 0: deactivate ([$0DF5+X] = 0)
$04:FA9E 20 62 FE JSR.W $FE62 ; Screen position
$04:FAA1 BD F5 0D LDA.W $0DF5,X ; A = state/properties [$0DF5+X]
$04:FAA4 A0 08 LDY.B #$08 ; Y = 8: animation frame mask
$04:FAA6 3C B5 0E BIT.W $0EB5,X ; \
$04:FAA9 10 04 BPL $FAAF ; |
$04:FAAB 49 C0 EOR.B #$C0 ; |
$04:FAAD A0 10 LDY.B #$10 ; / Falling (Z speed negative): flip both axes and Y = $10
$04:FAAF EB XBA ; \
$04:FAB0 98 TYA ; |
$04:FAB1 A0 4A LDY.B #$4A ; |
$04:FAB3 25 13 AND RAM_FrameCounter ; |
$04:FAB5 F0 02 BEQ $FAB9 ; |
$04:FAB7 A0 48 LDY.B #$48 ; |
$04:FAB9 98 TYA ; / B = properties; tile $4A, or $48 when [$13] AND mask is set (flap animation)
$04:FABA 20 06 FB JSR.W $FB06 ; Draw 16x16 tile at this slot's own OAM entry
$04:FABD 20 4E FE JSR.W $FE4E ; \
$04:FAC0 38 SEC ; |
$04:FAC1 E9 08 SBC.B #$08 ; |
$04:FAC3 85 02 STA $02 ; |
$04:FAC5 B0 02 BCS $FAC9 ; |
$04:FAC7 C6 03 DEC $03 ; / [$02]/[$03] = ground Y - 8: splash position
$04:FAC9 A9 36 LDA.B #$36 ; \
$04:FACB EB XBA ; / B = properties $36 for the splash
$04:FACC BD 25 0E LDA.W $0E25,X ; \
$04:FACF F0 B1 BEQ $FA82 ; / Splash timer = 0: nothing more to draw
$04:FAD1 4A LSR ; \
$04:FAD2 4A LSR ; |
$04:FAD3 5A PHY ; |
$04:FAD4 A8 TAY ; |
$04:FAD5 B9 3A FA LDA.W $FA3A,Y ; |
$04:FAD8 7A PLY ; / A = $FA3A[timer / 4], splash tile (Y preserved)
$04:FAD9 48 PHA ; \
$04:FADA 20 ED FA JSR.W $FAED ; / Save the tile, draw the left half (8x8) at the next OAM slot
$04:FADD C2 20 REP #$20 ; \
$04:FADF A5 00 LDA $00 ; |
$04:FAE1 18 CLC ; |
$04:FAE2 69 08 00 ADC.W #$0008 ; |
$04:FAE5 85 00 STA $00 ; |
$04:FAE7 E2 20 SEP #$20 ; / [$00] += 8: position of the right half
$04:FAE9 A9 76 LDA.B #$76 ; \
$04:FAEB EB XBA ; |
$04:FAEC 68 PLA ; / B = $76 (X-flipped splash), A = saved tile; falls into the draw
$04:FAED 18 CLC ; \
$04:FAEE 4C 0A FB JMP.W $FB0A ; / Draw an 8x8 tile (carry clear) at OAM offset Y ($FB0A)
$04:FAF1 20 D7 FE JSR.W $FED7 ; Mario touching the sprite? Sets [$0EF7] = slot ($FED7)
$04:FAF4 20 62 FE JSR.W $FE62 ; Screen position (without this the sprite would not appear)
$04:FAF7 20 5B FE JSR.W $FE5B ; A = [$13] + per-slot offset: animation timer (without it the sprite stops animating)
$04:FAFA A0 2A LDY.B #$2A ; \
$04:FAFC 29 08 AND.B #$08 ; |
$04:FAFE F0 02 BEQ $FB02 ; |
$04:FB00 A0 2C LDY.B #$2C ; / Tile $2A, or $2C when bit 3 of A is set: 2-frame animation
$04:FB02 A9 32 LDA.B #$32 ; \
$04:FB04 EB XBA ; |
$04:FB05 98 TYA ; / B = properties $32, A = tile; falls into the draw
$04:FB06 38 SEC ; \
$04:FB07 BC 43 F8 LDY.W $F843,X ; / Draw a 16x16 tile (carry set) at this slot's OAM offset $F843[X]
$04:FB0A 99 42 02 STA.W $0242,Y ; OAM tile low: tile number = A
$04:FB0D EB XBA ; A = properties (from B)
$04:FB0E 99 43 02 STA.W $0243,Y ; OAM tile high: properties = A
$04:FB11 A5 01 LDA $01 ; \
$04:FB13 D0 21 BNE $FB36 ; / X position high byte [$01] != 0: off screen, return
$04:FB15 A5 00 LDA $00 ; \
$04:FB17 99 40 02 STA.W $0240,Y ; / OAM X position = [$00]
$04:FB1A A5 03 LDA $03 ; \
$04:FB1C D0 18 BNE $FB36 ; / Y position high byte [$03] != 0: off screen, return
$04:FB1E 08 PHP ; Save carry (size flag)
$04:FB1F A5 02 LDA $02 ; \
$04:FB21 99 41 02 STA.W $0241,Y ; / OAM Y position = [$02]
$04:FB24 98 TYA ; \
$04:FB25 4A LSR ; |
$04:FB26 4A LSR ; / A = OAM offset / 4
$04:FB27 28 PLP ; Restore carry
$04:FB28 5A PHY ; Save the OAM offset
$04:FB29 A8 TAY ; Y = A: index into the OAM size table
$04:FB2A 2A ROL ; \
$04:FB2B 0A ASL ; |
$04:FB2C 29 03 AND.B #$03 ; |
$04:FB2E 99 30 04 STA.W $0430,Y ; / [$0430+Y] = carry << 1: size bit (16x16 if carry was set), X bit 8 clear
$04:FB31 7A PLY ; \
$04:FB32 88 DEY ; |
$04:FB33 88 DEY ; |
$04:FB34 88 DEY ; |
$04:FB35 88 DEY ; / Restore Y and subtract 4: next OAM slot (grows downward)
$04:FB36 60 RTS ; Return
$04:FB37 A9 02 LDA.B #$02 ; \
$04:FB39 9D 95 0E STA.W $0E95,X ; / X speed [$0E95+X] = 2 (drifts right)
$04:FB3C A9 FF LDA.B #$FF ; \
$04:FB3E 9D A5 0E STA.W $0EA5,X ; / Y speed [$0EA5+X] = $FF (drifts up slowly)
$04:FB41 20 90 FE JSR.W $FE90 ; Move the sprite
$04:FB44 20 62 FE JSR.W $FE62 ; Screen position
$04:FB47 C2 20 REP #$20 ; \
$04:FB49 A5 00 LDA $00 ; |
$04:FB4B 18 CLC ; |
$04:FB4C 69 20 00 ADC.W #$0020 ; |
$04:FB4F C9 40 01 CMP.W #$0140 ; |
$04:FB52 B0 09 BCS $FB5D ; / Screen X + $20 >= $140: off screen horizontally, skip the Y test
$04:FB54 A5 02 LDA $02 ; \
$04:FB56 18 CLC ; |
$04:FB57 69 80 00 ADC.W #$0080 ; |
$04:FB5A C9 A0 01 CMP.W #$01A0 ; / Screen Y + $80 >= $1A0: off screen vertically (carry)
$04:FB5D E2 20 SEP #$20 ; A 8-bit
$04:FB5F 90 03 BCC $FB64 ; \
$04:FB61 9E E5 0D STZ.W $0DE5,X ; / Off screen: free the slot ([$0DE5+X] = 0)
$04:FB64 A9 32 LDA.B #$32 ; \
$04:FB66 20 77 FB JSR.W $FB77 ; / Left half: properties $32, tile $44
$04:FB69 C2 20 REP #$20 ; \
$04:FB6B A5 00 LDA $00 ; |
$04:FB6D 18 CLC ; |
$04:FB6E 69 10 00 ADC.W #$0010 ; |
$04:FB71 85 00 STA $00 ; |
$04:FB73 E2 20 SEP #$20 ; / [$00] += $10: right half
$04:FB75 A9 72 LDA.B #$72 ; A = $72: properties X-flipped for the right half
$04:FB77 EB XBA ; B = properties
$04:FB78 A9 44 LDA.B #$44 ; A = tile $44 (cloud, 16x16)
$04:FB7A 38 SEC ; Carry set: 16x16 tile
$04:FB7B AC DF 0D LDY.W $0DDF ; Y = [$0DDF]: next free dynamic OAM offset
$04:FB7E 20 0A FB JSR.W $FB0A ; Draw the tile
$04:FB81 8C DF 0D STY.W $0DDF ; [$0DDF] = Y: move on to the next slot
$04:FB84 60 RTS ; Return
;;; $FB85..FB95: Table: sprite 6 spawn data ;;;
;; Per-tile bit, spawn X/Y words, animation masks and stop positions for sprite 6.
$04:FB85 .db $80,$40,$20 ; Sprite 6: [$0EF5] bit for each of tiles $49-$4B
$04:FB88 .db $30,$10,$C0 ; Sprite 6: start X low
$04:FB8B .db $01,$01,$01 ; Sprite 6: start X high
$04:FB8E .db $7F,$7F,$8F ; Sprite 6: start Y low
$04:FB91 .db $01,$00 ; Sprite 6: start Y high (third entry reads the next byte)
$04:FB93 .db $01,$08 ; Sprite 6: animation masks by state (third entry reads the next byte)
$04:FB95 .db $02,$0F,$00 ; Sprite 6: X low nibble at which each state ends
;;; $FB98: Overworld sprite 6: walks in on tiles $49-$4B ;;;
;; Idle until Mario stands on tile $49-$4B ([$13C1]) and that instance's bit in [$0EF5] is clear. Spawns at
;; one of three spots, state 2, walking left.
;; At each stop (X low nibble = $FB95[state]) the state drops, X speed becomes 4 and it waits $60
;; frames. Drawn as 16x16 tile $6A, X flip toggling.
;; Touching Mario sets [$0EF7] = slot | $80. Purpose in game terms is not clear.
$04:FB98 BD F5 0D LDA.W $0DF5,X ; \
$04:FB9B D0 3B BNE $FBD8 ; / State [$0DF5+X] != 0: active, go to $FBD8
$04:FB9D AD C1 13 LDA.W $13C1 ; \
$04:FBA0 38 SEC ; |
$04:FBA1 E9 49 SBC.B #$49 ; |
$04:FBA3 C9 03 CMP.B #$03 ; |
$04:FBA5 B0 DD BCS $FB84 ; / Idle: start only when Mario stands on overworld tile $49-$4B ([$13C1])
$04:FBA7 A8 TAY ; Y = tile - $49 (0-2)
$04:FBA8 8D F6 0E STA.W $0EF6 ; [$0EF6] = which of the three (probably read by the touch handling)
$04:FBAB AD F5 0E LDA.W $0EF5 ; \
$04:FBAE 39 85 FB AND.W $FB85,Y ; |
$04:FBB1 D0 D1 BNE $FB84 ; / [$0EF5] bit $FB85[Y] already set: sprite used up, return
$04:FBB3 B9 88 FB LDA.W $FB88,Y ; \
$04:FBB6 9D 35 0E STA.W $0E35,X ; / X position low = $FB88[Y]
$04:FBB9 B9 8B FB LDA.W $FB8B,Y ; \
$04:FBBC 9D 65 0E STA.W $0E65,X ; / X position high
$04:FBBF B9 8E FB LDA.W $FB8E,Y ; \
$04:FBC2 9D 45 0E STA.W $0E45,X ; / Y position low
$04:FBC5 B9 91 FB LDA.W $FB91,Y ; \
$04:FBC8 9D 75 0E STA.W $0E75,X ; / Y position high
$04:FBCB A9 02 LDA.B #$02 ; \
$04:FBCD 9D F5 0D STA.W $0DF5,X ; / State = 2
$04:FBD0 A9 F0 LDA.B #$F0 ; \
$04:FBD2 9D 95 0E STA.W $0E95,X ; / X speed = $F0 (walks left)
$04:FBD5 9E 25 0E STZ.W $0E25,X ; Wait timer [$0E25+X] = 0
$04:FBD8 20 62 FE JSR.W $FE62 ; Screen position
$04:FBDB BD 25 0E LDA.W $0E25,X ; \
$04:FBDE D0 20 BNE $FC00 ; / Timer running: skip the movement, just draw
$04:FBE0 FE 05 0E INC.W $0E05,X ; Animation counter [$0E05+X]++
$04:FBE3 20 AB FE JSR.W $FEAB ; Move in X by the X speed ($FEAB)
$04:FBE6 BC F5 0D LDY.W $0DF5,X ; Y = state
$04:FBE9 BD 35 0E LDA.W $0E35,X ; \
$04:FBEC 29 0F AND.B #$0F ; |
$04:FBEE D9 95 FB CMP.W $FB95,Y ; |
$04:FBF1 D0 0D BNE $FC00 ; / X low nibble = $FB95[state]? If not, keep moving
$04:FBF3 DE F5 0D DEC.W $0DF5,X ; State--: next phase
$04:FBF6 A9 04 LDA.B #$04 ; \
$04:FBF8 9D 95 0E STA.W $0E95,X ; / X speed = 4 (slow)
$04:FBFB A9 60 LDA.B #$60 ; \
$04:FBFD 9D 25 0E STA.W $0E25,X ; / Wait timer [$0E25+X] = $60 frames
$04:FC00 B9 93 FB LDA.W $FB93,Y ; \
$04:FC03 A0 22 LDY.B #$22 ; |
$04:FC05 3D 05 0E AND.W $0E05,X ; |
$04:FC08 D0 02 BNE $FC0C ; |
$04:FC0A A0 62 LDY.B #$62 ; / Properties $22, or $62 (X flip) when the animation counter AND $FB93[state] is 0
$04:FC0C 98 TYA ; \
$04:FC0D EB XBA ; |
$04:FC0E A9 6A LDA.B #$6A ; |
$04:FC10 20 06 FB JSR.W $FB06 ; / B = properties, draw 16x16 tile $6A at this slot's OAM entry
$04:FC13 20 D7 FE JSR.W $FED7 ; Touching Mario? Sets [$0EF7] = slot; carry set = not touching
$04:FC16 B0 05 BCS $FC1D ; \
$04:FC18 09 80 ORA.B #$80 ; |
$04:FC1A 8D F7 0E STA.W $0EF7 ; / Touching: [$0EF7] = slot OR $80 (marks it as hit)
$04:FC1D 60 RTS ; Return
;;; $FC1E..FC2E: Table: sprite 7 position and wobble ;;;
;; X/Y position words per submap (0 and 1) and the X wobble of the puffs.
$04:FC1E .db $38 ; Sprite 7: X positions, one word per submap ($0038, $0068)
$04:FC1F .db $00,$68,$00
$04:FC22 .db $8A ; Sprite 7: Y positions, one word per submap ($018A, $006A)
$04:FC23 .db $01,$6A,$00
$04:FC26 .db $01,$02,$03,$04,$03,$02,$01,$00 ; Sprite 7: X wobble, steps 0-7
$04:FC2E .db $01,$02,$03,$04,$03,$02,$01,$00 ; Sprite 7: X wobble, steps 8-15
;;; $FC36..FC3E: Table: sprite 7 rise offsets ;;;
;; Signed Y offsets for the three puffs, 16 animation steps.
$04:FC36 .db $FF,$FF,$FE,$FD,$FD,$FC,$FB,$FB ; Sprite 7: Y offsets (rising), steps 0-7
$04:FC3E .db $FA,$F9,$F9,$F8,$F7,$F7,$F6,$F5 ; Sprite 7: Y offsets (rising), steps 8-15
;;; $FC46: Overworld sprites 7 and 8 ;;;
;; Sprite 7: fixed position per submap (0 or 1), three small 8x8 tiles ($28/$5F flicker) rising and wobbling,
;; animation phase [$0DF5] advances every 16 frames. Probably chimney smoke.
;; Sprite 8 ($FCE1, label 'Bowser's sign' in the source): four 8x8 tiles $6C-$6F in a row going left,
;; palette cycling 0-3 with the frame counter.
$04:FC46 AD D6 0D LDA.W $0DD6 ; \
$04:FC49 4A LSR ; |
$04:FC4A 4A LSR ; |
$04:FC4B A8 TAY ; / Y = [$0DD6] / 4: player index
$04:FC4C B9 11 1F LDA.W $1F11,Y ; \
$04:FC4F 0A ASL ; |
$04:FC50 A8 TAY ; / Y = submap of that player * 2
$04:FC51 B9 1E FC LDA.W $FC1E,Y ; \
$04:FC54 9D 35 0E STA.W $0E35,X ; / X position low = $FC1E[Y]
$04:FC57 B9 1F FC LDA.W $FC1F,Y ; \
$04:FC5A 9D 65 0E STA.W $0E65,X ; / X position high
$04:FC5D B9 22 FC LDA.W $FC22,Y ; \
$04:FC60 9D 45 0E STA.W $0E45,X ; / Y position low
$04:FC63 B9 23 FC LDA.W $FC23,Y ; \
$04:FC66 9D 75 0E STA.W $0E75,X ; / Y position high
$04:FC69 A5 13 LDA RAM_FrameCounter ; \
$04:FC6B 29 0F AND.B #$0F ; |
$04:FC6D D0 0D BNE $FC7C ; / Only every 16th frame advance the animation
$04:FC6F BD F5 0D LDA.W $0DF5,X ; \
$04:FC72 1A INC A ; |
$04:FC73 C9 0C CMP.B #$0C ; |
$04:FC75 90 02 BCC $FC79 ; |
$04:FC77 A9 00 LDA.B #$00 ; |
$04:FC79 9D F5 0D STA.W $0DF5,X ; / [$0DF5+X] = ([$0DF5+X] + 1) wrapped at 12: animation phase
$04:FC7C A9 03 LDA.B #$03 ; \
$04:FC7E 85 04 STA $04 ; / [$04] = 3: number of puffs
$04:FC80 A5 13 LDA RAM_FrameCounter ; \
$04:FC82 85 06 STA $06 ; / [$06] = [$13]: counter for the size flicker
$04:FC84 64 07 STZ $07 ; [$07] = 0: accumulated Y offset
$04:FC86 BC 43 F8 LDY.W $F843,X ; Y = OAM offset of this slot ($F843)
$04:FC89 BD F5 0D LDA.W $0DF5,X ; \
$04:FC8C AA TAX ; / X = [$0DF5+X]: animation index
$04:FC8D 5A PHY ; \
$04:FC8E DA PHX ; / Save the OAM offset and the animation index
$04:FC8F AE DE 0D LDX.W $0DDE ; X = [$0DDE]: current sprite slot
$04:FC92 20 62 FE JSR.W $FE62 ; Screen position
$04:FC95 FA PLX ; Restore the animation index into X
$04:FC96 A5 07 LDA $07 ; \
$04:FC98 18 CLC ; |
$04:FC99 7D 36 FC ADC.W $FC36,X ; |
$04:FC9C 18 CLC ; |
$04:FC9D 65 02 ADC $02 ; |
$04:FC9F 85 02 STA $02 ; |
$04:FCA1 B0 02 BCS $FCA5 ; |
$04:FCA3 C6 03 DEC $03 ; / [$02]/[$03] += [$07] + $FC36[X] (puff rises)
$04:FCA5 A5 00 LDA $00 ; \
$04:FCA7 18 CLC ; |
$04:FCA8 7D 26 FC ADC.W $FC26,X ; |
$04:FCAB 85 00 STA $00 ; |
$04:FCAD 90 02 BCC $FCB1 ; |
$04:FCAF E6 01 INC $01 ; / [$00]/[$01] += $FC26[X] (puff wobbles)
$04:FCB1 8A TXA ; \
$04:FCB2 18 CLC ; |
$04:FCB3 69 0C ADC.B #$0C ; |
$04:FCB5 C9 10 CMP.B #$10 ; |
$04:FCB7 29 0F AND.B #$0F ; |
$04:FCB9 AA TAX ; / X = (X + 12) AND $0F: animation index of the next puff (carry = wrapped)
$04:FCBA 90 06 BCC $FCC2 ; \
$04:FCBC A5 07 LDA $07 ; |
$04:FCBE E9 0C SBC.B #$0C ; |
$04:FCC0 85 07 STA $07 ; / Wrapped: [$07] -= $0C (later puffs sit higher)
$04:FCC2 A9 30 LDA.B #$30 ; \
$04:FCC4 EB XBA ; |
$04:FCC5 A0 28 LDY.B #$28 ; / B = properties $30; Y = tile $28 (small puff)
$04:FCC7 A5 06 LDA $06 ; \
$04:FCC9 18 CLC ; |
$04:FCCA 69 0A ADC.B #$0A ; |
$04:FCCC 85 06 STA $06 ; / [$06] += $0A
$04:FCCE 29 20 AND.B #$20 ; \
$04:FCD0 F0 02 BEQ $FCD4 ; |
$04:FCD2 A0 5F LDY.B #$5F ; / Tile $5F instead when bit 5 of [$06] is set (flicker)
$04:FCD4 98 TYA ; \
$04:FCD5 7A PLY ; / A = tile, Y = OAM offset again
$04:FCD6 20 ED FA JSR.W $FAED ; Draw an 8x8 tile (carry clear) at OAM offset Y; Y -= 4
$04:FCD9 C6 04 DEC $04 ; \
$04:FCDB D0 B0 BNE $FC8D ; / Next puff (3 in total)
$04:FCDD AE DE 0D LDX.W $0DDE ; X = [$0DDE]: current sprite slot
$04:FCE0 60 RTS ; Return
;Bowser's sign code starts here.
$04:FCE1 20 62 FE JSR.W $FE62 ; Screen position
$04:FCE4 A9 04 LDA.B #$04 ; \
$04:FCE6 85 04 STA $04 ; / [$04] = 4: number of tiles in Bowser's sign
$04:FCE8 A9 6F LDA.B #$6F ; \
$04:FCEA 85 05 STA $05 ; / [$05] = $6F: tile number of the rightmost tile
$04:FCEC BC 43 F8 LDY.W $F843,X ; Y = OAM offset of this slot ($F843)
$04:FCEF A5 13 LDA RAM_FrameCounter ; \
$04:FCF1 4A LSR ; |
$04:FCF2 29 06 AND.B #$06 ; |
$04:FCF4 09 30 ORA.B #$30 ; |
$04:FCF6 EB XBA ; / B = properties $30 + (([$13] / 2) AND 6): cycles palette 0-3 (flashing)
$04:FCF7 A5 05 LDA $05 ; \
$04:FCF9 20 ED FA JSR.W $FAED ; / A = tile [$05]; draw 8x8 via $FAED
$04:FCFC A5 00 LDA $00 ; \
$04:FCFE 38 SEC ; |
$04:FCFF E9 08 SBC.B #$08 ; |
$04:FD01 85 00 STA $00 ; / [$00] -= 8: next tile to the left
$04:FD03 C6 05 DEC $05 ; Tile number--
$04:FD05 C6 04 DEC $04 ; \
$04:FD07 D0 E6 BNE $FCEF ; / Tiles left--; loop until all 4 are drawn
$04:FD09 60 RTS ; Return
;;; $FD0A..FD18: Table: masks and steps for sprites 9, 10 ;;;
;; Timer masks for sprite 10 and the +1/-1 speed step pairs used by sprites 9 and 10.
$04:FD0A .db $07,$07,$03,$03,$5F,$5F ; Sprite 10: masks ANDed with its timer (indexed [$0DF5] OR 4; exact use unclear)
$04:FD10 .db $01,$FF,$01,$FF,$01,$FF,$01,$FF ; Sprites 9 and 10: speed steps, +1/-1 pairs
$04:FD18 .db $01,$FF ; Sprites 9 and 10: speed steps, last pair
;;; $FD1A..FD22: Table: speed limits for sprites 9, 10 ;;;
;; Speed limit pairs (+/-) for sprites 9 and 10.
$04:FD1A .db $18,$E8,$0A,$F6,$08,$F8,$03,$FD ; Sprites 9 and 10: speed limits, +/- pairs ($18, $0A, $08, $03, $01)
$04:FD22 .db $01,$FF ; Sprites 9 and 10: speed limits, last pair
;;; $FD24: Overworld sprites 9 and 10: drifting movement ;;;
;; Main routines for overworld sprite types 9 ($04FD24) and 10 ($04FD70) in the OWSprites pointer table.
;; Neither is named here (purpose unclear).
;; Each applies speed to position, draws one tile with X flip following X speed, then makes each speed swing
;; between +/- limits:
;; every axis adds +1/-1 per step ($FD10) and reverses at the limit in $FD1A. Type 9 steps every
;; second frame.
;; Type 10 steps X, Y and Z at different rates via masks $FD0A against a phase counter [$0E25], and is
;; hidden (Y position forced off-screen) on some submaps.
;; Parameters: X = sprite slot [$0DDE]. Speed at [$0E95+$10*axis,X], direction index at [$0DF5+$10*axis,X].
$04:FD24 20 90 FE JSR.W $FE90 ; Move by speed ($FE90)
$04:FD27 20 62 FE JSR.W $FE62 ; \
$04:FD2A 20 62 FE JSR.W $FE62 ; / Screen X in [$00], screen Y (minus height) in [$02]; done twice, redundant
$04:FD2D A9 00 LDA.B #$00 ; Property = $00 (no flip)
$04:FD2F BC 95 0E LDY.W $0E95,X ; Y = X speed (sets N flag)
$04:FD32 30 02 BMI $FD36 ; Moving left: no flip
$04:FD34 A9 40 LDA.B #$40 ; Moving right: property = $40 (X flip)
$04:FD36 EB XBA ; Property into B
$04:FD37 A9 68 LDA.B #$68 ; A = tile $68
$04:FD39 20 06 FB JSR.W $FB06 ; Write tile and position to OAM ($FB06)
$04:FD3C FE 15 0E INC.W $0E15,X ; Animation counter [$0E15,X]++
$04:FD3F BD 15 0E LDA.W $0E15,X ; A = counter
$04:FD42 4A LSR ; Counter bit 0 into carry
$04:FD43 B0 2A BCS $FD6F ; Odd counts: return (speeds change every other frame)
$04:FD45 BD 05 0E LDA.W $0E05,X ; A = Y-axis direction index [$0E05,X]
$04:FD48 09 02 ORA.B #$02 ; OR 2: use the second step/limit pair
$04:FD4A A8 TAY ; Y = table index
$04:FD4B 8A TXA ; \
$04:FD4C 69 10 ADC.B #$10 ; } X += $10: Y-axis slot (carry is clear)
$04:FD4E AA TAX ; /
$04:FD4F 20 55 FD JSR.W $FD55 ; Step the Y-axis speed ($FD55)
$04:FD52 BC F5 0D LDY.W $0DF5,X ; Y = X-axis direction index [$0DF5,X]; falls into the X-axis step
$04:FD55 BD 95 0E LDA.W $0E95,X ; A = speed [$0E95,X]
$04:FD58 18 CLC ; Clear carry
$04:FD59 79 10 FD ADC.W $FD10,Y ; Speed += $FD10[Y] (+1 or -1)
$04:FD5C 9D 95 0E STA.W $0E95,X ; Store new speed
$04:FD5F D9 1A FD CMP.W $FD1A,Y ; Reached the limit $FD1A[Y]?
$04:FD62 D0 04 BNE $FD68 ; No: keep direction
$04:FD64 98 TYA ; \
$04:FD65 49 01 EOR.B #$01 ; |
$04:FD67 A8 TAY ; } Y ^= 1: reverse direction (accelerate the other way)
$04:FD68 98 TYA ; \
$04:FD69 9D F5 0D STA.W $0DF5,X ; / Save direction index in [$0DF5,X]
$04:FD6C AE DE 0D LDX.W $0DDE ; X = sprite slot [$0DDE]
$04:FD6F 60 RTS ; Return
$04:FD70 20 90 FE JSR.W $FE90 ; Move by speed ($FE90)
$04:FD73 20 62 FE JSR.W $FE62 ; \
$04:FD76 20 62 FE JSR.W $FE62 ; / Screen X in [$00], screen Y (minus height) in [$02]; done twice, redundant
$04:FD79 AC B3 0D LDY.W $0DB3 ; Y = [$0DB3] (player index)
$04:FD7C B9 11 1F LDA.W $1F11,Y ; A = [$1F11,Y] (probably the player's current submap)
$04:FD7F F0 24 BEQ $FDA5 ; Main map (0): no position offset
$04:FD81 E0 0F CPX.B #$0F ; Slot $0F?
$04:FD83 D0 09 BNE $FD8E ; No: apply offset
$04:FD85 AD 07 1F LDA.W $1F07 ; A = [$1F07] (probably level-beaten flags)
$04:FD88 29 12 AND.B #$12 ; Test bits $12
$04:FD8A D0 02 BNE $FD8E ; Either set: apply offset
$04:FD8C 86 03 STX $03 ; Neither set: [$03] = X (non-zero) hides the sprite
$04:FD8E 8A TXA ; \
$04:FD8F 0A ASL ; |
$04:FD90 A8 TAY ; } Y = X * 2: word table index
$04:FD91 C2 20 REP #$20 ; A 16-bit
$04:FD93 A5 00 LDA $00 ; A = screen X [$00]
$04:FD95 18 CLC ; \
$04:FD96 79 4C F6 ADC.W $F64C,Y ; / + $F64C[Y]: per-slot X offset
$04:FD99 85 00 STA $00 ; Store screen X
$04:FD9B A5 02 LDA $02 ; A = screen Y [$02]
$04:FD9D 18 CLC ; \
$04:FD9E 79 52 F6 ADC.W $F652,Y ; / + $F652[Y]: per-slot Y offset
$04:FDA1 85 02 STA $02 ; Store screen Y
$04:FDA3 E2 20 SEP #$20 ; A 8-bit
$04:FDA5 A9 34 LDA.B #$34 ; Property = $34
$04:FDA7 BC 95 0E LDY.W $0E95,X ; Y = X speed (sets N flag)
$04:FDAA 30 02 BMI $FDAE ; Moving left: keep $34
$04:FDAC A9 44 LDA.B #$44 ; Moving right: property = $44 (X flip)
$04:FDAE EB XBA ; Property into B
$04:FDAF A9 60 LDA.B #$60 ; A = tile $60
$04:FDB1 20 06 FB JSR.W $FB06 ; Write tile and position to OAM ($FB06)
$04:FDB4 BD 25 0E LDA.W $0E25,X ; A = phase counter [$0E25,X]
$04:FDB7 85 00 STA $00 ; [$00] = counter; masks the acceleration steps below
$04:FDB9 FE 25 0E INC.W $0E25,X ; Phase counter++
$04:FDBC 8A TXA ; \
$04:FDBD 18 CLC ; |
$04:FDBE 69 20 ADC.B #$20 ; } X += $20: Z-axis slot
$04:FDC0 AA TAX ; /
$04:FDC1 A9 08 LDA.B #$08 ; A = 8: timing table index base for Z
$04:FDC3 20 D2 FD JSR.W $FDD2 ; Step the Z-axis speed if the timing mask allows
$04:FDC6 8A TXA ; \
$04:FDC7 18 CLC ; |
$04:FDC8 69 10 ADC.B #$10 ; } X += $10: Y-axis slot
$04:FDCA AA TAX ; /
$04:FDCB A9 06 LDA.B #$06 ; A = 6: timing table index base for Y
$04:FDCD 20 D2 FD JSR.W $FDD2 ; Step the Y-axis speed if the timing mask allows
$04:FDD0 A9 04 LDA.B #$04 ; A = 4: timing base for X; falls through with X = sprite slot
$04:FDD2 1D F5 0D ORA.W $0DF5,X ; A |= direction index [$0DF5,X]
$04:FDD5 A8 TAY ; Y = table index
$04:FDD6 B9 06 FD LDA.W ADDR_04FD06,Y ; A = timing mask ($07 X, $03 Y, $5F Z) from $FD0A
$04:FDD9 25 00 AND $00 ; AND the phase counter [$00]
$04:FDDB D0 8B BNE $FD68 ; Non-zero: skip this step, just save direction ($FD68)
$04:FDDD 4C 55 FD JMP.W $FD55 ; Zero: step the speed ($FD55)
;;; $FDE0..FDE8: Table: X offset of first tile by height ;;;
$04:FDE0 .db $00,$00,$00,$00,$01,$02,$02,$02 ; $00-$07: small sprite, indexed by height / 16
$04:FDE8 .db $00,$00,$01,$01,$02,$02,$03,$03 ; $08-$0F: large sprite
;;; $FDF0..FDF8: Table: X offset of second tile by height ;;;
$04:FDF0 .db $08,$08,$08,$08,$07,$06,$05,$05 ; $00-$07: small sprite, indexed by height / 16
$04:FDF8 .db $00,$00,$0E,$0E,$0C,$0C,$0A,$0A ; $08-$0F: large sprite
;;; $FE00: Overworld sprite helpers: draw, move, home in ;;;
;; $04FE00: draws a two-tile mirrored sprite whose tile size and X spacing depend on the Z height. Carry on
;; entry = 16x16 flag.
;; $04FE4E: [$02] += Z height. $04FE5B: A = [$13] + $F833[X]. $04FE62: screen X in [$00], screen Y minus
;; height in [$02].
;; $04FE90: apply X/Y/Z speeds to positions (Z clamped at 0). $04FEAB: one axis, speed in 1/16 pixel per
;; frame, fraction in [$0EC5,X].
;; $04FED7: sets [$0EF7] = slot if the sprite is within 8 pixels of the player's map position. $04FEEF: dx,
;; dy, |dx|, |dy| to the player.
;; $04FF2E: sets X/Y/Z speed to head toward the player (longest axis $20, others scaled); at the target zeroes
;; speeds and Z height = $40.
;; Called by:
;; $04:F8D0: Overworld sprite 1: hovering creature
;; $04:F9B9: Overworld sprite 2: chases Mario's X
$04:FE00 66 04 ROR $04 ; Carry from caller into bit 7 of [$04]: 1 = 16x16 size
$04:FE02 20 62 FE JSR.W $FE62 ; Screen position in [$00]/[$02] ($FE62)
$04:FE05 20 4E FE JSR.W $FE4E ; Add height back to [$02]: ground-level Y ($FE4E)
$04:FE08 BD 55 0E LDA.W $0E55,X ; A = Z height [$0E55,X]
$04:FE0B 4A LSR ; \
$04:FE0C 4A LSR ; |
$04:FE0D 4A LSR ; } A = height / 16
$04:FE0E 4A LSR ; /
$04:FE0F A0 29 LDY.B #$29 ; Y = $29: tile for the small version
$04:FE11 24 04 BIT $04 ; Test bit 7 of [$04] (size flag)
$04:FE13 10 05 BPL $FE1A ; Clear: keep small tile
$04:FE15 A0 2E LDY.B #$2E ; Y = $2E: tile for the large version
$04:FE17 18 CLC ; \
$04:FE18 69 08 ADC.B #$08 ; / A += 8: use the large half of the offset tables
$04:FE1A 84 05 STY $05 ; [$05] = tile number
$04:FE1C A8 TAY ; Y = table index
$04:FE1D 84 06 STY $06 ; [$06] = table index (kept for the second tile)
$04:FE1F A5 00 LDA $00 ; A = screen X [$00]
$04:FE21 18 CLC ; \
$04:FE22 79 E0 FD ADC.W $FDE0,Y ; / + $FDE0[Y]: offset of first tile
$04:FE25 85 00 STA $00 ; Store screen X
$04:FE27 90 02 BCC $FE2B ; No carry: skip
$04:FE29 E6 01 INC $01 ; Carry: [$01]++ (X high byte)
$04:FE2B A9 32 LDA.B #$32 ; A = $32: property (priority 3, palette 1)
$04:FE2D BC 43 F8 LDY.W $F843,X ; Y = OAM slot offset $F843[X]
$04:FE30 20 45 FE JSR.W $FE45 ; Draw first tile ($FE45)
$04:FE33 5A PHY ; Save Y (OAM index, already moved to the next slot)
$04:FE34 A4 06 LDY $06 ; Y = saved table index [$06]
$04:FE36 A5 00 LDA $00 ; \
$04:FE38 18 CLC ; |
$04:FE39 79 F0 FD ADC.W $FDF0,Y ; } Screen X += $FDF0[Y]: offset of second tile
$04:FE3C 85 00 STA $00 ; Store screen X
$04:FE3E 90 02 BCC $FE42 ; No carry: skip
$04:FE40 E6 01 INC $01 ; Carry: [$01]++ (X high byte)
$04:FE42 A9 72 LDA.B #$72 ; A = $72: property, X-flipped mirror of first tile
$04:FE44 7A PLY ; Y = OAM slot for the second tile
$04:FE45 EB XBA ; Property into B
$04:FE46 A5 04 LDA $04 ; A = [$04]
$04:FE48 0A ASL ; ASL: carry = bit 7 (16x16 size flag)
$04:FE49 A5 05 LDA $05 ; A = tile number [$05]
$04:FE4B 4C 0A FB JMP.W $FB0A ; Write tile, property, position and size bit to OAM ($FB0A)
$04:FE4E A5 02 LDA $02 ; A = screen Y low [$02]
$04:FE50 18 CLC ; Clear carry
$04:FE51 7D 55 0E ADC.W $0E55,X ; + Z height [$0E55,X]
$04:FE54 85 02 STA $02 ; Store screen Y
$04:FE56 90 02 BCC $FE5A ; No carry: skip
$04:FE58 E6 03 INC $03 ; Carry: [$03]++
$04:FE5A 60 RTS ; Return
$04:FE5B A5 13 LDA RAM_FrameCounter ; A = frame counter [$13]
$04:FE5D 18 CLC ; Clear carry
$04:FE5E 7D 33 F8 ADC.W $F833,X ; + per-slot offset $F833[X] (staggers animation)
$04:FE61 60 RTS ; Return
$04:FE62 8A TXA ; \
$04:FE63 18 CLC ; |
$04:FE64 69 10 ADC.B #$10 ; } X += $10: Y-axis slot
$04:FE66 AA TAX ; /
$04:FE67 A0 02 LDY.B #$02 ; Y = 2: index of the screen Y scroll
$04:FE69 20 7D FE JSR.W $FE7D ; [$02] = Y position - screen Y scroll ($FE7D)
$04:FE6C AE DE 0D LDX.W $0DDE ; X = sprite slot [$0DDE]
$04:FE6F A5 02 LDA $02 ; A = screen Y [$02]
$04:FE71 38 SEC ; Set carry
$04:FE72 FD 55 0E SBC.W $0E55,X ; - Z height [$0E55,X]
$04:FE75 85 02 STA $02 ; Store screen Y
$04:FE77 B0 02 BCS $FE7B ; No borrow: skip
$04:FE79 C6 03 DEC $03 ; Borrow: [$03]--
$04:FE7B A0 00 LDY.B #$00 ; Y = 0: index of the screen X scroll
$04:FE7D BD 65 0E LDA.W $0E65,X ; A = position high byte [$0E65,X]
$04:FE80 EB XBA ; Into B
$04:FE81 BD 35 0E LDA.W $0E35,X ; A = position low byte [$0E35,X]
$04:FE84 C2 20 REP #$20 ; A 16-bit
$04:FE86 38 SEC ; Set carry
$04:FE87 F9 1A 00 SBC.W RAM_ScreenBndryXLo,Y ; - screen scroll ([$1A] for Y = 0, [$1C] for Y = 2)
$04:FE8A 99 00 00 STA.W $0000,Y ; Store screen-relative position in [$00,Y]
$04:FE8D E2 20 SEP #$20 ; A 8-bit
$04:FE8F 60 RTS ; Return
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Modify the overworld sprite slot index to handle XYZ speed.
;
;SpriteSlotIndex+($10*Type)
;where:
;Type = 0: X speed
;Type = 1: Y speed
;Type = 2: Z speed
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$04:FE90 8A TXA ; \
$04:FE91 18 CLC ; |
$04:FE92 69 20 ADC.B #$20 ; } X += $20: Z-axis slot
$04:FE94 AA TAX ; /
$04:FE95 20 AB FE JSR.W $FEAB ; Move Z position by Z speed ($FEAB)
$04:FE98 BD 35 0E LDA.W $0E35,X ; A = Z position low [$0E55,X]
$04:FE9B 10 03 BPL $FEA0 ; Not negative: keep
$04:FE9D 9E 35 0E STZ.W $0E35,X ; Below ground: Z position = 0
$04:FEA0 8A TXA ; \
$04:FEA1 38 SEC ; |
$04:FEA2 E9 10 SBC.B #$10 ; } X -= $10: Y-axis slot
$04:FEA4 AA TAX ; /
$04:FEA5 20 AB FE JSR.W $FEAB ; Move Y position by Y speed
$04:FEA8 AE DE 0D LDX.W $0DDE ; X = sprite slot: fall into the X-axis update
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Update overworld sprite XYZ position by speed. This is similar to Player's
;version at $00DC4F, and even more similar to $01ABD8 (SubSprYPosNoGrvty).
;
;There are 16 ($10) slots, numbered from $00-$0F (00-15) for overworld
;sprites, and we have 3 axis to handle, so indexes as follows.
;If X index is:
;$00-$0F (00-15; SpriteSlotIndex + $00): Handle X speed
;$10-$1F (16-31; SpriteSlotIndex + $10): Handle Y speed
;$20-$2F (32-47; SpriteSlotIndex + $20): Handle Z speed
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$04:FEAB BD 95 0E LDA.W $0E95,X ; A = speed [$0E95,X] (1/16 pixel per frame)
$04:FEAE 0A ASL ; \
$04:FEAF 0A ASL ; |
$04:FEB0 0A ASL ; } A = speed * 16 (fraction part)
$04:FEB1 0A ASL ; /
$04:FEB2 18 CLC ; Clear carry
$04:FEB3 7D C5 0E ADC.W $0EC5,X ; Add to sub-pixel fraction [$0EC5,X]
$04:FEB6 9D C5 0E STA.W $0EC5,X ; Store; carry = one extra pixel
$04:FEB9 BD 95 0E LDA.W $0E95,X ; A = speed
$04:FEBC 08 PHP ; Save flags (carry, N = speed sign)
$04:FEBD 4A LSR ; \
$04:FEBE 4A LSR ; |
$04:FEBF 4A LSR ; } A = speed / 16 (whole pixels)
$04:FEC0 4A LSR ; /
$04:FEC1 A0 00 LDY.B #$00 ; Y = 0: high byte of the movement
$04:FEC3 28 PLP ; Restore flags
$04:FEC4 10 03 BPL $FEC9 ; Speed positive: skip
$04:FEC6 09 F0 ORA.B #$F0 ; Negative: sign-extend A
$04:FEC8 88 DEY ; Y = $FF: high byte of the movement
$04:FEC9 7D 35 0E ADC.W $0E35,X ; Position low += pixels + carry
$04:FECC 9D 35 0E STA.W $0E35,X ; Store
$04:FECF 98 TYA ; A = high byte of the movement
$04:FED0 7D 65 0E ADC.W $0E65,X ; Position high += high byte + carry
$04:FED3 9D 65 0E STA.W $0E65,X ; Store
$04:FED6 60 RTS ; Return
$04:FED7 20 EF FE JSR.W $FEEF ; Get distances to the player ($FEEF)
$04:FEDA A5 06 LDA $06 ; A = |dx| [$06]
$04:FEDC C9 08 00 CMP.W #$0008 ; Within 8 pixels?
$04:FEDF B0 05 BCS $FEE6 ; No: not touching
$04:FEE1 A5 08 LDA $08 ; A = |dy| [$08]
$04:FEE3 C9 08 00 CMP.W #$0008 ; Within 8 pixels?
$04:FEE6 E2 20 SEP #$20 ; A 8-bit; carry set = not touching
$04:FEE8 8A TXA ; A = sprite slot
$04:FEE9 B0 03 BCS $FEEE ; Not touching: return
$04:FEEB 8D F7 0E STA.W $0EF7 ; [$0EF7] = slot of the sprite the player is touching
$04:FEEE 60 RTS ; Return
$04:FEEF BD 65 0E LDA.W $0E65,X ; A = X position high byte [$0E65,X]
$04:FEF2 EB XBA ; Into B
$04:FEF3 BD 35 0E LDA.W $0E35,X ; A = X position low byte [$0E35,X]
$04:FEF6 C2 20 REP #$20 ; A 16-bit
$04:FEF8 18 CLC ; Clear carry
$04:FEF9 69 08 00 ADC.W #$0008 ; + 8: sprite center
$04:FEFC AC D6 0D LDY.W $0DD6 ; Y = [$0DD6] (player index)
$04:FEFF 38 SEC ; Set carry
$04:FF00 F9 17 1F SBC.W $1F17,Y ; - player map X [$1F17,Y]
$04:FF03 85 00 STA $00 ; [$00] = dx
$04:FF05 10 04 BPL $FF0B ; Positive: skip
$04:FF07 49 FF FF EOR.W #$FFFF ; \
$04:FF0A 1A INC A ; / A = -A (negate)
$04:FF0B 85 06 STA $06 ; [$06] = |dx|
$04:FF0D E2 20 SEP #$20 ; A 8-bit
$04:FF0F BD 75 0E LDA.W $0E75,X ; A = Y position high byte [$0E75,X]
$04:FF12 EB XBA ; Into B
$04:FF13 BD 45 0E LDA.W $0E45,X ; A = Y position low byte [$0E45,X]
$04:FF16 C2 20 REP #$20 ; A 16-bit
$04:FF18 18 CLC ; Clear carry
$04:FF19 69 08 00 ADC.W #$0008 ; + 8: sprite center
$04:FF1C AC D6 0D LDY.W $0DD6 ; Y = [$0DD6] (player index)
$04:FF1F 38 SEC ; Set carry
$04:FF20 F9 19 1F SBC.W $1F19,Y ; - player map Y [$1F19,Y]
$04:FF23 85 02 STA $02 ; [$02] = dy
$04:FF25 10 04 BPL $FF2B ; Positive: skip
$04:FF27 49 FF FF EOR.W #$FFFF ; \
$04:FF2A 1A INC A ; / A = -A (negate)
$04:FF2B 85 08 STA $08 ; [$08] = |dy|
$04:FF2D 60 RTS ; Return
$04:FF2E 20 EF FE JSR.W $FEEF ; Get dx, dy, |dx|, |dy| ($FEEF)
$04:FF31 46 06 LSR $06 ; [$06] = |dx| / 2
$04:FF33 46 08 LSR $08 ; [$08] = |dy| / 2
$04:FF35 E2 20 SEP #$20 ; A 8-bit
$04:FF37 BD 55 0E LDA.W $0E55,X ; A = Z height [$0E55,X]
$04:FF3A 4A LSR ; Height / 2
$04:FF3B 85 0A STA $0A ; [$0A] = height / 2
$04:FF3D 64 05 STZ $05 ; [$05] = 0: Z delta positive (so Z speed ends up negative)
$04:FF3F A0 04 LDY.B #$04 ; Y = 4: assume Z is the longest distance
$04:FF41 C5 08 CMP $08 ; height / 2 >= |dy| / 2?
$04:FF43 B0 04 BCS $FF49 ; Yes: keep Y = 4
$04:FF45 A0 02 LDY.B #$02 ; Y = 2: Y is longer
$04:FF47 A5 08 LDA $08 ; A = |dy| / 2
$04:FF49 C5 06 CMP $06 ; >= |dx| / 2?
$04:FF4B B0 04 BCS $FF51 ; Yes: keep
$04:FF4D A0 00 LDY.B #$00 ; Y = 0: X is the longest
$04:FF4F A5 06 LDA $06 ; A = |dx| / 2
$04:FF51 C9 01 CMP.B #$01 ; Longest distance >= 1?
$04:FF53 B0 12 BCS $FF67 ; Yes: head for the player
$04:FF55 9E 15 0E STZ.W $0E15,X ; Arrived: clear animation counter [$0E15,X]
$04:FF58 9E 95 0E STZ.W $0E95,X ; X speed = 0
$04:FF5B 9E A5 0E STZ.W $0EA5,X ; Y speed = 0
$04:FF5E 9E B5 0E STZ.W $0EB5,X ; Z speed = 0
$04:FF61 A9 40 LDA.B #$40 ; A = $40
$04:FF63 9D 55 0E STA.W $0E55,X ; Z height = $40
$04:FF66 60 RTS ; Return
$04:FF67 84 0C STY $0C ; [$0C] = index of the longest axis
$04:FF69 A2 04 LDX.B #$04 ; X = 4: start with Z
$04:FF6B E4 0C CPX $0C ; This the longest axis?
$04:FF6D D0 04 BNE $FF73 ; No: scale its speed
$04:FF6F A9 20 LDA.B #$20 ; Longest axis: speed magnitude = $20 (maximum)
$04:FF71 80 1E BRA $FF91 ; Go apply the sign
$04:FF73 9C 04 42 STZ.W $4204 ; Dividend low byte = 0
$04:FF76 B5 06 LDA $06,X ; Dividend high byte = this axis distance [$06,X]
$04:FF78 8D 05 42 STA.W $4205 ; Store in $4205
$04:FF7B B9 06 00 LDA.W $0006,Y ; A = longest distance
$04:FF7E 8D 06 42 STA.W $4206 ; Divisor = longest distance
$04:FF81 EA NOP ; \
$04:FF82 EA NOP ; |
$04:FF83 EA NOP ; |
$04:FF84 EA NOP ; } Wait for the hardware divide to finish
$04:FF85 EA NOP ; |
$04:FF86 EA NOP ; /
$04:FF87 C2 20 REP #$20 ; A 16-bit
$04:FF89 AD 14 42 LDA.W $4214 ; A = quotient (distance * 256 / longest distance)
$04:FF8C 4A LSR ; \
$04:FF8D 4A LSR ; } A = quotient / 8: speed proportional to distance (max $20)
$04:FF8E 4A LSR ; /
$04:FF8F E2 20 SEP #$20 ; A 8-bit
$04:FF91 34 01 BIT $01,X ; Test sign of delta (high byte at [$01,X])
$04:FF93 30 03 BMI $FF98 ; Negative delta: speed stays positive
$04:FF95 49 FF EOR.B #$FF ; \
$04:FF97 1A INC A ; / Positive delta: negate (move toward the player)
$04:FF98 95 00 STA $00,X ; Store speed in [$00,X] ($00 X, $02 Y, $04 Z)
$04:FF9A CA DEX ; \
$04:FF9B CA DEX ; / X -= 2: next axis
$04:FF9C 10 CD BPL $FF6B ; Loop for X = 4, 2, 0
$04:FF9E AE DE 0D LDX.W $0DDE ; X = sprite slot [$0DDE]
$04:FFA1 A5 00 LDA $00 ; A = X speed
$04:FFA3 9D 95 0E STA.W $0E95,X ; Store [$0E95,X]
$04:FFA6 A5 02 LDA $02 ; A = Y speed
$04:FFA8 9D A5 0E STA.W $0EA5,X ; Store [$0EA5,X]
$04:FFAB A5 04 LDA $04 ; A = Z speed
$04:FFAD 9D B5 0E STA.W $0EB5,X ; Store [$0EB5,X]
$04:FFB0 60 RTS ; Return
;;; $FFB1..FFF9: Freespace padding ;;;
$04:FFB1 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFB9 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFC1 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFC9 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFD1 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFD9 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFE1 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFE9 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFF1 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$04:FFF9 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF