;;; $8000..800E: Football data tables ;;;
;; $038000: unused values $13-$19 (not referenced).
;; $038007: X speed change indexed by the ground slope, $03800E: Y speed of the next bounce chosen at random.
$03:8000 .db $13,$14,$15,$16,$17,$18,$19 ; Unused: values $13-$19, not referenced anywhere
$03:8007 .db $F0,$F8,$FC,$00,$04,$08,$10 ; Football: X speed change indexed by [$15B8] + 3 (ground slope -3..+3)
$03:800E .db $A0,$D0,$C0,$D0 ; Football: Y speed after a bounce, indexed by random number & 3
;;; : Football sprite main routine (Football) ;;;
;; Bouncing football: reverses X speed on walls, zeroes Y speed on ceilings and, each time it lands, flips
;; horizontally,
;; picks a random bounce height and adds a slope-dependent push to its X speed (clamped to +/-$20).
;; Does nothing while sprites are locked; [$1540] > 1 freezes it, [$1540] = 1 spawns a smoke puff (probably
;; spin-jump kill).
;; Called by:
;; $03:A13C: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8012 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw sprite (generic graphics routine)
$03:8016 A5 9D LDA RAM_SpritesLocked ; \
$03:8018 D0 6C BNE $8086 ; / Return if sprites are locked
$03:801A 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when far off-screen
$03:801D 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Sprite-sprite and Mario-sprite interaction
$03:8021 BD 40 15 LDA.W $1540,X ; \
$03:8024 F0 07 BEQ $802D ; / [$1540] = 0: go move the sprite
$03:8026 3A DEC A ; \
$03:8027 D0 08 BNE $8031 ; / [$1540] - 1 != 0: skip the smoke and the movement
$03:8029 22 6F AB 01 JSL.L $AB6F ; [$1540] = 1: spawn a smoke puff
$03:802D 22 2A 80 01 JSL.L UpdateSpritePos ; Apply speed to position, check contact with blocks (UpdateSpritePos)
$03:8031 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8034 29 03 AND.B #$03 ; |
$03:8036 F0 07 BEQ $803F ; / No horizontal wall contact ([$1588] & 3 = 0): skip
$03:8038 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:803A 49 FF EOR.B #$FF ; |
$03:803C 1A INC A ; |
$03:803D 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = -[X speed] (bounce off the wall)
$03:803F BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8042 29 08 AND.B #$08 ; |
$03:8044 F0 02 BEQ $8048 ; / Not touching a ceiling ([$1588] bit 3): skip
$03:8046 74 AA STZ RAM_SpriteSpeedY,X ; Touching a ceiling: Y speed = 0
$03:8048 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:804B 29 04 AND.B #$04 ; |
$03:804D F0 37 BEQ $8086 ; / Not on the ground ([$1588] bit 2): return
$03:804F BD 40 15 LDA.W $1540,X ; \
$03:8052 D0 32 BNE $8086 ; / [$1540] non-zero: return
$03:8054 BD F6 15 LDA.W RAM_SpritePal,X ; \
$03:8057 49 40 EOR.B #$40 ; |
$03:8059 9D F6 15 STA.W RAM_SpritePal,X ; / Flip the sprite horizontally: [$15F6] ^= $40
$03:805C 22 F9 AC 01 JSL.L GetRand ; \
$03:8060 29 03 AND.B #$03 ; |
$03:8062 A8 TAY ; |
$03:8063 B9 0E 80 LDA.W $800E,Y ; |
$03:8066 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $800E[random & 3] (bounce up by a random amount)
$03:8068 BC B8 15 LDY.W $15B8,X ; \
$03:806B C8 INY ; |
$03:806C C8 INY ; |
$03:806D C8 INY ; |
$03:806E B9 07 80 LDA.W $8007,Y ; |
$03:8071 18 CLC ; |
$03:8072 75 B6 ADC RAM_SpriteSpeedX,X ; / A = [X speed] + $8007[[$15B8] + 3] (slope pushes the ball)
$03:8074 10 08 BPL $807E ; Result positive: go clamp at +$20
$03:8076 C9 E0 CMP.B #$E0 ; \
$03:8078 B0 0A BCS $8084 ; / Negative: keep it if >= $E0 (-$20)
$03:807A A9 E0 LDA.B #$E0 ; Else clamp to $E0
$03:807C 80 06 BRA $8084 ; Store
$03:807E C9 20 CMP.B #$20 ; \
$03:8080 90 02 BCC $8084 ; / Positive: keep it if < $20
$03:8082 A9 20 LDA.B #$20 ; Else clamp to $20
$03:8084 95 B6 STA RAM_SpriteSpeedX,X ; Store new X speed
$03:8086 60 RTS ; Return
;;; $8087: Big Boo boss main routine (BigBooBoss) ;;;
;; Draws the boss, updates its fade palette and dispatches on state [$C2] through BooBossPtrs.
;; When the sprite slot is freed (status 0) the level ends: sets cutscene flag [$13C6], end timer [$1493] =
;; $FF and level end music.
;; Called by:
;; $03:A160: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8087 22 98 83 03 JSL.L $8398 ; Draw the boss ($8398)
$03:808B 22 39 82 03 JSL.L $8239 ; Queue the boss's fade palette ($8239)
$03:808F BD C8 14 LDA.W $14C8,X ; \
$03:8092 D0 0E BNE $80A2 ; / Sprite status non-zero: go to the main code
$03:8094 EE C6 13 INC.W $13C6 ; Sprite gone: [$13C6]++ (cutscene flag, Mario stops walking at level end)
$03:8097 A9 FF LDA.B #$FF ; \
$03:8099 8D 93 14 STA.W $1493 ; / [$1493] = $FF: end-of-level timer
$03:809C A9 0B LDA.B #$0B ; \
$03:809E 8D FB 1D STA.W $1DFB ; / [$1DFB] = $0B: request level end music
$03:80A1 60 RTS ; Return
$03:80A2 C9 08 CMP.B #$08 ; \
$03:80A4 D0 2E BNE $80D4 ; / Status not 8 (normal): return
$03:80A6 A5 9D LDA RAM_SpritesLocked ; \
$03:80A8 D0 2A BNE $80D4 ; / Sprites locked: return
$03:80AA B5 C2 LDA RAM_SpriteState,X ; A = boss state [$C2]
$03:80AC 22 DF 86 00 JSL.L ExecutePtr ; Run the handler for this state (BooBossPtrs)
; this table holds the location of the coding to use for the various sprite states
;;; $80B0: Pointer table: Big Boo boss states (BooBossPtrs) ;;;
;; States: 0 hidden wait, 1 fade in, 2 normal movement, 3 hit, 4 fade out, 5 hidden movement, 6 defeated.
;; Also holds the code for state 0 ($80BE, waits $50 frames with graphics frame 3) and state 1
;; ($80D5,
;; steps the palette index [$190B] up every 8 frames until 7, then state 2).
$03:80B0 BE 80 .dw $80BE ; State 0: hidden, wait
$03:80B2 D5 80 .dw $80D5 ; State 1: fade in
$03:80B4 19 81 .dw $8119 ; State 2: normal movement
$03:80B6 8B 81 .dw $818B ; State 3: hit by a thrown sprite
$03:80B8 BC 81 .dw $81BC ; State 4: fade out
$03:80BA 06 81 .dw $8106 ; State 5: hidden, moving, wait
$03:80BC D3 81 .dw $81D3 ; State 6: defeated
; sprite state 0
$03:80BE A9 03 LDA.B #$03 ; \
$03:80C0 9D 02 16 STA.W $1602,X ; / Graphics frame [$1602] = 3 (hiding)
$03:80C3 FE 70 15 INC.W $1570,X ; [$1570]++: hidden time counter
$03:80C6 BD 70 15 LDA.W $1570,X ; \
$03:80C9 C9 90 CMP.B #$90 ; |
$03:80CB D0 07 BNE $80D4 ; / [$1570] != $90: return
$03:80CD A9 08 LDA.B #$08 ; \
$03:80CF 9D 40 15 STA.W $1540,X ; / [$1540] = 8: delay between fade steps
$03:80D2 F6 C2 INC RAM_SpriteState,X ; State = 1 (fade in)
$03:80D4 60 RTS ; Return
; sprite state 1
$03:80D5 BD 40 15 LDA.W $1540,X ; \
$03:80D8 D0 1F BNE $80F9 ; / Fade step timer [$1540] still running: return
$03:80DA A9 08 LDA.B #$08 ; \
$03:80DC 9D 40 15 STA.W $1540,X ; / [$1540] = 8
$03:80DF EE 0B 19 INC.W $190B ; Fade step: [$190B]++ (palette index)
$03:80E2 AD 0B 19 LDA.W $190B ; \
$03:80E5 C9 02 CMP.B #$02 ; |
$03:80E7 D0 05 BNE $80EE ; / [$190B] != 2: skip the sound
$03:80E9 A0 10 LDY.B #$10 ; \
$03:80EB 8C F9 1D STY.W $1DF9 ; / [$1DF9] = $10: sound effect
$03:80EE C9 07 CMP.B #$07 ; \
$03:80F0 D0 07 BNE $80F9 ; / [$190B] != 7: return
$03:80F2 F6 C2 INC RAM_SpriteState,X ; Fully visible: state = 2 (normal)
$03:80F4 A9 40 LDA.B #$40 ; \
$03:80F6 9D 40 15 STA.W $1540,X ; / [$1540] = $40
$03:80F9 60 RTS ; Return
;;; $80FA..8102: Data: Big Boo boss movement tables ;;;
;; X/Y acceleration and max speed pairs (reversed when the max is reached) and the turn animation frames.
$03:80FA .db $FF,$01 ; X acceleration: +1, -1 (indexed by [$151C] & 1)
$03:80FC .db $F0,$10 ; Max X speed: $F0, $10
$03:80FE .db $0C,$F4 ; Max Y speed: $0C, $F4
$03:8100 .db $01,$FF ; Y acceleration: +1, -1 (indexed by [$1528] & 1)
$03:8102 .db $01,$02,$02,$01 ; Graphics frame while turning, indexed by turn timer / 8
; sprite state 5
;;; $8106: Big Boo boss: remaining states and helpers ;;;
;; State 5 (hidden and moving, then back to state 0), state 2 (visible: sprite hit check, turn toward Mario,
;; drift every 8th frame),
;; state 3 (hit: flash, 3rd hit = defeated and KillMostSprites), state 4 (fade out), state 6 (killed, flung
;; upward).
;; $0381E4: checks sprite slots 0-$0B for a carryable or kicked sprite touching the boss; it is destroyed and
;; shatters like a block.
;; $038239 (JSL, also called from bank $02): queues a CGRAM upload of 8 colors for fade step [$190B] and sets
;; [$40] for transparency.
$03:8106 BD 40 15 LDA.W $1540,X ; \
$03:8109 D0 07 BNE $8112 ; / [$1540] still running: skip
$03:810B 74 C2 STZ RAM_SpriteState,X ; Timer done: state = 0
$03:810D A9 40 LDA.B #$40 ; \
$03:810F 9D 70 15 STA.W $1570,X ; / [$1570] = $40
$03:8112 A9 03 LDA.B #$03 ; \
$03:8114 9D 02 16 STA.W $1602,X ; / Graphics frame [$1602] = 3 (hiding)
$03:8117 80 06 BRA $811F ; Go to the movement code ($811F)
; sprite state 2
$03:8119 9E 02 16 STZ.W $1602,X ; Graphics frame [$1602] = 0 (normal)
$03:811C 20 E4 81 JSR.W $81E4 ; Check for thrown sprites hitting the boss ($81E4)
$03:811F BD AC 15 LDA.W $15AC,X ; \
$03:8122 D0 0E BNE $8132 ; / Turn timer [$15AC] non-zero: already turning, skip
$03:8124 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:8127 98 TYA ; |
$03:8128 DD 7C 15 CMP.W RAM_SpriteDir,X ; |
$03:812B F0 1D BEQ $814A ; / Already facing Mario: skip to the movement code
$03:812D A9 1F LDA.B #$1F ; \
$03:812F 9D AC 15 STA.W $15AC,X ; / [$15AC] = $1F: start the turn animation
$03:8132 C9 10 CMP.B #$10 ; \
$03:8134 D0 0A BNE $8140 ; / Turn timer = $10 (halfway)? no: skip the flip
$03:8136 48 PHA ; Save the timer
$03:8137 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:813A 49 01 EOR.B #$01 ; |
$03:813C 9D 7C 15 STA.W RAM_SpriteDir,X ; / Flip direction: [$157C] ^= 1
$03:813F 68 PLA ; Restore the timer
$03:8140 4A LSR ; \
$03:8141 4A LSR ; |
$03:8142 4A LSR ; |
$03:8143 A8 TAY ; / Y = turn timer / 8
$03:8144 B9 02 81 LDA.W $8102,Y ; \
$03:8147 9D 02 16 STA.W $1602,X ; / Graphics frame [$1602] = $8102[Y] (turn animation)
$03:814A A5 14 LDA RAM_FrameCounterB ; \
$03:814C 29 07 AND.B #$07 ; |
$03:814E D0 16 BNE $8166 ; / Not every 8th frame ([$14] & 7): skip the X acceleration
$03:8150 BD 1C 15 LDA.W $151C,X ; \
$03:8153 29 01 AND.B #$01 ; |
$03:8155 A8 TAY ; |
$03:8156 B5 B6 LDA RAM_SpriteSpeedX,X ; |
$03:8158 18 CLC ; |
$03:8159 79 FA 80 ADC.W $80FA,Y ; |
$03:815C 95 B6 STA RAM_SpriteSpeedX,X ; / X speed += $80FA[[$151C] & 1]
$03:815E D9 FC 80 CMP.W $80FC,Y ; \
$03:8161 D0 03 BNE $8166 ; / X speed != max ($80FC)? skip
$03:8163 FE 1C 15 INC.W $151C,X ; [$151C]++: reverse the X acceleration
$03:8166 A5 14 LDA RAM_FrameCounterB ; \
$03:8168 29 07 AND.B #$07 ; |
$03:816A D0 16 BNE $8182 ; / Not every 8th frame: skip the Y acceleration
$03:816C BD 28 15 LDA.W $1528,X ; \
$03:816F 29 01 AND.B #$01 ; |
$03:8171 A8 TAY ; |
$03:8172 B5 AA LDA RAM_SpriteSpeedY,X ; |
$03:8174 18 CLC ; |
$03:8175 79 00 81 ADC.W $8100,Y ; |
$03:8178 95 AA STA RAM_SpriteSpeedY,X ; / Y speed += $8100[[$1528] & 1]
$03:817A D9 FE 80 CMP.W $80FE,Y ; \
$03:817D D0 03 BNE $8182 ; / Y speed != max ($80FE)? skip
$03:817F FE 28 15 INC.W $1528,X ; [$1528]++: reverse the Y acceleration
$03:8182 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed (no gravity)
$03:8186 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:818A 60 RTS ; Return
; sprite state 3
$03:818B BD 40 15 LDA.W $1540,X ; \
$03:818E D0 1E BNE $81AE ; / Hit timer [$1540] still running: go flash
$03:8190 F6 C2 INC RAM_SpriteState,X ; State = 4 (fade out)
$03:8192 A9 08 LDA.B #$08 ; \
$03:8194 9D 40 15 STA.W $1540,X ; / [$1540] = 8
$03:8197 22 8B F7 07 JSL.L LoadSpriteTables ; Reload the sprite tables (LoadSpriteTables)
$03:819B FE 34 15 INC.W $1534,X ; Hit counter [$1534]++
$03:819E BD 34 15 LDA.W $1534,X ; \
$03:81A1 C9 03 CMP.B #$03 ; |
$03:81A3 D0 08 BNE $81AD ; / Not the 3rd hit: return
$03:81A5 A9 06 LDA.B #$06 ; \
$03:81A7 95 C2 STA RAM_SpriteState,X ; / State = 6 (defeated)
$03:81A9 22 C8 A6 03 JSL.L KillMostSprites ; Kill all other sprites (KillMostSprites)
$03:81AD 60 RTS ; Return
$03:81AE 29 0E AND.B #$0E ; \
$03:81B0 5D F6 15 EOR.W RAM_SpritePal,X ; |
$03:81B3 9D F6 15 STA.W RAM_SpritePal,X ; / Flash: [$15F6] ^= [$1540] & $0E (palette bits)
$03:81B6 A9 03 LDA.B #$03 ; \
$03:81B8 9D 02 16 STA.W $1602,X ; / Graphics frame [$1602] = 3 (hiding)
$03:81BB 60 RTS ; Return
; sprite state 4
$03:81BC BD 40 15 LDA.W $1540,X ; \
$03:81BF D0 11 BNE $81D2 ; / Timer [$1540] still running: return
$03:81C1 A9 08 LDA.B #$08 ; \
$03:81C3 9D 40 15 STA.W $1540,X :/ ; / [$1540] = 8
$03:81C6 CE 0B 19 DEC.W $190B ; \
$03:81C9 D0 07 BNE $81D2 ; / [$190B]--; non-zero: return
$03:81CB F6 C2 INC RAM_SpriteState,X ; Fully faded out: state = 5
$03:81CD A9 C0 LDA.B #$C0 ; \
$03:81CF 9D 40 15 STA.W $1540,X ; / [$1540] = $C0
$03:81D2 60 RTS ; Return
; sprite state 6
$03:81D3 A9 02 LDA.B #$02 ; \
$03:81D5 9D C8 14 STA.W $14C8,X ; / Status = 2 (killed, falls off screen)
$03:81D8 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:81DA A9 D0 LDA.B #$D0 ; \
$03:81DC 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $D0 (up)
$03:81DE A9 23 LDA.B #$23 ; \
$03:81E0 8D F9 1D STA.W $1DF9 ; / [$1DF9] = $23: sound effect
$03:81E3 60 RTS ; Return
$03:81E4 A0 0B LDY.B #$0B ; Y = $0B: start with the last sprite slot
$03:81E6 B9 C8 14 LDA.W $14C8,Y ; \
$03:81E9 C9 09 CMP.B #$09 ; |
$03:81EB F0 08 BEQ $81F5 ; / Status 9 (carryable): check contact
$03:81ED C9 0A CMP.B #$0A ; \
$03:81EF F0 04 BEQ $81F5 ; / Status $0A (kicked): check contact
$03:81F1 88 DEY ; Next slot: Y--
$03:81F2 10 F2 BPL $81E6 ; Loop while Y >= 0
$03:81F4 60 RTS ; Return
$03:81F5 DA PHX ; Save the boss's sprite index
$03:81F6 BB TYX ; X = other sprite
$03:81F7 22 E5 B6 03 JSL.L GetSpriteClippingB ; Get clipping box B of the other sprite
$03:81FB FA PLX ; Restore the boss's index
$03:81FC 22 9F B6 03 JSL.L GetSpriteClippingA ; Get clipping box A of the boss
$03:8200 22 2B B7 03 JSL.L CheckForContact ; Check overlap (carry set = touching)
$03:8204 90 EB BCC $81F1 ; Not touching: next slot
$03:8206 A9 03 LDA.B #$03 ; \
$03:8208 95 C2 STA RAM_SpriteState,X ; / State = 3 (hit)
$03:820A A9 40 LDA.B #$40 ; \
$03:820C 9D 40 15 STA.W $1540,X ; / [$1540] = $40
$03:820F DA PHX ; Save the boss's index
$03:8210 BB TYX ; X = the sprite that hit the boss
$03:8211 9E C8 14 STZ.W $14C8,X ; Remove that sprite (status 0)
$03:8214 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:8216 85 9A STA RAM_BlockXLo ; |
$03:8218 BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:821B 85 9B STA RAM_BlockXHi ; |
$03:821D B5 D8 LDA RAM_SpriteYLo,X ; |
$03:821F 85 98 STA RAM_BlockYLo ; |
$03:8221 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:8224 85 99 STA RAM_BlockYHi ; / Block position [$9A],[$9B],[$98],[$99] = that sprite's position
$03:8226 8B PHB ; Save the data bank
$03:8227 A9 02 LDA.B #$02 ; \
$03:8229 48 PHA ; |
$03:822A AB PLB ; / Data bank = $02
$03:822B A9 FF LDA.B #$FF ; A = $FF
$03:822D 22 63 86 02 JSL.L ShatterBlock ; Spawn shattering block pieces at the block position (ShatterBlock)
$03:8231 AB PLB ; Restore the data bank
$03:8232 FA PLX ; Restore the boss's index
$03:8233 A9 28 LDA.B #$28 ; \
$03:8235 8D FC 1D STA.W $1DFC ; / [$1DFC] = $28: sound effect
$03:8238 60 RTS ; Return
$03:8239 A0 24 LDY.B #$24 ; \
$03:823B 84 40 STY $40 ; / [$40] (CGADSUB mirror) = $24: color math on BG3 and backdrop
$03:823D AD 0B 19 LDA.W $190B ; A = [$190B] (fade step)
$03:8240 C9 08 CMP.B #$08 ; Carry set if step >= 8
$03:8242 3A DEC A ; A = step - 1 (carry unchanged)
$03:8243 B0 05 BCS $824A ; Step >= 8: keep $24
$03:8245 A0 34 LDY.B #$34 ; \
$03:8247 84 40 STY $40 ; / [$40] = $34: color math also on sprites (transparent boss)
$03:8249 1A INC A ; Undo the DEC: A = step
$03:824A 0A ASL ; \
$03:824B 0A ASL ; |
$03:824C 0A ASL ; |
$03:824D 0A ASL ; |
$03:824E AA TAX ; / X = A * 16: offset into BooBossPals (8 colors per step)
$03:824F 64 00 STZ $00 ; [$00] = 0: byte counter
$03:8251 AC 81 06 LDY.W $0681 ; Y = [$0681]: index into the CGRAM upload queue
$03:8254 BF 82 B9 03 LDA.L BooBossPals,X ; A = next palette byte from BooBossPals[X]
$03:8258 99 84 06 STA.W $0684,Y ; Store at $0684 + Y (data part of the new queue record)
$03:825B C8 INY ; Y++
$03:825C E8 INX ; X++
$03:825D E6 00 INC $00 ; [$00]++
$03:825F A5 00 LDA $00 ; \
$03:8261 C9 10 CMP.B #$10 ; |
$03:8263 D0 EF BNE $8254 ; / Loop for 16 bytes
$03:8265 AE 81 06 LDX.W $0681 ; X = [$0681]
$03:8268 A9 10 LDA.B #$10 ; \
$03:826A 9D 82 06 STA.W $0682,X ; / Record byte count = $10
$03:826D A9 F0 LDA.B #$F0 ; \
$03:826F 9D 83 06 STA.W $0683,X ; / Record CGRAM address = $F0 (last sprite palette)
$03:8272 9E 94 06 STZ.W $0694,X ; Terminate the queue after the record
$03:8275 8A TXA ; \
$03:8276 18 CLC ; |
$03:8277 69 12 ADC.B #$12 ; |
$03:8279 8D 81 06 STA.W $0681 ; / [$0681] += $12: advance the queue by one record
$03:827C AE E9 15 LDX.W $15E9 ; Restore the sprite index from [$15E9]
$03:827F 6B RTL ; Return
;;; $8280: Table: Big Boo X tile offsets (BigBooDispX) ;;;
;; 80 entries: 4 graphics frames x 20 tiles (16x16), X offset of each tile.
$03:8280 .db $08,$08,$20,$00,$00,$00,$00,$10 ; X offsets: frame 0, tiles 0-7
$03:8288 .db $10,$10,$10,$20,$20,$20,$20,$30 ; X offsets: frame 0, tiles 8-15
$03:8290 .db $30,$30,$30,$FD,$0C,$0C,$27,$00 ; X offsets: frame 0 tile 16 to frame 1 tile 3
$03:8298 .db $00,$00,$00,$10,$10,$10,$10,$1F ; X offsets: frame 1, tiles 4-11
$03:82A0 .db $20,$20,$1F,$2E,$2E,$2C,$2C,$FB ; X offsets: frame 1, tiles 12-19
$03:82A8 .db $12,$12,$30,$00,$00,$00,$00,$10 ; X offsets: frame 2, tiles 0-7
$03:82B0 .db $10,$10,$10,$1F,$20,$20,$1F,$2E ; X offsets: frame 2, tiles 8-15
$03:82B8 .db $2E,$2E,$2E,$F8,$11,$FF,$08,$08 ; X offsets: frame 2 tile 16 to frame 3 tile 3
$03:82C0 .db $00,$00,$00,$00,$10,$10,$10,$10 ; X offsets: frame 3, tiles 4-11
$03:82C8 .db $20,$20,$20,$20,$30,$30,$30,$30 ; X offsets: frame 3, tiles 12-19
;;; $82D0: Table: Big Boo Y tile offsets (BigBooDispY) ;;;
;; 40 entries: 2 sets x 20 tiles. Set 0 for frames 0-2, set 1 for frame 3 (hiding).
$03:82D0 .db $12,$22,$18,$00,$10,$20,$30,$00 ; Y offsets: set 0, tiles 0-7
$03:82D8 .db $10,$20,$30,$00,$10,$20,$30,$00 ; Y offsets: set 0, tiles 8-15
$03:82E0 .db $10,$20,$30,$18,$16,$16,$12,$22 ; Y offsets: set 0 tile 16 to set 1 tile 3
$03:82E8 .db $00,$10,$20,$30,$00,$10,$20,$30 ; Y offsets: set 1, tiles 4-11
$03:82F0 .db $00,$10,$20,$30,$00,$10,$20,$30 ; Y offsets: set 1, tiles 12-19
;;; $82F8: Table: Big Boo tile numbers (BigBooTiles) ;;;
;; 80 entries: 4 graphics frames x 20 tiles.
$03:82F8 .db $C0,$E0,$E8,$80,$A0,$A0,$80,$82 ; Tiles: frame 0, tiles 0-7
$03:8300 .db $A2,$A2,$82,$84,$A4,$C4,$E4,$86 ; Tiles: frame 0, tiles 8-15
$03:8308 .db $A6,$C6,$E6,$E8,$C0,$E0,$E8,$80 ; Tiles: frame 0 tile 16 to frame 1 tile 3
$03:8310 .db $A0,$A0,$80,$82,$A2,$A2,$82,$84 ; Tiles: frame 1, tiles 4-11
$03:8318 .db $A4,$C4,$E4,$86,$A6,$C6,$E6,$E8 ; Tiles: frame 1, tiles 12-19
$03:8320 .db $C0,$E0,$E8,$80,$A0,$A0,$80,$82 ; Tiles: frame 2, tiles 0-7
$03:8328 .db $A2,$A2,$82,$84,$A4,$A4,$84,$86 ; Tiles: frame 2, tiles 8-15
$03:8330 .db $A6,$A6,$86,$E8,$E8,$E8,$C2,$E2 ; Tiles: frame 2 tile 16 to frame 3 tile 3
$03:8338 .db $80,$A0,$A0,$80,$82,$A2,$A2,$82 ; Tiles: frame 3, tiles 4-11
$03:8340 .db $84,$A4,$C4,$E4,$86,$A6,$C6,$E6 ; Tiles: frame 3, tiles 12-19
;;; $8348: Big Boo graphics routine, flip table (BigBooGfxProp) ;;;
;; Properties table (X/Y flip bits), then the drawing code at $038398 (wrapper, also called from bank $01 for
;; the Boo block).
;; Sprite $37 only picks a frame (0, 6, or flashing 2/3) and uses the generic routine; others draw 20 16x16
;; tiles,
;; mirroring the X offsets within a $28 wide area when direction is 0.
;; Parameters: X: sprite index.
$03:8348 .db $00,$00,$40,$00,$00,$80,$80,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 0, tiles 0-7
$03:8350 .db $00,$80,$80,$00,$00,$00,$00,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 0, tiles 8-15
$03:8358 .db $00,$00,$00,$00,$00,$00,$40,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 0 tile 16 to frame 1 tile 3
$03:8360 .db $00,$80,$80,$00,$00,$80,$80,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 1, tiles 4-11
$03:8368 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 1, tiles 12-19
$03:8370 .db $00,$00,$40,$00,$00,$80,$80,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 2, tiles 0-7
$03:8378 .db $00,$80,$80,$00,$00,$80,$80,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 2, tiles 8-15
$03:8380 .db $00,$80,$80,$00,$00,$40,$00,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 2 tile 16 to frame 3 tile 3
$03:8388 .db $00,$00,$80,$80,$00,$00,$80,$80 ; Properties ($40 = X flip, $80 = Y flip): frame 3, tiles 4-11
$03:8390 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Properties ($40 = X flip, $80 = Y flip): frame 3, tiles 12-19
$03:8398 8B PHB ; \
$03:8399 4B PHK ; |
$03:839A AB PLB ; / Data bank = $03
$03:839B 20 A0 83 JSR.W $83A0 ; Draw ($83A0)
$03:839E AB PLB ; Restore the data bank
$03:839F 6B RTL ; Return
$03:83A0 B5 9E LDA RAM_SpriteNum,X ; \
$03:83A2 C9 37 CMP.B #$37 ; |
$03:83A4 D0 1C BNE $83C2 ; / Not sprite $37: go to the Big Boo drawing code
$03:83A6 A9 00 LDA.B #$00 ; Frame 0
$03:83A8 B4 C2 LDY RAM_SpriteState,X ; \
$03:83AA F0 0E BEQ $83BA ; / State 0: use frame 0
$03:83AC A9 06 LDA.B #$06 ; Frame 6
$03:83AE BC 58 15 LDY.W $1558,X ; \
$03:83B1 F0 07 BEQ $83BA ; / [$1558] = 0: use frame 6
$03:83B3 98 TYA ; \
$03:83B4 29 04 AND.B #$04 ; |
$03:83B6 4A LSR ; |
$03:83B7 4A LSR ; |
$03:83B8 69 02 ADC.B #$02 ; / Frame = 2 + (([$1558] >> 2) & 1): flashing frames 2 and 3
$03:83BA 9D 02 16 STA.W $1602,X ; Store the graphics frame [$1602]
$03:83BD 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw (generic graphics routine)
$03:83C1 60 RTS ; Return
$03:83C2 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:83C5 BD 02 16 LDA.W $1602,X ; \
$03:83C8 85 06 STA $06 ; / [$06] = graphics frame [$1602]
$03:83CA 0A ASL ; \
$03:83CB 0A ASL ; |
$03:83CC 85 03 STA $03 ; |
$03:83CE 0A ASL ; |
$03:83CF 0A ASL ; |
$03:83D0 65 03 ADC $03 ; |
$03:83D2 85 02 STA $02 ; / [$02] = frame * 20: index of this frame's first tile in the tables
$03:83D4 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:83D7 85 04 STA $04 ; / [$04] = sprite direction [$157C]
$03:83D9 BD F6 15 LDA.W RAM_SpritePal,X ; \
$03:83DC 85 05 STA $05 ; / [$05] = sprite properties [$15F6]
$03:83DE A2 00 LDX.B #$00 ; X = 0: tile loop counter
$03:83E0 DA PHX ; Save the loop counter
$03:83E1 A6 02 LDX $02 ; X = [$02]: table index of this tile
$03:83E3 BD F8 82 LDA.W BigBooTiles,X ; \
$03:83E6 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = BigBooTiles[X]
$03:83E9 A5 04 LDA $04 ; \
$03:83EB 4A LSR ; / Carry = sprite direction
$03:83EC BD 48 83 LDA.W BigBooGfxProp,X ; \
$03:83EF 05 05 ORA $05 ; |
$03:83F1 B0 02 BCS $83F5 ; / A = BigBooGfxProp[X] | [$05]
$03:83F3 49 40 EOR.B #$40 ; Direction 0: flip the tile horizontally
$03:83F5 05 64 ORA $64 ; \
$03:83F7 99 03 03 STA.W OAM_Prop,Y ; / Add the level's sprite priority [$64] and store as OAM properties
$03:83FA BD 80 82 LDA.W BigBooDispX,X ; A = BigBooDispX[X]
$03:83FD B0 06 BCS $8405 ; Direction 1: use the offset as is
$03:83FF 49 FF EOR.B #$FF ; \
$03:8401 1A INC A ; |
$03:8402 18 CLC ; |
$03:8403 69 28 ADC.B #$28 ; / Direction 0: A = $28 - offset (mirror the tile within the boss)
$03:8405 18 CLC ; \
$03:8406 65 00 ADC $00 ; |
$03:8408 99 00 03 STA.W OAM_DispX,Y ; / OAM X = A + [$00] (sprite screen X)
$03:840B FA PLX ; \
$03:840C DA PHX ; / X = loop counter (also kept on the stack)
$03:840D A5 06 LDA $06 ; \
$03:840F C9 03 CMP.B #$03 ; |
$03:8411 90 05 BCC $8418 ; / Frame < 3: use the first set of Y offsets
$03:8413 8A TXA ; \
$03:8414 18 CLC ; |
$03:8415 69 14 ADC.B #$14 ; |
$03:8417 AA TAX ; / Frame 3 (hiding): X += $14 (second set of Y offsets)
$03:8418 A5 01 LDA $01 ; \
$03:841A 18 CLC ; |
$03:841B 7D D0 82 ADC.W BigBooDispY,X ; |
$03:841E 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = [$01] + BigBooDispY[X]
$03:8421 FA PLX ; X = loop counter
$03:8422 C8 INY ; \
$03:8423 C8 INY ; |
$03:8424 C8 INY ; |
$03:8425 C8 INY ; / Y += 4: next OAM slot
$03:8426 E6 02 INC $02 ; Tile index [$02]++
$03:8428 E8 INX ; Loop counter++
$03:8429 E0 14 CPX.B #$14 ; \
$03:842B D0 B3 BNE $83E0 ; / Loop for all 20 ($14) tiles
$03:842D AE E9 15 LDX.W $15E9 ; X = sprite index [$15E9]
$03:8430 BD 02 16 LDA.W $1602,X ; \
$03:8433 C9 03 CMP.B #$03 ; |
$03:8435 D0 14 BNE $844B ; / Graphics frame != 3 (hiding): finish
$03:8437 BD 58 15 LDA.W $1558,X ; \
$03:843A F0 0F BEQ $844B ; / [$1558] = 0 (never set): finish
$03:843C BC EA 15 LDY.W RAM_SprOAMIndex,X ; Unused: Y = OAM index
$03:843F B9 01 03 LDA.W OAM_DispY,Y ; Unused: A = OAM Y of the first tile
$03:8442 18 CLC ; Unused: CLC
$03:8443 69 05 ADC.B #$05 ; Unused: A += 5
$03:8445 99 01 03 STA.W OAM_DispY,Y ; Unused: move the first tile down 5 pixels
$03:8448 99 05 03 STA.W OAM_Tile2DispY,Y ; Unused: move the second tile down as well
$03:844B A9 13 LDA.B #$13 ; A = $13: 20 tiles written
$03:844D A0 02 LDY.B #$02 ; Y = 2: the tiles are 16x16
$03:844F 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish the OAM write (FinishOAMWrite)
$03:8453 60 RTS ; Return
;;; $8454: Grey falling platform main routine (GreyFallingPlat) ;;;
;; Platform that falls when Mario stands on it: starts at Y speed 3, waits [$1540] = $18 frames, then
;; accelerates by 2 up to $40.
;; Called by:
;; $03:A169: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8454 20 92 84 JSR.W $8492 ; Draw the platform ($8492)
$03:8457 A5 9D LDA RAM_SpritesLocked ; \
$03:8459 D0 2E BNE $8489 ; / Sprites locked: return
$03:845B 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when far off-screen
$03:845E B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8460 F0 14 BEQ $8476 ; / Y speed = 0 (not stepped on yet): skip the movement
$03:8462 BD 40 15 LDA.W $1540,X ; \
$03:8465 D0 0B BNE $8472 ; / [$1540] non-zero: skip the acceleration
$03:8467 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8469 C9 40 CMP.B #$40 ; |
$03:846B 10 05 BPL $8472 ; / Y speed >= $40: skip the acceleration
$03:846D 18 CLC ; \
$03:846E 69 02 ADC.B #$02 ; |
$03:8470 95 AA STA RAM_SpriteSpeedY,X ; / Y speed += 2
$03:8472 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:8476 22 4F B4 01 JSL.L InvisBlkMainRt ; Make the platform solid (InvisBlkMainRt); carry set if Mario stands on it
$03:847A 90 0D BCC $8489 ; Mario not on it: return
$03:847C B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:847E D0 09 BNE $8489 ; / Already falling: return
$03:8480 A9 03 LDA.B #$03 ; \
$03:8482 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = 3: start falling
$03:8484 A9 18 LDA.B #$18 ; \
$03:8486 9D 40 15 STA.W $1540,X ; / [$1540] = $18: delay before accelerating
$03:8489 60 RTS ; Return
;;; $848A: Table: falling platform tile X offsets (FallingPlatDispX) ;;;
$03:848A .db $00,$10,$20,$30 ; Tile X offsets: 0, $10, $20, $30
;;; $848E: Falling platform tiles and graphics routine (FallingPlatTiles) ;;;
;; Tile table, then $8492 which draws four 16x16 tiles in a row (palette 9, GFX page 2).
$03:848E .db $60,$61,$61,$62 ; Tiles: $60 (left end), $61, $61, $62 (right end)
$03:8492 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:8495 DA PHX ; Save the sprite index
$03:8496 A2 03 LDX.B #$03 ; X = 3: tile loop counter
$03:8498 A5 00 LDA $00 ; \
$03:849A 18 CLC ; |
$03:849B 7D 8A 84 ADC.W FallingPlatDispX,X ; |
$03:849E 99 00 03 STA.W OAM_DispX,Y ; / OAM X = [$00] + FallingPlatDispX[X]
$03:84A1 A5 01 LDA $01 ; \
$03:84A3 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = [$01]
$03:84A6 BD 8E 84 LDA.W FallingPlatTiles,X ; \
$03:84A9 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = FallingPlatTiles[X]
$03:84AC A9 03 LDA.B #$03 ; \
$03:84AE 05 64 ORA $64 ; |
$03:84B0 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = $03 | [$64]: palette 9, second sprite GFX page
$03:84B3 C8 INY ; \
$03:84B4 C8 INY ; |
$03:84B5 C8 INY ; |
$03:84B6 C8 INY : / ; / Y += 4: next OAM slot
$03:84B7 CA DEX ; X--
$03:84B8 10 DE BPL $8498 ; Loop for all 4 tiles
$03:84BA FA PLX ; Restore the sprite index
$03:84BB A0 02 LDY.B #$02 ; Y = 2: the tiles are 16x16
$03:84BD A9 03 LDA.B #$03 ; A = 3: 4 tiles written
$03:84BF 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish the OAM write (FinishOAMWrite)
$03:84C3 60 RTS ; Return
;;; $84C4: Table: Blurp max Y speed (BlurpMaxSpeedY) ;;;
$03:84C4 .db $04,$FC ; Max Y speed by direction: +4 (down), -4 (up)
;;; $84C6: Table: Blurp X speed (BlurpSpeedX) ;;;
$03:84C6 .db $08,$F8 ; X speed by direction: +8 (right), -8 (left)
;;; $84C8: Table: Blurp Y acceleration (BlurpAccelY) ;;;
$03:84C8 .db $01,$FF ; Y acceleration by direction: +1, -1
;;; $84CA: Blurp main routine (Blurp) ;;;
;; Swimming fish. Alternates between tiles $A2 and $EC every 8 frames; dead Blurps are drawn flipped.
;; Every 4th frame Y accelerates up and down within +/-4 (state bit 0 selects the direction); constant X speed
;; +/-8 by facing.
;; Called by:
;; $03:A172: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:84CA 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw sprite (generic graphics routine)
$03:84CE BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:84D1 AD 14 00 LDA.W RAM_FrameCounterB ; \
$03:84D4 4A LSR ; |
$03:84D5 4A LSR ; |
$03:84D6 4A LSR ; |
$03:84D7 18 CLC ; |
$03:84D8 6D E9 15 ADC.W $15E9 ; |
$03:84DB 4A LSR ; / Carry = bit 0 of ([$14] / 8 + sprite index): swim animation, 8 frames per tile
$03:84DC A9 A2 LDA.B #$A2 ; A = $A2: first animation tile
$03:84DE 90 02 BCC $84E2 ; Carry clear: use it
$03:84E0 A9 EC LDA.B #$EC ; A = $EC: second animation tile
$03:84E2 99 02 03 STA.W OAM_Tile,Y ; Store the tile number
$03:84E5 BD C8 14 LDA.W $14C8,X ; \
$03:84E8 C9 08 CMP.B #$08 ; |
$03:84EA F0 09 BEQ $84F5 ; / Status 8 (normal): go to the main code
$03:84EC B9 03 03 LDA.W OAM_Prop,Y ; \
$03:84EF 09 80 ORA.B #$80 : | ; |
$03:84F1 99 03 03 STA.W OAM_Prop,Y ; / Dead: flip the sprite vertically
$03:84F4 60 RTS ; Return
$03:84F5 A5 9D LDA RAM_SpritesLocked ; \
$03:84F7 D0 31 BNE $852A ; / Sprites locked: return
$03:84F9 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when far off-screen
$03:84FC A5 14 LDA RAM_FrameCounterB ; \
$03:84FE 29 03 AND.B #$03 ; |
$03:8500 D0 14 BNE $8516 ; / Not every 4th frame: skip the Y acceleration
$03:8502 B5 C2 LDA RAM_SpriteState,X ; \
$03:8504 29 01 AND.B #$01 ; |
$03:8506 A8 TAY ; / Y = [$C2] & 1: acceleration direction
$03:8507 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8509 18 CLC ; |
$03:850A 79 C8 84 ADC.W BlurpAccelY,Y ; |
$03:850D 95 AA STA RAM_SpriteSpeedY,X ; / Y speed += BlurpAccelY[Y]
$03:850F D9 C4 84 CMP.W BlurpMaxSpeedY,Y ; \
$03:8512 D0 02 BNE $8516 ; / Y speed != max for this direction: skip
$03:8514 F6 C2 INC RAM_SpriteState,X ; Max reached: state++ (reverse direction)
$03:8516 BC 7C 15 LDY.W RAM_SpriteDir,X ; \
$03:8519 B9 C6 84 LDA.W BlurpSpeedX,Y ; |
$03:851C 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = BlurpSpeedX[direction]
$03:851E 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed (no gravity)
$03:8522 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:8526 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Sprite-sprite and Mario-sprite interaction
$03:852A 60 RTS ; Return
;;; $852B: Table: Porcu-Puffer X acceleration (PorcuPuffAccel) ;;;
$03:852B .db $01,$FF ; X acceleration by direction: +1 (right), -1 (left)
;;; $852D: Table: Porcu-Puffer max X speed (PorcuPuffMaxSpeed) ;;;
$03:852D .db $10,$F0 ; Max X speed by direction: $10 (right), $F0 (left)
;;; $852F: Porcu-Puffer main routine (PorcuPuffer) ;;;
;; Faces Mario and accelerates toward him (+/-1 every 4th frame, max $10). X speed is temporarily boosted by
;; [$17BD] * 8 for movement.
;; Y speed is 4 (sinks) out of water and $FC (rises) in water.
;; Called by:
;; $03:A17B: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:852F 20 A3 85 JSR.W $85A3 ; Draw the sprite ($85A3)
$03:8532 A5 9D LDA RAM_SpritesLocked ; \
$03:8534 D0 50 BNE $8586 ; / Sprites locked: return
$03:8536 BD C8 14 LDA.W $14C8,X ; \
$03:8539 C9 08 CMP.B #$08 ; |
$03:853B D0 49 BNE $8586 ; / Status not 8 (normal): return
$03:853D 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when far off-screen
$03:8540 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Sprite-sprite and Mario-sprite interaction
$03:8544 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:8547 98 TYA ; |
$03:8548 9D 7C 15 STA.W RAM_SpriteDir,X ; / Face Mario: [$157C] = 1 if Mario is to the left, else 0
$03:854B A5 14 LDA RAM_FrameCounterB ; \
$03:854D 29 03 AND.B #$03 ; |
$03:854F D0 0D BNE $855E ; / Not every 4th frame: skip the X acceleration
$03:8551 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:8553 D9 2D 85 CMP.W PorcuPuffMaxSpeed,Y ; |
$03:8556 F0 06 BEQ $855E ; / X speed already at the max for this direction: skip
$03:8558 18 CLC ; \
$03:8559 79 2B 85 ADC.W PorcuPuffAccel,Y ; |
$03:855C 95 B6 STA RAM_SpriteSpeedX,X ; / X speed += PorcuPuffAccel[direction]
$03:855E B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:8560 48 PHA ; / Save the X speed
$03:8561 AD BD 17 LDA.W $17BD ; \
$03:8564 0A ASL ; |
$03:8565 0A ASL ; |
$03:8566 0A ASL ; |
$03:8567 18 CLC ; |
$03:8568 75 B6 ADC RAM_SpriteSpeedX,X ; |
$03:856A 95 B6 STA RAM_SpriteSpeedX,X ; / Temporary X speed += [$17BD] * 8 (probably compensates screen scroll)
$03:856C 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed (no gravity)
$03:8570 68 PLA ; \
$03:8571 95 B6 STA RAM_SpriteSpeedX,X ; / Restore the saved X speed
$03:8573 22 38 91 01 JSL.L $9138 ; Sprite-block interaction; also sets in-water flag [$164A]
$03:8577 A0 04 LDY.B #$04 ; Y = 4: Y speed when not in water (sinks)
$03:8579 BD 4A 16 LDA.W $164A,X ; \
$03:857C F0 02 BEQ $8580 ; / Not in water: keep Y = 4
$03:857E A0 FC LDY.B #$FC ; Y = $FC: Y speed in water (rises)
$03:8580 94 AA STY RAM_SpriteSpeedY,X ; Store Y speed
$03:8582 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:8586 60 RTS ; Return
;;; $8587: Table: Porcu-Puffer tile X offsets (PocruPufferDispX) ;;;
$03:8587 .db $F8,$08,$F8,$08,$08,$F8,$08,$F8 ; X offsets of the 4 tiles: left-facing layout, then mirrored layout
;;; $858F: Table: Porcu-Puffer tile Y offsets (PocruPufferDispY) ;;;
$03:858F .db $F8,$F8,$08,$08 ; Y offsets of the 4 tiles: top row $F8, bottom row $08
;;; $8593: Table: Porcu-Puffer tiles (PocruPufferTiles) ;;;
$03:8593 .db $86,$C0,$A6,$C2,$86,$C0,$A6,$8A ; Tiles: animation frame 0 (4 tiles), animation frame 1 (4 tiles)
;;; $859B: Porcu-Puffer graphics routine (PocruPufferGfxProp) ;;;
;; Property table, then $85A3: draws four 16x16 tiles in a 2x2 layout; tile set swaps every 4 frames,
;; layout mirrored by direction.
$03:859B .db $0D,$0D,$0D,$0D,$4D,$4D,$4D,$4D ; OAM properties: $0D (no flip) / $4D (X flip)
$03:85A3 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:85A6 A5 14 LDA RAM_FrameCounterB ; \
$03:85A8 29 04 AND.B #$04 ; |
$03:85AA 85 03 STA $03 ; / [$03] = [$14] & 4: animation frame offset (0 or 4), changes every 4 frames
$03:85AC BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:85AF 85 02 STA $02 ; / [$02] = sprite direction
$03:85B1 DA PHX ; Save the sprite index
$03:85B2 A2 03 LDX.B #$03 ; X = 3: tile loop counter
$03:85B4 A5 01 LDA $01 ; \
$03:85B6 18 CLC ; |
$03:85B7 7D 8F 85 ADC.W PocruPufferDispY,X ; |
$03:85BA 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = [$01] + PocruPufferDispY[X]
$03:85BD DA PHX ; Save the loop counter
$03:85BE A5 02 LDA $02 ; \
$03:85C0 D0 04 BNE $85C6 ; / Direction non-zero: use X as is
$03:85C2 8A TXA ; \
$03:85C3 09 04 ORA.B #$04 ; |
$03:85C5 AA TAX ; / Direction 0: X |= 4 (mirrored half of the tables)
$03:85C6 A5 00 LDA $00 ; \
$03:85C8 18 CLC ; |
$03:85C9 7D 87 85 ADC.W PocruPufferDispX,X ; |
$03:85CC 99 00 03 STA.W OAM_DispX,Y ; / OAM X = [$00] + PocruPufferDispX[X]
$03:85CF BD 9B 85 LDA.W PocruPufferGfxProp,X ; \
$03:85D2 05 64 ORA $64 ; |
$03:85D4 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = PocruPufferGfxProp[X] | [$64]
$03:85D7 68 PLA ; \
$03:85D8 48 PHA ; / X = loop counter (kept on the stack)
$03:85D9 05 03 ORA $03 ; \
$03:85DB AA TAX ; / X = loop counter | [$03]: tile table index
$03:85DC BD 93 85 LDA.W PocruPufferTiles,X ; \
$03:85DF 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = PocruPufferTiles[X]
$03:85E2 FA PLX ; X = loop counter
$03:85E3 C8 INY ; \
$03:85E4 C8 INY ; |
$03:85E5 C8 INY ; |
$03:85E6 C8 INY ; / Y += 4: next OAM slot
$03:85E7 CA DEX ; X--
$03:85E8 10 CA BPL $85B4 ; Loop for all 4 tiles
$03:85EA FA PLX ; Restore the sprite index
$03:85EB A0 02 LDY.B #$02 ; Y = 2: the tiles are 16x16
$03:85ED A9 03 LDA.B #$03 ; A = 3: 4 tiles written
$03:85EF 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish the OAM write (FinishOAMWrite)
$03:85F3 60 RTS ; Return
;;; $85F4: Table: flying turnblocks Y speed (FlyingBlockSpeedY) ;;;
$03:85F4 .db $08,$F8 ; Y speed by direction: +8, -8
;;; $85F6: Flying grey turnblocks main routine (FlyingTurnBlocks) ;;;
;; Platform that starts moving right at X speed 8 (flag [$1B9A] = 8) once Mario stands on it, bobbing up and
;; down;
;; [$1602] is used as the direction switch timer (not a graphics frame). Also starts the first other $C1
;; sprite found in slots 0-9.
;; Called by:
;; $03:A184: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:85F6 20 A8 86 JSR.W $86A8 ; Draw the sprite ($86A8)
$03:85F9 A5 9D LDA RAM_SpritesLocked ; \
$03:85FB D0 78 BNE $8675 ; / Sprites locked: return
$03:85FD AD 9A 1B LDA.W $1B9A ; \
$03:8600 F0 27 BEQ $8629 ; / [$1B9A] = 0 (scroll not started): go to 038629
$03:8602 BD 34 15 LDA.W $1534,X ; A = [$1534]
$03:8605 FE 34 15 INC.W $1534,X ; [$1534]++
$03:8608 29 01 AND.B #$01 ; \
$03:860A D0 12 BNE $861E ; / Old [$1534] was odd: skip the direction timer
$03:860C DE 02 16 DEC.W $1602,X ; [$1602]--: direction switch timer
$03:860F BD 02 16 LDA.W $1602,X ; \
$03:8612 C9 FF CMP.B #$FF ; |
$03:8614 D0 08 BNE $861E ; / Timer != $FF (not underflowed): skip
$03:8616 A9 FF LDA.B #$FF ; \
$03:8618 9D 02 16 STA.W $1602,X ; |
$03:861B FE 7C 15 INC.W RAM_SpriteDir,X ; / [$1602] = $FF; [$157C]++: swap the direction
$03:861E BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8621 29 01 AND.B #$01 ; |
$03:8623 A8 TAY ; / Y = [$157C] & 1
$03:8624 B9 F4 85 LDA.W FlyingBlockSpeedY,Y ; \
$03:8627 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = FlyingBlockSpeedY[Y]
$03:8629 B5 AA LDA RAM_SpriteSpeedY,X ; A = Y speed
$03:862B 48 PHA ; Save the Y speed
$03:862C BC 1C 15 LDY.W $151C,X ; \
$03:862F D0 05 BNE $8636 ; / [$151C] non-zero: use the speed as is
$03:8631 49 FF EOR.B #$FF ; \
$03:8633 1A INC A ; |
$03:8634 95 AA STA RAM_SpriteSpeedY,X ; / Else Y speed = -[Y speed]
$03:8636 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:863A 68 PLA ; \
$03:863B 95 AA STA RAM_SpriteSpeedY,X ; / Restore the saved Y speed
$03:863D AD 9A 1B LDA.W $1B9A ; \
$03:8640 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = [$1B9A] ($08 once the scroll has started, else 0)
$03:8642 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed (no gravity)
$03:8646 9D 28 15 STA.W $1528,X ; Store A in [$1528] (never read by this sprite)
$03:8649 22 4F B4 01 JSL.L InvisBlkMainRt ; Make the platform solid (InvisBlkMainRt); carry set if Mario stands on it
$03:864D 90 26 BCC $8675 ; Mario not on it: return
$03:864F AD 9A 1B LDA.W $1B9A ; \
$03:8652 D0 21 BNE $8675 ; / [$1B9A] already set: return
$03:8654 A9 08 LDA.B #$08 ; \
$03:8656 8D 9A 1B STA.W $1B9A ; / [$1B9A] = 8: start the movement
$03:8659 A9 7F LDA.B #$7F ; \
$03:865B 9D 02 16 STA.W $1602,X ; / [$1602] = $7F: direction switch timer
$03:865E A0 09 LDY.B #$09 ; Y = 9: search sprite slots 9 to 0
$03:8660 CC E9 15 CPY.W $15E9 ; \
$03:8663 F0 07 BEQ $866C ; / This sprite itself: skip
$03:8665 B9 9E 00 LDA.W RAM_SpriteNum,Y ; \
$03:8668 C9 C1 CMP.B #$C1 ; |
$03:866A F0 04 BEQ $8670 ; / Sprite number $C1 (flying turnblocks) found: go set its timer
$03:866C 88 DEY ; \
$03:866D 10 F1 BPL $8660 ; / Next slot; loop
$03:866F C8 INY ; None found: Y wraps to 0 (so slot 0 is written)
$03:8670 A9 7F LDA.B #$7F ; \
$03:8672 99 02 16 STA.W $1602,Y ; / [$1602,Y] = $7F: sync the other block's direction timer
$03:8675 60 RTS ; Return
;;; $8676: Table: flying turnblocks tile X offsets (ForestPlatDispX) ;;;
;; 2 frames x 5 tiles (3 blocks + 2 wings).
$03:8676 .db $00,$10,$20,$F2,$2E,$00,$10,$20 ; Entries 0-7: blocks 0, $10, $20, wings $F2, $2E; then blocks again, wing $FA
$03:867E .db $FA,$2E ; Entries 8-9: wing X offsets of the second frame
;;; $8680: Table: flying turnblocks tile Y offsets (ForestPlatDispY) ;;;
$03:8680 .db $00,$00,$00,$F6,$F6,$00,$00,$00 ; Y offsets: blocks 0; wings $F6; then the same with wing at $FE
$03:8688 .db $FE,$FE ; Entries 8-9: wing Y offsets of the second frame
;;; $868A: Table: flying turnblocks tiles (ForestPlatTiles) ;;;
$03:868A .db $40,$40,$40,$C6,$C6,$40,$40,$40 ; Tiles: $40 x3 (blocks), $C6 x2 (wings up); then $5D x2 (wings down)
$03:8692 .db $5D,$5D ; Entries 8-9: wing tiles of the second frame
;;; $8694: Table: flying turnblocks properties (ForestPlatGfxProp) ;;;
$03:8694 .db $32,$32,$32,$72,$32,$32,$32,$32 ; OAM properties: $32 blocks, $72 left wing (X flip), $32 right wing; two frames
$03:869C .db $72,$32 ; Entries 8-9: wing properties of the second frame
;;; $869E: Flying turn blocks graphics routine (ForestPlatTileSize) ;;;
;; Table: OAM size bits for the five tiles (2 = 16x16). Then the draw routine (called from FlyingTurnBlocks):
;; draws 5 tiles from the
;; ForestPlat* tables; [$14] bit 3 picks the table half (wing animation). Tiles written with varying sizes (Y
;; = $FF), A = 4 for FinishOAMWrite.
$03:869E .db $02,$02,$02,$02,$02,$02,$02,$02 ; Tile sizes: $02 (16x16) for tiles 0-7
$03:86A6 .db $00,$00 ; Tiles 8-9: size 0 (8x8, unused)
$03:86A8 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get sprite draw position ($00 = X, $01 = Y)
$03:86AB BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index of this sprite
$03:86AE A5 14 LDA RAM_FrameCounterB ; \
$03:86B0 4A LSR ; |
$03:86B1 29 04 AND.B #$04 ; |
$03:86B3 F0 01 BEQ $86B6 ; |
$03:86B5 1A INC A ; |
$03:86B6 85 02 STA $02 ; / [$02] = 0 or 5: wing frame from [$14] bit 3
$03:86B8 DA PHX ; Save sprite index
$03:86B9 A2 04 LDX.B #$04 ; \
$03:86BB 86 06 STX $06 ; / Loop counter [$06] = 4 (five tiles)
$03:86BD 8A TXA ; \
$03:86BE 18 CLC ; |
$03:86BF 65 02 ADC $02 ; |
$03:86C1 AA TAX ; / X = loop counter + [$02]: table index
$03:86C2 A5 00 LDA $00 ; \
$03:86C4 18 CLC ; |
$03:86C5 7D 76 86 ADC.W ForestPlatDispX,X ; |
$03:86C8 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite X + ForestPlatDispX[X]
$03:86CB A5 01 LDA $01 ; \
$03:86CD 18 CLC ; |
$03:86CE 7D 80 86 ADC.W ForestPlatDispY,X ; |
$03:86D1 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite Y + ForestPlatDispY[X]
$03:86D4 BD 8A 86 LDA.W ForestPlatTiles,X ; \
$03:86D7 99 02 03 STA.W OAM_Tile,Y ; / OAM tile number from ForestPlatTiles
$03:86DA BD 94 86 LDA.W ForestPlatGfxProp,X ; \
$03:86DD 99 03 03 STA.W OAM_Prop,Y ; / OAM properties from ForestPlatGfxProp
$03:86E0 5A PHY ; \
$03:86E1 98 TYA ; |
$03:86E2 4A LSR ; |
$03:86E3 4A LSR ; |
$03:86E4 A8 TAY ; / Y = OAM index / 4 (size table index)
$03:86E5 BD 9E 86 LDA.W ForestPlatTileSize,X ; \
$03:86E8 99 60 04 STA.W OAM_TileSize,Y ; / OAM size bits from ForestPlatTileSize
$03:86EB 7A PLY ; Restore OAM index
$03:86EC C8 INY ; \
$03:86ED C8 INY ; |
$03:86EE C8 INY ; |
$03:86EF C8 INY ; / OAM index += 4
$03:86F0 A6 06 LDX $06 ; \
$03:86F2 CA DEX ; |
$03:86F3 10 C6 BPL $86BB ; / Next tile unless all five are drawn
$03:86F5 FA PLX ; Restore sprite index
$03:86F6 A0 FF LDY.B #$FF ; Sizes are stored individually (no common size)
$03:86F8 A9 04 LDA.B #$04 ; Tiles drawn - 1 = 4
$03:86FA 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write (offscreen culling)
$03:86FE 60 RTS ; Return
;;; $86FF: Gray lava platform main (GrayLavaPlatform) ;;;
;; Draws, then handles the platform: Mario can stand on it; standing on it starts a $40-frame sink timer
;; ($1540) with Y speed 6.
;; When the timer reaches 1 the sprite is removed and its load status reset so it respawns from level data.
;; Called by:
;; $03:A18D: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:86FF 20 3A 87 JSR.W $873A ; Draw the platform ($873A)
$03:8702 A5 9D LDA RAM_SpritesLocked ; \
$03:8704 D0 2D BNE $8733 ; / Return if sprites locked
$03:8706 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Handle offscreen despawn
$03:8709 BD 40 15 LDA.W $1540,X ; \
$03:870C 3A DEC A ; |
$03:870D D0 0C BNE $871B ; / Branch unless the sink timer [$1540] equals 1
$03:870F BC 1A 16 LDY.W RAM_SprIndexInLvl,X ; \
$03:8712 A9 00 LDA.B #$00 ; |
$03:8714 99 38 19 STA.W RAM_SprLoadStatus,Y ; |
$03:8717 9E C8 14 STZ.W $14C8,X ; / Clear load status so the platform respawns; remove sprite
$03:871A 60 RTS ; Return
$03:871B 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically (no gravity)
$03:871F 22 4F B4 01 JSL.L InvisBlkMainRt ; Solid on top for Mario (like an invisible block)
$03:8723 90 0E BCC $8733 ; Return if Mario is not standing on it
$03:8725 BD 40 15 LDA.W $1540,X ; \
$03:8728 D0 09 BNE $8733 ; / Return if the sink timer is already running
$03:872A A9 06 LDA.B #$06 ; \
$03:872C 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = 6 (sink)
$03:872E A9 40 LDA.B #$40 ; \
$03:8730 9D 40 15 STA.W $1540,X ; / Sink timer = $40 frames
$03:8733 60 RTS ; Return
;;; $8734: Gray lava platform graphics (LavaPlatTiles) ;;;
;; Tables: tile numbers and properties for the three 16x16 tiles, then the draw routine that places them 16
;; pixels apart.
$03:8734 .db $85,$86,$85 ; Tiles: $85,$86,$85 (left, middle, right)
$03:8737 .db $43,$03,$03 ; Properties: $43,$03,$03 (right tile X-flipped)
$03:873A 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get sprite draw position ($00 = X, $01 = Y)
$03:873D DA PHX ; Save sprite index
$03:873E A2 02 LDX.B #$02 ; Loop counter = 2 (three tiles)
$03:8740 A5 00 LDA $00 ; \
$03:8742 99 00 03 STA.W OAM_DispX,Y ; / OAM X = current X
$03:8745 18 CLC ; \
$03:8746 69 10 ADC.B #$10 ; |
$03:8748 85 00 STA $00 ; / Next tile X += $10
$03:874A A5 01 LDA $01 ; \
$03:874C 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite Y
$03:874F BD 34 87 LDA.W LavaPlatTiles,X ; \
$03:8752 99 02 03 STA.W OAM_Tile,Y ; / OAM tile number from LavaPlatTiles
$03:8755 BD 37 87 LDA.W $8737,X ; \
$03:8758 05 64 ORA $64 ; |
$03:875A 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = table | level priority [$64]
$03:875D C8 INY ; \
$03:875E C8 INY ; |
$03:875F C8 INY ; |
$03:8760 C8 INY ; / OAM index += 4
$03:8761 CA DEX ; \
$03:8762 10 DC BPL $8740 ; / Next tile
$03:8764 FA PLX ; Restore sprite index
$03:8765 A0 02 LDY.B #$02 ; All 16x16
$03:8767 A9 02 LDA.B #$02 ; Three tiles drawn - 1 = 2
$03:8769 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:876D 60 RTS ; Return
;;; $876E: Table: Mega Mole X speed by direction (MegaMoleSpeed) ;;;
$03:876E .db $10,$F0 ; $10 - walking right, $F0 - walking left
;;; $8770: Mega Mole main (MegaMole) ;;;
;; Draws, then (if status 8 and sprites not locked) walks left/right at $10/$F0, updates position and sprite
;; contacts.
;; Remembers whether it was on the ground this frame ($0A frame grace timer in $1540 after leaving the
;; ground).
;; Called by:
;; $03:A196: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8770 20 3F 88 JSR.W MegaMoleGfxRt ; Draw Mega Mole
$03:8773 BD C8 14 LDA.W $14C8,X ; \
$03:8776 C9 08 CMP.B #$08 ; |
$03:8778 D0 B9 BNE $8733 ; / Return unless status is 8 (normal)
$03:877A 20 4F B8 JSR.W SubOffscreen3Bnk3 ; Handle offscreen despawn
$03:877D BC 7C 15 LDY.W RAM_SpriteDir,X ; \
$03:8780 B9 6E 87 LDA.W MegaMoleSpeed,Y ; |
$03:8783 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = MegaMoleSpeed[direction]
$03:8785 A5 9D LDA RAM_SpritesLocked ; \
$03:8787 D0 AA BNE $8733 ; / Return if sprites locked
$03:8789 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:878C 29 04 AND.B #$04 ; |
$03:878E 48 PHA ; / Save the on-ground flag from last frame
$03:878F 22 2A 80 01 JSL.L UpdateSpritePos ; Update position from speeds
$03:8793 22 32 80 01 JSL.L SprSprInteract ; Interact with other sprites
$03:8797 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:879A 29 04 AND.B #$04 ; |
$03:879C F0 05 BEQ MegaMoleInAir ; / Branch if not on ground now
$03:879E 74 AA STZ RAM_SpriteSpeedY,X ; On ground: Y speed = 0
$03:87A0 68 PLA ; Pop saved flag
$03:87A1 80 0F BRA MegaMoleOnGround ; Skip the ledge timer logic
;;; $87A3: Mega Mole: airborne this frame (MegaMoleInAir) ;;;
;; Pops the saved on-ground bit; if it was on the ground last frame, starts the $0A-frame timer in $1540.
$03:87A3 68 PLA ; Pop last frame's on-ground flag
$03:87A4 F0 05 BEQ MegaMoleWasInAir ; Was on ground last frame: start ledge timer
$03:87A6 A9 0A LDA.B #$0A ; \
$03:87A8 9D 40 15 STA.W $1540,X ; / [$1540] = $0A
;;; $87AB: Mega Mole: ledge grace timer (MegaMoleWasInAir) ;;;
;; While the $1540 timer runs, Y speed is held at 0 so it walks off ledges smoothly.
$03:87AB BD 40 15 LDA.W $1540,X ; \
$03:87AE F0 02 BEQ MegaMoleOnGround ; / While the ledge timer is running...
$03:87B0 74 AA STZ RAM_SpriteSpeedY,X ; Keep Y speed 0 (hover briefly off ledges)
;;; $87B2: Mega Mole: turn at walls, Mario contact (MegaMoleOnGround) ;;;
;; Turns around on wall contact (with a $10-frame turn timer $15AC for the graphics direction $151C).
;; Mario touching it from above (not too high, falling) lets Mario ride on it; touching from the side hurts
;; Mario.
$03:87B2 BC AC 15 LDY.W $15AC,X ; Y = turn timer [$15AC]
$03:87B5 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:87B8 29 03 AND.B #$03 ; |
$03:87BA F0 11 BEQ $87CD ; / Branch if not touching a wall (bits 0-1)
$03:87BC C0 00 CPY.B #$00 ; \
$03:87BE D0 05 BNE $87C5 ; / Skip if a turn timer is already running
$03:87C0 A9 10 LDA.B #$10 ; \
$03:87C2 9D AC 15 STA.W $15AC,X ; / Turn timer = $10 frames
$03:87C5 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:87C8 49 01 EOR.B #$01 ; |
$03:87CA 9D 7C 15 STA.W RAM_SpriteDir,X ; / Flip walking direction
$03:87CD C0 00 CPY.B #$00 ; \
$03:87CF D0 06 BNE $87D7 ; / Turn timer != 0: keep the old graphics direction
$03:87D1 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:87D4 9D 1C 15 STA.W $151C,X ; / Graphics direction [$151C] = walking direction
$03:87D7 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario contact
$03:87DB 90 4D BCC $882A ; Return if no contact
$03:87DD 20 29 B8 JSR.W SubVertPosBnk3 ; Mario Y position relative to sprite into [$0E]
$03:87E0 A5 0E LDA $0E ; \
$03:87E2 C9 D8 CMP.B #$D8 ; |
$03:87E4 10 38 BPL MegaMoleContact ; / Mario not above the head: side hit
$03:87E6 A5 7D LDA RAM_MarioSpeedY ; \
$03:87E8 30 40 BMI $882A ; / Return if Mario is moving up
$03:87EA A9 01 LDA.B #$01 ; \
$03:87EC 8D 71 14 STA.W $1471 ; / [$1471] = 1: Mario is standing on a sprite
$03:87EF A9 06 LDA.B #$06 ; \
$03:87F1 9D 4C 15 STA.W RAM_DisableInter,X ; / Riding flag [$154C] = 6 (no interaction)
$03:87F4 64 7D STZ RAM_MarioSpeedY ; Mario Y speed = 0
$03:87F6 A9 D6 LDA.B #$D6 ; \
$03:87F8 AC 7A 18 LDY.W RAM_OnYoshi ; |
$03:87FB F0 02 BEQ MegaMoleNoYoshi ; |
$03:87FD A9 C6 LDA.B #$C6 ; / A = $D6, or $C6 if Mario is on Yoshi
;;; $87FF: Mega Mole: carry Mario (MegaMoleNoYoshi) ;;;
;; Puts Mario on top of the Mega Mole (Y offset differs with Yoshi) and moves him horizontally by [$1491]
;; (+1/-1).
$03:87FF 18 CLC ; \
$03:8800 75 D8 ADC RAM_SpriteYLo,X ; |
$03:8802 85 96 STA RAM_MarioYPos ; |
$03:8804 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:8807 69 FF ADC.B #$FF ; |
$03:8809 85 97 STA RAM_MarioYPosHi ; / Mario Y = sprite Y + A (16-bit)
$03:880B A0 00 LDY.B #$00 ; \
$03:880D AD 91 14 LDA.W $1491 ; |
$03:8810 10 01 BPL $8813 ; |
$03:8812 88 DEY ; |
$03:8813 18 CLC ; |
$03:8814 65 94 ADC RAM_MarioXPos ; |
$03:8816 85 94 STA RAM_MarioXPos ; |
$03:8818 98 TYA ; |
$03:8819 65 95 ADC RAM_MarioXPosHi ; |
$03:881B 85 95 STA RAM_MarioXPosHi ; / Mario X += [$1491] (+1 or -1, platform movement)
$03:881D 60 RTS ; Return
;;; $881E: Mega Mole: hurt Mario on side contact (MegaMoleContact) ;;;
;; Hurts Mario unless he is riding it, or it is being eaten by Yoshi.
$03:881E BD 4C 15 LDA.W RAM_DisableInter,X ; \
$03:8821 1D D0 15 ORA.W $15D0,X ; |
$03:8824 D0 04 BNE $882A ; / Return if riding it or it is being eaten
$03:8826 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
$03:882A 60 RTS ; Return
;;; $882B: Table: Mega Mole tile X offsets (MegaMoleTileDispX) ;;;
;; 8 entries: 4 tiles for facing left, then 4 for facing right.
$03:882B .db $00,$10,$00,$10,$10,$00,$10,$00 ; X offsets: left-facing $00,$10,$00,$10; right-facing $10,$00,$10,$00
;;; $8833: Table: Mega Mole tile Y offsets (MegaMoleTileDispY) ;;;
$03:8833 .db $F0,$F0,$00,$00 ; Y offsets: $F0,$F0,$00,$00 (top row, bottom row)
;;; $8837: Table: Mega Mole tile numbers (MegaMoleTiles) ;;;
;; Two animation frames of four 16x16 tiles each, per direction.
$03:8837 .db $C6,$C8,$E6,$E8,$CA,$CC,$EA,$EC ; Tiles: $C6,$C8,$E6,$E8 / $CA,$CC,$EA,$EC (two frames)
;;; $883F: Mega Mole graphics routine (MegaMoleGfxRt) ;;;
;; Draws four 16x16 tiles (2x2). Animation frame from [$14] and the sprite's slot index; flips horizontally
;; when facing right.
;; Called by:
;; $03:8770: Mega Mole main (MegaMole)
$03:883F 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get sprite draw position ($00 = X, $01 = Y)
$03:8842 BD 1C 15 LDA.W $151C,X ; \
$03:8845 85 02 STA $02 ; / [$02] = graphics direction
$03:8847 A5 14 LDA RAM_FrameCounterB ; \
$03:8849 4A LSR ; |
$03:884A 4A LSR ; |
$03:884B EA NOP ; |
$03:884C 18 CLC ; |
$03:884D 6D E9 15 ADC.W $15E9 ; |
$03:8850 29 01 AND.B #$01 ; |
$03:8852 0A ASL ; |
$03:8853 0A ASL ; |
$03:8854 85 03 STA $03 ; } [$03] = 0 or 4: animation frame (changes every 4 frames, per sprite)
$03:8856 DA PHX ; /
$03:8857 A2 03 LDX.B #$03 ; Loop counter = 3 (four tiles)
;;; $8859: Mega Mole: draw tile loop (MegaMoleGfxLoopSt) ;;;
$03:8859 DA PHX ; Save loop counter
$03:885A A5 02 LDA $02 ; \
$03:885C D0 04 BNE MegaMoleFaceLeft ; / Facing right (dir 0): use the second half of the tables
$03:885E E8 INX ; \
$03:885F E8 INX ; |
$03:8860 E8 INX ; |
$03:8861 E8 INX ; / X += 4
;;; $8862: Mega Mole: place one tile (MegaMoleFaceLeft) ;;;
$03:8862 A5 00 LDA $00 ; \
$03:8864 18 CLC ; |
$03:8865 7D 2B 88 ADC.W MegaMoleTileDispX,X ; |
$03:8868 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite X + MegaMoleTileDispX[X]
$03:886B FA PLX ; \
$03:886C A5 01 LDA $01 ; |
$03:886E 18 CLC ; |
$03:886F 7D 33 88 ADC.W MegaMoleTileDispY,X ; |
$03:8872 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite Y + MegaMoleTileDispY[X]
$03:8875 DA PHX ; Save index
$03:8876 8A TXA ; \
$03:8877 18 CLC ; |
$03:8878 65 03 ADC $03 ; |
$03:887A AA TAX ; / X = tile index + frame offset
$03:887B BD 37 88 LDA.W MegaMoleTiles,X ; \
$03:887E 99 02 03 STA.W OAM_Tile,Y ; / OAM tile number from MegaMoleTiles
$03:8881 A9 01 LDA.B #$01 ; Properties: palette 0, page 1
$03:8883 A6 02 LDX $02 ; \
$03:8885 D0 02 BNE MegaMoleGfxNoFlip ; |
$03:8887 09 40 ORA.B #$40 ; / X-flip when direction is 0
;;; $8889: Mega Mole: tile properties (MegaMoleGfxNoFlip) ;;;
$03:8889 05 64 ORA $64 ; Add level priority [$64]
$03:888B 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:888E FA PLX ; Restore loop counter
$03:888F C8 INY ; \
$03:8890 C8 INY ; |
$03:8891 C8 INY ; |
$03:8892 C8 INY ; / OAM index += 4
$03:8893 CA DEX ; \
$03:8894 10 C3 BPL MegaMoleGfxLoopSt ; / Next tile
$03:8896 FA PLX ; Restore sprite index
$03:8897 A0 02 LDY.B #$02 ; All 16x16
$03:8899 A9 03 LDA.B #$03 ; Four tiles - 1 = 3
$03:889B 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:889F 60 RTS ; Return
;;; $88A0: Table: Swooper tile numbers (BatTiles) ;;;
;; Tile per graphics frame ($1602): 0 = hanging, 1-2 = wings up/down.
$03:88A0 .db $AE,$C0,$E8 ; Hanging, wings up, wings down
;;; $88A3: Swooper bat main (Swooper) ;;;
;; Uses GenericSprGfxRt2, replaces the tile by frame. If not status 8 falls to the upside-down death drawing.
;; Otherwise processes sprite interaction, moves, and runs a state machine: 0 = waiting, 1 = swooping down, 2
;; = flying horizontally.
;; Called by:
;; $03:A19F: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:88A3 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw generic sprite
$03:88A7 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:88AA DA PHX ; \
$03:88AB BD 02 16 LDA.W $1602,X ; |
$03:88AE AA TAX ; |
$03:88AF BD A0 88 LDA.W BatTiles,X ; |
$03:88B2 99 02 03 STA.W OAM_Tile,Y ; |
$03:88B5 FA PLX ; / OAM tile = BatTiles[graphics frame $1602]
$03:88B6 BD C8 14 LDA.W $14C8,X ; \
$03:88B9 C9 08 CMP.B #$08 ; |
$03:88BB F0 03 BEQ $88C0 ; / Status 8: run main code
$03:88BD 4C EC 84 JMP.W $84EC ; Otherwise: draw as dead (upside down)
$03:88C0 A5 9D LDA RAM_SpritesLocked ; \
$03:88C2 D0 1B BNE $88DF ; / Return if sprites locked
$03:88C4 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Handle offscreen despawn
$03:88C7 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Sprite and Mario interaction
$03:88CB 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Update X position
$03:88CF 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Update Y position
$03:88D3 B5 C2 LDA RAM_SpriteState,X ; \
$03:88D5 22 DF 86 00 JSL.L ExecutePtr ; / Run state routine from SwooperPtrs
;;; $88D9: Pointer table: Swooper states (SwooperPtrs) ;;;
$03:88D9 E4 88 .dw $88E4 ; State 0: waiting
$03:88DB 05 89 .dw $8905 ; State 1: swooping down
$03:88DD 36 89 .dw $8936 ; State 2: flying horizontally
$03:88DF 60 RTS ; Return
;;; $88E0..88E2: Table: Swooper X speed limits and acceleration ;;;
;; Max X speed $10/$F0 and acceleration +1/-1, indexed by direction.
$03:88E0 .db $10,$F0 ; Max X speed: $10 right, $F0 left
$03:88E2 .db $01,$FF ; X acceleration: +1, -1
;;; $88E4: Swooper state routines ;;;
;; $0388E4: waiting; wakes when Mario is within $50 pixels horizontally.
;; $038905: swooping down; Y speed decays, X accelerates toward Mario's side.
;; $038936: flying horizontally with bobbing Y speed (Blurp tables).
$03:88E4 BD A0 15 LDA.W RAM_OffscreenHorz,X ; \
$03:88E7 D0 1B BNE $8904 ; / Return if offscreen horizontally
$03:88E9 20 17 B8 JSR.W SubHorzPosBnk3 ; Mario horizontal distance in [$0F], Y = side
$03:88EC A5 0F LDA $0F ; \
$03:88EE 18 CLC ; |
$03:88EF 69 50 ADC.B #$50 ; |
$03:88F1 C9 A0 CMP.B #$A0 ; |
$03:88F3 B0 0F BCS $8904 ; / Return if Mario is more than $50 pixels away
$03:88F5 F6 C2 INC RAM_SpriteState,X ; State = 1 (swooping down)
$03:88F7 98 TYA ; \
$03:88F8 9D 7C 15 STA.W RAM_SpriteDir,X ; / Face Mario
$03:88FB A9 20 LDA.B #$20 ; \
$03:88FD 95 AA STA RAM_SpriteSpeedY,X ; / Initial Y speed = $20 (down)
$03:88FF A9 26 LDA.B #$26 ; \
$03:8901 8D FC 1D STA.W $1DFC ; / Play swoop sound effect
$03:8904 60 RTS ; Return
$03:8905 A5 13 LDA RAM_FrameCounter ; \
$03:8907 29 03 AND.B #$03 ; |
$03:8909 D0 0A BNE $8915 ; / Skip Y speed decay 3 of 4 frames
$03:890B B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:890D F0 06 BEQ $8915 ; / Skip if Y speed is already 0
$03:890F D6 AA DEC RAM_SpriteSpeedY,X ; Y speed decays toward 0
$03:8911 D0 02 BNE $8915 ; Still moving: keep state
$03:8913 F6 C2 INC RAM_SpriteState,X ; Y speed reached 0: state = 2 (flying horizontally)
$03:8915 A5 13 LDA RAM_FrameCounter ; \
$03:8917 29 03 AND.B #$03 ; |
$03:8919 D0 10 BNE $892B ; / Skip X acceleration 3 of 4 frames
$03:891B BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = direction
$03:891E B5 B6 LDA RAM_SpriteSpeedX,X ; A = X speed
$03:8920 D9 E0 88 CMP.W $88E0,Y ; \
$03:8923 F0 06 BEQ $892B ; / Skip if X speed is at max
$03:8925 18 CLC ; \
$03:8926 79 E2 88 ADC.W $88E2,Y ; |
$03:8929 95 B6 STA RAM_SpriteSpeedX,X ; / X speed += $88E2[direction]
$03:892B A5 14 LDA RAM_FrameCounterB ; \
$03:892D 29 04 AND.B #$04 ; |
$03:892F 4A LSR ; |
$03:8930 4A LSR ; |
$03:8931 1A INC A ; |
$03:8932 9D 02 16 STA.W $1602,X ; / Graphics frame [$1602] = 1 or 2 (flap animation)
$03:8935 60 RTS ; Return
$03:8936 A5 13 LDA RAM_FrameCounter ; \
$03:8938 29 01 AND.B #$01 ; |
$03:893A D0 16 BNE $8952 ; / Only update on even frames
$03:893C BD 1C 15 LDA.W $151C,X ; \
$03:893F 29 01 AND.B #$01 ; |
$03:8941 A8 TAY ; / Y = vertical direction bit ($151C)
$03:8942 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8944 18 CLC ; |
$03:8945 79 C8 84 ADC.W BlurpAccelY,Y ; |
$03:8948 95 AA STA RAM_SpriteSpeedY,X ; / Y speed += BlurpAccelY[Y]
$03:894A D9 C4 84 CMP.W BlurpMaxSpeedY,Y ; \
$03:894D D0 03 BNE $8952 ; / Branch unless Y speed hit the limit BlurpMaxSpeedY[Y]
$03:894F FE 1C 15 INC.W $151C,X ; Reverse vertical direction (bob up and down)
$03:8952 80 C1 BRA $8915 ; Go to X acceleration and animation ($8915)
;;; $8954..8956: Table: Sliding Koopa speed limits and acceleration ;;;
;; Max X speed $20/$E0 and acceleration +2/-2, indexed by direction.
$03:8954 .db $20,$E0 ; Max X speed: $20 right, $E0 left
$03:8956 .db $02,$FE ; X acceleration: +2, -2
;;; $8958: Sliding Koopa (shell-less blue) main (SlidingKoopa) ;;;
;; Faces its movement direction, draws; slides down slopes accelerating, decelerates on flat ground.
;; When it stops, a $20-frame timer ($1558) runs, then it becomes a shell-less blue Koopa (sprite 02). Makes
;; smoke particles while sliding.
;; $0389FF: spawns a smoke image in a free slot ($17C0-$17C3) every 4th frame while moving.
;; Called by:
;; $03:A1A8: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8958 A9 00 LDA.B #$00 ; \
$03:895A B4 B6 LDY RAM_SpriteSpeedX,X ; |
$03:895C F0 06 BEQ $8964 ; |
$03:895E 10 01 BPL $8961 ; |
$03:8960 1A INC A ; |
$03:8961 9D 7C 15 STA.W RAM_SpriteDir,X ; / Direction = 1 if X speed > 0, kept if 0, else 0
$03:8964 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw generic sprite
$03:8968 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:896B BD 58 15 LDA.W $1558,X ; \
$03:896E C9 01 CMP.B #$01 ; |
$03:8970 D0 11 BNE $8983 ; / Branch unless it is time to turn into a Koopa ($1558 = 1)
$03:8972 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8975 48 PHA ; / Save direction
$03:8976 A9 02 LDA.B #$02 ; \
$03:8978 95 9E STA RAM_SpriteNum,X ; / Sprite number = $02 (shell-less blue Koopa)
$03:897A 22 D2 F7 07 JSL.L InitSpriteTables ; Initialise sprite tables for the new sprite
$03:897E 68 PLA ; \
$03:897F 9D 7C 15 STA.W RAM_SpriteDir,X ; / Restore direction
$03:8982 38 SEC ; Carry set: select the Koopa tile
$03:8983 A9 86 LDA.B #$86 ; \
$03:8985 90 02 BCC $8989 ; / Sliding tile $86 (carry clear)
$03:8987 A9 E0 LDA.B #$E0 ; Shell-less Koopa tile $E0
$03:8989 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:898C BD C8 14 LDA.W $14C8,X ; \
$03:898F C9 08 CMP.B #$08 ; |
$03:8991 D0 6B BNE $89FE ; / Return unless status is 8
$03:8993 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Handle offscreen despawn
$03:8996 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Sprite and Mario interaction
$03:899A A5 9D LDA RAM_SpritesLocked ; \
$03:899C 1D 40 15 ORA.W $1540,X ; |
$03:899F 1D 58 15 ORA.W $1558,X ; |
$03:89A2 D0 5A BNE $89FE ; / Return if locked, INIT timer running or turning into Koopa
$03:89A4 22 2A 80 01 JSL.L UpdateSpritePos ; Update position
$03:89A8 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:89AB 29 04 AND.B #$04 ; |
$03:89AD F0 4F BEQ $89FE ; / Return if not on ground
$03:89AF 20 FF 89 JSR.W $89FF ; Maybe spawn smoke
$03:89B2 A0 00 LDY.B #$00 ; Y = 0 (Y speed default)
$03:89B4 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:89B6 F0 14 BEQ $89CC ; / Y speed 0 if X speed is 0
$03:89B8 10 03 BPL $89BD ; Branch if moving right
$03:89BA 49 FF EOR.B #$FF ; \
$03:89BC 1A INC A ; |
$03:89BD 85 00 STA $00 ; / [$00] = |X speed|
$03:89BF BD B8 15 LDA.W $15B8,X ; \
$03:89C2 F0 08 BEQ $89CC ; / If not on a slope, Y speed 0
$03:89C4 A4 00 LDY $00 ; Y = |X speed| (stick to slope)
$03:89C6 55 B6 EOR RAM_SpriteSpeedX,X ; \
$03:89C8 10 02 BPL $89CC ; / If slope direction matches movement, keep it
$03:89CA A0 D0 LDY.B #$D0 ; Otherwise Y speed = $D0 (up the slope)
$03:89CC 94 AA STY RAM_SpriteSpeedY,X ; Set Y speed
$03:89CE A5 13 LDA RAM_FrameCounter ; \
$03:89D0 29 01 AND.B #$01 ; |
$03:89D2 D0 2A BNE $89FE ; / Return on odd frames
$03:89D4 BD B8 15 LDA.W $15B8,X ; \
$03:89D7 D0 13 BNE $89EC ; / On a slope: accelerate ($89EC)
$03:89D9 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:89DB D0 06 BNE $89E3 ; / Moving: decelerate
$03:89DD A9 20 LDA.B #$20 ; \
$03:89DF 9D 58 15 STA.W $1558,X ; / Stopped: start $20-frame timer to become a Koopa
$03:89E2 60 RTS ; Return
$03:89E3 10 04 BPL $89E9 ; \
$03:89E5 F6 B6 INC RAM_SpriteSpeedX,X ; |
$03:89E7 F6 B6 INC RAM_SpriteSpeedX,X ; |
$03:89E9 D6 B6 DEC RAM_SpriteSpeedX,X ; / Move X speed one step toward 0
$03:89EB 60 RTS ; Return
$03:89EC 0A ASL ; \
$03:89ED 2A ROL ; |
$03:89EE 29 01 AND.B #$01 ; |
$03:89F0 A8 TAY ; / Y = 1 if X speed is negative, else 0
$03:89F1 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:89F3 D9 54 89 CMP.W $8954,Y ; |
$03:89F6 F0 06 BEQ $89FE ; / Skip if at max X speed
$03:89F8 18 CLC ; \
$03:89F9 79 56 89 ADC.W $8956,Y ; |
$03:89FC 95 B6 STA RAM_SpriteSpeedX,X ; / X speed += acceleration
$03:89FE 60 RTS ; Return
$03:89FF B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:8A01 F0 1D BEQ $8A20 ; / Return if not moving
$03:8A03 A5 13 LDA RAM_FrameCounter ; \
$03:8A05 29 03 AND.B #$03 ; |
$03:8A07 D0 17 BNE $8A20 ; / Only every 4th frame
$03:8A09 A9 04 LDA.B #$04 ; \
$03:8A0B 85 00 STA $00 ; |
$03:8A0D A9 0A LDA.B #$0A ; |
$03:8A0F 85 01 STA $01 ; / Smoke offset: X +4, Y +$0A
$03:8A11 20 FB B8 JSR.W IsSprOffScreenBnk3 ; \
$03:8A14 D0 0A BNE $8A20 ; / Return if offscreen
$03:8A16 A0 03 LDY.B #$03 ; Loop over 4 smoke slots
$03:8A18 B9 C0 17 LDA.W $17C0,Y ; \
$03:8A1B F0 04 BEQ $8A21 ; |
$03:8A1D 88 DEY ; |
$03:8A1E 10 F8 BPL $8A18 ; / Find a free smoke slot
$03:8A20 60 RTS ; Return
$03:8A21 A9 03 LDA.B #$03 ; \
$03:8A23 99 C0 17 STA.W $17C0,Y ; / Smoke type 3
$03:8A26 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:8A28 18 CLC ; |
$03:8A29 65 00 ADC $00 ; |
$03:8A2B 99 C8 17 STA.W $17C8,Y ; / Smoke X = sprite X + [$00]
$03:8A2E B5 D8 LDA RAM_SpriteYLo,X ; \
$03:8A30 18 CLC ; |
$03:8A31 65 01 ADC $01 ; |
$03:8A33 99 C4 17 STA.W $17C4,Y ; / Smoke Y = sprite Y + [$01]
$03:8A36 A9 13 LDA.B #$13 ; \
$03:8A38 99 CC 17 STA.W $17CC,Y ; / Smoke lifetime = $13
$03:8A3B 60 RTS ; Return
;;; $8A3C: Bowser statue main (BowserStatue) ;;;
;; Draws, then runs a state routine: 0 sits, 1 and 3 breathe fire, 2 jumps toward Mario. Mario can stand on
;; it.
;; Called by:
;; $03:A1B1: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8A3C 20 3D 8B JSR.W BowserStatueGfx ; Draw the statue
$03:8A3F A5 9D LDA RAM_SpritesLocked ; \
$03:8A41 D0 25 BNE $8A68 ; / Return if sprites locked
$03:8A43 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Handle offscreen despawn
$03:8A46 B5 C2 LDA RAM_SpriteState,X ; \
$03:8A48 22 DF 86 00 JSL.L ExecutePtr ; / Run state routine from BowserStatuePtrs
; list of sprite states
;;; $8A4C: Bowser statue states (BowserStatuePtrs) ;;;
;; $038A54 spawns fire and falls into $038A57, which handles standing, gravity and landing.
;; $038A69: jumping state with wall bounce and a $30-frame wait between jumps.
$03:8A4C 57 8A .dw $8A57 ; State 0: stand still
$03:8A4E 54 8A .dw $8A54 ; State 1: breathe fire
$03:8A50 69 8A .dw $8A69 ; State 2: jump around
$03:8A52 54 8A .dw $8A54 ; State 3: breathe fire
$03:8A54 20 CB 8A JSR.W $8ACB ; Maybe spawn a fireball
$03:8A57 22 4F B4 01 JSL.L InvisBlkMainRt ; Mario can stand on it
$03:8A5B 22 2A 80 01 JSL.L UpdateSpritePos ; Update position
$03:8A5F BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8A62 29 04 AND.B #$04 ; |
$03:8A64 F0 02 BEQ $8A68 ; / Return if not on ground
$03:8A66 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:8A68 60 RTS ; Return
$03:8A69 1E 7A 16 ASL.W RAM_Tweaker167A,X ; \
$03:8A6C 5E 7A 16 LSR.W RAM_Tweaker167A,X ; / Clear bit 7 of tweaker $167A (ASL then LSR)
$03:8A6F 22 DC A7 01 JSL.L MarioSprInteract ; Interact with Mario (hurts)
$03:8A73 9E 02 16 STZ.W $1602,X ; Graphics frame = 0
$03:8A76 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8A78 C9 10 CMP.B #$10 ; |
$03:8A7A 10 03 BPL $8A7F ; / Branch unless Y speed < $10 (signed)
$03:8A7C FE 02 16 INC.W $1602,X ; Graphics frame = 1 (jumping)
$03:8A7F 22 2A 80 01 JSL.L UpdateSpritePos ; Update position
$03:8A83 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8A86 29 03 AND.B #$03 ; |
$03:8A88 F0 0F BEQ $8A99 ; / Branch if no wall contact
$03:8A8A B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:8A8C 49 FF EOR.B #$FF ; |
$03:8A8E 1A INC A ; |
$03:8A8F 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = -X speed
$03:8A91 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8A94 49 01 EOR.B #$01 ; |
$03:8A96 9D 7C 15 STA.W RAM_SpriteDir,X ; / Flip direction
$03:8A99 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8A9C 29 04 AND.B #$04 ; |
$03:8A9E F0 26 BEQ $8AC6 ; / Return if not on ground
$03:8AA0 A9 10 LDA.B #$10 ; \
$03:8AA2 95 AA STA RAM_SpriteSpeedY,X ; / Landed: Y speed = $10
$03:8AA4 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:8AA6 BD 40 15 LDA.W $1540,X ; \
$03:8AA9 F0 16 BEQ $8AC1 ; / Branch if wait timer is 0
$03:8AAB 3A DEC A ; \
$03:8AAC D0 18 BNE $8AC6 ; / Return unless timer = 1 (time to jump)
$03:8AAE A9 C0 LDA.B #$C0 ; \
$03:8AB0 95 AA STA RAM_SpriteSpeedY,X ; / Jump Y speed = $C0
$03:8AB2 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:8AB5 98 TYA ; |
$03:8AB6 9D 7C 15 STA.W RAM_SpriteDir,X ; |
$03:8AB9 B9 BF 8A LDA.W BwsrStatueSpeed,Y ; |
$03:8ABC 95 B6 STA RAM_SpriteSpeedX,X ; / Face Mario and set X speed from BwsrStatueSpeed
$03:8ABE 60 RTS ; Return
;;; $8ABF: Table: Bowser statue jump X speed (BwsrStatueSpeed) ;;;
$03:8ABF .db $10,$F0 ; $10 - right, $F0 - left
$03:8AC1 A9 30 LDA.B #$30 ; \
$03:8AC3 9D 40 15 STA.W $1540,X ; / Wait timer = $30 frames
$03:8AC6 60 RTS ; Return
;;; $8AC7: Table: fire spawn X offset low byte (BwserFireDispXLo) ;;;
$03:8AC7 .db $10,$F0 ; Fire X offset low: $10 (dir 0, right), $F0 (dir 1, left)
;;; $8AC9: Bowser statue fireball spawner (BwserFireDispXHi) ;;;
;; Table of high bytes, then $8ACB: every 128 frames (staggered by slot) spawns sprite B3 (Bowser statue
;; fireball) in front of the statue.
$03:8AC9 .db $00,$FF ; Fire X offset high: $00, $FF
$03:8ACB 8A TXA ; \
$03:8ACC 0A ASL ; |
$03:8ACD 0A ASL ; |
$03:8ACE 65 13 ADC RAM_FrameCounter ; |
$03:8AD0 29 7F AND.B #$7F ; / Only when ([slot] * 4 + [$13]) mod $80 = 0
$03:8AD2 D0 50 BNE $8B24 ; Return if not time
$03:8AD4 22 E4 A9 02 JSL.L FindFreeSprSlot ; Find a free sprite slot
$03:8AD8 30 4A BMI $8B24 ; Return if none
$03:8ADA A9 17 LDA.B #$17 ; \
$03:8ADC 8D FC 1D STA.W $1DFC ; / Play fire sound effect
$03:8ADF A9 08 LDA.B #$08 ; \
$03:8AE1 99 C8 14 STA.W $14C8,Y ; / New sprite status = 8 (normal)
$03:8AE4 A9 B3 LDA.B #$B3 ; \
$03:8AE6 99 9E 00 STA.W RAM_SpriteNum,Y ; / New sprite number = $B3 (Bowser statue fireball)
$03:8AE9 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:8AEB 85 00 STA $00 ; |
$03:8AED BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:8AF0 85 01 STA $01 ; |
$03:8AF2 DA PHX ; |
$03:8AF3 BD 7C 15 LDA.W RAM_SpriteDir,X ; |
$03:8AF6 AA TAX ; |
$03:8AF7 A5 00 LDA $00 ; |
$03:8AF9 18 CLC ; |
$03:8AFA 7D C7 8A ADC.W BwserFireDispXLo,X ; |
$03:8AFD 99 E4 00 STA.W RAM_SpriteXLo,Y ; |
$03:8B00 A5 01 LDA $01 ; |
$03:8B02 7D C9 8A ADC.W BwserFireDispXHi,X ; |
$03:8B05 99 E0 14 STA.W RAM_SpriteXHi,Y ; / New sprite X = statue X +/- $10
$03:8B08 BB TYX ; \
$03:8B09 22 D2 F7 07 JSL.L InitSpriteTables ; |
$03:8B0D FA PLX ; / Reset the new sprite's tables
$03:8B0E B5 D8 LDA RAM_SpriteYLo,X ; \
$03:8B10 38 SEC ; |
$03:8B11 E9 02 SBC.B #$02 ; |
$03:8B13 99 D8 00 STA.W RAM_SpriteYLo,Y ; |
$03:8B16 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:8B19 E9 00 SBC.B #$00 ; |
$03:8B1B 99 D4 14 STA.W RAM_SpriteYHi,Y ; / New sprite Y = statue Y - 2
$03:8B1E BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8B21 99 7C 15 STA.W RAM_SpriteDir,Y ; / New sprite direction = statue direction
$03:8B24 60 RTS ; Return
;;; $8B25: Table: Bowser statue tile X offsets (BwsrStatueDispX) ;;;
$03:8B25 .db $08,$F8,$00,$00,$08,$00 ; Tile X offsets: dir 1 (left) $08,$F8,$00; dir 0 (right) $00,$08,$00
;;; $8B2B: Table: Bowser statue tile Y offsets (BwsrStatueDispY) ;;;
$03:8B2B .db $10,$F8,$00 ; Tile Y offsets: $10,$F8,$00
;;; $8B2E: Table: Bowser statue tile numbers (BwsrStatueTiles) ;;;
$03:8B2E .db $56,$30,$41,$56,$30,$35 ; Tile numbers per frame (3 tiles each): $56,$30,$41 and $56,$30,$35
;;; $8B34: Table: Bowser statue tile sizes (BwsrStatueTileSize) ;;;
$03:8B34 .db $00,$02,$02 ; Tile sizes: $00 = 8x8, $02 = 16x16, $02 = 16x16
;;; $8B37: Table: Bowser statue tile properties (BwsrStatueGfxProp) ;;;
;; Per tile: second half X-flipped ($40) for the other direction.
$03:8B37 .db $00,$00,$00,$40,$40,$40 ; Tile properties: $00 x3 (dir 1), $40 x3 (dir 0, X-flipped)
;;; $8B3D: Bowser statue graphics routine (BowserStatueGfx) ;;;
;; Draws three tiles (a small 8x8 and two 16x16) with direction and frame ($1602) selecting the tables;
;; palette from sprite palette.
;; Called by:
;; $03:8A3C: Bowser statue main (BowserStatue)
$03:8B3D 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get sprite draw position ($00 = X, $01 = Y)
$03:8B40 BD 02 16 LDA.W $1602,X ; \
$03:8B43 85 04 STA $04 ; / [$04] = graphics frame
$03:8B45 49 01 EOR.B #$01 ; \
$03:8B47 3A DEC A ; |
$03:8B48 85 03 STA $03 ; / [$03] = ([$04] EOR 1) - 1: loop end index
$03:8B4A BD F6 15 LDA.W RAM_SpritePal,X ; \
$03:8B4D 85 05 STA $05 ; / [$05] = sprite palette
$03:8B4F BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8B52 85 02 STA $02 ; / [$02] = direction
$03:8B54 DA PHX ; Save sprite index
$03:8B55 A2 02 LDX.B #$02 ; Loop: 3 tiles
$03:8B57 DA PHX ; Save loop counter
$03:8B58 A5 02 LDA $02 ; \
$03:8B5A D0 03 BNE $8B5F ; |
$03:8B5C E8 INX ; |
$03:8B5D E8 INX ; |
$03:8B5E E8 INX ; / Direction 0: use the second half of the X/property tables
$03:8B5F A5 00 LDA $00 ; \
$03:8B61 18 CLC ; |
$03:8B62 7D 25 8B ADC.W BwsrStatueDispX,X ; |
$03:8B65 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite X + BwsrStatueDispX[X]
$03:8B68 BD 37 8B LDA.W BwsrStatueGfxProp,X ; \
$03:8B6B 05 05 ORA $05 ; |
$03:8B6D 05 64 ORA $64 ; |
$03:8B6F 99 03 03 STA.W OAM_Prop,Y ; / Properties from table, palette and level priority
$03:8B72 FA PLX ; Restore loop counter
$03:8B73 A5 01 LDA $01 ; \
$03:8B75 18 CLC ; |
$03:8B76 7D 2B 8B ADC.W BwsrStatueDispY,X ; |
$03:8B79 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite Y + BwsrStatueDispY[X]
$03:8B7C DA PHX ; Save index
$03:8B7D A5 04 LDA $04 ; \
$03:8B7F F0 03 BEQ $8B84 ; |
$03:8B81 E8 INX ; |
$03:8B82 E8 INX ; |
$03:8B83 E8 INX ; / Frame 1: use the second half of the tile table
$03:8B84 BD 2E 8B LDA.W BwsrStatueTiles,X ; \
$03:8B87 99 02 03 STA.W OAM_Tile,Y ; / OAM tile from BwsrStatueTiles
$03:8B8A FA PLX ; Restore index
$03:8B8B 5A PHY ; \
$03:8B8C 98 TYA ; |
$03:8B8D 4A LSR ; |
$03:8B8E 4A LSR ; |
$03:8B8F A8 TAY ; / Y = OAM index / 4
$03:8B90 BD 34 8B LDA.W BwsrStatueTileSize,X ; \
$03:8B93 99 60 04 STA.W OAM_TileSize,Y ; / OAM size from BwsrStatueTileSize
$03:8B96 7A PLY ; Restore OAM index
$03:8B97 C8 INY ; \
$03:8B98 C8 INY ; |
$03:8B99 C8 INY ; |
$03:8B9A C8 INY ; / OAM index += 4
$03:8B9B CA DEX ; Next tile
$03:8B9C E4 03 CPX $03 ; \
$03:8B9E D0 B7 BNE $8B57 ; / Loop until the marker
$03:8BA0 FA PLX ; Restore sprite index
$03:8BA1 A0 FF LDY.B #$FF ; Sizes are individual
$03:8BA3 A9 02 LDA.B #$02 ; Three tiles - 1 = 2
$03:8BA5 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:8BA9 60 RTS ; Return
;;; $8BAA..8C22: Table: Bowser statue shake/wave data ;;;
;; Triangular wave from $20 down to 0 up to $20 (probably unused or used by another sprite).
$03:8BAA .db $20,$20,$20,$20,$20,$20,$20,$20 ; $20 x16 then ramp down $20..$00 (triangle wave, probably unused)
$03:8BB2 .db $20,$20,$20,$20,$20,$20,$20,$20
$03:8BBA .db $20,$1F,$1E,$1D,$1C,$1B,$1A,$19
$03:8BC2 .db $18,$17,$16,$15,$14,$13,$12,$11
$03:8BCA .db $10,$0F,$0E,$0D,$0C,$0B,$0A,$09
$03:8BD2 .db $08,$07,$06,$05,$04,$03,$02,$01
$03:8BDA .db $00,$00,$00,$00,$00,$00,$00,$00
$03:8BE2 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:8BEA .db $00,$00,$00,$00,$00,$00,$00,$00
$03:8BF2 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:8BFA .db $01,$02,$03,$04,$05,$06,$07,$08
$03:8C02 .db $09,$0A,$0B,$0C,$0D,$0E,$0F,$10
$03:8C0A .db $11,$12,$13,$14,$15,$16,$17,$18
$03:8C12 .db $19,$1A,$1B,$1C,$1D,$1E,$1F,$20
$03:8C1A .db $20,$20,$20,$20,$20,$20,$20,$20
$03:8C22 .db $20,$20,$20,$20,$20,$20,$20,$20
;;; $8C2A..8C2A: Table: 4 offsets ($00,$F8,$00,$08) ;;;
$03:8C2A .db $00,$F8,$00,$08 ; $00,$F8,$00,$08 (purpose unclear)
;;; $8C2E: Unused. Return stub ;;;
$03:8C2E 60 RTS ; Unused return
;;; $8C2F: Carrot top lift main routine (CarrotTopLift) ;;;
;; Sprites $B7/$B8: slanted platforms that move diagonally in a 4-phase cycle ($80 frames each, speed from
;; $8C2A, Y speed is -X speed for $B7).
;; Mario can stand on the slope: his X offset from the sprite indexes the surface height table $8BAA,
;; and he is carried along by [$1491].
;; Parts of the original author's logic are unclear ('can't make sense of the details'), so some comments here
;; are hedged.
;; Called by:
;; $03:A1BE: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8C2F 20 24 8D JSR.W CarrotTopLiftGfx ; Draw the carrot top lift (CarrotTopLiftGfx)
$03:8C32 A5 9D LDA RAM_SpritesLocked ; \
$03:8C34 D0 F8 BNE $8C2E ; / Return if sprites are locked
$03:8C36 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:8C39 BD 40 15 LDA.W $1540,X ; \
$03:8C3C D0 07 BNE $8C45 ; / Phase timer [$1540] still running: skip the phase change
$03:8C3E F6 C2 INC RAM_SpriteState,X ; Next movement phase: [sprite state]++
$03:8C40 A9 80 LDA.B #$80 ; \
$03:8C42 9D 40 15 STA.W $1540,X ; / Phase timer [$1540] = $80 frames
$03:8C45 B5 C2 LDA RAM_SpriteState,X ; \
$03:8C47 29 03 AND.B #$03 ; } Y = [sprite state] AND 3 (movement phase)
$03:8C49 A8 TAY ; /
$03:8C4A B9 2A 8C LDA.W $8C2A,Y ; A = X speed from $8C2A ($00,$F8,$00,$08) for this phase
$03:8C4D 95 B6 STA RAM_SpriteSpeedX,X ; Sprite X speed = A
$03:8C4F B5 B6 LDA RAM_SpriteSpeedX,X ; A = sprite X speed
$03:8C51 B4 9E LDY RAM_SpriteNum,X ; \
$03:8C53 C0 B8 CPY.B #$B8 ; } Sprite $B8 keeps Y speed = X speed (skips the negation)
$03:8C55 F0 03 BEQ $8C5A ; /
$03:8C57 49 FF EOR.B #$FF ; \
$03:8C59 1A INC A ; / Other lift ($B7): Y speed = -X speed
$03:8C5A 95 AA STA RAM_SpriteSpeedY,X ; Sprite Y speed = A
$03:8C5C 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically (no gravity)
$03:8C60 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:8C62 9D 1C 15 STA.W $151C,X ; / [$151C] = sprite X low before moving (reference for Mario's position on the slope)
$03:8C65 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:8C69 20 E4 8C JSR.W $8CE4 ; Build Mario's feet hitbox ($8CE4)
$03:8C6C 22 9F B6 03 JSL.L GetSpriteClippingA ; Sprite hitbox A (GetSpriteClippingA)
$03:8C70 22 2B B7 03 JSL.L CheckForContact ; Check hitbox overlap (CheckForContact)
$03:8C74 90 6D BCC $8CE3 ; No contact: return
$03:8C76 A5 7D LDA RAM_MarioSpeedY ; \
$03:8C78 30 69 BMI $8CE3 ; / Mario moving upward: return
$03:8C7A A5 94 LDA RAM_MarioXPos ; \
$03:8C7C 38 SEC ; |
$03:8C7D FD 1C 15 SBC.W $151C,X ; |
$03:8C80 18 CLC ; } A = Mario X - old sprite X + $1C
$03:8C81 69 1C ADC.B #$1C ; /
$03:8C83 B4 9E LDY RAM_SpriteNum,X ; \
$03:8C85 C0 B8 CPY.B #$B8 ; } Sprite $B8 adds $38 more (second half of the slope table)
$03:8C87 D0 03 BNE $8C8C ; /
$03:8C89 18 CLC ; \
$03:8C8A 69 38 ADC.B #$38 ; / A += $38
$03:8C8C A8 TAY ; Y = index into slope height table $8BAA
$03:8C8D AD 7A 18 LDA.W RAM_OnYoshi ; \
$03:8C90 C9 01 CMP.B #$01 ; |
$03:8C92 A9 20 LDA.B #$20 ; } A = $20, or $30 if riding Yoshi (set at $038C96)
$03:8C94 90 02 BCC $8C98 ; /
$03:8C96 A9 30 LDA.B #$30 ; Riding Yoshi: A = $30
$03:8C98 18 CLC ; \
$03:8C99 65 96 ADC RAM_MarioYPos ; } $00 = Mario Y + A (Y of Mario's feet)
$03:8C9B 85 00 STA $00 ; /
$03:8C9D B5 D8 LDA RAM_SpriteYLo,X ; \
$03:8C9F 18 CLC ; |
$03:8CA0 79 AA 8B ADC.W $8BAA,Y ; } A = sprite Y + slope height at Mario's X; compare to feet Y
$03:8CA3 C5 00 CMP $00 ; /
$03:8CA5 10 3C BPL $8CE3 ; Surface at or below the feet: not landed, return
$03:8CA7 AD 7A 18 LDA.W RAM_OnYoshi ; \
$03:8CAA C9 01 CMP.B #$01 ; |
$03:8CAC A9 1D LDA.B #$1D ; } A = $1D, or $2D if riding Yoshi (set at $038CB0)
$03:8CAE 90 02 BCC $8CB2 ; /
$03:8CB0 A9 2D LDA.B #$2D ; Riding Yoshi: A = $2D
$03:8CB2 85 00 STA $00 ; $00 = height of Mario above the surface
$03:8CB4 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:8CB6 18 CLC ; } A = sprite Y + slope height at Mario's X
$03:8CB7 79 AA 8B ADC.W $8BAA,Y ; /
$03:8CBA 08 PHP ; Save carry from the 8-bit sum
$03:8CBB 38 SEC ; \
$03:8CBC E5 00 SBC $00 ; } Mario Y low = surface Y - $00 (stand on the slope)
$03:8CBE 85 96 STA RAM_MarioYPos ; /
$03:8CC0 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:8CC3 E9 00 SBC.B #$00 ; |
$03:8CC5 28 PLP ; |
$03:8CC6 69 00 ADC.B #$00 ; } Mario Y high = sprite Y high - borrow + saved carry
$03:8CC8 85 97 STA RAM_MarioYPosHi ; /
$03:8CCA 64 7D STZ RAM_MarioSpeedY ; Mario Y speed = 0
$03:8CCC A9 01 LDA.B #$01 ; \
$03:8CCE 8D 71 14 STA.W $1471 ; / [$1471] = 1: Mario is riding a platform sprite
$03:8CD1 A0 00 LDY.B #$00 ; \
$03:8CD3 AD 91 14 LDA.W $1491 ; / Y = 0, A = [$1491] (sprite X movement this frame, probably)
$03:8CD6 10 01 BPL $8CD9 ; Positive: Y stays 0
$03:8CD8 88 DEY ; Negative: Y = $FF (sign extension)
$03:8CD9 18 CLC ; \
$03:8CDA 65 94 ADC RAM_MarioXPos ; } Mario X low += sprite movement
$03:8CDC 85 94 STA RAM_MarioXPos ; /
$03:8CDE 98 TYA ; \
$03:8CDF 65 95 ADC RAM_MarioXPosHi ; } Mario X high += sign extension and carry
$03:8CE1 85 95 STA RAM_MarioXPosHi ; /
$03:8CE3 60 RTS ; Return
$03:8CE4 A5 94 LDA RAM_MarioXPos ; \
$03:8CE6 18 CLC ; |
$03:8CE7 69 04 ADC.B #$04 ; } $00 = Mario X + 4 (hitbox X low)
$03:8CE9 85 00 STA $00 ; /
$03:8CEB A5 95 LDA RAM_MarioXPosHi ; \
$03:8CED 69 00 ADC.B #$00 ; } $08 = Mario X high + carry
$03:8CEF 85 08 STA $08 ; /
$03:8CF1 A9 08 LDA.B #$08 ; \
$03:8CF3 85 02 STA $02 ; } Hitbox width and height ($02, $03) = 8
$03:8CF5 85 03 STA $03 ; /
$03:8CF7 A9 20 LDA.B #$20 ; \
$03:8CF9 AC 7A 18 LDY.W RAM_OnYoshi ; } A = $20, or $30 if riding Yoshi (set at $038CFE)
$03:8CFC F0 02 BEQ $8D00 ; /
$03:8CFE A9 30 LDA.B #$30 ; Riding Yoshi: A = $30
$03:8D00 18 CLC ; \
$03:8D01 65 96 ADC RAM_MarioYPos ; } $01 = Mario Y + A (hitbox at Mario's feet)
$03:8D03 85 01 STA $01 ; /
$03:8D05 A5 97 LDA RAM_MarioYPosHi ; \
$03:8D07 69 00 ADC.B #$00 ; } $09 = Mario Y high + carry
$03:8D09 85 09 STA $09 ; /
$03:8D0B 60 RTS ; Return
;;; $8D0C: Table: carrot top lift tile X offsets (DiagPlatDispX) ;;;
$03:8D0C .db $10,$00,$10,$00,$10,$00 ; X offsets of the 3 tiles ($B7 uses entries 2-0, $B8 uses entries 5-3)
;;; $8D12: Table: carrot top lift tile Y offsets (DiagPlatDispY) ;;;
$03:8D12 .db $00,$10,$10,$00,$10,$10 ; Y offsets of the tiles
;;; $8D18: Table: carrot top lift tile numbers (DiagPlatTiles) ;;;
$03:8D18 .db $E4,$E0,$E2,$E4,$E0,$E2 ; Tile numbers
;;; $8D1E: Table: carrot top lift tile properties (DiagPlatGfxProp) ;;;
$03:8D1E .db $0B,$0B,$0B,$4B,$4B,$4B ; Tile properties (second half X-flipped)
;;; $8D24: Carrot top lift graphics (CarrotTopLiftGfx) ;;;
;; Draws three 16x16 tiles: entries 2-0 for sprite $B7, entries 5-3 (X-flipped) for sprite $B8.
;; Called by:
;; $03:8C2F: Carrot top lift main routine (CarrotTopLift)
$03:8D24 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:8D27 DA PHX ; Save sprite index
$03:8D28 B5 9E LDA RAM_SpriteNum,X ; \
$03:8D2A C9 B8 CMP.B #$B8 ; / Carry = sprite number >= $B8
$03:8D2C A2 02 LDX.B #$02 ; \
$03:8D2E 86 02 STX $02 ; / X = $02 = 2 (three tiles)
$03:8D30 90 02 BCC $8D34 ; Sprite $B7: use entries 2-0
$03:8D32 A2 05 LDX.B #$05 ; Sprite $B8: X = 5, use entries 5-3
$03:8D34 A5 00 LDA $00 ; \
$03:8D36 18 CLC ; |
$03:8D37 7D 0C 8D ADC.W DiagPlatDispX,X ; } OAM X = sprite X + DiagPlatDispX[X]
$03:8D3A 99 00 03 STA.W OAM_DispX,Y ; /
$03:8D3D A5 01 LDA $01 ; \
$03:8D3F 18 CLC ; |
$03:8D40 7D 12 8D ADC.W DiagPlatDispY,X ; } OAM Y = sprite Y + DiagPlatDispY[X]
$03:8D43 99 01 03 STA.W OAM_DispY,Y ; /
$03:8D46 BD 18 8D LDA.W DiagPlatTiles,X ; \
$03:8D49 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = DiagPlatTiles[X]
$03:8D4C BD 1E 8D LDA.W DiagPlatGfxProp,X ; \
$03:8D4F 05 64 ORA $64 ; } OAM properties = DiagPlatGfxProp[X] | [$64] (priority)
$03:8D51 99 03 03 STA.W OAM_Prop,Y ; /
$03:8D54 C8 INY ; \
$03:8D55 C8 INY ; |
$03:8D56 C8 INY ; } OAM index += 4
$03:8D57 C8 INY ; /
$03:8D58 CA DEX ; \
$03:8D59 C6 02 DEC $02 ; } X--, $02--; loop for 3 tiles
$03:8D5B 10 D7 BPL $8D34 ; /
$03:8D5D FA PLX ; Restore sprite index
$03:8D5E A0 02 LDY.B #$02 ; \
$03:8D60 98 TYA ; / Y = 2 (16x16 tiles), A = 2 (three tiles)
$03:8D61 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:8D65 60 RTS ; Return
;;; $8D66..8D6E: Table: info box bounce offsets ;;;
;; Screen Y offsets applied while the block bounces, indexed by [$1558] / 2.
$03:8D66 .db $00,$04,$07,$08,$08,$07,$04,$00 ; Block bounce offsets, indexed by [$1558] / 2 (up to 8 pixels)
$03:8D6E .db $00 ; Last bounce offset
;;; $8D6F: Message box main routine (InfoBox) ;;;
;; Solid block (InvisBlkMainRt). When hit from below the timer [$1558] counts down; at 1 it plays sound $22
;; and sets [$1426] to message 1 or 2
;; (chosen by bit 4 of the sprite's X position). While the timer runs the layer 1 Y scroll is shifted
;; temporarily to fake a bounce; the tile is forced to $C0.
;; Called by:
;; $03:A1C7: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8D6F 22 4F B4 01 JSL.L InvisBlkMainRt ; Make Mario able to stand on / hit the block (InvisBlkMainRt)
$03:8D73 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:8D76 BD 58 15 LDA.W $1558,X ; \
$03:8D79 C9 01 CMP.B #$01 ; } Message timer [$1558] = 1 (about to show message)? Otherwise skip
$03:8D7B D0 16 BNE $8D93 ; /
$03:8D7D A9 22 LDA.B #$22 ; \
$03:8D7F 8D FC 1D STA.W $1DFC ; / Play sound effect $22 (port $1DFC)
$03:8D82 9E 58 15 STZ.W $1558,X ; Clear the message timer
$03:8D85 74 C2 STZ RAM_SpriteState,X ; Clear sprite state
$03:8D87 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:8D89 4A LSR ; |
$03:8D8A 4A LSR ; |
$03:8D8B 4A LSR ; |
$03:8D8C 4A LSR ; |
$03:8D8D 29 01 AND.B #$01 ; |
$03:8D8F 1A INC A ; } [$1426] = message number 1 or 2 from bit 4 of sprite X low
$03:8D90 8D 26 14 STA.W $1426 ; /
$03:8D93 BD 58 15 LDA.W $1558,X ; \
$03:8D96 4A LSR ; } Y = [$1558] / 2: index into the bounce table
$03:8D97 A8 TAY ; /
$03:8D98 A5 1C LDA RAM_ScreenBndryYLo ; \
$03:8D9A 48 PHA ; |
$03:8D9B 18 CLC ; |
$03:8D9C 79 66 8D ADC.W $8D66,Y ; } Save layer 1 Y low; [$1C] += $8D66[Y] (fake the block bounce)
$03:8D9F 85 1C STA RAM_ScreenBndryYLo ; /
$03:8DA1 A5 1D LDA RAM_ScreenBndryYHi ; \
$03:8DA3 48 PHA ; |
$03:8DA4 69 00 ADC.B #$00 ; } Save layer 1 Y high; add the carry
$03:8DA6 85 1D STA RAM_ScreenBndryYHi ; /
$03:8DA8 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw the sprite (GenericSprGfxRt2)
$03:8DAC BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:8DAF A9 C0 LDA.B #$C0 ; \
$03:8DB1 99 02 03 STA.W OAM_Tile,Y ; / Force OAM tile to $C0
$03:8DB4 68 PLA ; \
$03:8DB5 85 1D STA RAM_ScreenBndryYHi ; |
$03:8DB7 68 PLA ; } Restore layer 1 Y position (high, then low)
$03:8DB8 85 1C STA RAM_ScreenBndryYLo ; /
$03:8DBA 60 RTS ; Return
;;; $8DBB: Timed lift main routine (TimedLift) ;;;
;; Platform with a countdown number. Waits for Mario to stand on it, then moves right at speed $10 while the
;; timer [$1570] counts down,
;; and falls with gravity when it reaches 0. Note: the 'AND #$00' at $038DC7 means the branch after it never
;; happens.
;; Called by:
;; $03:A1D0: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8DBB 20 12 8E JSR.W TimedPlatformGfx ; Draw the platform with its countdown number (TimedPlatformGfx)
$03:8DBE A5 9D LDA RAM_SpritesLocked ; \
$03:8DC0 D0 2D BNE $8DEF ; / Return if sprites are locked
$03:8DC2 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:8DC5 A5 13 LDA RAM_FrameCounter ; \
$03:8DC7 29 00 AND.B #$00 ; } A = frame counter AND 0 = 0: this branch is never taken
$03:8DC9 D0 0C BNE $8DD7 ; /
$03:8DCB B5 C2 LDA RAM_SpriteState,X ; \
$03:8DCD F0 08 BEQ $8DD7 ; / Not triggered by Mario yet (state = 0): skip the countdown
$03:8DCF BD 70 15 LDA.W $1570,X ; \
$03:8DD2 F0 03 BEQ $8DD7 ; / Timer [$1570] already 0: skip
$03:8DD4 DE 70 15 DEC.W $1570,X ; Count down timer [$1570]
$03:8DD7 BD 70 15 LDA.W $1570,X ; \
$03:8DDA F0 14 BEQ $8DF0 ; / Timer ran out: fall ($8DF0)
$03:8DDC 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:8DE0 9D 28 15 STA.W $1528,X ; [$1528] = A (never used)
$03:8DE3 22 4F B4 01 JSL.L InvisBlkMainRt ; \
$03:8DE7 90 06 BCC $8DEF ; / Return unless Mario stands on it (InvisBlkMainRt)
$03:8DE9 A9 10 LDA.B #$10 ; \
$03:8DEB 95 B6 STA RAM_SpriteSpeedX,X ; } Mario is on it: X speed = state = $10 (start moving)
$03:8DED 95 C2 STA RAM_SpriteState,X ; /
$03:8DEF 60 RTS ; Return
$03:8DF0 22 2A 80 01 JSL.L UpdateSpritePos ; Timer expired: move with gravity (UpdateSpritePos)
$03:8DF4 AD 91 14 LDA.W $1491 ; \
$03:8DF7 9D 28 15 STA.W $1528,X ; / [$1528] = [$1491] (never used)
$03:8DFA 22 4F B4 01 JSL.L InvisBlkMainRt ; Make Mario able to stand on the platform
$03:8DFE 60 RTS ; Return
;;; $8DFF: Table: timed lift tile X offsets (TimedPlatDispX) ;;;
$03:8DFF .db $00,$10,$0C ; X offsets: left half, right half, countdown number
;;; $8E02: Table: timed lift tile Y offsets (TimedPlatDispY) ;;;
$03:8E02 .db $00,$00,$04 ; Y offsets
;;; $8E05: Table: timed lift tile numbers (TimedPlatTiles) ;;;
$03:8E05 .db $C4,$C4,$00 ; Tile numbers (number tile is replaced from TimedPlatNumTiles)
;;; $8E08: Table: timed lift tile properties (TimedPlatGfxProp) ;;;
$03:8E08 .db $0B,$4B,$0B ; Tile properties (right half X-flipped)
;;; $8E0B: Table: timed lift OAM size bits (TimedPlatTileSize) ;;;
$03:8E0B .db $02,$02,$00 ; OAM size bits: 2 = 16x16, 0 = 8x8
;;; $8E0E: Table: timed lift countdown digit tiles (TimedPlatNumTiles) ;;;
$03:8E0E .db $B6,$B5,$B4,$B3 ; Number tiles by timer / 64 ($B6, $B5, $B4, $B3)
;;; $8E12: Timed lift graphics (TimedPlatformGfx) ;;;
;; Draws two 16x16 platform halves plus an 8x8 countdown digit chosen by [$1570] / 64. The digit is omitted
;; when the timer is below 8.
;; Sizes are written to the OAM size table by hand, so FinishOAMWrite is called with Y = $FF.
;; Called by:
;; $03:8DBB: Timed lift main routine (TimedLift)
$03:8E12 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:8E15 BD 70 15 LDA.W $1570,X ; \
$03:8E18 DA PHX ; |
$03:8E19 48 PHA ; |
$03:8E1A 4A LSR ; |
$03:8E1B 4A LSR ; |
$03:8E1C 4A LSR ; |
$03:8E1D 4A LSR ; |
$03:8E1E 4A LSR ; |
$03:8E1F 4A LSR ; |
$03:8E20 AA TAX ; } $02 = number tile from TimedPlatNumTiles[[$1570] / 64]
$03:8E21 BD 0E 8E LDA.W TimedPlatNumTiles,X ; /
$03:8E24 85 02 STA $02 ; Store the number tile in $02
$03:8E26 A2 02 LDX.B #$02 ; X = 2: three tiles (entry 2 is the number)
$03:8E28 68 PLA ; \
$03:8E29 C9 08 CMP.B #$08 ; |
$03:8E2B B0 01 BCS $8E2E ; } Timer < 8: skip the number tile (X = 1)
$03:8E2D CA DEX ; /
$03:8E2E A5 00 LDA $00 ; \
$03:8E30 18 CLC ; |
$03:8E31 7D FF 8D ADC.W TimedPlatDispX,X ; } OAM X = sprite X + TimedPlatDispX[X]
$03:8E34 99 00 03 STA.W OAM_DispX,Y ; /
$03:8E37 A5 01 LDA $01 ; \
$03:8E39 18 CLC ; |
$03:8E3A 7D 02 8E ADC.W TimedPlatDispY,X ; } OAM Y = sprite Y + TimedPlatDispY[X]
$03:8E3D 99 01 03 STA.W OAM_DispY,Y ; /
$03:8E40 BD 05 8E LDA.W TimedPlatTiles,X ; \
$03:8E43 E0 02 CPX.B #$02 ; |
$03:8E45 D0 02 BNE $8E49 ; |
$03:8E47 A5 02 LDA $02 ; } OAM tile = TimedPlatTiles[X], or the number tile in $02 for X = 2
$03:8E49 99 02 03 STA.W OAM_Tile,Y ; /
$03:8E4C BD 08 8E LDA.W TimedPlatGfxProp,X ; \
$03:8E4F 05 64 ORA $64 ; } OAM properties = TimedPlatGfxProp[X] | [$64]
$03:8E51 99 03 03 STA.W OAM_Prop,Y ; /
$03:8E54 5A PHY ; \
$03:8E55 98 TYA ; |
$03:8E56 4A LSR ; |
$03:8E57 4A LSR ; |
$03:8E58 A8 TAY ; |
$03:8E59 BD 0B 8E LDA.W TimedPlatTileSize,X ; } OAM size bits at $0460 + (OAM index / 4) = TimedPlatTileSize[X]
$03:8E5C 99 60 04 STA.W OAM_TileSize,Y ; /
$03:8E5F 7A PLY ; Restore OAM index
$03:8E60 C8 INY ; \
$03:8E61 C8 INY ; |
$03:8E62 C8 INY ; } OAM index += 4
$03:8E63 C8 INY ; /
$03:8E64 CA DEX ; \
$03:8E65 10 C7 BPL $8E2E ; / X--; loop while X >= 0
$03:8E67 FA PLX ; Restore sprite index
$03:8E68 A0 FF LDY.B #$FF ; \
$03:8E6A A9 02 LDA.B #$02 ; / Y = $FF (sizes already written), A = 2 (three tiles)
$03:8E6C 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:8E70 60 RTS ; Return
;;; $8E71: Table: grey castle block X speeds (GreyMoveBlkSpeed) ;;;
$03:8E71 .db $00,$F0,$00,$10 ; X speed for each phase (0, left, 0, right)
;;; $8E75: Table: grey castle block phase lengths (GreyMoveBlkTiming) ;;;
$03:8E75 .db $40,$50,$40,$50 ; Phase length in frames
;;; $8E79: Grey moving castle block main routine (GreyCastleBlock) ;;;
;; Sprite state AND 3 selects a phase: speed 0, left $F0, 0, right $10, for $40 or $50 frames. Solid via
;; InvisBlkMainRt.
;; Called by:
;; $03:A1D9: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8E79 20 B4 8E JSR.W $8EB4 ; Draw the block ($8EB4)
$03:8E7C A5 9D LDA RAM_SpritesLocked ; \
$03:8E7E D0 27 BNE $8EA7 ; / Return if sprites are locked
$03:8E80 BD 40 15 LDA.W $1540,X ; \
$03:8E83 D0 0D BNE $8E92 ; / Phase timer [$1540] running: skip the phase change
$03:8E85 F6 C2 INC RAM_SpriteState,X ; Next phase: state++
$03:8E87 B5 C2 LDA RAM_SpriteState,X ; \
$03:8E89 29 03 AND.B #$03 ; |
$03:8E8B A8 TAY ; |
$03:8E8C B9 75 8E LDA.W GreyMoveBlkTiming,Y ; } [$1540] = GreyMoveBlkTiming[state AND 3]
$03:8E8F 9D 40 15 STA.W $1540,X ; /
$03:8E92 B5 C2 LDA RAM_SpriteState,X ; \
$03:8E94 29 03 AND.B #$03 ; |
$03:8E96 A8 TAY ; |
$03:8E97 B9 71 8E LDA.W GreyMoveBlkSpeed,Y ; } X speed = GreyMoveBlkSpeed[state AND 3]
$03:8E9A 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:8E9C 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:8EA0 9D 28 15 STA.W $1528,X ; [$1528] = A (never used)
$03:8EA3 22 4F B4 01 JSL.L InvisBlkMainRt ; Make Mario able to stand on top of the block
$03:8EA7 60 RTS ; Return
;;; $8EA8: Table: grey castle block tile X offsets (GreyMoveBlkDispX) ;;;
$03:8EA8 .db $00,$10,$00,$10 ; X offsets of the 2x2 tiles
;;; $8EAC: Table: grey castle block tile Y offsets (GreyMoveBlkDispY) ;;;
$03:8EAC .db $00,$00,$10,$10 ; Y offsets of the 2x2 tiles
;;; $8EB0: Grey castle block graphics (GreyMoveBlkTiles) ;;;
;; Draws a 2x2 arrangement of 16x16 tiles (32x32 pixels) with palette 9. The tile numbers table is at the
;; start of the section.
$03:8EB0 .db $CC,$CE,$EC,$EE ; Tile numbers
$03:8EB4 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:8EB7 DA PHX ; Save sprite index
$03:8EB8 A2 03 LDX.B #$03 ; X = 3: four tiles
$03:8EBA A5 00 LDA $00 ; \
$03:8EBC 18 CLC ; |
$03:8EBD 7D A8 8E ADC.W GreyMoveBlkDispX,X ; } OAM X = sprite X + GreyMoveBlkDispX[X]
$03:8EC0 99 00 03 STA.W OAM_DispX,Y ; /
$03:8EC3 A5 01 LDA $01 ; \
$03:8EC5 18 CLC ; |
$03:8EC6 7D AC 8E ADC.W GreyMoveBlkDispY,X ; } OAM Y = sprite Y + GreyMoveBlkDispY[X]
$03:8EC9 99 01 03 STA.W OAM_DispY,Y ; /
$03:8ECC BD B0 8E LDA.W GreyMoveBlkTiles,X ; \
$03:8ECF 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = GreyMoveBlkTiles[X]
$03:8ED2 A9 03 LDA.B #$03 ; \
$03:8ED4 05 64 ORA $64 ; } OAM properties = $03 | [$64] (palette 9, second graphics page)
$03:8ED6 99 03 03 STA.W OAM_Prop,Y ; /
$03:8ED9 C8 INY ; \
$03:8EDA C8 INY ; |
$03:8EDB C8 INY ; } OAM index += 4
$03:8EDC C8 INY ; /
$03:8EDD CA DEX ; \
$03:8EDE 10 DA BPL $8EBA ; / X--; loop while X >= 0
$03:8EE0 FA PLX ; Restore sprite index
$03:8EE1 A0 02 LDY.B #$02 ; \
$03:8EE3 A9 03 LDA.B #$03 ; / Y = 2 (16x16 tiles), A = 3 (four tiles)
$03:8EE5 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:8EE9 60 RTS ; Return
;;; $8EEA: Table: statue fireball X speeds (StatueFireSpeed) ;;;
$03:8EEA .db $10,$F0 ; X speed by direction: right $10, left $F0
;;; $8EEC: Bowser statue fireball main routine (StatueFireball) ;;;
;; Moves horizontally at $10 (right) or $F0 (left) by sprite direction and hurts Mario on contact.
;; Called by:
;; $03:A1E2: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8EEC 20 1B 8F JSR.W StatueFireballGfx ; Draw the fireball (StatueFireballGfx)
$03:8EEF A5 9D LDA RAM_SpritesLocked ; \
$03:8EF1 D0 13 BNE $8F06 ; / Return if sprites are locked
$03:8EF3 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:8EF6 22 DC A7 01 JSL.L MarioSprInteract ; Interact with Mario (MarioSprInteract)
$03:8EFA BC 7C 15 LDY.W RAM_SpriteDir,X ; \
$03:8EFD B9 EA 8E LDA.W StatueFireSpeed,Y ; } X speed = StatueFireSpeed[direction]
$03:8F00 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:8F02 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:8F06 60 RTS ; Return
;;; $8F07: Table: statue fireball tile X offsets (StatueFireDispX) ;;;
$03:8F07 .db $08,$00,$00,$08 ; X offsets of the two tiles, per direction (2 entries each)
;;; $8F0B: Table: statue fireball tile numbers (StatueFireTiles) ;;;
$03:8F0B .db $32,$50,$33,$34,$32,$50,$33,$34 ; Tile numbers, 4 animation frames per direction
;;; $8F13: Table: statue fireball tile properties (StatueFireGfxProp) ;;;
$03:8F13 .db $09,$09,$09,$09,$89,$89,$89,$89 ; Tile properties (second half Y-flipped), 4 per direction
;;; $8F1B: Statue fireball graphics (StatueFireballGfx) ;;;
;; Draws two 8x8 tiles. Animation frame is ([$14] / 2 AND 3); the right-moving version is flipped
;; horizontally.
;; Called by:
;; $03:8EEC: Bowser statue fireball main routine (StatueFireball)
$03:8F1B 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:8F1E BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:8F21 0A ASL ; } $02 = direction * 2
$03:8F22 85 02 STA $02 ; /
$03:8F24 A5 14 LDA RAM_FrameCounterB ; \
$03:8F26 4A LSR ; |
$03:8F27 29 03 AND.B #$03 ; |
$03:8F29 0A ASL ; } $03 = ((frame counter / 2) AND 3) * 2 (animation frame)
$03:8F2A 85 03 STA $03 ; /
$03:8F2C DA PHX ; Save sprite index
$03:8F2D A2 01 LDX.B #$01 ; X = 1: two tiles
$03:8F2F A5 01 LDA $01 ; \
$03:8F31 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite Y
$03:8F34 DA PHX ; Save loop counter
$03:8F35 8A TXA ; \
$03:8F36 05 02 ORA $02 ; } X = loop counter | $02 (index into X offsets)
$03:8F38 AA TAX ; /
$03:8F39 A5 00 LDA $00 ; \
$03:8F3B 18 CLC ; |
$03:8F3C 7D 07 8F ADC.W StatueFireDispX,X ; } OAM X = sprite X + StatueFireDispX[X]
$03:8F3F 99 00 03 STA.W OAM_DispX,Y ; /
$03:8F42 68 PLA ; \
$03:8F43 48 PHA ; |
$03:8F44 05 03 ORA $03 ; } X = loop counter | $03 (index into tiles and properties)
$03:8F46 AA TAX ; /
$03:8F47 BD 0B 8F LDA.W StatueFireTiles,X ; \
$03:8F4A 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = StatueFireTiles[X]
$03:8F4D BD 13 8F LDA.W StatueFireGfxProp,X ; A = StatueFireGfxProp[X]
$03:8F50 A6 02 LDX $02 ; \
$03:8F52 D0 02 BNE $8F56 ; } Direction 0 (right): flip horizontally
$03:8F54 49 40 EOR.B #$40 ; /
$03:8F56 05 64 ORA $64 ; \
$03:8F58 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = A | [$64]
$03:8F5B FA PLX ; Restore loop counter
$03:8F5C C8 INY ; \
$03:8F5D C8 INY ; |
$03:8F5E C8 INY ; } OAM index += 4
$03:8F5F C8 INY ; /
$03:8F60 CA DEX ; \
$03:8F61 10 CC BPL $8F2F ; / X--; loop while X >= 0
$03:8F63 FA PLX ; Restore sprite index
$03:8F64 A0 00 LDY.B #$00 ; \
$03:8F66 A9 01 LDA.B #$01 ; / Y = 0 (8x8 tiles), A = 1 (two tiles)
$03:8F68 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:8F6C 60 RTS ; Return
;;; $8F6D: Table: Boo stream head tiles (BooStreamFrntTiles) ;;;
$03:8F6D .db $88,$8C,$8E,$A8,$AA,$AE,$88,$8C ; Boo stream tiles: index = ((sprite index AND 3) * 2) | animation bit
;;; $8F75: Reflecting fireball main routine (ReflectingFireball) ;;;
;; Draws with $8FF2, then shares the Boo stream movement code (bounces off walls and ceilings).
;; Called by:
;; $03:A1FF: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8F75 20 F2 8F JSR.W $8FF2 ; Draw the fireball ($8FF2)
$03:8F78 80 2A BRA $8FA4 ; Continue with the shared movement code ($8FA4)
;;; $8F7A: Boo stream main routine (BooStream) ;;;
;; Sprite $B0 flies diagonally, bouncing off walls and floors (inverting the speed component). Every 8th frame
;; (staggered per sprite) it spawns a trail tile
;; as extended sprite $0A. Also contains the shared movement code at $8FA4 used by the reflecting
;; fireball.
;; $038FF2: fireball graphics (tile $AC, palette flickers, flips follow the movement direction). $039020:
;; spawn the Boo stream extended sprite.
;; Called by:
;; $03:A208: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:8F7A A9 00 LDA.B #$00 ; \
$03:8F7C B4 B6 LDY RAM_SpriteSpeedX,X ; |
$03:8F7E 10 01 BPL $8F81 ; |
$03:8F80 1A INC A ; } Direction = 1 if X speed is negative, else 0
$03:8F81 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:8F84 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw the sprite (GenericSprGfxRt2)
$03:8F88 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:8F8B A5 14 LDA RAM_FrameCounterB ; \
$03:8F8D 4A LSR ; |
$03:8F8E 4A LSR ; |
$03:8F8F 4A LSR ; |
$03:8F90 4A LSR ; |
$03:8F91 29 01 AND.B #$01 ; } $00 = (frame counter / 16) AND 1 (animation bit)
$03:8F93 85 00 STA $00 ; /
$03:8F95 8A TXA ; \
$03:8F96 29 03 AND.B #$03 ; |
$03:8F98 0A ASL ; } A = ((sprite index AND 3) * 2) | animation bit
$03:8F99 05 00 ORA $00 ; /
$03:8F9B DA PHX ; Save sprite index
$03:8F9C AA TAX ; X = tile table index
$03:8F9D BD 6D 8F LDA.W BooStreamFrntTiles,X ; \
$03:8FA0 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = BooStreamFrntTiles[X]
$03:8FA3 FA PLX ; Restore sprite index
$03:8FA4 BD C8 14 LDA.W $14C8,X ; \
$03:8FA7 C9 08 CMP.B #$08 ; } Return unless sprite status = 8 (normal)
$03:8FA9 D0 46 BNE $8FF1 ; /
$03:8FAB A5 9D LDA RAM_SpritesLocked ; \
$03:8FAD D0 42 BNE $8FF1 ; / Return if sprites are locked
$03:8FAF 8A TXA ; \
$03:8FB0 45 14 EOR RAM_FrameCounterB ; |
$03:8FB2 29 07 AND.B #$07 ; |
$03:8FB4 1D 6C 18 ORA.W RAM_OffscreenVert,X ; } Skip unless (sprite index XOR frame counter) AND 7 = 0 and on-screen vertically
$03:8FB7 D0 09 BNE $8FC2 ; /
$03:8FB9 B5 9E LDA RAM_SpriteNum,X ; \
$03:8FBB C9 B0 CMP.B #$B0 ; } Only sprite $B0 (Boo stream) spawns trail tiles
$03:8FBD D0 03 BNE $8FC2 ; /
$03:8FBF 20 20 90 JSR.W $9020 ; Spawn a Boo stream extended sprite ($9020)
$03:8FC2 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically (no gravity)
$03:8FC6 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:8FCA 22 38 91 01 JSL.L $9138 ; Interact with objects ($9138)
$03:8FCE BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8FD1 29 03 AND.B #$03 ; } Touching a wall (object status bits 0-1)? Otherwise skip
$03:8FD3 F0 07 BEQ $8FDC ; /
$03:8FD5 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:8FD7 49 FF EOR.B #$FF ; |
$03:8FD9 1A INC A ; } X speed = -X speed (bounce)
$03:8FDA 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:8FDC BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:8FDF 29 0C AND.B #$0C ; } Touching floor or ceiling (bits 2-3)? Otherwise skip
$03:8FE1 F0 07 BEQ $8FEA ; /
$03:8FE3 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:8FE5 49 FF EOR.B #$FF ; |
$03:8FE7 1A INC A ; } Y speed = -Y speed (bounce)
$03:8FE8 95 AA STA RAM_SpriteSpeedY,X ; /
$03:8FEA 22 DC A7 01 JSL.L MarioSprInteract ; Interact with Mario (MarioSprInteract)
$03:8FEE 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:8FF1 60 RTS ; Return
$03:8FF2 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw the sprite (GenericSprGfxRt2)
$03:8FF6 A5 14 LDA RAM_FrameCounterB ; \
$03:8FF8 4A LSR ; |
$03:8FF9 4A LSR ; |
$03:8FFA A9 04 LDA.B #$04 ; } A = $04 (palette 2) when bit 1 of [$14] is clear, else $08 (palette 4): flickers
$03:8FFC 90 01 BCC $8FFF ; /
$03:8FFE 0A ASL ; Bit set: A = $08
$03:8FFF B4 B6 LDY RAM_SpriteSpeedX,X ; \
$03:9001 10 02 BPL $9005 ; } Moving left: flip horizontally
$03:9003 49 40 EOR.B #$40 ; /
$03:9005 B4 AA LDY RAM_SpriteSpeedY,X ; \
$03:9007 30 02 BMI $900B ; } Moving down (Y speed >= 0): flip vertically
$03:9009 49 80 EOR.B #$80 ; /
$03:900B 85 00 STA $00 ; $00 = palette and flip bits
$03:900D BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:9010 A9 AC LDA.B #$AC ; \
$03:9012 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $AC
$03:9015 B9 03 03 LDA.W OAM_Prop,Y ; \
$03:9018 29 31 AND.B #$31 ; |
$03:901A 05 00 ORA $00 ; } OAM properties = (old properties AND $31) | $00 (keep priority and tile page)
$03:901C 99 03 03 STA.W OAM_Prop,Y ; /
$03:901F 60 RTS ; Return
$03:9020 A0 0B LDY.B #$0B ; Y = $0B: search the 12 extended sprite slots
$03:9022 B9 F0 17 LDA.W $17F0,Y ; \
$03:9025 F0 10 BEQ $9037 ; |
$03:9027 88 DEY ; } Find an empty extended sprite slot ($17F0 table)
$03:9028 10 F8 BPL $9022 ; /
$03:902A CE 5D 18 DEC.W $185D ; \
$03:902D 10 05 BPL $9034 ; |
$03:902F A9 0B LDA.B #$0B ; |
$03:9031 8D 5D 18 STA.W $185D ; } No free slot: pick one round-robin from [$185D] (counts 11 to 0)
$03:9034 AC 5D 18 LDY.W $185D ; /
$03:9037 A9 0A LDA.B #$0A ; \
$03:9039 99 F0 17 STA.W $17F0,Y ; / Extended sprite number = $0A (Boo stream tile)
$03:903C B5 E4 LDA RAM_SpriteXLo,X ; \
$03:903E 99 08 18 STA.W $1808,Y ; |
$03:9041 BD E0 14 LDA.W RAM_SpriteXHi,X ; } Extended sprite X position = sprite X (low, high)
$03:9044 99 EA 18 STA.W $18EA,Y ; /
$03:9047 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:9049 99 FC 17 STA.W $17FC,Y ; |
$03:904C BD D4 14 LDA.W RAM_SpriteYHi,X ; } Extended sprite Y position = sprite Y (low, high)
$03:904F 99 14 18 STA.W $1814,Y ; /
$03:9052 A9 30 LDA.B #$30 ; \
$03:9054 99 50 18 STA.W $1850,Y ; / Extended sprite timer = $30
$03:9057 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:9059 99 2C 18 STA.W $182C,Y ; / Extended sprite X speed = sprite X speed
$03:905C 60 RTS ; Return
;;; $905D: Table: Fishin' Boo X acceleration (FishinBooAccelX) ;;;
$03:905D .db $01,$FF ; X acceleration by direction (+1, -1)
;;; $905F: Table: Fishin' Boo max X speed (FishinBooMaxSpeedX) ;;;
$03:905F .db $20,$E0 ; Max X speed by direction ($20, $E0)
;;; $9061: Table: Fishin' Boo Y acceleration (FishinBooAccelY) ;;;
$03:9061 .db $01,$FF ; Y acceleration by bob direction (+1, -1)
;;; $9063: Table: Fishin' Boo max Y speed (FishinBooMaxSpeedY) ;;;
$03:9063 .db $10,$F0 ; Max Y speed by bob direction ($10, $F0)
;;; $9065: Fishin' Boo main routine (FishinBoo) ;;;
;; Boo that dangles a fishing hook. Accelerates horizontally toward Mario (away if [$18BF] is set) and bobs
;; vertically by flipping the sign of Y acceleration at the max speed.
;; Faces Mario every 64 frames via a turn timer [$15AC]. [$1602] is the animation frame (1 while turning).
;; Called by:
;; $03:A1F6: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9065 20 80 91 JSR.W FishinBooGfx ; Draw the sprite (FishinBooGfx)
$03:9068 A5 9D LDA RAM_SpritesLocked ; \
$03:906A D0 7E BNE $90EA ; / Return if sprites are locked
$03:906C 22 DC A7 01 JSL.L MarioSprInteract ; Interact with Mario (MarioSprInteract)
$03:9070 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = 0 if Mario is to the right, 1 if to the left (SubHorzPosBnk3)
$03:9073 9E 02 16 STZ.W $1602,X ; [$1602] = 0: normal animation frame
$03:9076 BD AC 15 LDA.W $15AC,X ; \
$03:9079 F0 0B BEQ $9086 ; / Turn timer [$15AC] = 0? Then skip
$03:907B FE 02 16 INC.W $1602,X ; [$1602] = 1: turning animation frame
$03:907E C9 10 CMP.B #$10 ; \
$03:9080 D0 04 BNE $9086 ; / Turn timer = $10 (halfway)? Otherwise skip
$03:9082 98 TYA ; \
$03:9083 9D 7C 15 STA.W RAM_SpriteDir,X ; / Face Mario: direction = Y
$03:9086 8A TXA ; \
$03:9087 0A ASL ; |
$03:9088 0A ASL ; |
$03:9089 0A ASL ; |
$03:908A 0A ASL ; |
$03:908B 65 13 ADC RAM_FrameCounter ; } A = ((sprite index * 16 + [$13]) AND $3F)
$03:908D 29 3F AND.B #$3F ; /
$03:908F 1D AC 15 ORA.W $15AC,X ; A |= turn timer [$15AC]
$03:9092 D0 05 BNE $9099 ; Non-zero: skip
$03:9094 A9 20 LDA.B #$20 ; \
$03:9096 9D AC 15 STA.W $15AC,X ; / Turn timer [$15AC] = $20 (look at Mario again)
$03:9099 AD BF 18 LDA.W $18BF ; \
$03:909C F0 04 BEQ $90A2 ; / [$18BF] = 0? Then chase Mario (flag meaning unclear)
$03:909E 98 TYA ; \
$03:909F 49 01 EOR.B #$01 ; } [$18BF] set: invert Y (move away from Mario)
$03:90A1 A8 TAY ; /
$03:90A2 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:90A4 D9 5F 90 CMP.W FishinBooMaxSpeedX,Y ; } Already at max X speed for this direction? Skip
$03:90A7 F0 06 BEQ $90AF ; /
$03:90A9 18 CLC ; \
$03:90AA 79 5D 90 ADC.W FishinBooAccelX,Y ; } X speed += FishinBooAccelX[Y]
$03:90AD 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:90AF A5 13 LDA RAM_FrameCounter ; \
$03:90B1 29 01 AND.B #$01 ; } Odd frame: skip the vertical update
$03:90B3 D0 14 BNE $90C9 ; /
$03:90B5 B5 C2 LDA RAM_SpriteState,X ; \
$03:90B7 29 01 AND.B #$01 ; } Y = [sprite state] AND 1 (bob direction)
$03:90B9 A8 TAY ; /
$03:90BA B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:90BC 18 CLC ; |
$03:90BD 79 61 90 ADC.W FishinBooAccelY,Y ; } Y speed += FishinBooAccelY[Y]
$03:90C0 95 AA STA RAM_SpriteSpeedY,X ; /
$03:90C2 D9 63 90 CMP.W FishinBooMaxSpeedY,Y ; \
$03:90C5 D0 02 BNE $90C9 ; / Not at max Y speed yet: skip
$03:90C7 F6 C2 INC RAM_SpriteState,X ; State++: reverse the bobbing direction
$03:90C9 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:90CB 48 PHA ; / Save the X speed
$03:90CC AC BF 18 LDY.W $18BF ; \
$03:90CF D0 0B BNE $90DC ; / [$18BF] set: skip the scroll adjustment
$03:90D1 AD BD 17 LDA.W $17BD ; \
$03:90D4 0A ASL ; |
$03:90D5 0A ASL ; |
$03:90D6 0A ASL ; |
$03:90D7 18 CLC ; |
$03:90D8 75 B6 ADC RAM_SpriteSpeedX,X ; } X speed += [$17BD] * 8 (compensates for screen scrolling, probably)
$03:90DA 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:90DC 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move horizontally (no gravity)
$03:90E0 68 PLA ; \
$03:90E1 95 B6 STA RAM_SpriteSpeedX,X ; / Restore the unadjusted X speed
$03:90E3 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically (no gravity)
$03:90E7 20 F3 90 JSR.W $90F3 ; Check the fishing hook against Mario ($90F3)
$03:90EA 60 RTS ; Return
;;; $90EB..90EF: Table: Fishin' Boo hook hitbox X offsets ;;;
;; Low bytes at $0390EB, high bytes at $0390EF, indexed by direction * 2 + frame.
$03:90EB .db $1A,$14,$EE,$F8 ; Hook hitbox X offsets (low), per direction * 2 + frame
$03:90EF .db $00,$00,$FF,$FF ; Hook hitbox X offsets (high)
;;; $90F3: Fishin' Boo hook contact check ;;;
;; Builds a 4x4 hitbox $47 pixels below the sprite at the hook's X offset and hurts Mario if it overlaps.
;; Called by:
;; $03:90E7: Fishin' Boo main routine (FishinBoo)
$03:90F3 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:90F6 0A ASL ; |
$03:90F7 7D 02 16 ADC.W $1602,X ; } Y = direction * 2 + animation frame
$03:90FA A8 TAY ; /
$03:90FB B5 E4 LDA RAM_SpriteXLo,X ; \
$03:90FD 18 CLC ; |
$03:90FE 79 EB 90 ADC.W $90EB,Y ; } $04 = hook hitbox X low = sprite X + $90EB[Y]
$03:9101 85 04 STA $04 ; /
$03:9103 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:9106 79 EF 90 ADC.W $90EF,Y ; } $0A = hook hitbox X high
$03:9109 85 0A STA $0A ; /
$03:910B A9 04 LDA.B #$04 ; \
$03:910D 85 06 STA $06 ; } Hook hitbox width and height ($06, $07) = 4
$03:910F 85 07 STA $07 ; /
$03:9111 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:9113 18 CLC ; |
$03:9114 69 47 ADC.B #$47 ; } $05 = hook hitbox Y low = sprite Y + $47
$03:9116 85 05 STA $05 ; /
$03:9118 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:911B 69 00 ADC.B #$00 ; } $0B = hook hitbox Y high
$03:911D 85 0B STA $0B ; /
$03:911F 22 64 B6 03 JSL.L GetMarioClipping ; Mario hitbox B (GetMarioClipping)
$03:9123 22 2B B7 03 JSL.L CheckForContact ; Check hitbox overlap (CheckForContact)
$03:9127 90 04 BCC $912D ; No contact: return
$03:9129 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
$03:912D 60 RTS ; Return
;;; $912E: Table: Fishin' Boo tile X offsets (FishinBooDispX) ;;;
;; Four sets of 10: (facing left, frame 0), (left, frame 1), (right, frame 0), (right, frame 1).
$03:912E .db $FB,$05,$00,$F2,$FD,$03,$EA,$EA ; X offsets, 10 tiles per set: set 0 (facing left, frame 0) entries 0-7
$03:9136 .db $EA,$EA,$FB,$05,$00,$FA,$FD,$03 ; Set 0 entries 8-9; set 1 (facing left, frame 1) entries 0-5
$03:913E .db $F2,$F2,$F2,$F2,$FB,$05,$00,$0E ; Set 1 entries 6-9; set 2 (facing right, frame 0) entries 0-3
$03:9146 .db $03,$FD,$16,$16,$16,$16,$FB,$05 ; Set 2 entries 4-9; set 3 (facing right, frame 1) entries 0-1
$03:914E .db $00,$06,$03,$FD,$0E,$0E,$0E,$0E ; Set 3 entries 2-9
;;; $9156: Table: Fishin' Boo tile Y offsets (FishinBooDispY) ;;;
$03:9156 .db $0B,$0B,$00,$03,$0F,$0F,$13,$23 ; Y offsets of the 10 tiles (entries 0-7); body, rod, line segments, hook at +$43
$03:915E .db $33,$43 ; Y offsets, entries 8-9
;;; $9160: Table: Fishin' Boo tile numbers (FishinBooTiles1) ;;;
$03:9160 .db $60,$60,$64,$8A,$60,$60,$AC,$AC ; Tile numbers (entries 0-7); entry 9 is replaced by the animated hook
$03:9168 .db $AC,$CE ; Tile numbers, entries 8-9
;;; $916A: Table: Fishin' Boo tile properties (FishinBooGfxProp) ;;;
$03:916A .db $04,$04,$0D,$09,$04,$04,$0D,$0D ; Tile properties (entries 0-7)
$03:9172 .db $0D,$07 ; Tile properties, entries 8-9
;;; $9174: Tables: Fishin' Boo hook animation (FishinBooTiles2) ;;;
;; Hook tiles ($039174), hook flip bits ($039178) and body wobble flip bits ($03917C).
$03:9174 .db $CC,$CE,$CC,$CE ; Hook animation tiles
$03:9178 .db $00,$00,$40,$40 ; Hook animation flip bits
$03:917C .db $00,$40,$C0,$80 ; Body tile flip bits cycled for the wobble animation
;;; $9180: Fishin' Boo graphics (FishinBooGfx) ;;;
;; Draws 10 16x16 tiles: Boo body, rod, three line segments and the animated hook (last tile). The body tiles
;; then get their flip bits cycled for a wobble.
;; Called by:
;; $03:9065: Fishin' Boo main routine (FishinBoo)
$03:9180 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and screen position (GetDrawInfoBnk3)
$03:9183 BD 02 16 LDA.W $1602,X ; \
$03:9186 85 04 STA $04 ; / $04 = animation frame [$1602]
$03:9188 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:918B 85 02 STA $02 ; / $02 = direction
$03:918D DA PHX ; Save sprite index
$03:918E 5A PHY ; Save OAM index
$03:918F A2 09 LDX.B #$09 ; X = 9: ten tiles
$03:9191 A5 01 LDA $01 ; \
$03:9193 18 CLC ; |
$03:9194 7D 56 91 ADC.W FishinBooDispY,X ; } OAM Y = sprite Y + FishinBooDispY[X]
$03:9197 99 01 03 STA.W OAM_DispY,Y ; /
$03:919A 64 03 STZ $03 ; $03 = 0: no extra flip
$03:919C BD 60 91 LDA.W FishinBooTiles1,X ; A = FishinBooTiles1[X]
$03:919F E0 09 CPX.B #$09 ; \
$03:91A1 D0 11 BNE $91B4 ; / Not tile 9 (the hook): skip the animation
$03:91A3 A5 14 LDA RAM_FrameCounterB ; \
$03:91A5 4A LSR ; |
$03:91A6 4A LSR ; |
$03:91A7 DA PHX ; } X = (frame counter / 4) AND 3: hook animation frame
$03:91A8 29 03 AND.B #$03 ; /
$03:91AA AA TAX
$03:91AB BD 78 91 LDA.W $9178,X ; \
$03:91AE 85 03 STA $03 ; / $03 = $9178[X] (hook flip bits)
$03:91B0 BD 74 91 LDA.W FishinBooTiles2,X ; A = FishinBooTiles2[X] (hook tile)
$03:91B3 FA PLX ; Restore loop counter
$03:91B4 99 02 03 STA.W OAM_Tile,Y ; OAM tile = A
$03:91B7 A5 02 LDA $02 ; \
$03:91B9 C9 01 CMP.B #$01 ; / Carry = direction >= 1
$03:91BB BD 6A 91 LDA.W FishinBooGfxProp,X ; A = FishinBooGfxProp[X]
$03:91BE 45 03 EOR $03 ; \
$03:91C0 05 64 ORA $64 ; / Apply hook flip bits and priority [$64]
$03:91C2 B0 02 BCS $91C6 ; \
$03:91C4 49 40 EOR.B #$40 ; / Direction 0: flip horizontally
$03:91C6 99 03 03 STA.W OAM_Prop,Y ; OAM properties = A
$03:91C9 DA PHX ; Save loop counter
$03:91CA A5 04 LDA $04 ; \
$03:91CC F0 05 BEQ $91D3 ; |
$03:91CE 8A TXA ; |
$03:91CF 18 CLC ; } Frame 1: X += $0A (second set of X offsets)
$03:91D0 69 0A ADC.B #$0A ; /
$03:91D2 AA TAX ; X = adjusted index
$03:91D3 A5 02 LDA $02 ; \
$03:91D5 D0 05 BNE $91DC ; |
$03:91D7 8A TXA ; |
$03:91D8 18 CLC ; } Direction 0: X += $14 (mirrored sets)
$03:91D9 69 14 ADC.B #$14 ; /
$03:91DB AA TAX ; X = adjusted index
$03:91DC A5 00 LDA $00 ; \
$03:91DE 18 CLC ; |
$03:91DF 7D 2E 91 ADC.W FishinBooDispX,X ; } OAM X = sprite X + FishinBooDispX[X]
$03:91E2 99 00 03 STA.W OAM_DispX,Y ; /
$03:91E5 FA PLX ; Restore loop counter
$03:91E6 C8 INY ; \
$03:91E7 C8 INY ; |
$03:91E8 C8 INY ; } OAM index += 4
$03:91E9 C8 INY ; /
$03:91EA CA DEX ; \
$03:91EB 10 A4 BPL $9191 ; / X--; loop while X >= 0
$03:91ED A5 14 LDA RAM_FrameCounterB ; \
$03:91EF 4A LSR ; |
$03:91F0 4A LSR ; |
$03:91F1 4A LSR ; } X = (frame counter / 8) AND 3: body wobble index
$03:91F2 29 03 AND.B #$03 ; /
$03:91F4 AA TAX ; X = wobble index
$03:91F5 7A PLY ; Restore OAM index
$03:91F6 BD 7C 91 LDA.W $917C,X ; \
$03:91F9 59 13 03 EOR.W $0313,Y ; } OAM properties of tile slot 4 (offset +$10) ^= $917C[X]
$03:91FC 99 13 03 STA.W $0313,Y ; /
$03:91FF 99 27 03 STA.W $0327,Y ; Same value for tile slot 9 (+$24)
$03:9202 49 C0 EOR.B #$C0 ; \
$03:9204 99 17 03 STA.W $0317,Y ; / A ^= $C0; tile slot 5 (+$14) gets it
$03:9207 99 23 03 STA.W $0323,Y ; Same value for tile slot 8 (+$20)
$03:920A FA PLX ; Restore sprite index
$03:920B A0 02 LDY.B #$02 ; \
$03:920D A9 09 LDA.B #$09 ; / Y = 2 (16x16 tiles), A = 9 (ten tiles)
$03:920F 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:9213 60 RTS ; Return
;;; $9214: Falling spike main routine (FallingSpike) ;;;
;; Draws the spike (tile $E0), shakes it horizontally while the timer [$1540] runs, then moves with gravity
;; and runs a state routine through ExecutePtr (pointer table follows).
;; Called by:
;; $03:A1ED: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9214 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw the sprite (GenericSprGfxRt2)
$03:9218 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:921B A9 E0 LDA.B #$E0 ; \
$03:921D 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $E0
$03:9220 B9 01 03 LDA.W OAM_DispY,Y ; \
$03:9223 3A DEC A ; } OAM Y -= 1
$03:9224 99 01 03 STA.W OAM_DispY,Y ; /
$03:9227 BD 40 15 LDA.W $1540,X ; \
$03:922A F0 0B BEQ $9237 ; / Timer [$1540] = 0: skip shaking
$03:922C 4A LSR ; \
$03:922D 4A LSR ; |
$03:922E 29 01 AND.B #$01 ; |
$03:9230 18 CLC ; } A = ([$1540] / 4) AND 1: shake offset
$03:9231 79 00 03 ADC.W OAM_DispX,Y ; /
$03:9234 99 00 03 STA.W OAM_DispX,Y ; OAM X += A
$03:9237 A5 9D LDA RAM_SpritesLocked ; \
$03:9239 D0 31 BNE $926C ; / Sprites locked: skip to $03926C
$03:923B 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn check when off-screen (SubOffscreen)
$03:923E 22 2A 80 01 JSL.L UpdateSpritePos ; Move with gravity (UpdateSpritePos)
$03:9242 B5 C2 LDA RAM_SpriteState,X ; A = sprite state
$03:9244 22 DF 86 00 JSL.L ExecutePtr ; Run the state routine (ExecutePtr; pointer table follows)
;;; $9248: Falling spike: state handlers (FallingSpikePtrs) ;;;
;; State 0: stand still until Mario is within $40 pixels horizontally, then state 1 with a $40 frame timer.
;; State 1: shake in place while [$1540] runs, then fall (gravity applied earlier in the main routine) and
;; hurt Mario on contact.
$03:9248 4C 92 .dw $924C ; State 0: wait for Mario to come near
$03:924A 62 92 .dw $9262 ; State 1: wait, then fall and hurt Mario on contact
$03:924C 74 AA STZ RAM_SpriteSpeedY,X ; Sprite Y speed = 0 (hangs in place)
$03:924E 20 17 B8 JSR.W SubHorzPosBnk3 ; $0F = horizontal distance to Mario, Y = side
$03:9251 A5 0F LDA $0F ; \
$03:9253 18 CLC ; |
$03:9254 69 40 ADC.B #$40 ; |
$03:9256 C9 80 CMP.B #$80 ; } Return unless Mario is within $40 pixels horizontally ([$0F]+$40 < $80)
$03:9258 B0 07 BCS $9261 ; /
$03:925A F6 C2 INC RAM_SpriteState,X ; Next state: state 1
$03:925C A9 40 LDA.B #$40 ; A = $40
$03:925E 9D 40 15 STA.W $1540,X ; Shake/stall timer [$1540] = $40 frames
$03:9261 60 RTS ; Return
$03:9262 BD 40 15 LDA.W $1540,X ; Timer [$1540] still running?
$03:9265 D0 05 BNE $926C ; Yes: stay put, Y speed = 0
$03:9267 22 DC A7 01 JSL.L MarioSprInteract ; Timer done: check Mario contact (hurts Mario)
$03:926B 60 RTS ; Return
$03:926C 74 AA STZ RAM_SpriteSpeedY,X ; Sprite Y speed = 0 while waiting
$03:926E 60 RTS ; Return
;;; $926F: Table: creating/eating block X speed (CrtEatBlkSpeedX) ;;;
$03:926F .db $10,$F0,$00,$00,$00 ; Speed X by direction: $10 right, $F0 left, 0 down, 0 up, 0 stopped
;;; $9274: Table: creating/eating block Y speed and contact map (CrtEatBlkSpeedY) ;;;
;; Also contains $9279: sprite-block contact bits (1 right, 2 left, 4 down, 8 up) to direction 0-3.
$03:9274 .db $00,$00,$10,$F0,$00 ; Speed Y by direction: 0, 0, $10 down, $F0 up, 0 stopped
$03:9279 .db $00,$00,$01,$00,$02,$00,$00,$00 ; Sprite-block contact bits to direction: 1 right = 0, 2 left = 1, 4 down = 2, 8 up = 3
$03:9281 .db $03,$00,$00 ; (rest of the contact-bit table)
;;; $9284: Creating/eating block main routine (CreateEatBlock) ;;;
;; Moving block that follows a fixed path, either laying down blocks (creating) or erasing them (eating)
;; behind it.
;; Mode in [$151C]: 0 creating, non-zero eating. Path steps come from CrtEatBlkData1 (submap non-zero) or
;; CrtEatBlkData2 (submap 0).
;; Step byte: high nibble = blocks to travel, low 2 bits = direction, $FF = end of path (sprite removed).
;; Eating mode follows the existing trail of blocks.
;; Called by:
;; $03:A211: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9284 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw sprite (generic 16x16 gfx)
$03:9288 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = index into sprite OAM
$03:928B B9 01 03 LDA.W OAM_DispY,Y ; \
$03:928E 3A DEC A ; } OAM Y position -= 1
$03:928F 99 01 03 STA.W OAM_DispY,Y ; /
$03:9292 A9 2E LDA.B #$2E ; A = $2E
$03:9294 99 02 03 STA.W OAM_Tile,Y ; OAM tile = $2E
$03:9297 B9 03 03 LDA.W OAM_Prop,Y ; \
$03:929A 29 3F AND.B #$3F ; } OAM properties: clear Y-flip and X-flip bits
$03:929C 99 03 03 STA.W OAM_Prop,Y ; /
$03:929F A0 02 LDY.B #$02 ; Y = 2: 16x16 tile size
$03:92A1 A9 00 LDA.B #$00 ; A = 0: draw 1 tile
$03:92A3 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write (size, offscreen check)
$03:92A7 A0 04 LDY.B #$04 ; Y = 4: direction 4 = stopped
$03:92A9 AD 09 19 LDA.W $1909 ; [$1909] = $FF? (probably 'block frozen' flag)
$03:92AC C9 FF CMP.B #$FF ; Compare with $FF
$03:92AE F0 10 BEQ $92C0 ; Yes: keep Y = 4, no sound
$03:92B0 A5 13 LDA RAM_FrameCounter ; \
$03:92B2 29 03 AND.B #$03 ; |
$03:92B4 05 9D ORA RAM_SpritesLocked ; } Every 4th frame while sprites unlocked: play sound
$03:92B6 D0 05 BNE $92BD ; /
$03:92B8 A9 04 LDA.B #$04 ; Sound effect $04
$03:92BA 8D FA 1D STA.W $1DFA ; Play it via $1DFA
$03:92BD BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = sprite direction (0 right, 1 left, 2 down, 3 up)
$03:92C0 A5 9D LDA RAM_SpritesLocked ; Sprites locked?
$03:92C2 D0 67 BNE $932B ; Yes: return
$03:92C4 B9 6F 92 LDA.W CrtEatBlkSpeedX,Y ; \
$03:92C7 95 B6 STA RAM_SpriteSpeedX,X ; / Speed X = CrtEatBlkSpeedX[direction]
$03:92C9 B9 74 92 LDA.W CrtEatBlkSpeedY,Y ; \
$03:92CC 95 AA STA RAM_SpriteSpeedY,X ; / Speed Y = CrtEatBlkSpeedY[direction]
$03:92CE 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move Y position by speed (no gravity)
$03:92D2 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move X position by speed (no gravity)
$03:92D6 9E 28 15 STZ.W $1528,X ; Clear [$1528,X] (so Mario is not carried like on a platform)
$03:92D9 22 4F B4 01 JSL.L InvisBlkMainRt ; Act as a solid invisible block for Mario
$03:92DD AD 09 19 LDA.W $1909 ; [$1909] = $FF? (frozen)
$03:92E0 C9 FF CMP.B #$FF ; Compare with $FF
$03:92E2 F0 47 BEQ $932B ; Yes: return
$03:92E4 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:92E6 15 E4 ORA RAM_SpriteXLo,X ; |
$03:92E8 29 0F AND.B #$0F ; } Only act when sprite X and Y are both aligned to a 16 pixel boundary
$03:92EA D0 3F BNE $932B ; /
$03:92EC BD 1C 15 LDA.W $151C,X ; [$151C] = mode: 0 creating, non-zero eating
$03:92EF D0 3B BNE $932C ; Eating: go to $03932C
$03:92F1 DE 70 15 DEC.W $1570,X ; Creating: decrement step timer [$1570]
$03:92F4 30 02 BMI $92F8 ; Negative: fetch next step
$03:92F6 D0 27 BNE $931F ; Still counting: just make the block
$03:92F8 AC B3 0D LDY.W $0DB3 ; Y = current player's submap index [$0DB3]
$03:92FB B9 11 1F LDA.W $1F11,Y ; A = overworld submap [$1F11]
$03:92FE C9 01 CMP.B #$01 ; Carry set if submap >= 1
$03:9300 BC 34 15 LDY.W $1534,X ; Y = path step index [$1534]
$03:9303 FE 34 15 INC.W $1534,X ; Next step index
$03:9306 B9 A4 93 LDA.W CrtEatBlkData1,Y ; A = step from CrtEatBlkData1
$03:9309 B0 03 BCS $930E ; Submap non-zero: use data 1
$03:930B B9 EF 93 LDA.W CrtEatBlkData2,Y ; Submap 0: A = step from CrtEatBlkData2
$03:930E 9D 02 16 STA.W $1602,X ; Remember step byte in [$1602] ($FF = end of path)
$03:9311 48 PHA ; Save step byte
$03:9312 4A LSR ; \
$03:9313 4A LSR ; |
$03:9314 4A LSR ; |
$03:9315 4A LSR ; } Blocks left in this step [$1570] = upper nibble of step byte
$03:9316 9D 70 15 STA.W $1570,X ; /
$03:9319 68 PLA ; Restore step byte
$03:931A 29 03 AND.B #$03 ; \
$03:931C 9D 7C 15 STA.W RAM_SpriteDir,X ; / Direction = step byte & 3
$03:931F A9 0D LDA.B #$0D ; A = $0D: block to generate
$03:9321 20 8B 93 JSR.W GenTileFromSpr1 ; Generate block at sprite position
$03:9324 BD 02 16 LDA.W $1602,X ; A = step byte
$03:9327 C9 FF CMP.B #$FF ; Compare with $FF
$03:9329 F0 5C BEQ $9387 ; End of path: remove sprite
$03:932B 60 RTS ; Return
$03:932C A9 02 LDA.B #$02 ; Eating mode: A = $02, block to generate (empty tile)
$03:932E 20 8B 93 JSR.W GenTileFromSpr1 ; Erase the block under the sprite
$03:9331 A9 01 LDA.B #$01 ; \
$03:9333 95 B6 STA RAM_SpriteSpeedX,X ; } Speed X = Speed Y = 1 (probe down and right)
$03:9335 95 AA STA RAM_SpriteSpeedY,X ; /
$03:9337 22 38 91 01 JSL.L $9138 ; Sprite-block interaction
$03:933B BD 88 15 LDA.W RAM_SprObjStatus,X ; A = contact bits from probe
$03:933E 48 PHA ; Save them
$03:933F A9 FF LDA.B #$FF ; \
$03:9341 95 B6 STA RAM_SpriteSpeedX,X ; } Speed X = Speed Y = $FF (probe up and left)
$03:9343 95 AA STA RAM_SpriteSpeedY,X ; /
$03:9345 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:9347 48 PHA ; / Save X low
$03:9348 38 SEC ; \
$03:9349 E9 01 SBC.B #$01 ; } X position low -= 1
$03:934B 95 E4 STA RAM_SpriteXLo,X ; /
$03:934D BD E0 14 LDA.W RAM_SpriteXHi,X ; A = X high
$03:9350 48 PHA ; Save X high
$03:9351 E9 00 SBC.B #$00 ; X high -= borrow
$03:9353 9D E0 14 STA.W RAM_SpriteXHi,X ; Store X high
$03:9356 B5 D8 LDA RAM_SpriteYLo,X ; A = Y low
$03:9358 48 PHA ; Save Y low
$03:9359 38 SEC ; \
$03:935A E9 01 SBC.B #$01 ; } Y position low -= 1
$03:935C 95 D8 STA RAM_SpriteYLo,X ; /
$03:935E BD D4 14 LDA.W RAM_SpriteYHi,X ; A = Y high
$03:9361 48 PHA ; Save Y high
$03:9362 E9 00 SBC.B #$00 ; Y high -= borrow
$03:9364 9D D4 14 STA.W RAM_SpriteYHi,X ; Store Y high
$03:9367 22 38 91 01 JSL.L $9138 ; Sprite-block interaction at the offset position
$03:936B 68 PLA ; Restore Y high
$03:936C 9D D4 14 STA.W RAM_SpriteYHi,X ; Store Y high
$03:936F 68 PLA ; Restore Y low
$03:9370 95 D8 STA RAM_SpriteYLo,X ; Store Y low
$03:9372 68 PLA ; Restore X high
$03:9373 9D E0 14 STA.W RAM_SpriteXHi,X ; Store X high
$03:9376 68 PLA ; Restore X low
$03:9377 95 E4 STA RAM_SpriteXLo,X ; Store X low
$03:9379 68 PLA ; Restore first probe contact bits
$03:937A 1D 88 15 ORA.W RAM_SprObjStatus,X ; Combine with second probe bits
$03:937D F0 08 BEQ $9387 ; No block touching: remove sprite
$03:937F A8 TAY ; Y = combined contact bits
$03:9380 B9 79 92 LDA.W $9279,Y ; A = direction for those bits ($9279)
$03:9383 9D 7C 15 STA.W RAM_SpriteDir,X ; Set sprite direction
$03:9386 60 RTS ; Return
$03:9387 9E C8 14 STZ.W $14C8,X ; Sprite status = 0 (erase sprite)
$03:938A 60 RTS ; Return
;;; $938B: Generate block at sprite position (GenTileFromSpr1) ;;;
;; Parameters: A: block number to generate. Uses sprite X/Y position.
;; Called by:
;; $03:9321: Creating/eating block main routine (CreateEatBlock)
;; $03:932E: Creating/eating block main routine (CreateEatBlock)
$03:938B 85 9C STA RAM_BlockBlock ; Block to generate = A
$03:938D B5 E4 LDA RAM_SpriteXLo,X ; \
$03:938F 85 9A STA RAM_BlockXLo ; / Block X position low = sprite X low
$03:9391 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:9394 85 9B STA RAM_BlockXHi ; / Block X position high = sprite X high
$03:9396 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:9398 85 98 STA RAM_BlockYLo ; / Block Y position low = sprite Y low
$03:939A BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:939D 85 99 STA RAM_BlockYHi ; / Block Y position high = sprite Y high
$03:939F 22 B0 BE 00 JSL.L GenerateTile ; Generate the block
$03:93A3 60 RTS ; Return
;;; $93A4: Table: creating block path (submap non-zero) (CrtEatBlkData1) ;;;
;; Step bytes: high nibble = blocks to travel, low 2 bits = direction (0 right, 1 left, 2 down, 3 up), $FF =
;; end.
$03:93A4 .db $10,$13,$10,$13,$10,$13,$10,$13 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93AC .db $10,$13,$10,$13,$10,$13,$10,$13 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93B4 .db $F0,$F0,$20,$12,$10,$12,$10,$12 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93BC .db $10,$12,$10,$12,$10,$12,$10,$12 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93C4 .db $D0,$C3,$F1,$21,$22,$F1,$F1,$51 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93CC .db $43,$10,$13,$10,$13,$10,$13,$F0 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93D4 .db $F0,$F0,$60,$32,$60,$32,$71,$32 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93DC .db $60,$32,$61,$32,$70,$33,$10,$33 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93E4 .db $10,$33,$10,$33,$10,$33,$F0,$10 ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
$03:93EC .db $F2,$52,$FF ; Path steps: high nibble = blocks to travel, low 2 bits = direction, $FF = end
;;; $93EF: Table: creating block path (submap 0) (CrtEatBlkData2) ;;;
$03:93EF .db $80,$13,$10,$13,$10,$13,$10,$13 ; Path steps for submap 0 (same format as CrtEatBlkData1)
$03:93F7 .db $60,$23,$20,$23,$B0,$22,$A1,$22 ; Path steps (same format)
$03:93FF .db $A0,$22,$A1,$22,$C0,$13,$10,$13 ; Path steps (same format)
$03:9407 .db $10,$13,$10,$13,$10,$13,$10,$13 ; Path steps (same format)
$03:940F .db $10,$13,$F0,$F0,$F0,$52,$50,$33 ; Path steps (same format)
$03:9417 .db $50,$32,$50,$33,$50,$22,$50,$33 ; Path steps (same format)
$03:941F .db $F0,$50,$82,$FF ; Path steps (same format)
;;; $9423: Wooden spike main routine (WoodenSpike) ;;;
;; Sprites $AC/$AD. Draws, handles Mario contact, then cycles through 4 states (rise, pause, drop, pause).
;; Called by:
;; $03:A21E: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9423 20 CF 94 JSR.W WoodSpikeGfx ; Draw the spike
$03:9426 A5 9D LDA RAM_SpritesLocked ; Sprites locked?
$03:9428 D0 16 BNE $9440 ; Yes: return
$03:942A 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Process only while on screen
$03:942D 20 88 94 JSR.W $9488 ; Handle Mario contact
$03:9430 B5 C2 LDA RAM_SpriteState,X ; A = state
$03:9432 29 03 AND.B #$03 ; State & 3 (4 phase cycle)
$03:9434 22 DF 86 00 JSL.L ExecutePtr ; Run the state routine
;;; $9438: Pointer table: wooden spike states (WoodenSpikePtrs) ;;;
$03:9438 58 94 .dw $9458 ; State 0: rise
$03:943A 4E 94 .dw $944E ; State 1: pause at top
$03:943C 41 94 .dw $9441 ; State 2: drop
$03:943E 6B 94 .dw $946B ; State 3: pause at bottom
$03:9440 60 RTS ; Return
$03:9441 BD 40 15 LDA.W $1540,X ; State 2: timer [$1540] running?
$03:9444 F0 04 BEQ $944A ; No: go to $03944A
$03:9446 A9 20 LDA.B #$20 ; A = $20 (fast drop speed)
$03:9448 80 2B BRA $9475 ; Move with this speed
$03:944A A9 30 LDA.B #$30 ; A = $30: pause length
$03:944C 80 17 BRA SetTimerNextState ; Set timer and go to next state
$03:944E BD 40 15 LDA.W $1540,X ; State 1: timer running?
$03:9451 D0 04 BNE $9457 ; Yes: wait
$03:9453 A9 18 LDA.B #$18 ; A = $18: length of next phase
$03:9455 80 0E BRA SetTimerNextState ; Set timer and go to next state
$03:9457 60 RTS ; Return
$03:9458 BD 40 15 LDA.W $1540,X ; State 0: timer running?
$03:945B F0 06 BEQ $9463 ; No: go to $039463
$03:945D A9 F0 LDA.B #$F0 ; A = $F0 (rise speed)
$03:945F 20 75 94 JSR.W $9475 ; Move with this speed
$03:9462 60 RTS ; Return
$03:9463 A9 30 LDA.B #$30 ; A = $30: length of next phase
;;; $9465: Set timer and go to next state (SetTimerNextState) ;;;
;; Parameters: A: value for timer [$1540]. Increments the sprite state.
$03:9465 9D 40 15 STA.W $1540,X ; Timer [$1540] = A
$03:9468 F6 C2 INC RAM_SpriteState,X ; Next state
$03:946A 60 RTS ; Return
$03:946B BD 40 15 LDA.W $1540,X ; State 3: timer running?
$03:946E D0 04 BNE $9474 ; Yes: wait
$03:9470 A9 2F LDA.B #$2F ; A = $2F: length of next phase
$03:9472 80 F1 BRA SetTimerNextState ; Set timer and go to next state (wraps to state 0)
$03:9474 60 RTS ; Return
$03:9475 BC 1C 15 LDY.W $151C,X ; Y = [$151C] (0 = normal, non-zero = reverse direction)
$03:9478 F0 03 BEQ $947D ; Normal: keep speed
$03:947A 49 FF EOR.B #$FF ; \
$03:947C 1A INC A ; / Reverse: negate A
$03:947D 95 AA STA RAM_SpriteSpeedY,X ; Sprite Y speed = A
$03:947F 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move Y position by speed (no gravity)
$03:9483 60 RTS ; Return
;;; $9484..9486: Table: wooden spike push direction ;;;
$03:9484 .db $01,$FF ; Push Mario X: +1 (Mario on right), -1 (Mario on left)
$03:9486 .db $00,$FF ; High byte of that push: $00, $FF
;;; $9488: Wooden spike Mario contact ;;;
;; Hurts Mario if he touches the center of the spike; otherwise pushes him sideways by 1 pixel and zeroes his
;; X speed.
;; Called by:
;; $03:942D: Wooden spike main routine (WoodenSpike)
$03:9488 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario contact
$03:948C 90 22 BCC $94B0 ; No contact: return
$03:948E 20 17 B8 JSR.W SubHorzPosBnk3 ; $0F = horizontal distance to Mario, Y = side
$03:9491 A5 0F LDA $0F ; \
$03:9493 18 CLC ; |
$03:9494 69 04 ADC.B #$04 ; |
$03:9496 C9 08 CMP.B #$08 ; } Mario within 4 pixels of the sprite's center ([$0F]+4 < 8)?
$03:9498 B0 05 BCS $949F ; /
$03:949A 22 B7 F5 00 JSL.L HurtMario ; Yes: hurt Mario
$03:949E 60 RTS ; Return
$03:949F A5 94 LDA RAM_MarioXPos ; \
$03:94A1 18 CLC ; |
$03:94A2 79 84 94 ADC.W $9484,Y ; } Mario X position low += $9484[side] (push sideways)
$03:94A5 85 94 STA RAM_MarioXPos ; /
$03:94A7 A5 95 LDA RAM_MarioXPosHi ; \
$03:94A9 79 86 94 ADC.W $9486,Y ; } Mario X position high += $9486[side]
$03:94AC 85 95 STA RAM_MarioXPosHi ; /
$03:94AE 64 7B STZ RAM_MarioSpeedX ; Mario X speed = 0
$03:94B0 60 RTS ; Return
;;; $94B1: Table: wooden spike tile Y offsets (WoodSpikeDispY) ;;;
$03:94B1 .db $00,$10,$20,$30,$40,$40,$30,$20 ; Tile Y offsets, sprite $AC (5 tiles, then sprite $AD)
$03:94B9 .db $10,$00 ; (sprite $AD, continued)
;;; $94BB: Table: wooden spike tile numbers (WoodSpikeTiles) ;;;
$03:94BB .db $6A,$6A,$6A,$6A,$4A,$6A,$6A,$6A ; Tile numbers: $6A, tip $4A
$03:94C3 .db $6A,$4A ; (sprite $AD, continued)
;;; $94C5: Table: wooden spike tile properties (WoodSpikeGfxProp) ;;;
$03:94C5 .db $81,$81,$81,$81,$81,$01,$01,$01 ; Tile properties: $81 flipped vertically, $01 normal
$03:94CD .db $01,$01 ; (sprite $AD, continued)
;;; $94CF: Wooden spike graphics: setup (WoodSpikeGfx) ;;;
;; Sprite $AD uses the second half of the tables.
;; Called by:
;; $03:9423: Wooden spike main routine (WoodenSpike)
$03:94CF 20 60 B7 JSR.W GetDrawInfoBnk3 ; Y = OAM index, $00 = X, $01 = Y
$03:94D2 64 02 STZ $02 ; $02 = 0: table offset for first spike type
$03:94D4 B5 9E LDA RAM_SpriteNum,X ; \
$03:94D6 C9 AD CMP.B #$AD ; |
$03:94D8 D0 04 BNE $94DE ; |
$03:94DA A9 05 LDA.B #$05 ; } $02 = 5 if sprite number is $AD (second spike type)
$03:94DC 85 02 STA $02 ; /
$03:94DE DA PHX ; Save sprite index
$03:94DF A2 04 LDX.B #$04 ; X = 4: draw 5 tiles
;;; $94E1: Wooden spike graphics: draw 5 tiles (WoodSpikeGfxLoopSt) ;;;
;; Draws 5 16x16 tiles in a column.
$03:94E1 DA PHX ; Save tile counter
$03:94E2 8A TXA ; \
$03:94E3 18 CLC ; |
$03:94E4 65 02 ADC $02 ; } X = tile counter + [$02]: table index
$03:94E6 AA TAX ; /
$03:94E7 A5 00 LDA $00 ; \
$03:94E9 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite X
$03:94EC A5 01 LDA $01 ; \
$03:94EE 18 CLC ; |
$03:94EF 7D B1 94 ADC.W WoodSpikeDispY,X ; } OAM Y = sprite Y + WoodSpikeDispY[X]
$03:94F2 99 01 03 STA.W OAM_DispY,Y ; /
$03:94F5 BD BB 94 LDA.W WoodSpikeTiles,X ; \
$03:94F8 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = WoodSpikeTiles[X]
$03:94FB BD C5 94 LDA.W WoodSpikeGfxProp,X ; \
$03:94FE 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = WoodSpikeGfxProp[X]
$03:9501 C8 INY ; \
$03:9502 C8 INY ; |
$03:9503 C8 INY ; } Next OAM slot
$03:9504 C8 INY ; /
$03:9505 FA PLX ; Restore tile counter
$03:9506 CA DEX ; Next tile
$03:9507 10 D8 BPL WoodSpikeGfxLoopSt ; Loop for 5 tiles
$03:9509 FA PLX ; Restore sprite index
$03:950A A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:950C A9 04 LDA.B #$04 ; A = 4: 5 tiles
$03:950E 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:9512 60 RTS ; Return
;;; $9513: Table: Rex X speed (RexSpeed) ;;;
$03:9513 .db $08,$F8,$10,$F0 ; Rex X speed: $08 right, $F8 left, then $10, $F0 when half squashed
;;; $9517: Rex main routine (RexMainRt) ;;;
;; Draws Rex. Only runs while status is 8 and sprites are unlocked. Counts down the remains timer when
;; flattened.
;; Called by:
;; $03:A227: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9517 20 7E 96 JSR.W RexGfxRt ; Draw Rex
$03:951A BD C8 14 LDA.W $14C8,X ; A = sprite status
$03:951D C9 08 CMP.B #$08 ; Normal (8)?
$03:951F D0 12 BNE RexReturn ; No (spin kill, star kill, ...): return
$03:9521 A5 9D LDA RAM_SpritesLocked ; Sprites locked?
$03:9523 D0 0E BNE RexReturn ; Yes: return
$03:9525 BD 58 15 LDA.W $1558,X ; A = timer [$1558] for showing squashed remains
$03:9528 F0 0A BEQ RexAlive ; Zero: Rex alive
$03:952A 9D D0 15 STA.W $15D0,X ; Copy timer to [$15D0]
$03:952D 3A DEC A ; Timer - 1
$03:952E D0 03 BNE RexReturn ; Remains still showing: return
$03:9530 9E C8 14 STZ.W $14C8,X ; Last frame of remains: sprite status = 0 (erase)
;;; $9533: Return (RexReturn) ;;;
$03:9533 60 RTS ; Return
;;; $9534: Rex: walk and animate (RexAlive) ;;;
;; Animates, walks (speed depends on stomp state) and turns at walls, then interacts with sprites and Mario.
$03:9534 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Process only while on screen
$03:9537 FE 70 15 INC.W $1570,X ; Frame counter [$1570]++
$03:953A BD 70 15 LDA.W $1570,X ; A = [$1570]
$03:953D 4A LSR ; \
$03:953E 4A LSR ; / A = [$1570] / 4
$03:953F B4 C2 LDY RAM_SpriteState,X ; Y = state (number of stomps)
$03:9541 F0 07 BEQ $954A ; Not stomped: go to $03954A
$03:9543 29 01 AND.B #$01 ; Stomped: A = frame & 1
$03:9545 18 CLC ; Clear carry
$03:9546 69 03 ADC.B #$03 ; +3: squashed walk frames 3 and 4
$03:9548 80 03 BRA $954D ; Store frame
$03:954A 4A LSR ; Normal: A = [$1570] / 8
$03:954B 29 01 AND.B #$01 ; Walk frame 0 or 1
$03:954D 9D 02 16 STA.W $1602,X ; Store frame in [$1602]
$03:9550 BD 88 15 LDA.W RAM_SprObjStatus,X ; A = object contact flags
$03:9553 29 04 AND.B #$04 ; On ground (bit 2)?
$03:9555 F0 12 BEQ RexInAir ; No: go to RexInAir
$03:9557 A9 10 LDA.B #$10 ; \
$03:9559 95 AA STA RAM_SpriteSpeedY,X ; / Sprite Y speed = $10 (stay on the ground)
$03:955B BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = direction
$03:955E B5 C2 LDA RAM_SpriteState,X ; A = state
$03:9560 F0 02 BEQ RexNoAdjustSpeed ; Not stomped: normal speed
$03:9562 C8 INY ; \
$03:9563 C8 INY ; / Y += 2: use squashed speeds
;;; $9564: Rex: set X speed (RexNoAdjustSpeed) ;;;
$03:9564 B9 13 95 LDA.W RexSpeed,Y ; A = RexSpeed[Y]
$03:9567 95 B6 STA RAM_SpriteSpeedX,X ; Sprite X speed = A
;;; $9569: Rex: update position (RexInAir) ;;;
$03:9569 BD E2 1F LDA.W $1FE2,X ; A = half-squash timer [$1FE2]
$03:956C D0 04 BNE RexHalfSmushed ; Non-zero: skip movement
$03:956E 22 2A 80 01 JSL.L UpdateSpritePos ; Update position from speeds (with gravity and block interaction)
;;; $9572: Rex: wall turn and Mario contact (RexHalfSmushed) ;;;
;; Turns at walls, then handles contact with Mario: star kills, stomp, or hurts Mario.
$03:9572 BD 88 15 LDA.W RAM_SprObjStatus,X ; A = object contact flags
$03:9575 29 03 AND.B #$03 ; \
$03:9577 F0 08 BEQ $9581 ; / Touching a wall on left or right?
$03:9579 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:957C 49 01 EOR.B #$01 ; } Yes: flip direction
$03:957E 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:9581 22 32 80 01 JSL.L SprSprInteract ; Interact with other sprites
$03:9585 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario contact
$03:9589 90 52 BCC NoRexContact ; No contact: return
$03:958B AD 90 14 LDA.W $1490 ; A = Mario star timer [$1490]
$03:958E D0 62 BNE RexStarKill ; Star active: kill Rex
$03:9590 BD 4C 15 LDA.W RAM_DisableInter,X ; A = Rex contact disable timer
$03:9593 D0 48 BNE NoRexContact ; Non-zero: ignore contact
$03:9595 A9 08 LDA.B #$08 ; \
$03:9597 9D 4C 15 STA.W RAM_DisableInter,X ; / Contact disable timer = 8 frames
$03:959A A5 7D LDA RAM_MarioSpeedY ; \
$03:959C C9 10 CMP.B #$10 ; / Mario Y speed < $10 (not falling onto Rex)?
$03:959E 30 2A BMI RexWins ; Yes: Rex hurts Mario
;;; $95A0: Mario stomps Rex (MarioBeatsRex) ;;;
;; Gives points, bounces Mario. Spin jump or Yoshi kills Rex outright; first stomp half-squashes, second
;; flattens.
$03:95A0 20 28 96 JSR.W RexPoints ; Give points
$03:95A3 22 33 AA 01 JSL.L BoostMarioSpeed ; Bounce Mario
$03:95A7 22 99 AB 01 JSL.L DisplayContactGfx ; Show contact star
$03:95AB AD 0D 14 LDA.W RAM_IsSpinJump ; \
$03:95AE 0D 7A 18 ORA.W RAM_OnYoshi ; / Mario spin jumping or on Yoshi?
$03:95B1 D0 2B BNE RexSpinKill ; Yes: spin kill
$03:95B3 F6 C2 INC RAM_SpriteState,X ; Stomp count++
$03:95B5 B5 C2 LDA RAM_SpriteState,X ; A = stomp count
$03:95B7 C9 02 CMP.B #$02 ; Second stomp?
$03:95B9 D0 06 BNE SmushRex ; No: half squash
$03:95BB A9 20 LDA.B #$20 ; \
$03:95BD 9D 58 15 STA.W $1558,X ; / Timer for showing squashed remains [$1558] = $20
$03:95C0 60 RTS ; Return
;;; $95C1: Half squash Rex (SmushRex) ;;;
$03:95C1 A9 0C LDA.B #$0C ; \
$03:95C3 9D E2 1F STA.W $1FE2,X ; / Half-squash timer [$1FE2] = $0C
$03:95C6 9E 62 16 STZ.W RAM_Tweaker1662,X ; Sprite clipping = 0 (smaller hitbox)
$03:95C9 60 RTS ; Return
;;; $95CA: Rex hurts Mario (RexWins) ;;;
$03:95CA AD 97 14 LDA.W $1497 ; \
$03:95CD 0D 7A 18 ORA.W RAM_OnYoshi ; } Mario invincible after a hit or on Yoshi: skip
$03:95D0 D0 0B BNE NoRexContact ; /
$03:95D2 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side of Mario
$03:95D5 98 TYA ; A = Y
$03:95D6 9D 7C 15 STA.W RAM_SpriteDir,X ; Rex turns towards Mario
$03:95D9 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
;;; $95DD: Return (NoRexContact) ;;;
$03:95DD 60 RTS ; Return
;;; $95DE: Rex killed by spin jump (RexSpinKill) ;;;
$03:95DE A9 04 LDA.B #$04 ; \
$03:95E0 9D C8 14 STA.W $14C8,X ; / Sprite status = 4 (killed by spin jump)
$03:95E3 A9 1F LDA.B #$1F ; \
$03:95E5 9D 40 15 STA.W $1540,X ; / Timer [$1540] = $1F (spin kill animation)
$03:95E8 22 3B FC 07 JSL.L $FC3B ; Spawn star particles
$03:95EC A9 08 LDA.B #$08 ; \
$03:95EE 8D F9 1D STA.W $1DF9 ; / Sound effect $08
$03:95F1 60 RTS ; Return
;;; $95F2: Rex killed by star (RexStarKill) ;;;
$03:95F2 A9 02 LDA.B #$02 ; \
$03:95F4 9D C8 14 STA.W $14C8,X ; / Sprite status = 2 (killed by star)
$03:95F7 A9 D0 LDA.B #$D0 ; \
$03:95F9 95 AA STA RAM_SpriteSpeedY,X ; / Sprite Y speed = $D0 (jump up)
$03:95FB 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side of Mario
$03:95FE B9 25 96 LDA.W RexKilledSpeed,Y ; \
$03:9601 95 B6 STA RAM_SpriteSpeedX,X ; / Sprite X speed = RexKilledSpeed[Y] (away from Mario)
$03:9603 EE D2 18 INC.W $18D2 ; Star kill counter [$18D2]++
$03:9606 AD D2 18 LDA.W $18D2 ; A = counter
$03:9609 C9 08 CMP.B #$08 ; Compare with 8
$03:960B 90 05 BCC $9612 ; < 8: keep
$03:960D A9 08 LDA.B #$08 ; \
$03:960F 8D D2 18 STA.W $18D2 ; / Counter = 8 (max)
$03:9612 22 E5 AC 02 JSL.L GivePoints ; Give points
$03:9616 AC D2 18 LDY.W $18D2 ; Y = counter
$03:9619 C0 08 CPY.B #$08 ; Compare with 8
$03:961B B0 06 BCS $9623 ; 8 or more: no sound
$03:961D B9 FF 7F LDA.W $7FFF,Y ; \
$03:9620 8D F9 1D STA.W $1DF9 ; / Sound effect = table at $03:8000 (rising pitch)
$03:9623 60 RTS ; Return
$03:9624 60 RTS ; Unreferenced return
;;; $9625: Table: Rex X speed when killed (RexKilledSpeed) ;;;
$03:9625 .db $F0,$10 ; X speed when killed by star: $F0 left, $10 right
$03:9627 60 RTS ; Unreferenced return
;;; $9628: Give points for stomp (RexPoints) ;;;
;; Gives points based on the consecutive stomp counter [$1697] and plays the matching sound.
;; Called by:
;; $03:95A0: Mario stomps Rex (MarioBeatsRex)
$03:9628 5A PHY ; Save Y
$03:9629 AD 97 16 LDA.W $1697 ; A = stomp counter [$1697]
$03:962C 18 CLC ; Clear carry
$03:962D 7D 26 16 ADC.W $1626,X ; + sprite's own counter [$1626]
$03:9630 EE 97 16 INC.W $1697 ; Stomp counter++
$03:9633 A8 TAY ; Y = A
$03:9634 C8 INY ; Y + 1
$03:9635 C0 08 CPY.B #$08 ; Compare with 8
$03:9637 B0 06 BCS $963F ; 8 or more: no sound
$03:9639 B9 FF 7F LDA.W $7FFF,Y ; \
$03:963C 8D F9 1D STA.W $1DF9 ; / Sound effect = table at $03:8000 (rising pitch)
$03:963F 98 TYA ; A = Y
$03:9640 C9 08 CMP.B #$08 ; Compare with 8
$03:9642 90 02 BCC $9646 ; < 8: keep
$03:9644 A9 08 LDA.B #$08 ; A = 8 (max)
$03:9646 22 E5 AC 02 JSL.L GivePoints ; Give points
$03:964A 7A PLY ; Restore Y
$03:964B 60 RTS ; Return
;;; $964C: Table: Rex tile X offsets (RexTileDispX) ;;;
$03:964C .db $FC,$00,$FC,$00,$FE,$00,$00,$00 ; Tile X offsets, 2 tiles per frame, facing left; the next 12 bytes face right
$03:9654 .db $00,$00,$00,$08,$04,$00,$04,$00 ; (frames 3-5, facing left)
$03:965C .db $02,$00,$00,$00,$00,$00,$08,$00 ; (facing right)
;;; $9664: Table: Rex tile Y offsets (RexTileDispY) ;;;
$03:9664 .db $F1,$00,$F0,$00,$F8,$00,$00,$00 ; Tile Y offsets, 2 tiles per frame
$03:966C .db $00,$00,$08,$08 ; (frames 4-5)
;;; $9670: Table: Rex tile numbers (RexTiles) ;;;
$03:9670 .db $8A,$AA,$8A,$AC,$8A,$AA,$8C,$8C ; Tile numbers, 2 per frame
$03:9678 .db $A8,$A8,$A2,$B2 ; (frames 4-5)
;;; $967C: Table: Rex tile properties (RexGfxProp) ;;;
$03:967C .db $47,$07 ; Tile properties: $47 facing left (X flip), $07 facing right
;;; $967E: Rex graphics routine (RexGfxRt) ;;;
;; Chooses frame: 5 when remains timer is set, 2 when half squashed. Draws 2 tiles (second row of tables for
;; facing right).
;; Called by:
;; $03:9517: Rex main routine (RexMainRt)
$03:967E BD 58 15 LDA.W $1558,X ; A = remains timer [$1558]
$03:9681 F0 05 BEQ RexGfxAlive ; Zero: alive
$03:9683 A9 05 LDA.B #$05 ; Frame = 5 (squashed flat)
$03:9685 9D 02 16 STA.W $1602,X ; Store frame
;;; $9688: Rex graphics: half squashed frame (RexGfxAlive) ;;;
$03:9688 BD E2 1F LDA.W $1FE2,X ; A = half-squash timer [$1FE2]
$03:968B F0 05 BEQ RexNotHalfSmushed ; Zero: skip
$03:968D A9 02 LDA.B #$02 ; Frame = 2 (half squashed)
$03:968F 9D 02 16 STA.W $1602,X ; Store frame
;;; $9692: Rex graphics: draw tiles (RexNotHalfSmushed) ;;;
$03:9692 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw position
$03:9695 BD 02 16 LDA.W $1602,X ; \
$03:9698 0A ASL ; } $03 = frame * 2 (index of first tile of frame)
$03:9699 85 03 STA $03 ; /
$03:969B BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:969E 85 02 STA $02 ; / $02 = direction
$03:96A0 DA PHX ; Save sprite index
$03:96A1 A2 01 LDX.B #$01 ; X = 1: two tiles per frame
;;; $96A3: Rex graphics: tile loop (RexGfxLoopStart) ;;;
$03:96A3 DA PHX ; Save tile counter
$03:96A4 8A TXA ; \
$03:96A5 05 03 ORA $03 ; / A = frame start + tile counter (index of this tile)
$03:96A7 48 PHA ; Save it
$03:96A8 A6 02 LDX $02 ; X = direction
$03:96AA D0 03 BNE RexFaceLeft ; Facing left: no offset
$03:96AC 18 CLC ; \
$03:96AD 69 0C ADC.B #$0C ; / Facing right: +12 to use the second row of X offsets
;;; $96AF: Rex graphics: write tile (RexFaceLeft) ;;;
$03:96AF AA TAX ; X = offset index
$03:96B0 A5 00 LDA $00 ; \
$03:96B2 18 CLC ; |
$03:96B3 7D 4C 96 ADC.W RexTileDispX,X ; } OAM X = sprite X + RexTileDispX[X]
$03:96B6 99 00 03 STA.W OAM_DispX,Y ; /
$03:96B9 FA PLX ; Restore tile index
$03:96BA A5 01 LDA $01 ; \
$03:96BC 18 CLC ; |
$03:96BD 7D 64 96 ADC.W RexTileDispY,X ; } OAM Y = sprite Y + RexTileDispY[X]
$03:96C0 99 01 03 STA.W OAM_DispY,Y ; /
$03:96C3 BD 70 96 LDA.W RexTiles,X ; \
$03:96C6 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = RexTiles[X]
$03:96C9 A6 02 LDX $02 ; \
$03:96CB BD 7C 96 LDA.W RexGfxProp,X ; |
$03:96CE 05 64 ORA $64 ; } OAM properties = RexGfxProp[dir] | [$64] (level priority)
$03:96D0 99 03 03 STA.W OAM_Prop,Y ; /
$03:96D3 98 TYA ; \
$03:96D4 4A LSR ; } A = OAM index / 4
$03:96D5 4A LSR ; /
$03:96D6 A6 03 LDX $03 ; \
$03:96D8 E0 0A CPX.B #$0A ; } X = A; carry set if frame start >= $0A (frames 5 only)
$03:96DA AA TAX ; /
$03:96DB A9 00 LDA.B #$00 ; A = 0: 8x8 tile size
$03:96DD B0 02 BCS Rex8x8Tile ; Frame 5: use 8x8
$03:96DF A9 02 LDA.B #$02 ; A = 2: 16x16 tile size
;;; $96E1: Rex graphics: store tile size (Rex8x8Tile) ;;;
$03:96E1 9D 60 04 STA.W OAM_TileSize,X ; Store in OAM size table
$03:96E4 FA PLX ; Restore tile counter
$03:96E5 C8 INY ; \
$03:96E6 C8 INY ; |
$03:96E7 C8 INY ; } Next OAM slot
$03:96E8 C8 INY ; /
$03:96E9 CA DEX ; Next tile
$03:96EA 10 B7 BPL RexGfxLoopStart ; Loop for 2 tiles
$03:96EC FA PLX ; Restore sprite index
$03:96ED A0 FF LDY.B #$FF ; Y = $FF: sizes already written
$03:96EF A9 01 LDA.B #$01 ; A = 1: 2 tiles
$03:96F1 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:96F5 60 RTS ; Return
;;; $96F6: Fishbone main routine (Fishbone) ;;;
;; Swims horizontally; sometimes opens its mouth. Alternates between accelerating and slowing down.
;; Called by:
;; $03:A230: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:96F6 20 8C 97 JSR.W FishboneGfx ; Draw Fishbone
$03:96F9 A5 9D LDA RAM_SpritesLocked ; Sprites locked?
$03:96FB D0 2D BNE $972A ; Yes: return
$03:96FD 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Process only while on screen
$03:9700 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario contact
$03:9704 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move X position by speed
$03:9708 8A TXA ; \
$03:9709 0A ASL ; |
$03:970A 0A ASL ; |
$03:970B 0A ASL ; } A = sprite index * 16
$03:970C 0A ASL ; /
$03:970D 65 13 ADC RAM_FrameCounter ; + frame counter
$03:970F 29 7F AND.B #$7F ; Every 128 frames
$03:9711 D0 0D BNE $9720 ; Not now: go on
$03:9713 22 F9 AC 01 JSL.L GetRand ; Random number
$03:9717 29 01 AND.B #$01 ; Bit 0
$03:9719 D0 05 BNE $9720 ; Half the time: skip
$03:971B A9 0C LDA.B #$0C ; A = $0C
$03:971D 9D 58 15 STA.W $1558,X ; Mouth open timer [$1558] = $0C
$03:9720 B5 C2 LDA RAM_SpriteState,X ; A = state
$03:9722 22 DF 86 00 JSL.L ExecutePtr ; Run state routine
;;; $9726: Pointer table: Fishbone states (FishbonePtrs) ;;;
$03:9726 2F 97 .dw $972F ; State 0: swim and accelerate
$03:9728 5E 97 .dw $975E ; State 1: slow down
$03:972A 60 RTS ; Return
;;; $972B: Table: Fishbone max X speed (FishboneMaxSpeed) ;;;
$03:972B .db $10,$F0 ; Max X speed: $10 right, $F0 left
;;; $972D: Table: Fishbone states and acceleration (FishboneAcceler) ;;;
;; State 0 accelerates up to max speed; state 1 slows to a stop. Each lasts $30 frames.
$03:972D .db $01,$FF ; Acceleration: +1 right, -1 left
$03:972F FE 70 15 INC.W $1570,X ; Animation counter [$1570]++
$03:9732 BD 70 15 LDA.W $1570,X ; A = counter
$03:9735 EA NOP ; No operation
$03:9736 4A LSR ; \
$03:9737 29 01 AND.B #$01 ; } Animation frame [$1602] = (counter / 2) & 1
$03:9739 9D 02 16 STA.W $1602,X ; /
$03:973C BD 40 15 LDA.W $1540,X ; A = timer [$1540]
$03:973F F0 15 BEQ $9756 ; Zero: next state
$03:9741 29 01 AND.B #$01 ; Odd timer value?
$03:9743 D0 10 BNE $9755 ; Yes: skip this frame
$03:9745 BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = direction
$03:9748 B5 B6 LDA RAM_SpriteSpeedX,X ; A = X speed
$03:974A D9 2B 97 CMP.W FishboneMaxSpeed,Y ; At max speed for this direction?
$03:974D F0 06 BEQ $9755 ; Yes: return
$03:974F 18 CLC ; \
$03:9750 79 2D 97 ADC.W FishboneAcceler,Y ; } X speed += FishboneAcceler[direction]
$03:9753 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:9755 60 RTS ; Return
$03:9756 F6 C2 INC RAM_SpriteState,X ; \
$03:9758 A9 30 LDA.B #$30 ; } State 1, timer [$1540] = $30
$03:975A 9D 40 15 STA.W $1540,X ; /
$03:975D 60 RTS ; Return
$03:975E 9E 02 16 STZ.W $1602,X ; Animation frame = 0
$03:9761 BD 40 15 LDA.W $1540,X ; A = timer
$03:9764 F0 10 BEQ $9776 ; Zero: back to state 0
$03:9766 29 03 AND.B #$03 ; Timer & 3
$03:9768 D0 0B BNE $9775 ; Only every 4th frame
$03:976A B5 B6 LDA RAM_SpriteSpeedX,X ; A = X speed
$03:976C F0 07 BEQ $9775 ; Zero: done
$03:976E 10 03 BPL $9773 ; Positive: go to $039773
$03:9770 F6 B6 INC RAM_SpriteSpeedX,X ; Negative: speed++ (towards 0)
$03:9772 60 RTS ; Return
$03:9773 D6 B6 DEC RAM_SpriteSpeedX,X ; Positive: speed-- (towards 0)
$03:9775 60 RTS ; Return
$03:9776 74 C2 STZ RAM_SpriteState,X ; \
$03:9778 A9 30 LDA.B #$30 ; } State 0, timer [$1540] = $30
$03:977A 9D 40 15 STA.W $1540,X ; /
$03:977D 60 RTS ; Return
;;; $977E: Table: Fishbone tail X offsets (FishboneDispX) ;;;
$03:977E .db $F8,$F8,$10,$10 ; Tail tile X offsets by direction and tile
;;; $9782: Table: Fishbone tail Y offsets (FishboneDispY) ;;;
$03:9782 .db $00,$08 ; Tail tile Y offsets: 0, 8
;;; $9784: Table: Fishbone tail properties (FishboneGfxProp) ;;;
$03:9784 .db $4D,$CD,$0D,$8D ; Tail tile properties: facing left $4D/$CD, right $0D/$8D
;;; $9788: Table: Fishbone tail tile numbers (FishboneTailTiles) ;;;
$03:9788 .db $A3,$A3,$B3,$B3 ; Tail tile numbers by animation frame: $A3 / $B3
;;; $978C: Fishbone graphics, and aim at Mario routine (FishboneGfx) ;;;
;; Draws head tile and 2 tail tiles. Also contains $97F9 at $0397F9: computes X/Y speeds aiming at
;; Mario.
;; Parameters: A: speed. Returns: $00: X speed, $01: Y speed.
;; Called by:
;; $03:96F6: Fishbone main routine (Fishbone)
$03:978C 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw head (generic 16x16 gfx)
$03:9790 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:9793 BD 58 15 LDA.W $1558,X ; A = mouth timer
$03:9796 C9 01 CMP.B #$01 ; Compare with 1
$03:9798 A9 A6 LDA.B #$A6 ; A = $A6: mouth closed tile
$03:979A 90 02 BCC $979E ; Timer = 0: keep
$03:979C A9 A8 LDA.B #$A8 ; A = $A8: mouth open tile
$03:979E 99 02 03 STA.W OAM_Tile,Y ; OAM tile = A
$03:97A1 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw position
$03:97A4 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:97A7 0A ASL ; } $02 = direction * 2
$03:97A8 85 02 STA $02 ; /
$03:97AA BD 02 16 LDA.W $1602,X ; \
$03:97AD 0A ASL ; } $03 = frame * 2
$03:97AE 85 03 STA $03 ; /
$03:97B0 BD EA 15 LDA.W RAM_SprOAMIndex,X ; \
$03:97B3 18 CLC ; |
$03:97B4 69 04 ADC.B #$04 ; } OAM index += 4 (next slot, after head)
$03:97B6 9D EA 15 STA.W RAM_SprOAMIndex,X ; /
$03:97B9 A8 TAY ; Y = OAM index
$03:97BA DA PHX ; Save sprite index
$03:97BB A2 01 LDX.B #$01 ; X = 1: two tail tiles
$03:97BD A5 01 LDA $01 ; \
$03:97BF 18 CLC ; |
$03:97C0 7D 82 97 ADC.W FishboneDispY,X ; } OAM Y = sprite Y + FishboneDispY[X]
$03:97C3 99 01 03 STA.W OAM_DispY,Y ; /
$03:97C6 DA PHX ; Save tile counter
$03:97C7 8A TXA ; \
$03:97C8 05 02 ORA $02 ; } X = tile counter | direction offset
$03:97CA AA TAX ; /
$03:97CB A5 00 LDA $00 ; \
$03:97CD 18 CLC ; |
$03:97CE 7D 7E 97 ADC.W FishboneDispX,X ; } OAM X = sprite X + FishboneDispX[X]
$03:97D1 99 00 03 STA.W OAM_DispX,Y ; /
$03:97D4 BD 84 97 LDA.W FishboneGfxProp,X ; \
$03:97D7 05 64 ORA $64 ; } OAM properties = FishboneGfxProp[X] | [$64]
$03:97D9 99 03 03 STA.W OAM_Prop,Y ; /
$03:97DC 68 PLA ; \
$03:97DD 48 PHA ; |
$03:97DE 05 03 ORA $03 ; } X = tile counter | frame offset
$03:97E0 AA TAX ; /
$03:97E1 BD 88 97 LDA.W FishboneTailTiles,X ; \
$03:97E4 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = FishboneTailTiles[X]
$03:97E7 FA PLX ; Restore tile counter
$03:97E8 C8 INY ; \
$03:97E9 C8 INY ; |
$03:97EA C8 INY ; } Next OAM slot
$03:97EB C8 INY ; /
$03:97EC CA DEX ; Next tile
$03:97ED 10 CE BPL $97BD ; Loop for 2 tiles
$03:97EF FA PLX ; Restore sprite index
$03:97F0 A0 00 LDY.B #$00 ; Y = 0: 8x8 tiles
$03:97F2 A9 02 LDA.B #$02 ; A = 2: 3 tiles
$03:97F4 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:97F8 60 RTS ; Return
$03:97F9 85 01 STA $01 ; Aim at Mario. A: speed. Save to $01
$03:97FB DA PHX ; Save X
$03:97FC 5A PHY ; Save Y
$03:97FD 20 29 B8 JSR.W SubVertPosBnk3 ; Vertical distance: $0E, Y = side
$03:9800 84 02 STY $02 ; $02 = vertical side
$03:9802 A5 0E LDA $0E ; A = vertical distance
$03:9804 10 05 BPL $980B ; Positive: keep
$03:9806 49 FF EOR.B #$FF ; \
$03:9808 18 CLC ; } Negate
$03:9809 69 01 ADC.B #$01 ; /
$03:980B 85 0C STA $0C ; $0C = |vertical distance|
$03:980D 20 17 B8 JSR.W SubHorzPosBnk3 ; Horizontal distance: $0F, Y = side
$03:9810 84 03 STY $03 ; $03 = horizontal side
$03:9812 A5 0F LDA $0F ; A = horizontal distance
$03:9814 10 05 BPL $981B ; Positive: keep
$03:9816 49 FF EOR.B #$FF ; \
$03:9818 18 CLC ; } Negate
$03:9819 69 01 ADC.B #$01 ; /
$03:981B 85 0D STA $0D ; $0D = |horizontal distance|
$03:981D A0 00 LDY.B #$00 ; Y = 0: no swap
$03:981F A5 0D LDA $0D ; A = |horizontal|
$03:9821 C5 0C CMP $0C ; Compare with |vertical|
$03:9823 B0 09 BCS $982E ; Horizontal is larger: no swap
$03:9825 C8 INY ; Y = 1: swapped
$03:9826 48 PHA ; \
$03:9827 A5 0C LDA $0C ; |
$03:9829 85 0D STA $0D ; |
$03:982B 68 PLA ; } Swap $0C and $0D
$03:982C 85 0C STA $0C ; /
$03:982E A9 00 LDA.B #$00 ; \
$03:9830 85 0B STA $0B ; } $0B = $00 = 0
$03:9832 85 00 STA $00 ; /
$03:9834 A6 01 LDX $01 ; X = speed [$01]
$03:9836 A5 0B LDA $0B ; \
$03:9838 18 CLC ; |
$03:9839 65 0C ADC $0C ; |
$03:983B C5 0D CMP $0D ; } $0B += $0C; if >= $0D...
$03:983D 90 04 BCC $9843 ; /
$03:983F E5 0D SBC $0D ; \
$03:9841 E6 00 INC $00 ; / ...$0B -= $0D and $00++
$03:9843 85 0B STA $0B ; Store $0B
$03:9845 CA DEX ; Count down
$03:9846 D0 EE BNE $9836 ; Loop speed times
$03:9848 98 TYA ; A = swap flag
$03:9849 F0 0A BEQ $9855 ; Not swapped: skip
$03:984B A5 00 LDA $00 ; \
$03:984D 48 PHA ; |
$03:984E A5 01 LDA $01 ; |
$03:9850 85 00 STA $00 ; |
$03:9852 68 PLA ; } Swap $00 and $01
$03:9853 85 01 STA $01 ; /
$03:9855 A5 00 LDA $00 ; A = $00
$03:9857 A4 02 LDY $02 ; Y = vertical side
$03:9859 F0 07 BEQ $9862 ; Zero: keep
$03:985B 49 FF EOR.B #$FF ; \
$03:985D 18 CLC ; |
$03:985E 69 01 ADC.B #$01 ; } Negate $00
$03:9860 85 00 STA $00 ; /
$03:9862 A5 01 LDA $01 ; A = $01
$03:9864 A4 03 LDY $03 ; Y = horizontal side
$03:9866 F0 07 BEQ $986F ; Zero: keep
$03:9868 49 FF EOR.B #$FF ; \
$03:986A 18 CLC ; |
$03:986B 69 01 ADC.B #$01 ; } Negate $01
$03:986D 85 01 STA $01 ; /
$03:986F 7A PLY ; Restore Y
$03:9870 FA PLX ; Restore X
$03:9871 60 RTS ; Return
;;; $9872: Reznor init (ReznorInit) ;;;
;; Slot 7 sets up the Reznor room. Rotation counter [$1570] = random.
;; Called by:
;; $01:8789: Init: Reznor (InitReznor)
$03:9872 E0 07 CPX.B #$07 ; Sprite slot 7?
$03:9874 D0 08 BNE $987E ; No: skip
$03:9876 A9 04 LDA.B #$04 ; A = 4
$03:9878 95 C2 STA RAM_SpriteState,X ; State = 4 (only slot 7)
$03:987A 22 7D DD 03 JSL.L $DD7D ; Set up Reznor room (palette, scrolling, bridge)
$03:987E 22 F9 AC 01 JSL.L GetRand ; Random number
$03:9882 9D 70 15 STA.W $1570,X ; Rotation counter [$1570] = random
$03:9885 6B RTL ; Return
;;; $9886: Table: Reznor start positions low (ReznorStartPosLo) ;;;
$03:9886 .db $00,$80,$00,$80 ; Reznor start positions, low byte (4 Reznors)
;;; $988A: Table: Reznor start positions high (ReznorStartPosHi) ;;;
$03:988A .db $00,$00,$01,$01 ; Reznor start positions, high byte
;;; $988E: Table: Reznor rebound X speed (ReboundSpeedX) ;;;
$03:988E .db $20,$E0 ; Bounce X speed: $20, $E0
;;; $9890: Reznor main routine: start (Reznor) ;;;
;; Called by:
;; $03:A239: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9890 EE 0F 14 INC.W $140F ; Reznor frame counter [$140F]++
$03:9893 A5 9D LDA RAM_SpritesLocked ; Sprites locked?
$03:9895 F0 03 BEQ ReznorNotLocked ; No: continue
$03:9897 4C 7B 9A JMP.W DrawReznor ; Only draw
;;; $989A: Reznor: unlocked, slot 7 setup (ReznorNotLocked) ;;;
;; Slot 7 breaks the bridge when necessary.
$03:989A E0 07 CPX.B #$07 ; Sprite slot 7?
$03:989C D0 72 BNE $9910 ; No: go to $039910
$03:989E DA PHX ; Save X
$03:989F 22 0C D7 03 JSL.L $D70C ; Break bridge when needed
;;; $98A3: Reznor ring: sign and level end (ReznorSignCode) ;;;
;; Second half of the Reznor main code (entered for every Reznor/platform slot). Only sprite slot 7 runs this
;; part: it positions the Reznor sign,
;; advances the ring angle [$37,$36] (0-$1FF) by one per frame and, once the level end timer [$163E,X] reaches
;; 1, ends the fight:
;; stops Mario walking, starts the end of level timer [$1493] and plays the clear music ([$1DFB] = $0B).
$03:98A3 A9 80 LDA.B #$80 ; \
$03:98A5 85 2A STA $2A ; |
$03:98A7 64 2B STZ $2B ; / Circle centre X: [$2A]/[$2B] = $0080 (also the Mode 7 center X)
$03:98A9 A2 00 LDX.B #$00 ; X = 0: sprite slot 0 gets the sign position
$03:98AB A9 C0 LDA.B #$C0 ; \
$03:98AD 85 E4 STA RAM_SpriteXLo ; |
$03:98AF 9C E0 14 STZ.W RAM_SpriteXHi ; / Slot 0 X position = $00C0 (position of the Reznor sign)
$03:98B2 A9 B2 LDA.B #$B2 ; \
$03:98B4 85 D8 STA RAM_SpriteYLo ; |
$03:98B6 9C D4 14 STZ.W RAM_SpriteYHi ; / Slot 0 Y position = $00B2
$03:98B9 A9 2C LDA.B #$2C ; A = $2C: value for $1BA2 (read by $DF2E, purpose unclear)
$03:98BB 8D A2 1B STA.W $1BA2 ; [$1BA2] = $2C
$03:98BE 22 DF DE 03 JSL.L $DEDF ; Apply position change to the Reznor sign ($DEDF, Mode 7 related)
$03:98C2 FA PLX ; Restore X = sprite index
$03:98C3 C2 20 REP #$20 ; A 16-bit
$03:98C5 A5 36 LDA $36 ; \
$03:98C7 18 CLC ; |
$03:98C8 69 01 00 ADC.W #$0001 ; } [$36] = ([$36] + 1) & $01FF: advance the Reznor ring angle one step per frame
$03:98CB 29 FF 01 AND.W #$01FF ; |
$03:98CE 85 36 STA $36 ; /
$03:98D0 E2 20 SEP #$20 ; A 8-bit
$03:98D2 E0 07 CPX.B #$07 ; Only sprite slot 7 runs the level end logic
$03:98D4 D0 3A BNE $9910 ; Other slots: skip to the status check
$03:98D6 BD 3E 16 LDA.W $163E,X ; A = level end timer [$163E,X]
$03:98D9 F0 11 BEQ ReznorNoLevelEnd ; Timer not set: go check whether all Reznors are dead
$03:98DB 3A DEC A ; Timer - 1
$03:98DC D0 32 BNE $9910 ; Not yet 1: skip
$03:98DE CE C6 13 DEC.W $13C6 ; [$13C6]--: stop Mario from walking at level end (cutscene state)
$03:98E1 A9 FF LDA.B #$FF ; \
$03:98E3 8D 93 14 STA.W $1493 ; / End of level timer [$1493] = $FF (time before returning to the overworld)
$03:98E6 A9 0B LDA.B #$0B ; \
$03:98E8 8D FB 1D STA.W $1DFB ; / Music request [$1DFB] = $0B (probably the boss defeated music)
$03:98EB 60 RTS ; Return
;;; $98EC: Reznor: check all Reznors dead (ReznorNoLevelEnd) ;;;
;; Adds the four dead flags. When all four Reznors are dead, sets the level end timer [$163E,X] = $90, removes
;; all other sprites and clears the extended sprites.
;; Then, for every Reznor slot, places the Reznor and its platform on the ring (see ReznorAlive) or skips to
;; drawing if the status is not 8.
$03:98EC AD 23 15 LDA.W RAM_Reznor4Dead ; \
$03:98EF 18 CLC ; |
$03:98F0 6D 22 15 ADC.W RAM_Reznor3Dead ; |
$03:98F3 6D 21 15 ADC.W RAM_Reznor2Dead ; |
$03:98F6 6D 20 15 ADC.W RAM_Reznor1Dead ; } A = number of dead Reznors (sum of the four dead flags); all four dead?
$03:98F9 C9 04 CMP.B #$04 ; |
$03:98FB D0 13 BNE $9910 ; Not all four dead: skip
$03:98FD A9 90 LDA.B #$90 ; \
$03:98FF 9D 3E 16 STA.W $163E,X ; / Level end timer [$163E,X] = $90: set when all Reznors are dead
$03:9902 22 C8 A6 03 JSL.L KillMostSprites ; Remove all other sprites (KillMostSprites)
$03:9906 A0 07 LDY.B #$07 ; \
$03:9908 A9 00 LDA.B #$00 ; |
$03:990A 99 0B 17 STA.W RAM_ExSpriteNum,Y ; |
$03:990D 88 DEY ; } Clear all 8 extended sprite slots (removes fireballs)
$03:990E 10 FA BPL $990A ; /
$03:9910 BD C8 14 LDA.W $14C8,X ; A = sprite status
$03:9913 C9 08 CMP.B #$08 ; Status 8 (normal)?
$03:9915 F0 03 BEQ $991A ; Yes: continue
$03:9917 4C 7B 9A JMP.W DrawReznor ; Not normal: just draw
$03:991A 8A TXA ; \
$03:991B 29 03 AND.B #$03 ; } Y = Reznor number (sprite slot AND 3)
$03:991D A8 TAY ; /
$03:991E A5 36 LDA $36 ; \
$03:9920 18 CLC ; |
$03:9921 79 86 98 ADC.W ReznorStartPosLo,Y ; |
$03:9924 85 00 STA $00 ; |
$03:9926 A5 37 LDA $37 ; } $01/$00 = ([$36] + start angle [Y]) & $01FF: this Reznor's position on the ring
$03:9928 79 8A 98 ADC.W ReznorStartPosHi,Y ; |
$03:992B 29 01 AND.B #$01 ; |
$03:992D 85 01 STA $01 ; /
$03:992F C2 30 REP #$30 ; A and index 16-bit
$03:9931 A5 00 LDA $00 ; \
$03:9933 49 FF 01 EOR.W #$01FF ; } $00 = -$00 (mod $200): Reznors turn clockwise
$03:9936 1A INC A ; |
$03:9937 85 00 STA $00 ; /
$03:9939 18 CLC ; \
$03:993A 69 80 00 ADC.W #$0080 ; } $02 = $00 + $80 (mod $200): angle shifted a quarter turn for the other axis
$03:993D 29 FF 01 AND.W #$01FF ; |
$03:9940 85 02 STA $02 ; /
$03:9942 A5 00 LDA $00 ; \
$03:9944 29 FF 00 AND.W #$00FF ; |
$03:9947 0A ASL ; |
$03:9948 AA TAX ; |
$03:9949 BF DB F7 07 LDA.L CircleCoords,X ; Read a CircleCoords entry (sine, $0000-$0100)
$03:994D 85 04 STA $04 ; $04 = sine value for $00
$03:994F A5 02 LDA $02 ; \
$03:9951 29 FF 00 AND.W #$00FF ; |
$03:9954 0A ASL ; |
$03:9955 AA TAX ; / X = ([$02] & $FF) * 2: index into CircleCoords
$03:9956 BF DB F7 07 LDA.L CircleCoords,X ; Read a CircleCoords entry (cosine, $0000-$0100)
$03:995A 85 06 STA $06 ; $06 = value for angle $02 (a quarter turn later)
$03:995C E2 30 SEP #$30 ; A and index 8-bit
$03:995E A5 04 LDA $04 ; A = low byte of the sine value
$03:9960 8D 02 42 STA.W $4202 ; Hardware multiply: multiplicand A
$03:9963 A9 38 LDA.B #$38 ; A = $38: ring radius in pixels
$03:9965 A4 05 LDY $05 ; Y = high byte of the value ($01 only if value is $100)
$03:9967 D0 0F BNE $9978 ; Value = $100: use A = $38 directly
$03:9969 8D 03 42 STA.W $4203 ; Multiplier B
$03:996C EA NOP ; \
$03:996D EA NOP ; |
$03:996E EA NOP ; |
$03:996F EA NOP ; / Wait for the multiplication result
$03:9970 0E 16 42 ASL.W $4216 ; Product * 2 (carry gets the top bit of the low byte)
$03:9973 AD 17 42 LDA.W $4217 ; A = high byte of product
$03:9976 69 00 ADC.B #$00 ; Round: A = value * $38 / $100 (high byte of the product plus bit 7 of the low byte)
$03:9978 46 01 LSR $01 ; $01 >>= 1: carry = ring half (bit 8 of the angle)
$03:997A 90 03 BCC $997F ; Carry clear: positive offset
$03:997C 49 FF EOR.B #$FF ; \
$03:997E 1A INC A ; / Second half of the ring: negate A
$03:997F 85 04 STA $04 ; $04 = X offset from the ring centre
$03:9981 A5 06 LDA $06 ; A = low byte of the second sine value
$03:9983 8D 02 42 STA.W $4202 ; Hardware multiply: multiplicand A
$03:9986 A9 38 LDA.B #$38 ; A = $38: ring radius
$03:9988 A4 07 LDY $07 ; Y = high byte of the value
$03:998A D0 0F BNE $999B ; Value = $100: use A = $38 directly
$03:998C 8D 03 42 STA.W $4203 ; Multiplier B
$03:998F EA NOP ; \
$03:9990 EA NOP ; |
$03:9991 EA NOP ; |
$03:9992 EA NOP ; / Wait for the multiplication result
$03:9993 0E 16 42 ASL.W $4216 ; Product * 2
$03:9996 AD 17 42 LDA.W $4217 ; A = high byte of product
$03:9999 69 00 ADC.B #$00 ; Add carry (rounding)
$03:999B 46 03 LSR $03 ; $03 >>= 1: carry = ring half
$03:999D 90 03 BCC $99A2 ; Carry clear: positive offset
$03:999F 49 FF EOR.B #$FF ; \
$03:99A1 1A INC A ; / Second half of the ring: negate A
$03:99A2 85 06 STA $06 ; $06 = Y offset from the ring centre
$03:99A4 AE E9 15 LDX.W $15E9 ; X = sprite index
$03:99A7 B5 E4 LDA RAM_SpriteXLo,X ; A = old X position low
$03:99A9 48 PHA ; Save it (for the movement delta)
$03:99AA 64 00 STZ $00 ; $00 = 0: high byte for sign extension
$03:99AC A5 04 LDA $04 ; A = X offset
$03:99AE 10 02 BPL $99B2 ; Positive: keep $00 = 0
$03:99B0 C6 00 DEC $00 ; Negative: $00 = $FF (sign extend)
$03:99B2 18 CLC ; Clear carry
$03:99B3 65 2A ADC $2A ; Add centre X low byte [$2A]
$03:99B5 08 PHP ; Save carry
$03:99B6 18 CLC ; Clear carry
$03:99B7 69 40 ADC.B #$40 ; Plus $40: X offset of the ring
$03:99B9 95 E4 STA RAM_SpriteXLo,X ; Sprite X position low
$03:99BB A5 2B LDA $2B ; Centre X high byte [$2B]
$03:99BD 69 00 ADC.B #$00 ; Add carry from the +$40
$03:99BF 28 PLP ; Restore carry from the first add
$03:99C0 65 00 ADC $00 ; Add sign extension
$03:99C2 9D E0 14 STA.W RAM_SpriteXHi,X ; Sprite X position high
$03:99C5 68 PLA ; \
$03:99C6 38 SEC ; |
$03:99C7 F5 E4 SBC RAM_SpriteXLo,X ; |
$03:99C9 49 FF EOR.B #$FF ; } $1528,X = old X - new X, negated: X movement this frame (carries Mario)
$03:99CB 1A INC A ; |
$03:99CC 9D 28 15 STA.W $1528,X ; /
$03:99CF 64 01 STZ $01 ; $01 = 0: high byte for sign extension
$03:99D1 A5 06 LDA $06 ; A = Y offset
$03:99D3 10 02 BPL $99D7 ; Positive: keep $01 = 0
$03:99D5 C6 01 DEC $01 ; Negative: $01 = $FF
$03:99D7 18 CLC ; Clear carry
$03:99D8 65 2C ADC $2C ; Add centre Y low byte [$2C]
$03:99DA 08 PHP ; Save carry
$03:99DB 69 20 ADC.B #$20 ; Plus $20: Y offset of the ring on screen
$03:99DD 95 D8 STA RAM_SpriteYLo,X ; Sprite Y position low
$03:99DF A5 2D LDA $2D ; Centre Y high byte [$2D]
$03:99E1 69 00 ADC.B #$00 ; Add carry
$03:99E3 28 PLP ; Restore carry from the first add
$03:99E4 65 01 ADC $01 ; Add sign extension
$03:99E6 9D D4 14 STA.W RAM_SpriteYHi,X ; Sprite Y position high
$03:99E9 BD 1C 15 LDA.W $151C,X ; \
$03:99EC F0 07 BEQ ReznorAlive ; / Reznor already killed ([$151C,X] != 0)? If not, go to ReznorAlive
$03:99EE 22 4F B4 01 JSL.L InvisBlkMainRt ; Dead: make its platform solid (InvisBlkMainRt)
$03:99F2 4C 7B 9A JMP.W DrawReznor ; Draw only the platform
;;; $99F5: Reznor: fire timer (ReznorAlive) ;;;
;; Reached for a live Reznor. Counts [$1570,X] every frame (unless turning) and every 256 frames sets the
;; firing timer [$1558,X] = $40.
$03:99F5 A5 13 LDA RAM_FrameCounter ; A = frame counter
$03:99F7 29 00 AND.B #$00 ; Mask $00: always 0 (fires on every frame check)
$03:99F9 1D AC 15 ORA.W $15AC,X ; OR turning timer [$15AC,X]
$03:99FC D0 12 BNE NoSetRznrFireTime ; Turning: do not start firing
$03:99FE FE 70 15 INC.W $1570,X ; [$1570,X]++: firing counter
$03:9A01 BD 70 15 LDA.W $1570,X ; A = firing counter
$03:9A04 C9 00 CMP.B #$00 ; Counter wrapped to 0 (every 256 frames)?
$03:9A06 D0 08 BNE NoSetRznrFireTime ; No: skip
$03:9A08 9E 70 15 STZ.W $1570,X ; Reset the firing counter
$03:9A0B A9 40 LDA.B #$40 ; \
$03:9A0D 9D 58 15 STA.W $1558,X ; / Firing timer [$1558,X] = $40: show the firing image, fireball at $20
;;; $9A10: Reznor: face Mario (NoSetRznrFireTime) ;;;
;; Every 64 frames (staggered per slot), if not firing or turning, faces Mario; a direction change starts the
;; turning timer [$15AC,X] = $0A.
$03:9A10 8A TXA ; \
$03:9A11 0A ASL ; |
$03:9A12 0A ASL ; |
$03:9A13 0A ASL ; |
$03:9A14 0A ASL ; } A = (slot * 16 + [$14]) & $3F: staggers each Reznor, every 64 frames
$03:9A15 65 14 ADC RAM_FrameCounterB ; |
$03:9A17 29 3F AND.B #$3F ; /
$03:9A19 1D 58 15 ORA.W $1558,X ; OR firing timer
$03:9A1C 1D AC 15 ORA.W $15AC,X ; OR turning timer
$03:9A1F D0 16 BNE NoSetRenrTurnTime ; Firing or turning, or not this frame: skip
$03:9A21 BD 7C 15 LDA.W RAM_SpriteDir,X ; A = old sprite direction
$03:9A24 48 PHA ; Save it
$03:9A25 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on (SubHorzPosBnk3)
$03:9A28 98 TYA ; A = Y
$03:9A29 9D 7C 15 STA.W RAM_SpriteDir,X ; Direction = Y: face Mario
$03:9A2C 68 PLA ; Pull the old direction
$03:9A2D DD 7C 15 CMP.W RAM_SpriteDir,X ; Compare with the new direction
$03:9A30 F0 05 BEQ NoSetRenrTurnTime ; Unchanged: skip
$03:9A32 A9 0A LDA.B #$0A ; \
$03:9A34 9D AC 15 STA.W $15AC,X ; / Turning timer [$15AC,X] = $0A
;;; $9A37: Reznor: Mario contact (NoSetRenrTurnTime) ;;;
;; Interacts with Mario unless [$154C,X] (disable interaction) is running. Contact sets it to 8 and compares
;; Mario Y - sprite Y: far above = hurts Mario
;; (HitReznor), at the platform edge or moving down = side bounce, moving up from below = platform bounce that
;; kills this Reznor.
$03:9A37 BD 4C 15 LDA.W RAM_DisableInter,X ; A = interaction disabled timer [$154C,X]
$03:9A3A D0 3F BNE DrawReznor ; Running: just draw
$03:9A3C 22 DC A7 01 JSL.L MarioSprInteract ; Check contact with Mario (MarioSprInteract)
$03:9A40 90 39 BCC DrawReznor ; No contact: just draw
$03:9A42 A9 08 LDA.B #$08 ; \
$03:9A44 9D 4C 15 STA.W RAM_DisableInter,X ; / Disable interaction timer [$154C,X] = $08 (after a hit or a bounce)
$03:9A47 A5 96 LDA RAM_MarioYPos ; \
$03:9A49 38 SEC ; |
$03:9A4A F5 D8 SBC RAM_SpriteYLo,X ; |
$03:9A4C C9 ED CMP.B #$ED ; } A = Mario Y - sprite Y; below -19 (Mario well above the platform) = hit Reznor
$03:9A4E 30 27 BMI HitReznor ; /
$03:9A50 C9 F2 CMP.B #$F2 ; Mario Y difference compared with -14
$03:9A52 30 19 BMI HitPlatSide ; Between -19 and -15: hit the side of the platform
$03:9A54 A5 7D LDA RAM_MarioSpeedY ; A = Mario Y speed
$03:9A56 10 15 BPL HitPlatSide ; Mario moving down or still: side hit
;;; $9A58: Mario hits platform from below (HitPlatBottom) ;;;
;; Starts the platform bounce timer [$1564,X] = $0F, knocks Mario down (Y speed $10) and plays a sound.
;; KillReznor runs when the timer reaches $0C.
$03:9A58 A9 29 LDA.B #$29 ; A = $29
$03:9A5A 9D 62 16 STA.W RAM_Tweaker1662,X ; Tweaker byte [$1662,X] = $29: object clipping, probably so Mario can bump the platform
$03:9A5D A9 0F LDA.B #$0F ; \
$03:9A5F 9D 64 15 STA.W $1564,X ; / Platform bounce timer [$1564,X] = $0F
$03:9A62 A9 10 LDA.B #$10 ; \
$03:9A64 85 7D STA RAM_MarioSpeedY ; / Mario Y speed = $10: knocked down off the platform
$03:9A66 A9 01 LDA.B #$01 ; \
$03:9A68 8D F9 1D STA.W $1DF9 ; / Sound effect $01 (hit head)
$03:9A6B 80 0E BRA DrawReznor ; Draw
;;; $9A6D: Mario bounces off platform side (HitPlatSide) ;;;
;; Sets Mario X speed from ReboundSpeedX (indexed by the side Mario is on), then draws.
$03:9A6D 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side of Mario (SubHorzPosBnk3)
$03:9A70 B9 8E 98 LDA.W ReboundSpeedX,Y ; \
$03:9A73 85 7B STA RAM_MarioSpeedX ; / Mario X speed = ReboundSpeedX[Y]: push him away from the platform
$03:9A75 80 04 BRA DrawReznor ; Draw
;;; $9A77: Hurt Mario, then draw Reznor (HitReznor) ;;;
;; Hurts Mario then falls into DrawReznor.
$03:9A77 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario (touched the Reznor itself)
;;; $9A7B: Reznor: pick frame and draw (DrawReznor) ;;;
;; Chooses the frame in [$1602,X]: 0 normal, 1 firing, 2 turning (direction temporarily flipped while the turn
;; timer >= 5). Fires a fireball when the firing timer = $20, draws via ReznorGfxRt and kills the Reznor when
;; the platform bounce timer = $0C.
;; Called by:
;; $03:9897: Reznor main routine: start (Reznor)
;; $03:9917: Reznor: check all Reznors dead (ReznorNoLevelEnd)
;; $03:99F2: Reznor: check all Reznors dead (ReznorNoLevelEnd)
$03:9A7B 9E 02 16 STZ.W $1602,X ; Frame [$1602,X] = 0: normal image
$03:9A7E BD 7C 15 LDA.W RAM_SpriteDir,X ; A = sprite direction
$03:9A81 48 PHA ; Save the direction
$03:9A82 BC AC 15 LDY.W $15AC,X ; Y = turning timer [$15AC,X]
$03:9A85 F0 0E BEQ ReznorNoTurning ; Not turning: skip
$03:9A87 C0 05 CPY.B #$05 ; Turning timer < 5?
$03:9A89 90 05 BCC ReznorTurning ; Yes: keep the direction
$03:9A8B 49 01 EOR.B #$01 ; \
$03:9A8D 9D 7C 15 STA.W RAM_SpriteDir,X ; / Turning timer >= 5: flip the direction for drawing
;;; $9A90: Reznor: turning frame (ReznorTurning) ;;;
;; Sets frame 2 (turning).
$03:9A90 A9 02 LDA.B #$02 ; \
$03:9A92 9D 02 16 STA.W $1602,X ; / Frame [$1602,X] = 2: turning image
;;; $9A95: Reznor: firing check (ReznorNoTurning) ;;;
;; If the firing timer [$1558,X] is non-zero, fires a fireball when it equals $20 and uses frame 1.
$03:9A95 BD 58 15 LDA.W $1558,X ; \
$03:9A98 F0 0C BEQ ReznorNoFiring ; / A = firing timer [$1558,X]; zero: no firing image
$03:9A9A C9 20 CMP.B #$20 ; Timer = $20?
$03:9A9C D0 03 BNE ReznorFiring ; No: just show the firing image
$03:9A9E 20 F8 9A JSR.W ReznorFireRt ; Spit a fireball (ReznorFireRt)
;;; $9AA1: Reznor: firing frame (ReznorFiring) ;;;
;; Sets frame 1 (firing).
$03:9AA1 A9 01 LDA.B #$01 ; \
$03:9AA3 9D 02 16 STA.W $1602,X ; / Frame [$1602,X] = 1: firing image
;;; $9AA6: Reznor: draw and kill check (ReznorNoFiring) ;;;
;; Draws, restores the sprite direction, then returns unless sprites are not locked, the Reznor is alive and
;; the bounce timer = $0C.
$03:9AA6 20 75 9B JSR.W ReznorGfxRt ; Draw Reznor and his platform (ReznorGfxRt)
$03:9AA9 68 PLA ; Restore the sprite direction
$03:9AAA 9D 7C 15 STA.W RAM_SpriteDir,X ; Sprite direction = saved value
$03:9AAD A5 9D LDA RAM_SpritesLocked ; \
$03:9AAF 1D 1C 15 ORA.W $151C,X ; } Return if sprites are locked or this Reznor is already dead
$03:9AB2 D0 43 BNE $9AF7 ; /
$03:9AB4 BD 64 15 LDA.W $1564,X ; \
$03:9AB7 C9 0C CMP.B #$0C ; } Return unless the platform bounce timer = $0C (delays the kill)
$03:9AB9 D0 3C BNE $9AF7 ; /
;;; $9ABB: Kill Reznor (KillReznor) ;;;
;; Plays a sound, records the death in [$151C,X] and spawns a falling dead Reznor (sprite $A9, status 2) at
;; the same position with Y speed $C0 (bounces up). Returns if no free sprite slot.
$03:9ABB A9 03 LDA.B #$03 ; \
$03:9ABD 8D F9 1D STA.W $1DF9 ; / Sound effect $03 (kick/kill)
$03:9AC0 9E 58 15 STZ.W $1558,X ; Firing timer = 0: no more fireballs
$03:9AC3 FE 1C 15 INC.W $151C,X ; [$151C,X]++: mark this Reznor as dead
$03:9AC6 22 E4 A9 02 JSL.L FindFreeSprSlot ; Find a free sprite slot for the falling dead Reznor (Y)
$03:9ACA 30 2B BMI $9AF7 ; No free slot: return
$03:9ACC A9 02 LDA.B #$02 ; \
$03:9ACE 99 C8 14 STA.W $14C8,Y ; / Status = 2 (killed, falling)
$03:9AD1 A9 A9 LDA.B #$A9 ; \
$03:9AD3 99 9E 00 STA.W RAM_SpriteNum,Y ; / Sprite number $A9 (dead Reznor)
$03:9AD6 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:9AD8 99 E4 00 STA.W RAM_SpriteXLo,Y ; |
$03:9ADB BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:9ADE 99 E0 14 STA.W RAM_SpriteXHi,Y ; / Copy X position to the new sprite
$03:9AE1 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:9AE3 99 D8 00 STA.W RAM_SpriteYLo,Y ; |
$03:9AE6 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:9AE9 99 D4 14 STA.W RAM_SpriteYHi,Y ; / Copy Y position to the new sprite
$03:9AEC DA PHX ; \
$03:9AED BB TYX ; |
$03:9AEE 22 D2 F7 07 JSL.L InitSpriteTables ; / Save X; X = new sprite index, then initialize its tables (InitSpriteTables)
$03:9AF2 A9 C0 LDA.B #$C0 ; \
$03:9AF4 95 AA STA RAM_SpriteSpeedY,X ; / New sprite Y speed = $C0: bounces upward
$03:9AF6 FA PLX ; Restore X = Reznor sprite index
$03:9AF7 60 RTS ; Return
;;; $9AF8: Reznor: find free fireball slot (ReznorFireRt) ;;;
;; Finds a free extended sprite slot (7 down to 0) and falls into FoundRznrFireSlot; returns if none.
;; Called by:
;; $03:9A9E: Reznor: firing check (ReznorNoTurning)
$03:9AF8 A0 07 LDY.B #$07 ; \
$03:9AFA B9 0B 17 LDA.W RAM_ExSpriteNum,Y ; |
$03:9AFD F0 04 BEQ FoundRznrFireSlot ; |
$03:9AFF 88 DEY ; } Find a free extended sprite slot (Y = 7..0); return if all are used
$03:9B00 10 F8 BPL $9AFA ; /
$03:9B02 60 RTS ; Return: no free slot
;;; $9B03: Spawn Reznor fireball (FoundRznrFireSlot) ;;;
;; Creates extended sprite 2 (Reznor fireball) at Reznor position (-8, -$14), aims it at Mario with speed $10
;; using $97F9 and stores the speeds.
$03:9B03 A9 10 LDA.B #$10 ; \
$03:9B05 8D F9 1D STA.W $1DF9 ; / Sound effect $10 (Reznor fireball)
$03:9B08 A9 02 LDA.B #$02 ; \
$03:9B0A 99 0B 17 STA.W RAM_ExSpriteNum,Y ; / Extended sprite number = 2 (Reznor fireball)
$03:9B0D B5 E4 LDA RAM_SpriteXLo,X ; A = Reznor X position low
$03:9B0F 48 PHA ; Save it
$03:9B10 38 SEC ; Carry set for the subtract
$03:9B11 E9 08 SBC.B #$08 ; Fireball X = Reznor X - 8
$03:9B13 99 1F 17 STA.W RAM_ExSpriteXLo,Y ; Fireball X low
$03:9B16 95 E4 STA RAM_SpriteXLo,X ; Temporarily move the Reznor X too (aim origin)
$03:9B18 BD E0 14 LDA.W RAM_SpriteXHi,X ; A = Reznor X high
$03:9B1B E9 00 SBC.B #$00 ; Subtract the borrow
$03:9B1D 99 33 17 STA.W RAM_ExSpriteXHi,Y ; Fireball X high
$03:9B20 B5 D8 LDA RAM_SpriteYLo,X ; A = Reznor Y low
$03:9B22 48 PHA ; Save it
$03:9B23 38 SEC ; Carry set for the subtract
$03:9B24 E9 14 SBC.B #$14 ; Fireball Y = Reznor Y - $14
$03:9B26 95 D8 STA RAM_SpriteYLo,X ; Temporarily move Reznor Y
$03:9B28 99 15 17 STA.W RAM_ExSpriteYLo,Y ; Fireball Y low
$03:9B2B BD D4 14 LDA.W RAM_SpriteYHi,X ; A = Reznor Y high
$03:9B2E 48 PHA ; Save it
$03:9B2F E9 00 SBC.B #$00 ; Subtract the borrow
$03:9B31 99 29 17 STA.W RAM_ExSpriteYHi,Y ; Fireball Y high
$03:9B34 9D D4 14 STA.W RAM_SpriteYHi,X ; Temporarily move Reznor Y high
$03:9B37 A9 10 LDA.B #$10 ; A = $10: fireball speed
$03:9B39 20 F9 97 JSR.W $97F9 ; Aim at Mario: $00 = Y speed, $01 = X speed ($97F9)
$03:9B3C 68 PLA ; Pull saved Y high
$03:9B3D 9D D4 14 STA.W RAM_SpriteYHi,X ; Restore Reznor Y high
$03:9B40 68 PLA ; Pull saved Y low
$03:9B41 95 D8 STA RAM_SpriteYLo,X ; Restore Reznor Y low
$03:9B43 68 PLA ; Pull saved X low
$03:9B44 95 E4 STA RAM_SpriteXLo,X ; Restore Reznor X low
$03:9B46 A5 00 LDA $00 ; A = aimed Y speed
$03:9B48 99 3D 17 STA.W RAM_ExSprSpeedY,Y ; Fireball Y speed
$03:9B4B A5 01 LDA $01 ; A = aimed X speed
$03:9B4D 99 47 17 STA.W RAM_ExSprSpeedX,Y ; Fireball X speed
$03:9B50 60 RTS ; Return
;;; $9B51: Table: Reznor tile X offsets (ReznorTileDispX) ;;;
$03:9B51 .db $00,$F0,$00,$F0,$F0,$00,$F0,$00 ; X offsets per tile, facing right: $00,$F0,$00,$F0; facing left: $F0,$00,$F0,$00
;;; $9B59: Table: Reznor tile Y offsets (ReznorTileDispY) ;;;
$03:9B59 .db $E0,$E0,$F0,$F0 ; Y offsets per tile: $E0,$E0,$F0,$F0 (2x2 tiles of 16x16)
;;; $9B5D: Table: Reznor tile numbers (ReznorTiles) ;;;
$03:9B5D .db $40,$42,$60,$62,$44,$46,$64,$66 ; Tiles for frame 0 (normal) $40,$42,$60,$62 and frame 1 (firing) $44,$46,$64,$66
$03:9B65 .db $28,$28,$48,$48 ; Tiles for frame 2 (turning): $28,$28,$48,$48
;;; $9B69: Table: Reznor tile properties (ReznorPal) ;;;
$03:9B69 .db $3F,$3F,$3F,$3F,$3F,$3F,$3F,$3F ; Properties for frames 0 and 1: $3F = palette 7, priority 3 (flip added in code)
$03:9B71 .db $7F,$3F,$7F,$3F ; Properties for frame 2 (turning): $7F,$3F,$7F,$3F
;;; $9B75: Draw Reznor (ReznorGfxRt) ;;;
;; Draws the four 16x16 tiles of Reznor (frame from [$1602,X], mirrored by direction) and then his platform. A
;; dead Reznor only draws the platform.
;; Called by:
;; $03:9AA6: Reznor: draw and kill check (ReznorNoFiring)
$03:9B75 BD 1C 15 LDA.W $151C,X ; \
$03:9B78 D0 65 BNE DrawReznorPlats ; / Reznor dead ([$151C,X] != 0)? Then only draw the platform
$03:9B7A 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index Y and screen position $00/$01 (GetDrawInfoBnk3)
$03:9B7D BD 02 16 LDA.W $1602,X ; \
$03:9B80 0A ASL ; |
$03:9B81 0A ASL ; |
$03:9B82 85 03 STA $03 ; / $03 = frame [$1602,X] * 4: index of the frame's first tile
$03:9B84 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:9B87 0A ASL ; |
$03:9B88 0A ASL ; |
$03:9B89 85 02 STA $02 ; / $02 = direction * 4: index into the facing-dependent X offsets
$03:9B8B DA PHX ; Save sprite index
$03:9B8C A2 03 LDX.B #$03 ; X = 3: four tiles per frame
;;; $9B8E: Reznor draw: tile loop (RznrGfxLoopStart) ;;;
;; Loop over the 4 tiles of the frame (X = 3..0): OAM position from the offset tables, tile and properties
;; from ReznorTiles/ReznorPal.
$03:9B8E DA PHX ; Save the tile counter
$03:9B8F A5 03 LDA $03 ; A = frame offset
$03:9B91 C9 08 CMP.B #$08 ; Frame >= 2 (turning image)?
$03:9B93 B0 04 BCS $9B99 ; Yes: X offsets not direction dependent
$03:9B95 8A TXA ; \
$03:9B96 05 02 ORA $02 ; } Add the direction offset to the tile index
$03:9B98 AA TAX ; /
$03:9B99 A5 00 LDA $00 ; A = sprite X on screen
$03:9B9B 18 CLC ; Clear carry
$03:9B9C 7D 51 9B ADC.W ReznorTileDispX,X ; Plus tile X offset
$03:9B9F 99 00 03 STA.W OAM_DispX,Y ; OAM X position
$03:9BA2 FA PLX ; Pull tile counter
$03:9BA3 A5 01 LDA $01 ; A = sprite Y on screen
$03:9BA5 18 CLC ; Clear carry
$03:9BA6 7D 59 9B ADC.W ReznorTileDispY,X ; Plus tile Y offset
$03:9BA9 99 01 03 STA.W OAM_DispY,Y ; OAM Y position
$03:9BAC DA PHX ; Save the tile counter again
$03:9BAD 8A TXA ; \
$03:9BAE 05 03 ORA $03 ; |
$03:9BB0 AA TAX ; / X = frame offset + tile counter: index into the tile and property tables
$03:9BB1 BD 5D 9B LDA.W ReznorTiles,X ; Tile number from ReznorTiles
$03:9BB4 99 02 03 STA.W OAM_Tile,Y ; OAM tile number
$03:9BB7 BD 69 9B LDA.W ReznorPal,X ; Properties from ReznorPal
$03:9BBA E0 08 CPX.B #$08 ; \
$03:9BBC B0 06 BCS NoReznorGfxFlip ; / Turning image (index >= 8): do not flip
$03:9BBE A6 02 LDX $02 ; \
$03:9BC0 D0 02 BNE NoReznorGfxFlip ; } Direction 0: flip tile horizontally
$03:9BC2 49 40 EOR.B #$40 ; /
;;; $9BC4: Reznor draw: finish OAM (NoReznorGfxFlip) ;;;
;; Writes properties, advances the OAM index by 4 and finishes with FinishOAMWrite (4 tiles, 16x16).
$03:9BC4 99 03 03 STA.W OAM_Prop,Y ; OAM properties
$03:9BC7 FA PLX ; Pull tile counter
$03:9BC8 C8 INY ; \
$03:9BC9 C8 INY ; |
$03:9BCA C8 INY ; |
$03:9BCB C8 INY ; / OAM index Y += 4: next OAM slot
$03:9BCC CA DEX ; Next tile
$03:9BCD 10 BF BPL RznrGfxLoopStart ; Loop for all 4 tiles
$03:9BCF FA PLX ; Restore sprite index X
$03:9BD0 A0 02 LDY.B #$02 ; Y = 2: all tiles are 16x16
$03:9BD2 A9 03 LDA.B #$03 ; A = number of tiles - 1
$03:9BD4 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write, hide offscreen tiles (FinishOAMWrite)
$03:9BD8 BD C8 14 LDA.W $14C8,X ; A = sprite status
$03:9BDB C9 02 CMP.B #$02 ; Status 2 (killed)?
$03:9BDD F0 03 BEQ $9BE2 ; Yes: no platform, return
;;; $9BDF: Draw Reznor platform (DrawReznorPlats) ;;;
;; Calls ReznorPlatGfxRt.
$03:9BDF 20 EB 9B JSR.W ReznorPlatGfxRt ; Draw the platform (ReznorPlatGfxRt)
$03:9BE2 60 RTS ; Return
;;; $9BE3: Table: platform bounce Y offsets (ReznorPlatDispY) ;;;
$03:9BE3 .db $00,$03,$04,$05,$05,$04,$03,$00 ; Platform bounce Y offsets, indexed by [$1564,X] >> 1: 0,3,4,5,5,4,3,0
;;; $9BEB: Draw Reznor platform graphics (ReznorPlatGfxRt) ;;;
;; Reserves 4 OAM slots for Reznor, then draws two 16x16 tiles ($4E, the right one X flipped) for the
;; platform; Y is lowered by the bounce table indexed by [$1564,X] >> 1.
;; Called by:
;; $03:9BDF: Draw Reznor platform (DrawReznorPlats)
$03:9BEB BD EA 15 LDA.W RAM_SprOAMIndex,X ; \
$03:9BEE 18 CLC ; } Skip the 4 OAM slots used by Reznor: OAM index [$15EA,X] += $10
$03:9BEF 69 10 ADC.B #$10 ; |
$03:9BF1 9D EA 15 STA.W RAM_SprOAMIndex,X ; /
$03:9BF4 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index Y and screen position $00/$01 (GetDrawInfoBnk3)
$03:9BF7 BD 64 15 LDA.W $1564,X ; A = platform bounce timer [$1564,X]
$03:9BFA 4A LSR ; A = timer >> 1: index into the bounce table
$03:9BFB 5A PHY ; Save OAM index Y
$03:9BFC A8 TAY ; Y = bounce table index
$03:9BFD B9 E3 9B LDA.W ReznorPlatDispY,Y ; A = platform Y offset
$03:9C00 85 02 STA $02 ; $02 = platform Y offset
$03:9C02 7A PLY ; Restore OAM index Y
$03:9C03 A5 00 LDA $00 ; A = sprite X on screen
$03:9C05 99 04 03 STA.W OAM_Tile2DispX,Y ; Right half X position
$03:9C08 38 SEC ; Set carry
$03:9C09 E9 10 SBC.B #$10 ; Left half X = X - $10
$03:9C0B 99 00 03 STA.W OAM_DispX,Y ; Left half X position
$03:9C0E A5 01 LDA $01 ; A = sprite Y on screen
$03:9C10 38 SEC ; Set carry
$03:9C11 E5 02 SBC $02 ; Minus the bounce offset
$03:9C13 99 01 03 STA.W OAM_DispY,Y ; Left half Y position
$03:9C16 99 05 03 STA.W OAM_Tile2DispY,Y ; Right half Y position
$03:9C19 A9 4E LDA.B #$4E ; \
$03:9C1B 99 02 03 STA.W OAM_Tile,Y ; } Both tiles = $4E (platform)
$03:9C1E 99 06 03 STA.W OAM_Tile2,Y ; /
$03:9C21 A9 33 LDA.B #$33 ; \
$03:9C23 99 03 03 STA.W OAM_Prop,Y ; / Left tile properties $33 (palette 1, priority 3)
$03:9C26 09 40 ORA.B #$40 ; \
$03:9C28 99 07 03 STA.W OAM_Tile2Prop,Y ; / Right tile properties: X flipped
$03:9C2B A0 02 LDY.B #$02 ; \
$03:9C2D A9 01 LDA.B #$01 ; / Y = 2 (16x16 tiles), A = 1: two tiles
$03:9C2F 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write, hide offscreen tiles (FinishOAMWrite)
$03:9C33 60 RTS ; Return
;;; $9C34: Dino sprite main entry (and invisible block) (InvisBlk+DinosMain) ;;;
;; Entry point shared by sprites $6D (Invisible solid block) , $6E (Dino-Rhino) and $6F (Dino-Torch). Sprite
;; $6D calls InvisBlkMainRt; the Dinos go to DinoMainRt.
;; Called by:
;; $01:875E: Invisible solid block, Dino Rhino and Dino Torch (InvisSolid+Dinos)
$03:9C34 B5 9E LDA RAM_SpriteNum,X ; \
$03:9C36 C9 6D CMP.B #$6D ; } Sprite $6D (invisible solid block)? Otherwise go to DinoMainRt
$03:9C38 D0 05 BNE DinoMainRt ; /
$03:9C3A 22 4F B4 01 JSL.L InvisBlkMainRt ; Run the invisible solid block routine (InvisBlkMainRt)
$03:9C3E 6B RTL ; Return
;;; $9C3F: Dino main wrapper (DinoMainRt) ;;;
;; Sets the data bank to the program bank around DinoMainSubRt.
$03:9C3F 8B PHB ; Save data bank
$03:9C40 4B PHK ; \
$03:9C41 AB PLB ; / Data bank = program bank ($03)
$03:9C42 20 47 9C JSR.W DinoMainSubRt ; Run the Dino-Rhino/Dino-Torch main code
$03:9C45 AB PLB ; Restore data bank
$03:9C46 6B RTL ; Return
;;; $9C47: Dino main code (DinoMainSubRt) ;;;
;; Draws, returns if sprites are locked or status is not 8, handles offscreen, Mario contact and movement,
;; then runs the state: 0 walk, 1/2 breathe fire (Dino-Torch only), 3 jump.
;; Called by:
;; $03:9C42: Dino main wrapper (DinoMainRt)
$03:9C47 20 49 9E JSR.W DinoGfxRt ; Draw the sprite (DinoGfxRt)
$03:9C4A A5 9D LDA RAM_SpritesLocked ; A = sprites locked flag
$03:9C4C D0 55 BNE $9CA3 ; Locked: return
$03:9C4E BD C8 14 LDA.W $14C8,X ; A = sprite status
$03:9C51 C9 08 CMP.B #$08 ; Status 8 (normal)?
$03:9C53 D0 4E BNE $9CA3 ; No: return
$03:9C55 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Handle offscreen despawn (SubOffscreen0Bnk3)
$03:9C58 22 DC A7 01 JSL.L MarioSprInteract ; Interact with Mario
$03:9C5C 22 2A 80 01 JSL.L UpdateSpritePos ; Apply speed and gravity, check object collision (UpdateSpritePos)
$03:9C60 B5 C2 LDA RAM_SpriteState,X ; A = sprite state [$C2,X]
$03:9C62 22 DF 86 00 JSL.L ExecutePtr ; Run state: 0 walk, 1/2 breathe fire, 3 jump
;;; $9C66: Pointer table: Dino states, wall nudge (RhinoStatePtrs) ;;;
;; State pointers for Dino-Rhino/Dino-Torch, plus $9C6E/71 (X nudge out of walls) and the state 3 jump
;; code $9C74.
$03:9C66 A8 9C .dw $9CA8 ; State 0: walk ($9CA8)
$03:9C68 41 9D .dw $9D41 ; State 1: breathe fire, horizontal flame ($9D41)
$03:9C6A 41 9D .dw $9D41 ; State 2: breathe fire, vertical flame ($9D41)
$03:9C6C 74 9C .dw $9C74 ; State 3: jump ($9C74)
$03:9C6E .db $00,$FE,$02 ; X nudge out of a wall, low byte, by wall flags [$1588]: $00,$FE,$02
$03:9C71 .db $00,$FF,$00 ; X nudge out of a wall, high byte: $00,$FF,$00
$03:9C74 B5 AA LDA RAM_SpriteSpeedY,X ; A = Y speed
$03:9C76 30 11 BMI $9C89 ; Rising: skip
$03:9C78 74 C2 STZ RAM_SpriteState,X ; Falling: state = 0 (walk)
$03:9C7A BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:9C7D 29 03 AND.B #$03 ; } Not touching a wall: skip the turn
$03:9C7F F0 08 BEQ $9C89 ; /
$03:9C81 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:9C84 49 01 EOR.B #$01 ; } Touching a wall: flip direction
$03:9C86 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:9C89 9E 02 16 STZ.W $1602,X ; Frame [$1602,X] = 0
$03:9C8C BD 88 15 LDA.W RAM_SprObjStatus,X ; A = object contact flags
$03:9C8F 29 03 AND.B #$03 ; Keep side wall bits
$03:9C91 A8 TAY ; Y = wall flags: 0 none, 1 right, 2 left
$03:9C92 B5 E4 LDA RAM_SpriteXLo,X ; A = X position low
$03:9C94 18 CLC ; Clear carry
$03:9C95 79 6E 9C ADC.W $9C6E,Y ; Add nudge from $9C6E (pushes the sprite out of the wall)
$03:9C98 95 E4 STA RAM_SpriteXLo,X ; X position low
$03:9C9A BD E0 14 LDA.W RAM_SpriteXHi,X ; A = X position high
$03:9C9D 79 71 9C ADC.W $9C71,Y ; Add nudge high byte
$03:9CA0 9D E0 14 STA.W RAM_SpriteXHi,X ; X position high
$03:9CA3 60 RTS ; Return
;;; $9CA4: Dino walking states and speeds (DinoSpeed) ;;;
;; DinoSpeed table: X speeds for Rhino ($08/$F8) and Torch ($10/$F0). $9CA8 is state 0 (walk): on the
;; ground, Dino-Torch starts a flame ([$1540,X] = $FF, state 1 or 2) when the timer is 0;
;; every 64 frames it faces Mario; it jumps (Y speed $C0, state 3) when it hits a wall.
$03:9CA4 .db $08,$F8,$10,$F0 ; X speed: Dino-Rhino $08 right, $F8 left; Dino-Torch $10 right, $F0 left
$03:9CA8 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:9CAB 29 04 AND.B #$04 ; } Not on the ground? Go to $9C89 (no walking in the air)
$03:9CAD F0 DA BEQ $9C89 ; /
$03:9CAF BD 40 15 LDA.W $1540,X ; A = fire timer [$1540,X]
$03:9CB2 D0 14 BNE $9CC8 ; Timer running: skip
$03:9CB4 B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:9CB6 C9 6E CMP.B #$6E ; Dino-Rhino ($6E)?
$03:9CB8 F0 0E BEQ $9CC8 ; Yes: never breathes fire
$03:9CBA A9 FF LDA.B #$FF ; \
$03:9CBC 9D 40 15 STA.W $1540,X ; / Fire timer [$1540,X] = $FF
$03:9CBF 22 F9 AC 01 JSL.L GetRand ; Random number
$03:9CC3 29 01 AND.B #$01 ; 0 or 1
$03:9CC5 1A INC A ; 1 or 2
$03:9CC6 95 C2 STA RAM_SpriteState,X ; State = 1 or 2: pick the flame direction
$03:9CC8 8A TXA ; \
$03:9CC9 0A ASL ; |
$03:9CCA 0A ASL ; |
$03:9CCB 0A ASL ; |
$03:9CCC 0A ASL ; } A = (slot * 16 + [$14]) & $3F: every 64 frames per Dino
$03:9CCD 65 14 ADC RAM_FrameCounterB ; |
$03:9CCF 29 3F AND.B #$3F ; /
$03:9CD1 D0 07 BNE $9CDA ; Not this frame: skip
$03:9CD3 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:9CD6 98 TYA ; } Face Mario: direction = result of SubHorzPosBnk3
$03:9CD7 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:9CDA A9 10 LDA.B #$10 ; \
$03:9CDC 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $10 (keeps it on the ground)
$03:9CDE BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = direction
$03:9CE1 B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:9CE3 C9 6E CMP.B #$6E ; Dino-Rhino?
$03:9CE5 F0 02 BEQ $9CE9 ; Yes: use the first pair of speeds
$03:9CE7 C8 INY ; \
$03:9CE8 C8 INY ; / Dino-Torch: Y += 2 for the faster pair
$03:9CE9 B9 A4 9C LDA.W DinoSpeed,Y ; A = walking X speed
$03:9CEC 95 B6 STA RAM_SpriteSpeedX,X ; X speed
$03:9CEE 20 EF 9D JSR.W DinoSetGfxFrame ; Update the walking animation frame (DinoSetGfxFrame)
$03:9CF1 BD 88 15 LDA.W RAM_SprObjStatus,X ; A = object contact flags
$03:9CF4 29 03 AND.B #$03 ; Keep side wall bits
$03:9CF6 F0 08 BEQ $9D00 ; Not touching a wall: return
$03:9CF8 A9 C0 LDA.B #$C0 ; \
$03:9CFA 95 AA STA RAM_SpriteSpeedY,X ; / Touching a wall: Y speed = $C0 (jump)
$03:9CFC A9 03 LDA.B #$03 ; \
$03:9CFE 95 C2 STA RAM_SpriteState,X ; / State = 3 (jumping)
$03:9D00 60 RTS ; Return
;;; $9D01: Table: Dino-Torch flame animation (DinoFlameTable) ;;;
;; 32 entries per flame state (1 = horizontal, 2 = vertical), indexed by [$1540,X] / 8 so played from the end:
;; high nibble = flame size (0 = full flame that hurts Mario), low nibble = frame for [$1602,X].
$03:9D01 .db $41,$42,$42,$32,$22,$12,$02,$02 ; Flame steps, state 1, 0-7 (timer counts down, so played last): size << 4 | frame
$03:9D09 .db $02,$02,$02,$02,$02,$02,$02,$02 ; Flame steps, state 1, 8-15
$03:9D11 .db $02,$02,$02,$02,$02,$02,$02,$12 ; Flame steps, state 1, 16-23
$03:9D19 .db $22,$32,$42,$42,$42,$42,$41,$41 ; Flame steps, state 1, 24-31 (played first: flame grows)
$03:9D21 .db $41,$43,$43,$33,$23,$13,$03,$03 ; Flame steps, state 2 (vertical flame), 0-7
$03:9D29 .db $03,$03,$03,$03,$03,$03,$03,$03 ; Flame steps, state 2, 8-15
$03:9D31 .db $03,$03,$03,$03,$03,$03,$03,$13 ; Flame steps, state 2, 16-23
$03:9D39 .db $23,$33,$43,$43,$43,$43,$41,$41 ; Flame steps, state 2, 24-31
$03:9D41 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0: stand still while breathing
$03:9D43 BD 40 15 LDA.W $1540,X ; A = fire timer [$1540,X]
$03:9D46 D0 09 BNE DinoFlameTimerSet ; Timer running: continue the flame animation
$03:9D48 74 C2 STZ RAM_SpriteState,X ; Timer ran out: state = 0 (walk)
$03:9D4A A9 40 LDA.B #$40 ; \
$03:9D4C 9D 40 15 STA.W $1540,X ; / Fire timer [$1540,X] = $40: walk for a while before breathing again
$03:9D4F A9 00 LDA.B #$00 ; A = 0 (timer value for the table lookup)
;;; $9D51: Dino-Torch breathing flame (state 1/2) (DinoFlameTimerSet) ;;;
;; Stands still and runs the flame from timer [$1540,X] ($FF down to 0): sound at $C0, frame and size from
;; DinoFlameTable. When the flame is full and every 4th frame, checks contact with the flame box and hurts
;; Mario unless he has a star.
$03:9D51 C9 C0 CMP.B #$C0 ; Timer = $C0 (just after the flame started)?
$03:9D53 D0 05 BNE $9D5A ; No: skip the sound
$03:9D55 A0 17 LDY.B #$17 ; \
$03:9D57 8C FC 1D STY.W $1DFC ; / Sound effect $17 (fire breath) on [$1DFC]
$03:9D5A 4A LSR ; \
$03:9D5B 4A LSR ; |
$03:9D5C 4A LSR ; / A = timer / 8: flame step 0-31
$03:9D5D B4 C2 LDY RAM_SpriteState,X ; Y = state
$03:9D5F C0 02 CPY.B #$02 ; State 2?
$03:9D61 D0 03 BNE $9D66 ; No: first half of the table
$03:9D63 18 CLC ; \
$03:9D64 69 20 ADC.B #$20 ; / State 2: step += $20 (second half of the table)
$03:9D66 A8 TAY ; Y = table index
$03:9D67 B9 01 9D LDA.W DinoFlameTable,Y ; A = flame animation entry
$03:9D6A 48 PHA ; Save it
$03:9D6B 29 0F AND.B #$0F ; Low nibble
$03:9D6D 9D 02 16 STA.W $1602,X ; Frame [$1602,X]
$03:9D70 68 PLA ; Pull the entry
$03:9D71 4A LSR ; \
$03:9D72 4A LSR ; } High nibble: flame size, 0 = full flame
$03:9D73 4A LSR ; |
$03:9D74 4A LSR ; /
$03:9D75 9D 1C 15 STA.W $151C,X ; [$151C,X] = flame size
$03:9D78 D0 23 BNE $9D9D ; Not full size: no damage, return
$03:9D7A B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:9D7C C9 6E CMP.B #$6E ; Dino-Rhino?
$03:9D7E F0 1D BEQ $9D9D ; Yes: no flame, return
$03:9D80 8A TXA ; \
$03:9D81 45 13 EOR RAM_FrameCounter ; |
$03:9D83 29 03 AND.B #$03 ; |
$03:9D85 D0 16 BNE $9D9D ; / Only every 4th frame (slot dependent): return otherwise
$03:9D87 20 B6 9D JSR.W DinoFlameClipping ; Set up the flame clipping box (DinoFlameClipping)
$03:9D8A 22 64 B6 03 JSL.L GetMarioClipping ; Get Mario clipping box (GetMarioClipping)
$03:9D8E 22 2B B7 03 JSL.L CheckForContact ; Check contact with the flame (CheckForContact)
$03:9D92 90 09 BCC $9D9D ; No contact: return
$03:9D94 AD 90 14 LDA.W $1490 ; A = star power timer
$03:9D97 D0 04 BNE $9D9D ; Mario has a star: return
$03:9D99 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
$03:9D9D 60 RTS ; Return
;;; $9D9E: Table: flame box X offset low (DinoFlame1) ;;;
$03:9D9E .db $DC,$02,$10,$02 ; Flame box X offset low, indexed [frame - 2] (+2 if facing right)
;;; $9DA2: Table: flame box X offset high (DinoFlame2) ;;;
$03:9DA2 .db $FF,$00,$00,$00 ; Flame box X offset high
;;; $9DA6: Table: flame box width (DinoFlame3) ;;;
$03:9DA6 .db $24,$0C,$24,$0C ; Flame box width
;;; $9DAA: Table: flame box Y offset low (DinoFlame4) ;;;
$03:9DAA .db $02,$DC,$02,$DC ; Flame box Y offset low
;;; $9DAE: Table: flame box Y offset high (DinoFlame5) ;;;
$03:9DAE .db $00,$FF,$00,$FF ; Flame box Y offset high
;;; $9DB2: Table: flame box height (DinoFlame6) ;;;
$03:9DB2 .db $0C,$24,$0C,$24 ; Flame box height
;;; $9DB6: Dino-Torch flame hitbox (DinoFlameClipping) ;;;
;; Fills the sprite clipping slot B ($04 X low, $0A X high, $06 width, $05 Y low, $0B Y high, $07 height) from
;; the DinoFlame tables, indexed by frame - 2 (+2 when the sprite direction is 0).
;; Called by:
;; $03:9D87: Dino-Torch breathing flame (state 1/2) (DinoFlameTimerSet)
$03:9DB6 BD 02 16 LDA.W $1602,X ; A = frame [$1602,X] (2 = horizontal flame, 3 = vertical flame)
$03:9DB9 38 SEC ; Set carry
$03:9DBA E9 02 SBC.B #$02 ; Minus 2
$03:9DBC A8 TAY ; Y = 0 or 1
$03:9DBD BD 7C 15 LDA.W RAM_SpriteDir,X ; A = sprite direction
$03:9DC0 D0 02 BNE $9DC4 ; Direction 1: keep Y
$03:9DC2 C8 INY ; \
$03:9DC3 C8 INY ; / Direction 0: Y += 2
$03:9DC4 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:9DC6 18 CLC ; |
$03:9DC7 79 9E 9D ADC.W DinoFlame1,Y ; |
$03:9DCA 85 04 STA $04 ; / $04 = X position low + flame X offset
$03:9DCC BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:9DCF 79 A2 9D ADC.W DinoFlame2,Y ; |
$03:9DD2 85 0A STA $0A ; / $0A = X position high + offset high
$03:9DD4 B9 A6 9D LDA.W DinoFlame3,Y ; A = flame width
$03:9DD7 85 06 STA $06 ; $06 = width
$03:9DD9 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:9DDB 18 CLC ; |
$03:9DDC 79 AA 9D ADC.W DinoFlame4,Y ; |
$03:9DDF 85 05 STA $05 ; / $05 = Y position low + flame Y offset
$03:9DE1 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:9DE4 79 AE 9D ADC.W DinoFlame5,Y ; |
$03:9DE7 85 0B STA $0B ; / $0B = Y position high + offset high
$03:9DE9 B9 B2 9D LDA.W DinoFlame6,Y ; A = flame height
$03:9DEC 85 07 STA $07 ; $07 = height
$03:9DEE 60 RTS ; Return
;;; $9DEF: Dino walk animation frame (DinoSetGfxFrame) ;;;
;; Increments the animation counter [$1570,X] and sets the frame [$1602,X] to bit 3 of it (0/1, every 8
;; frames).
;; Called by:
;; $03:9CEE: Dino walking states and speeds (DinoSpeed)
$03:9DEF FE 70 15 INC.W $1570,X ; [$1570,X]++: animation counter
$03:9DF2 BD 70 15 LDA.W $1570,X ; A = animation counter
$03:9DF5 29 08 AND.B #$08 ; \
$03:9DF7 4A LSR ; |
$03:9DF8 4A LSR ; |
$03:9DF9 4A LSR ; |
$03:9DFA 9D 02 16 STA.W $1602,X ; / Frame [$1602,X] = bit 3 of the counter: toggles every 8 frames
$03:9DFD 60 RTS ; Return
;;; $9DFE: Table: Dino-Torch flame X offsets (DinoTorchTileDispX) ;;;
$03:9DFE .db $D8,$E0,$EC,$F8,$00,$FF,$FF,$FF ; Flame tile X offsets: $D8,$E0,$EC,$F8,$00 (horizontal flame), then $FF,$FF,$FF (vertical)
$03:9E06 .db $FF,$00 ; Flame tile X offsets, continued: $FF,$00
;;; $9E08: Table: Dino-Torch flame Y offsets (DinoTorchTileDispY) ;;;
$03:9E08 .db $00,$00,$00,$00,$00,$D8,$E0,$EC ; Flame tile Y offsets: $00 x5 (horizontal), then $D8,$E0,$EC (vertical)
$03:9E10 .db $F8,$00 ; Flame tile Y offsets, continued: $F8,$00
;;; $9E12: Table: Dino-Torch flame tiles (DinoFlameTiles) ;;;
$03:9E12 .db $80,$82,$84,$86,$00,$88,$8A,$8C ; Flame tiles: $80,$82,$84,$86,$00 (horizontal), then $88,$8A,$8C (vertical)
$03:9E1A .db $8E,$00 ; Flame tiles, continued: $8E,$00
;;; $9E1C: Table: Dino-Torch tile properties (DinoTorchGfxProp) ;;;
$03:9E1C .db $09,$05,$05,$05,$0F ; Dino-Torch tile properties
;;; $9E21: Table: Dino-Torch tiles (DinoTorchTiles) ;;;
$03:9E21 .db $EA,$AA,$C4,$C6 ; Dino-Torch body tiles: $EA,$AA,$C4,$C6
;;; $9E25: Table: Dino body tile X offsets (DinoRhinoTileDispX) ;;;
$03:9E25 .db $F8,$08,$F8,$08,$08,$F8,$08,$F8 ; Dino-Rhino/Torch body X offsets: facing right $F8,$08,$F8,$08; facing left $08,$F8,$08,$F8
;;; $9E2D: Table: Dino body tile properties (DinoRhinoGfxProp) ;;;
$03:9E2D .db $2F,$2F,$2F,$2F,$6F,$6F,$6F,$6F ; Body tile properties: $2F facing right (4 tiles), $6F facing left (X flipped)
;;; $9E35: Table: Dino body tile Y offsets (DinoRhinoTileDispY) ;;;
$03:9E35 .db $F0,$F0,$00,$00 ; Body tile Y offsets: $F0,$F0,$00,$00
;;; $9E39: Table: Dino body tiles (DinoRhinoTiles) ;;;
$03:9E39 .db $C0,$C2,$E4,$E6,$C0,$C2,$E0,$E2 ; Body tiles per frame (4 each): frame 0 $C0,$C2,$E4,$E6; frame 1 $C0,$C2,$E0,$E2
$03:9E41 .db $C8,$CA,$E8,$E2,$CC,$CE,$EC,$EE ; Body tiles per frame: frame 2 $C8,$CA,$E8,$E2; frame 3 $CC,$CE,$EC,$EE
;;; $9E49: Dino Rhino and Dino Torch graphics (DinoGfxRt) ;;;
;; Draws sprite $6E (Dino Rhino): 4 16x16 tiles from DinoRhinoTiles, X-flipped via the mirrored half of the
;; tables when facing right.
;; Sprite $6F (Dino Torch): head tile plus up to 5 flame segments, flame flickers by flipping every other
;; frame.
;; Uses [$1602] as animation frame, [$151C] as flame length. Parameters: X = sprite index.
;; Called by:
;; $03:9C47: Dino main code (DinoMainSubRt)
$03:9E49 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index [Y] and on-screen position [$00]/[$01] (returns if off-screen)
$03:9E4C BD 7C 15 LDA.W RAM_SpriteDir,X ; A = sprite direction (0 = right)
$03:9E4F 85 02 STA $02 ; $02 = direction
$03:9E51 BD 02 16 LDA.W $1602,X ; A = animation frame [$1602]
$03:9E54 85 04 STA $04 ; $04 = frame
$03:9E56 B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:9E58 C9 6F CMP.B #$6F ; Compare with $6F (Dino Torch)
$03:9E5A F0 4D BEQ $9EA9 ; Dino Torch: go draw torch and flame
$03:9E5C DA PHX ; Save sprite index
$03:9E5D A2 03 LDX.B #$03 ; X = 3: four tiles to draw
$03:9E5F 86 0F STX $0F ; $0F = tile counter
$03:9E61 A5 02 LDA $02 ; A = direction
$03:9E63 C9 01 CMP.B #$01 ; Direction >= 1 (left): keep table index
$03:9E65 B0 05 BCS $9E6C ; Skip the mirrored-table offset if facing left
$03:9E67 8A TXA ; \
$03:9E68 18 CLC ; |
$03:9E69 69 04 ADC.B #$04 ; } Facing right: X += 4 (use the X-flipped half of the tables)
$03:9E6B AA TAX ; /
$03:9E6C BD 2D 9E LDA.W DinoRhinoGfxProp,X ; Tile property from DinoRhinoGfxProp (palette, X-flip when facing right)
$03:9E6F 99 03 03 STA.W OAM_Prop,Y
$03:9E72 BD 25 9E LDA.W DinoRhinoTileDispX,X ; \
$03:9E75 18 CLC ; |
$03:9E76 65 00 ADC $00 ; } OAM X = [$00] + DinoRhinoTileDispX[X]
$03:9E78 99 00 03 STA.W OAM_DispX,Y ; /
$03:9E7B A5 04 LDA $04 ; \
$03:9E7D C9 01 CMP.B #$01 ; / Carry = 1 when animation frame >= 1
$03:9E7F A6 0F LDX $0F ; X = tile counter
$03:9E81 BD 35 9E LDA.W DinoRhinoTileDispY,X ; \
$03:9E84 65 01 ADC $01 ; } OAM Y = [$01] + DinoRhinoTileDispY[X] + carry (frames 1+ sit 1 pixel lower)
$03:9E86 99 01 03 STA.W OAM_DispY,Y ; /
$03:9E89 A5 04 LDA $04 ; \
$03:9E8B 0A ASL ; |
$03:9E8C 0A ASL ; |
$03:9E8D 65 0F ADC $0F ; } X = frame * 4 + tile counter
$03:9E8F AA TAX ; /
$03:9E90 BD 39 9E LDA.W DinoRhinoTiles,X ; \
$03:9E93 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = DinoRhinoTiles[X]
$03:9E96 C8 INY ; \
$03:9E97 C8 INY ; |
$03:9E98 C8 INY ; } Y += 4: next OAM slot
$03:9E99 C8 INY ; /
$03:9E9A A6 0F LDX $0F ; X = tile counter
$03:9E9C CA DEX ; Next tile
$03:9E9D 10 C0 BPL $9E5F ; Loop for all 4 tiles
$03:9E9F FA PLX ; Restore sprite index
$03:9EA0 A9 03 LDA.B #$03 ; A = 3: four tiles
$03:9EA2 A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:9EA4 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write (size bits, off-screen check)
$03:9EA8 60 RTS ; Return
$03:9EA9 BD 1C 15 LDA.W $151C,X ; A = [$151C] (flame length index; 0 = longest)
$03:9EAC 85 03 STA $03 ; $03 = lowest flame segment to draw
$03:9EAE BD 02 16 LDA.W $1602,X ; A = animation frame [$1602]
$03:9EB1 85 04 STA $04 ; $04 = frame
$03:9EB3 DA PHX ; Save sprite index
$03:9EB4 A5 14 LDA RAM_FrameCounterB ; \
$03:9EB6 29 02 AND.B #$02 ; |
$03:9EB8 0A ASL ; |
$03:9EB9 0A ASL ; |
$03:9EBA 0A ASL ; |
$03:9EBB 0A ASL ; } A = ([$14] & 2) << 5 = $00 or $40: flame flicker flip bit
$03:9EBC 0A ASL ; /
$03:9EBD A6 04 LDX $04 ; X = frame
$03:9EBF E0 03 CPX.B #$03 ; Frame 3?
$03:9EC1 F0 01 BEQ $9EC4 ; Yes: keep H-flip flicker
$03:9EC3 0A ASL ; Other frames: shift again, flicker flips vertically ($80)
$03:9EC4 85 05 STA $05 ; $05 = flicker flip bits
$03:9EC6 A2 04 LDX.B #$04 ; X = 4: start with the head segment
$03:9EC8 86 06 STX $06 ; $06 = current segment index
$03:9ECA A5 04 LDA $04 ; A = frame
$03:9ECC C9 03 CMP.B #$03 ; Frame 3 uses a second set of X offsets
$03:9ECE D0 05 BNE $9ED5
$03:9ED0 8A TXA ; \
$03:9ED1 18 CLC ; |
$03:9ED2 69 05 ADC.B #$05 ; } X = segment + 5 (second row of DinoTorchTileDispX)
$03:9ED4 AA TAX ; /
$03:9ED5 DA PHX ; Save segment index
$03:9ED6 BD FE 9D LDA.W DinoTorchTileDispX,X ; A = X offset of this segment
$03:9ED9 A6 02 LDX $02 ; X = direction
$03:9EDB D0 03 BNE $9EE0 ; Facing right: keep sign
$03:9EDD 49 FF EOR.B #$FF ; \
$03:9EDF 1A INC A ; / Facing left: negate the X offset
$03:9EE0 FA PLX ; X = segment index
$03:9EE1 18 CLC ; \
$03:9EE2 65 00 ADC $00 ; } OAM X = [$00] + X offset
$03:9EE4 99 00 03 STA.W OAM_DispX,Y ; /
$03:9EE7 BD 08 9E LDA.W DinoTorchTileDispY,X ; \
$03:9EEA 18 CLC ; |
$03:9EEB 65 01 ADC $01 ; } OAM Y = [$01] + DinoTorchTileDispY[X]
$03:9EED 99 01 03 STA.W OAM_DispY,Y ; /
$03:9EF0 A5 06 LDA $06 ; A = segment index
$03:9EF2 C9 04 CMP.B #$04 ; Segment 4 is the head/torch tile
$03:9EF4 D0 07 BNE $9EFD ; No: it is a flame tile
$03:9EF6 A6 04 LDX $04 ; X = frame
$03:9EF8 BD 21 9E LDA.W DinoTorchTiles,X ; Head tile = DinoTorchTiles[frame]
$03:9EFB 80 03 BRA $9F00 ; Skip flame tile lookup
$03:9EFD BD 12 9E LDA.W DinoFlameTiles,X ; Flame tile = DinoFlameTiles[X]
$03:9F00 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:9F03 A9 00 LDA.B #$00 ; A = 0
$03:9F05 A6 02 LDX $02 ; X = direction
$03:9F07 D0 02 BNE $9F0B ; Facing left: no flip
$03:9F09 09 40 ORA.B #$40 ; Facing right: X-flip
$03:9F0B A6 06 LDX $06 ; X = segment index
$03:9F0D E0 04 CPX.B #$04 ; Head segment?
$03:9F0F F0 02 BEQ $9F13 ; Yes: no flicker
$03:9F11 45 05 EOR $05 ; Flame segments: apply flicker flip [$05]
$03:9F13 1D 1C 9E ORA.W DinoTorchGfxProp,X ; OR palette/page from DinoTorchGfxProp
$03:9F16 05 64 ORA $64 ; OR priority bits [$64]
$03:9F18 99 03 03 STA.W OAM_Prop,Y ; Store OAM property
$03:9F1B C8 INY ; \
$03:9F1C C8 INY ; |
$03:9F1D C8 INY ; } Y += 4: next OAM slot
$03:9F1E C8 INY ; /
$03:9F1F CA DEX ; Next segment
$03:9F20 E4 03 CPX $03 ; Compare with lowest segment [$03]
$03:9F22 10 A4 BPL $9EC8 ; Loop while segment >= [$03]
$03:9F24 FA PLX ; Restore sprite index
$03:9F25 BC 1C 15 LDY.W $151C,X ; Y = flame length index
$03:9F28 B9 32 9F LDA.W DinoTilesWritten,Y ; A = number of tiles - 1 (DinoTilesWritten)
$03:9F2B A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:9F2D 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:9F31 60 RTS ; Return
;;; $9F32: Table: Dino Torch tile counts (DinoTilesWritten) ;;;
;; Tiles written minus 1 by [$151C] flame length (4..0). Followed by an unreferenced RTS.
$03:9F32 .db $04,$03,$02,$01,$00 ; Tiles written - 1, indexed by [$151C]
$03:9F37 60 RTS ; Unused return
;;; $9F38: Blargg main routine (Blargg) ;;;
;; Draws, then (unless sprites are locked) does Mario interaction, off-screen despawn and runs one of 5 states
;; from [$C2].
;; Parameters: X = sprite index.
;; Called by:
;; $03:A242: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:9F38 20 62 A0 JSR.W $A062 ; Draw Blargg ($A062)
$03:9F3B A5 9D LDA RAM_SpritesLocked ; A = sprites locked flag
$03:9F3D D0 17 BNE $9F56 ; Locked: return
$03:9F3F 22 DC A7 01 JSL.L MarioSprInteract ; Mario/sprite interaction
$03:9F43 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when far off-screen
$03:9F46 B5 C2 LDA RAM_SpriteState,X ; A = Blargg state
$03:9F48 22 DF 86 00 JSL.L ExecutePtr ; Run state routine
;;; $9F4C: Blargg state machine (BlarggPtrs) ;;;
;; State 0 waits hidden in lava; 1 eyes rise; 2 eyes look around; 3 sink and leap; 4 leap and fall back.
;; Home position is saved in [$151C]/[$1528]/[$1534]/[$1594] and restored when Blargg falls back into the
;; lava.
;; Sound $25 on the leap; lava splash via $A045. The pointer table is at the top.
$03:9F4C 57 9F .dw $9F57 ; State 0: waiting in lava for Mario
$03:9F4E 8B 9F .dw $9F8B ; State 1: eyes rise out of the lava
$03:9F50 A4 9F .dw $9FA4 ; State 2: eyes look around
$03:9F52 C8 9F .dw $9FC8 ; State 3: sink, then leap
$03:9F54 EF 9F .dw $9FEF ; State 4: leap out of the lava
$03:9F56 60 RTS ; Return
$03:9F57 BD A0 15 LDA.W RAM_OffscreenHorz,X ; \
$03:9F5A 1D 40 15 ORA.W $1540,X ; } Return if off-screen or wait timer [$1540] still running
$03:9F5D D0 2B BNE $9F8A ; /
$03:9F5F 20 17 B8 JSR.W SubHorzPosBnk3 ; $0F = Mario X - Blargg X
$03:9F62 A5 0F LDA $0F ; A = horizontal distance
$03:9F64 18 CLC ; Clear carry
$03:9F65 69 70 ADC.B #$70 ; Add $70
$03:9F67 C9 E0 CMP.B #$E0 ; Compare with $E0
$03:9F69 B0 1F BCS $9F8A ; Mario more than $70 pixels away: stay hidden
$03:9F6B A9 E3 LDA.B #$E3 ; \
$03:9F6D 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $E3 (rise out of the lava)
$03:9F6F BD E0 14 LDA.W RAM_SpriteXHi,X ; Remember home X high
$03:9F72 9D 1C 15 STA.W $151C,X ; [$151C] = X high
$03:9F75 B5 E4 LDA RAM_SpriteXLo,X ; Remember home X low
$03:9F77 9D 28 15 STA.W $1528,X ; [$1528] = X low
$03:9F7A BD D4 14 LDA.W RAM_SpriteYHi,X ; Remember home Y high
$03:9F7D 9D 34 15 STA.W $1534,X ; [$1534] = Y high
$03:9F80 B5 D8 LDA RAM_SpriteYLo,X ; Remember home Y low
$03:9F82 9D 94 15 STA.W $1594,X ; [$1594] = Y low
$03:9F85 20 C0 9F JSR.W $9FC0 ; Face Mario
$03:9F88 F6 C2 INC RAM_SpriteState,X ; State 1
$03:9F8A 60 RTS ; Return
$03:9F8B B5 AA LDA RAM_SpriteSpeedY,X ; A = Y speed
$03:9F8D C9 10 CMP.B #$10 ; Compare with $10
$03:9F8F 30 0A BMI $9F9B ; Still slower than $10: keep rising
$03:9F91 A9 50 LDA.B #$50 ; \
$03:9F93 9D 40 15 STA.W $1540,X ; / Wait timer [$1540] = $50
$03:9F96 F6 C2 INC RAM_SpriteState,X ; State 2
$03:9F98 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:9F9A 60 RTS ; Return
$03:9F9B 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically, no gravity
$03:9F9F F6 AA INC RAM_SpriteSpeedY,X ; \
$03:9FA1 F6 AA INC RAM_SpriteSpeedY,X ; / Y speed += 2 (slow the rise)
$03:9FA3 60 RTS ; Return
$03:9FA4 BD 40 15 LDA.W $1540,X ; A = wait timer
$03:9FA7 D0 08 BNE $9FB1 ; Still running: go look around
$03:9FA9 F6 C2 INC RAM_SpriteState,X ; Timer expired: state 3
$03:9FAB A9 0A LDA.B #$0A ; \
$03:9FAD 9D 40 15 STA.W $1540,X ; / Timer = $0A: sink for 10 frames
$03:9FB0 60 RTS ; Return
$03:9FB1 C9 20 CMP.B #$20 ; Timer < $20?
$03:9FB3 90 0B BCC $9FC0 ; Yes: track Mario ($9FC0)
$03:9FB5 29 1F AND.B #$1F ; Look back and forth: A = timer & $1F
$03:9FB7 D0 0E BNE $9FC7 ; Only flip direction when it is 0 ($40 and $20)
$03:9FB9 BD 7C 15 LDA.W RAM_SpriteDir,X ; A = direction
$03:9FBC 49 01 EOR.B #$01 ; Flip direction
$03:9FBE 80 04 BRA $9FC4 ; Store it
$03:9FC0 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on (SubHorzPos)
$03:9FC3 98 TYA ; A = side
$03:9FC4 9D 7C 15 STA.W RAM_SpriteDir,X ; Face Mario
$03:9FC7 60 RTS ; Return
$03:9FC8 BD 40 15 LDA.W $1540,X ; A = timer
$03:9FCB F0 09 BEQ $9FD6 ; Timer expired: leap
$03:9FCD A9 20 LDA.B #$20 ; \
$03:9FCF 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $20 (sink)
$03:9FD1 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically
$03:9FD5 60 RTS ; Return
$03:9FD6 A9 20 LDA.B #$20 ; \
$03:9FD8 9D 40 15 STA.W $1540,X ; / Timer = $20
$03:9FDB BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = direction
$03:9FDE B9 ED 9F LDA.W $9FED,Y ; A = X speed by direction
$03:9FE1 95 B6 STA RAM_SpriteSpeedX,X ; Sprite X speed
$03:9FE3 A9 E2 LDA.B #$E2 ; A = $E2
$03:9FE5 95 AA STA RAM_SpriteSpeedY,X ; Y speed = $E2 (leap up)
$03:9FE7 20 45 A0 JSR.W $A045 ; Spawn a lava splash
$03:9FEA F6 C2 INC RAM_SpriteState,X ; State 4
$03:9FEC 60 RTS ; Return
;;; $9FED..9FED: Table: Blargg leap X speeds ;;;
$03:9FED .db $10,$F0 ; X speed: $10 when facing right, $F0 when facing left
;;; $9FEF: Blargg leap state, splash, graphics ;;;
;; State 4: waits [$1540] frames, plays sound $25, moves with gravity, resets to state 0 after falling back
;; (timer $40).
;; $A038 picks frame 1 (mouth open) at the top of the leap. $A045 spawns a lava splash $0C above
;; the sprite.
;; $A062 draws: state 0 nothing, states 1-3 an eyes tile with priority bits cleared, state 4 the full
;; head ($A09D).
$03:9FEF 9E 02 16 STZ.W $1602,X ; Frame = 0 (mouth closed)
$03:9FF2 BD 40 15 LDA.W $1540,X ; A = timer
$03:9FF5 F0 0B BEQ $A002 ; Timer 0: move now
$03:9FF7 3A DEC A ; Timer - 1
$03:9FF8 D0 3E BNE $A038 ; Timer was above 1: keep waiting
$03:9FFA A9 25 LDA.B #$25 ; \
$03:9FFC 8D F9 1D STA.W $1DF9 ; / Play sound effect $25 (probably the roar)
$03:9FFF 20 45 A0 JSR.W $A045 ; Spawn a lava splash
$03:A002 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed
$03:A006 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed
$03:A00A A5 13 LDA RAM_FrameCounter ; A = frame counter
$03:A00C 29 00 AND.B #$00 ; AND #$00: always 0 (leftover)
$03:A00E D0 02 BNE $A012 ; Always taken to the gravity step
$03:A010 F6 AA INC RAM_SpriteSpeedY,X ; Y speed++ (gravity every frame)
$03:A012 B5 AA LDA RAM_SpriteSpeedY,X ; A = Y speed
$03:A014 C9 20 CMP.B #$20 ; Compare with $20
$03:A016 30 20 BMI $A038 ; Below $20: still airborne
$03:A018 20 45 A0 JSR.W $A045 ; Back in lava: splash
$03:A01B 74 C2 STZ RAM_SpriteState,X ; State 0: hide again
$03:A01D BD 1C 15 LDA.W $151C,X ; Restore X high from [$151C]
$03:A020 9D E0 14 STA.W RAM_SpriteXHi,X ; X high
$03:A023 BD 28 15 LDA.W $1528,X ; Restore X low from [$1528]
$03:A026 95 E4 STA RAM_SpriteXLo,X ; X low
$03:A028 BD 34 15 LDA.W $1534,X ; Restore Y high from [$1534]
$03:A02B 9D D4 14 STA.W RAM_SpriteYHi,X ; Y high
$03:A02E BD 94 15 LDA.W $1594,X ; Restore Y low from [$1594]
$03:A031 95 D8 STA RAM_SpriteYLo,X ; Y low
$03:A033 A9 40 LDA.B #$40 ; \
$03:A035 9D 40 15 STA.W $1540,X ; / Timer = $40 before it can rise again
$03:A038 B5 AA LDA RAM_SpriteSpeedY,X ; A = Y speed
$03:A03A 18 CLC ; Clear carry
$03:A03B 69 06 ADC.B #$06 ; Add 6
$03:A03D C9 0C CMP.B #$0C ; Compare with $0C
$03:A03F B0 03 BCS $A044 ; Speed outside -6..+5: keep frame 0
$03:A041 FE 02 16 INC.W $1602,X ; Near the top of the leap: frame 1 (mouth open)
$03:A044 60 RTS ; Return
$03:A045 B5 D8 LDA RAM_SpriteYLo,X ; A = Y low
$03:A047 48 PHA ; Save it
$03:A048 38 SEC ; Set carry
$03:A049 E9 0C SBC.B #$0C ; \
$03:A04B 95 D8 STA RAM_SpriteYLo,X ; / Y low -= $0C (splash just above the sprite)
$03:A04D BD D4 14 LDA.W RAM_SpriteYHi,X ; A = Y high
$03:A050 48 PHA ; Save it
$03:A051 E9 00 SBC.B #$00 ; \
$03:A053 9D D4 14 STA.W RAM_SpriteYHi,X ; / Y high -= borrow
$03:A056 22 28 85 02 JSL.L $8528 ; Spawn lava splash extended sprite ($8528)
$03:A05A 68 PLA ; Restore Y high
$03:A05B 9D D4 14 STA.W RAM_SpriteYHi,X ; Y high
$03:A05E 68 PLA ; Restore Y low
$03:A05F 95 D8 STA RAM_SpriteYLo,X ; Y low
$03:A061 60 RTS ; Return
$03:A062 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and position
$03:A065 B5 C2 LDA RAM_SpriteState,X ; A = state
$03:A067 F0 CF BEQ $A038 ; State 0: hidden, skip drawing
$03:A069 C9 04 CMP.B #$04 ; State 4?
$03:A06B F0 30 BEQ $A09D ; Yes: draw the full head
$03:A06D 22 B2 90 01 JSL.L GenericSprGfxRt2 ; States 1-3: draw one 16x16 tile (GenericSprGfxRt2)
$03:A071 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:A074 A9 A0 LDA.B #$A0 ; \
$03:A076 99 02 03 STA.W OAM_Tile,Y ; / Tile = $A0 (eyes)
$03:A079 B9 03 03 LDA.W OAM_Prop,Y ; \
$03:A07C 29 CF AND.B #$CF ; } Clear priority bits so it is drawn behind the lava layer
$03:A07E 99 03 03 STA.W OAM_Prop,Y ; /
$03:A081 60 RTS ; Return
;;; $A082..A08A: Table: Blargg tile X offsets ;;;
$03:A082 .db $F8,$08,$F8,$08,$18,$08,$F8,$08 ; X offsets: tiles 0-4 (right), 5-9 (left, X += 5)
$03:A08A .db $F8,$E8 ; X offsets, mirrored set (end)
;;; $A08C..A08C: Table: Blargg tile Y offsets ;;;
$03:A08C .db $F8,$F8,$08,$08,$08 ; Y offsets of the five head tiles
;;; $A091: Blargg head draw, Bowser scene init (BlarggTilemap) ;;;
;; BlarggTilemap: 5 tiles per frame (2 frames). $A09D draws the 5-tile head, mirrored by direction.
;; $A0F1: init for the Bowser scene sprite (called from InitBowserScene in bank 1): places it at X
;; $00D0, Y $FF80, state 3.
$03:A091 .db $A2,$A4,$C2,$C4,$A6,$A2,$A4,$E6 ; Head tiles, frame 0 ($A2,$A4,$C2,$C4,$A6), then frame 1
$03:A099 .db $C8,$A6 ; Frame 1 tiles (end): $C8,$A6
$03:A09B .db $45,$05 ; OAM property by direction: $45 (X-flip) / $05
$03:A09D BD 02 16 LDA.W $1602,X ; \
$03:A0A0 0A ASL ; |
$03:A0A1 0A ASL ; |
$03:A0A2 7D 02 16 ADC.W $1602,X ; } $03 = frame * 5 (index into BlarggTilemap)
$03:A0A5 85 03 STA $03 ; /
$03:A0A7 BD 7C 15 LDA.W RAM_SpriteDir,X ; A = direction
$03:A0AA 85 02 STA $02 ; $02 = direction
$03:A0AC DA PHX ; Save sprite index
$03:A0AD A2 04 LDX.B #$04 ; X = 4: five tiles
$03:A0AF DA PHX ; Save tile counter
$03:A0B0 DA PHX ; Save it again
$03:A0B1 A5 01 LDA $01 ; \
$03:A0B3 18 CLC ; |
$03:A0B4 7D 8C A0 ADC.W $A08C,X ; } OAM Y = [$01] + $A08C[X]
$03:A0B7 99 01 03 STA.W OAM_DispY,Y ; /
$03:A0BA A5 02 LDA $02 ; A = direction
$03:A0BC D0 05 BNE $A0C3 ; Facing right: keep index
$03:A0BE 8A TXA ; \
$03:A0BF 18 CLC ; |
$03:A0C0 69 05 ADC.B #$05 ; } Facing left: X += 5 (mirrored X offsets)
$03:A0C2 AA TAX ; /
$03:A0C3 A5 00 LDA $00 ; \
$03:A0C5 18 CLC ; |
$03:A0C6 7D 82 A0 ADC.W $A082,X ; } OAM X = [$00] + $A082[X]
$03:A0C9 99 00 03 STA.W OAM_DispX,Y ; /
$03:A0CC 68 PLA ; \
$03:A0CD 18 CLC ; |
$03:A0CE 65 03 ADC $03 ; |
$03:A0D0 AA TAX ; |
$03:A0D1 BD 91 A0 LDA.W BlarggTilemap,X ; } OAM tile = BlarggTilemap[tile counter + frame * 5]
$03:A0D4 99 02 03 STA.W OAM_Tile,Y ; /
$03:A0D7 A6 02 LDX $02 ; X = direction
$03:A0D9 BD 9B A0 LDA.W $A09B,X ; A = property for this direction
$03:A0DC 99 03 03 STA.W OAM_Prop,Y ; Store OAM property
$03:A0DF FA PLX ; X = tile counter
$03:A0E0 C8 INY ; \
$03:A0E1 C8 INY ; |
$03:A0E2 C8 INY ; } Y += 4: next OAM slot
$03:A0E3 C8 INY ; /
$03:A0E4 CA DEX ; Next tile
$03:A0E5 10 C8 BPL $A0AF ; Loop for 5 tiles
$03:A0E7 FA PLX ; Restore sprite index
$03:A0E8 A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:A0EA A9 04 LDA.B #$04 ; A = 4: five tiles
$03:A0EC 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:A0F0 60 RTS ; Return
$03:A0F1 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize sprite tables
$03:A0F5 9E A0 15 STZ.W RAM_OffscreenHorz,X ; Not off-screen horizontally
$03:A0F8 A9 80 LDA.B #$80 ; \
$03:A0FA 95 D8 STA RAM_SpriteYLo,X ; / Y low = $80
$03:A0FC A9 FF LDA.B #$FF ; \
$03:A0FE 9D D4 14 STA.W RAM_SpriteYHi,X ; / Y high = $FF (above the screen)
$03:A101 A9 D0 LDA.B #$D0 ; \
$03:A103 95 E4 STA RAM_SpriteXLo,X ; / X low = $D0
$03:A105 A9 00 LDA.B #$00 ; \
$03:A107 9D E0 14 STA.W RAM_SpriteXHi,X ; / X high = 0
$03:A10A A9 02 LDA.B #$02 ; \
$03:A10C 9D 7B 18 STA.W $187B,X ; / [$187B] = 2 (hit counter, probably)
$03:A10F A9 03 LDA.B #$03 ; \
$03:A111 95 C2 STA RAM_SpriteState,X ; / State = 3
$03:A113 22 7D DD 03 JSL.L $DD7D ; Set up the Bowser scene (palette, scroll, Mode 7 state)
$03:A117 6B RTL ; Return
;;; $A118: Bank 3 sprite main dispatch (Bnk3CallSprMain) ;;;
;; Called with X = sprite index. Compares the sprite number with a chain of values and JSRs the matching main
;; routine (Light switch, Ninji, Peach, Reznor, Blargg, ...).
;; Falls through to BowserFight when nothing matches. Always restores the data bank and returns with RTL.
;; Called by:
;; $01:878E: Run Run bank $03 sprite main (Bank3SprHandler)
$03:A118 8B PHB ; Save data bank
$03:A119 4B PHK ; Data bank = program bank
$03:A11A AB PLB ; Bank 3
$03:A11B B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:A11D C9 C8 CMP.B #$C8 ; Sprite C8?
$03:A11F D0 05 BNE $A126 ; No: check next sprite
$03:A121 20 F5 C1 JSR.W LightSwitch ; Run Light switch
$03:A124 AB PLB ; Restore data bank
$03:A125 6B RTL ; Return
$03:A126 C9 C7 CMP.B #$C7 ; Sprite C7?
$03:A128 D0 05 BNE $A12F ; No: check next sprite
$03:A12A 20 0F C3 JSR.W InvisMushroom ; Run Invisible mushroom
$03:A12D AB PLB ; Restore data bank
$03:A12E 6B RTL ; Return
$03:A12F C9 51 CMP.B #$51 ; Sprite 51?
$03:A131 D0 05 BNE $A138 ; No: check next sprite
$03:A133 20 4C C3 JSR.W Ninji ; Run Ninji
$03:A136 AB PLB ; Restore data bank
$03:A137 6B RTL ; Return
$03:A138 C9 1B CMP.B #$1B ; Sprite 1B?
$03:A13A D0 05 BNE $A141 ; No: check next sprite
$03:A13C 20 12 80 JSR.W Football ; Run Football
$03:A13F AB PLB ; Restore data bank
$03:A140 6B RTL ; Return
$03:A141 C9 C6 CMP.B #$C6 ; Sprite C6?
$03:A143 D0 05 BNE $A14A ; No: check next sprite
$03:A145 20 DC C4 JSR.W DarkRoomWithLight ; Run Dark room with light
$03:A148 AB PLB ; Restore data bank
$03:A149 6B RTL ; Return
$03:A14A C9 7A CMP.B #$7A ; Sprite 7A?
$03:A14C D0 05 BNE $A153 ; No: check next sprite
$03:A14E 20 16 C8 JSR.W Firework ; Run Firework
$03:A151 AB PLB ; Restore data bank
$03:A152 6B RTL ; Return
$03:A153 C9 7C CMP.B #$7C ; Sprite 7C?
$03:A155 D0 05 BNE $A15C ; No: check next sprite
$03:A157 20 97 AC JSR.W PrincessPeach ; Run Princess Peach
$03:A15A AB PLB ; Restore data bank
$03:A15B 6B RTL ; Return
$03:A15C C9 C5 CMP.B #$C5 ; Sprite C5?
$03:A15E D0 05 BNE $A165 ; No: check next sprite
$03:A160 20 87 80 JSR.W BigBooBoss ; Run Big Boo boss
$03:A163 AB PLB ; Restore data bank
$03:A164 6B RTL ; Return
$03:A165 C9 C4 CMP.B #$C4 ; Sprite C4?
$03:A167 D0 05 BNE $A16E ; No: check next sprite
$03:A169 20 54 84 JSR.W GreyFallingPlat ; Run Grey falling platform
$03:A16C AB PLB ; Restore data bank
$03:A16D 6B RTL ; Return
$03:A16E C9 C2 CMP.B #$C2 ; Sprite C2?
$03:A170 D0 05 BNE $A177 ; No: check next sprite
$03:A172 20 CA 84 JSR.W Blurp ; Run Blurp
$03:A175 AB PLB ; Restore data bank
$03:A176 6B RTL ; Return
$03:A177 C9 C3 CMP.B #$C3 ; Sprite C3?
$03:A179 D0 05 BNE $A180 ; No: check next sprite
$03:A17B 20 2F 85 JSR.W PorcuPuffer ; Run Porcu-Puffer
$03:A17E AB PLB ; Restore data bank
$03:A17F 6B RTL ; Return
$03:A180 C9 C1 CMP.B #$C1 ; Sprite C1?
$03:A182 D0 05 BNE $A189 ; No: check next sprite
$03:A184 20 F6 85 JSR.W FlyingTurnBlocks ; Run Flying turn blocks
$03:A187 AB PLB ; Restore data bank
$03:A188 6B RTL ; Return
$03:A189 C9 C0 CMP.B #$C0 ; Sprite C0?
$03:A18B D0 05 BNE $A192 ; No: check next sprite
$03:A18D 20 FF 86 JSR.W GrayLavaPlatform ; Run Gray lava platform
$03:A190 AB PLB ; Restore data bank
$03:A191 6B RTL ; Return
$03:A192 C9 BF CMP.B #$BF ; Sprite BF?
$03:A194 D0 05 BNE $A19B ; No: check next sprite
$03:A196 20 70 87 JSR.W MegaMole ; Run Mega Mole
$03:A199 AB PLB ; Restore data bank
$03:A19A 6B RTL ; Return
$03:A19B C9 BE CMP.B #$BE ; Sprite BE?
$03:A19D D0 05 BNE $A1A4 ; No: check next sprite
$03:A19F 20 A3 88 JSR.W Swooper ; Run Swooper
$03:A1A2 AB PLB ; Restore data bank
$03:A1A3 6B RTL ; Return
$03:A1A4 C9 BD CMP.B #$BD ; Sprite BD?
$03:A1A6 D0 05 BNE $A1AD ; No: check next sprite
$03:A1A8 20 58 89 JSR.W SlidingKoopa ; Run Sliding Koopa
$03:A1AB AB PLB ; Restore data bank
$03:A1AC 6B RTL ; Return
$03:A1AD C9 BC CMP.B #$BC ; Sprite BC?
$03:A1AF D0 05 BNE $A1B6 ; No: check next sprite
$03:A1B1 20 3C 8A JSR.W BowserStatue ; Run Bowser statue
$03:A1B4 AB PLB ; Restore data bank
$03:A1B5 6B RTL ; Return
$03:A1B6 C9 B8 CMP.B #$B8 ; Sprite B8?
$03:A1B8 F0 04 BEQ $A1BE ; Yes: Carrot top lift
$03:A1BA C9 B7 CMP.B #$B7 ; Sprite B7?
$03:A1BC D0 05 BNE $A1C3 ; No: next
$03:A1BE 20 2F 8C JSR.W CarrotTopLift ; Run Carrot top lift (B7/B8)
$03:A1C1 AB PLB ; Restore data bank
$03:A1C2 6B RTL ; Return
$03:A1C3 C9 B9 CMP.B #$B9 ; Sprite B9?
$03:A1C5 D0 05 BNE $A1CC ; No: check next sprite
$03:A1C7 20 6F 8D JSR.W InfoBox ; Run Info box
$03:A1CA AB PLB ; Restore data bank
$03:A1CB 6B RTL ; Return
$03:A1CC C9 BA CMP.B #$BA ; Sprite BA?
$03:A1CE D0 05 BNE $A1D5 ; No: check next sprite
$03:A1D0 20 BB 8D JSR.W TimedLift ; Run Timed lift
$03:A1D3 AB PLB ; Restore data bank
$03:A1D4 6B RTL ; Return
$03:A1D5 C9 BB CMP.B #$BB ; Sprite BB?
$03:A1D7 D0 05 BNE $A1DE ; No: check next sprite
$03:A1D9 20 79 8E JSR.W GreyCastleBlock ; Run Grey castle block
$03:A1DC AB PLB ; Restore data bank
$03:A1DD 6B RTL ; Return
$03:A1DE C9 B3 CMP.B #$B3 ; Sprite B3?
$03:A1E0 D0 05 BNE $A1E7 ; No: check next sprite
$03:A1E2 20 EC 8E JSR.W StatueFireball ; Run Statue fireball
$03:A1E5 AB PLB ; Restore data bank
$03:A1E6 6B RTL ; Return
$03:A1E7 B5 9E LDA RAM_SpriteNum,X ; A = sprite number
$03:A1E9 C9 B2 CMP.B #$B2 ; Sprite B2?
$03:A1EB D0 05 BNE $A1F2 ; No: check next sprite
$03:A1ED 20 14 92 JSR.W FallingSpike ; Run Falling spike
$03:A1F0 AB PLB ; Restore data bank
$03:A1F1 6B RTL ; Return
$03:A1F2 C9 AE CMP.B #$AE ; Sprite AE?
$03:A1F4 D0 05 BNE $A1FB ; No: check next sprite
$03:A1F6 20 65 90 JSR.W FishinBoo ; Run Fishin Boo
$03:A1F9 AB PLB ; Restore data bank
$03:A1FA 6B RTL ; Return
$03:A1FB C9 B6 CMP.B #$B6 ; Sprite B6?
$03:A1FD D0 05 BNE $A204 ; No: check next sprite
$03:A1FF 20 75 8F JSR.W ReflectingFireball ; Run Reflecting fireball
$03:A202 AB PLB ; Restore data bank
$03:A203 6B RTL ; Return
$03:A204 C9 B0 CMP.B #$B0 ; Sprite B0?
$03:A206 D0 05 BNE $A20D ; No: check next sprite
$03:A208 20 7A 8F JSR.W BooStream ; Run Boo stream
$03:A20B AB PLB ; Restore data bank
$03:A20C 6B RTL ; Return
$03:A20D C9 B1 CMP.B #$B1 ; Sprite B1?
$03:A20F D0 05 BNE $A216 ; No: check next sprite
$03:A211 20 84 92 JSR.W CreateEatBlock ; Run Create/eat block
$03:A214 AB PLB ; Restore data bank
$03:A215 6B RTL ; Return
$03:A216 C9 AC CMP.B #$AC ; Sprite AC?
$03:A218 F0 04 BEQ $A21E ; Yes: wooden spike
$03:A21A C9 AD CMP.B #$AD ; Sprite AD?
$03:A21C D0 05 BNE $A223 ; No: next
$03:A21E 20 23 94 JSR.W WoodenSpike ; Run Wooden spike (AC/AD)
$03:A221 AB PLB ; Restore data bank
$03:A222 6B RTL ; Return
$03:A223 C9 AB CMP.B #$AB ; Sprite AB?
$03:A225 D0 05 BNE $A22C ; No: check next sprite
$03:A227 20 17 95 JSR.W RexMainRt ; Run Rex
$03:A22A AB PLB ; Restore data bank
$03:A22B 6B RTL ; Return
$03:A22C C9 AA CMP.B #$AA ; Sprite AA?
$03:A22E D0 05 BNE $A235 ; No: check next sprite
$03:A230 20 F6 96 JSR.W Fishbone ; Run Fishbone
$03:A233 AB PLB ; Restore data bank
$03:A234 6B RTL ; Return
$03:A235 C9 A9 CMP.B #$A9 ; Sprite A9?
$03:A237 D0 05 BNE $A23E ; No: check next sprite
$03:A239 20 90 98 JSR.W Reznor ; Run Reznor
$03:A23C AB PLB ; Restore data bank
$03:A23D 6B RTL ; Return
$03:A23E C9 A8 CMP.B #$A8 ; Sprite A8?
$03:A240 D0 05 BNE $A247 ; No: check next sprite
$03:A242 20 38 9F JSR.W Blargg ; Run Blargg
$03:A245 AB PLB ; Restore data bank
$03:A246 6B RTL ; Return
$03:A247 C9 A1 CMP.B #$A1 ; Sprite A1?
$03:A249 D0 05 BNE $A250 ; No: check next sprite
$03:A24B 20 63 B1 JSR.W BowserBowlingBall ; Run Bowser bowling ball
$03:A24E AB PLB ; Restore data bank
$03:A24F 6B RTL ; Return
$03:A250 C9 A2 CMP.B #$A2 ; Sprite A2?
$03:A252 D0 05 BNE BowserFight ; No: Bowser
$03:A254 20 A9 B2 JSR.W MechaKoopa ; Run Mechakoopa (A2)
$03:A257 AB PLB ; Restore data bank
$03:A258 6B RTL ; Return
;;; $A259: Bowser fight sprite main (BowserFight) ;;;
;; Fallthrough target for unmatched sprite numbers: lightning/palette update, Bowser logic, item box and scene
;; graphics.
$03:A259 22 CC DF 03 JSL.L $DFCC ; Update Bowser room lightning/palette flashes ($DFCC)
$03:A25D 20 79 A2 JSR.W $A279 ; Bowser main logic ($A279)
$03:A260 20 3C B4 JSR.W $B43C ; Draw item box and Bowser scene ($B43C)
$03:A263 AB PLB ; Restore data bank
$03:A264 6B RTL ; Return
;;; $A265..A275: Table: Bowser animation values ;;;
;; [$1429] by [$38] / 8 (20 entries, probably Bowser animation).
$03:A265 .db $04,$03,$02,$01,$00,$01,$02,$03 ; [$1429] values by [$38] / 8
$03:A26D .db $04,$05,$06,$07,$07,$07,$07,$07 ; [$1429] values (cont.)
$03:A275 .db $07,$07,$07,$07 ; [$1429] values (end)
;;; $A279: Bowser main logic ;;;
;; Sets animation values [$1428]/[$1429]/[$1BA2] and Mode 7 center, runs hurt/hit timers ([$14B5], [$14B0],
;; [$14B1]), Mario interaction, applies speed and runs state [$151C] via BowserFightPtrs.
;; Names of $14Bx timers are inferred, not verified.
;; Called by:
;; $03:A25D: Bowser fight sprite main (BowserFight)
$03:A279 A5 38 LDA $38 ; \
$03:A27B 4A LSR ; |
$03:A27C 4A LSR ; |
$03:A27D 4A LSR ; } Y = [$38] / 8
$03:A27E A8 TAY ; /
$03:A27F B9 65 A2 LDA.W $A265,Y ; \
$03:A282 8D 29 14 STA.W $1429 ; / [$1429] = $A265[Y] (Bowser animation frame, probably)
$03:A285 BD 70 15 LDA.W $1570,X ; \
$03:A288 18 CLC ; |
$03:A289 69 1E ADC.B #$1E ; |
$03:A28B 1D 7C 15 ORA.W RAM_SpriteDir,X ; } [$1BA2] = [$1570] + $1E, OR direction (Bowser image index, probably)
$03:A28E 8D A2 1B STA.W $1BA2 ; /
$03:A291 A5 14 LDA RAM_FrameCounterB ; \
$03:A293 4A LSR ; |
$03:A294 29 03 AND.B #$03 ; } [$1428] = ([$14] >> 1) & 3: four-step animation counter
$03:A296 8D 28 14 STA.W $1428 ; /
$03:A299 A9 90 LDA.B #$90 ; \
$03:A29B 85 2A STA $2A ; / Mode 7 center X = $90
$03:A29D A9 C8 LDA.B #$C8 ; \
$03:A29F 85 2C STA $2C ; / Mode 7 center Y = $C8
$03:A2A1 22 DF DE 03 JSL.L $DEDF ; Update Bowser Mode 7 position from sprite X/Y ($DEDF)
$03:A2A5 AD B5 14 LDA.W $14B5 ; A = [$14B5] (Bowser hurt timer, probably)
$03:A2A8 F0 03 BEQ $A2AD ; Zero: skip
$03:A2AA 20 59 AF JSR.W $AF59 ; Draw circling stars ($AF59)
$03:A2AD BD 64 15 LDA.W $1564,X ; A = [$1564,X]
$03:A2B0 F0 03 BEQ $A2B5 ; Zero: skip
$03:A2B2 20 E2 A3 JSR.W $A3E2 ; Draw expanding particle burst ($A3E2)
$03:A2B5 BD 94 15 LDA.W $1594,X ; A = [$1594,X]
$03:A2B8 F0 14 BEQ $A2CE ; Zero: skip
$03:A2BA 3A DEC A ; \
$03:A2BB 4A LSR ; |
$03:A2BC 4A LSR ; |
$03:A2BD 48 PHA ; |
$03:A2BE 4A LSR ; } Y = ([$1594] - 1) / 8; keep ([$1594] - 1) / 4 on the stack
$03:A2BF A8 TAY ; /
$03:A2C0 B9 BE A8 LDA.W $A8BE,Y ; A = $A8BE[Y]
$03:A2C3 85 02 STA $02 ; $02 = offset
$03:A2C5 68 PLA ; \
$03:A2C6 29 03 AND.B #$03 ; } $03 = ([$1594] - 1) / 4 & 3
$03:A2C8 85 03 STA $03 ; /
$03:A2CA 20 6E AA JSR.W $AA6E ; Draw the effect ($AA6E)
$03:A2CD EA NOP ; NOP
$03:A2CE A5 9D LDA RAM_SpritesLocked ; A = sprites locked flag
$03:A2D0 D0 6E BNE $A340 ; Locked: return
$03:A2D2 9E 94 15 STZ.W $1594,X ; Clear [$1594]
$03:A2D5 A9 30 LDA.B #$30 ; \
$03:A2D7 85 64 STA $64 ; / Sprite priority [$64] = $30
$03:A2D9 A5 38 LDA $38 ; A = [$38]
$03:A2DB C9 20 CMP.B #$20 ; Compare with $20
$03:A2DD B0 02 BCS $A2E1 ; >= $20: keep priority
$03:A2DF 64 64 STZ $64 ; Below $20: priority = 0
$03:A2E1 20 61 A6 JSR.W $A661 ; Handle the hurt timer [$14B5] ($A661)
$03:A2E4 AD B0 14 LDA.W $14B0 ; A = [$14B0]
$03:A2E7 F0 09 BEQ $A2F2 ; Zero: skip
$03:A2E9 A5 13 LDA RAM_FrameCounter ; A = frame counter
$03:A2EB 29 03 AND.B #$03 ; Every 4th frame
$03:A2ED D0 03 BNE $A2F2 ; Not this frame
$03:A2EF CE B0 14 DEC.W $14B0 ; [$14B0]--
$03:A2F2 A5 13 LDA RAM_FrameCounter ; A = frame counter
$03:A2F4 29 7F AND.B #$7F ; Every 128 frames
$03:A2F6 D0 0D BNE $A305 ; Not this frame
$03:A2F8 22 F9 AC 01 JSL.L GetRand ; A = random
$03:A2FC 29 01 AND.B #$01 ; 50 percent chance
$03:A2FE D0 05 BNE $A305 ; Skip
$03:A300 A9 0C LDA.B #$0C ; \
$03:A302 9D 58 15 STA.W $1558,X ; / [$1558] = $0C (blink/mouth timer, probably)
$03:A305 20 78 B0 JSR.W $B078 ; Mario interaction with Bowser ($B078)
$03:A308 BD 1C 15 LDA.W $151C,X ; A = Bowser state [$151C]
$03:A30B C9 09 CMP.B #$09 ; State 9?
$03:A30D F0 0B BEQ $A31A ; Yes: skip
$03:A30F 9C 27 14 STZ.W $1427 ; [$1427] = 0
$03:A312 BD 58 15 LDA.W $1558,X ; A = [$1558]
$03:A315 F0 03 BEQ $A31A ; Zero: skip
$03:A317 EE 27 14 INC.W $1427 ; [$1427] = 1 while the timer runs
$03:A31A 20 AD A5 JSR.W $A5AD ; Handle timer [$14B1] ($A5AD)
$03:A31D 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Apply X speed
$03:A321 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed
$03:A325 BD 1C 15 LDA.W $151C,X ; A = Bowser state
$03:A328 22 DF 86 00 JSL.L ExecutePtr ; Run state routine
;;; $A32C: Pointer table: Bowser states (BowserFightPtrs) ;;;
;; 10 states indexed by [$151C].
$03:A32C 41 A4 .dw $A441 ; State 0
$03:A32E F8 A6 .dw $A6F8 ; State 1
$03:A330 4B A8 .dw $A84B ; State 2
$03:A332 AD A7 .dw $A7AD ; State 3
$03:A334 9F AB .dw $AB9F ; State 4
$03:A336 BE AB .dw $ABBE ; State 5
$03:A338 03 AC .dw $AC03 ; State 6
$03:A33A 9C A4 .dw $A49C ; State 7
$03:A33C 21 AB .dw $AB21 ; State 8
$03:A33E 64 AB .dw $AB64 ; State 9
$03:A340 60 RTS ; Return
;;; $A341..A381: Table: burst particle X offsets ;;;
;; 9 phases of 8 signed offsets.
$03:A341 .db $D5,$DD,$23,$2B,$D5,$DD,$23,$2B ; Burst X offsets, phase 0
$03:A349 .db $D5,$DD,$23,$2B,$D5,$DD,$23,$2B ; Burst X offsets, phase 1
$03:A351 .db $D6,$DE,$22,$2A,$D6,$DE,$22,$2A ; Burst X offsets, phase 2
$03:A359 .db $D7,$DF,$21,$29,$D7,$DF,$21,$29 ; Burst X offsets, phase 3
$03:A361 .db $D8,$E0,$20,$28,$D8,$E0,$20,$28 ; Burst X offsets, phase 4
$03:A369 .db $DA,$E2,$1E,$26,$DA,$E2,$1E,$26 ; Burst X offsets, phase 5
$03:A371 .db $DC,$E4,$1C,$24,$DC,$E4,$1C,$24 ; Burst X offsets, phase 6
$03:A379 .db $E0,$E8,$18,$20,$E0,$E8,$18,$20 ; Burst X offsets, phase 7
$03:A381 .db $E8,$F0,$10,$18,$E8,$F0,$10,$18 ; Burst X offsets, phase 8
;;; $A389..A3C9: Table: burst particle Y offsets ;;;
;; 9 phases of 8 signed offsets.
$03:A389 .db $DD,$D5,$D5,$DD,$23,$2B,$2B,$23 ; Burst Y offsets, phase 0
$03:A391 .db $DD,$D5,$D5,$DD,$23,$2B,$2B,$23 ; Burst Y offsets, phase 1
$03:A399 .db $DE,$D6,$D6,$DE,$22,$2A,$2A,$22 ; Burst Y offsets, phase 2
$03:A3A1 .db $DF,$D7,$D7,$DF,$21,$29,$29,$21 ; Burst Y offsets, phase 3
$03:A3A9 .db $E0,$D8,$D8,$E0,$20,$28,$28,$20 ; Burst Y offsets, phase 4
$03:A3B1 .db $E2,$DA,$DA,$E2,$1E,$26,$26,$1E ; Burst Y offsets, phase 5
$03:A3B9 .db $E4,$DC,$DC,$E4,$1C,$24,$24,$1C ; Burst Y offsets, phase 6
$03:A3C1 .db $E8,$E0,$E0,$E8,$18,$20,$20,$18 ; Burst Y offsets, phase 7
$03:A3C9 .db $F0,$E8,$E8,$F0,$10,$18,$18,$10 ; Burst Y offsets, phase 8
;;; $A3D1..A3E1: Table: burst particle properties and tiles ;;;
;; OAM properties for 8 particles, then tiles by phase.
$03:A3D1 .db $80,$40,$00,$C0,$00,$C0,$80,$40 ; OAM properties (flips) of the 8 burst particles
$03:A3D9 .db $E3,$ED,$ED,$EB,$EB,$E9,$E9,$E7 ; Burst tiles by phase 0-7
$03:A3E1 .db $E7 ; Burst tile for phase 8
;;; $A3E2: Draw expanding particle burst ;;;
;; Draws 8 particles using OAM slots from $70, phase from [$1564]; they move outward as the timer counts down.
;; Called by:
;; $03:A2B2: Bowser main logic
$03:A3E2 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM index and position
$03:A3E5 BD 64 15 LDA.W $1564,X ; A = [$1564]
$03:A3E8 3A DEC A ; \
$03:A3E9 4A LSR ; } $03 = phase = ([$1564] - 1) / 2
$03:A3EA 85 03 STA $03 ; /
$03:A3EC 0A ASL ; \
$03:A3ED 0A ASL ; |
$03:A3EE 0A ASL ; } $02 = phase * 8 (row offset into the tables)
$03:A3EF 85 02 STA $02 ; /
$03:A3F1 A9 70 LDA.B #$70 ; \
$03:A3F3 9D EA 15 STA.W RAM_SprOAMIndex,X ; / Use OAM slots starting at $70
$03:A3F6 A8 TAY ; Y = OAM index
$03:A3F7 DA PHX ; Save sprite index
$03:A3F8 A2 07 LDX.B #$07 ; X = 7: eight particles
$03:A3FA DA PHX ; Save particle counter
$03:A3FB 8A TXA ; \
$03:A3FC 05 02 ORA $02 ; } X = phase row | particle
$03:A3FE AA TAX ; /
$03:A3FF A5 00 LDA $00 ; \
$03:A401 18 CLC ; |
$03:A402 7D 41 A3 ADC.W $A341,X ; |
$03:A405 18 CLC ; |
$03:A406 69 08 ADC.B #$08 ; } OAM X = [$00] + $A341[X] + 8
$03:A408 99 00 03 STA.W OAM_DispX,Y ; /
$03:A40B A5 01 LDA $01 ; \
$03:A40D 18 CLC ; |
$03:A40E 7D 89 A3 ADC.W $A389,X ; |
$03:A411 18 CLC ; |
$03:A412 69 30 ADC.B #$30 ; } OAM Y = [$01] + $A389[X] + $30
$03:A414 99 01 03 STA.W OAM_DispY,Y ; /
$03:A417 A6 03 LDX $03 ; \
$03:A419 BD D9 A3 LDA.W $A3D9,X ; } OAM tile = $A3D9[phase]
$03:A41C 99 02 03 STA.W OAM_Tile,Y ; /
$03:A41F FA PLX ; X = particle counter
$03:A420 BD D1 A3 LDA.W $A3D1,X ; \
$03:A423 99 03 03 STA.W OAM_Prop,Y ; / OAM property = $A3D1[X]
$03:A426 C8 INY ; \
$03:A427 C8 INY ; |
$03:A428 C8 INY ; } Y += 4: next OAM slot
$03:A429 C8 INY ; /
$03:A42A CA DEX ; Next particle
$03:A42B 10 CD BPL $A3FA ; Loop for 8 particles
$03:A42D FA PLX ; Restore sprite index
$03:A42E A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:A430 A9 07 LDA.B #$07 ; A = 7: eight tiles
$03:A432 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:A436 60 RTS ; Return
;;; $A437..A43F: Table: Bowser state data, purpose unclear ;;;
$03:A437 .db $00,$00,$00,$00,$02,$04,$06,$08 ; Bowser state table (indexed by Y), purpose unclear
$03:A43F .db $0A,$0E ; Table continues
;;; $A441: Bowser state 0: enter and start fight ;;;
;; Bowser main routine state 0 ([$151C] = 0). Bowser descends from the top of the screen to line $10, pauses
;; for [$1540] frames animating his face,
;; then sets [$154C] and switches to state 7 with the attack timer [$14B0] = $78. Ending at $03A482 is the
;; state change itself.
;; Quirk: [$154C] is used here as a delay timer, not only for interaction.
$03:A441 BD 4C 15 LDA.W RAM_DisableInter,X ; Interaction disable timer [$154C] non-zero: go wait for it to expire
$03:A444 D0 3C BNE $A482
$03:A446 BD 40 15 LDA.W $1540,X ; Descent timer [$1540] = 0: still entering
$03:A449 D0 1A BNE $A465
$03:A44B A9 0E LDA.B #$0E ; Bowser face frame = $0E (mouth open, entering)
$03:A44D 9D 70 15 STA.W $1570,X
$03:A450 A9 04 LDA.B #$04 ; Y speed = +4 (descend)
$03:A452 95 AA STA RAM_SpriteSpeedY,X
$03:A454 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A456 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:A458 38 SEC ; |
$03:A459 E5 1C SBC RAM_ScreenBndryYLo ; } Bowser Y position on screen = [Y low] - [layer 1 Y low]; compare with $10
$03:A45B C9 10 CMP.B #$10 ; /
$03:A45D D0 05 BNE $A464 ; Not at screen line $10 yet: keep descending
$03:A45F A9 A4 LDA.B #$A4 ; Reached it: stop timer [$1540] = $A4
$03:A461 9D 40 15 STA.W $1540,X
$03:A464 60 RTS ; Return
$03:A465 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:A467 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A469 C9 01 CMP.B #$01 ; Timer = 1 (about to expire)?
$03:A46B F0 0F BEQ $A47C ; Yes: start the fight
$03:A46D C9 40 CMP.B #$40 ; Timer >= $40: keep the current face
$03:A46F B0 0A BCS $A47B
$03:A471 4A LSR ; \
$03:A472 4A LSR ; |
$03:A473 4A LSR ; } Y = timer / 8: face animation index
$03:A474 A8 TAY ; /
$03:A475 B9 37 A4 LDA.W $A437,Y ; Face frame from $A437 (mouth closes as the timer runs out)
$03:A478 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A47B 60 RTS ; Return
$03:A47C A9 24 LDA.B #$24 ; Interaction disable timer [$154C] = $24 (delay before the first state change)
$03:A47E 9D 4C 15 STA.W RAM_DisableInter,X
$03:A481 60 RTS ; Return
$03:A482 3A DEC A ; Timer [$154C] counted down to 1?
$03:A483 D0 0A BNE $A48F ; No: wait
$03:A485 A9 07 LDA.B #$07 ; Bowser state = 7 (hover and move)
$03:A487 9D 1C 15 STA.W $151C,X
$03:A48A A9 78 LDA.B #$78 ; Phase timer [$14B0] = $78 before the first attack
$03:A48C 8D B0 14 STA.W $14B0
$03:A48F 60 RTS ; Return
;;; $A490..A498: Table: Bowser hover speeds ;;;
$03:A490 .db $FF,$01 ; X acceleration for state 7: +1 / -1 per frame, indexed by [$1528] bit 0
$03:A492 .db $C8,$38 ; X speed limits for state 7: -$38 / +$38
$03:A494 .db $01,$FF ; Y acceleration for state 7: +1 / -1 per frame, indexed by [$1534] bit 0
$03:A496 .db $1C,$E4 ; Y speed limits for state 7: +$1C / -$1C
$03:A498 .db $00,$02,$04,$02 ; Face frame cycle for idle animation: 0, 2, 4, 2
;;; $A49C: Bowser state 7: hover and face Mario ;;;
;; State 7 ([$151C] = 7): Bowser floats in a loop. X speed ramps between -$38 and +$38 and Y speed between
;; -$1C and +$1C,
;; reversing direction each time the limit is reached. Also runs the face animation and attack scheduler.
;; $03A4D2: face animation. Frame counter bits 3-4 pick $A498 for 32 frames out of every 256, else face
;; 0.
$03:A49C 20 D2 A4 JSR.W $A4D2 ; Animate the face ($A4D2)
$03:A49F 20 FD A4 JSR.W $A4FD ; Run the attack scheduler ($A4FD)
$03:A4A2 20 ED A4 JSR.W $A4ED ; Turn to face Mario every 32 frames ($A4ED)
$03:A4A5 BD 28 15 LDA.W $1528,X ; \
$03:A4A8 29 01 AND.B #$01 ; } Y = [$1528] AND 1: X direction of acceleration
$03:A4AA A8 TAY ; /
$03:A4AB B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:A4AD 18 CLC ; |
$03:A4AE 79 90 A4 ADC.W $A490,Y ; } X speed += $A490[Y] (+1 or -1)
$03:A4B1 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:A4B3 D9 92 A4 CMP.W $A492,Y ; Reached the X speed limit?
$03:A4B6 D0 03 BNE $A4BB
$03:A4B8 FE 28 15 INC.W $1528,X ; Yes: reverse the X acceleration direction ([$1528]++)
$03:A4BB BD 34 15 LDA.W $1534,X ; \
$03:A4BE 29 01 AND.B #$01 ; } Y = [$1534] AND 1: Y direction of acceleration
$03:A4C0 A8 TAY ; /
$03:A4C1 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:A4C3 18 CLC ; |
$03:A4C4 79 94 A4 ADC.W $A494,Y ; } Y speed += $A494[Y] (+1 or -1)
$03:A4C7 95 AA STA RAM_SpriteSpeedY,X ; /
$03:A4C9 D9 96 A4 CMP.W $A496,Y ; Reached the Y speed limit?
$03:A4CC D0 03 BNE $A4D1
$03:A4CE FE 34 15 INC.W $1534,X ; Yes: reverse the Y acceleration direction ([$1534]++)
$03:A4D1 60 RTS ; Return
$03:A4D2 A0 00 LDY.B #$00 ; Y = 0: default face
$03:A4D4 A5 13 LDA RAM_FrameCounter ; Frame counter AND $E0: only animate during the first 32 of every 256 frames
$03:A4D6 29 E0 AND.B #$E0
$03:A4D8 D0 0C BNE $A4E6 ; Not in that window: use face 0
$03:A4DA A5 13 LDA RAM_FrameCounter
$03:A4DC 29 18 AND.B #$18 ; \
$03:A4DE 4A LSR ; |
$03:A4DF 4A LSR ; |
$03:A4E0 4A LSR ; } Y = ([frame counter] AND $18) / 8: animation step
$03:A4E1 A8 TAY ; /
$03:A4E2 B9 98 A4 LDA.W $A498,Y ; Face frame from $A498
$03:A4E5 A8 TAY
$03:A4E6 98 TYA ; A = face frame
$03:A4E7 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A4EA 60 RTS ; Return
;;; $A4EB..A4EB: Table: sprite direction toward Mario ;;;
$03:A4EB .db $80,$00 ; Sprite direction [$157C] values: $80 / $00 (indexed by side Mario is on)
;;; $A4ED: Bowser: face Mario and attack scheduler ;;;
;; $03A4ED: every 32 frames, sets Bowser's direction [$157C] so he looks at Mario.
;; $03A4FD: attack scheduler, run when the phase timer [$14B0] is 0. In state 8 it starts a Bowser Ball throw
;; ([$14B6] = $FF) the first two times
;; (counted in [$14B8]) and then falls to the Mechakoopa drop: [$14B1] = $FF, only if sprite slot 0 or 1 is
;; free.
;; Called by:
;; $03:A4A2: Bowser state 7: hover and face Mario
;; $03:AB27: Bowser state 8: chase Mario
;; $03:AB6F: Bowser phase 9: bounce on the floor
$03:A4ED A5 13 LDA RAM_FrameCounter ; Frame counter AND $1F: every 32 frames
$03:A4EF 29 1F AND.B #$1F
$03:A4F1 D0 09 BNE $A4FC ; Other frames: return
$03:A4F3 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side of Mario (0 = right, 1 = left)
$03:A4F6 B9 EB A4 LDA.W $A4EB,Y ; Face direction from table
$03:A4F9 9D 7C 15 STA.W RAM_SpriteDir,X ; Sprite direction [$157C] (turn toward Mario)
$03:A4FC 60 RTS ; Return
$03:A4FD AD B0 14 LDA.W $14B0 ; Phase timer [$14B0] non-zero: no attack yet
$03:A500 D0 2A BNE $A52C
$03:A502 BD 1C 15 LDA.W $151C,X ; Bowser state
$03:A505 C9 08 CMP.B #$08 ; State 8 (chase Mario)?
$03:A507 D0 11 BNE $A51A ; No: drop Mechakoopas instead
$03:A509 EE B8 14 INC.W $14B8 ; Ball counter [$14B8]++
$03:A50C AD B8 14 LDA.W $14B8
$03:A50F C9 03 CMP.B #$03 ; Third time: reset and drop Mechakoopas
$03:A511 F0 07 BEQ $A51A
$03:A513 A9 FF LDA.B #$FF ; Start the Bowser Ball throw: ball timer [$14B6] = $FF
$03:A515 8D B6 14 STA.W $14B6
$03:A518 80 12 BRA $A52C ; Done
$03:A51A 9C B8 14 STZ.W $14B8 ; Ball counter [$14B8] = 0
$03:A51D AD C8 14 LDA.W $14C8 ; Sprite slot 0 status
$03:A520 F0 05 BEQ $A527 ; Slot 0 free: can spawn
$03:A522 AD C9 14 LDA.W $14C9 ; Sprite slot 1 status
$03:A525 D0 05 BNE $A52C ; Slot 1 also in use: skip
$03:A527 A9 FF LDA.B #$FF ; Start the Mechakoopa drop: timer [$14B1] = $FF
$03:A529 8D B1 14 STA.W $14B1
$03:A52C 60 RTS ; Return
;;; $A52D..A565: Table: Bowser face frames for attacks ;;;
;; Face frame [$1570] indexed by attack timer / 4 for both the Mechakoopa drop and the ball throw.
$03:A52D .db $00,$00,$00,$00,$00,$00,$00,$00 ; Face frame by timer / 4 (Mechakoopa drop and ball throw): $00 closed, up to $0E open
$03:A535 .db $00,$02,$04,$06,$08,$0A,$0E,$0E
$03:A53D .db $0E,$0E,$0E,$0E,$0E,$0E,$0E,$0E
$03:A545 .db $0E,$0E,$0E,$0E,$0E,$0E,$0E,$0E
$03:A54D .db $0E,$0E,$0E,$0E,$0E,$0E,$0E,$0E
$03:A555 .db $0E,$0E,$0A,$08,$06,$04,$02,$00
$03:A55D .db $00,$00,$00,$00,$00,$00,$00,$00
$03:A565 .db $00,$00,$00,$00,$00,$00,$00,$00
;;; $A56D..A5A5: Table: Bowser tilt for ball throw ;;;
;; [$36] values indexed by [$14B6] / 4. $FF means the high byte [$37] becomes 1 instead.
$03:A56D .db $00,$00,$00,$00,$00,$00,$00,$00 ; Mode 7 tilt [$36] by timer / 4 (ball throw): ramps 0 to $FF and back
$03:A575 .db $00,$00,$10,$20,$30,$40,$50,$60
$03:A57D .db $80,$A0,$C0,$E0,$FF,$FF,$FF,$FF
$03:A585 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:A58D .db $FF,$FF,$FF,$FF,$FF,$C0,$80,$60
$03:A595 .db $40,$30,$20,$10,$00,$00,$00,$00
$03:A59D .db $00,$00,$00,$00,$00,$00,$00,$00
$03:A5A5 .db $00,$00,$00,$00,$00,$00,$00,$00
;;; $A5AD: Bowser: Mechakoopa drop and ball throw ;;;
;; Called every frame from the main routine. If the Mechakoopa timer [$14B1] runs, animates the face and
;; spawns a Mechakoopa (sprite $A2, $B019)
;; when it hits $80, then skips the rest of the main routine (PLA, PLA). Else if the ball timer [$14B6] runs,
;; does the same and spawns a
;; Bowser Ball (sprite $A1) at timer $80. When a timer finishes it sets the next phase timer [$14B0].
;; $03A61D: spawn the Bowser Ball in slot 8 at Bowser X + 8, Y + $40.
;; Called by:
;; $03:A31A: Bowser main logic
$03:A5AD AD B1 14 LDA.W $14B1 ; Mechakoopa drop timer [$14B1]
$03:A5B0 F0 26 BEQ $A5D8 ; Zero: check the ball throw instead
$03:A5B2 CE B1 14 DEC.W $14B1 ; Timer--
$03:A5B5 D0 06 BNE $A5BD ; Not finished: animate
$03:A5B7 A9 54 LDA.B #$54 ; Finished: phase timer [$14B0] = $54
$03:A5B9 8D B0 14 STA.W $14B0
$03:A5BC 60 RTS ; Return
$03:A5BD 4A LSR ; \
$03:A5BE 4A LSR ; } Y = timer / 4
$03:A5BF A8 TAY ; /
$03:A5C0 B9 2D A5 LDA.W $A52D,Y ; Face frame from $A52D
$03:A5C3 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A5C6 AD B1 14 LDA.W $14B1 ; Timer at $80?
$03:A5C9 C9 80 CMP.B #$80
$03:A5CB D0 08 BNE $A5D5 ; No
$03:A5CD 20 19 B0 JSR.W $B019 ; Spawn a Mechakoopa (sprite $A2) from Bowser ($B019)
$03:A5D0 A9 08 LDA.B #$08 ; \
$03:A5D2 8D FC 1D STA.W $1DFC ; / Play sound effect $08
$03:A5D5 68 PLA ; \
$03:A5D6 68 PLA ; / Discard return address: skip the rest of Bowser main routine this frame
$03:A5D7 60 RTS ; Return
$03:A5D8 AD B6 14 LDA.W $14B6 ; Ball throw timer [$14B6]
$03:A5DB F0 30 BEQ $A60D ; Zero: nothing to do
$03:A5DD CE B6 14 DEC.W $14B6 ; Timer--
$03:A5E0 F0 2C BEQ $A60E ; Reached 0: set the next phase timer
$03:A5E2 4A LSR ; \
$03:A5E3 4A LSR ; } Y = timer / 4
$03:A5E4 A8 TAY ; /
$03:A5E5 B9 2D A5 LDA.W $A52D,Y ; Face frame from $A52D
$03:A5E8 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A5EB B9 6D A5 LDA.W $A56D,Y ; Tilt value from $A56D
$03:A5EE 85 36 STA $36 ; [$36] = tilt low
$03:A5F0 64 37 STZ $37 ; [$37] = 0
$03:A5F2 C9 FF CMP.B #$FF ; Tilt = $FF (maximum)?
$03:A5F4 D0 06 BNE $A5FC
$03:A5F6 64 36 STZ $36 ; Yes: [$36] = 0 and [$37] = 1 (tilt $0100)
$03:A5F8 E6 37 INC $37
$03:A5FA 64 64 STZ $64 ; [$64] = 0 (sprite priority)
$03:A5FC AD B6 14 LDA.W $14B6 ; Timer at $80?
$03:A5FF C9 80 CMP.B #$80
$03:A601 D0 08 BNE $A60B ; No
$03:A603 A9 09 LDA.B #$09 ; \
$03:A605 8D FC 1D STA.W $1DFC ; / Play sound effect $09
$03:A608 20 1D A6 JSR.W $A61D ; Spawn the Bowser Ball ($A61D)
$03:A60B 68 PLA ; \
$03:A60C 68 PLA ; / Discard return address: skip the rest of Bowser main routine this frame
$03:A60D 60 RTS ; Return
$03:A60E A9 60 LDA.B #$60 ; Phase timer = $60 after the third ball
$03:A610 AC B8 14 LDY.W $14B8 ; [$14B8]
$03:A613 C0 02 CPY.B #$02 ; Third ball?
$03:A615 F0 02 BEQ $A619
$03:A617 A9 20 LDA.B #$20 ; Otherwise phase timer = $20
$03:A619 8D B0 14 STA.W $14B0 ; Phase timer [$14B0]
$03:A61C 60 RTS ; Return
$03:A61D A9 08 LDA.B #$08 ; Status of slot 8 = 8 (normal)
$03:A61F 8D D0 14 STA.W $14D0
$03:A622 A9 A1 LDA.B #$A1 ; Sprite number of slot 8 = $A1 (Bowser Ball)
$03:A624 85 A6 STA $A6
$03:A626 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:A628 18 CLC ; |
$03:A629 69 08 ADC.B #$08 ; } Ball X low = Bowser X + 8
$03:A62B 85 EC STA $EC ; /
$03:A62D BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:A630 69 00 ADC.B #$00 ; } Ball X high (carry)
$03:A632 8D E8 14 STA.W $14E8 ; /
$03:A635 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:A637 18 CLC ; |
$03:A638 69 40 ADC.B #$40 ; } Ball Y low = Bowser Y + $40
$03:A63A 85 E0 STA $E0 ; /
$03:A63C BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:A63F 69 00 ADC.B #$00 ; } Ball Y high (carry)
$03:A641 8D DC 14 STA.W $14DC ; /
$03:A644 DA PHX ; Save Bowser index
$03:A645 A2 08 LDX.B #$08 ; X = 8: the ball slot
$03:A647 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize sprite tables for the ball
$03:A64B FA PLX ; Restore Bowser index
$03:A64C 60 RTS ; Return
;;; $A64D..A65D: Table: Bowser shake when hurt ;;;
;; Signed X shake [$36] indexed by hurt timer [$14B5] / 4.
$03:A64D .db $00,$00,$00,$00,$FC,$F8,$F4,$F0 ; Mode 7 shake [$36] when Bowser is hit, by [$14B5] / 4 (signed)
$03:A655 .db $F4,$F8,$FC,$00,$04,$08,$0C,$10
$03:A65D .db $0C,$08,$04,$00
;;; $A661: Bowser: hurt reaction ;;;
;; Called every frame. While the hurt timer [$14B5] runs, cancels attacks, shakes Bowser and flickers his
;; face, then skips the rest of the main routine.
;; When it ends, decrements the hits-left counter [$187B]. At 0 Bowser goes to state 1 (retreat), or to state
;; 4 if he was in state 9 (probably the defeat).
;; Called by:
;; $03:A2E1: Bowser main logic
$03:A661 AD B5 14 LDA.W $14B5 ; Hurt timer [$14B5]
$03:A664 F0 59 BEQ $A6BF ; Zero: not hurt, return
$03:A666 9C B1 14 STZ.W $14B1 ; Cancel the Mechakoopa drop
$03:A669 9C B6 14 STZ.W $14B6 ; Cancel the ball throw
$03:A66C CE B5 14 DEC.W $14B5 ; Hurt timer--
$03:A66F D0 20 BNE $A691 ; Still hurt: animate
$03:A671 A9 50 LDA.B #$50 ; Hurt finished: phase timer [$14B0] = $50
$03:A673 8D B0 14 STA.W $14B0
$03:A676 DE 7B 18 DEC.W $187B,X ; Hits-left counter [$187B]--
$03:A679 D0 16 BNE $A691 ; Hits left: keep going
$03:A67B BD 1C 15 LDA.W $151C,X ; Bowser state
$03:A67E C9 09 CMP.B #$09 ; State 9?
$03:A680 F0 3E BEQ $A6C0 ; Yes: go to the defeat state
$03:A682 A9 02 LDA.B #$02 ; Hits-left counter [$187B] = 2
$03:A684 9D 7B 18 STA.W $187B,X
$03:A687 A9 01 LDA.B #$01 ; Bowser state = 1 (retreat)
$03:A689 9D 1C 15 STA.W $151C,X
$03:A68C A9 80 LDA.B #$80 ; Timer [$1540] = $80
$03:A68E 9D 40 15 STA.W $1540,X
$03:A691 7A PLY ; \
$03:A692 7A PLY ; / Discard return address: skip the rest of Bowser main routine this frame
$03:A693 48 PHA ; Save A
$03:A694 AD B5 14 LDA.W $14B5 ; Hurt timer
$03:A697 4A LSR ; \
$03:A698 4A LSR ; } Y = timer / 4
$03:A699 A8 TAY ; /
$03:A69A B9 4D A6 LDA.W $A64D,Y ; Shake value from $A64D
$03:A69D 85 36 STA $36 ; [$36] = shake low (signed)
$03:A69F 64 37 STZ $37 ; [$37] = 0
$03:A6A1 10 02 BPL $A6A5 ; Positive: keep
$03:A6A3 E6 37 INC $37 ; Negative: [$37] = 1
$03:A6A5 68 PLA ; Restore A
$03:A6A6 A0 0C LDY.B #$0C ; Y = $0C: hurt face frame
$03:A6A8 C9 40 CMP.B #$40 ; A >= $40?
$03:A6AA B0 0A BCS $A6B6 ; Yes: keep hurt face
$03:A6AC A5 13 LDA RAM_FrameCounter ; Frame counter
$03:A6AE A0 10 LDY.B #$10 ; Y = $10
$03:A6B0 29 04 AND.B #$04 ; Bit 2 of the frame counter
$03:A6B2 F0 02 BEQ $A6B6 ; Clear: face $10
$03:A6B4 A0 12 LDY.B #$12 ; Set: face $12 (flicker)
$03:A6B6 98 TYA
$03:A6B7 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A6BA A9 02 LDA.B #$02 ; [$1427] = 2 (probably Bowser animation / palette flag)
$03:A6BC 8D 27 14 STA.W $1427
$03:A6BF 60 RTS ; Return
$03:A6C0 A9 04 LDA.B #$04 ; Bowser state = 4 (defeated)
$03:A6C2 9D 1C 15 STA.W $151C,X
$03:A6C5 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A6C7 60 RTS ; Return
;;; $A6C8: Kill all sprites except bosses (KillMostSprites) ;;;
;; Sets every sprite in slots 0-9 to status 4 (killed by spin jump) with a smoke timer of $1F, except Reznor
;; ($A9), Koopa Kid ($29), Bowser ($A0)
;; and Big Boo Boss ($C5). Long call (RTL).
;; Called by:
;; $01:FB6A: Iggy/Larry: tilting-platform Koopaling (PlatformKoopaKids)
;; $03:81A9: Big Boo boss: remaining states and helpers
;; $03:9902: Reznor: check all Reznors dead (ReznorNoLevelEnd)
;; $03:B13D: Bowser Mario and Mecha-Koopa contact
;; $03:CED7: Koopa Kid states 5-6 and Mario contact
$03:A6C8 A0 09 LDY.B #$09 ; Y = 9: sprite slot counter
$03:A6CA B9 C8 14 LDA.W $14C8,Y ; Sprite status
$03:A6CD F0 1D BEQ $A6EC ; Empty: next slot
$03:A6CF B9 9E 00 LDA.W RAM_SpriteNum,Y ; Sprite number
$03:A6D2 C9 A9 CMP.B #$A9 ; $A9 (Reznor)?
$03:A6D4 F0 16 BEQ $A6EC ; Keep it
$03:A6D6 C9 29 CMP.B #$29 ; $29 (Koopa Kid)?
$03:A6D8 F0 12 BEQ $A6EC ; Keep it
$03:A6DA C9 A0 CMP.B #$A0 ; $A0 (Bowser)?
$03:A6DC F0 0E BEQ $A6EC ; Keep it
$03:A6DE C9 C5 CMP.B #$C5 ; $C5 (Big Boo Boss)?
$03:A6E0 F0 0A BEQ $A6EC ; Keep it
$03:A6E2 A9 04 LDA.B #$04 ; \
$03:A6E4 99 C8 14 STA.W $14C8,Y ; / Sprite status = 4 (killed by spin jump)
$03:A6E7 A9 1F LDA.B #$1F ; \
$03:A6E9 99 40 15 STA.W $1540,Y ; / Smoke cloud timer = $1F
$03:A6EC 88 DEY ; \
$03:A6ED 10 DB BPL $A6CA ; / Next slot, loop for slots 9 to 0
$03:A6EF 6B RTL ; Return long
;;; $A6F0..A6F0: Table: Bowser face frame in state 1 ;;;
$03:A6F0 .db $0E,$0E,$0A,$08,$06,$04,$02,$00 ; Face frame by timer / 16 (state 1 shaking)
;;; $A6F8: Bowser state 1: shake then retreat ;;;
;; State 1: while [$1540] counts down Bowser sits still with his face animated (music $17 when it reaches 1),
;; then moves via $A731.
$03:A6F8 BD 40 15 LDA.W $1540,X ; Timer [$1540]
$03:A6FB F0 34 BEQ $A731 ; Zero: drift away
$03:A6FD C9 01 CMP.B #$01 ; Timer = 1?
$03:A6FF D0 05 BNE $A706
$03:A701 A0 17 LDY.B #$17 ; \
$03:A703 8C FB 1D STY.W $1DFB ; / Change music to $17
$03:A706 4A LSR ; \
$03:A707 4A LSR ; |
$03:A708 4A LSR ; |
$03:A709 4A LSR ; } Y = timer / 16
$03:A70A A8 TAY ; /
$03:A70B B9 F0 A6 LDA.W $A6F0,Y ; Face frame from $A6F0
$03:A70E 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A711 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A713 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:A715 9E 28 15 STZ.W $1528,X ; X accel stage [$1528] = 0
$03:A718 9E 34 15 STZ.W $1534,X ; Y accel stage [$1534] = 0
$03:A71B 9C B2 14 STZ.W $14B2 ; Scale stage [$14B2] = 0
$03:A71E 60 RTS ; Return
;;; $A71F..A72F: Table: Bowser retreat accelerations ;;;
;; Pairs for the X, Y and scale stages of the retreat: steps, limits and frame masks.
$03:A71F .db $01,$FF ; X accel step per stage: +1, -1
$03:A721 .db $10,$80 ; X speed limits: +$10, -$80
$03:A723 .db $07,$03 ; X accel mask on frame counter: $07, $03
$03:A725 .db $FF,$01 ; Y accel step per stage: -1, +1
$03:A727 .db $F0,$08 ; Y speed limits: -$10, +$08
$03:A729 .db $01,$FF ; Scale [$38] step per stage: +1, -1
$03:A72B .db $03,$03 ; Y accel mask on frame counter: $03, $03
$03:A72D .db $60,$02 ; Scale [$38] limits: $60, $02
$03:A72F .db $01,$01 ; Scale accel mask on frame counter: $01, $01
;;; $A731: Bowser state 1: retreat off-screen ;;;
;; Ramps X speed, Y speed and the scale [$38]/[$39] in two stages each. Once scale stage [$14B2] is 2, or
;; Bowser's X high is $FE,
;; goes to state 3 with timer [$14B0] = $80, picks a random start for the falling objects and starts music
;; $1D.
$03:A731 BC 28 15 LDY.W $1528,X ; Y = X accel stage [$1528]
$03:A734 C0 02 CPY.B #$02 ; Stage >= 2: done with X
$03:A736 B0 17 BCS $A74F
$03:A738 A5 13 LDA RAM_FrameCounter ; \
$03:A73A 39 23 A7 AND.W $A723,Y ; } Only accelerate on frames matching the mask in $A723
$03:A73D D0 10 BNE $A74F ; /
$03:A73F B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:A741 18 CLC ; |
$03:A742 79 1F A7 ADC.W $A71F,Y ; } X speed += $A71F[Y]
$03:A745 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:A747 D9 21 A7 CMP.W $A721,Y ; Reached the limit?
$03:A74A D0 03 BNE $A74F
$03:A74C FE 28 15 INC.W $1528,X ; Yes: next stage
$03:A74F BC 34 15 LDY.W $1534,X ; Y = Y accel stage [$1534]
$03:A752 C0 02 CPY.B #$02 ; Stage >= 2: done with Y
$03:A754 B0 17 BCS $A76D
$03:A756 A5 13 LDA RAM_FrameCounter ; \
$03:A758 39 2B A7 AND.W $A72B,Y ; } Only accelerate on frames matching the mask in $A72B
$03:A75B D0 10 BNE $A76D ; /
$03:A75D B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:A75F 18 CLC ; |
$03:A760 79 25 A7 ADC.W $A725,Y ; } Y speed += $A725[Y]
$03:A763 95 AA STA RAM_SpriteSpeedY,X ; /
$03:A765 D9 27 A7 CMP.W $A727,Y ; Reached the limit?
$03:A768 D0 03 BNE $A76D
$03:A76A FE 34 15 INC.W $1534,X ; Yes: next stage
$03:A76D AC B2 14 LDY.W $14B2 ; Y = scale stage [$14B2]
$03:A770 C0 02 CPY.B #$02 ; Stage 2: finished
$03:A772 F0 20 BEQ $A794
$03:A774 A5 13 LDA RAM_FrameCounter ; \
$03:A776 39 2F A7 AND.W $A72F,Y ; } Only change scale on frames matching the mask in $A72F
$03:A779 D0 12 BNE $A78D ; /
$03:A77B A5 38 LDA $38 ; \
$03:A77D 18 CLC ; |
$03:A77E 79 29 A7 ADC.W $A729,Y ; } [$38] += $A729[Y] (Mode 7 scale, probably)
$03:A781 85 38 STA $38 ; /
$03:A783 85 39 STA $39 ; Also store in [$39]
$03:A785 D9 2D A7 CMP.W $A72D,Y ; Reached the limit?
$03:A788 D0 03 BNE $A78D
$03:A78A EE B2 14 INC.W $14B2 ; Yes: next stage
$03:A78D BD E0 14 LDA.W RAM_SpriteXHi,X ; Bowser X high byte
$03:A790 C9 FE CMP.B #$FE ; Off-screen at $FE?
$03:A792 D0 18 BNE $A7AC ; No: keep moving
$03:A794 A9 03 LDA.B #$03 ; Bowser state = 3 (waiting off-screen)
$03:A796 9D 1C 15 STA.W $151C,X
$03:A799 A9 80 LDA.B #$80 ; Phase timer [$14B0] = $80
$03:A79B 8D B0 14 STA.W $14B0
$03:A79E 22 F9 AC 01 JSL.L GetRand ; Random number
$03:A7A2 29 F0 AND.B #$F0 ; Keep the high nibble
$03:A7A4 8D B7 14 STA.W $14B7 ; Falling object X start [$14B7] = random multiple of $10
$03:A7A7 A9 1D LDA.B #$1D
$03:A7A9 8D FB 1D STA.W $1DFB ; Change music to $1D
$03:A7AC 60 RTS ; Return
$03:A7AD A9 60 LDA.B #$60 ; Scale [$38] = $60
$03:A7AF 85 38 STA $38
$03:A7B1 85 39 STA $39 ; Scale [$39] = $60
$03:A7B3 A9 FF LDA.B #$FF ; Bowser X high = $FF
$03:A7B5 9D E0 14 STA.W RAM_SpriteXHi,X
$03:A7B8 A9 60 LDA.B #$60 ; Bowser X low = $60 (off-screen to the left)
$03:A7BA 95 E4 STA RAM_SpriteXLo,X
$03:A7BC AD B0 14 LDA.W $14B0 ; Phase timer [$14B0]
$03:A7BF D0 1E BNE $A7DF ; Non-zero: spawn objects while it runs
$03:A7C1 A9 18 LDA.B #$18 ; Music $18
$03:A7C3 8D FB 1D STA.W $1DFB ; / Change music
$03:A7C6 A9 02 LDA.B #$02 ; Bowser state = 2 (return)
$03:A7C8 9D 1C 15 STA.W $151C,X
$03:A7CB A9 18 LDA.B #$18 ; Bowser Y low = $18
$03:A7CD 95 D8 STA RAM_SpriteYLo,X
$03:A7CF A9 00 LDA.B #$00 ; Bowser Y high = 0
$03:A7D1 9D D4 14 STA.W RAM_SpriteYHi,X
$03:A7D4 A9 08 LDA.B #$08 ; Scale [$38] = 8
$03:A7D6 85 38 STA $38
$03:A7D8 85 39 STA $39 ; Scale [$39] = 8
$03:A7DA A9 64 LDA.B #$64 ; X speed = $64
$03:A7DC 95 B6 STA RAM_SpriteSpeedX,X
$03:A7DE 60 RTS ; Return
$03:A7DF C9 60 CMP.B #$60 ; Timer >= $60: wait
$03:A7E1 B0 5D BCS $A840
$03:A7E3 A5 13 LDA RAM_FrameCounter ; Every 32 frames only
$03:A7E5 29 1F AND.B #$1F
$03:A7E7 D0 57 BNE $A840
$03:A7E9 A0 07 LDY.B #$07 ; Y = 7: look for a free slot from 7 down to 2
$03:A7EB B9 C8 14 LDA.W $14C8,Y ; Slot status
$03:A7EE F0 06 BEQ $A7F6 ; Free: use it
$03:A7F0 88 DEY ; Next slot
$03:A7F1 C0 01 CPY.B #$01
$03:A7F3 D0 F6 BNE $A7EB
$03:A7F5 60 RTS ; No free slot: return
$03:A7F6 A9 17 LDA.B #$17 ; \
$03:A7F8 8D FC 1D STA.W $1DFC ; / Play sound effect $17
$03:A7FB A9 08 LDA.B #$08 ; \
$03:A7FD 99 C8 14 STA.W $14C8,Y ; / Sprite status = 8 (normal)
$03:A800 A9 33 LDA.B #$33 ; Sprite number $33
$03:A802 99 9E 00 STA.W RAM_SpriteNum,Y
$03:A805 AD B7 14 LDA.W $14B7 ; Falling object X position [$14B7]
$03:A808 48 PHA ; Save it
$03:A809 99 E4 00 STA.W RAM_SpriteXLo,Y ; Sprite X low
$03:A80C 18 CLC ; Next object is $20 further along
$03:A80D 69 20 ADC.B #$20
$03:A80F 8D B7 14 STA.W $14B7
$03:A812 A9 00 LDA.B #$00 ; X high = 0
$03:A814 99 E0 14 STA.W RAM_SpriteXHi,Y
$03:A817 A9 00 LDA.B #$00 ; Y low = 0 (top of the screen)
$03:A819 99 D8 00 STA.W RAM_SpriteYLo,Y
$03:A81C 99 D4 14 STA.W RAM_SpriteYHi,Y ; Y high = 0
$03:A81F DA PHX ; Save Bowser index
$03:A820 BB TYX ; X = new sprite
$03:A821 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize sprite tables
$03:A825 F6 C2 INC RAM_SpriteState,X ; Sprite state [$00C2]++
$03:A827 1E 86 16 ASL.W RAM_Tweaker1686,X ; Clear bit 7 of tweaker [$1686]
$03:A82A 5E 86 16 LSR.W RAM_Tweaker1686,X
$03:A82D A9 39 LDA.B #$39 ; Tweaker [$1662] = $39 (sprite clipping)
$03:A82F 9D 62 16 STA.W RAM_Tweaker1662,X
$03:A832 FA PLX ; Restore Bowser index
$03:A833 68 PLA ; Saved X position
$03:A834 4A LSR ; \
$03:A835 4A LSR ; |
$03:A836 4A LSR ; |
$03:A837 4A LSR ; |
$03:A838 4A LSR ; } Y = X position / 32: column 0-7
$03:A839 A8 TAY ; /
$03:A83A B9 41 A8 LDA.W BowserSound,Y ; Sound from BowserSound[Y] (a note per column)
$03:A83D 8D FC 1D STA.W $1DFC ; Play it ($1DFC)
$03:A840 60 RTS ; Return
;;; $A841: Table: Bowser sound effect (first entry) (BowserSound) ;;;
;; Sound effect values for $1DFC indexed by column / 32; it continues in the next label.
$03:A841 .db $2D ; Sound effect $2D (start of a note table of 8 sounds)
;;; $A842: Bowser state 2 and music table (BowserSoundMusic) ;;;
;; $03A842: table of values indexed by [$14B4], written to $1DFB (music) at timer $3F; the first 8 bytes also
;; serve as sound effects for BowserSound.
;; State 2 ($03A84B): Bowser slows, scales up to $20, drops a Super Mushroom at timer $A0, plays sound $2A at
;; $E8 and at timer 1 switches to state [$14B4] + 1.
$03:A842 .db $2E,$2F,$30,$31,$32,$33,$34,$19 ; Values indexed by [$14B4]: $2E-$34, $19, $1A; also the rest of BowserSound
$03:A84A .db $1A
$03:A84B 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:A84D BD 40 15 LDA.W $1540,X ; Timer [$1540]
$03:A850 D0 1C BNE $A86E ; Running: go handle it
$03:A852 B5 B6 LDA RAM_SpriteSpeedX,X ; X speed
$03:A854 F0 02 BEQ $A858 ; Zero: skip
$03:A856 D6 B6 DEC RAM_SpriteSpeedX,X ; Slow down: X speed--
$03:A858 A5 13 LDA RAM_FrameCounter ; Frame counter AND 3
$03:A85A 29 03 AND.B #$03
$03:A85C D0 0F BNE $A86D ; Only every 4th frame
$03:A85E E6 38 INC $38 ; Scale [$38]++
$03:A860 E6 39 INC $39 ; Scale [$39]++
$03:A862 A5 38 LDA $38 ; Scale reached $20?
$03:A864 C9 20 CMP.B #$20
$03:A866 D0 05 BNE $A86D ; No: wait
$03:A868 A9 FF LDA.B #$FF ; Timer [$1540] = $FF
$03:A86A 9D 40 15 STA.W $1540,X
$03:A86D 60 RTS ; Return
$03:A86E C9 A0 CMP.B #$A0 ; Timer = $A0?
$03:A870 D0 05 BNE $A877
$03:A872 48 PHA ; Save timer
$03:A873 20 D6 A8 JSR.W $A8D6 ; Spawn a Super Mushroom ($A8D6)
$03:A876 68 PLA ; Restore timer
$03:A877 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A879 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:A87B C9 01 CMP.B #$01 ; Timer = 1?
$03:A87D F0 1E BEQ $A89D ; Yes: go to the next state
$03:A87F C9 40 CMP.B #$40 ; Timer >= $40?
$03:A881 B0 2B BCS $A8AE ; Yes: flash
$03:A883 C9 3F CMP.B #$3F ; Timer = $3F?
$03:A885 D0 0B BNE $A892
$03:A887 48 PHA ; Save timer
$03:A888 AC B4 14 LDY.W $14B4 ; Phase counter [$14B4] (probably)
$03:A88B B9 42 A8 LDA.W BowserSoundMusic,Y ; Value from BowserSoundMusic[Y]
$03:A88E 8D FB 1D STA.W $1DFB ; Change music
$03:A891 68 PLA ; Restore timer
$03:A892 4A LSR ; \
$03:A893 4A LSR ; |
$03:A894 4A LSR ; } Y = timer / 8
$03:A895 A8 TAY ; /
$03:A896 B9 37 A4 LDA.W $A437,Y ; Face frame from $A437
$03:A899 9D 70 15 STA.W $1570,X ; Bowser face frame [$1570]
$03:A89C 60 RTS ; Return
$03:A89D AD B4 14 LDA.W $14B4 ; Next state = [$14B4] + 1
$03:A8A0 1A INC A
$03:A8A1 9D 1C 15 STA.W $151C,X ; Bowser state
$03:A8A4 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:A8A6 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:A8A8 A9 80 LDA.B #$80 ; Phase timer [$14B0] = $80
$03:A8AA 8D B0 14 STA.W $14B0
$03:A8AD 60 RTS ; Return
$03:A8AE C9 E8 CMP.B #$E8 ; Timer = $E8?
$03:A8B0 D0 05 BNE $A8B7
$03:A8B2 A0 2A LDY.B #$2A ; \
$03:A8B4 8C F9 1D STY.W $1DF9 ; / Play sound effect $2A on $1DF9
$03:A8B7 38 SEC ; Peach animation counter [$1594] = timer - $3F (probably)
$03:A8B8 E9 3F SBC.B #$3F
$03:A8BA 9D 94 15 STA.W $1594,X
$03:A8BD 60 RTS ; Return
;;; $A8BE..A8CE: Table: object vertical offset ;;;
;; Offset subtracted from the drawn object's Y, indexed by [$1594] / 8.
$03:A8BE .db $00,$00,$00,$08,$10,$14,$14,$16 ; Vertical offset by [$1594] / 8: the rising and falling motion of the drawn object
$03:A8C6 .db $16,$18,$18,$17,$16,$16,$17,$18
$03:A8CE .db $18,$17,$14,$10,$0C,$08,$04,$00
;;; $A8D6: Spawn Super Mushroom from Bowser ;;;
;; Finds a free sprite slot (7 down to 2), makes it a Super Mushroom (sprite $74) at Bowser X + 4, Y + $18,
;; thrown upward ($C0) and sideways toward the screen center.
;; Called by:
;; $03:A873: Bowser state 2 and music table (BowserSoundMusic)
$03:A8D6 A0 07 LDY.B #$07 ; Y = 7: look for a free slot from 7 down to 2
$03:A8D8 B9 C8 14 LDA.W $14C8,Y ; Slot status
$03:A8DB F0 06 BEQ $A8E3 ; Free: use it
$03:A8DD 88 DEY ; Next slot
$03:A8DE C0 01 CPY.B #$01
$03:A8E0 D0 F6 BNE $A8D8
$03:A8E2 60 RTS ; No free slot: return
$03:A8E3 A9 10 LDA.B #$10 ; \
$03:A8E5 8D F9 1D STA.W $1DF9 ; / Play sound effect $10 on $1DF9
$03:A8E8 A9 08 LDA.B #$08 ; \
$03:A8EA 99 C8 14 STA.W $14C8,Y ; / Sprite status = 8 (normal)
$03:A8ED A9 74 LDA.B #$74 ; Sprite number $74 (Super Mushroom)
$03:A8EF 99 9E 00 STA.W RAM_SpriteNum,Y
$03:A8F2 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:A8F4 18 CLC ; |
$03:A8F5 69 04 ADC.B #$04 ; } Mushroom X low = Bowser X + 4
$03:A8F7 99 E4 00 STA.W RAM_SpriteXLo,Y ; /
$03:A8FA BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:A8FD 69 00 ADC.B #$00 ; } Mushroom X high (carry)
$03:A8FF 99 E0 14 STA.W RAM_SpriteXHi,Y ; /
$03:A902 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:A904 18 CLC ; |
$03:A905 69 18 ADC.B #$18 ; } Mushroom Y low = Bowser Y + $18
$03:A907 99 D8 00 STA.W RAM_SpriteYLo,Y ; /
$03:A90A BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:A90D 69 00 ADC.B #$00 ; } Mushroom Y high (carry)
$03:A90F 99 D4 14 STA.W RAM_SpriteYHi,Y ; /
$03:A912 DA PHX ; Save Bowser index
$03:A913 BB TYX ; X = mushroom
$03:A914 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize sprite tables
$03:A918 A9 C0 LDA.B #$C0 ; Y speed = $C0 (thrown upward)
$03:A91A 95 AA STA RAM_SpriteSpeedY,X
$03:A91C 9E 7C 15 STZ.W RAM_SpriteDir,X ; Direction = 0
$03:A91F A0 0C LDY.B #$0C ; Y = $0C: X speed to the right
$03:A921 B5 E4 LDA RAM_SpriteXLo,X ; Mushroom X low
$03:A923 10 05 BPL $A92A ; Left half of the screen: keep
$03:A925 A0 F4 LDY.B #$F4 ; Y = $F4: X speed to the left
$03:A927 FE 7C 15 INC.W RAM_SpriteDir,X ; Direction = 1
$03:A92A 94 B6 STY RAM_SpriteSpeedX,X ; X speed
$03:A92C FA PLX ; Restore Bowser index
$03:A92D 60 RTS ; Return
;;; $A92E..A976: Table: X offsets for Bowser overlay tiles ;;;
$03:A92E .db $00,$08,$00,$08,$00,$08,$00,$08 ; X offsets of the 4 tiles, 20 frames x 4 tiles (data below)
$03:A936 .db $00,$08,$00,$08,$00,$08,$00,$08
$03:A93E .db $00,$08,$00,$08,$00,$08,$00,$08
$03:A946 .db $00,$08,$00,$08,$00,$08,$00,$08
$03:A94E .db $00,$08,$00,$08,$00,$08,$00,$08
$03:A956 .db $00,$08,$00,$08,$00,$08,$00,$08
$03:A95E .db $08,$00,$08,$00,$08,$00,$08,$00
$03:A966 .db $08,$00,$08,$00,$08,$00,$08,$00
$03:A96E .db $08,$00,$08,$00,$08,$00,$08,$00
$03:A976 .db $08,$00,$08,$00,$08,$00,$08,$00
;;; $A97E..A9C6: Table: Y offsets for Bowser overlay tiles ;;;
$03:A97E .db $00,$00,$08,$08,$00,$00,$08,$08 ; Y offsets of the 4 tiles, 20 frames x 4 tiles
$03:A986 .db $00,$00,$08,$08,$00,$00,$08,$08
$03:A98E .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A996 .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A99E .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A9A6 .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A9AE .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A9B6 .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A9BE .db $00,$00,$10,$10,$00,$00,$10,$10
$03:A9C6 .db $00,$00,$10,$10,$00,$00,$10,$10
;;; $A9CE..AA16: Table: tile numbers for Bowser overlay ;;;
$03:A9CE .db $05,$06,$15,$16,$9D,$9E,$4E,$AE ; Tile numbers, 20 frames x 4 tiles
$03:A9D6 .db $06,$05,$16,$15,$9E,$9D,$AE,$4E
$03:A9DE .db $8A,$8B,$AA,$68,$83,$84,$AA,$68
$03:A9E6 .db $8A,$8B,$80,$81,$83,$84,$80,$81
$03:A9EE .db $85,$86,$A5,$A6,$83,$84,$A5,$A6
$03:A9F6 .db $82,$83,$A2,$A3,$82,$83,$A2,$A3
$03:A9FE .db $8A,$8B,$AA,$68,$83,$84,$AA,$68
$03:AA06 .db $8A,$8B,$80,$81,$83,$84,$80,$81
$03:AA0E .db $85,$86,$A5,$A6,$83,$84,$A5,$A6
$03:AA16 .db $82,$83,$A2,$A3,$82,$83,$A2,$A3
;;; $AA1E..AA66: Table: tile properties for Bowser overlay ;;;
$03:AA1E .db $01,$01,$01,$01,$01,$01,$01,$01 ; Tile properties (flip / palette), 20 frames x 4 tiles
$03:AA26 .db $41,$41,$41,$41,$41,$41,$41,$41
$03:AA2E .db $01,$01,$01,$01,$01,$01,$01,$01
$03:AA36 .db $01,$01,$01,$01,$01,$01,$01,$01
$03:AA3E .db $00,$00,$00,$00,$01,$01,$00,$00
$03:AA46 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:AA4E .db $41,$41,$41,$41,$41,$41,$41,$41
$03:AA56 .db $41,$41,$41,$41,$41,$41,$41,$41
$03:AA5E .db $40,$40,$40,$40,$41,$41,$40,$40
$03:AA66 .db $40,$40,$40,$40,$40,$40,$40,$40
;;; $AA6E: Draw Bowser overlay (probably Peach) ;;;
;; Draws a 2x2 group of 16x16 tiles at OAM $70 using the four tables above, indexed by [$03] * 4. Frames 8-15
;; of the animation also draw two extra
;; sprites at OAM $02A0/$02A4. Identification of the drawn object as Peach is a guess based on the tile data
;; and the mushroom drop.
;; Parameters: Y: animation step, [$02]: vertical offset, [$03]: frame row.
;; Called by:
;; $03:A2CA: Bowser main logic
$03:AA6E B5 E4 LDA RAM_SpriteXLo,X ; \
$03:AA70 18 CLC ; |
$03:AA71 69 04 ADC.B #$04 ; |
$03:AA73 38 SEC ; |
$03:AA74 E5 1A SBC RAM_ScreenBndryXLo ; } $00 = Bowser X + 4 - [layer 1 X low] (screen X)
$03:AA76 85 00 STA $00 ; /
$03:AA78 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:AA7A 18 CLC ; |
$03:AA7B 69 20 ADC.B #$20 ; |
$03:AA7D 38 SEC ; |
$03:AA7E E5 02 SBC $02 ; |
$03:AA80 38 SEC ; |
$03:AA81 E5 1C SBC RAM_ScreenBndryYLo ; } $01 = Bowser Y + $20 - [$02] - [layer 1 Y low] (screen Y)
$03:AA83 85 01 STA $01 ; /
$03:AA85 C0 08 CPY.B #$08 ; Y (animation index) < 8?
$03:AA87 90 3D BCC $AAC6 ; Yes: skip the extra sprites
$03:AA89 C0 10 CPY.B #$10 ; Y >= $10?
$03:AA8B B0 39 BCS $AAC6 ; Yes: skip the extra sprites
$03:AA8D A5 00 LDA $00 ; \
$03:AA8F 38 SEC ; |
$03:AA90 E9 04 SBC.B #$04 ; } OAM $02A0 X = [$00] - 4
$03:AA92 8D A0 02 STA.W $02A0 ; /
$03:AA95 18 CLC ; \
$03:AA96 69 10 ADC.B #$10 ; } OAM $02A4 X = [$00] + $0C
$03:AA98 8D A4 02 STA.W $02A4 ; /
$03:AA9B A5 01 LDA $01 ; \
$03:AA9D 38 SEC ; |
$03:AA9E E9 18 SBC.B #$18 ; |
$03:AAA0 8D A1 02 STA.W $02A1 ; } OAM $02A1 and $02A5 Y = [$01] - $18
$03:AAA3 8D A5 02 STA.W $02A5 ; /
$03:AAA6 A9 20 LDA.B #$20 ; Tile $20
$03:AAA8 8D A2 02 STA.W $02A2 ; OAM $02A2 tile
$03:AAAB A9 22 LDA.B #$22 ; Tile $22
$03:AAAD 8D A6 02 STA.W $02A6 ; OAM $02A6 tile
$03:AAB0 A5 14 LDA RAM_FrameCounterB ; \
$03:AAB2 4A LSR ; |
$03:AAB3 29 06 AND.B #$06 ; |
$03:AAB5 1A INC A ; |
$03:AAB6 1A INC A ; } Properties: palette from the frame counter, 3 + 2 * ([frame counter B] / 2 AND 3)
$03:AAB7 1A INC A ; /
$03:AAB8 8D A3 02 STA.W $02A3 ; OAM $02A3 properties
$03:AABB 8D A7 02 STA.W $02A7 ; OAM $02A7 properties
$03:AABE A9 02 LDA.B #$02 ; Size bits = 2 (16x16)
$03:AAC0 8D 48 04 STA.W $0448 ; OAM $0448 size
$03:AAC3 8D 49 04 STA.W $0449 ; OAM $0449 size
$03:AAC6 A0 70 LDY.B #$70 ; Y = $70: OAM index of the 4 main tiles
$03:AAC8 A5 03 LDA $03 ; \
$03:AACA 0A ASL ; |
$03:AACB 0A ASL ; } $04 = [$03] * 4: row offset into the tile tables
$03:AACC 85 04 STA $04 ; /
$03:AACE DA PHX ; Save sprite index
$03:AACF A2 03 LDX.B #$03 ; X = 3: tile counter
$03:AAD1 DA PHX ; Save counter
$03:AAD2 8A TXA ; \
$03:AAD3 18 CLC ; |
$03:AAD4 65 04 ADC $04 ; } X = counter + [$04]: table index
$03:AAD6 AA TAX ; /
$03:AAD7 A5 00 LDA $00 ; \
$03:AAD9 18 CLC ; |
$03:AADA 7D 2E A9 ADC.W $A92E,X ; } OAM X = [$00] + $A92E[X]
$03:AADD 99 00 03 STA.W OAM_DispX,Y ; /
$03:AAE0 A5 01 LDA $01 ; \
$03:AAE2 18 CLC ; |
$03:AAE3 7D 7E A9 ADC.W $A97E,X ; } OAM Y = [$01] + $A97E[X]
$03:AAE6 99 01 03 STA.W OAM_DispY,Y ; /
$03:AAE9 BD CE A9 LDA.W $A9CE,X ; Tile from $A9CE
$03:AAEC 99 02 03 STA.W OAM_Tile,Y ; OAM tile
$03:AAEF BD 1E AA LDA.W $AA1E,X ; Properties from $AA1E
$03:AAF2 DA PHX ; Save table index
$03:AAF3 AE E9 15 LDX.W $15E9 ; X = current sprite index
$03:AAF6 E0 09 CPX.B #$09 ; Sprite slot 9?
$03:AAF8 F0 02 BEQ $AAFC ; Yes: keep properties
$03:AAFA 09 30 ORA.B #$30 ; Otherwise add priority bits $30
$03:AAFC 99 03 03 STA.W OAM_Prop,Y ; OAM properties
$03:AAFF FA PLX ; Restore table index
$03:AB00 5A PHY ; Save OAM index
$03:AB01 98 TYA ; \
$03:AB02 4A LSR ; |
$03:AB03 4A LSR ; } Y = OAM index / 4
$03:AB04 A8 TAY ; /
$03:AB05 A9 02 LDA.B #$02 ; Size = 2 (16x16)
$03:AB07 99 60 04 STA.W OAM_TileSize,Y ; OAM size table
$03:AB0A 7A PLY ; Restore OAM index
$03:AB0B C8 INY ; \
$03:AB0C C8 INY ; |
$03:AB0D C8 INY ; } Next OAM slot
$03:AB0E C8 INY ; /
$03:AB0F FA PLX ; Restore counter
$03:AB10 CA DEX ; Counter--
$03:AB11 10 BE BPL $AAD1 ; Loop for 4 tiles
$03:AB13 FA PLX ; Restore sprite index
$03:AB14 60 RTS ; Return
;;; $AB15..AB1B: Table: Bowser chase accelerations ;;;
;; X and Y acceleration and speed limits for state 8. The last 4 bytes belong to another routine.
$03:AB15 .db $01,$FF ; X acceleration toward Mario: +1, -1
$03:AB17 .db $20,$E0 ; X speed limits: +$20, -$20
$03:AB19 .db $02,$FE ; Y acceleration: +2, -2
$03:AB1B .db $20,$E0,$01,$FF,$10,$F0 ; Y speed limits: +$20, -$20 (remaining bytes belong to later code)
;;; $AB21: Bowser state 8: chase Mario ;;;
;; State 8: runs the attack scheduler and face routines. Every frame, accelerates X toward Mario up to +/-$20,
;; and Y toward screen line $10 at +/-$20.
$03:AB21 20 FD A4 JSR.W $A4FD ; Run the attack scheduler ($A4FD)
$03:AB24 20 D2 A4 JSR.W $A4D2 ; Animate the face ($A4D2)
$03:AB27 20 ED A4 JSR.W $A4ED ; Turn to face Mario every 32 frames ($A4ED)
$03:AB2A A5 13 LDA RAM_FrameCounter ; Frame counter AND 0: always zero, so this runs every frame
$03:AB2C 29 00 AND.B #$00
$03:AB2E D0 1B BNE $AB4B
$03:AB30 A0 00 LDY.B #$00 ; Y = 0
$03:AB32 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:AB34 C5 94 CMP RAM_MarioXPos ; |
$03:AB36 BD E0 14 LDA.W RAM_SpriteXHi,X ; } Compare Bowser X to Mario X (16-bit)
$03:AB39 E5 95 SBC RAM_MarioXPosHi ; /
$03:AB3B 30 01 BMI $AB3E ; Bowser left of Mario: keep Y = 0
$03:AB3D C8 INY ; Bowser right of Mario: Y = 1
$03:AB3E B5 B6 LDA RAM_SpriteSpeedX,X ; X speed
$03:AB40 D9 17 AB CMP.W $AB17,Y ; At the limit already?
$03:AB43 F0 06 BEQ $AB4B ; Yes: skip
$03:AB45 18 CLC
$03:AB46 79 15 AB ADC.W $AB15,Y ; Accelerate toward Mario
$03:AB49 95 B6 STA RAM_SpriteSpeedX,X ; X speed
$03:AB4B A0 00 LDY.B #$00 ; Y = 0
$03:AB4D B5 D8 LDA RAM_SpriteYLo,X ; Bowser Y low
$03:AB4F C9 10 CMP.B #$10 ; Compare with $10
$03:AB51 30 01 BMI $AB54 ; Above: keep Y = 0
$03:AB53 C8 INY ; Below: Y = 1
$03:AB54 B5 AA LDA RAM_SpriteSpeedY,X ; Y speed
$03:AB56 D9 1B AB CMP.W $AB1B,Y ; At the limit already?
$03:AB59 F0 06 BEQ $AB61 ; Yes: return
$03:AB5B 18 CLC
$03:AB5C 79 19 AB ADC.W $AB19,Y ; Accelerate toward Y = $10
$03:AB5F 95 AA STA RAM_SpriteSpeedY,X ; Y speed
$03:AB61 60 RTS ; Return
;;; $AB62..AB62: Table: Bowser hop X speed ;;;
;; X speed $10/-$10 by side of Mario (used by the next state).
$03:AB62 .db $10,$F0 ; X speeds for landing: $10 (Mario on right), $F0
;;; $AB64: Bowser phase 9: bounce on the floor ;;;
;; Last Bowser phase ([$151C] = 9). Bowser falls with gravity (Y speed += 3) and bounces when he hits Y = $64:
;; Y speed = $A0,
;; X speed = +/-$10 away from or toward Mario, sound effect and a $20-frame ground shake.
;; Phase 4 ($AB9F): Bowser rises off the top of the screen. Phase 5 ($ABBE): holds still while
;; [$36]/[$37] counts up,
;; then moves on to phase 6 and starts a music change. Phase 6 ($AC03): spawns Princess Peach, flies off
;; to the upper left, changes music to $1C.
;; $AC63 (called from phase 6): creates Peach in sprite slot 8 at Bowser X + 8, Y + $47.
$03:AB64 A9 03 LDA.B #$03 ; \
$03:AB66 8D 27 14 STA.W $1427 ; / Bowser animation/drawing mode [$1427] = 3
$03:AB69 20 FD A4 JSR.W $A4FD ; Handle Bowser's hit timer and Mario contact ($A4FD)
$03:AB6C 20 D2 A4 JSR.W $A4D2 ; Pick clown car face frame ($A4D2)
$03:AB6F 20 ED A4 JSR.W $A4ED ; Every 32 frames turn to face Mario ($A4ED)
$03:AB72 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:AB74 18 CLC ; |
$03:AB75 69 03 ADC.B #$03 ; |
$03:AB77 95 AA STA RAM_SpriteSpeedY,X ; / Bowser Y speed += 3 (gravity)
$03:AB79 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:AB7B C9 64 CMP.B #$64 ; / Bowser Y < $64: still in the air, return
$03:AB7D 90 1F BCC $AB9E ; Return if Y position is above the floor
$03:AB7F BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:AB82 30 1A BMI $AB9E ; / Y high byte negative: above the screen, return
$03:AB84 A9 64 LDA.B #$64 ; \
$03:AB86 95 D8 STA RAM_SpriteYLo,X ; / Bowser Y = $64 (land on the floor)
$03:AB88 A9 A0 LDA.B #$A0 ; \
$03:AB8A 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $A0 (bounce up)
$03:AB8C A9 09 LDA.B #$09 ; \
$03:AB8E 8D FC 1D STA.W $1DFC ; / Sound effect: ground pound / thump
$03:AB91 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on
$03:AB94 B9 62 AB LDA.W $AB62,Y ; \
$03:AB97 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = $10 or $F0 (away from or toward Mario)
$03:AB99 A9 20 LDA.B #$20 ; \
$03:AB9B 8D 87 18 STA.W RAM_ShakeGrndTimer ; / Shake the ground for $20 frames
$03:AB9E 60 RTS ; Return
$03:AB9F 20 AC A6 JSR.W $A6AC ; Animate the clown car propeller ($A6AC)
$03:ABA2 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:ABA5 30 08 BMI $ABAF ; / Y high byte: above the screen ($FF) goes to the end branch
$03:ABA7 D0 10 BNE $ABB9 ; Y high non-zero (below top): skip to the rising code
$03:ABA9 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:ABAB C9 10 CMP.B #$10 ; |
$03:ABAD B0 0A BCS $ABB9 ; / Y position >= $10: keep rising
$03:ABAF A9 05 LDA.B #$05 ; \
$03:ABB1 9D 1C 15 STA.W $151C,X ; / Bowser phase [$151C] = 5 (hold in place)
$03:ABB4 A9 60 LDA.B #$60 ; \
$03:ABB6 9D 40 15 STA.W $1540,X ; / Phase timer [$1540] = $60
$03:ABB9 A9 F8 LDA.B #$F8 ; \
$03:ABBB 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = -8 (fly upward)
$03:ABBD 60 RTS ; Return
$03:ABBE 20 AC A6 JSR.W $A6AC ; Animate the clown car propeller ($A6AC)
$03:ABC1 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:ABC3 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:ABC5 BD 40 15 LDA.W $1540,X ; \
$03:ABC8 D0 21 BNE $ABEB ; / Phase timer [$1540] non-zero: go to the countdown handling
$03:ABCA A5 36 LDA $36 ; \
$03:ABCC 18 CLC ; |
$03:ABCD 69 0A ADC.B #$0A ; |
$03:ABCF 85 36 STA $36 ; } [$36]/[$37] += $0A (16-bit)
$03:ABD1 A5 37 LDA $37 ; |
$03:ABD3 69 00 ADC.B #$00 ; |
$03:ABD5 85 37 STA $37 ; |
$03:ABD7 F0 11 BEQ $ABEA ; / Carry into [$37] clear: return
$03:ABD9 64 36 STZ $36 ; [$36] = 0
$03:ABDB A9 20 LDA.B #$20 ; \
$03:ABDD 9D 4C 15 STA.W RAM_DisableInter,X ; / Disable sprite interaction for $20 frames
$03:ABE0 A9 60 LDA.B #$60 ; \
$03:ABE2 9D 40 15 STA.W $1540,X ; / Phase timer [$1540] = $60
$03:ABE5 A9 06 LDA.B #$06 ; \
$03:ABE7 9D 1C 15 STA.W $151C,X ; / Bowser phase [$151C] = 6
$03:ABEA 60 RTS ; Return
$03:ABEB C9 40 CMP.B #$40 ; \
$03:ABED 90 13 BCC $AC02 ; / Timer < $40: return
$03:ABEF C9 5E CMP.B #$5E ; \
$03:ABF1 D0 05 BNE $ABF8 ; / Timer = $5E? No: skip
$03:ABF3 A0 1B LDY.B #$1B ; \
$03:ABF5 8C FB 1D STY.W $1DFB ; / Change music to $1B
$03:ABF8 BD 64 15 LDA.W $1564,X ; \
$03:ABFB D0 05 BNE $AC02 ; / Animation timer [$1564] already running: return
$03:ABFD A9 12 LDA.B #$12 ; \
$03:ABFF 9D 64 15 STA.W $1564,X ; / Start the $1564 animation timer at $12
$03:AC02 60 RTS ; Return
$03:AC03 20 AC A6 JSR.W $A6AC ; Animate the clown car propeller ($A6AC)
$03:AC06 BD 4C 15 LDA.W RAM_DisableInter,X ; \
$03:AC09 C9 01 CMP.B #$01 ; / Interaction-disable timer = 1 (about to expire)?
$03:AC0B D0 15 BNE $AC22 ; Not yet: skip the Peach spawn
$03:AC0D A9 0B LDA.B #$0B ; \
$03:AC0F 85 71 STA RAM_MarioAnimation ; / Mario animation [$71] = $0B (disappear/freeze, ending pose)
$03:AC11 EE 0D 19 INC.W $190D ; [$190D]++ (probably flags the Peach-appears event)
$03:AC14 9C 01 07 STZ.W $0701 ; Clear $0701 (background color low)
$03:AC17 9C 02 07 STZ.W $0702 ; Clear $0702 (background color high)
$03:AC1A A9 03 LDA.B #$03 ; \
$03:AC1C 8D F9 13 STA.W RAM_IsBehindScenery ; / Mario is behind scenery [$13F9] = 3
$03:AC1F 20 63 AC JSR.W $AC63 ; Spawn Princess Peach ($AC63)
$03:AC22 BD 40 15 LDA.W $1540,X ; \
$03:AC25 D0 25 BNE $AC4C ; / Timer [$1540] non-zero: return
$03:AC27 A9 FA LDA.B #$FA ; \
$03:AC29 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = $FA (fly left)
$03:AC2B A9 FC LDA.B #$FC ; \
$03:AC2D 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $FC (fly up)
$03:AC2F A5 36 LDA $36 ; \
$03:AC31 18 CLC ; |
$03:AC32 69 05 ADC.B #$05 ; |
$03:AC34 85 36 STA $36 ; } [$36]/[$37] += $05 (16-bit)
$03:AC36 A5 37 LDA $37 ; |
$03:AC38 69 00 ADC.B #$00 ; |
$03:AC3A 85 37 STA $37 ; /
$03:AC3C A5 13 LDA RAM_FrameCounter ; \
$03:AC3E 29 03 AND.B #$03 ; |
$03:AC40 D0 0A BNE $AC4C ; / Every 4th frame only
$03:AC42 A5 38 LDA $38 ; \
$03:AC44 C9 80 CMP.B #$80 ; / [$38] >= $80: finished, go to AC4D
$03:AC46 B0 05 BCS $AC4D ; [$38]++
$03:AC48 E6 38 INC $38 ; [$39]++
$03:AC4A E6 39 INC $39
$03:AC4C 60 RTS ; Return
$03:AC4D BD 4A 16 LDA.W $164A,X ; \
$03:AC50 D0 08 BNE $AC5A ; / Already switched music? [$164A] non-zero: skip
$03:AC52 A9 1C LDA.B #$1C ; \
$03:AC54 8D FB 1D STA.W $1DFB ; / Change music to $1C
$03:AC57 FE 4A 16 INC.W $164A,X ; Mark the music as changed
$03:AC5A A9 FE LDA.B #$FE ; \
$03:AC5C 9D E0 14 STA.W RAM_SpriteXHi,X ; |
$03:AC5F 9D D4 14 STA.W RAM_SpriteYHi,X ; / Set X and Y high bytes to $FE: move the clown car far off-screen
$03:AC62 60 RTS ; Return
$03:AC63 A9 08 LDA.B #$08 ; \
$03:AC65 8D D0 14 STA.W $14D0 ; / Slot 8 sprite status [$14D0] = 8 (normal)
$03:AC68 A9 7C LDA.B #$7C ; \
$03:AC6A 85 A6 STA $A6 ; / Slot 8 sprite number [$A6] = $7C: Princess Peach
$03:AC6C B5 E4 LDA RAM_SpriteXLo,X ; \
$03:AC6E 18 CLC ; |
$03:AC6F 69 08 ADC.B #$08 ; |
$03:AC71 85 EC STA $EC ; |
$03:AC73 BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:AC76 69 00 ADC.B #$00 ; } Peach X = Bowser X + $08 (slot 8: low [$EC], high [$14E8])
$03:AC78 8D E8 14 STA.W $14E8 ; /
$03:AC7B B5 D8 LDA RAM_SpriteYLo,X ; \
$03:AC7D 18 CLC ; |
$03:AC7E 69 47 ADC.B #$47 ; |
$03:AC80 85 E0 STA $E0 ; |
$03:AC82 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:AC85 69 00 ADC.B #$00 ; } Peach Y = Bowser Y + $47 (slot 8: low [$E0], high [$14DC])
$03:AC87 8D DC 14 STA.W $14DC ; /
$03:AC8A DA PHX ; Save X
$03:AC8B A2 08 LDX.B #$08 ; X = 8: Peach's sprite slot
$03:AC8D 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize slot 8's sprite tables (InitSpriteTables)
$03:AC91 FA PLX ; Restore X
$03:AC92 60 RTS ; Return
;;; $AC93: Data: heart Y offsets for Peach scene (BlushTileDispY) ;;;
$03:AC93 .db $01,$11 ; Heart Y offsets: $01 for big Mario (X=0), $11 for small Mario (X=1)
;;; $AC95: Data: heart tiles for Peach scene (BlushTiles) ;;;
$03:AC95 .db $6E,$88 ; Heart tiles: $6E for big Mario, $88 for small Mario
;;; $AC97: Princess Peach main routine (PrincessPeach) ;;;
;; Sprite $7C. Draws Peach (two 16x16 tiles via $AAC8), blinks at random (1 in 8 every 128 frames) and,
;; while [$1558] is
;; running, draws a small heart/blush tile next to Mario. Freezes both Peach and Mario X speed, then runs the
;; state routine in PeachPtrs.
;; Called by:
;; $03:A157: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:AC97 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:AC99 38 SEC ; |
$03:AC9A E5 1A SBC RAM_ScreenBndryXLo ; |
$03:AC9C 85 00 STA $00 ; / [$00] = Peach screen X position
$03:AC9E B5 D8 LDA RAM_SpriteYLo,X ; \
$03:ACA0 38 SEC ; |
$03:ACA1 E5 1C SBC RAM_ScreenBndryYLo ; |
$03:ACA3 85 01 STA $01 ; / [$01] = Peach screen Y position
$03:ACA5 A5 13 LDA RAM_FrameCounter ; \
$03:ACA7 29 7F AND.B #$7F ; / Every 128 frames
$03:ACA9 D0 0D BNE $ACB8 ; Not yet: skip
$03:ACAB 22 F9 AC 01 JSL.L GetRand ; Get a random number
$03:ACAF 29 07 AND.B #$07 ; \
$03:ACB1 D0 05 BNE $ACB8 ; / 1 in 8 chance
$03:ACB3 A9 0C LDA.B #$0C ; \
$03:ACB5 9D 4C 15 STA.W RAM_DisableInter,X ; / Blink timer [$154C] = $0C
$03:ACB8 BC 02 16 LDY.W $1602,X ; Y = Peach pose frame [$1602]
$03:ACBB BD 4C 15 LDA.W RAM_DisableInter,X ; \
$03:ACBE F0 01 BEQ $ACC1 ; / Blink timer running?
$03:ACC0 C8 INY ; Y++ (blinking frame)
$03:ACC1 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:ACC4 D0 05 BNE $ACCB ; / Facing left? (direction 0) go on, else skip
$03:ACC6 98 TYA ; \
$03:ACC7 18 CLC ; |
$03:ACC8 69 08 ADC.B #$08 ; |
$03:ACCA A8 TAY ; / Facing direction 0: add 8 to the frame number
$03:ACCB 84 03 STY $03 ; [$03] = frame number
$03:ACCD A9 D0 LDA.B #$D0 ; \
$03:ACCF 9D EA 15 STA.W RAM_SprOAMIndex,X ; / OAM index = $D0
$03:ACD2 A8 TAY ; Y = $D0
$03:ACD3 20 C8 AA JSR.W $AAC8 ; Draw Peach's tiles ($AAC8)
$03:ACD6 A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:ACD8 A9 03 LDA.B #$03 ; A = 3: draw 4 tiles
$03:ACDA 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write (FinishOAMWrite)
$03:ACDE BD 58 15 LDA.W $1558,X ; \
$03:ACE1 F0 35 BEQ $AD18 ; / Blush/heart timer [$1558] = 0: skip the extra sprite
$03:ACE3 DA PHX ; Save X
$03:ACE4 A2 00 LDX.B #$00 ; X = 0
$03:ACE6 A5 19 LDA RAM_MarioPowerUp ; \
$03:ACE8 D0 01 BNE $ACEB ; / X = 0 for powered-up Mario, X = 1 for small Mario (index into heart tables)
$03:ACEA E8 INX ; |
$03:ACEB A0 4C LDY.B #$4C ; Y = $4C: OAM slot for the extra tile
$03:ACED A5 7E LDA $7E ; \
$03:ACEF 99 00 03 STA.W OAM_DispX,Y ; / OAM X = Mario screen X [$7E]
$03:ACF2 A5 80 LDA $80 ; \
$03:ACF4 18 CLC ; |
$03:ACF5 7D 93 AC ADC.W BlushTileDispY,X ; |
$03:ACF8 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = Mario screen Y [$80] + heart Y offset
$03:ACFB BD 95 AC LDA.W BlushTiles,X ; \
$03:ACFE 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = heart tile
$03:AD01 FA PLX ; Restore X
$03:AD02 A5 76 LDA RAM_MarioDirection ; \
$03:AD04 C9 01 CMP.B #$01 ; |
$03:AD06 A9 31 LDA.B #$31 ; |
$03:AD08 90 02 BCC $AD0C ; |
$03:AD0A 09 40 ORA.B #$40 ; |
$03:AD0C 99 03 03 STA.W OAM_Prop,Y ; / OAM property = $31, flip X if Mario faces right
$03:AD0F 98 TYA ; \
$03:AD10 4A LSR ; |
$03:AD11 4A LSR ; |
$03:AD12 A8 TAY ; / Y = OAM index / 4
$03:AD13 A9 02 LDA.B #$02 ; \
$03:AD15 99 60 04 STA.W OAM_TileSize,Y ; / OAM size = 16x16 for this tile
$03:AD18 74 B6 STZ RAM_SpriteSpeedX,X ; X speed = 0
$03:AD1A 64 7B STZ RAM_MarioSpeedX ; Mario X speed = 0 (Mario cannot walk away)
$03:AD1C A9 04 LDA.B #$04 ; \
$03:AD1E 9D 02 16 STA.W $1602,X ; / Peach pose frame [$1602] = 4
$03:AD21 B5 C2 LDA RAM_SpriteState,X ; A = Peach state [$C2]
$03:AD23 22 DF 86 00 JSL.L ExecutePtr ; Run the state routine below
;;; $AD27: Pointer table: Peach states, state 0-1 (PeachPtrs) ;;;
;; 8 states in [$C2]: 0 fall to ground (sparkles), 1 wait and face Mario, 2 walk together, 3 wait, 4 wait and
;; blink, 5 ending picture, 6 fade, 7 start credits ($C796).
;; State 0: falls to Y = $A0 and spawns sparkles every 8 frames. State 1: waits for [$1540], faces Mario.
;; $ADCC: contact check between Peach and Mario (carry set if touching).
$03:AD27 37 AD .dw $AD37 ; State 0: Peach falls to the ground
$03:AD29 B3 AD .dw $ADB3 ; State 1: wait, then face Mario
$03:AD2B DD AD .dw $ADDD ; State 2: Peach and Mario approach each other
$03:AD2D 25 AE .dw $AE25 ; State 3: wait
$03:AD2F 32 AE .dw $AE32 ; State 4: wait, then fade the screen
$03:AD31 AF AE .dw $AEAF ; State 5: show the ending picture step by step
$03:AD33 E8 AE .dw $AEE8 ; State 6: fade out
$03:AD35 96 C7 .dw $C796 ; State 7: start the credits ($C796)
$03:AD37 A9 06 LDA.B #$06 ; \
$03:AD39 9D 02 16 STA.W $1602,X ; / Peach pose [$1602] = 6 (falling)
$03:AD3C 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Update Y position with no gravity
$03:AD40 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:AD42 C9 08 CMP.B #$08 ; |
$03:AD44 B0 05 BCS $AD4B ; / Y speed >= 8: stop accelerating
$03:AD46 18 CLC ; \
$03:AD47 69 01 ADC.B #$01 ; |
$03:AD49 95 AA STA RAM_SpriteSpeedY,X ; / Y speed++ (gravity)
$03:AD4B BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:AD4E 30 13 BMI $AD63 ; / Y high byte negative: skip the landing check
$03:AD50 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:AD52 C9 A0 CMP.B #$A0 ; |
$03:AD54 90 0D BCC $AD63 ; / Y < $A0: still falling
$03:AD56 A9 A0 LDA.B #$A0 ; \
$03:AD58 95 D8 STA RAM_SpriteYLo,X ; / Peach Y = $A0 (ground)
$03:AD5A 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:AD5C A9 A0 LDA.B #$A0 ; \
$03:AD5E 9D 40 15 STA.W $1540,X ; / Timer [$1540] = $A0
$03:AD61 F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AD63 A5 13 LDA RAM_FrameCounter ; \
$03:AD65 29 07 AND.B #$07 ; / Every 8 frames spawn a sparkle
$03:AD67 D0 0A BNE $AD73 ; Else return
$03:AD69 A0 0B LDY.B #$0B ; Y = $0B: search extended sprite slots
$03:AD6B B9 F0 17 LDA.W $17F0,Y ; \
$03:AD6E F0 04 BEQ $AD74 ; / Slot Y free? Use it
$03:AD70 88 DEY ; \
$03:AD71 10 F8 BPL $AD6B ; / Next slot
$03:AD73 60 RTS ; Return
$03:AD74 A9 05 LDA.B #$05 ; \
$03:AD76 99 F0 17 STA.W $17F0,Y ; / Minor extended sprite slot Y = type 5 (sparkle)
$03:AD79 22 F9 AC 01 JSL.L GetRand ; Get a random number (GetRand)
$03:AD7D 64 00 STZ $00 ; \
$03:AD7F 29 1F AND.B #$1F ; |
$03:AD81 18 CLC ; |
$03:AD82 69 F8 ADC.B #$F8 ; |
$03:AD84 10 02 BPL $AD88 ; |
$03:AD86 C6 00 DEC $00 ; |
$03:AD88 18 CLC ; |
$03:AD89 75 E4 ADC RAM_SpriteXLo,X ; |
$03:AD8B 99 08 18 STA.W $1808,Y ; } Sparkle X = Peach X + random -8..+23 (high byte via [$00])
$03:AD8E BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:AD91 65 00 ADC $00 ; |
$03:AD93 99 EA 18 STA.W $18EA,Y ; /
$03:AD96 AD 8E 14 LDA.W RAM_RandomByte2 ; \
$03:AD99 29 1F AND.B #$1F ; |
$03:AD9B 75 D8 ADC RAM_SpriteYLo,X ; |
$03:AD9D 99 FC 17 STA.W $17FC,Y ; } Sparkle Y = Peach Y + random 0..$1F
$03:ADA0 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:ADA3 69 00 ADC.B #$00 ; |
$03:ADA5 99 14 18 STA.W $1814,Y ; /
$03:ADA8 A9 00 LDA.B #$00 ; \
$03:ADAA 99 20 18 STA.W $1820,Y ; / Sparkle sprite table $1820 = 0
$03:ADAD A9 17 LDA.B #$17 ; \
$03:ADAF 99 50 18 STA.W $1850,Y ; / Sparkle lifetime = $17
$03:ADB2 60 RTS ; Return
$03:ADB3 BD 40 15 LDA.W $1540,X ; \
$03:ADB6 D0 0A BNE $ADC2 ; / Timer [$1540] non-zero: skip ahead to face Mario
$03:ADB8 F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:ADBA 20 CC AD JSR.W $ADCC ; Check contact with Mario ($ADCC)
$03:ADBD 90 03 BCC $ADC2 ; No contact: skip
$03:ADBF FE 1C 15 INC.W $151C,X ; Unused. Sets the flag [$151C] when Peach already touches Mario.
$03:ADC2 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on
$03:ADC5 98 TYA ; \
$03:ADC6 9D 7C 15 STA.W RAM_SpriteDir,X ; / Peach faces Mario
$03:ADC9 85 76 STA RAM_MarioDirection ; Mario faces Peach
$03:ADCB 60 RTS ; Return
$03:ADCC 22 9F B6 03 JSL.L GetSpriteClippingA ; Get Peach's clipping box (GetSpriteClippingA)
$03:ADD0 22 64 B6 03 JSL.L GetMarioClipping ; Get Mario's clipping box (GetMarioClipping)
$03:ADD4 22 2B B7 03 JSL.L CheckForContact ; Check for contact; carry set if touching
$03:ADD8 60 RTS ; Return
;;; $ADD9..ADD9: Data: Peach walk X speeds ;;;
$03:ADD9 .db $08,$F8,$F8,$08 ; Walk speeds toward each other: $08, $F8, $F8, $08
;;; $ADDD: Peach states 2-4: walk to Mario, wait ;;;
;; State 2: Peach and Mario walk toward each other until they touch, then both face each other and [$1540] =
;; $60. State 3 waits, State 4 blinks and starts the blush timer.
$03:ADDD A5 14 LDA RAM_FrameCounterB ; \
$03:ADDF 29 08 AND.B #$08 ; |
$03:ADE1 D0 05 BNE $ADE8 ; |
$03:ADE3 A9 08 LDA.B #$08 ; |
$03:ADE5 9D 02 16 STA.W $1602,X ; / Every 16 frames toggle pose [$1602] = 8
$03:ADE8 20 CC AD JSR.W $ADCC ; Check contact with Mario ($ADCC)
$03:ADEB 08 PHP ; Save the contact flag
$03:ADEC 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on
$03:ADEF 28 PLP ; Restore the contact flag
$03:ADF0 BD 1C 15 LDA.W $151C,X ; \
$03:ADF3 D0 04 BNE $ADF9 ; / [$151C] set? Use the unused branch
$03:ADF5 B0 1D BCS $AE14 ; Contact: go to AE14
$03:ADF7 80 06 BRA $ADFF ; Else walk toward Mario
$03:ADF9 90 19 BCC $AE14 ; Unused branch for [$151C] non-zero, no contact
$03:ADFB 98 TYA ; \
$03:ADFC 49 01 EOR.B #$01 ; |
$03:ADFE A8 TAY ; / Y ^= 1 (reverse direction)
$03:ADFF B9 D9 AD LDA.W $ADD9,Y ; \
$03:AE02 95 B6 STA RAM_SpriteSpeedX,X ; / Peach X speed = $ADD9[Y]
$03:AE04 49 FF EOR.B #$FF ; \
$03:AE06 1A INC A ; |
$03:AE07 85 7B STA RAM_MarioSpeedX ; / Mario X speed = -(Peach X speed)
$03:AE09 98 TYA ; \
$03:AE0A 9D 7C 15 STA.W RAM_SpriteDir,X ; |
$03:AE0D 85 76 STA RAM_MarioDirection ; / Peach and Mario face direction Y
$03:AE0F 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Move Peach horizontally
$03:AE13 60 RTS ; Return
$03:AE14 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on
$03:AE17 98 TYA ; \
$03:AE18 9D 7C 15 STA.W RAM_SpriteDir,X ; |
$03:AE1B 85 76 STA RAM_MarioDirection ; / Peach and Mario face each other
$03:AE1D F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AE1F A9 60 LDA.B #$60 ; \
$03:AE21 9D 40 15 STA.W $1540,X ; / Timer [$1540] = $60
$03:AE24 60 RTS ; Return
$03:AE25 BD 40 15 LDA.W $1540,X ; \
$03:AE28 D0 07 BNE $AE31 ; / Timer [$1540] non-zero: return
$03:AE2A F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AE2C A9 A0 LDA.B #$A0 ; \
$03:AE2E 9D 40 15 STA.W $1540,X ; / Timer [$1540] = $A0
$03:AE31 60 RTS ; Return
$03:AE32 BD 40 15 LDA.W $1540,X ; \
$03:AE35 D0 08 BNE $AE3F ; / Timer [$1540] non-zero: skip
$03:AE37 F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AE39 9C 8A 18 STZ.W $188A ; Clear $188A (probably ending-picture counter)
$03:AE3C 9C 8B 18 STZ.W $188B ; Clear $188B
$03:AE3F C9 50 CMP.B #$50 ; \
$03:AE41 90 17 BCC $AE5A ; / Timer < $50: return
$03:AE43 48 PHA ; Save the timer
$03:AE44 D0 05 BNE $AE4B ; Timer = $50 exactly? Else skip
$03:AE46 A9 14 LDA.B #$14 ; \
$03:AE48 9D 4C 15 STA.W RAM_DisableInter,X ; / Blink timer [$154C] = $14
$03:AE4B A9 0A LDA.B #$0A ; \
$03:AE4D 9D 02 16 STA.W $1602,X ; / Peach pose [$1602] = $0A
$03:AE50 68 PLA ; Restore the timer
$03:AE51 C9 68 CMP.B #$68 ; \
$03:AE53 D0 05 BNE $AE5A ; / Timer = $68? Else return
$03:AE55 A9 80 LDA.B #$80 ; \
$03:AE57 9D 58 15 STA.W $1558,X ; / Start blush timer [$1558] = $80
$03:AE5A 60 RTS ; Return
;;; $AE5B..AEAB: Data: ending picture step delays ;;;
;; $55 bytes: frame delay per step of the ending picture, indexed by [$1921].
$03:AE5B .db $08,$08,$08,$08,$08,$08,$18,$08 ; Ending picture delays: timers in frames for each step (index = [$1921])
$03:AE63 .db $08,$08,$08,$08,$08,$08,$08,$08 ; Delay table row
$03:AE6B .db $08,$08,$08,$08,$08,$08,$20,$08 ; Delay table row
$03:AE73 .db $08,$08,$08,$08,$20,$08,$08,$10 ; Delay table row
$03:AE7B .db $08,$08,$08,$08,$08,$08,$08,$08 ; Delay table row
$03:AE83 .db $20,$08,$08,$08,$08,$08,$20,$08 ; Delay table row
$03:AE8B .db $04,$20,$08,$08,$08,$08,$08,$08 ; Delay table row
$03:AE93 .db $08,$08,$08,$08,$08,$08,$10,$08 ; Delay table row
$03:AE9B .db $08,$08,$08,$08,$08,$08,$08,$08 ; Delay table row
$03:AEA3 .db $08,$08,$10,$08,$08,$08,$08,$08 ; Delay table row
$03:AEAB .db $08,$08,$08,$40 ; Delay table row (last delay $40)
;;; $AEAF: Peach state 5: ending picture steps ;;;
;; Draws the ending picture ($D674) and advances one step ([$1921]) each time [$1540] expires, using
;; $AE5B delays. After step $54 moves to state 6. $AED0: state++, [$1FEB] = $80.
$03:AEAF 20 74 D6 JSR.W $D674 ; Draw the ending picture so far ($D674)
$03:AEB2 BD 40 15 LDA.W $1540,X ; \
$03:AEB5 D0 10 BNE $AEC7 ; / Timer [$1540] non-zero: return
$03:AEB7 AC 21 19 LDY.W $1921 ; Y = ending picture step [$1921]
$03:AEBA C0 54 CPY.B #$54 ; \
$03:AEBC F0 0A BEQ $AEC8 ; / Step $54: the last one, go to AEC8
$03:AEBE EE 21 19 INC.W $1921 ; Step++
$03:AEC1 B9 5B AE LDA.W $AE5B,Y ; \
$03:AEC4 9D 40 15 STA.W $1540,X ; / Timer = delay for this step
$03:AEC7 60 RTS ; Return
$03:AEC8 F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AECA A9 40 LDA.B #$40 ; \
$03:AECC 9D 40 15 STA.W $1540,X ; / Timer [$1540] = $40
$03:AECF 60 RTS ; Return
$03:AED0 F6 C2 INC RAM_SpriteState,X ; Peach state++
$03:AED2 A9 80 LDA.B #$80 ; \
$03:AED4 8D EB 1F STA.W $1FEB ; / [$1FEB] = $80 (probably starts the credits)
$03:AED7 60 RTS ; Return
;;; $AED8..AEE0: Unused. Data, purpose unclear ;;;
$03:AED8 .db $00,$00,$94,$18,$18,$9C,$9C,$FF ; Unused. Palette-like data, purpose unclear.
$03:AEE0 .db $00,$00,$52,$63,$63,$73,$73,$7F
;;; $AEE8: Peach state 6: fade ending color ;;;
;; Writes a grey CGRAM color $F1 (value = timer/2 replicated into R, G, B) to the palette buffer each frame so
;; the ending picture fades; redraws the picture. When [$1540] reaches 0, goes to $AED0.
$03:AEE8 BD 40 15 LDA.W $1540,X ; \
$03:AEEB F0 E3 BEQ $AED0 ; / Timer [$1540] = 0: go to AED0
$03:AEED 4A LSR ; \
$03:AEEE 85 00 STA $00 ; |
$03:AEF0 64 01 STZ $01 ; / [$00] = timer / 2
$03:AEF2 C2 20 REP #$20 ; A 16-bit
$03:AEF4 A5 00 LDA $00 ; \
$03:AEF6 0A ASL ; |
$03:AEF7 0A ASL ; |
$03:AEF8 0A ASL ; |
$03:AEF9 0A ASL ; |
$03:AEFA 0A ASL ; |
$03:AEFB 05 00 ORA $00 ; |
$03:AEFD 85 00 STA $00 ; / [$00] = v | v<<5
$03:AEFF 0A ASL ; \
$03:AF00 0A ASL ; |
$03:AF01 0A ASL ; |
$03:AF02 0A ASL ; |
$03:AF03 0A ASL ; |
$03:AF04 05 00 ORA $00 ; |
$03:AF06 85 00 STA $00 ; / [$00] = v | v<<5 | v<<10 (grey color value v)
$03:AF08 E2 20 SEP #$20 ; A 8-bit
$03:AF0A DA PHX ; Save X
$03:AF0B AA TAX ; X = A
$03:AF0C AC 81 06 LDY.W $0681 ; Y = palette write buffer index [$0681]
$03:AF0F A9 02 LDA.B #$02 ; \
$03:AF11 99 82 06 STA.W $0682,Y ; / Palette buffer: size 2
$03:AF14 A9 F1 LDA.B #$F1 ; \
$03:AF16 99 83 06 STA.W $0683,Y ; / Palette buffer: CGRAM color $F1
$03:AF19 A5 00 LDA $00 ; \
$03:AF1B 99 84 06 STA.W $0684,Y ; / Color low byte
$03:AF1E A5 01 LDA $01 ; \
$03:AF20 99 85 06 STA.W $0685,Y ; / Color high byte
$03:AF23 A9 00 LDA.B #$00 ; \
$03:AF25 99 86 06 STA.W $0686,Y ; / Terminator $00
$03:AF28 98 TYA ; \
$03:AF29 18 CLC ; |
$03:AF2A 69 04 ADC.B #$04 ; |
$03:AF2C 8D 81 06 STA.W $0681 ; / Buffer index += 4
$03:AF2F FA PLX ; Restore X
$03:AF30 20 74 D6 JSR.W $D674 ; Draw the ending picture ($D674)
$03:AF33 60 RTS ; Return
;;; $AF34..AF54: Data: Bowser hit star offsets and tiles ;;;
$03:AF34 .db $F4,$FF,$0C,$19,$24,$19,$0C,$FF ; Sparkle X offsets (8 steps around a circle)
$03:AF3C .db $FC,$F6,$F4,$F6,$FC,$02,$04,$02 ; Sparkle Y offsets
$03:AF44 .db $05,$05,$05,$05,$45,$45,$45,$45 ; Sparkle OAM properties: palette, flip X
$03:AF4C .db $34,$34,$34,$35,$35,$36,$36,$37 ; Y offsets of the sparkle trail tiles
$03:AF54 .db $38,$3A,$3E,$46,$54
;;; $AF59: Draw hit stars and puffs around Bowser ;;;
;; Called while [$14B5] (hit flash timer) is non-zero. Draws 4 stars (tile $59) circling Bowser and, for the
;; first $68 frames of [$14B3], a trail of smoke puffs (tile $49); then copies the 5 OAM entries into the
;; extended OAM area.
;; Called by:
;; $03:A2AA: Bowser main logic
$03:AF59 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get OAM draw info for Bowser (GetDrawInfoBnk3)
$03:AF5C BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:AF5F 85 04 STA $04 ; / [$04] = Bowser direction
$03:AF61 A5 14 LDA RAM_FrameCounterB ; \
$03:AF63 4A LSR ; |
$03:AF64 4A LSR ; |
$03:AF65 29 07 AND.B #$07 ; |
$03:AF67 85 02 STA $02 ; / [$02] = ([$14] >> 2) AND 7: rotation phase
$03:AF69 A9 EC LDA.B #$EC ; \
$03:AF6B 9D EA 15 STA.W RAM_SprOAMIndex,X ; / OAM index = $EC
$03:AF6E A8 TAY ; Y = $EC
$03:AF6F DA PHX ; Save X
$03:AF70 A2 03 LDX.B #$03 ; X = 3: draw 4 sparkles
$03:AF72 DA PHX ; Save X
$03:AF73 8A TXA ; \
$03:AF74 0A ASL ; |
$03:AF75 0A ASL ; |
$03:AF76 65 02 ADC $02 ; |
$03:AF78 29 07 AND.B #$07 ; |
$03:AF7A AA TAX ; / X = (X * 4 + [$02]) AND 7: position on the circle
$03:AF7B A5 00 LDA $00 ; \
$03:AF7D 18 CLC ; |
$03:AF7E 7D 34 AF ADC.W $AF34,X ; |
$03:AF81 99 00 03 STA.W OAM_DispX,Y ; / OAM X = [$00] + sparkle X offset
$03:AF84 A5 01 LDA $01 ; \
$03:AF86 18 CLC ; |
$03:AF87 7D 3C AF ADC.W $AF3C,X ; |
$03:AF8A 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = [$01] + sparkle Y offset
$03:AF8D A9 59 LDA.B #$59 ; \
$03:AF8F 99 02 03 STA.W OAM_Tile,Y ; / Tile $59 (star)
$03:AF92 BD 44 AF LDA.W $AF44,X ; \
$03:AF95 05 64 ORA $64 ; |
$03:AF97 99 03 03 STA.W OAM_Prop,Y ; / Property from $AF44 ORed with [$64] (priority)
$03:AF9A FA PLX ; Restore X
$03:AF9B C8 INY ; \
$03:AF9C C8 INY ; |
$03:AF9D C8 INY ; |
$03:AF9E C8 INY ; / Next OAM slot (Y += 4)
$03:AF9F CA DEX ; X--
$03:AFA0 10 D0 BPL $AF72 ; Loop for all 4
$03:AFA2 AD B3 14 LDA.W $14B3 ; \
$03:AFA5 EE B3 14 INC.W $14B3 ; / A = [$14B3]; then [$14B3]++ (Bowser-hit effect timer)
$03:AFA8 4A LSR ; \
$03:AFA9 4A LSR ; |
$03:AFAA 4A LSR ; / Divide by 8
$03:AFAB C9 0D CMP.B #$0D ; \
$03:AFAD B0 28 BCS $AFD7 ; / >= $0D: effect finished, skip
$03:AFAF AA TAX ; X = frame of the effect
$03:AFB0 A0 FC LDY.B #$FC ; Y = $FC: last OAM slot of the extra tile
$03:AFB2 A5 04 LDA $04 ; \
$03:AFB4 0A ASL ; |
$03:AFB5 2A ROL ; |
$03:AFB6 0A ASL ; |
$03:AFB7 0A ASL ; |
$03:AFB8 0A ASL ; |
$03:AFB9 65 00 ADC $00 ; / Add [$00] plus $15 with direction-based offset
$03:AFBB 18 CLC ; \
$03:AFBC 69 15 ADC.B #$15 ; / X offset +$15
$03:AFBE 99 00 03 STA.W OAM_DispX,Y ; OAM X = result
$03:AFC1 A5 01 LDA $01 ; \
$03:AFC3 18 CLC ; |
$03:AFC4 7F 4C AF 03 ADC.L $AF4C,X ; / OAM Y = [$01] + $AF4C[X]
$03:AFC8 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:AFCB A9 49 LDA.B #$49 ; \
$03:AFCD 99 02 03 STA.W OAM_Tile,Y ; / Tile $49 (smoke puff)
$03:AFD0 A9 07 LDA.B #$07 ; \
$03:AFD2 05 64 ORA $64 ; |
$03:AFD4 99 03 03 STA.W OAM_Prop,Y ; / Property $07 ORed with [$64]
$03:AFD7 FA PLX ; Restore X
$03:AFD8 A0 00 LDY.B #$00 ; Y = 0: 8x8 tiles
$03:AFDA A9 04 LDA.B #$04 ; A = 4: draw 5 tiles
$03:AFDC 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write (FinishOAMWrite)
$03:AFE0 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index
$03:AFE3 DA PHX ; Save X
$03:AFE4 A2 04 LDX.B #$04 ; X = 4: copy 5 tiles
$03:AFE6 B9 00 03 LDA.W OAM_DispX,Y ; \
$03:AFE9 99 00 02 STA.W OAM_ExtendedDispX,Y ; / Copy OAM X to extended OAM area
$03:AFEC B9 01 03 LDA.W OAM_DispY,Y ; \
$03:AFEF 99 01 02 STA.W OAM_ExtendedDispY,Y ; / Copy OAM Y
$03:AFF2 B9 02 03 LDA.W OAM_Tile,Y ; \
$03:AFF5 99 02 02 STA.W OAM_ExtendedTile,Y ; / Copy tile
$03:AFF8 B9 03 03 LDA.W OAM_Prop,Y ; \
$03:AFFB 99 03 02 STA.W OAM_ExtendedProp,Y ; / Copy property
$03:AFFE 5A PHY ; Save Y
$03:AFFF 98 TYA ; \
$03:B000 4A LSR ; |
$03:B001 4A LSR ; |
$03:B002 A8 TAY ; / Y = OAM index / 4
$03:B003 B9 60 04 LDA.W OAM_TileSize,Y ; \
$03:B006 99 20 04 STA.W $0420,Y ; / Copy tile size to the $0420 table
$03:B009 7A PLY ; Restore Y
$03:B00A C8 INY ; \
$03:B00B C8 INY ; |
$03:B00C C8 INY ; |
$03:B00D C8 INY ; / Next slot (Y += 4)
$03:B00E CA DEX ; X--
$03:B00F 10 D5 BPL $AFE6 ; Loop for all 5
$03:B011 FA PLX ; Restore X
$03:B012 60 RTS ; Return
;;; $B013..B017: Data: Mecha-Koopa spawn offsets and speeds ;;;
$03:B013 .db $00,$10 ; Spawn X offsets low byte: $00, $10
$03:B015 .db $00,$00 ; Spawn X offsets high byte: $00, $00
$03:B017 .db $F8,$08 ; Spawned Mecha-Koopa X speeds: $F8, $08
;;; $B019: Bowser drops two Mecha-Koopas ;;;
;; Finds a free sprite slot (0 or 1) twice and spawns Mecha-Koopa ($A2, status 8) at Bowser X + 0 / + $10, Y +
;; $10, with X speed $F8 / $08 and Y speed $C0. Parameters: [$02] = side (0 left, 1 right).
;; Called by:
;; $03:A5CD: Bowser: Mechakoopa drop and ball throw
$03:B019 64 02 STZ $02 ; \
$03:B01B 20 20 B0 JSR.W $B020 ; / Clear [$02]; spawn the left Mecha-Koopa
$03:B01E E6 02 INC $02 ; [$02] = 1: spawn the right one
$03:B020 A0 01 LDY.B #$01 ; Y = 1: search sprite slots 1 and 0
$03:B022 B9 C8 14 LDA.W $14C8,Y ; \
$03:B025 F0 04 BEQ $B02B ; / Slot Y empty (status 0)? Use it
$03:B027 88 DEY ; \
$03:B028 10 F8 BPL $B022 ; / Next slot; none free: return
$03:B02A 60 RTS ; Return
$03:B02B A9 08 LDA.B #$08 ; \
$03:B02D 99 C8 14 STA.W $14C8,Y ; / Status = 8 (normal)
$03:B030 A9 A2 LDA.B #$A2 ; \
$03:B032 99 9E 00 STA.W RAM_SpriteNum,Y ; / Sprite number $A2: Mecha-Koopa
$03:B035 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:B037 18 CLC ; |
$03:B038 69 10 ADC.B #$10 ; |
$03:B03A 99 D8 00 STA.W RAM_SpriteYLo,Y ; / Y position = Bowser Y + $10
$03:B03D BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:B040 69 00 ADC.B #$00 ; |
$03:B042 99 D4 14 STA.W RAM_SpriteYHi,Y ; / Y high byte
$03:B045 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:B047 85 00 STA $00 ; / [$00] = Bowser X low
$03:B049 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:B04C 85 01 STA $01 ; / [$01] = Bowser X high
$03:B04E DA PHX ; Save X
$03:B04F A6 02 LDX $02 ; X = [$02]: which side
$03:B051 A5 00 LDA $00 ; \
$03:B053 18 CLC ; |
$03:B054 7D 13 B0 ADC.W $B013,X ; |
$03:B057 99 E4 00 STA.W RAM_SpriteXLo,Y ; / X low = Bowser X + $B013[X]
$03:B05A A5 01 LDA $01 ; \
$03:B05C 7D 15 B0 ADC.W $B015,X ; |
$03:B05F 99 E0 14 STA.W RAM_SpriteXHi,Y ; / X high = Bowser X high + $B015[X] (carry)
$03:B062 BB TYX ; X = new sprite slot
$03:B063 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize the new sprite's tables
$03:B067 A4 02 LDY $02 ; Y = [$02]
$03:B069 B9 17 B0 LDA.W $B017,Y ; \
$03:B06C 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = $B017[Y]
$03:B06E A9 C0 LDA.B #$C0 ; \
$03:B070 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $C0 (toss upward)
$03:B072 FA PLX ; Restore X
$03:B073 60 RTS ; Return
;;; $B074..B076: Data: Mario shove X speeds ;;;
$03:B074 .db $40,$C0 ; Mario shove X speeds: $40, $C0
$03:B076 .db $10,$F0 ; Mario shove X speeds while running/spinning: $10, $F0
;;; $B078: Bowser Mario and Mecha-Koopa contact ;;;
;; Runs when Bowser is in phase 7 or later and [$38] = $20. Checks carried Mecha-Koopas against Bowser
;; ($B0DC/03B0F3), then three Bowser hitboxes against Mario via MarioSprInteract (Tweaker $24-$26):
;; first two shove Mario away; the last hurts him. Mecha-Koopa hit starts the hit flash [$14B5] = $4C and
;; kills the sprite.
;; Called by:
;; $03:A305: Bowser main logic
$03:B078 A5 38 LDA $38 ; \
$03:B07A C9 20 CMP.B #$20 ; |
$03:B07C D0 5D BNE $B0DB ; / Return unless [$38] = $20
$03:B07E BD 1C 15 LDA.W $151C,X ; \
$03:B081 C9 07 CMP.B #$07 ; |
$03:B083 90 6D BCC $B0F2 ; / Bowser phase [$151C] < 7: return
$03:B085 A5 36 LDA $36 ; \
$03:B087 05 37 ORA $37 ; |
$03:B089 D0 67 BNE $B0F2 ; / Return while [$36]/[$37] is non-zero
$03:B08B 20 DC B0 JSR.W $B0DC ; Check carried Mecha-Koopas hitting Bowser ($B0DC)
$03:B08E BD 4C 15 LDA.W RAM_DisableInter,X ; \
$03:B091 D0 48 BNE $B0DB ; / Interaction disabled: return
$03:B093 A9 24 LDA.B #$24 ; \
$03:B095 9D 62 16 STA.W RAM_Tweaker1662,X ; / Tweaker $24: first body hitbox
$03:B098 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario/Bowser contact
$03:B09C 90 1F BCC $B0BD ; No contact: next hitbox
$03:B09E 20 D6 B0 JSR.W $B0D6 ; Bounce: disable interaction ($B0D6)
$03:B0A1 64 7D STZ RAM_MarioSpeedY ; Mario Y speed = 0
$03:B0A3 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side Mario is on
$03:B0A6 AD B1 14 LDA.W $14B1 ; \
$03:B0A9 0D B6 14 ORA.W $14B6 ; |
$03:B0AC F0 05 BEQ $B0B3 ; / [$14B1] or [$14B6] both zero? (purpose unclear)
$03:B0AE B9 76 B0 LDA.W $B076,Y ; Unused. Weaker shove X speed
$03:B0B1 80 03 BRA $B0B6 ; Skip
$03:B0B3 B9 74 B0 LDA.W $B074,Y ; Mario X speed from the strong table
$03:B0B6 85 7B STA RAM_MarioSpeedX ; Mario X speed = shove
$03:B0B8 A9 01 LDA.B #$01 ; \
$03:B0BA 8D F9 1D STA.W $1DF9 ; / Sound effect: contact
$03:B0BD FE 62 16 INC.W RAM_Tweaker1662,X ; Next hitbox: Tweaker++
$03:B0C0 22 DC A7 01 JSL.L MarioSprInteract ; Check contact again
$03:B0C4 90 03 BCC $B0C9 ; No contact: next
$03:B0C6 20 D2 B0 JSR.W $B0D2 ; Unused. Hurt Mario ($B0D2).
$03:B0C9 FE 62 16 INC.W RAM_Tweaker1662,X ; Next hitbox: Tweaker++
$03:B0CC 22 DC A7 01 JSL.L MarioSprInteract ; Check contact
$03:B0D0 90 09 BCC $B0DB ; No contact: return
$03:B0D2 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
$03:B0D6 A9 20 LDA.B #$20 ; \
$03:B0D8 9D 4C 15 STA.W RAM_DisableInter,X ; / Disable interaction for $20 frames
$03:B0DB 60 RTS ; Return
$03:B0DC A0 01 LDY.B #$01 ; Y = 1: check sprites 1 and 0
$03:B0DE 5A PHY ; Save Y
$03:B0DF B9 C8 14 LDA.W $14C8,Y ; \
$03:B0E2 C9 09 CMP.B #$09 ; / Status $09 (carried/stunned)?
$03:B0E4 D0 08 BNE $B0EE ; No: next
$03:B0E6 B9 A0 15 LDA.W RAM_OffscreenHorz,Y ; \
$03:B0E9 D0 03 BNE $B0EE ; / Skip sprites that are off-screen horizontally
$03:B0EB 20 F3 B0 JSR.W $B0F3 ; Test hit against Bowser ($B0F3)
$03:B0EE 7A PLY ; Restore Y
$03:B0EF 88 DEY ; Y--
$03:B0F0 10 EC BPL $B0DE ; Loop
$03:B0F2 60 RTS ; Return
$03:B0F3 DA PHX ; Save X
$03:B0F4 BB TYX ; X = sprite slot Y
$03:B0F5 22 E5 B6 03 JSL.L GetSpriteClippingB ; Get that sprite's clipping box (GetSpriteClippingB)
$03:B0F9 FA PLX ; Restore X
$03:B0FA A9 24 LDA.B #$24 ; \
$03:B0FC 9D 62 16 STA.W RAM_Tweaker1662,X ; / Bowser Tweaker $24
$03:B0FF 22 9F B6 03 JSL.L GetSpriteClippingA ; Get Bowser's clipping box
$03:B103 22 2B B7 03 JSL.L CheckForContact ; Check for contact
$03:B107 B0 39 BCS $B142 ; Contact: go to B142
$03:B109 FE 62 16 INC.W RAM_Tweaker1662,X ; Tweaker++ (second hitbox)
$03:B10C 22 9F B6 03 JSL.L GetSpriteClippingA ; Get clipping box
$03:B110 22 2B B7 03 JSL.L CheckForContact ; Check contact
$03:B114 90 4A BCC $B160 ; No contact: return
$03:B116 AD B5 14 LDA.W $14B5 ; \
$03:B119 D0 45 BNE $B160 ; / Hit flash timer [$14B5] running: return
$03:B11B A9 4C LDA.B #$4C ; \
$03:B11D 8D B5 14 STA.W $14B5 ; / Bowser hit flash timer [$14B5] = $4C
$03:B120 9C B3 14 STZ.W $14B3 ; Reset effect timer [$14B3] = 0
$03:B123 BD 1C 15 LDA.W $151C,X ; \
$03:B126 8D B4 14 STA.W $14B4 ; / [$14B4] = Bowser phase
$03:B129 A9 28 LDA.B #$28 ; \
$03:B12B 8D FC 1D STA.W $1DFC ; / Sound effect: Bowser hit
$03:B12E BD 1C 15 LDA.W $151C,X ; \
$03:B131 C9 09 CMP.B #$09 ; / Phase = 9?
$03:B133 D0 0D BNE $B142 ; No: skip
$03:B135 BD 7B 18 LDA.W $187B,X ; \
$03:B138 C9 01 CMP.B #$01 ; / [$187B] (hit counter) = 1?
$03:B13A D0 06 BNE $B142 ; No: skip
$03:B13C 5A PHY ; Save Y
$03:B13D 22 C8 A6 03 JSL.L KillMostSprites ; Kill all sprites except Bowser (KillMostSprites)
$03:B141 7A PLY ; Restore Y
$03:B142 A9 00 LDA.B #$00 ; \
$03:B144 99 B6 00 STA.W RAM_SpriteSpeedX,Y ; / Thrown sprite X speed = 0
$03:B147 DA PHX ; Save X
$03:B148 A2 10 LDX.B #$10 ; X = $10
$03:B14A B9 AA 00 LDA.W RAM_SpriteSpeedY,Y ; \
$03:B14D 30 02 BMI $B151 ; / Thrown sprite moving up? Keep $10
$03:B14F A2 D0 LDX.B #$D0 ; X = $D0
$03:B151 8A TXA ; \
$03:B152 99 AA 00 STA.W RAM_SpriteSpeedY,Y ; / Y speed = $10 or $D0
$03:B155 A9 02 LDA.B #$02 ; \
$03:B157 99 C8 14 STA.W $14C8,Y ; / Status 2: killed
$03:B15A BB TYX ; X = slot
$03:B15B 22 6F AB 01 JSL.L $AB6F ; Give points / spawn effect ($AB6F)
$03:B15F FA PLX ; Restore X
$03:B160 60 RTS ; Return
;;; $B161: Data: bowling ball X speeds (BowserBallSpeed) ;;;
$03:B161 .db $10,$F0 ; Bowling ball X speeds: $10, $F0
;;; $B163: Bowser bowling ball main (BowserBowlingBall) ;;;
;; Main routine of the bowling ball Bowser throws (sprite $A1): draws it, applies gravity (+3 per frame, max
;; $40),
;; lands on the floor line Y = $B0, plays a thud and shakes the ground on hard landings, bounces via
;; $B7F8,
;; and starts rolling toward Mario after the first landing. [$1570] is the rotation counter, stepped by roll
;; direction.
;; Called by:
;; $03:A24B: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:B163 20 21 B2 JSR.W BowserBallGfx ; Draw the bowling ball
$03:B166 A5 9D LDA RAM_SpritesLocked ; \
$03:B168 D0 6A BNE $B1D4 ; / Return if sprites are locked
$03:B16A 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn if far offscreen
$03:B16D 22 DC A7 01 JSL.L MarioSprInteract ; Check contact with Mario
$03:B171 22 22 80 01 JSL.L UpdateXPosNoGrvty ; Update X position (no gravity)
$03:B175 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Update Y position (no gravity)
$03:B179 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:B17B C9 40 CMP.B #$40 ; } If Y speed < $40 (signed)...
$03:B17D 10 07 BPL $B186 ; /
$03:B17F 18 CLC ; \
$03:B180 69 03 ADC.B #$03 ; } ... Y speed += 3 (gravity)
$03:B182 95 AA STA RAM_SpriteSpeedY,X ; /
$03:B184 80 04 BRA $B18A ; Skip the clamp
$03:B186 A9 40 LDA.B #$40 ; \
$03:B188 95 AA STA RAM_SpriteSpeedY,X ; / Clamp Y speed to $40 (terminal velocity)
$03:B18A B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:B18C 30 37 BMI $B1C5 ; / Moving up: skip the floor check
$03:B18E BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:B191 30 32 BMI $B1C5 ; / Y position high byte negative (above level): skip the floor check
$03:B193 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:B195 C9 B0 CMP.B #$B0 ; } Above floor line Y = $B0: skip
$03:B197 90 2C BCC $B1C5 ; /
$03:B199 A9 B0 LDA.B #$B0 ; \
$03:B19B 95 D8 STA RAM_SpriteYLo,X ; / Land on the floor: Y position = $B0
$03:B19D B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:B19F C9 3E CMP.B #$3E ; } Fall speed >= $3E (hard landing)?
$03:B1A1 90 0A BCC $B1AD ; /
$03:B1A3 A0 25 LDY.B #$25 ; \
$03:B1A5 8C FC 1D STY.W $1DFC ; / Play sound effect $25 (heavy impact)
$03:B1A8 A0 20 LDY.B #$20 ; \
$03:B1AA 8C 87 18 STY.W RAM_ShakeGrndTimer ; / Shake the ground for $20 frames
$03:B1AD C9 08 CMP.B #$08 ; \
$03:B1AF 90 05 BCC $B1B6 ; / Fall speed < 8: no bounce sound
$03:B1B1 A9 01 LDA.B #$01 ; \
$03:B1B3 8D F9 1D STA.W $1DF9 ; / Play sound effect 1 (bounce)
$03:B1B6 20 F8 B7 JSR.W $B7F8 ; Set bounce Y speed from table by impact speed
$03:B1B9 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:B1BB D0 08 BNE $B1C5 ; / Already rolling horizontally: skip
$03:B1BD 20 17 B8 JSR.W SubHorzPosBnk3 ; Y = side of Mario relative to the ball
$03:B1C0 B9 61 B1 LDA.W BowserBallSpeed,Y ; \
$03:B1C3 95 B6 STA RAM_SpriteSpeedX,X ; / Start rolling toward Mario (X speed from BowserBallSpeed)
$03:B1C5 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:B1C7 F0 0B BEQ $B1D4 ; / No X speed: return
$03:B1C9 30 06 BMI $B1D1 ; Moving left (negative): skip to the single increment
$03:B1CB DE 70 15 DEC.W $1570,X ; Moving right: [$1570] -= 2 ...
$03:B1CE DE 70 15 DEC.W $1570,X ; (second decrement)
$03:B1D1 FE 70 15 INC.W $1570,X ; ... then += 1: net -1 right, +1 left (spin direction follows roll)
$03:B1D4 60 RTS ; Return
;;; $B1D5: Table: bowling ball tile X offsets (BowserBallDispX) ;;;
$03:B1D5 .db $F0,$00,$10,$F0,$00,$10,$F0,$00 ; Tile X offsets, 12 tiles (3 columns x 3 rows, then 3 extra pieces)
$03:B1DD .db $10,$00,$00,$F8 ; Extra pieces: eyes/mouth overlay
;;; $B1E1: Table: bowling ball tile Y offsets (BowserBallDispY) ;;;
$03:B1E1 .db $E2,$E2,$E2,$F2,$F2,$F2,$02,$02 ; Tile Y offsets, 12 tiles
$03:B1E9 .db $02,$02,$02,$EA ; Extra pieces
;;; $B1ED: Table: bowling ball tile numbers (BowserBallTiles) ;;;
$03:B1ED .db $45,$47,$45,$65,$66,$65,$45,$47 ; Tile numbers, 12 tiles (body)
$03:B1F5 .db $45,$39,$38,$63 ; Extra pieces
;;; $B1F9: Table: bowling ball tile properties (BowserBallGfxProp) ;;;
$03:B1F9 .db $0D,$0D,$4D,$0D,$0D,$4D,$8D,$8D ; Tile YXPPCCCT properties (flips) for 12 tiles
$03:B201 .db $CD,$0D,$0D,$0D ; Extra pieces
;;; $B205: Table: bowling ball tile sizes (BowserBallTileSize) ;;;
$03:B205 .db $02,$02,$02,$02,$02,$02,$02,$02 ; Tile sizes (2 = 16x16, 0 = 8x8)
$03:B20D .db $02,$00,$00,$02 ; Extra pieces
;;; $B211: Table: bowling ball spin X offsets (BowserBallDispX2) ;;;
$03:B211 .db $04,$0D,$10,$0D,$04,$FB,$F8,$FB ; Rotating offset X (8 positions around a circle) for the spinning tiles
;;; $B219: Table: bowling ball spin Y offsets (BowserBallDispY2) ;;;
$03:B219 .db $00,$FD,$F4,$EB,$E8,$EB,$F4,$FD ; Rotating offset Y (8 positions around a circle) for the spinning tiles
;;; $B221: Bowling ball graphics routine (BowserBallGfx) ;;;
;; Draws 12 tiles (a 3x3 body plus 3 extra pieces) into OAM at index $70, then moves tiles 2 and 3 (the bright
;; pieces)
;; around a circle using the 8-step offset tables, stepped by [$1570] >> 3, to fake rotation.
;; Called by:
;; $03:B163: Bowser bowling ball main (BowserBowlingBall)
$03:B221 A9 70 LDA.B #$70 ; OAM index = $70
$03:B223 9D EA 15 STA.W RAM_SprOAMIndex,X ; Store sprite OAM index
$03:B226 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw info: $00/$01 = screen X/Y
$03:B229 DA PHX ; Save sprite index
$03:B22A A2 0B LDX.B #$0B ; X = 11: 12 tiles
$03:B22C A5 00 LDA $00 ; \
$03:B22E 18 CLC ; } Tile X = sprite X + X offset
$03:B22F 7D D5 B1 ADC.W BowserBallDispX,X ; /
$03:B232 99 00 03 STA.W OAM_DispX,Y ; Store OAM X
$03:B235 A5 01 LDA $01 ; \
$03:B237 18 CLC ; } Tile Y = sprite Y + Y offset
$03:B238 7D E1 B1 ADC.W BowserBallDispY,X ; /
$03:B23B 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:B23E BD ED B1 LDA.W BowserBallTiles,X ; Tile number from table
$03:B241 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:B244 BD F9 B1 LDA.W BowserBallGfxProp,X ; \
$03:B247 05 64 ORA $64 ; / Properties from table | sprite priority bits [$64]
$03:B249 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:B24C 5A PHY ; Save OAM index
$03:B24D 98 TYA ; \
$03:B24E 4A LSR ; |
$03:B24F 4A LSR ; } Y = OAM index / 4: index into the size table
$03:B250 A8 TAY ; /
$03:B251 BD 05 B2 LDA.W BowserBallTileSize,X ; Tile size from table
$03:B254 99 60 04 STA.W OAM_TileSize,Y ; Store OAM size/high X bit
$03:B257 7A PLY ; Restore OAM index
$03:B258 C8 INY ; \
$03:B259 C8 INY ; |
$03:B25A C8 INY ; } OAM index += 4
$03:B25B C8 INY ; /
$03:B25C CA DEX ; Next tile
$03:B25D 10 CD BPL $B22C ; Loop for all 12 tiles
$03:B25F FA PLX ; Restore sprite index
$03:B260 DA PHX ; Save it again
$03:B261 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index of the sprite
$03:B264 BD 70 15 LDA.W $1570,X ; \
$03:B267 4A LSR ; |
$03:B268 4A LSR ; |
$03:B269 4A LSR ; } Frame = ([$1570] >> 3) & 7: rotation step 0-7
$03:B26A 29 07 AND.B #$07 ; /
$03:B26C 48 PHA ; Save step
$03:B26D AA TAX ; X = step
$03:B26E B9 04 03 LDA.W OAM_Tile2DispX,Y ; \
$03:B271 18 CLC ; } Spinning tile 2: X += circle X offset [step]
$03:B272 7D 11 B2 ADC.W BowserBallDispX2,X ; /
$03:B275 99 04 03 STA.W OAM_Tile2DispX,Y ; Store OAM X
$03:B278 B9 05 03 LDA.W OAM_Tile2DispY,Y ; \
$03:B27B 18 CLC ; } Spinning tile 2: Y += circle Y offset [step]
$03:B27C 7D 19 B2 ADC.W BowserBallDispY2,X ; /
$03:B27F 99 05 03 STA.W OAM_Tile2DispY,Y ; Store OAM Y
$03:B282 68 PLA ; \
$03:B283 18 CLC ; |
$03:B284 69 02 ADC.B #$02 ; } Step + 2 (quarter turn), wrapped to 0-7
$03:B286 29 07 AND.B #$07 ; /
$03:B288 AA TAX ; X = step + 2
$03:B289 B9 08 03 LDA.W OAM_Tile3DispX,Y ; \
$03:B28C 18 CLC ; } Spinning tile 3: X += circle X offset
$03:B28D 7D 11 B2 ADC.W BowserBallDispX2,X ; /
$03:B290 99 08 03 STA.W OAM_Tile3DispX,Y ; Store OAM X
$03:B293 B9 09 03 LDA.W OAM_Tile3DispY,Y ; \
$03:B296 18 CLC ; } Spinning tile 3: Y += circle Y offset
$03:B297 7D 19 B2 ADC.W BowserBallDispY2,X ; /
$03:B29A 99 09 03 STA.W OAM_Tile3DispY,Y ; Store OAM Y
$03:B29D FA PLX ; Restore sprite index
$03:B29E A9 0B LDA.B #$0B ; A = 11: 12 tiles
$03:B2A0 A0 FF LDY.B #$FF ; Y = $FF: tile sizes already set
$03:B2A2 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:B2A6 60 RTS ; Return
;;; $B2A7: Table: Mechakoopa walk speed (MechakoopaSpeed) ;;;
$03:B2A7 .db $08,$F8 ; X speed on the ground, by direction: right $08, left $F8
;;; $B2A9: Mechakoopa main (MechaKoopa) ;;;
;; Draws itself, then (status 8, sprites unlocked) walks at +/-8 X speed, turns toward Mario every 64 frames
;; while on the ground, reverses at walls, and advances the walk animation frame in [$1602] (0-3).
;; Stunned handling is elsewhere; here [$1540] only drives the stun graphics.
;; Called by:
;; $03:A254: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:B2A9 22 07 B3 03 JSL.L $B307 ; Draw the Mechakoopa (via wrapper)
$03:B2AD BD C8 14 LDA.W $14C8,X ; \
$03:B2B0 C9 08 CMP.B #$08 ; } Return unless sprite status = 8 (normal)
$03:B2B2 D0 52 BNE $B306 ; /
$03:B2B4 A5 9D LDA RAM_SpritesLocked ; \
$03:B2B6 D0 4E BNE $B306 ; / Return if sprites are locked
$03:B2B8 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn if far offscreen
$03:B2BB 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Check contact with Mario and other sprites
$03:B2BF 22 2A 80 01 JSL.L UpdateSpritePos ; Update position with gravity and object collision
$03:B2C3 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:B2C6 29 04 AND.B #$04 ; } Not on the ground: skip to wall check
$03:B2C8 F0 19 BEQ $B2E3 ; /
$03:B2CA 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:B2CC BC 7C 15 LDY.W RAM_SpriteDir,X ; Y = facing direction
$03:B2CF B9 A7 B2 LDA.W MechakoopaSpeed,Y ; \
$03:B2D2 95 B6 STA RAM_SpriteSpeedX,X ; / X speed = walk speed for the direction
$03:B2D4 B5 C2 LDA RAM_SpriteState,X ; \
$03:B2D6 F6 C2 INC RAM_SpriteState,X ; |
$03:B2D8 29 3F AND.B #$3F ; } Every 64 frames ([state] & $3F = 0), turn toward Mario
$03:B2DA D0 07 BNE $B2E3 ; /
$03:B2DC 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:B2DF 98 TYA ; } Face Mario
$03:B2E0 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:B2E3 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:B2E6 29 03 AND.B #$03 ; } Not touching a wall: skip
$03:B2E8 F0 0F BEQ $B2F9 ; /
$03:B2EA B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:B2EC 49 FF EOR.B #$FF ; |
$03:B2EE 1A INC A ; } Hit a wall: X speed = -X speed
$03:B2EF 95 B6 STA RAM_SpriteSpeedX,X ; /
$03:B2F1 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:B2F4 49 01 EOR.B #$01 ; } Flip facing direction
$03:B2F6 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:B2F9 FE 70 15 INC.W $1570,X ; Walk animation counter [$1570]++
$03:B2FC BD 70 15 LDA.W $1570,X ; \
$03:B2FF 29 0C AND.B #$0C ; |
$03:B301 4A LSR ; } Frame = ([$1570] & $0C) >> 2: walk frames 0-3
$03:B302 4A LSR ; /
$03:B303 9D 02 16 STA.W $1602,X ; Store animation frame
$03:B306 60 RTS ; Return
$03:B307 8B PHB ; \
$03:B308 4B PHK ; } Wrapper: data bank = program bank
$03:B309 AB PLB ; /
$03:B30A 20 55 B3 JSR.W MechaKoopaGfx ; Draw the Mechakoopa
$03:B30D AB PLB ; Restore data bank
$03:B30E 6B RTL ; Return long
;;; $B30F: Table: Mechakoopa tile X offsets (MechakoopaDispX) ;;;
$03:B30F .db $F8,$08,$F8,$00,$08,$00,$10,$00 ; X offsets: 4 tiles per frame x 2 directions
;;; $B317: Table: Mechakoopa tile Y offsets (MechakoopaDispY) ;;;
$03:B317 .db $F8,$F8,$08,$00,$F9,$F9,$09,$00 ; Y offsets: 4 tiles per frame; frames 0-3 walk, 4/5 stunned
$03:B31F .db $F8,$F8,$08,$00,$F9,$F9,$09,$00 ; Frames 2-3
$03:B327 .db $FD,$00,$05,$00,$00,$00,$08,$00 ; Frames 4-5 (stunned)
;;; $B32F: Table: Mechakoopa tile numbers (MechakoopaTiles) ;;;
$03:B32F .db $40,$42,$60,$51,$40,$42,$60,$0A ; Tile numbers: frames 0-1
$03:B337 .db $40,$42,$60,$0C,$40,$42,$60,$0E ; Frames 2-3
$03:B33F .db $00,$02,$10,$01,$00,$02,$10,$01 ; Frames 4-5 (stunned)
;;; $B347: Table: Mechakoopa tile properties (MechakoopaGfxProp) ;;;
$03:B347 .db $00,$00,$00,$00,$40,$40,$40,$40 ; YXPPCCCT flips: $00 facing one way, $40 mirrored
;;; $B34F: Table: Mechakoopa tile sizes (MechakoopaTileSize) ;;;
$03:B34F .db $02,$00,$00,$02 ; Tile sizes: head/body 16x16 ($02), key parts 8x8 ($00)
;;; $B353: Table: Mechakoopa stun flash palettes (MechakoopaPalette) ;;;
$03:B353 .db $0B,$05 ; Palette values for the stun flash: $0B, $05
;;; $B355: Mechakoopa graphics routine (MechaKoopaGfx) ;;;
;; Draws the 4-tile Mechakoopa body (frame [$1602], mirrored by direction) and then its wind-up key. While
;; [$1540] is non-zero
;; it shows the stunned frames 4/5 and, for the last $30 frames, flashes the palette between $0B and $05.
;; Called by:
;; $03:B30A: Mechakoopa main (MechaKoopa)
$03:B355 A9 0B LDA.B #$0B ; A = $0B: default palette
$03:B357 9D F6 15 STA.W RAM_SpritePal,X ; Set sprite palette
$03:B35A BD 40 15 LDA.W $1540,X ; \
$03:B35D F0 20 BEQ $B37F ; / Stun timer [$1540] = 0: draw normally
$03:B35F A0 05 LDY.B #$05 ; Y = frame 5 (stunned)
$03:B361 C9 05 CMP.B #$05 ; \
$03:B363 90 04 BCC $B369 ; / Timer < 5: use frame 4
$03:B365 C9 FA CMP.B #$FA ; \
$03:B367 90 02 BCC $B36B ; / Timer < $FA: keep frame 5
$03:B369 A0 04 LDY.B #$04 ; Y = frame 4
$03:B36B 98 TYA ; \
$03:B36C 9D 02 16 STA.W $1602,X ; / Stunned frame = Y
$03:B36F BD 40 15 LDA.W $1540,X ; \
$03:B372 C9 30 CMP.B #$30 ; } Timer >= $30: no flashing
$03:B374 B0 09 BCS $B37F ; /
$03:B376 29 01 AND.B #$01 ; \
$03:B378 A8 TAY ; |
$03:B379 B9 53 B3 LDA.W MechakoopaPalette,Y ; } Last 48 frames: flash palette (alternates $0B/$05)
$03:B37C 9D F6 15 STA.W RAM_SpritePal,X ; /
$03:B37F 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw info: $00/$01 = screen X/Y
$03:B382 BD F6 15 LDA.W RAM_SpritePal,X ; \
$03:B385 85 04 STA $04 ; / $04 = palette bits
$03:B387 98 TYA ; \
$03:B388 18 CLC ; |
$03:B389 69 0C ADC.B #$0C ; } OAM index += $0C: draw the 4 tiles from the last slot
$03:B38B A8 TAY ; /
$03:B38C BD 02 16 LDA.W $1602,X ; \
$03:B38F 0A ASL ; |
$03:B390 0A ASL ; } $03 = frame * 4: offset into tile tables
$03:B391 85 03 STA $03 ; /
$03:B393 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:B396 0A ASL ; |
$03:B397 0A ASL ; |
$03:B398 49 04 EOR.B #$04 ; } $02 = (direction * 4) EOR 4: offset into the X/flip tables
$03:B39A 85 02 STA $02 ; /
$03:B39C DA PHX ; Save sprite index
$03:B39D A2 03 LDX.B #$03 ; X = 3: 4 tiles
$03:B39F DA PHX ; Save tile index
$03:B3A0 5A PHY ; Save OAM index
$03:B3A1 98 TYA ; \
$03:B3A2 4A LSR ; |
$03:B3A3 4A LSR ; } Y = OAM index / 4
$03:B3A4 A8 TAY ; /
$03:B3A5 BD 4F B3 LDA.W MechakoopaTileSize,X ; Tile size from table
$03:B3A8 99 60 04 STA.W OAM_TileSize,Y ; Store OAM size
$03:B3AB 7A PLY ; Restore OAM index
$03:B3AC 68 PLA ; A = tile index
$03:B3AD 48 PHA ; Keep it on the stack
$03:B3AE 18 CLC ; \
$03:B3AF 65 02 ADC $02 ; } X = tile index + direction offset
$03:B3B1 AA TAX ; /
$03:B3B2 A5 00 LDA $00 ; \
$03:B3B4 18 CLC ; } Tile X = sprite X + X offset
$03:B3B5 7D 0F B3 ADC.W MechakoopaDispX,X ; /
$03:B3B8 99 00 03 STA.W OAM_DispX,Y ; Store OAM X
$03:B3BB BD 47 B3 LDA.W MechakoopaGfxProp,X ; \
$03:B3BE 05 04 ORA $04 ; } Properties | palette | priority bits [$64]
$03:B3C0 05 64 ORA $64 ; /
$03:B3C2 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:B3C5 68 PLA ; A = tile index
$03:B3C6 48 PHA ; Keep it
$03:B3C7 18 CLC ; \
$03:B3C8 65 03 ADC $03 ; } X = tile index + frame offset
$03:B3CA AA TAX ; /
$03:B3CB BD 2F B3 LDA.W MechakoopaTiles,X ; Tile number from table
$03:B3CE 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:B3D1 A5 01 LDA $01 ; \
$03:B3D3 18 CLC ; } Tile Y = sprite Y + Y offset
$03:B3D4 7D 17 B3 ADC.W MechakoopaDispY,X ; /
$03:B3D7 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:B3DA FA PLX ; Restore tile index
$03:B3DB 88 DEY ; \
$03:B3DC 88 DEY ; |
$03:B3DD 88 DEY ; } OAM index -= 4
$03:B3DE 88 DEY ; /
$03:B3DF CA DEX ; Next tile
$03:B3E0 10 BD BPL $B39F ; Loop for all 4 tiles
$03:B3E2 FA PLX ; Restore sprite index
$03:B3E3 A0 FF LDY.B #$FF ; Y = $FF: tile sizes already set
$03:B3E5 A9 03 LDA.B #$03 ; A = 3: 4 tiles
$03:B3E7 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:B3EB 20 F7 B3 JSR.W MechaKoopaKeyGfx ; Draw the wind-up key on its back
$03:B3EE 60 RTS ; Return
;;; $B3EF: Table: Mechakoopa key X offsets (MechaKeyDispX) ;;;
$03:B3EF .db $F9,$0F ; Key X offsets by direction
;;; $B3F1: Table: Mechakoopa key properties (MechaKeyGfxProp) ;;;
$03:B3F1 .db $4D,$0D ; Key properties by direction
;;; $B3F3: Table: Mechakoopa key tiles (MechaKeyTiles) ;;;
$03:B3F3 .db $70,$71,$72,$71 ; Key tiles for the 4 rotation frames
;;; $B3F7: Mechakoopa key graphics (MechaKoopaKeyGfx) ;;;
;; Draws the rotating wind-up key on its back as one 8x8 tile in the OAM slot after the body.
;; Called by:
;; $03:B3EB: Mechakoopa graphics routine (MechaKoopaGfx)
$03:B3F7 BD EA 15 LDA.W RAM_SprOAMIndex,X ; \
$03:B3FA 18 CLC ; |
$03:B3FB 69 10 ADC.B #$10 ; } OAM index += $10: key uses the next slot
$03:B3FD 9D EA 15 STA.W RAM_SprOAMIndex,X ; /
$03:B400 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw info
$03:B403 DA PHX ; Save sprite index
$03:B404 BD 70 15 LDA.W $1570,X ; \
$03:B407 4A LSR ; |
$03:B408 4A LSR ; |
$03:B409 29 03 AND.B #$03 ; } $02 = ([$1570] >> 2) & 3: key rotation frame
$03:B40B 85 02 STA $02 ; /
$03:B40D BD 7C 15 LDA.W RAM_SpriteDir,X ; A = facing direction
$03:B410 AA TAX ; X = direction
$03:B411 A5 00 LDA $00 ; \
$03:B413 18 CLC ; } Key X = sprite X + offset
$03:B414 7D EF B3 ADC.W MechaKeyDispX,X ; /
$03:B417 99 00 03 STA.W OAM_DispX,Y ; Store OAM X
$03:B41A A5 01 LDA $01 ; \
$03:B41C 38 SEC ; } Key Y = sprite Y (no offset)
$03:B41D E9 00 SBC.B #$00 ; /
$03:B41F 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:B422 BD F1 B3 LDA.W MechaKeyGfxProp,X ; \
$03:B425 05 64 ORA $64 ; / Properties | priority bits [$64]
$03:B427 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:B42A A6 02 LDX $02 ; X = key frame
$03:B42C BD F3 B3 LDA.W MechaKeyTiles,X ; Key tile from table
$03:B42F 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:B432 FA PLX ; Restore sprite index
$03:B433 A0 00 LDY.B #$00 ; Y = 0: 8x8 tile
$03:B435 A9 00 LDA.B #$00 ; A = 0: one tile
$03:B437 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish OAM write
$03:B43B 60 RTS ; Return
$03:B43C 20 4F B4 JSR.W BowserItemBoxGfx ; Draw the Bowser scene: item box
$03:B43F 20 AC B4 JSR.W BowserSceneGfx ; Draw the Bowser scene: background pieces
$03:B442 60 RTS ; Return
;;; $B443: Table: Bowser scene item box X (BowserItemBoxPosX) ;;;
$03:B443 .db $70,$80,$70,$80 ; Item box X positions of the 4 corners
;;; $B447: Table: Bowser scene item box Y (BowserItemBoxPosY) ;;;
$03:B447 .db $07,$07,$17,$17 ; Item box Y positions
;;; $B44B: Table: Bowser scene item box properties (BowserItemBoxProp) ;;;
$03:B44B .db $37,$77,$B7,$F7 ; Item box properties (flip bits make the 4 corners)
;;; $B44F: Bowser scene: draw item box (BowserItemBoxGfx) ;;;
;; Draws the reserve item box at the top of the screen as four 16x16 corner tiles ($43, flipped). Hidden when
;; [$190D] is non-zero
;; (it also clears [$0DC2], the reserve item).
;; $B43C (just above) calls this and BowserSceneGfx.
;; Called by:
;; $03:B43C: Mechakoopa key graphics (MechaKoopaKeyGfx)
$03:B44F AD 0D 19 LDA.W $190D ; \
$03:B452 F0 03 BEQ $B457 ; / Bowser fight stage [$190D] = 0?
$03:B454 9C C2 0D STZ.W $0DC2 ; Stage non-zero: hide the item box ($0DC2 = 0)
$03:B457 AD C2 0D LDA.W $0DC2 ; \
$03:B45A F0 2F BEQ $B48B ; / No reserve item: return
$03:B45C DA PHX ; Save sprite index
$03:B45D A2 03 LDX.B #$03 ; X = 3: 4 corners
$03:B45F A0 04 LDY.B #$04 ; Y = $04: OAM index (extended slot)
$03:B461 BD 43 B4 LDA.W BowserItemBoxPosX,X ; \
$03:B464 99 00 02 STA.W OAM_ExtendedDispX,Y ; / OAM X = corner X
$03:B467 BD 47 B4 LDA.W BowserItemBoxPosY,X ; \
$03:B46A 99 01 02 STA.W OAM_ExtendedDispY,Y ; / OAM Y = corner Y
$03:B46D A9 43 LDA.B #$43 ; \
$03:B46F 99 02 02 STA.W OAM_ExtendedTile,Y ; / OAM tile = $43 (item box corner)
$03:B472 BD 4B B4 LDA.W BowserItemBoxProp,X ; \
$03:B475 99 03 02 STA.W OAM_ExtendedProp,Y ; / OAM properties from table
$03:B478 5A PHY ; Save OAM index
$03:B479 98 TYA ; \
$03:B47A 4A LSR ; |
$03:B47B 4A LSR ; } Y = OAM index / 4
$03:B47C A8 TAY ; /
$03:B47D A9 02 LDA.B #$02 ; \
$03:B47F 99 20 04 STA.W $0420,Y ; / Size = 16x16 (written to $0420 table)
$03:B482 7A PLY ; Restore OAM index
$03:B483 C8 INY ; \
$03:B484 C8 INY ; |
$03:B485 C8 INY ; } OAM index += 4
$03:B486 C8 INY ; /
$03:B487 CA DEX ; Next corner
$03:B488 10 D7 BPL $B461 ; Loop for all 4 corners
$03:B48A FA PLX ; Restore sprite index
$03:B48B 60 RTS ; Return
;;; $B48C: Table: Bowser scene roof tile X (BowserRoofPosX) ;;;
$03:B48C .db $00,$30,$60,$90,$C0,$F0,$00,$30 ; Roof piece X positions (16 pieces)
$03:B494 .db $40,$50,$60,$90,$A0,$B0,$C0,$F0 ; Second half
;;; $B49C: Table: Bowser scene roof tile Y (BowserRoofPosY) ;;;
$03:B49C .db $B0,$B0,$B0,$B0,$B0,$B0,$D0,$D0 ; Roof piece Y positions
$03:B4A4 .db $D0,$D0,$D0,$D0,$D0,$D0,$D0,$D0 ; Second half
;;; $B4AC: Bowser scene: draw floor and roof (BowserSceneGfx) ;;;
;; Draws the Bowser fight room backdrop with sprites: a row of floor tiles at Y = $C0 and 16 roof/battlement
;; tiles from the tables,
;; positioned relative to the screen scroll. [$190D] (fight phase) selects which OAM area is used (stage 0:
;; $BC/$14, otherwise $90/$50).
;; Called by:
;; $03:B43F: Mechakoopa key graphics (MechaKoopaKeyGfx)
$03:B4AC DA PHX ; Save sprite index
$03:B4AD A0 BC LDY.B #$BC ; Y = $BC: OAM index of the first piece (stage 0)
$03:B4AF 64 01 STZ $01 ; $01 = 0: running X
$03:B4B1 AD 0D 19 LDA.W $190D ; \
$03:B4B4 85 0F STA $0F ; / $0F = Bowser fight stage [$190D]
$03:B4B6 C9 01 CMP.B #$01 ; \
$03:B4B8 A2 10 LDX.B #$10 ; / X = $10: 17 floor tiles
$03:B4BA 90 03 BCC $B4BF ; Stage 0: keep Y = $BC
$03:B4BC A0 90 LDY.B #$90 ; Stage >= 1: Y = $90 (other OAM slots)
$03:B4BE CA DEX ; X = $0F: 16 floor tiles
$03:B4BF A9 C0 LDA.B #$C0 ; \
$03:B4C1 38 SEC ; } Y = $C0 - screen Y: floor row
$03:B4C2 E5 1C SBC RAM_ScreenBndryYLo ; /
$03:B4C4 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:B4C7 A5 01 LDA $01 ; \
$03:B4C9 38 SEC ; } X = running X - screen X
$03:B4CA E5 1A SBC RAM_ScreenBndryXLo ; /
$03:B4CC 99 00 03 STA.W OAM_DispX,Y ; Store OAM X
$03:B4CF 18 CLC ; \
$03:B4D0 69 10 ADC.B #$10 ; } Running X += $10: next tile
$03:B4D2 85 01 STA $01 ; /
$03:B4D4 A9 08 LDA.B #$08 ; \
$03:B4D6 99 02 03 STA.W OAM_Tile,Y ; / Tile $08
$03:B4D9 A9 0D LDA.B #$0D ; \
$03:B4DB 05 64 ORA $64 ; / Properties $0D | priority bits [$64]
$03:B4DD 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:B4E0 5A PHY ; Save OAM index
$03:B4E1 98 TYA ; \
$03:B4E2 4A LSR ; |
$03:B4E3 4A LSR ; } Y = OAM index / 4
$03:B4E4 A8 TAY ; /
$03:B4E5 A9 02 LDA.B #$02 ; \
$03:B4E7 99 60 04 STA.W OAM_TileSize,Y ; / Size = 16x16
$03:B4EA 7A PLY ; Restore OAM index
$03:B4EB C8 INY ; \
$03:B4EC C8 INY ; |
$03:B4ED C8 INY ; } OAM index += 4
$03:B4EE C8 INY ; /
$03:B4EF CA DEX ; Next tile
$03:B4F0 10 CD BPL $B4BF ; Loop for the floor row
$03:B4F2 A2 0F LDX.B #$0F ; X = $0F: 16 roof pieces
$03:B4F4 A5 0F LDA $0F ; \
$03:B4F6 D0 3A BNE $B532 ; / Stage non-zero: use the other OAM area ($B532)
$03:B4F8 A0 14 LDY.B #$14 ; Y = $14: extended OAM slot for stage 0
$03:B4FA BD 8C B4 LDA.W BowserRoofPosX,X ; \
$03:B4FD 38 SEC ; } X = piece X - screen X
$03:B4FE E5 1A SBC RAM_ScreenBndryXLo ; /
$03:B500 99 00 02 STA.W OAM_ExtendedDispX,Y ; Store OAM X
$03:B503 BD 9C B4 LDA.W BowserRoofPosY,X ; \
$03:B506 38 SEC ; } Y = piece Y - screen Y
$03:B507 E5 1C SBC RAM_ScreenBndryYLo ; /
$03:B509 99 01 02 STA.W OAM_ExtendedDispY,Y ; Store OAM Y
$03:B50C A9 08 LDA.B #$08 ; \
$03:B50E E0 06 CPX.B #$06 ; } Tile $08, but $03 for pieces 0-5
$03:B510 B0 02 BCS $B514 ; /
$03:B512 A9 03 LDA.B #$03 ; Tile $03
$03:B514 99 02 02 STA.W OAM_ExtendedTile,Y ; Store OAM tile
$03:B517 A9 0D LDA.B #$0D ; \
$03:B519 05 64 ORA $64 ; / Properties $0D | priority bits [$64]
$03:B51B 99 03 02 STA.W OAM_ExtendedProp,Y ; Store OAM properties
$03:B51E 5A PHY ; Save OAM index
$03:B51F 98 TYA ; \
$03:B520 4A LSR ; |
$03:B521 4A LSR ; } Y = OAM index / 4
$03:B522 A8 TAY ; /
$03:B523 A9 02 LDA.B #$02 ; \
$03:B525 99 20 04 STA.W $0420,Y ; / Size = 16x16
$03:B528 7A PLY ; Restore OAM index
$03:B529 C8 INY ; \
$03:B52A C8 INY ; |
$03:B52B C8 INY ; } OAM index += 4
$03:B52C C8 INY ; /
$03:B52D CA DEX ; Next piece
$03:B52E 10 CA BPL $B4FA ; Loop for all 16 pieces
$03:B530 80 38 BRA $B56A ; Done
$03:B532 A0 50 LDY.B #$50 ; Y = $50: OAM index for stage >= 1
$03:B534 BD 8C B4 LDA.W BowserRoofPosX,X ; \
$03:B537 38 SEC ; } X = piece X - screen X
$03:B538 E5 1A SBC RAM_ScreenBndryXLo ; /
$03:B53A 99 00 03 STA.W OAM_DispX,Y ; Store OAM X
$03:B53D BD 9C B4 LDA.W BowserRoofPosY,X ; \
$03:B540 38 SEC ; } Y = piece Y - screen Y
$03:B541 E5 1C SBC RAM_ScreenBndryYLo ; /
$03:B543 99 01 03 STA.W OAM_DispY,Y ; Store OAM Y
$03:B546 A9 08 LDA.B #$08 ; \
$03:B548 E0 06 CPX.B #$06 ; } Tile $08, but $03 for pieces 0-5
$03:B54A B0 02 BCS $B54E ; /
$03:B54C A9 03 LDA.B #$03 ; Tile $03
$03:B54E 99 02 03 STA.W OAM_Tile,Y ; Store OAM tile
$03:B551 A9 0D LDA.B #$0D ; \
$03:B553 05 64 ORA $64 ; / Properties $0D | priority bits [$64]
$03:B555 99 03 03 STA.W OAM_Prop,Y ; Store OAM properties
$03:B558 5A PHY ; Save OAM index
$03:B559 98 TYA ; \
$03:B55A 4A LSR ; |
$03:B55B 4A LSR ; } Y = OAM index / 4
$03:B55C A8 TAY ; /
$03:B55D A9 02 LDA.B #$02 ; \
$03:B55F 99 60 04 STA.W OAM_TileSize,Y ; / Size = 16x16
$03:B562 7A PLY ; Restore OAM index
$03:B563 C8 INY ; \
$03:B564 C8 INY ; |
$03:B565 C8 INY ; } OAM index += 4
$03:B566 C8 INY ; /
$03:B567 CA DEX ; Next piece
$03:B568 10 CA BPL $B534 ; Loop for all 16 pieces
$03:B56A FA PLX ; Restore sprite index
$03:B56B 60 RTS ; Return
;;; $B56C: Table: sprite hitbox X offsets (SprClippingDispX) ;;;
;; Indexed by [$1662] & $3F.
$03:B56C .db $02,$02,$10,$14,$00,$00,$01,$08 ; Sprite hitbox X offset, indexed by clipping index [$1662] & $3F (00-07)
$03:B574 .db $F8,$FE,$03,$06,$01,$00,$06,$02 ; 08-0F
$03:B57C .db $00,$E8,$FC,$FC,$04,$00,$FC,$02 ; 10-17
$03:B584 .db $02,$02,$02,$02,$00,$02,$E0,$F0 ; 18-1F
$03:B58C .db $FC,$FC,$00,$F8,$F4,$F2,$00,$FC ; 20-27
$03:B594 .db $F2,$F0,$02,$00,$F8,$04,$02,$02 ; 28-2F
$03:B59C .db $08,$00,$00,$00,$FC,$03,$08,$00 ; 30-37
$03:B5A4 .db $08,$04,$F8,$00 ; 38-3B
;;; $B5A8: Table: sprite hitbox widths (SprClippingWidth) ;;;
$03:B5A8 .db $0C,$0C,$10,$08,$30,$50,$0E,$28 ; Sprite hitbox width (00-07)
$03:B5B0 .db $20,$14,$01,$03,$0D,$0F,$14,$24 ; 08-0F
$03:B5B8 .db $0F,$40,$08,$08,$18,$0F,$18,$0C ; 10-17
$03:B5C0 .db $0C,$0C,$0C,$0C,$0A,$1C,$30,$30 ; 18-1F
$03:B5C8 .db $08,$08,$10,$20,$38,$3C,$20,$18 ; 20-27
$03:B5D0 .db $1C,$20,$0C,$10,$10,$08,$1C,$1C ; 28-2F
$03:B5D8 .db $10,$30,$30,$40,$08,$12,$34,$0F ; 30-37
$03:B5E0 .db $20,$08,$20,$10 ; 38-3B
;;; $B5E4: Table: sprite hitbox Y offsets (SprClippingDispY) ;;;
$03:B5E4 .db $03,$03,$FE,$08,$FE,$FE,$02,$08 ; Sprite hitbox Y offset (00-07)
$03:B5EC .db $FE,$08,$07,$06,$FE,$FC,$06,$FE ; 08-0F
$03:B5F4 .db $FE,$E8,$10,$10,$02,$FE,$F4,$08 ; 10-17
$03:B5FC .db $13,$23,$33,$43,$0A,$FD,$F8,$FC ; 18-1F
$03:B604 .db $E8,$10,$00,$E8,$20,$04,$58,$FC ; 20-27
$03:B60C .db $E8,$FC,$F8,$02,$F8,$04,$FE,$FE ; 28-2F
$03:B614 .db $F2,$FE,$FE,$FE,$FC,$00,$08,$F8 ; 30-37
$03:B61C .db $10,$03,$10,$00 ; 38-3B
;;; $B620: Table: sprite hitbox heights (SprClippingHeight) ;;;
$03:B620 .db $0A,$15,$12,$08,$0E,$0E,$18,$30 ; Sprite hitbox height (00-07)
$03:B628 .db $10,$1E,$02,$03,$16,$10,$14,$12 ; 08-0F
$03:B630 .db $20,$40,$34,$74,$0C,$0E,$18,$45 ; 10-17
$03:B638 .db $3A,$2A,$1A,$0A,$30,$1B,$20,$12 ; 18-1F
$03:B640 .db $18,$18,$10,$20,$38,$14,$08,$18 ; 20-27
$03:B648 .db $28,$1B,$13,$4C,$10,$04,$22,$20 ; 28-2F
$03:B650 .db $1C,$12,$12,$12,$08,$20,$2E,$14 ; 30-37
$03:B658 .db $28,$0A,$10,$0D ; 38-3B
;;; $B65C: Table: Mario hitbox Y offsets (MairoClipDispY) ;;;
$03:B65C .db $06,$14,$10,$18 ; Mario hitbox Y offset: 0 big, 1 small/ducking, 2 big on Yoshi, 3 small on Yoshi
;;; $B660: Table: Mario hitbox heights (MarioClippingHeight) ;;;
$03:B660 .db $1A,$0C,$20,$18 ; Mario hitbox height, same indices: $1A, $0C, $20, $18
;;; $B664: Get Mario hitbox (GetMarioClipping) ;;;
;; Builds Mario's hitbox in the "B" slot used by CheckForContact: X = Mario X + 2, width $0C, Y = Mario Y +
;; offset, height by
;; form (big, small/ducking, on Yoshi). Returns: $00/$08 X, $01/$09 Y (low/high), $02 width, $03 height.
;; Called by:
;; $01:A824: Test Mario against sprite (ProcessInteract)
;; $01:B933: Finish OAM write and solid-sprite helpers (FinishOAMWriteRt)
;; $01:CAC2: Platform: Mario interaction and geometry helpers
;; $01:D2BD: Koopa Kid boss: landing, stomp, fireballs
;; $01:E1ED: Keyhole main (Keyhole)
;; $01:ED2E: Yoshi physics, mounting and dismount
;; $02:8CEC: Minor extended sprite 0A: Boo stream (BooStreamTiles)
;; $02:A3FE: Extended sprite: smoke puff, contact with Mario (SmokePuff)
;; $02:F9E6: Sumo Bro flame: contact with Mario
;; $03:911F: Fishin' Boo hook contact check
;; $03:9D8A: Dino-Torch breathing flame (state 1/2) (DinoFlameTimerSet)
;; $03:ADD0: Pointer table: Peach states, state 0-1 (PeachPtrs)
$03:B664 DA PHX ; Save sprite index
$03:B665 A5 94 LDA RAM_MarioXPos ; \
$03:B667 18 CLC ; |
$03:B668 69 02 ADC.B #$02 ; } $00 = Mario X + 2 (low byte): hitbox X
$03:B66A 85 00 STA $00 ; /
$03:B66C A5 95 LDA RAM_MarioXPosHi ; \
$03:B66E 69 00 ADC.B #$00 ; } $08 = Mario X high byte (+ carry)
$03:B670 85 08 STA $08 ; /
$03:B672 A9 0C LDA.B #$0C ; \
$03:B674 85 02 STA $02 ; / $02 = hitbox width $0C
$03:B676 A2 00 LDX.B #$00 ; X = 0: big Mario
$03:B678 A5 73 LDA RAM_IsDucking ; \
$03:B67A D0 04 BNE $B680 ; / Ducking: X = 1
$03:B67C A5 19 LDA RAM_MarioPowerUp ; \
$03:B67E D0 01 BNE $B681 ; / Powerup non-zero (not small): keep X = 0
$03:B680 E8 INX ; Small or ducking: X = 1
$03:B681 AD 7A 18 LDA.W RAM_OnYoshi ; \
$03:B684 F0 02 BEQ $B688 ; / Not on Yoshi: skip
$03:B686 E8 INX ; \
$03:B687 E8 INX ; / On Yoshi: X += 2
$03:B688 BF 60 B6 03 LDA.L MarioClippingHeight,X ; \
$03:B68C 85 03 STA $03 ; / $03 = hitbox height from table
$03:B68E A5 96 LDA RAM_MarioYPos ; \
$03:B690 18 CLC ; |
$03:B691 7F 5C B6 03 ADC.L MairoClipDispY,X ; } $01 = Mario Y + Y offset (low byte)
$03:B695 85 01 STA $01 ; /
$03:B697 A5 97 LDA RAM_MarioYPosHi ; \
$03:B699 69 00 ADC.B #$00 ; } $09 = Mario Y high byte (+ carry)
$03:B69B 85 09 STA $09 ; /
$03:B69D FA PLX ; Restore sprite index
$03:B69E 6B RTL ; Return long
;;; $B69F: Get sprite hitbox into slot A (GetSpriteClippingA) ;;;
;; Builds the hitbox of sprite X from the clipping tables ([$1662] & $3F) with sign-extended offsets.
;; Parameters: X = sprite index. Returns: $04/$0A X, $05/$0B Y (low/high), $06 width, $07 height. X and Y
;; preserved.
;; Called by:
;; $01:88CD: Check shell proximity and jump (HandleJumpOver)
;; $01:8AB8: Shelless Koopa logic, part 2 (NOTE)
;; $01:A828: Test Mario against sprite (ProcessInteract)
;; $01:BAFD: Climbing net door main (ClimbingDoor)
;; $01:E201: Keyhole main (Keyhole)
;; $01:F590: Check tongue contact with sprite (TryEatSprite)
;; $01:F66F: Yoshi vs. other sprites contact
;; $02:8157: Explosion: kill sprite on contact (ExplodeKillSpr)
;; $02:93DE: Bounce block and cape hit sprites
;; $02:A0D4: Fireball vs. sprite loop (FireRtLoopStart)
;; $02:B7C7: Pokey: behaviour and drawing (PokeyAlive)
;; $02:E61F: Moving ledge (hole) sprite main (MovingLedgeMain)
;; ... and 6 more
$03:B69F 5A PHY ; Save Y
$03:B6A0 DA PHX ; Save X
$03:B6A1 9B TXY ; Y = sprite index
$03:B6A2 BD 62 16 LDA.W RAM_Tweaker1662,X ; \
$03:B6A5 29 3F AND.B #$3F ; } X = clipping index [$1662] & $3F
$03:B6A7 AA TAX ; /
$03:B6A8 64 0F STZ $0F ; $0F = 0 (X displacement high byte)
$03:B6AA BF 6C B5 03 LDA.L SprClippingDispX,X ; Load X displacement
$03:B6AE 10 02 BPL $B6B2 ; Positive: skip sign extension
$03:B6B0 C6 0F DEC $0F ; Negative: $0F = $FF (sign extend)
$03:B6B2 18 CLC ; \
$03:B6B3 79 E4 00 ADC.W RAM_SpriteXLo,Y ; } $04 = sprite X + displacement (low byte)
$03:B6B6 85 04 STA $04 ; /
$03:B6B8 B9 E0 14 LDA.W RAM_SpriteXHi,Y ; \
$03:B6BB 65 0F ADC $0F ; } $0A = sprite X high byte + sign extension
$03:B6BD 85 0A STA $0A ; /
$03:B6BF BF A8 B5 03 LDA.L SprClippingWidth,X ; \
$03:B6C3 85 06 STA $06 ; / $06 = hitbox width
$03:B6C5 64 0F STZ $0F ; $0F = 0 (Y displacement high byte)
$03:B6C7 BF E4 B5 03 LDA.L SprClippingDispY,X ; Load Y displacement
$03:B6CB 10 02 BPL $B6CF ; Positive: skip sign extension
$03:B6CD C6 0F DEC $0F ; Negative: $0F = $FF (sign extend)
$03:B6CF 18 CLC ; \
$03:B6D0 79 D8 00 ADC.W RAM_SpriteYLo,Y ; } $05 = sprite Y + displacement (low byte)
$03:B6D3 85 05 STA $05 ; /
$03:B6D5 B9 D4 14 LDA.W RAM_SpriteYHi,Y ; \
$03:B6D8 65 0F ADC $0F ; } $0B = sprite Y high byte + sign extension
$03:B6DA 85 0B STA $0B ; /
$03:B6DC BF 20 B6 03 LDA.L SprClippingHeight,X ; \
$03:B6E0 85 07 STA $07 ; / $07 = hitbox height
$03:B6E2 FA PLX ; Restore sprite index
$03:B6E3 7A PLY ; Restore Y
$03:B6E4 6B RTL ; Return long
;;; $B6E5: Get sprite hitbox into slot B (GetSpriteClippingB) ;;;
;; Same as GetSpriteClippingA but writes $00/$08 X, $01/$09 Y, $02 width, $03 height.
;; Called by:
;; $01:8ABE: Shelless Koopa logic, part 2 (NOTE)
;; $01:E1FC: Keyhole main (Keyhole)
;; $01:F66A: Yoshi vs. other sprites contact
;; $02:8152: Explosion: kill sprite on contact (ExplodeKillSpr)
;; $02:B7C2: Pokey: behaviour and drawing (PokeyAlive)
;; $02:E618: Moving ledge (hole) sprite main (MovingLedgeMain)
;; $02:EA8C: Pipe Lakitu tiles, Baby Yoshi helpers (PipeLakitu2)
;; $03:81F7: Big Boo boss: remaining states and helpers
;; $03:B0F5: Bowser Mario and Mecha-Koopa contact
$03:B6E5 5A PHY ; Save Y
$03:B6E6 DA PHX ; Save X
$03:B6E7 9B TXY ; Y = sprite index
$03:B6E8 BD 62 16 LDA.W RAM_Tweaker1662,X ; \
$03:B6EB 29 3F AND.B #$3F ; } X = clipping index [$1662] & $3F
$03:B6ED AA TAX ; /
$03:B6EE 64 0F STZ $0F ; $0F = 0 (X displacement high byte)
$03:B6F0 BF 6C B5 03 LDA.L SprClippingDispX,X ; Load X displacement
$03:B6F4 10 02 BPL $B6F8 ; Positive: skip sign extension
$03:B6F6 C6 0F DEC $0F ; Negative: $0F = $FF (sign extend)
$03:B6F8 18 CLC ; \
$03:B6F9 79 E4 00 ADC.W RAM_SpriteXLo,Y ; } $00 = sprite X + displacement (low byte)
$03:B6FC 85 00 STA $00 ; /
$03:B6FE B9 E0 14 LDA.W RAM_SpriteXHi,Y ; \
$03:B701 65 0F ADC $0F ; } $08 = sprite X high byte + sign extension
$03:B703 85 08 STA $08 ; /
$03:B705 BF A8 B5 03 LDA.L SprClippingWidth,X ; \
$03:B709 85 02 STA $02 ; / $02 = hitbox width
$03:B70B 64 0F STZ $0F ; $0F = 0 (Y displacement high byte)
$03:B70D BF E4 B5 03 LDA.L SprClippingDispY,X ; Load Y displacement
$03:B711 10 02 BPL $B715 ; Positive: skip sign extension
$03:B713 C6 0F DEC $0F ; Negative: $0F = $FF (sign extend)
$03:B715 18 CLC ; \
$03:B716 79 D8 00 ADC.W RAM_SpriteYLo,Y ; } $01 = sprite Y + displacement (low byte)
$03:B719 85 01 STA $01 ; /
$03:B71B B9 D4 14 LDA.W RAM_SpriteYHi,Y ; \
$03:B71E 65 0F ADC $0F ; } $09 = sprite Y high byte + sign extension
$03:B720 85 09 STA $09 ; /
$03:B722 BF 20 B6 03 LDA.L SprClippingHeight,X ; \
$03:B726 85 03 STA $03 ; / $03 = hitbox height
$03:B728 FA PLX ; Restore sprite index
$03:B729 7A PLY ; Restore Y
$03:B72A 6B RTL ; Return long
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;This subroutine checks if the two hitboxes of A and B to see if they are in contact.
;Carry is set if true, else false.
;Syntax:
; $00 = X low byte position/displacement B
; $01 = Y low byte position/displacement B
; $02 = Hitbox width (8-bit) B
; $03 = Hitbox height (8-bit) B
; $04 = X low byte position/displacement A
; $05 = Y low byte position/displacement A
; $06 = Hitbox width (8-bit) A
; $07 = Hitbox height (8-bit) A
; $08 = X high byte position/displacement B
; $09 = Y high byte position/displacement B
; $0A = X high byte position/displacement A
; $0B = Y high byte position/displacement A
;Destroyed values:
; $0C = used as part of the high byte to check if they are too far
; $0F = used as the furthest distance to check if the hitboxes are at least edge
; to edge on contact.
;-------------------------------------------------------------------------------------
;Functionality explanation:
;(1) The first thing it does is that it handles the high byte position of the
; hitboxes. It checks if the distance is too far (high byte would increment during
; calculation if it was too far at $03B740).
;
;(2) The second thing while within the #$0100 range is checking the distance between
; two edges of each boxes. During calculation at $03B746, it subtracts to find the
; distance between two boxes' top/lefts:
;
; If the subtraction result was negative (B is right/down of A), it adds by A's
; size (width/height) to get the "negative distance" of the gap space itself
; (distance of both boxes' size excluded).
;
; Otherwise (positive; B is left/up of A), it would get the total distance of both
; sizes, and also includes the gap in between as well.
;
;(3) The third calculates the farthest distance possible while remainding in contact
; (assuming if two boxes are edge-to-edge touching, no gaps, no overlaps), then
; compares the results with 2 using BCC (if the max distance is < distance of 2
; boxes, carry clear + end of routine. This is unsigned, by the way, so negative
; numbers also don't set the carry).
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; $B72B: Check two hitboxes for contact (CheckForContact) ;;;
;; Tests whether hitbox A ($04-$07, $0A-$0B) and hitbox B ($00-$03, $08-$09) overlap, on Y then X.
;; Returns: carry set if in contact, clear otherwise. Trashes $0C and $0F.
;; Called by:
;; $01:88D1: Check shell proximity and jump (HandleJumpOver)
;; $01:8AC3: Shelless Koopa logic, part 2 (NOTE)
;; $01:A82C: Test Mario against sprite (ProcessInteract)
;; $01:B937: Finish OAM write and solid-sprite helpers (FinishOAMWriteRt)
;; $01:BB04: Climbing net door main (ClimbingDoor)
;; $01:CAC6: Platform: Mario interaction and geometry helpers
;; $01:D2C4: Koopa Kid boss: landing, stomp, fireballs
;; $01:D3E3: Koopa Kid boss: landing, stomp, fireballs
;; $01:E205: Keyhole main (Keyhole)
;; $01:ED32: Yoshi physics, mounting and dismount
;; $01:F595: Check tongue contact with sprite (TryEatSprite)
;; $01:F673: Yoshi vs. other sprites contact
;; ... and 19 more
$03:B72B DA PHX ; Save sprite index
$03:B72C A2 01 LDX.B #$01 ; X = 1: check Y axis first, then X axis
$03:B72E B5 00 LDA $00,X ; \
$03:B730 38 SEC ; |
$03:B731 F5 04 SBC $04,X ; } Low byte of distance between hitbox origins (B - A); save it
$03:B733 48 PHA ; /
$03:B734 B5 08 LDA $08,X ; \
$03:B736 F5 0A SBC $0A,X ; } High byte of that distance -> $0C
$03:B738 85 0C STA $0C ; /
$03:B73A 68 PLA ; \
$03:B73B 18 CLC ; } Low byte + $80: rounds to nearest $100
$03:B73C 69 80 ADC.B #$80 ; /
$03:B73E A5 0C LDA $0C ; \
$03:B740 69 00 ADC.B #$00 ; / Distance high byte + carry: non-zero if boxes are $100 or more apart
$03:B742 D0 16 BNE $B75A ; Too far apart: no contact
$03:B744 B5 04 LDA $04,X ; \
$03:B746 38 SEC ; } A - B origin distance
$03:B747 F5 00 SBC $00,X ; /
$03:B749 18 CLC ; \
$03:B74A 75 06 ADC $06,X ; } $0F = A - B + size of A (0 if A's far edge touches B's origin)
$03:B74C 85 0F STA $0F ; /
$03:B74E B5 02 LDA $02,X ; \
$03:B750 18 CLC ; } A = sum of both sizes: the largest distance that still overlaps
$03:B751 75 06 ADC $06,X ; /
$03:B753 C5 0F CMP $0F ; Compare against distance
$03:B755 90 03 BCC $B75A ; Gap too large: exit with carry clear
$03:B757 CA DEX ; Next axis (Y, then X)
$03:B758 10 D4 BPL $B72E ; Loop for both axes (carry set = contact)
$03:B75A FA PLX ; Restore sprite index
$03:B75B 6B RTL ; Return long
;;; $B75C..B75E: Table: offscreen margins and flags ;;;
$03:B75C .db $0C,$1C ; Vertical offscreen margins: $0C normal, $1C for smushed sprites
$03:B75E .db $01,$02 ; Offscreen flag bits: 1 and 2
;;; $B760: Get sprite draw info (bank 3) (GetDrawInfoBnk3) ;;;
;; Common graphics prologue. Sets [RAM_OffscreenHorz]/[RAM_OffscreenVert], sets [$15C4] if far offscreen, and
;; gives screen-relative position.
;; Returns: $00/$01 = sprite X/Y relative to the screen, Y = sprite OAM index. If far offscreen it pops its
;; own return address
;; so the calling graphics routine returns without drawing.
;; Called by:
;; $03:83C2: Big Boo graphics routine, flip table (BigBooGfxProp)
;; $03:8492: Falling platform tiles and graphics routine (FallingPlatTiles)
;; $03:85A3: Porcu-Puffer graphics routine (PocruPufferGfxProp)
;; $03:86A8: Flying turn blocks graphics routine (ForestPlatTileSize)
;; $03:873A: Gray lava platform graphics (LavaPlatTiles)
;; $03:883F: Mega Mole graphics routine (MegaMoleGfxRt)
;; $03:8B3D: Bowser statue graphics routine (BowserStatueGfx)
;; $03:8D24: Carrot top lift graphics (CarrotTopLiftGfx)
;; $03:8E12: Timed lift graphics (TimedPlatformGfx)
;; $03:8EB4: Grey castle block graphics (GreyMoveBlkTiles)
;; $03:8F1B: Statue fireball graphics (StatueFireballGfx)
;; $03:9180: Fishin' Boo graphics (FishinBooGfx)
;; ... and 17 more
$03:B760 9E 6C 18 STZ.W RAM_OffscreenVert,X ; Clear vertical offscreen flag
$03:B763 9E A0 15 STZ.W RAM_OffscreenHorz,X ; Clear horizontal offscreen flag
$03:B766 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:B768 C5 1A CMP RAM_ScreenBndryXLo ; |
$03:B76A BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:B76D E5 1B SBC RAM_ScreenBndryXHi ; } Sprite X - screen X (16-bit): offscreen horizontally?
$03:B76F F0 03 BEQ $B774 ; /
$03:B771 FE A0 15 INC.W RAM_OffscreenHorz,X ; Set horizontal offscreen flag
$03:B774 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:B777 EB XBA ; } A = sprite X (16 bit, high byte in B)
$03:B778 B5 E4 LDA RAM_SpriteXLo,X ; /
$03:B77A C2 20 REP #$20 ; A 16-bit
$03:B77C 38 SEC ; \
$03:B77D E5 1A SBC RAM_ScreenBndryXLo ; |
$03:B77F 18 CLC ; } A = sprite X - screen X + $40
$03:B780 69 40 00 ADC.W #$0040 ; /
$03:B783 C9 80 01 CMP.W #$0180 ; Compare with $0180 (on screen with a margin)
$03:B786 E2 20 SEP #$20 ; A 8-bit
$03:B788 2A ROL ; \
$03:B789 29 01 AND.B #$01 ; } Carry -> [$15C4] = 1 if far offscreen
$03:B78B 9D C4 15 STA.W $15C4,X ; /
$03:B78E D0 3F BNE $B7CF ; Far offscreen: return from the caller too
$03:B790 A0 00 LDY.B #$00 ; Y = 0: check two vertical margins
$03:B792 BD 62 16 LDA.W RAM_Tweaker1662,X ; \
$03:B795 29 20 AND.B #$20 ; } Sprite smushed ([$1662] bit 5)?
$03:B797 F0 01 BEQ $B79A ; /
$03:B799 C8 INY ; Smushed: check only the second margin
$03:B79A B5 D8 LDA RAM_SpriteYLo,X ; \
$03:B79C 18 CLC ; } A = sprite Y + margin
$03:B79D 79 5C B7 ADC.W $B75C,Y ; /
$03:B7A0 08 PHP ; Save carry
$03:B7A1 C5 1C CMP RAM_ScreenBndryYLo ; Compare with screen Y
$03:B7A3 26 00 ROL $00 ; Keep the carry in $00
$03:B7A5 28 PLP ; Restore carry
$03:B7A6 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:B7A9 69 00 ADC.B #$00 ; / Sprite Y high byte + carry
$03:B7AB 46 00 LSR $00 ; \
$03:B7AD E5 1D SBC RAM_ScreenBndryYHi ; / Minus screen Y high byte and borrow
$03:B7AF F0 09 BEQ $B7BA ; On screen: skip
$03:B7B1 BD 6C 18 LDA.W RAM_OffscreenVert,X ; \
$03:B7B4 19 5E B7 ORA.W $B75E,Y ; } Set the vertical offscreen flag bit
$03:B7B7 9D 6C 18 STA.W RAM_OffscreenVert,X ; /
$03:B7BA 88 DEY ; Next margin
$03:B7BB 10 DD BPL $B79A ; Loop
$03:B7BD BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = sprite OAM index
$03:B7C0 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:B7C2 38 SEC ; |
$03:B7C3 E5 1A SBC RAM_ScreenBndryXLo ; } $00 = sprite X - screen X
$03:B7C5 85 00 STA $00 ; /
$03:B7C7 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:B7C9 38 SEC ; |
$03:B7CA E5 1C SBC RAM_ScreenBndryYLo ; } $01 = sprite Y - screen Y
$03:B7CC 85 01 STA $01 ; /
$03:B7CE 60 RTS ; Return
$03:B7CF 68 PLA ; Far offscreen: discard the return address ...
$03:B7D0 68 PLA ; ... so the caller returns too
$03:B7D1 60 RTS ; Return
;;; $B7D2..B7F2: Table: bowling ball bounce speeds ;;;
$03:B7D2 .db $00,$00,$00,$F8,$F8,$F8,$F8,$F8 ; Bounce Y speed table, by (impact speed / 4): first 19 entries default, then 19 for sprite $A1
$03:B7DA .db $F8,$F7,$F6,$F5,$F4,$F3,$F2,$E8
$03:B7E2 .db $E8,$E8,$E8,$00,$00,$00,$00,$FE
$03:B7EA .db $FC,$F8,$EC,$EC,$EC,$E8,$E4,$E0
$03:B7F2 .db $DC,$D8,$D4,$D0,$CC,$C8
;;; $B7F8: Set bounce Y speed ;;;
;; Replaces Y speed by a bounce speed from $B7D2 indexed by old speed / 4 (+$13 for sprite $A1, the
;; bowling ball).
;; Table entries are negative (upward); skipped if [$1588] is negative. Called by the bowling ball on landing.
;; Called by:
;; $03:B1B6: Bowser bowling ball main (BowserBowlingBall)
$03:B7F8 B5 AA LDA RAM_SpriteSpeedY,X ; Save current Y speed
$03:B7FA 48 PHA ; \
$03:B7FB 74 AA STZ RAM_SpriteSpeedY,X ; } Y speed = 0
$03:B7FD 68 PLA ; /
$03:B7FE 4A LSR ; \
$03:B7FF 4A LSR ; } Y = old speed / 4: table index
$03:B800 A8 TAY ; /
$03:B801 B5 9E LDA RAM_SpriteNum,X ; \
$03:B803 C9 A1 CMP.B #$A1 ; } Sprite $A1 (Bowser bowling ball)?
$03:B805 D0 05 BNE $B80C ; /
$03:B807 98 TYA ; \
$03:B808 18 CLC ; |
$03:B809 69 13 ADC.B #$13 ; } Yes: index += $13 (second half of the table)
$03:B80B A8 TAY ; /
$03:B80C B9 D2 B7 LDA.W $B7D2,Y ; A = bounce speed
$03:B80F BC 88 15 LDY.W RAM_SprObjStatus,X ; \
$03:B812 30 02 BMI $B816 ; / Skip if [$1588] is negative
$03:B814 95 AA STA RAM_SpriteSpeedY,X ; Y speed = bounce speed
$03:B816 60 RTS ; Return
;;; $B817: Sprite to Mario horizontal distance (SubHorzPosBnk3) ;;;
;; Bank 3 copy of SubHorzPos.
;; Returns: Y = 0 if Mario is at or right of the sprite, 1 if left; [$0F] = low byte of Mario X - sprite X.
;; Called by:
;; $03:8124: Big Boo boss: remaining states and helpers
;; $03:8544: Porcu-Puffer main routine (PorcuPuffer)
;; $03:88E9: Swooper state routines
;; $03:8AB2: Bowser statue states (BowserStatuePtrs)
;; $03:9070: Fishin' Boo main routine (FishinBoo)
;; $03:924E: Falling spike: state handlers (FallingSpikePtrs)
;; $03:948E: Wooden spike Mario contact
;; $03:95D2: Rex hurts Mario (RexWins)
;; $03:95FB: Rex killed by star (RexStarKill)
;; $03:980D: Fishbone graphics, and aim at Mario routine (FishboneGfx)
;; $03:9A25: Reznor: face Mario (NoSetRznrFireTime)
;; $03:9A6D: Mario bounces off platform side (HitPlatSide)
;; ... and 12 more
$03:B817 A0 00 LDY.B #$00 ; Y = 0: assume Mario is at or to the right of the sprite
$03:B819 A5 94 LDA RAM_MarioXPos ; \
$03:B81B 38 SEC ; |
$03:B81C F5 E4 SBC RAM_SpriteXLo,X ; |
$03:B81E 85 0F STA $0F ; / [$0F] = Mario X position low - sprite X position low
$03:B820 A5 95 LDA RAM_MarioXPosHi ; \
$03:B822 FD E0 14 SBC.W RAM_SpriteXHi,X ; / 16-bit borrow: sign of the high byte tells which side Mario is on
$03:B825 10 01 BPL $B828 ; Mario right of (or at) the sprite: keep Y = 0
$03:B827 C8 INY ; Mario left of the sprite: Y = 1
$03:B828 60 RTS ; Return
;;; $B829: Sprite to Mario vertical distance (SubVertPosBnk3) ;;;
;; Bank 3 copy of SubVertPos.
;; Returns: Y = 0 if Mario is at or below the sprite, 1 if above; [$0F] = low byte of Mario Y - sprite Y.
;; Called by:
;; $03:87DD: Mega Mole: turn at walls, Mario contact (MegaMoleOnGround)
;; $03:97FD: Fishbone graphics, and aim at Mario routine (FishboneGfx)
$03:B829 A0 00 LDY.B #$00 ; Y = 0: assume Mario is at or below the sprite
$03:B82B A5 96 LDA RAM_MarioYPos ; \
$03:B82D 38 SEC ; |
$03:B82E F5 D8 SBC RAM_SpriteYLo,X ; |
$03:B830 85 0F STA $0F ; / [$0F] = Mario Y position low - sprite Y position low
$03:B832 A5 97 LDA RAM_MarioYPosHi ; \
$03:B834 FD D4 14 SBC.W RAM_SpriteYHi,X ; / 16-bit borrow: sign of the high byte tells which side Mario is on
$03:B837 10 01 BPL $B83A ; Mario below (or at) the sprite: keep Y = 0
$03:B839 C8 INY ; Mario above the sprite: Y = 1
$03:B83A 60 RTS ; Return
;;; $B83B..B847: Table: off-screen despawn limits ;;;
;; Vertical (2 entries) and horizontal (4 pairs) limits used by the SubOffscreen routines, as 16-bit offsets
;; from the screen boundary, low and high bytes in separate tables.
$03:B83B .db $40,$B0 ; Vertical limits, low bytes: $40 (below screen), $B0 (above screen)
$03:B83D .db $01,$FF ; Vertical limits, high bytes: $01, $FF (so +$0140 and -$0050)
$03:B83F .db $30,$C0,$A0,$80,$A0,$40,$60,$B0 ; Horizontal limits, low bytes: pairs (right, left) for margin sets 0, 1, 2, 3
$03:B847 .db $01,$FF,$01,$FF,$01,$00,$01,$FF ; Horizontal limits, high bytes: $0130/$FFC0, $01A0/$FF80, $01A0/$0040, $0160/$FFB0
;;; $B84F: Despawn off-screen sprite, margin set 3 (SubOffscreen3Bnk3) ;;;
;; Entry point that selects the widest margin set ([$03] = 6) and joins SubOffscreen0Bnk3.
;; Called by:
;; $03:877A: Mega Mole main (MegaMole)
$03:B84F A9 06 LDA.B #$06 ; [$03] = 6: margin set 3
$03:B851 80 06 BRA $B859 ; Go to the shared code
;;; $B853: Despawn off-screen sprite, margin set 2 (SubOffscreen2Bnk3) ;;;
;; Entry point that sets [$03] = 4 and joins the shared code.
$03:B853 A9 04 LDA.B #$04 ; [$03] = 4: margin set 2
$03:B855 80 02 BRA $B859 ; Go to the shared code
;;; $B857: Despawn off-screen sprite, margin set 1 (SubOffscreen1Bnk3) ;;;
;; Entry point that sets [$03] = 2 and joins the shared code.
$03:B857 A9 02 LDA.B #$02 ; [$03] = 2: margin set 1
$03:B859 85 03 STA $03 ; Store the margin set number
$03:B85B 80 02 BRA $B85F ; Skip the STZ below
;;; $B85D: Despawn off-screen sprite (horizontal) (SubOffscreen0Bnk3) ;;;
;; Bank 3 copy of SubOffscreen. Called by sprites every frame to remove themselves when too far from the
;; screen.
;; Does nothing while the sprite is on screen or has the process-off-screen tweaker bit set (except falling
;; below the level).
;; Otherwise alternates frames between the right and the left limit and erases the sprite once beyond it.
;; Parameters: X = sprite index; entry point picks the margin set in [$03] (0, 2, 4, 6). Vertical levels use
;; VerticalLevelBnk3.
;; Called by:
;; $03:801A: Football sprite main routine (Football)
;; $03:845B: Grey falling platform main routine (GreyFallingPlat)
;; $03:84F9: Blurp main routine (Blurp)
;; $03:853D: Porcu-Puffer main routine (PorcuPuffer)
;; $03:8706: Gray lava platform main (GrayLavaPlatform)
;; $03:88C4: Swooper bat main (Swooper)
;; $03:8993: Sliding Koopa (shell-less blue) main (SlidingKoopa)
;; $03:8A43: Bowser statue main (BowserStatue)
;; $03:8C36: Carrot top lift main routine (CarrotTopLift)
;; $03:8D73: Message box main routine (InfoBox)
;; $03:8DC2: Timed lift main routine (TimedLift)
;; $03:8EF3: Bowser statue fireball main routine (StatueFireball)
;; ... and 11 more
$03:B85D 64 03 STZ $03 ; [$03] = 0: margin set 0 (default)
$03:B85F 20 FB B8 JSR.W IsSprOffScreenBnk3 ; A = non-zero if the sprite is off-screen (IsSprOffScreenBnk3)
$03:B862 F0 5E BEQ $B8C2 ; On screen: return
$03:B864 A5 5B LDA RAM_IsVerticalLvl ; \
$03:B866 29 01 AND.B #$01 ; |
$03:B868 D0 59 BNE VerticalLevelBnk3 ; / Vertical level: use VerticalLevelBnk3 instead
$03:B86A B5 D8 LDA RAM_SpriteYLo,X ; \
$03:B86C 18 CLC ; |
$03:B86D 69 50 ADC.B #$50 ; |
$03:B86F BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:B872 69 00 ADC.B #$00 ; |
$03:B874 C9 02 CMP.B #$02 ; |
$03:B876 10 34 BPL OffScrEraseSprBnk3 ; / Sprite Y + $50 reaches high byte >= 2 (fell below the level): erase it
$03:B878 BD 7A 16 LDA.W RAM_Tweaker167A,X ; \
$03:B87B 29 04 AND.B #$04 ; |
$03:B87D D0 43 BNE $B8C2 ; / Tweaker [$167A] bit 2 = process off-screen: never despawn, return
$03:B87F A5 13 LDA RAM_FrameCounter ; \
$03:B881 29 01 AND.B #$01 ; |
$03:B883 05 03 ORA $03 ; |
$03:B885 85 01 STA $01 ; / [$01] = (frame counter & 1) | [$03]: picks right edge or left edge, per margin set
$03:B887 A8 TAY ; Y = index into the horizontal limit tables
$03:B888 A5 1A LDA RAM_ScreenBndryXLo ; A = screen boundary X low
$03:B88A 18 CLC ; \
$03:B88B 79 3F B8 ADC.W $B83F,Y ; / + limit low byte $B83F[Y]
$03:B88E 26 00 ROL $00 ; Save the carry out in [$00] bit 0
$03:B890 D5 E4 CMP RAM_SpriteXLo,X ; Compare with sprite X low
$03:B892 08 PHP ; Save the compare result
$03:B893 A5 1B LDA RAM_ScreenBndryXHi ; A = screen boundary X high
$03:B895 46 00 LSR $00 ; Restore the carry from the limit addition
$03:B897 79 47 B8 ADC.W $B847,Y ; + limit high byte $B847[Y]
$03:B89A 28 PLP ; Restore the compare result
$03:B89B FD E0 14 SBC.W RAM_SpriteXHi,X ; A = (screen X + limit) - sprite X, high byte (16-bit subtract)
$03:B89E 85 00 STA $00 ; [$00] = that high byte
$03:B8A0 46 01 LSR $01 ; Carry = 1 on odd frames (left edge check)
$03:B8A2 90 04 BCC $B8A8 ; Even frame (right edge): keep the sign
$03:B8A4 49 80 EOR.B #$80 ; \
$03:B8A6 85 00 STA $00 ; / Odd frame (left edge): flip the sign
$03:B8A8 A5 00 LDA $00 ; A = [$00]
$03:B8AA 10 16 BPL $B8C2 ; Sprite inside the limit: return, otherwise fall into the erase code
;;; $B8AC: Erase sprite, allow level reload (OffScrEraseSprBnk3) ;;;
;; Clears the sprite status. If the sprite came from the level's sprite list (and was alive, status >= 8) its
;; load status is cleared too, so it respawns when its position scrolls back.
$03:B8AC BD C8 14 LDA.W $14C8,X ; A = sprite status
$03:B8AF C9 08 CMP.B #$08 ; \
$03:B8B1 90 0C BCC OffScrKillSprBnk3 ; / Status < 8 (already dying): just clear the status below
$03:B8B3 BC 1A 16 LDY.W RAM_SprIndexInLvl,X ; Y = index of this sprite in the level's sprite list
$03:B8B6 C0 FF CPY.B #$FF ; \
$03:B8B8 F0 05 BEQ OffScrKillSprBnk3 ; / $FF = not from level data (spawned): do not mark for reload
$03:B8BA A9 00 LDA.B #$00 ; \
$03:B8BC 99 38 19 STA.W RAM_SprLoadStatus,Y ; / Clear its load status so the level loader can respawn it later
;;; $B8BF: Erase sprite (OffScrKillSprBnk3) ;;;
;; Sets sprite status to 0 and returns.
$03:B8BF 9E C8 14 STZ.W $14C8,X ; Sprite status = 0 (erase sprite)
$03:B8C2 60 RTS ; Return
;;; $B8C3: Despawn off-screen sprite (vertical level) (VerticalLevelBnk3) ;;;
;; Vertical level version of the off-screen check: runs every other frame, alternates between the bottom and
;; the top limit, and jumps to OffScrEraseSprBnk3 when beyond it.
$03:B8C3 BD 7A 16 LDA.W RAM_Tweaker167A,X ; \
$03:B8C6 29 04 AND.B #$04 ; |
$03:B8C8 D0 F8 BNE $B8C2 ; / Tweaker [$167A] bit 2 = process off-screen: return
$03:B8CA A5 13 LDA RAM_FrameCounter ; \
$03:B8CC 4A LSR ; |
$03:B8CD B0 F3 BCS $B8C2 ; / Return on odd frames (carry = frame counter bit 0)
$03:B8CF 29 01 AND.B #$01 ; \
$03:B8D1 85 01 STA $01 ; / [$01] = frame counter bit 1: picks bottom edge or top edge
$03:B8D3 A8 TAY ; Y = index into the vertical limit tables
$03:B8D4 A5 1C LDA RAM_ScreenBndryYLo ; A = screen boundary Y low
$03:B8D6 18 CLC ; \
$03:B8D7 79 3B B8 ADC.W $B83B,Y ; / + limit low byte $B83B[Y]
$03:B8DA 26 00 ROL $00 ; Save the carry out in [$00] bit 0
$03:B8DC D5 D8 CMP RAM_SpriteYLo,X ; Compare with sprite Y low
$03:B8DE 08 PHP ; Save the compare result
$03:B8DF AD 1D 00 LDA.W RAM_ScreenBndryYHi ; A = screen boundary Y high
$03:B8E2 46 00 LSR $00 ; Restore the carry from the limit addition
$03:B8E4 79 3D B8 ADC.W $B83D,Y ; + limit high byte $B83D[Y]
$03:B8E7 28 PLP ; Restore the compare result
$03:B8E8 FD D4 14 SBC.W RAM_SpriteYHi,X ; A = (screen Y + limit) - sprite Y, high byte (16-bit subtract)
$03:B8EB 85 00 STA $00 ; [$00] = that high byte
$03:B8ED A4 01 LDY $01 ; Y = [$01]
$03:B8EF F0 04 BEQ $B8F5 ; Bottom edge check: keep the sign
$03:B8F1 49 80 EOR.B #$80 ; \
$03:B8F3 85 00 STA $00 ; / Top edge check: flip the sign
$03:B8F5 A5 00 LDA $00 ; A = [$00]
$03:B8F7 10 C9 BPL $B8C2 ; Sprite inside the limit: return
$03:B8F9 30 B1 BMI OffScrEraseSprBnk3 ; Outside: erase the sprite (always taken)
;;; $B8FB: Is sprite off-screen (IsSprOffScreenBnk3) ;;;
;; Returns: A = 0 if on screen, non-zero if off-screen horizontally or vertically.
;; Called by:
;; $03:8A11: Sliding Koopa (shell-less blue) main (SlidingKoopa)
;; $03:B85F: Despawn off-screen sprite (horizontal) (SubOffscreen0Bnk3)
$03:B8FB BD A0 15 LDA.W RAM_OffscreenHorz,X ; \
$03:B8FE 1D 6C 18 ORA.W RAM_OffscreenVert,X ; / A = horizontal off-screen flag | vertical off-screen flag (0 = on screen)
$03:B901 60 RTS ; Return
;;; $B902: Palette data: Magikoopa fade steps (MagiKoopaPals) ;;;
;; 8 steps of 16 bytes (8 colors, BGR555). Copied to the palette upload buffer by the sprite code in bank 1,
;; one step per animation frame ([$1570] - 1) * 16.
$03:B902 .db $FF,$7F,$4A,$29,$00,$00,$00,$14 ; Step 1: 8 colors (BGR555)
$03:B90A .db $00,$20,$92,$7E,$0A,$00,$2A,$00 ; Step 1 (second half)
$03:B912 .db $FF,$7F,$AD,$35,$00,$00,$00,$24 ; Step 2: 8 colors
$03:B91A .db $00,$2C,$2F,$72,$0D,$00,$AD,$00
$03:B922 .db $FF,$7F,$10,$42,$00,$00,$00,$30 ; Step 3: 8 colors
$03:B92A .db $00,$38,$CC,$65,$50,$00,$10,$01
$03:B932 .db $FF,$7F,$73,$4E,$00,$00,$00,$3C ; Step 4: 8 colors
$03:B93A .db $41,$44,$69,$59,$B3,$00,$73,$01
$03:B942 .db $FF,$7F,$D6,$5A,$00,$00,$00,$48 ; Step 5: 8 colors
$03:B94A .db $A4,$50,$06,$4D,$16,$01,$D6,$01
$03:B952 .db $FF,$7F,$39,$67,$00,$00,$42,$54 ; Step 6: 8 colors
$03:B95A .db $07,$5D,$A3,$40,$79,$01,$39,$02
$03:B962 .db $FF,$7F,$9C,$73,$00,$00,$A5,$60 ; Step 7: 8 colors
$03:B96A .db $6A,$69,$40,$34,$DC,$01,$9C,$02
$03:B972 .db $FF,$7F,$FF,$7F,$00,$00,$08,$6D ; Step 8: 8 colors
$03:B97A .db $CD,$75,$00,$28,$3F,$02,$FF,$02
;;; $B982: Palette data: Big Boo boss, then $FF padding (BooBossPals) ;;;
;; 8 rows of 16 bytes (8 colors, BGR555) copied by the Big Boo boss code in bank 3 to fade the boss
;; (transparency effect, palette E); row picked from [$190B]. The rest of the bank up to $03BFFF is $FF
;; padding.
$03:B982 .db $FF,$7F,$63,$0C,$00,$00,$00,$0C ; Row 0: 8 colors (BGR555)
$03:B98A .db $00,$0C,$00,$0C,$00,$0C,$03,$00
$03:B992 .db $FF,$7F,$E7,$1C,$00,$00,$00,$1C ; Row 1: 8 colors
$03:B99A .db $00,$1C,$20,$1C,$81,$1C,$07,$00
$03:B9A2 .db $FF,$7F,$6B,$2D,$00,$00,$00,$2C ; Row 2: 8 colors
$03:B9AA .db $40,$2C,$A2,$2C,$05,$2D,$0B,$00
$03:B9B2 .db $FF,$7F,$EF,$3D,$00,$00,$60,$3C ; Row 3: 8 colors
$03:B9BA .db $C3,$3C,$26,$3D,$89,$3D,$0F,$00
$03:B9C2 .db $FF,$7F,$73,$4E,$00,$00,$E4,$4C ; Row 4: 8 colors
$03:B9CA .db $47,$4D,$AA,$4D,$0D,$4E,$13,$10
$03:B9D2 .db $FF,$7F,$F7,$5E,$00,$00,$68,$5D ; Row 5: 8 colors
$03:B9DA .db $CB,$5D,$2E,$5E,$91,$5E,$17,$20
$03:B9E2 .db $FF,$7F,$7B,$6F,$00,$00,$EC,$6D ; Row 6: 8 colors
$03:B9EA .db $4F,$6E,$B2,$6E,$15,$6F,$1B,$30
$03:B9F2 .db $FF,$7F,$FF,$7F,$00,$00,$70,$7E ; Row 7: 8 colors
$03:B9FA .db $D3,$7E,$36,$7F,$99,$7F,$1F,$40
$03:BA02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BA9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BABA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BACA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAD2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BADA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BAFA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BB9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBBA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBCA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBD2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBDA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BBFA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BC9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCBA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCCA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCD2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCDA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BCFA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BD9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDBA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDCA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDD2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDDA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BDFA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BE9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEBA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BECA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BED2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEDA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BEFA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF02 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF0A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF12 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF1A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF22 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF2A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF32 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF3A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF42 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF4A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF52 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF5A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF62 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF6A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF72 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF7A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF82 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF8A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF92 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BF9A .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFA2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFAA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFB2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFBA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFC2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFCA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFD2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFDA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFE2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFEA .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFF2 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:BFFA .db $FF,$FF,$FF,$FF,$FF,$FF
;;; $C000: Generate block at sprite position (GenTileFromSpr2) ;;;
;; Creates a block (map16 tile) at the sprite's position (X - 8, Y + 8) using GenerateTile.
;; Parameters: A = block number; X = sprite index.
;; $03C023 (separate routine): long-call wrapper that sets the data bank and runs the Baby Yoshi swallow code
;; at $03C02F; called from bank 2.
;; Called by:
;; $01:BADE: Climbing net door main (ClimbingDoor)
;; $01:BB22: Climbing net door main (ClimbingDoor)
$03:C000 85 9C STA RAM_BlockBlock ; [$9C] = block number to generate
$03:C002 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:C004 38 SEC ; |
$03:C005 E9 08 SBC.B #$08 ; |
$03:C007 85 9A STA RAM_BlockXLo ; |
$03:C009 BD E0 14 LDA.W RAM_SpriteXHi,X ; |
$03:C00C E9 00 SBC.B #$00 ; |
$03:C00E 85 9B STA RAM_BlockXHi ; / Block X position = sprite X position - 8 (16-bit)
$03:C010 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:C012 18 CLC ; |
$03:C013 69 08 ADC.B #$08 ; |
$03:C015 85 98 STA RAM_BlockYLo ; |
$03:C017 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:C01A 69 00 ADC.B #$00 ; |
$03:C01C 85 99 STA RAM_BlockYHi ; / Block Y position = sprite Y position + 8 (16-bit)
$03:C01E 22 B0 BE 00 JSL.L GenerateTile ; Generate the tile (GenerateTile)
$03:C022 6B RTL ; Return
$03:C023 8B PHB ; \
$03:C024 4B PHK ; |
$03:C025 AB PLB ; / Data bank = program bank ($03), old bank saved
$03:C026 20 2F C0 JSR.W $C02F ; Run the Baby Yoshi swallow routine ($C02F)
$03:C029 AB PLB ; Restore the data bank
$03:C02A 6B RTL ; Return long
;;; $C02B..C02B: Table: cycling power-up sprite numbers ;;;
;; Sprite numbers $74 (mushroom), $75 (fire flower), $77 (feather), $76 (star).
$03:C02B .db $74,$75,$77,$76 ; $74 mushroom, $75 fire flower, $77 feather, $76 star
;;; $C02F: Baby Yoshi swallows caught sprite ;;;
;; Probably the Baby Yoshi eating code (called through the $03C023 wrapper). Erases the sprite caught by the
;; tongue ([$160E,X]) and plays a sound.
;; If the eaten sprite is a power-up ($74-$77), or it is the fifth sprite eaten ([$1570]), the sprite becomes
;; a full Yoshi (sprite $35).
;; Otherwise gives points. Sprite $81 is replaced by a power-up from a table cycled by the frame counter
;; (purpose partly unclear).
;; Parameters: X = Baby Yoshi sprite index.
;; Called by:
;; $03:C026: Generate block at sprite position (GenTileFromSpr2)
$03:C02F BC 0E 16 LDY.W $160E,X ; Y = sprite slot of the sprite caught by Baby Yoshi's tongue
$03:C032 A9 00 LDA.B #$00 ; \
$03:C034 99 C8 14 STA.W $14C8,Y ; / Erase the caught sprite (status 0)
$03:C037 A9 06 LDA.B #$06 ; \
$03:C039 8D F9 1D STA.W $1DF9 ; / Play sound effect $06
$03:C03C B9 0E 16 LDA.W $160E,Y ; A = [$160E] of the caught sprite
$03:C03F D0 5A BNE $C09B ; Non-zero: skip the power-up check (purpose unclear), go to the eat counter
$03:C041 B9 9E 00 LDA.W RAM_SpriteNum,Y ; A = caught sprite number
$03:C044 C9 81 CMP.B #$81 ; Is it sprite $81?
$03:C046 D0 0C BNE $C054 ; No: use the sprite number as it is
$03:C048 A5 14 LDA RAM_FrameCounterB ; \
$03:C04A 4A LSR ; |
$03:C04B 4A LSR ; |
$03:C04C 4A LSR ; |
$03:C04D 4A LSR ; |
$03:C04E 29 03 AND.B #$03 ; / Y = (frame counter >> 4) & 3
$03:C050 A8 TAY ; Y = index
$03:C051 B9 2B C0 LDA.W $C02B,Y ; Sprite $81: take a power-up from the cycling table
$03:C054 C9 74 CMP.B #$74 ; Sprite number >= $74?
$03:C056 90 43 BCC $C09B ; No: not a power-up, go to the eat counter
$03:C058 C9 78 CMP.B #$78 ; Sprite number < $78?
$03:C05A B0 3F BCS $C09B ; No: not a power-up, go to the eat counter
$03:C05C 9C AC 18 STZ.W $18AC ; Clear [$18AC] (Yoshi swallow/tongue timer)
$03:C05F 9C 1E 14 STZ.W RAM_YoshiHasWings ; Yoshi has no wings
$03:C062 A9 35 LDA.B #$35 ; \
$03:C064 9D 9E 00 STA.W RAM_SpriteNum,X ; / Sprite number = $35 (Yoshi): Baby Yoshi grows up
$03:C067 A9 08 LDA.B #$08 ; \
$03:C069 9D C8 14 STA.W $14C8,X ; / Sprite status = 8 (normal)
$03:C06C A9 1F LDA.B #$1F ; \
$03:C06E 8D FC 1D STA.W $1DFC ; / Play sound effect $1F
$03:C071 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:C073 E9 10 SBC.B #$10 ; |
$03:C075 95 D8 STA RAM_SpriteYLo,X ; |
$03:C077 BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:C07A E9 00 SBC.B #$00 ; |
$03:C07C 9D D4 14 STA.W RAM_SpriteYHi,X ; / Sprite Y position -= $10 (taller sprite)
$03:C07F BD F6 15 LDA.W RAM_SpritePal,X ; \
$03:C082 48 PHA ; / Save the sprite palette
$03:C083 22 D2 F7 07 JSL.L InitSpriteTables ; Reset all sprite tables for the new sprite type (InitSpriteTables)
$03:C087 68 PLA ; \
$03:C088 29 FE AND.B #$FE ; |
$03:C08A 9D F6 15 STA.W RAM_SpritePal,X ; / Restore the palette with the low bit cleared
$03:C08D A9 0C LDA.B #$0C ; \
$03:C08F 9D 02 16 STA.W $1602,X ; / [$1602] = $0C (animation frame)
$03:C092 DE 0E 16 DEC.W $160E,X ; [$160E] -= 1 (no caught sprite: $00 becomes $FF)
$03:C095 A9 40 LDA.B #$40 ; \
$03:C097 8D E8 18 STA.W $18E8 ; / [$18E8] = $40 (timer that blocks further tongue contact)
$03:C09A 60 RTS ; Return
$03:C09B FE 70 15 INC.W $1570,X ; Count this eaten sprite: [$1570] += 1
$03:C09E BD 70 15 LDA.W $1570,X ; A = eaten sprite count
$03:C0A1 C9 05 CMP.B #$05 ; Fifth eaten sprite?
$03:C0A3 D0 02 BNE $C0A7 ; No: just react to the meal
$03:C0A5 80 B5 BRA $C05C ; Yes: grow up too (go to $03C05C)
$03:C0A7 22 4A B3 05 JSL.L $B34A ; Eat reaction ($B34A, probably the Baby Yoshi gulp animation)
$03:C0AB A9 01 LDA.B #$01 ; \
$03:C0AD 22 E5 AC 02 JSL.L GivePoints ; / Give points (index 1) to this sprite (GivePoints)
$03:C0B1 60 RTS ; Return
;;; $C0B2..C0BE: Table: animated tiles and phase offsets ;;;
;; Tile numbers $68, $6A, $6C, $6E and 16 per-tile animation phase offsets, for the row drawn by $C0C6.
$03:C0B2 .db $68,$6A,$6C,$6E ; Tile numbers $68, $6A, $6C, $6E (animation frames)
$03:C0B6 .db $00,$03,$01,$02,$04,$02,$00,$01 ; Animation phase offsets per tile (index 0-15; the tile loop also reads 4 bytes past the table)
$03:C0BE .db $00,$04,$00,$02,$00,$03,$04,$01
;;; $C0C6: Iggy/Larry room: draw row and tilt platform ;;;
;; Called from bank 0 (non-Mode 7 boss room path). Updates the tilting platform unless sprites are locked,
;; then draws 20 16x16 tiles across the screen at Y = $C4 (probably the lava), OAM slots $6C-$7F, animated
;; from the frame counter.
;; Quirk: the phase offset loop reads 4 bytes past $C0B6 (into code), only the low two bits are used.
;; Called by:
;; $00:988C: Mode 7 boss room: per-frame update
$03:C0C6 A5 9D LDA RAM_SpritesLocked ; \
$03:C0C8 D0 03 BNE $C0CD ; / Sprites not locked: tilt the platform ($C11E)
$03:C0CA 20 1E C1 JSR.W $C11E ; Update the Iggy/Larry platform tilt
$03:C0CD 64 00 STZ $00 ; [$00] = 0: X position of the first tile
$03:C0CF A2 13 LDX.B #$13 ; X = $13: 20 tiles
$03:C0D1 A0 B0 LDY.B #$B0 ; Y = $B0: first OAM slot ($0300 + $B0 = OAM sprite $6C)
$03:C0D3 86 02 STX $02 ; [$02] = tile counter
$03:C0D5 A5 00 LDA $00 ; A = tile X position
$03:C0D7 99 00 03 STA.W OAM_DispX,Y ; OAM X position
$03:C0DA 18 CLC ; \
$03:C0DB 69 10 ADC.B #$10 ; |
$03:C0DD 85 00 STA $00 ; / Next tile X position += $10
$03:C0DF A9 C4 LDA.B #$C4 ; \
$03:C0E1 99 01 03 STA.W OAM_DispY,Y ; / OAM Y position = $C4 (bottom of the screen)
$03:C0E4 A5 64 LDA $64 ; \
$03:C0E6 09 09 ORA.B #$09 ; |
$03:C0E8 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = [$64] (priority bits) | $09 (palette 4, second tile page)
$03:C0EB DA PHX ; Save the tile counter
$03:C0EC A5 14 LDA RAM_FrameCounterB ; \
$03:C0EE 4A LSR ; |
$03:C0EF 4A LSR ; |
$03:C0F0 4A LSR ; / A = frame counter B >> 3
$03:C0F1 18 CLC ; \
$03:C0F2 7F B6 C0 03 ADC.L $C0B6,X ; / + animation offset $C0B6[counter]
$03:C0F6 29 03 AND.B #$03 ; A &= 3
$03:C0F8 AA TAX ; X = frame index
$03:C0F9 BF B2 C0 03 LDA.L $C0B2,X ; A = tile number from $C0B2[X]
$03:C0FD 99 02 03 STA.W OAM_Tile,Y ; OAM tile number
$03:C100 98 TYA ; \
$03:C101 4A LSR ; |
$03:C102 4A LSR ; |
$03:C103 AA TAX ; / X = OAM index / 4
$03:C104 A9 02 LDA.B #$02 ; \
$03:C106 9D 60 04 STA.W OAM_TileSize,X ; / Tile size = 16x16 (X high bit 0)
$03:C109 FA PLX ; Restore the tile counter
$03:C10A C8 INY ; \
$03:C10B C8 INY ; |
$03:C10C C8 INY ; |
$03:C10D C8 INY ; / Y += 4: next OAM slot
$03:C10E CA DEX ; Next tile
$03:C10F 10 C2 BPL $C0D3 ; Loop for all 20 tiles
$03:C111 6B RTL ; Return long
;;; $C112: Table: platform tilt speed (IggyPlatSpeed) ;;;
;; Low byte (-1, +1, -1, +1) and sign-extension byte of the tilt change per step, indexed by the tilt
;; direction (+2 for steep phases).
$03:C112 .db $FF,$01,$FF,$01 ; Low byte of tilt speed: -1, +1, -1, +1 (second pair for steep tilts)
$03:C116 .db $FF,$00,$FF,$00 ; High byte of tilt speed: $FF, $00, $FF, $00 (sign extension)
;;; $C11A: Iggy/Larry platform tilt update (IggyPlatBounds) ;;;
;; Tilts the platform one step every other frame by adding a speed to [$36]/[$37] until it hits the maximum,
;; then holds still for $40 frames and advances the phase.
;; [$1905] = number of tilts made, [$1906] = hold timer, [$1907] = phase 0-5 (phases 4 and 5 tilt further).
;; Data at $03C11A: maximum tilt values. Code at $03C11E returns at once if sprites are locked or the battle
;; is over ([$1493]).
$03:C11A .db $E7,$18,$D7,$28 ; Maximum tilt values: -$19, +$18 (normal), -$29, +$28 (steep)
$03:C11E A5 9D LDA RAM_SpritesLocked ; \
$03:C120 0D 93 14 ORA.W $1493 ; |
$03:C123 D0 50 BNE $C175 ; / Sprites locked or battle over ([$1493] non-zero): return
$03:C125 AD 06 19 LDA.W $1906 ; \
$03:C128 F0 03 BEQ $C12D ; / [$1906] = stationary timer at maximum tilt: 0 means moving
$03:C12A CE 06 19 DEC.W $1906 ; Count the stationary timer down
$03:C12D A5 13 LDA RAM_FrameCounter ; \
$03:C12F 29 01 AND.B #$01 ; |
$03:C131 0D 06 19 ORA.W $1906 ; |
$03:C134 D0 3F BNE $C175 ; / Move only every other frame, and only if the timer is 0
$03:C136 AD 05 19 LDA.W $1905 ; A = [$1905], total number of tilts made so far
$03:C139 29 01 AND.B #$01 ; \
$03:C13B AA TAX ; / X = tilt direction (bit 0 of the tilt count)
$03:C13C AD 07 19 LDA.W $1907 ; A = [$1907], current phase (0-5)
$03:C13F C9 04 CMP.B #$04 ; \
$03:C141 90 02 BCC $C145 ; / Phase < 4: normal tilt
$03:C143 E8 INX ; \
$03:C144 E8 INX ; / Phase 4 or 5: X += 2 for a steep tilt
$03:C145 A5 36 LDA $36 ; A = [$36], platform tilt (low byte)
$03:C147 18 CLC ; \
$03:C148 7F 12 C1 03 ADC.L IggyPlatSpeed,X ; / + speed from IggyPlatSpeed[X]
$03:C14C 85 36 STA $36 ; [$36] = new tilt
$03:C14E 48 PHA ; Save the new tilt
$03:C14F A5 37 LDA $37 ; A = [$37], platform tilt high byte
$03:C151 7F 16 C1 03 ADC.L $C116,X ; + sign extension from $C116[X]
$03:C155 29 01 AND.B #$01 ; \
$03:C157 85 37 STA $37 ; / [$37] = bit 0 only (which way the platform leans)
$03:C159 68 PLA ; A = new tilt
$03:C15A DF 1A C1 03 CMP.L IggyPlatBounds,X ; \
$03:C15E D0 15 BNE $C175 ; / Not at the maximum tilt yet: return
$03:C160 EE 05 19 INC.W $1905 ; Count one more tilt: [$1905] += 1
$03:C163 A9 40 LDA.B #$40 ; \
$03:C165 8D 06 19 STA.W $1906 ; / [$1906] = $40: hold the platform still for 64 frames
$03:C168 EE 07 19 INC.W $1907 ; Next phase: [$1907] += 1
$03:C16B AD 07 19 LDA.W $1907 ; \
$03:C16E C9 06 CMP.B #$06 ; |
$03:C170 D0 03 BNE $C175 ; / Phase 6: wrap back to 0
$03:C172 9C 07 19 STZ.W $1907 ; Phase = 0
$03:C175 60 RTS ; Return
;;; $C176..C196: Table: Yoshi tongue tip X offsets ;;;
;; 40 bytes of X offsets of the tongue tip tile (index [$02] from tongue phase, direction and head frame);
;; used by the Yoshi graphics code in bank 1.
$03:C176 .db $0C,$0C,$0C,$0C,$0C,$0C,$0D,$0D ; Yoshi tongue tip X offsets (index in [$02], 40 entries)
$03:C17E .db $0D,$0D,$FC,$FC,$FC,$FC,$FC,$FC
$03:C186 .db $FB,$FB,$FB,$FB,$0C,$0C,$0C,$0C
$03:C18E .db $0C,$0C,$0D,$0D,$0D,$0D,$FC,$FC
$03:C196 .db $FC,$FC,$FC,$FC,$FB,$FB,$FB,$FB
;;; $C19E..C1BE: Table: Yoshi tongue tip Y offsets ;;;
;; 40 bytes of Y offsets for the same tongue tip tile.
$03:C19E .db $0E,$0E,$0E,$0D,$0D,$0D,$0C,$0C ; Yoshi tongue tip Y offsets (index in [$02], 40 entries)
$03:C1A6 .db $0B,$0B,$0E,$0E,$0E,$0D,$0D,$0D
$03:C1AE .db $0C,$0C,$0B,$0B,$12,$12,$12,$11
$03:C1B6 .db $11,$11,$10,$10,$0F,$0F,$12,$12
$03:C1BE .db $12,$11,$11,$11,$10,$10,$0F,$0F
;;; $C1C6..C1C8: Table: slope nudge for sprites ;;;
;; X low bytes +2/-2 and X high bytes $00/$FF, indexed by slope direction.
$03:C1C6 .db $02,$FE ; Slope nudge X low: +2, -2
$03:C1C8 .db $00,$FF ; Slope nudge X high: $00, $FF
;;; $C1CA: Move sprite along a slope ;;;
;; Long-call routine from bank 1 (sprites on slopes such as the Diggin' Chuck rock and the football). Nudges
;; the sprite X by +2 or -2 depending on the slope sign in [$15B8,X] and sets Y speed to $18 so it stays on
;; the slope.
;; Parameters: X = sprite index.
;; Called by:
;; $01:9380: Sprite vertical check and map16 lookup
$03:C1CA 8B PHB ; \
$03:C1CB 4B PHK ; |
$03:C1CC AB PLB ; / Data bank = program bank ($03)
$03:C1CD A0 00 LDY.B #$00 ; Y = 0
$03:C1CF BD B8 15 LDA.W $15B8,X ; A = [$15B8] (slope under the sprite)
$03:C1D2 10 01 BPL $C1D5 ; Positive or flat: keep Y = 0
$03:C1D4 C8 INY ; Negative slope: Y = 1
$03:C1D5 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:C1D7 18 CLC ; |
$03:C1D8 79 C6 C1 ADC.W $C1C6,Y ; / Sprite X low += $C1C6[Y]
$03:C1DB 95 E4 STA RAM_SpriteXLo,X ; Store it
$03:C1DD BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:C1E0 79 C8 C1 ADC.W $C1C8,Y ; / Sprite X high += $C1C8[Y]
$03:C1E3 9D E0 14 STA.W RAM_SpriteXHi,X ; Store it
$03:C1E6 A9 18 LDA.B #$18 ; \
$03:C1E8 95 AA STA RAM_SpriteSpeedY,X ; / Sprite Y speed = $18 (push it down onto the slope)
$03:C1EA AB PLB ; Restore the data bank
$03:C1EB 6B RTL ; Return long
;;; $C1EC..C1F4: Table: light switch Y shake ;;;
;; Screen Y offsets applied while the switch is drawn, indexed by hit timer / 2.
$03:C1EC .db $00,$04,$07,$08,$08,$07,$04,$00 ; Screen Y shake offsets by hit timer / 2 (0,4,7,8,8,7,4,0,0)
$03:C1F4 .db $00
;;; $C1F5: Light switch sprite main (LightSwitch) ;;;
;; Sprite $C8. Behaves as a solid block (InvisBlkMainRt) and despawns off-screen. When the hit timer [$1558]
;; reaches 5 it toggles bit 0 of the state of every normal Dark Room (sprite $C6) in the 10 first slots.
;; Graphics: draws generic sprite tile $2A, temporarily shifting the screen Y by a table value for a press
;; animation.
;; Parameters: X = sprite index.
;; Called by:
;; $03:A121: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:C1F5 A5 9D LDA RAM_SpritesLocked ; \
$03:C1F7 D0 32 BNE $C22B ; / Sprites locked: skip to the graphics
$03:C1F9 22 4F B4 01 JSL.L InvisBlkMainRt ; Act as a solid block hit from below (InvisBlkMainRt)
$03:C1FD 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Despawn when off-screen (SubOffscreen0Bnk3)
$03:C200 BD 58 15 LDA.W $1558,X ; A = hit timer [$1558]
$03:C203 C9 05 CMP.B #$05 ; \
$03:C205 D0 24 BNE $C22B ; / Not yet 5 (the frame the switch fires): skip to the graphics
$03:C207 74 C2 STZ RAM_SpriteState,X ; Sprite state = 0
$03:C209 A0 0B LDY.B #$0B ; \
$03:C20B 8C F9 1D STY.W $1DF9 ; / Play sound effect $0B
$03:C20E 48 PHA ; Save the hit timer
$03:C20F A0 09 LDY.B #$09 ; Y = 9: loop over sprite slots 9 to 0
$03:C211 B9 C8 14 LDA.W $14C8,Y ; A = sprite status
$03:C214 C9 08 CMP.B #$08 ; \
$03:C216 D0 0F BNE $C227 ; / Not normal (8): next slot
$03:C218 B9 9E 00 LDA.W RAM_SpriteNum,Y ; A = sprite number
$03:C21B C9 C6 CMP.B #$C6 ; \
$03:C21D D0 08 BNE $C227 ; / Not sprite $C6 (dark room with spotlight): next slot
$03:C21F B9 C2 00 LDA.W RAM_SpriteState,Y ; A = its sprite state
$03:C222 49 01 EOR.B #$01 ; Toggle bit 0 (room lit or dark)
$03:C224 99 C2 00 STA.W RAM_SpriteState,Y ; Store it
$03:C227 88 DEY ; Next slot
$03:C228 10 E7 BPL $C211 ; Loop until Y < 0
$03:C22A 68 PLA ; Restore the hit timer
$03:C22B BD 58 15 LDA.W $1558,X ; \
$03:C22E 4A LSR ; / A = [$1558] >> 1
$03:C22F A8 TAY ; Y = index into the shake table
$03:C230 A5 1C LDA RAM_ScreenBndryYLo ; \
$03:C232 48 PHA ; / Save screen Y low
$03:C233 18 CLC ; \
$03:C234 79 EC C1 ADC.W $C1EC,Y ; / + $C1EC[Y]
$03:C237 85 1C STA RAM_ScreenBndryYLo ; Shift the screen so the switch appears to move
$03:C239 A5 1D LDA RAM_ScreenBndryYHi ; \
$03:C23B 48 PHA ; / Save screen Y high
$03:C23C 69 00 ADC.B #$00 ; \
$03:C23E 85 1D STA RAM_ScreenBndryYHi ; / Add the carry
$03:C240 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw a generic sprite (GenericSprGfxRt2)
$03:C244 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index of this sprite
$03:C247 A9 2A LDA.B #$2A ; \
$03:C249 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $2A
$03:C24C B9 03 03 LDA.W OAM_Prop,Y ; \
$03:C24F 29 BF AND.B #$BF ; |
$03:C251 99 03 03 STA.W OAM_Prop,Y ; / Clear the X flip bit of the properties
$03:C254 68 PLA ; \
$03:C255 85 1D STA RAM_ScreenBndryYHi ; / Restore screen Y high
$03:C257 68 PLA ; \
$03:C258 85 1C STA RAM_ScreenBndryYLo ; / Restore screen Y low
$03:C25A 60 RTS ; Return
;;; $C25B: Table: chainsaw tiles and setup (ChainsawMotorTiles) ;;;
;; Motor animation tiles, per-sprite blade segment Y spacing ($65 and $66) and blade properties. Code at
;; $03C263 is a long-call wrapper (data bank = $03) around ChainsawGfx, called from bank 1.
$03:C25B .db $E0,$C2,$C0,$C2 ; Motor tiles: $E0, $C2, $C0, $C2 (animation frames)
$03:C25F .db $F2,$0E ; Blade segment Y spacing: $F2 (-14, sprite $65), $0E (+14, sprite $66)
$03:C261 .db $33,$B3 ; Blade tile properties: $33, $B3 (Y flipped for the second sprite)
$03:C263 8B PHB ; \
$03:C264 4B PHK ; |
$03:C265 AB PLB ; / Data bank = program bank ($03)
$03:C266 20 6B C2 JSR.W ChainsawGfx ; Draw the chainsaw (ChainsawGfx)
$03:C269 AB PLB ; Restore the data bank
$03:C26A 6B RTL ; Return long
;;; $C26B: Draw chainsaw (ChainsawGfx) ;;;
;; Draws three 16x16 tiles: an animated motor and two blade tiles that jitter every other frame. Sprite $65
;; draws the blade above, $66 below (Y flipped).
;; Parameters: X = sprite index.
;; Called by:
;; $03:C266: Table: chainsaw tiles and setup (ChainsawMotorTiles)
$03:C26B 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get on-screen position: [$00] = X, [$01] = Y, Y = OAM index (GetDrawInfoBnk3)
$03:C26E DA PHX ; Save the sprite index
$03:C26F B5 9E LDA RAM_SpriteNum,X ; \
$03:C271 38 SEC ; |
$03:C272 E9 65 SBC.B #$65 ; / A = sprite number - $65
$03:C274 AA TAX ; X = 0 or 1
$03:C275 BD 5F C2 LDA.W $C25F,X ; \
$03:C278 85 03 STA $03 ; / [$03] = blade segment Y spacing
$03:C27A BD 61 C2 LDA.W $C261,X ; \
$03:C27D 85 04 STA $04 ; / [$04] = blade tile properties
$03:C27F FA PLX ; Restore the sprite index
$03:C280 A5 14 LDA RAM_FrameCounterB ; \
$03:C282 29 02 AND.B #$02 ; / [$02] = frame counter B & 2: blade jitter
$03:C284 85 02 STA $02 ; A = on-screen X
$03:C286 A5 00 LDA $00 ; \
$03:C288 38 SEC ; / - 8
$03:C289 E9 08 SBC.B #$08
$03:C28B 99 00 03 STA.W OAM_DispX,Y ; OAM X of the motor tile
$03:C28E 99 04 03 STA.W OAM_Tile2DispX,Y ; OAM X of the first blade tile
$03:C291 99 08 03 STA.W OAM_Tile3DispX,Y ; OAM X of the second blade tile
$03:C294 A5 01 LDA $01 ; A = on-screen Y
$03:C296 38 SEC ; \
$03:C297 E9 08 SBC.B #$08 ; / - 8
$03:C299 99 01 03 STA.W OAM_DispY,Y ; OAM Y of the motor tile
$03:C29C 18 CLC ; \
$03:C29D 65 03 ADC $03 ; / + spacing
$03:C29F 18 CLC ; \
$03:C2A0 65 02 ADC $02 ; / + jitter
$03:C2A2 99 05 03 STA.W OAM_Tile2DispY,Y ; OAM Y of the first blade tile
$03:C2A5 18 CLC ; \
$03:C2A6 65 03 ADC $03 ; / + spacing
$03:C2A8 99 09 03 STA.W OAM_Tile3DispY,Y ; OAM Y of the second blade tile
$03:C2AB A5 14 LDA RAM_FrameCounterB ; \
$03:C2AD 4A LSR ; |
$03:C2AE 4A LSR ; |
$03:C2AF 29 03 AND.B #$03 ; / A = (frame counter B >> 2) & 3
$03:C2B1 DA PHX ; Save the sprite index
$03:C2B2 AA TAX ; X = motor animation frame
$03:C2B3 BD 5B C2 LDA.W ChainsawMotorTiles,X ; A = motor tile from ChainsawMotorTiles[X]
$03:C2B6 99 02 03 STA.W OAM_Tile,Y ; OAM tile of the motor
$03:C2B9 FA PLX ; Restore the sprite index
$03:C2BA A9 AE LDA.B #$AE ; \
$03:C2BC 99 06 03 STA.W OAM_Tile2,Y ; / First blade tile = $AE
$03:C2BF A9 8E LDA.B #$8E ; \
$03:C2C1 99 0A 03 STA.W OAM_Tile3,Y ; / Second blade tile = $8E
$03:C2C4 A9 37 LDA.B #$37 ; \
$03:C2C6 99 03 03 STA.W OAM_Prop,Y ; / Motor properties = $37
$03:C2C9 A5 04 LDA $04 ; \
$03:C2CB 99 07 03 STA.W OAM_Tile2Prop,Y ; / First blade tile properties = [$04]
$03:C2CE 99 0B 03 STA.W OAM_Tile3Prop,Y ; Second blade tile properties = [$04]
$03:C2D1 A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:C2D3 98 TYA ; A = 2: three tiles
$03:C2D4 22 B3 B7 01 JSL.L FinishOAMWrite ; Finish the OAM write (FinishOAMWrite)
$03:C2D8 60 RTS ; Return
;;; $C2D9: Spawn 1-Up if a sprite slot is free (TriggerInivis1Up) ;;;
;; Long routine called from bank 0 when the hidden 1-Up counter ([$1421]) reaches 4. Searches slots $0B-$00
;; for a free one; if found, continues into Generate1Up.
;; Called by:
;; $00:F2B1: Block interaction: hurt tiles, bounce blocks, coins
$03:C2D9 DA PHX ; Save the sprite index
$03:C2DA A2 0B LDX.B #$0B ; X = $0B: search sprite slots 11 down to 0
$03:C2DC BD C8 14 LDA.W $14C8,X ; \
$03:C2DF F0 05 BEQ Generate1Up ; / Free slot (status 0): create the 1-Up there
$03:C2E1 CA DEX ; Next slot
$03:C2E2 10 F8 BPL $C2DC ; Loop
$03:C2E4 FA PLX ; No free slot: restore X
$03:C2E5 6B RTL ; Return long
;;; $C2E6: Create 1-Up mushroom at Mario (Generate1Up) ;;;
;; Makes sprite X a normal 1-Up mushroom ($78) at Mario's position, initializes it, sets the interaction
;; disable timer and pops it out (PopupMushroom). Returns long.
$03:C2E6 A9 08 LDA.B #$08 ; \
$03:C2E8 9D C8 14 STA.W $14C8,X ; / Sprite status = 8 (normal)
$03:C2EB A9 78 LDA.B #$78 ; \
$03:C2ED 95 9E STA RAM_SpriteNum,X ; / Sprite number = $78 (1-Up mushroom)
$03:C2EF A5 94 LDA RAM_MarioXPos ; \
$03:C2F1 95 E4 STA RAM_SpriteXLo,X ; |
$03:C2F3 A5 95 LDA RAM_MarioXPosHi ; |
$03:C2F5 9D E0 14 STA.W RAM_SpriteXHi,X ; / Sprite X position = Mario X position
$03:C2F8 A5 96 LDA RAM_MarioYPos ; \
$03:C2FA 95 D8 STA RAM_SpriteYLo,X ; |
$03:C2FC A5 97 LDA RAM_MarioYPosHi ; |
$03:C2FE 9D D4 14 STA.W RAM_SpriteYHi,X ; / Sprite Y position = Mario Y position
$03:C301 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize the sprite tables (InitSpriteTables)
$03:C305 A9 10 LDA.B #$10 ; \
$03:C307 9D 4C 15 STA.W RAM_DisableInter,X ; / Interaction disable timer = $10
$03:C30A 20 34 C3 JSR.W PopupMushroom ; Set direction, upward speed and sound (PopupMushroom)
$03:C30D FA PLX ; Restore the sprite index
$03:C30E 6B RTL ; Return long
;;; $C30F: Invisible mushroom sprite main (InvisMushroom) ;;;
;; Sprite $C7. When Mario touches it, becomes a mushroom ($74) a bit higher and falls into PopupMushroom.
;; Called by:
;; $03:A12A: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:C30F 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get on-screen position (GetDrawInfoBnk3)
$03:C312 22 DC A7 01 JSL.L MarioSprInteract ; Mario touching the sprite? (MarioSprInteract)
$03:C316 90 2F BCC $C347 ; No: return
$03:C318 A9 74 LDA.B #$74 ; \
$03:C31A 95 9E STA RAM_SpriteNum,X ; / Sprite number = $74 (mushroom)
$03:C31C 22 D2 F7 07 JSL.L InitSpriteTables ; Reset the sprite tables (InitSpriteTables)
$03:C320 A9 20 LDA.B #$20 ; \
$03:C322 9D 4C 15 STA.W RAM_DisableInter,X ; / Interaction disable timer = $20
$03:C325 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:C327 38 SEC ; |
$03:C328 E9 0F SBC.B #$0F ; |
$03:C32A 95 D8 STA RAM_SpriteYLo,X ; |
$03:C32C BD D4 14 LDA.W RAM_SpriteYHi,X ; |
$03:C32F E9 00 SBC.B #$00 ; |
$03:C331 9D D4 14 STA.W RAM_SpriteYHi,X ; / Sprite Y position -= $0F (16-bit)
;;; : Pop item upward (PopupMushroom) ;;;
;; Sets the sprite direction from Mario's X speed (left = 1), Y speed $C0 (up) and plays sound $02. Used when
;; a mushroom or 1-Up appears.
;; Called by:
;; $03:C30A: Create 1-Up mushroom at Mario (Generate1Up)
$03:C334 A9 00 LDA.B #$00 ; A = 0: facing right
$03:C336 A4 7B LDY RAM_MarioSpeedX ; Y = Mario X speed
$03:C338 10 01 BPL $C33B ; Mario not moving left: keep A = 0
$03:C33A 1A INC A ; Mario moving left: A = 1
$03:C33B 9D 7C 15 STA.W RAM_SpriteDir,X ; Sprite direction = A (same as Mario's horizontal direction)
$03:C33E A9 C0 LDA.B #$C0 ; \
$03:C340 95 AA STA RAM_SpriteSpeedY,X ; / Sprite Y speed = $C0 (pops upward)
$03:C342 A9 02 LDA.B #$02 ; \
$03:C344 8D FC 1D STA.W $1DFC ; / Play sound effect $02
$03:C347 60 RTS ; Return
;;; $C348: Table: Ninji jump Y speeds (NinjiSpeedY) ;;;
$03:C348 .db $D0,$C0,$B0,$D0 ; Ninji jump Y speeds: $D0, $C0, $B0, $D0
;;; $C34C: Ninji main; Dry Bones graphics wrapper (Ninji) ;;;
;; Sprite $51 Ninji: faces Mario and hops every $60 frames on the ground, cycling through four hop speeds
;; (NinjiSpeedY).
;; $03C390 (JSL from bank 01): draws Dry Bones / Bony Beetle with the direction temporarily flipped while
;; turning.
;; $03C3AE: Bony Beetle ($31) uses the generic sprite drawing routine instead.
;; Called by:
;; $03:A133: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:C34C 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Draw Ninji (generic sprite graphics routine)
$03:C350 A5 9D LDA RAM_SpritesLocked ; \
$03:C352 D0 3B BNE $C38F ; / Return if sprites are locked
$03:C354 20 17 B8 JSR.W SubHorzPosBnk3 ; \
$03:C357 98 TYA ; } Face Mario: sprite direction = side Mario is on
$03:C358 9D 7C 15 STA.W RAM_SpriteDir,X ; /
$03:C35B 20 5D B8 JSR.W SubOffscreen0Bnk3 ; Only process while on-screen (SubOffscreen0)
$03:C35E 22 3A 80 01 JSL.L SprSpr+MarioSprRts ; Interact with Mario
$03:C362 22 2A 80 01 JSL.L UpdateSpritePos ; Update position from speed, with gravity and object collision
$03:C366 BD 88 15 LDA.W RAM_SprObjStatus,X ; \
$03:C369 29 04 AND.B #$04 ; } Skip the landing code if not on the ground ([$1588] bit 2)
$03:C36B F0 18 BEQ $C385 ; /
$03:C36D 74 AA STZ RAM_SpriteSpeedY,X ; Landed: Y speed = 0
$03:C36F BD 40 15 LDA.W $1540,X ; \
$03:C372 D0 11 BNE $C385 ; / Skip if the hop timer [$1540] is still running
$03:C374 A9 60 LDA.B #$60 ; \
$03:C376 9D 40 15 STA.W $1540,X ; / Hop timer [$1540] = $60 frames
$03:C379 F6 C2 INC RAM_SpriteState,X ; Hop counter [$C2]++
$03:C37B B5 C2 LDA RAM_SpriteState,X ; \
$03:C37D 29 03 AND.B #$03 ; } Y = [$C2] & 3: which of the four hop heights
$03:C37F A8 TAY ; /
$03:C380 B9 48 C3 LDA.W NinjiSpeedY,Y ; \
$03:C383 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = NinjiSpeedY[Y] (jump up)
$03:C385 A9 00 LDA.B #$00 ; \
$03:C387 B4 AA LDY RAM_SpriteSpeedY,X ; |
$03:C389 30 01 BMI $C38C ; |
$03:C38B 1A INC A ; } Animation frame [$1602] = 0 while moving up, 1 when Y speed >= 0
$03:C38C 9D 02 16 STA.W $1602,X ; /
$03:C38F 60 RTS ; Return
$03:C390 8B PHB ; Save data bank
$03:C391 4B PHK ; \
$03:C392 AB PLB ; / Data bank = program bank ($03)
$03:C393 BD 7C 15 LDA.W RAM_SpriteDir,X ; Save sprite direction on the stack
$03:C396 48 PHA ; Push it
$03:C397 BC AC 15 LDY.W $15AC,X ; \
$03:C39A F0 09 BEQ $C3A5 ; / Y = turn timer [$15AC]; skip if not turning
$03:C39C C0 05 CPY.B #$05 ; \
$03:C39E 90 05 BCC $C3A5 ; / Skip if timer < 5 (turn nearly finished)
$03:C3A0 49 01 EOR.B #$01 ; \
$03:C3A2 9D 7C 15 STA.W RAM_SpriteDir,X ; / Turning: draw with the direction flipped
$03:C3A5 20 DA C3 JSR.W $C3DA ; Draw Dry Bones / Bony Beetle ($C3DA)
$03:C3A8 68 PLA ; \
$03:C3A9 9D 7C 15 STA.W RAM_SpriteDir,X ; / Restore the real sprite direction
$03:C3AC AB PLB ; Restore data bank
$03:C3AD 6B RTL ; Return long (JSL from bank 01)
$03:C3AE 22 B2 90 01 JSL.L GenericSprGfxRt2 ; Sprite $31 (Bony Beetle): draw with the generic routine instead
$03:C3B2 60 RTS ; Return
;;; $C3B3: Table: Dry Bones tile X offsets (DryBonesTileDispX) ;;;
;; Index = direction * 3 + tile (bone, head, body); +6 while turning.
$03:C3B3 .db $00,$08,$00,$00,$F8,$00,$00,$04 ; Tile X offsets, 3 tiles (bone, head, body) x direction: normal right, normal left, turning right (part)
$03:C3BB .db $00,$00,$FC,$00 ; Turning left; head is only 4 pixels forward while turning
;;; $C3BF: Table: Dry Bones tile properties (DryBonesGfxProp) ;;;
$03:C3BF .db $43,$43,$43,$03,$03,$03 ; Tile properties: $43 (X flip) for direction 0, $03 for direction 1
;;; $C3C5: Table: Dry Bones tile Y offsets (DryBonesTileDispY) ;;;
;; Index = frame * 3 + tile (bone, head, body).
$03:C3C5 .db $F4,$F0,$00,$F4,$F1,$00,$F4,$F0 ; Tile Y offsets (bone, head, body): frame 0, frame 1, start of frame 2
$03:C3CD .db $00 ; Frame 2 body offset
;;; $C3CE: Dry Bones tiles, drawing, bone spawn (DryBonesTiles) ;;;
;; Tile table (frame * 3 + tile), then $C3DA: draws Dry Bones with up to three 16x16 tiles (bone in hand
;; drawn only in frame 2).
;; Parameters: X: sprite index. Returns via FinishOAMWrite.
;; $03C44E (JSL from bank 01): throws a Bone extended sprite ($06) from above the sprite if it is on-screen,
;; toward the facing direction (X speed $18 or $E8).
$03:C3CE .db $00,$64,$66,$00,$64,$68,$82,$64 ; Tile numbers: frame 0, frame 1 (no bone tile), start of frame 2
$03:C3D6 .db $E6 ; Frame 2 body tile $E6 (frame 2 = $82 held bone, $64 head)
$03:C3D7 .db $00,$00,$FF ; Last tile index to skip, per frame: $00 = skip tile 0 (bone), $FF = draw all three
$03:C3DA B5 9E LDA RAM_SpriteNum,X ; \
$03:C3DC C9 31 CMP.B #$31 ; } Sprite $31 (Bony Beetle): use the generic drawing routine
$03:C3DE F0 CE BEQ $C3AE ; /
$03:C3E0 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get on-screen position: [$00] = X, [$01] = Y, Y = OAM index
$03:C3E3 BD AC 15 LDA.W $15AC,X ; \
$03:C3E6 85 05 STA $05 ; / [$05] = turn timer [$15AC]
$03:C3E8 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:C3EB 0A ASL ; |
$03:C3EC 7D 7C 15 ADC.W RAM_SpriteDir,X ; } [$02] = direction * 3 (index into the X offset tables)
$03:C3EF 85 02 STA $02 ; /
$03:C3F1 DA PHX ; Save sprite index
$03:C3F2 BD 02 16 LDA.W $1602,X ; A = animation frame [$1602]
$03:C3F5 48 PHA ; Save frame
$03:C3F6 0A ASL ; \
$03:C3F7 7D 02 16 ADC.W $1602,X ; } [$03] = frame * 3 (index into the Y offset and tile tables)
$03:C3FA 85 03 STA $03 ; /
$03:C3FC FA PLX ; X = frame
$03:C3FD BD D7 C3 LDA.W $C3D7,X ; \
$03:C400 85 04 STA $04 ; / [$04] = loop end marker for this frame
$03:C402 A2 02 LDX.B #$02 ; Start with tile 2 (body)
$03:C404 DA PHX ; Save tile index
$03:C405 8A TXA ; \
$03:C406 18 CLC ; |
$03:C407 65 02 ADC $02 ; } X = direction * 3 + tile index
$03:C409 AA TAX ; /
$03:C40A DA PHX ; Save it
$03:C40B A5 05 LDA $05 ; \
$03:C40D F0 05 BEQ $C414 ; / Not turning: use X as is
$03:C40F 8A TXA ; \
$03:C410 18 CLC ; |
$03:C411 69 06 ADC.B #$06 ; } Turning: use the second half of the X offset table (+6)
$03:C413 AA TAX ; /
$03:C414 A5 00 LDA $00 ; \
$03:C416 18 CLC ; |
$03:C417 7D B3 C3 ADC.W DryBonesTileDispX,X ; } OAM X = on-screen X + X offset
$03:C41A 99 00 03 STA.W OAM_DispX,Y ; /
$03:C41D FA PLX ; Restore X = direction * 3 + tile index
$03:C41E BD BF C3 LDA.W DryBonesGfxProp,X ; \
$03:C421 05 64 ORA $64 ; } OAM properties = flip bits for the direction | sprite palette/priority [$64]
$03:C423 99 03 03 STA.W OAM_Prop,Y ; /
$03:C426 68 PLA ; Pull tile index
$03:C427 48 PHA ; Push it back
$03:C428 18 CLC ; \
$03:C429 65 03 ADC $03 ; } X = frame * 3 + tile index
$03:C42B AA TAX ; /
$03:C42C A5 01 LDA $01 ; \
$03:C42E 18 CLC ; |
$03:C42F 7D C5 C3 ADC.W DryBonesTileDispY,X ; } OAM Y = on-screen Y + Y offset
$03:C432 99 01 03 STA.W OAM_DispY,Y ; /
$03:C435 BD CE C3 LDA.W DryBonesTiles,X ; \
$03:C438 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = DryBonesTiles[X]
$03:C43B FA PLX ; Restore the tile index
$03:C43C C8 INY ; \
$03:C43D C8 INY ; |
$03:C43E C8 INY ; } Next OAM slot (Y += 4)
$03:C43F C8 INY ; /
$03:C440 CA DEX ; \
$03:C441 E4 04 CPX $04 ; } Next tile; loop until the end marker
$03:C443 D0 BF BNE $C404 ; /
$03:C445 FA PLX ; Restore sprite index
$03:C446 A0 02 LDY.B #$02 ; Y = 2: 16x16 tiles
$03:C448 98 TYA ; \
$03:C449 22 B3 B7 01 JSL.L FinishOAMWrite ; / A = 2 (three tiles); finish OAM write
$03:C44D 60 RTS ; Return
$03:C44E BD A0 15 LDA.W RAM_OffscreenHorz,X ; \
$03:C451 1D 6C 18 ORA.W RAM_OffscreenVert,X ; } Return if the sprite is off-screen horizontally or vertically
$03:C454 D0 0A BNE $C460 ; /
$03:C456 A0 07 LDY.B #$07 ; \
$03:C458 B9 0B 17 LDA.W RAM_ExSpriteNum,Y ; |
$03:C45B F0 04 BEQ $C461 ; |
$03:C45D 88 DEY ; |
$03:C45E 10 F8 BPL $C458 ; } Find a free extended sprite slot (Y = 7..0); return if none
$03:C460 6B RTL ; /
$03:C461 A9 06 LDA.B #$06 ; \
$03:C463 99 0B 17 STA.W RAM_ExSpriteNum,Y ; / Extended sprite = Bone ($06)
$03:C466 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:C468 38 SEC ; |
$03:C469 E9 10 SBC.B #$10 ; } Bone Y low = sprite Y - $10
$03:C46B 99 15 17 STA.W RAM_ExSpriteYLo,Y ; /
$03:C46E BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:C471 E9 00 SBC.B #$00 ; } Bone Y high (with borrow)
$03:C473 99 29 17 STA.W RAM_ExSpriteYHi,Y ; /
$03:C476 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:C478 99 1F 17 STA.W RAM_ExSpriteXLo,Y ; / Bone X low = sprite X low
$03:C47B BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:C47E 99 33 17 STA.W RAM_ExSpriteXHi,Y ; / Bone X high = sprite X high
$03:C481 BD 7C 15 LDA.W RAM_SpriteDir,X ; \
$03:C484 4A LSR ; / Carry = sprite direction
$03:C485 A9 18 LDA.B #$18 ; Bone X speed = $18 (right)
$03:C487 90 02 BCC $C48B ; \
$03:C489 A9 E8 LDA.B #$E8 ; / Facing left: X speed = $E8
$03:C48B 99 47 17 STA.W RAM_ExSprSpeedX,Y ; Store the bone X speed
$03:C48E 6B RTL ; Return long
;;; $C48F..C491: Table: dark room beam sweep data ;;;
;; $03C48F: beam end X step (+1, -1). $03C491: right end value at which the sweep reverses ($FF, $90).
$03:C48F .db $01,$FF ; Spotlight sweep step per frame: +1, -1
$03:C491 .db $FF,$90 ; Bottom edge value that reverses the sweep: $FF, $90
;;; $C493: Disco ball tiles and drawing (DiscoBallTiles) ;;;
;; Tile and property tables, then $C4A5: draws the disco ball as one 16x16 sprite at screen position
;; ($78,$28).
;; It spins (8 frames) while the room light is on (state bit 0), otherwise shows the static tile $C2.
;; Parameters: X: sprite index.
$03:C493 .db $80,$82,$84,$86,$88,$8C,$C0,$C2 ; Disco ball tiles, animated (8 frames) then static tile $C2
$03:C49B .db $C2 ; Static tile
$03:C49C .db $31,$33,$35,$37,$31,$33,$35,$37 ; Disco ball tile properties (palette/priority), animated
$03:C4A4 .db $39 ; Static properties
$03:C4A5 BC EA 15 LDY.W RAM_SprOAMIndex,X ; Y = OAM index of this sprite
$03:C4A8 A9 78 LDA.B #$78 ; \
$03:C4AA 99 00 03 STA.W OAM_DispX,Y ; / OAM X = $78
$03:C4AD A9 28 LDA.B #$28 ; \
$03:C4AF 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = $28
$03:C4B2 DA PHX ; Save sprite index
$03:C4B3 B5 C2 LDA RAM_SpriteState,X ; A = state (lit flag)
$03:C4B5 A2 08 LDX.B #$08 ; X = 8: default frame (static ball)
$03:C4B7 29 01 AND.B #$01 ; \
$03:C4B9 F0 06 BEQ $C4C1 ; / Light off: keep the static ball
$03:C4BB A5 13 LDA RAM_FrameCounter ; \
$03:C4BD 4A LSR ; |
$03:C4BE 29 07 AND.B #$07 ; } Light on: X = ([frame counter] >> 1) & 7, spinning ball
$03:C4C0 AA TAX ; /
$03:C4C1 BD 93 C4 LDA.W DiscoBallTiles,X ; \
$03:C4C4 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = DiscoBallTiles[X]
$03:C4C7 BD 9C C4 LDA.W $C49C,X ; \
$03:C4CA 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = $C49C[X]
$03:C4CD 98 TYA ; \
$03:C4CE 4A LSR ; |
$03:C4CF 4A LSR ; } Y = OAM index / 4
$03:C4D0 A8 TAY ; /
$03:C4D1 A9 02 LDA.B #$02 ; \
$03:C4D3 99 60 04 STA.W OAM_TileSize,Y ; / Tile size = 16x16
$03:C4D6 FA PLX ; Restore sprite index
$03:C4D7 60 RTS ; Return
;;; $C4D8..C4DA: Table: dark room backdrop colors ;;;
;; Backdrop color ($0701/$0702) for light off / on: $4210 and $318C (low bytes at $03C4D8, high bytes at
;; $03C4DA).
$03:C4D8 .db $10,$8C ; Backdrop color low bytes: $10 (light off), $8C (light on)
$03:C4DA .db $42,$31 ; Backdrop color high bytes: $42, $31 (colors $4210 and $318C, dark grays)
;;; $C4DC: Dark room with spotlight main (DarkRoomWithLight) ;;;
;; Sprite $C6. Keeps only one instance alive, draws the disco ball, sets color math to darken everything
;; outside window 1 and builds the window shape.
;; The window is a beam widening from ($78..$87) at scanline 48 to ([$1476]..[$1478]) at scanline 223, with
;; the far end sweeping back and forth.
;; Edges are computed per scanline with a DDA (steps $CF) into the HDMA table at $04A0 (left, right per line);
;; the table is rebuilt every 4th frame.
;; State 0 (light off) fills the whole table with empty windows (left 1, right 0). Quirk: also sets the
;; backdrop color from the state.
;; Called by:
;; $03:A145: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:C4DC BD 34 15 LDA.W $1534,X ; \
$03:C4DF D0 1F BNE $C500 ; / Already initialized? Then skip the duplicate check
$03:C4E1 A0 09 LDY.B #$09 ; Y = 9: scan sprite slots 9..0
$03:C4E3 CC E9 15 CPY.W $15E9 ; \
$03:C4E6 F0 12 BEQ $C4FA ; / Skip this sprite's own slot
$03:C4E8 B9 C8 14 LDA.W $14C8,Y ; \
$03:C4EB C9 08 CMP.B #$08 ; } Skip slots whose status is not 8 (normal)
$03:C4ED D0 0B BNE $C4FA ; /
$03:C4EF B9 9E 00 LDA.W RAM_SpriteNum,Y ; \
$03:C4F2 C9 C6 CMP.B #$C6 ; } Skip slots that are not sprite $C6
$03:C4F4 D0 04 BNE $C4FA ; /
$03:C4F6 9E C8 14 STZ.W $14C8,X ; Another dark room sprite exists: erase this one
$03:C4F9 60 RTS ; Return
$03:C4FA 88 DEY ; \
$03:C4FB 10 E6 BPL $C4E3 ; / Next slot
$03:C4FD FE 34 15 INC.W $1534,X ; Mark as initialized
$03:C500 20 A5 C4 JSR.W $C4A5 ; Draw the disco ball
$03:C503 A9 FF LDA.B #$FF ; \
$03:C505 85 40 STA $40 ; / [$40] (CGADSUB mirror) = $FF: subtract all layers, half (darken)
$03:C507 A9 20 LDA.B #$20 ; \
$03:C509 85 44 STA $44 ; / [$44] (CGWSEL mirror) = $20: color math only outside the window
$03:C50B A9 20 LDA.B #$20 ; \
$03:C50D 85 43 STA $43 ; / [$43] (WOBJSEL mirror) = $20: color window uses window 1
$03:C50F A9 80 LDA.B #$80 ; \
$03:C511 8D 9F 0D STA.W $0D9F ; / Enable HDMA channel 7 (window 1 left/right edges per scanline)
$03:C514 B5 C2 LDA RAM_SpriteState,X ; \
$03:C516 29 01 AND.B #$01 ; } Y = state & 1
$03:C518 A8 TAY ; /
$03:C519 B9 D8 C4 LDA.W $C4D8,Y ; \
$03:C51C 8D 01 07 STA.W $0701 ; / Backdrop color low = $C4D8[Y]
$03:C51F B9 DA C4 LDA.W $C4DA,Y ; \
$03:C522 8D 02 07 STA.W $0702 ; / Backdrop color high = $C4DA[Y]
$03:C525 A5 9D LDA RAM_SpritesLocked ; \
$03:C527 D0 D0 BNE $C4F9 ; / Return if sprites are locked
$03:C529 AD 82 14 LDA.W $1482 ; \
$03:C52C D0 1F BNE $C54D ; / Beam already set up? Then skip the set-up
$03:C52E A9 00 LDA.B #$00 ; \
$03:C530 8D 76 14 STA.W $1476 ; / Beam end left X [$1476] = 0
$03:C533 A9 90 LDA.B #$90 ; \
$03:C535 8D 78 14 STA.W $1478 ; / Beam end right X [$1478] = $90
$03:C538 A9 78 LDA.B #$78 ; \
$03:C53A 8D 72 14 STA.W $1472 ; / Beam start left X [$1472] = $78
$03:C53D A9 87 LDA.B #$87 ; \
$03:C53F 8D 74 14 STA.W $1474 ; / Beam start right X [$1474] = $87
$03:C542 A9 01 LDA.B #$01 ; \
$03:C544 8D 86 14 STA.W $1486 ; / [$1486] = 1 (probably unused)
$03:C547 9C 83 14 STZ.W $1483 ; Sweep direction [$1483] = 0
$03:C54A EE 82 14 INC.W $1482 ; Set-up done
$03:C54D AC 83 14 LDY.W $1483 ; Y = sweep direction
$03:C550 AD 76 14 LDA.W $1476 ; \
$03:C553 18 CLC ; |
$03:C554 79 8F C4 ADC.W $C48F,Y ; } Beam end left X += $C48F[Y] (+1 or -1)
$03:C557 8D 76 14 STA.W $1476 ; /
$03:C55A AD 78 14 LDA.W $1478 ; \
$03:C55D 18 CLC ; |
$03:C55E 79 8F C4 ADC.W $C48F,Y ; } Beam end right X += $C48F[Y]
$03:C561 8D 78 14 STA.W $1478 ; /
$03:C564 D9 91 C4 CMP.W $C491,Y ; \
$03:C567 D0 09 BNE $C572 ; / Right end reached the turning value?
$03:C569 AD 83 14 LDA.W $1483 ; \
$03:C56C 1A INC A ; |
$03:C56D 29 01 AND.B #$01 ; } Yes: toggle the sweep direction
$03:C56F 8D 83 14 STA.W $1483 ; /
$03:C572 A5 13 LDA RAM_FrameCounter ; \
$03:C574 29 03 AND.B #$03 ; } Rebuild the window table only every 4th frame
$03:C576 D0 81 BNE $C4F9 ; /
$03:C578 A0 00 LDY.B #$00 ; Y = 0 (left side sign)
$03:C57A AD 72 14 LDA.W $1472 ; \
$03:C57D 8D 7A 14 STA.W $147A ; / [$147A] = left edge, starts at [$1472]
$03:C580 38 SEC ; \
$03:C581 ED 76 14 SBC.W $1476 ; } A = [$1472] - [$1476]; carry set if the edge moves left or stays
$03:C584 B0 04 BCS $C58A ; /
$03:C586 C8 INY ; \
$03:C587 49 FF EOR.B #$FF ; } Otherwise negate it and set the sign Y = 1
$03:C589 1A INC A ; /
$03:C58A 8D 80 14 STA.W $1480 ; [$1480] = |left edge change| (DDA step)
$03:C58D 8C 84 14 STY.W $1484 ; [$1484] = left edge sign (0 = moves left, 1 = moves right)
$03:C590 9C 7E 14 STZ.W $147E ; [$147E] = 0 (left DDA accumulator)
$03:C593 A0 00 LDY.B #$00 ; Y = 0 (right side sign)
$03:C595 AD 74 14 LDA.W $1474 ; \
$03:C598 8D 7C 14 STA.W $147C ; / [$147C] = right edge, starts at [$1474]
$03:C59B 38 SEC ; \
$03:C59C ED 78 14 SBC.W $1478 ; } A = [$1474] - [$1478]
$03:C59F B0 04 BCS $C5A5 ; /
$03:C5A1 C8 INY ; \
$03:C5A2 49 FF EOR.B #$FF ; } Negate it and set the sign Y = 1 if negative
$03:C5A4 1A INC A ; /
$03:C5A5 8D 81 14 STA.W $1481 ; [$1481] = |right edge change| (DDA step)
$03:C5A8 8C 85 14 STY.W $1485 ; [$1485] = right edge sign
$03:C5AB 9C 7F 14 STZ.W $147F ; [$147F] = 0 (right DDA accumulator)
$03:C5AE B5 C2 LDA RAM_SpriteState,X ; \
$03:C5B0 85 0F STA $0F ; / [$0F] = state (0 = light off)
$03:C5B2 DA PHX ; Save sprite index
$03:C5B3 C2 10 REP #$10 ; X, Y 16-bit
$03:C5B5 A2 00 00 LDX.W #$0000 ; X = 0: byte offset into the table at $04A0 (2 bytes per scanline)
$03:C5B8 E0 5F 00 CPX.W #$005F ; \
$03:C5BB 90 4A BCC $C607 ; / First 48 scanlines (above the beam): window left = 1, right = 0
$03:C5BD AD 7E 14 LDA.W $147E ; \
$03:C5C0 18 CLC ; |
$03:C5C1 6D 80 14 ADC.W $1480 ; } Left DDA: [$147E] += [$1480]
$03:C5C4 8D 7E 14 STA.W $147E ; /
$03:C5C7 B0 04 BCS $C5CD ; \
$03:C5C9 C9 CF CMP.B #$CF ; } Skip if no carry and below $CF
$03:C5CB 90 13 BCC $C5E0 ; /
$03:C5CD E9 CF SBC.B #$CF ; \
$03:C5CF 8D 7E 14 STA.W $147E ; / Overflow: subtract $CF
$03:C5D2 EE 7A 14 INC.W $147A ; Left edge [$147A] += 1
$03:C5D5 AD 84 14 LDA.W $1484 ; \
$03:C5D8 D0 06 BNE $C5E0 ; / Edge moves right: done
$03:C5DA CE 7A 14 DEC.W $147A ; \
$03:C5DD CE 7A 14 DEC.W $147A ; / Edge moves left: net -1
$03:C5E0 AD 7F 14 LDA.W $147F ; \
$03:C5E3 18 CLC ; |
$03:C5E4 6D 81 14 ADC.W $1481 ; } Right DDA: [$147F] += [$1481]
$03:C5E7 8D 7F 14 STA.W $147F ; /
$03:C5EA B0 04 BCS $C5F0 ; \
$03:C5EC C9 CF CMP.B #$CF ; } Skip if no carry and below $CF
$03:C5EE 90 13 BCC $C603 ; /
$03:C5F0 E9 CF SBC.B #$CF ; \
$03:C5F2 8D 7F 14 STA.W $147F ; / Overflow: subtract $CF
$03:C5F5 EE 7C 14 INC.W $147C ; Right edge [$147C] += 1
$03:C5F8 AD 85 14 LDA.W $1485 ; \
$03:C5FB D0 06 BNE $C603 ; / Edge moves right: done
$03:C5FD CE 7C 14 DEC.W $147C ; \
$03:C600 CE 7C 14 DEC.W $147C ; / Edge moves left: net -1
$03:C603 A5 0F LDA $0F ; \
$03:C605 D0 08 BNE $C60F ; / Light on: store the computed edges
$03:C607 A9 01 LDA.B #$01 ; \
$03:C609 9D A0 04 STA.W $04A0,X ; / Window left = 1 (empty window: no light on this line)
$03:C60C 3A DEC A ; \
$03:C60D 80 09 BRA $C618 ; / Window right = 0
$03:C60F AD 7A 14 LDA.W $147A ; \
$03:C612 9D A0 04 STA.W $04A0,X ; / Window left = [$147A]
$03:C615 AD 7C 14 LDA.W $147C ; Window right = [$147C]
$03:C618 9D A1 04 STA.W $04A1,X ; Store window right
$03:C61B E8 INX ; \
$03:C61C E8 INX ; / Next scanline (X += 2)
$03:C61D E0 C0 01 CPX.W #$01C0 ; \
$03:C620 D0 96 BNE $C5B8 ; / Loop for all 224 scanlines
$03:C622 E2 10 SEP #$10 ; X, Y 8-bit
$03:C624 FA PLX ; Restore sprite index
$03:C625 60 RTS ; Return
;;; $C626..C676: Table: firework burst X offsets (rockets 0-2) ;;;
$03:C626 .db $14,$28,$38,$20,$30,$4C,$40,$34 ; Firework burst particle X positions, rockets 0 to 2 (84 points, origin $40, scaled by burst size)
$03:C62E .db $2C,$1C,$08,$0C,$04,$0C,$1C,$24
$03:C636 .db $2C,$38,$40,$48,$50,$5C,$5C,$6C
$03:C63E .db $4C,$58,$24,$78,$64,$70,$78,$7C
$03:C646 .db $70,$68,$58,$4C,$40,$34,$24,$04
$03:C64E .db $18,$2C,$0C,$0C,$14,$18,$1C,$24
$03:C656 .db $2C,$28,$24,$30,$30,$34,$38,$3C
$03:C65E .db $44,$54,$48,$5C,$68,$40,$4C,$40
$03:C666 .db $3C,$40,$50,$54,$60,$54,$4C,$5C
$03:C66E .db $5C,$68,$74,$6C,$7C,$78,$68,$80
$03:C676 .db $18,$48,$2C,$1C
;;; $C67A..C6CA: Table: firework burst Y offsets (rockets 0-2) ;;;
$03:C67A .db $1C,$0C,$08,$1C,$14,$08,$14,$24 ; Firework burst particle Y positions, rockets 0 to 2 (84 points, origin $50)
$03:C682 .db $28,$2C,$30,$3C,$44,$4C,$44,$34
$03:C68A .db $40,$34,$24,$1C,$10,$0C,$18,$18
$03:C692 .db $2C,$28,$68,$28,$34,$34,$38,$40
$03:C69A .db $44,$44,$38,$3C,$44,$48,$4C,$5C
$03:C6A2 .db $5C,$54,$64,$74,$74,$88,$80,$94
$03:C6AA .db $8C,$78,$6C,$64,$70,$7C,$8C,$98
$03:C6B2 .db $90,$98,$84,$84,$88,$78,$78,$6C
$03:C6BA .db $5C,$50,$50,$48,$50,$5C,$64,$64
$03:C6C2 .db $74,$78,$74,$64,$60,$58,$54,$50
$03:C6CA .db $50,$58,$30,$34
;;; $C6CE..C71E: Table: firework burst X offsets (rocket 3) ;;;
$03:C6CE .db $20,$30,$39,$47,$50,$60,$70,$7C ; Firework burst particle X positions, rocket 3 (84 points, origin $40)
$03:C6D6 .db $7B,$80,$7D,$78,$6E,$60,$4F,$47
$03:C6DE .db $41,$38,$30,$2A,$20,$10,$04,$00
$03:C6E6 .db $00,$08,$10,$20,$1A,$10,$0A,$06
$03:C6EE .db $0F,$17,$16,$1C,$1F,$21,$10,$18
$03:C6F6 .db $20,$2C,$2E,$3B,$30,$30,$2D,$2A
$03:C6FE .db $34,$36,$3A,$3F,$45,$4D,$5F,$54
$03:C706 .db $4E,$67,$70,$67,$70,$5C,$4E,$40
$03:C70E .db $48,$56,$57,$5F,$68,$72,$77,$6F
$03:C716 .db $66,$60,$67,$5C,$57,$4B,$4D,$54
$03:C71E .db $48,$43,$3D,$3C
;;; $C722..C772: Table: firework burst Y offsets (rocket 3) ;;;
$03:C722 .db $18,$1E,$25,$22,$1A,$17,$20,$30 ; Firework burst particle Y positions, rocket 3 (84 points, origin $50)
$03:C72A .db $41,$4F,$61,$70,$7F,$8C,$94,$92
$03:C732 .db $A0,$86,$93,$88,$88,$78,$66,$50
$03:C73A .db $40,$30,$22,$20,$2C,$30,$40,$4F
$03:C742 .db $59,$51,$3F,$39,$4C,$5F,$6A,$6F
$03:C74A .db $77,$7E,$6C,$60,$58,$48,$3D,$2F
$03:C752 .db $28,$38,$44,$30,$36,$27,$21,$2F
$03:C75A .db $39,$2A,$2F,$39,$40,$3F,$49,$50
$03:C762 .db $60,$59,$4C,$51,$48,$4F,$56,$67
$03:C76A .db $5B,$68,$75,$7D,$87,$8A,$7A,$6B
$03:C772 .db $70,$82,$73,$92
;;; $C776..C776: Table: firework launch X positions ;;;
$03:C776 .db $60,$B0,$40,$80 ; Firework launch X position per rocket: $60, $B0, $40, $80
;;; $C77A: Table: firework launch sound ($1DF9) (FireworkSfx1) ;;;
$03:C77A .db $26,$00,$26,$28 ; Launch sound for $1DF9 per rocket
;;; $C77E: Table: firework launch sound ($1DFC) (FireworkSfx2) ;;;
$03:C77E .db $00,$2B,$00,$00 ; Launch sound for $1DFC per rocket
;;; $C782: Table: firework burst sound ($1DF9) (FireworkSfx3) ;;;
$03:C782 .db $27,$00,$27,$29 ; Burst sound for $1DF9 per rocket
;;; $C786: Firework burst sounds; Peach fireworks controller (FireworkSfx4) ;;;
;; Tables: burst sound ($1DFC), backdrop flash colors indexed by [$156D] & 3 and the launch delay per rocket.
;; $03C796: last Peach ending state (pointer 7 in PeachPtrs). Launches four Firework sprites ($7A) from below
;; the screen, one at a time (each waits for [$1FEB]),
;; flashes the backdrop color while a burst is active, then waits $70 frames, advances cutscene [$13C6] and
;; sets the end timer [$1493] = $FF.
;; Parameters: X: Peach sprite index.
$03:C786 .db $00,$2C,$00,$00 ; Burst sound for $1DFC per rocket
$03:C78A .db $00,$AA,$FF,$AA ; Flash backdrop color low byte, indexed by [$156D] & 3
$03:C78E .db $00,$7E,$27,$7E ; Flash backdrop color high byte ($7EAA, $27FF flashes)
$03:C792 .db $C0,$C0,$FF,$C0 ; Value for [$1FEB] after launching each rocket (delay before the next one)
$03:C796 BD 64 15 LDA.W $1564,X ; \
$03:C799 F0 0C BEQ $C7A7 ; / Rockets finished? Run the timer if [$1564] is set
$03:C79B 3A DEC A ; \
$03:C79C D0 08 BNE $C7A6 ; / Timer not at 1 yet: return
$03:C79E EE C6 13 INC.W $13C6 ; Next cutscene state [$13C6]++
$03:C7A1 A9 FF LDA.B #$FF ; \
$03:C7A3 8D 93 14 STA.W $1493 ; / End-of-level timer [$1493] = $FF
$03:C7A6 60 RTS ; Return
$03:C7A7 AD 6D 15 LDA.W $156D ; \
$03:C7AA 29 03 AND.B #$03 ; } Y = [$156D] & 3: backdrop flash step
$03:C7AC A8 TAY ; /
$03:C7AD B9 8A C7 LDA.W $C78A,Y ; \
$03:C7B0 8D 01 07 STA.W $0701 ; / Backdrop color low = $C78A[Y]
$03:C7B3 B9 8E C7 LDA.W $C78E,Y ; \
$03:C7B6 8D 02 07 STA.W $0702 ; / Backdrop color high = $C78E[Y]
$03:C7B9 AD EB 1F LDA.W $1FEB ; \
$03:C7BC D0 51 BNE $C80F ; / Return while launch delay [$1FEB] is non-zero
$03:C7BE BD 34 15 LDA.W $1534,X ; \
$03:C7C1 C9 04 CMP.B #$04 ; } Four rockets launched? Go start the end timer
$03:C7C3 F0 4B BEQ $C810 ; /
$03:C7C5 A0 01 LDY.B #$01 ; Y = 1: look for a free sprite slot among 1..0
$03:C7C7 B9 C8 14 LDA.W $14C8,Y ; \
$03:C7CA F0 04 BEQ $C7D0 ; / Free slot found
$03:C7CC 88 DEY ; \
$03:C7CD 10 F8 BPL $C7C7 ; / Next slot
$03:C7CF 60 RTS ; No free slot: return
$03:C7D0 A9 08 LDA.B #$08 ; \
$03:C7D2 99 C8 14 STA.W $14C8,Y ; / Sprite status = normal
$03:C7D5 A9 7A LDA.B #$7A ; \
$03:C7D7 99 9E 00 STA.W RAM_SpriteNum,Y ; / Sprite number = $7A (firework)
$03:C7DA A9 00 LDA.B #$00 ; \
$03:C7DC 99 E0 14 STA.W RAM_SpriteXHi,Y ; / X high = 0
$03:C7DF A9 A8 LDA.B #$A8 ; \
$03:C7E1 18 CLC ; |
$03:C7E2 65 1C ADC RAM_ScreenBndryYLo ; } Y low = screen Y + $A8 (below the screen bottom)
$03:C7E4 99 D8 00 STA.W RAM_SpriteYLo,Y ; /
$03:C7E7 A5 1D LDA RAM_ScreenBndryYHi ; \
$03:C7E9 69 00 ADC.B #$00 ; } Y high = screen Y high (with carry)
$03:C7EB 99 D4 14 STA.W RAM_SpriteYHi,Y ; /
$03:C7EE DA PHX ; Save sprite index
$03:C7EF BB TYX ; X = new slot
$03:C7F0 22 D2 F7 07 JSL.L InitSpriteTables ; Initialize the new sprite's tables
$03:C7F4 FA PLX ; Restore Peach's index
$03:C7F5 DA PHX ; Save it again
$03:C7F6 BD 34 15 LDA.W $1534,X ; \
$03:C7F9 29 03 AND.B #$03 ; } New sprite [$1534] = rocket number & 3
$03:C7FB 99 34 15 STA.W $1534,Y ; /
$03:C7FE AA TAX ; X = rocket number
$03:C7FF BD 92 C7 LDA.W $C792,X ; \
$03:C802 8D EB 1F STA.W $1FEB ; / [$1FEB] = launch delay for this rocket
$03:C805 BD 76 C7 LDA.W $C776,X ; \
$03:C808 99 E4 00 STA.W RAM_SpriteXLo,Y ; / New sprite X low = $C776[X]
$03:C80B FA PLX ; Restore Peach's index
$03:C80C FE 34 15 INC.W $1534,X ; Rockets launched [$1534]++
$03:C80F 60 RTS ; Return
$03:C810 A9 70 LDA.B #$70 ; \
$03:C812 9D 64 15 STA.W $1564,X ; / All launched: timer [$1564] = $70 frames before the scene ends
$03:C815 60 RTS ; Return
;;; $C816: Firework sprite main (state dispatch) (Firework) ;;;
;; Sprite $7A. Runs the routine for state [$C2] from FireworkPtrs; [$1534] = rocket number 0-3.
;; Called by:
;; $03:A14E: Bank 3 sprite main dispatch (Bnk3CallSprMain)
$03:C816 B5 C2 LDA RAM_SpriteState,X ; A = state
$03:C818 22 DF 86 00 JSL.L ExecutePtr ; Run the routine for this state
;;; $C81C: Pointer table: firework states (FireworkPtrs) ;;;
;; 0 launch, 1 rise, 2 burst, 3 fade out.
$03:C81C 28 C8 .dw $C828 ; State 0: launch
$03:C81E 45 C8 .dw $C845 ; State 1: rise
$03:C820 8D C8 .dw $C88D ; State 2: burst
$03:C822 41 C9 .dw $C941 ; State 3: fade out
;;; $C824: Table: firework launch speed; state 0 (FireworkSpeedY) ;;;
;; State 0: sets the launch Y speed from the rocket number, plays the launch sound, timer = $10, goes to state
;; 1.
$03:C824 .db $E4,$E6,$E4,$E2 ; Launch Y speed per rocket
$03:C828 BC 34 15 LDY.W $1534,X ; \
$03:C82B B9 24 C8 LDA.W FireworkSpeedY,Y ; } Y speed = FireworkSpeedY[rocket number [$1534]]
$03:C82E 95 AA STA RAM_SpriteSpeedY,X ; /
$03:C830 A9 25 LDA.B #$25 ; \
$03:C832 8D FC 1D STA.W $1DFC ; / Play rocket launch sound effect
$03:C835 A9 10 LDA.B #$10 ; \
$03:C837 9D 64 15 STA.W $1564,X ; / Timer [$1564] = $10
$03:C83A F6 C2 INC RAM_SpriteState,X ; State++
$03:C83C 60 RTS ; Return
;;; $C83D..C841: Table: firework burst start values ;;;
;; $03C83D: initial burst expansion rate [$151C]; $03C841: delay [$15AC] before the burst sound.
$03:C83D .db $14,$0C,$10,$15 ; Initial burst expansion rate [$151C] per rocket
$03:C841 .db $08,$10,$0C,$05 ; Burst delay [$15AC] per rocket
;;; $C845: Firework state 1: rise and slow down ;;;
;; Rises with Y speed increasing by 1 every 4th frame. At speed $FC it enters state 2 with the burst
;; parameters set and flashes the backdrop ([$156D] = 8). Draws the rocket spark.
$03:C845 BD 64 15 LDA.W $1564,X ; \
$03:C848 C9 01 CMP.B #$01 ; } Skip the sounds unless the timer [$1564] is at 1
$03:C84A D0 0F BNE $C85B ; /
$03:C84C BC 34 15 LDY.W $1534,X ; Y = rocket number
$03:C84F B9 7A C7 LDA.W FireworkSfx1,Y ; \
$03:C852 8D F9 1D STA.W $1DF9 ; / Sound $1DF9 = FireworkSfx1[Y]
$03:C855 B9 7E C7 LDA.W FireworkSfx2,Y ; \
$03:C858 8D FC 1D STA.W $1DFC ; / Sound $1DFC = FireworkSfx2[Y]
$03:C85B 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move up by the Y speed (no gravity)
$03:C85F F6 B6 INC RAM_SpriteSpeedX,X ; X speed [$B6] used as a frame counter
$03:C861 B5 B6 LDA RAM_SpriteSpeedX,X ; \
$03:C863 29 03 AND.B #$03 ; } Every 4th frame...
$03:C865 D0 02 BNE $C869 ; /
$03:C867 F6 AA INC RAM_SpriteSpeedY,X ; ...slow the rise: Y speed++
$03:C869 B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:C86B C9 FC CMP.B #$FC ; } Rise slowed to $FC? Not yet: just draw
$03:C86D D0 16 BNE $C885 ; /
$03:C86F F6 C2 INC RAM_SpriteState,X ; State++ (burst)
$03:C871 BC 34 15 LDY.W $1534,X ; \
$03:C874 B9 3D C8 LDA.W $C83D,Y ; } Burst expansion rate [$151C] = $C83D[rocket]
$03:C877 9D 1C 15 STA.W $151C,X ; /
$03:C87A B9 41 C8 LDA.W $C841,Y ; \
$03:C87D 9D AC 15 STA.W $15AC,X ; / Burst delay [$15AC] = $C841[rocket]
$03:C880 A9 08 LDA.B #$08 ; \
$03:C882 8D 6D 15 STA.W $156D ; / Backdrop flash timer [$156D] = 8
$03:C885 20 6D C9 JSR.W $C96D ; Draw the rocket spark
$03:C888 60 RTS ; Return
;;; $C889..C889: Table: firework maximum burst size ;;;
$03:C889 .db $FF,$80,$C0,$FF ; Maximum burst size [$1570] per rocket
;;; $C88D: Firework state 2: burst expansion ;;;
;; Plays the burst sound when the delay ends, expands the burst size [$1570] (twice per frame at first,
;; expansion rate slowing),
;; ends at the maximum size and goes to state 3, then draws the particles ($C9E9).
$03:C88D BD AC 15 LDA.W $15AC,X ; \
$03:C890 3A DEC A ; } Burst delay [$15AC] - 1 = 0 (reached 1)?
$03:C891 D0 0F BNE $C8A2 ; /
$03:C893 BC 34 15 LDY.W $1534,X ; \
$03:C896 B9 82 C7 LDA.W FireworkSfx3,Y ; } Sound $1DF9 = FireworkSfx3[rocket]
$03:C899 8D F9 1D STA.W $1DF9 ; /
$03:C89C B9 86 C7 LDA.W FireworkSfx4,Y ; \
$03:C89F 8D FC 1D STA.W $1DFC ; / Sound $1DFC = FireworkSfx4[rocket]
$03:C8A2 20 B1 C8 JSR.W $C8B1 ; Expand the burst
$03:C8A5 B5 C2 LDA RAM_SpriteState,X ; \
$03:C8A7 C9 02 CMP.B #$02 ; } State still 2?
$03:C8A9 D0 03 BNE $C8AE ; /
$03:C8AB 20 B1 C8 JSR.W $C8B1 ; Expand twice per frame while in this state
$03:C8AE 4C E9 C9 JMP.W $C9E9 ; Draw the burst particles ($C9E9)
$03:C8B1 BC 34 15 LDY.W $1534,X ; Y = rocket number
$03:C8B4 BD 70 15 LDA.W $1570,X ; \
$03:C8B7 18 CLC ; |
$03:C8B8 7D 1C 15 ADC.W $151C,X ; } Burst size [$1570] += expansion rate [$151C]
$03:C8BB 9D 70 15 STA.W $1570,X ; /
$03:C8BE B0 1B BCS $C8DB ; Overflowed: force the end
$03:C8C0 D9 89 C8 CMP.W $C889,Y ; \
$03:C8C3 B0 1B BCS $C8E0 ; / Reached the maximum size for this rocket: end
$03:C8C5 BD 1C 15 LDA.W $151C,X ; \
$03:C8C8 C9 02 CMP.B #$02 ; } Rate below 2: keep it at 1
$03:C8CA 90 08 BCC $C8D4 ; /
$03:C8CC 38 SEC ; \
$03:C8CD E9 01 SBC.B #$01 ; |
$03:C8CF 9D 1C 15 STA.W $151C,X ; } Rate -= 1 (expansion slows down)
$03:C8D2 B0 10 BCS $C8E4 ; /
$03:C8D4 A9 01 LDA.B #$01 ; \
$03:C8D6 9D 1C 15 STA.W $151C,X ; / Rate = 1
$03:C8D9 80 09 BRA $C8E4 ; Continue
$03:C8DB A9 FF LDA.B #$FF ; \
$03:C8DD 9D 70 15 STA.W $1570,X ; / Size = $FF
$03:C8E0 F6 C2 INC RAM_SpriteState,X ; State++ (fade out)
$03:C8E2 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:C8E4 BD 1C 15 LDA.W $151C,X ; \
$03:C8E7 29 FF AND.B #$FF ; } Y = expansion rate
$03:C8E9 A8 TAY ; /
$03:C8EA B9 F1 C8 LDA.W $C8F1,Y ; \
$03:C8ED 9D 02 16 STA.W $1602,X ; / Animation frame [$1602] = $C8F1[Y]
$03:C8F0 60 RTS ; Return
;;; $C8F1..C939: Table: firework burst frame by rate ;;;
$03:C8F1 .db $06,$05,$04,$03,$03,$03,$03,$02 ; Burst frame by expansion rate: fast = frame 0, slower rates give up to frame 6
$03:C8F9 .db $02,$02,$02,$02,$02,$02,$01,$01
$03:C901 .db $01,$00,$00,$00,$00,$00,$00,$00
$03:C909 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:C911 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:C919 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:C921 .db $03,$03,$03,$03,$03,$03,$03,$03 ; Probably unused (the rate never exceeds $15)
$03:C929 .db $03,$03,$02,$02,$02,$02,$02,$02
$03:C931 .db $02,$02,$02,$02,$02,$02,$02,$02
$03:C939 .db $02,$02,$02,$02,$02,$02,$02,$02
;;; $C941: Firework state 3: fade out and erase ;;;
;; Y speed grows every 8 frames; frame 7, 8, 9 as it speeds up; the sprite is erased at Y speed 8. Draws the
;; particles.
$03:C941 A5 13 LDA RAM_FrameCounter ; \
$03:C943 29 07 AND.B #$07 ; } Every 8th frame...
$03:C945 D0 02 BNE $C949 ; /
$03:C947 F6 AA INC RAM_SpriteSpeedY,X ; ...Y speed++ (falling faster)
$03:C949 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Move vertically
$03:C94D A9 07 LDA.B #$07 ; A = 7: frame for the fade
$03:C94F B4 AA LDY RAM_SpriteSpeedY,X ; \
$03:C951 C0 08 CPY.B #$08 ; } Y speed reached 8?
$03:C953 D0 03 BNE $C958 ; /
$03:C955 9E C8 14 STZ.W $14C8,X ; Yes: erase the sprite
$03:C958 C0 03 CPY.B #$03 ; \
$03:C95A 90 06 BCC $C962 ; / Y speed >= 3: next frame
$03:C95C 1A INC A ; Frame 8
$03:C95D C0 05 CPY.B #$05 ; \
$03:C95F 90 01 BCC $C962 ; / Y speed >= 5: next frame
$03:C961 1A INC A ; Frame 9
$03:C962 9D 02 16 STA.W $1602,X ; Animation frame [$1602] = A
$03:C965 20 E9 C9 JSR.W $C9E9 ; Draw the burst particles
$03:C968 60 RTS ; Return
;;; $C969..C969: Table: firework rocket spark tiles ;;;
$03:C969 .db $EC,$8E,$EC,$EC ; Rocket spark tile per rocket ($8E for rocket 1)
;;; $C96D: Draw firework rocket spark ;;;
;; Draws a flickering 8x8 spark at the sprite position in OAM slot 0 on every 4th frame (staggered by sprite
;; index).
;; Parameters: X: sprite index.
;; Called by:
;; $03:C885: Firework state 1: rise and slow down
$03:C96D 8A TXA ; \
$03:C96E 45 13 EOR RAM_FrameCounter ; |
$03:C970 29 03 AND.B #$03 ; } Draw only on every 4th frame (staggered by sprite index)
$03:C972 D0 44 BNE $C9B8 ; /
$03:C974 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get on-screen position
$03:C977 A0 00 LDY.B #$00 ; Y = 0: uses the first OAM slots
$03:C979 A5 00 LDA $00 ; \
$03:C97B 99 00 03 STA.W OAM_DispX,Y ; } OAM X of slots 0 and 1 = sprite X
$03:C97E 99 04 03 STA.W OAM_Tile2DispX,Y ; /
$03:C981 A5 01 LDA $01 ; \
$03:C983 99 01 03 STA.W OAM_DispY,Y ; / OAM Y of slot 0 = sprite Y
$03:C986 DA PHX ; Save sprite index
$03:C987 BD 34 15 LDA.W $1534,X ; \
$03:C98A AA TAX ; / X = rocket number
$03:C98B A5 13 LDA RAM_FrameCounter ; \
$03:C98D 4A LSR ; |
$03:C98E 4A LSR ; |
$03:C98F 29 02 AND.B #$02 ; } A = 0 or 1, toggles every 8 frames
$03:C991 4A LSR ; /
$03:C992 7D 69 C9 ADC.W $C969,X ; \
$03:C995 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $C969[X] + A
$03:C998 FA PLX ; Restore sprite index
$03:C999 A5 13 LDA RAM_FrameCounter ; \
$03:C99B 0A ASL ; |
$03:C99C 29 0E AND.B #$0E ; } [$02] = ([frame counter] * 2) & $0E: cycling palette
$03:C99E 85 02 STA $02 ; /
$03:C9A0 A5 13 LDA RAM_FrameCounter ; \
$03:C9A2 0A ASL ; |
$03:C9A3 0A ASL ; |
$03:C9A4 0A ASL ; |
$03:C9A5 0A ASL ; } A = X flip bit toggling with the frame counter
$03:C9A6 29 40 AND.B #$40 ; /
$03:C9A8 05 02 ORA $02 ; \
$03:C9AA 09 31 ORA.B #$31 ; } OAM properties = flip | palette | $31
$03:C9AC 99 03 03 STA.W OAM_Prop,Y ; /
$03:C9AF 98 TYA ; \
$03:C9B0 4A LSR ; |
$03:C9B1 4A LSR ; } Y = OAM index / 4
$03:C9B2 A8 TAY ; /
$03:C9B3 A9 00 LDA.B #$00 ; \
$03:C9B5 99 60 04 STA.W OAM_TileSize,Y ; / Tile size = 8x8
$03:C9B8 60 RTS ; Return
;;; $C9B9..C9D9: Table: firework burst particle tiles ;;;
$03:C9B9 .db $36,$35,$C7,$34,$34,$34,$34,$24 ; Burst particle tiles: 10 frames for each of 4 animation phases
$03:C9C1 .db $03,$03,$36,$35,$C7,$34,$34,$24
$03:C9C9 .db $24,$24,$24,$03,$36,$35,$C7,$34
$03:C9D1 .db $34,$34,$24,$24,$03,$24,$36,$35
$03:C9D9 .db $C7,$34,$24,$24,$24,$24,$24,$03
;;; $C9E1..C9E1: Table: firework burst jitter offsets ;;;
$03:C9E1 .db $00,$01,$01,$00,$00,$FF,$FF,$00 ; Burst particle jitter offsets: 0, 1, 1, 0, 0, -1, -1, 0
;;; $C9E9: Draw firework burst particles ;;;
;; Draws one firework burst: 64 particles in the $0200 OAM area, then 20 more in the $0300 area (84 in all).
;; Each particle position comes from a pattern table (type [$1534] 0-2 or 3+), scaled by the radius [$1570]
;; with the hardware
;; multiplier, so the burst expands. From animation frame 6 on, a small jitter makes the particles sparkle.
;; Parameters: X = sprite slot; [$1570] radius, [$1602] animation frame, [$1534] firework type. Always 8x8
;; tiles, priority 3.
;; Called by:
;; $03:C8AE: Firework state 2: burst expansion
;; $03:C965: Firework state 3: fade out and erase
$03:C9E9 8A TXA ; \
$03:C9EA 45 13 EOR RAM_FrameCounter ; } $05 = sprite slot XOR frame counter (seed that varies tile and palette)
$03:C9EC 85 05 STA $05 ; /
$03:C9EE BD 70 15 LDA.W $1570,X ; \
$03:C9F1 85 06 STA $06 ; / $06 = [$1570]: burst radius scale
$03:C9F3 BD 02 16 LDA.W $1602,X ; \
$03:C9F6 85 07 STA $07 ; / $07 = [$1602]: animation frame
$03:C9F8 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:C9FA 85 08 STA $08 ; / $08 = burst center X low
$03:C9FC B5 D8 LDA RAM_SpriteYLo,X ; \
$03:C9FE 38 SEC ; |
$03:C9FF E5 1C SBC RAM_ScreenBndryYLo ; } $09 = burst center Y relative to the screen
$03:CA01 85 09 STA $09 ; /
$03:CA03 BD 34 15 LDA.W $1534,X ; \
$03:CA06 85 0A STA $0A ; / $0A = [$1534]: firework type
$03:CA08 DA PHX ; Save sprite index
$03:CA09 A2 3F LDX.B #$3F ; X = $3F: first pass draws 64 particles (index counts down to 0)
$03:CA0B A0 00 LDY.B #$00 ; Y = 0: OAM buffer offset ($0200 area)
$03:CA0D 86 04 STX $04 ; $04 = particle index
$03:CA0F A5 0A LDA $0A ; \
$03:CA11 C9 03 CMP.B #$03 ; |
$03:CA13 BD 26 C6 LDA.W $C626,X ; } A = particle X from pattern table (type 0-2: $C626, type 3+: $C6CE)
$03:CA16 90 03 BCC $CA1B ; |
$03:CA18 BD CE C6 LDA.W $C6CE,X ; /
$03:CA1B 38 SEC ; \
$03:CA1C E9 40 SBC.B #$40 ; } $00 = X offset from burst center (table value - $40)
$03:CA1E 85 00 STA $00 ; /
$03:CA20 5A PHY ; Save OAM index
$03:CA21 A5 0A LDA $0A ; \
$03:CA23 C9 03 CMP.B #$03 ; |
$03:CA25 BD 7A C6 LDA.W $C67A,X ; } A = particle Y from pattern table (type 0-2: $C67A, type 3+: $C722)
$03:CA28 90 03 BCC $CA2D ; |
$03:CA2A BD 22 C7 LDA.W $C722,X ; /
$03:CA2D 38 SEC ; \
$03:CA2E E9 50 SBC.B #$50 ; } $01 = Y offset from burst center (table value - $50)
$03:CA30 85 01 STA $01 ; /
$03:CA32 A5 00 LDA $00 ; \
$03:CA34 10 03 BPL $CA39 ; |
$03:CA36 49 FF EOR.B #$FF ; } A = |X offset|
$03:CA38 1A INC A ; /
$03:CA39 8D 02 42 STA.W $4202 ; \
$03:CA3C A5 06 LDA $06 ; |
$03:CA3E 8D 03 42 STA.W $4203 ; |
$03:CA41 EA NOP ; } Hardware multiply: |X offset| * radius scale [$06], result in $4216/$4217
$03:CA42 EA NOP ; |
$03:CA43 EA NOP ; |
$03:CA44 EA NOP ; /
$03:CA45 AD 17 42 LDA.W $4217 ; \
$03:CA48 A4 00 LDY $00 ; |
$03:CA4A 10 03 BPL $CA4F ; |
$03:CA4C 49 FF EOR.B #$FF ; |
$03:CA4E 1A INC A ; } $02 = high byte of the product (X offset * scale / 256), sign restored from [$00]
$03:CA4F 85 02 STA $02 ; /
$03:CA51 A5 01 LDA $01 ; \
$03:CA53 10 03 BPL $CA58 ; |
$03:CA55 49 FF EOR.B #$FF ; } A = |Y offset|
$03:CA57 1A INC A ; /
$03:CA58 8D 02 42 STA.W $4202 ; \
$03:CA5B A5 06 LDA $06 ; |
$03:CA5D 8D 03 42 STA.W $4203 ; |
$03:CA60 EA NOP ; } Hardware multiply: |Y offset| * radius scale [$06]
$03:CA61 EA NOP ; |
$03:CA62 EA NOP ; |
$03:CA63 EA NOP ; /
$03:CA64 AD 17 42 LDA.W $4217 ; \
$03:CA67 A4 01 LDY $01 ; |
$03:CA69 10 03 BPL $CA6E ; |
$03:CA6B 49 FF EOR.B #$FF ; |
$03:CA6D 1A INC A ; } $03 = scaled Y offset, sign restored from [$01]
$03:CA6E 85 03 STA $03 ; /
$03:CA70 A0 00 LDY.B #$00 ; Y = 0: no sparkle jitter
$03:CA72 A5 07 LDA $07 ; \
$03:CA74 C9 06 CMP.B #$06 ; } Frames 0-5: skip the jitter
$03:CA76 90 0A BCC $CA82 ; /
$03:CA78 A5 05 LDA $05 ; \
$03:CA7A 18 CLC ; |
$03:CA7B 65 04 ADC $04 ; |
$03:CA7D 4A LSR ; |
$03:CA7E 4A LSR ; |
$03:CA7F 29 07 AND.B #$07 ; } Frame >= 6: Y = (([$05] + particle index) >> 2) & 7, index into the jitter table
$03:CA81 A8 TAY ; /
$03:CA82 B9 E1 C9 LDA.W $C9E1,Y ; A = sparkle jitter X (0,1,1,0,0,-1,-1,0)
$03:CA85 7A PLY ; Restore OAM index
$03:CA86 18 CLC ; \
$03:CA87 65 02 ADC $02 ; |
$03:CA89 18 CLC ; } OAM X = center X + scaled X offset + jitter
$03:CA8A 65 08 ADC $08 ; |
$03:CA8C 99 00 02 STA.W OAM_ExtendedDispX,Y ; /
$03:CA8F A5 03 LDA $03 ; \
$03:CA91 18 CLC ; |
$03:CA92 65 09 ADC $09 ; } OAM Y = center Y + scaled Y offset
$03:CA94 99 01 02 STA.W OAM_ExtendedDispY,Y ; /
$03:CA97 DA PHX ; Save particle index
$03:CA98 A5 05 LDA $05 ; \
$03:CA9A 29 03 AND.B #$03 ; |
$03:CA9C 85 0F STA $0F ; |
$03:CA9E 0A ASL ; |
$03:CA9F 0A ASL ; |
$03:CAA0 0A ASL ; } X = ([$05] & 3) * 10 + frame [$07]: row of 10 animation tiles
$03:CAA1 65 0F ADC $0F ; |
$03:CAA3 65 0F ADC $0F ; |
$03:CAA5 65 07 ADC $07 ; |
$03:CAA7 AA TAX ; /
$03:CAA8 BD B9 C9 LDA.W $C9B9,X ; \
$03:CAAB 99 02 02 STA.W OAM_ExtendedTile,Y ; / Tile = $C9B9[X] (sparkle animation)
$03:CAAE FA PLX ; Restore particle index
$03:CAAF A5 05 LDA $05 ; \
$03:CAB1 4A LSR ; |
$03:CAB2 EA NOP ; |
$03:CAB3 EA NOP ; |
$03:CAB4 DA PHX ; } A = [$05] / 2, XOR particle index unless type = 3: varies the palette per particle
$03:CAB5 A6 0A LDX $0A ; |
$03:CAB7 E0 03 CPX.B #$03 ; |
$03:CAB9 F0 02 BEQ $CABD ; |
$03:CABB 45 04 EOR $04 ; /
$03:CABD 29 0E AND.B #$0E ; \
$03:CABF 09 31 ORA.B #$31 ; } Properties = palette (bits 1-3) | priority 3 | page 1 ($31)
$03:CAC1 99 03 02 STA.W OAM_ExtendedProp,Y ; /
$03:CAC4 FA PLX ; Restore particle index
$03:CAC5 5A PHY ; \
$03:CAC6 98 TYA ; |
$03:CAC7 4A LSR ; |
$03:CAC8 4A LSR ; } Size bit [$0420 + slot] = 0: 8x8 sprite
$03:CAC9 A8 TAY ; |
$03:CACA A9 00 LDA.B #$00 ; |
$03:CACC 99 20 04 STA.W $0420,Y ; /
$03:CACF 7A PLY ; Restore OAM index
$03:CAD0 C8 INY ; \
$03:CAD1 C8 INY ; |
$03:CAD2 C8 INY ; } Y += 4: next OAM slot
$03:CAD3 C8 INY ; /
$03:CAD4 CA DEX ; \
$03:CAD5 30 03 BMI $CADA ; / Next particle, done when X < 0
$03:CAD7 4C 0D CA JMP.W $CA0D ; Loop
$03:CADA A2 53 LDX.B #$53 ; X = $53: second pass draws 20 particles ($53 down to $40); Y has wrapped to 0 ($0300 area)
$03:CADC 86 04 STX $04 ; $04 = particle index
$03:CADE A5 0A LDA $0A ; \
$03:CAE0 C9 03 CMP.B #$03 ; |
$03:CAE2 BD 26 C6 LDA.W $C626,X ; } A = particle X from pattern table (type 0-2: $C626, type 3+: $C6CE)
$03:CAE5 90 03 BCC $CAEA ; |
$03:CAE7 BD CE C6 LDA.W $C6CE,X ; /
$03:CAEA 38 SEC ; \
$03:CAEB E9 40 SBC.B #$40 ; } $00 = X offset from burst center (table value - $40)
$03:CAED 85 00 STA $00 ; /
$03:CAEF A5 0A LDA $0A ; \
$03:CAF1 C9 03 CMP.B #$03 ; |
$03:CAF3 BD 7A C6 LDA.W $C67A,X ; } A = particle Y from pattern table (type 0-2: $C67A, type 3+: $C722)
$03:CAF6 90 03 BCC $CAFB ; |
$03:CAF8 BD 22 C7 LDA.W $C722,X ; /
$03:CAFB 38 SEC ; \
$03:CAFC E9 50 SBC.B #$50 ; } $01 = Y offset from burst center (table value - $50)
$03:CAFE 85 01 STA $01 ; /
$03:CB00 5A PHY ; Save OAM index
$03:CB01 A5 00 LDA $00 ; \
$03:CB03 10 03 BPL $CB08 ; |
$03:CB05 49 FF EOR.B #$FF ; } A = |X offset|
$03:CB07 1A INC A ; /
$03:CB08 8D 02 42 STA.W $4202 ; \
$03:CB0B A5 06 LDA $06 ; |
$03:CB0D 8D 03 42 STA.W $4203 ; |
$03:CB10 EA NOP ; } Hardware multiply: |X offset| * radius scale [$06]
$03:CB11 EA NOP ; |
$03:CB12 EA NOP ; |
$03:CB13 EA NOP ; /
$03:CB14 AD 17 42 LDA.W $4217 ; \
$03:CB17 A4 00 LDY $00 ; |
$03:CB19 10 03 BPL $CB1E ; |
$03:CB1B 49 FF EOR.B #$FF ; |
$03:CB1D 1A INC A ; } $02 = high byte of the product, sign restored from [$00]
$03:CB1E 85 02 STA $02 ; /
$03:CB20 A5 01 LDA $01 ; \
$03:CB22 10 03 BPL $CB27 ; |
$03:CB24 49 FF EOR.B #$FF ; } A = |Y offset|
$03:CB26 1A INC A ; /
$03:CB27 8D 02 42 STA.W $4202 ; \
$03:CB2A A5 06 LDA $06 ; |
$03:CB2C 8D 03 42 STA.W $4203 ; |
$03:CB2F EA NOP ; } Hardware multiply: |Y offset| * radius scale [$06]
$03:CB30 EA NOP ; |
$03:CB31 EA NOP ; |
$03:CB32 EA NOP ; /
$03:CB33 AD 17 42 LDA.W $4217 ; \
$03:CB36 A4 01 LDY $01 ; |
$03:CB38 10 03 BPL $CB3D ; |
$03:CB3A 49 FF EOR.B #$FF ; |
$03:CB3C 1A INC A ; } $03 = scaled Y offset, sign restored from [$01]
$03:CB3D 85 03 STA $03 ; /
$03:CB3F A0 00 LDY.B #$00 ; Y = 0: no sparkle jitter
$03:CB41 A5 07 LDA $07 ; \
$03:CB43 C9 06 CMP.B #$06 ; } Frames 0-5: skip the jitter
$03:CB45 90 0A BCC $CB51 ; /
$03:CB47 A5 05 LDA $05 ; \
$03:CB49 18 CLC ; |
$03:CB4A 65 04 ADC $04 ; |
$03:CB4C 4A LSR ; |
$03:CB4D 4A LSR ; |
$03:CB4E 29 07 AND.B #$07 ; } Frame >= 6: Y = (([$05] + particle index) >> 2) & 7, index into the jitter table
$03:CB50 A8 TAY ; /
$03:CB51 B9 E1 C9 LDA.W $C9E1,Y ; A = sparkle jitter X (0,1,1,0,0,-1,-1,0)
$03:CB54 7A PLY ; Restore OAM index
$03:CB55 18 CLC ; \
$03:CB56 65 02 ADC $02 ; |
$03:CB58 18 CLC ; } OAM X = center X + scaled X offset + jitter
$03:CB59 65 08 ADC $08 ; |
$03:CB5B 99 00 03 STA.W OAM_DispX,Y ; /
$03:CB5E A5 03 LDA $03 ; \
$03:CB60 18 CLC ; |
$03:CB61 65 09 ADC $09 ; } OAM Y = center Y + scaled Y offset
$03:CB63 99 01 03 STA.W OAM_DispY,Y ; /
$03:CB66 DA PHX ; Save particle index
$03:CB67 A5 05 LDA $05 ; \
$03:CB69 29 03 AND.B #$03 ; |
$03:CB6B 85 0F STA $0F ; |
$03:CB6D 0A ASL ; |
$03:CB6E 0A ASL ; |
$03:CB6F 0A ASL ; } X = ([$05] & 3) * 10 + frame [$07]: row of 10 animation tiles
$03:CB70 65 0F ADC $0F ; |
$03:CB72 65 0F ADC $0F ; |
$03:CB74 65 07 ADC $07 ; |
$03:CB76 AA TAX ; /
$03:CB77 BD B9 C9 LDA.W $C9B9,X ; \
$03:CB7A 99 02 03 STA.W OAM_Tile,Y ; / Tile = $C9B9[X] (sparkle animation)
$03:CB7D FA PLX ; Restore particle index
$03:CB7E A5 05 LDA $05 ; \
$03:CB80 4A LSR ; |
$03:CB81 EA NOP ; |
$03:CB82 EA NOP ; |
$03:CB83 DA PHX ; } A = [$05] / 2, XOR particle index unless type = 3: varies the palette per particle
$03:CB84 A6 0A LDX $0A ; |
$03:CB86 E0 03 CPX.B #$03 ; |
$03:CB88 F0 02 BEQ $CB8C ; |
$03:CB8A 45 04 EOR $04 ; /
$03:CB8C 29 0E AND.B #$0E ; \
$03:CB8E 09 31 ORA.B #$31 ; } Properties = palette (bits 1-3) | priority 3 | page 1 ($31)
$03:CB90 99 03 03 STA.W OAM_Prop,Y ; /
$03:CB93 FA PLX ; Restore particle index
$03:CB94 5A PHY ; \
$03:CB95 98 TYA ; |
$03:CB96 4A LSR ; |
$03:CB97 4A LSR ; } Size bit [$0460 + slot] = 0: 8x8 sprite
$03:CB98 A8 TAY ; |
$03:CB99 A9 00 LDA.B #$00 ; |
$03:CB9B 99 60 04 STA.W OAM_TileSize,Y ; /
$03:CB9E 7A PLY ; Restore OAM index
$03:CB9F C8 INY ; \
$03:CBA0 C8 INY ; |
$03:CBA1 C8 INY ; } Y += 4: next OAM slot
$03:CBA2 C8 INY ; /
$03:CBA3 CA DEX ; \
$03:CBA4 E0 3F CPX.B #$3F ; / Next particle
$03:CBA6 F0 03 BEQ $CBAB ; Done when X = $3F (20 particles drawn)
$03:CBA8 4C DC CA JMP.W $CADC ; Loop
$03:CBAB FA PLX ; Restore sprite index
$03:CBAC 60 RTS ; Return
;;; $CBAD: Table: football spawn X offset (ChuckSprGenDispX) ;;;
$03:CBAD .db $14,$EC ; X offset from Chuck: $14 facing right, $EC facing left
;;; $CBAF: Table: football spawn X high offset (ChuckSprGenSpeedHi) ;;;
$03:CBAF .db $00,$FF ; X offset high byte: $00 / $FF
;;; $CBB1: Football spawn and Koopa Kid main (ChuckSprGenSpeedLo) ;;;
;; $03CBB1: football X speed table. $03CBB3: Chuck throws a football (called from bank 02): spawns sprite $1B
;; ahead of the Chuck,
;; moving horizontally at $18/$E8 and upward at $E0. Returns without spawning if there is no free slot.
;; $03CC09: long-call wrapper for the Pipe Koopa Kid sprite main routine (set from bank 01). $03CC14 draws the
;; sprite and, when
;; status = 8 and sprites are not locked, runs the state routine for [$151C].
$03:CBB1 .db $18,$E8 ; Football X speed: $18 right, $E8 left
$03:CBB3 22 E4 A9 02 JSL.L FindFreeSprSlot ; \
$03:CBB7 30 4F BMI $CC08 ; / Find a free sprite slot (Y); return if none
$03:CBB9 A9 1B LDA.B #$1B ; \
$03:CBBB 99 9E 00 STA.W RAM_SpriteNum,Y ; / Sprite number = $1B (Football)
$03:CBBE DA PHX ; \
$03:CBBF BB TYX ; |
$03:CBC0 22 D2 F7 07 JSL.L InitSpriteTables ; } Initialize the new sprite's tables (X = new slot meanwhile)
$03:CBC4 FA PLX ; /
$03:CBC5 A9 08 LDA.B #$08 ; \
$03:CBC7 99 C8 14 STA.W $14C8,Y ; / Sprite status = 8 (normal)
$03:CBCA B5 D8 LDA RAM_SpriteYLo,X ; \
$03:CBCC 99 D8 00 STA.W RAM_SpriteYLo,Y ; / New sprite Y low = spawner Y low
$03:CBCF BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:CBD2 99 D4 14 STA.W RAM_SpriteYHi,Y ; / New sprite Y high = spawner Y high
$03:CBD5 B5 E4 LDA RAM_SpriteXLo,X ; \
$03:CBD7 85 01 STA $01 ; / $01 = spawner X low
$03:CBD9 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:CBDC 85 00 STA $00 ; / $00 = spawner X high
$03:CBDE DA PHX ; \
$03:CBDF BD 7C 15 LDA.W RAM_SpriteDir,X ; } X = spawner facing direction (0 right, 1 left)
$03:CBE2 AA TAX ; /
$03:CBE3 A5 01 LDA $01 ; \
$03:CBE5 18 CLC ; |
$03:CBE6 7F AD CB 03 ADC.L ChuckSprGenDispX,X ; } New X low = spawner X low + offset by direction
$03:CBEA 99 E4 00 STA.W RAM_SpriteXLo,Y ; /
$03:CBED A5 00 LDA $00 ; \
$03:CBEF 7F AF CB 03 ADC.L ChuckSprGenSpeedHi,X ; } New X high = spawner X high + $00/$FF (carry)
$03:CBF3 99 E0 14 STA.W RAM_SpriteXHi,Y ; /
$03:CBF6 BF B1 CB 03 LDA.L ChuckSprGenSpeedLo,X ; \
$03:CBFA 99 B6 00 STA.W RAM_SpriteSpeedX,Y ; / New X speed = $18 / $E8 by direction
$03:CBFD A9 E0 LDA.B #$E0 ; \
$03:CBFF 99 AA 00 STA.W RAM_SpriteSpeedY,Y ; / New Y speed = $E0 (thrown upward)
$03:CC02 A9 10 LDA.B #$10 ; \
$03:CC04 99 40 15 STA.W $1540,Y ; / New [$1540] = $10 (sprite timer)
$03:CC07 FA PLX ; Restore spawner index
$03:CC08 6B RTL ; Return
$03:CC09 8B PHB ; \
$03:CC0A 4B PHK ; } Data bank = program bank (old bank saved)
$03:CC0B AB PLB ; /
$03:CC0C 9E 62 16 STZ.W RAM_Tweaker1662,X ; Clear sprite tweaker byte [$1662]
$03:CC0F 20 14 CC JSR.W $CC14 ; Draw and run the sprite ($CC14)
$03:CC12 AB PLB ; Restore the data bank
$03:CC13 6B RTL ; Return long
$03:CC14 20 84 D4 JSR.W $D484 ; Draw the sprite ($D484)
$03:CC17 BD C8 14 LDA.W $14C8,X ; \
$03:CC1A C9 08 CMP.B #$08 ; } Return unless sprite status = 8 (normal)
$03:CC1C D0 19 BNE $CC37 ; /
$03:CC1E A5 9D LDA RAM_SpritesLocked ; \
$03:CC20 D0 15 BNE $CC37 ; / Return if sprites are locked
$03:CC22 BD 1C 15 LDA.W $151C,X ; \
$03:CC25 22 DF 86 00 JSL.L ExecutePtr ; / Run the state routine for [$151C]
;;; $CC29: Pointer table: Pipe Koopa Kid states (PipeKoopaPtrs) ;;;
;; Indexed by [$151C]: 0 pick pipe and timing, 1 rise, 2 peek out (can be stomped), 3 sink, 4 stomped, 5 fall,
;; 6 landed (ends the
;; level). Hedge: the sprite looks like a Koopa Kid (number $29) peeking from pipes; Mario stomps it three
;; times.
$03:CC29 8A CC .dw $CC8A ; State $00 - 0 - Pick pipe and timing, spawn helpers
$03:CC2B 21 CD .dw $CD21 ; State $01 - 1 - Rise out of the pipe
$03:CC2D C7 CD .dw $CDC7 ; State $02 - 2 - Peek out, can be stomped
$03:CC2F EF CD .dw $CDEF ; State $03 - 3 - Sink back into the pipe
$03:CC31 0E CE .dw $CE0E ; State $04 - 4 - Stomped, recoil
$03:CC33 5A CE .dw $CE5A ; State $05 - 5 - Fall (after third stomp)
$03:CC35 89 CE .dw $CE89 ; State $06 - 6 - Landed, end the level
$03:CC37 60 RTS ; Return
;;; $CC38..CC50: Data: pipe positions and rise timers ;;;
$03:CC38 .db $18,$38,$58,$78,$98,$B8,$D8,$78 ; Pipe X positions (index 0-6; seventh entry $78 for the extra index 7)
$03:CC40 .db $40,$50,$50,$40,$30,$40,$50,$40 ; Pipe Y positions (index 0-6)
$03:CC48 .db $50,$4A,$50,$4A,$4A,$40,$4A,$48 ; Rise timer by [$1528] (0-8)
$03:CC50 .db $4A ; Rise timer for [$1528] = 8 (continued)
;;; $CC51..CC59: Data: initial animation frames ;;;
$03:CC51 .db $02,$04,$06,$08,$0B,$0C,$0E,$10 ; Initial animation frame by [$1528] (0-7)
$03:CC59 .db $13 ; Initial animation frame for [$1528] = 8
;;; $CC5A..CC82: Table: pipe number by random value ;;;
;; Indexed by [$160E] (random 0-15) | [$1570] (0, $10 or $20): gives the pipe number 0-6 for each of the three
;; Koopa Kid sprites.
$03:CC5A .db $00,$01,$02,$03,$04,$05,$06,$00 ; Pipe number 0-6 by ([$160E] | part offset): entries 0-7
$03:CC62 .db $01,$02,$03,$04,$05,$06,$00,$01 ; Pipe number 0-6 by ([$160E] | part offset): entries 8-15
$03:CC6A .db $02,$03,$04,$05,$06,$00,$01,$02 ; Pipe number 0-6 by ([$160E] | part offset): entries 16-23
$03:CC72 .db $03,$04,$05,$06,$00,$01,$02,$03 ; Pipe number 0-6 by ([$160E] | part offset): entries 24-31
$03:CC7A .db $04,$05,$06,$00,$01,$02,$03,$04 ; Pipe number 0-6 by ([$160E] | part offset): entries 32-39
$03:CC82 .db $05,$06,$00,$01,$02,$03,$04,$05 ; Pipe number 0-6 by ([$160E] | part offset): entries 40-47
;;; $CC8A: Koopa Kid state 0: choose pipe ;;;
;; Waits for [$1540]. Picks (main sprite) a random seed, puts the sprite on its pipe, spawns the two helper
;; sprites, chooses a
;; rise timer and initial frame, and moves on to state 1.
$03:CC8A BD 40 15 LDA.W $1540,X ; \
$03:CC8D D0 50 BNE $CCDF ; / Wait while the timer [$1540] runs; then return
$03:CC8F BD 70 15 LDA.W $1570,X ; \
$03:CC92 D0 09 BNE $CC9D ; / Skip the random pick for helper sprites ([$1570] != 0)
$03:CC94 22 F9 AC 01 JSL.L GetRand ; \
$03:CC98 29 0F AND.B #$0F ; } [$160E] = random 0-15 (shared pipe-order seed)
$03:CC9A 9D 0E 16 STA.W $160E,X ; /
$03:CC9D BD 0E 16 LDA.W $160E,X ; \
$03:CCA0 1D 70 15 ORA.W $1570,X ; |
$03:CCA3 A8 TAY ; } Y = pipe number 0-6 from $CC5A[[$160E] | [$1570]]
$03:CCA4 B9 5A CC LDA.W $CC5A,Y ; /
$03:CCA7 A8 TAY ; Y = pipe number
$03:CCA8 B9 38 CC LDA.W $CC38,Y ; \
$03:CCAB 95 E4 STA RAM_SpriteXLo,X ; / X position = $CC38[pipe number]
$03:CCAD B5 C2 LDA RAM_SpriteState,X ; \
$03:CCAF C9 06 CMP.B #$06 ; } A = $CC40[pipe number]: pipe Y position
$03:CCB1 B9 40 CC LDA.W $CC40,Y ; /
$03:CCB4 90 02 BCC $CCB8 ; [$C2] < 6: keep the table value
$03:CCB6 A9 50 LDA.B #$50 ; Otherwise Y = $50
$03:CCB8 95 D8 STA RAM_SpriteYLo,X ; Set Y position
$03:CCBA A9 08 LDA.B #$08 ; A = 8: [$1528] value for helper sprites
$03:CCBC BC 70 15 LDY.W $1570,X ; \
$03:CCBF D0 0B BNE $CCCC ; / Helper sprites ([$1570] != 0) keep A = 8
$03:CCC1 20 E2 CC JSR.W $CCE2 ; Spawn the two helper Koopa Kid sprites ($CCE2)
$03:CCC4 22 F9 AC 01 JSL.L GetRand ; \
$03:CCC8 4A LSR ; |
$03:CCC9 4A LSR ; } A = random 0-7
$03:CCCA 29 07 AND.B #$07 ; /
$03:CCCC 9D 28 15 STA.W $1528,X ; [$1528] = table index (0-8)
$03:CCCF A8 TAY ; \
$03:CCD0 B9 48 CC LDA.W $CC48,Y ; } [$1540] = $CC48[index]: time to rise
$03:CCD3 9D 40 15 STA.W $1540,X ; /
$03:CCD6 FE 1C 15 INC.W $151C,X ; State + 1 (rise out of the pipe)
$03:CCD9 B9 51 CC LDA.W $CC51,Y ; \
$03:CCDC 9D 02 16 STA.W $1602,X ; / [$1602] = $CC51[index]: initial animation frame
$03:CCDF 60 RTS ; Return
;;; $CCE0..CCE0: Data: helper part offsets ;;;
$03:CCE0 .db $10,$20 ; [$1570] part offsets for the two helper sprites: $10, $20
;;; $CCE2: Spawn helper Koopa Kids; state 1 rise ;;;
;; $03CCE2: spawns two extra sprites ($29) at the same position, with [$1570] = $10 and $20 (copies [$C2],
;; [$160E] and position).
;; $03CD21 (state 1): rises with Y speed $F8; when [$1540] expires sets it to $40 and goes to state 2.
;; Called by:
;; $03:CCC1: Koopa Kid state 0: choose pipe
$03:CCE2 A0 01 LDY.B #$01 ; Y = 1: first helper
$03:CCE4 20 E8 CC JSR.W $CCE8 ; Spawn helper Y = 1; then falls into the next copy with Y = 0
$03:CCE7 88 DEY ; Y = 0: second helper
$03:CCE8 A9 08 LDA.B #$08 ; \
$03:CCEA 99 C8 14 STA.W $14C8,Y ; / Sprite status = 8 (normal)
$03:CCED A9 29 LDA.B #$29 ; \
$03:CCEF 99 9E 00 STA.W RAM_SpriteNum,Y ; / Sprite number = $29 (Koopa Kid)
$03:CCF2 DA PHX ; \
$03:CCF3 BB TYX ; |
$03:CCF4 22 D2 F7 07 JSL.L InitSpriteTables ; } Initialize the new sprite's tables
$03:CCF8 FA PLX ; /
$03:CCF9 B9 E0 CC LDA.W $CCE0,Y ; \
$03:CCFC 99 70 15 STA.W $1570,Y ; / [$1570,Y] = $CCE0[Y]: part offset ($10 or $20)
$03:CCFF B5 C2 LDA RAM_SpriteState,X ; \
$03:CD01 99 C2 00 STA.W RAM_SpriteState,Y ; / Copy [$C2] (state value used for Y position) from the main sprite
$03:CD04 BD 0E 16 LDA.W $160E,X ; \
$03:CD07 99 0E 16 STA.W $160E,Y ; / Copy [$160E] (pipe seed) from the main sprite
$03:CD0A B5 E4 LDA RAM_SpriteXLo,X ; \
$03:CD0C 99 E4 00 STA.W RAM_SpriteXLo,Y ; / Copy X low
$03:CD0F BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:CD12 99 E0 14 STA.W RAM_SpriteXHi,Y ; / Copy X high
$03:CD15 B5 D8 LDA RAM_SpriteYLo,X ; \
$03:CD17 99 D8 00 STA.W RAM_SpriteYLo,Y ; / Copy Y low
$03:CD1A BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:CD1D 99 D4 14 STA.W RAM_SpriteYHi,Y ; / Copy Y high
$03:CD20 60 RTS ; Return
$03:CD21 BD 40 15 LDA.W $1540,X ; \
$03:CD24 D0 08 BNE $CD2E ; / Timer [$1540] running: keep rising
$03:CD26 A9 40 LDA.B #$40 ; \
$03:CD28 9D 40 15 STA.W $1540,X ; } Timer expired: [$1540] = $40, state + 1
$03:CD2B FE 1C 15 INC.W $151C,X ; /
$03:CD2E A9 F8 LDA.B #$F8 ; \
$03:CD30 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $F8 (rise out of the pipe)
$03:CD32 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:CD36 60 RTS ; Return
;;; $CD37..CDBF: Table: Koopa Kid peek animation frames ;;;
;; Indexed by [$1528] * 16 + [$1540] / 4; gives the animation frame [$1602] while peeking out of the pipe.
$03:CD37 .db $02,$02,$02,$02,$03,$03,$03,$03 ; [$1528] = 0, [$1540]/4 = 0-7
$03:CD3F .db $03,$03,$03,$03,$02,$02,$02,$02 ; [$1528] = 0, [$1540]/4 = 8-15
$03:CD47 .db $04,$04,$04,$04,$05,$05,$04,$05 ; [$1528] = 1, [$1540]/4 = 0-7
$03:CD4F .db $05,$04,$05,$05,$04,$04,$04,$04 ; [$1528] = 1, [$1540]/4 = 8-15
$03:CD57 .db $06,$06,$06,$06,$07,$07,$07,$07 ; [$1528] = 2, [$1540]/4 = 0-7
$03:CD5F .db $07,$07,$07,$07,$06,$06,$06,$06 ; [$1528] = 2, [$1540]/4 = 8-15
$03:CD67 .db $08,$08,$08,$08,$08,$09,$09,$08 ; [$1528] = 3, [$1540]/4 = 0-7
$03:CD6F .db $08,$09,$09,$08,$08,$08,$08,$08 ; [$1528] = 3, [$1540]/4 = 8-15
$03:CD77 .db $0B,$0B,$0B,$0B,$0B,$0A,$0B,$0A ; [$1528] = 4, [$1540]/4 = 0-7
$03:CD7F .db $0B,$0A,$0B,$0A,$0B,$0B,$0B,$0B ; [$1528] = 4, [$1540]/4 = 8-15
$03:CD87 .db $0C,$0C,$0C,$0C,$0D,$0C,$0D,$0C ; [$1528] = 5, [$1540]/4 = 0-7
$03:CD8F .db $0D,$0C,$0D,$0C,$0D,$0D,$0D,$0D ; [$1528] = 5, [$1540]/4 = 8-15
$03:CD97 .db $0E,$0E,$0E,$0E,$0E,$0F,$0E,$0F ; [$1528] = 6, [$1540]/4 = 0-7
$03:CD9F .db $0E,$0F,$0E,$0F,$0E,$0E,$0E,$0E ; [$1528] = 6, [$1540]/4 = 8-15
$03:CDA7 .db $10,$10,$10,$10,$11,$12,$11,$10 ; [$1528] = 7, [$1540]/4 = 0-7
$03:CDAF .db $11,$12,$11,$10,$11,$11,$11,$11 ; [$1528] = 7, [$1540]/4 = 8-15
$03:CDB7 .db $13,$13,$13,$13,$13,$13,$13,$13 ; [$1528] = 8, [$1540]/4 = 0-7
$03:CDBF .db $13,$13,$13,$13,$13,$13,$13,$13 ; [$1528] = 8, [$1540]/4 = 8-15
;;; $CDC7: Koopa Kid states 2-4: peek, sink, stomped ;;;
;; State 2: checks Mario contact and animates from $CD37; when the timer ends goes to state 3.
;; State 3: sinks at Y speed $10; helpers erase themselves, the main sprite returns to state 0.
;; State 4 (after a stomp): flickers or plays the recoil frames; after the third stomp ([$1534] = 3) goes to
;; state 5, otherwise sinks.
$03:CDC7 20 A7 CE JSR.W $CEA7 ; Handle Mario contact ($CEA7)
$03:CDCA BD 40 15 LDA.W $1540,X ; \
$03:CDCD D0 0B BNE $CDDA ; / Timer [$1540] still running: animate
$03:CDCF A9 24 LDA.B #$24 ; \
$03:CDD1 9D 40 15 STA.W $1540,X ; / Timer = $24
$03:CDD4 A9 03 LDA.B #$03 ; \
$03:CDD6 9D 1C 15 STA.W $151C,X ; / State = 3 (sink back)
$03:CDD9 60 RTS ; Return
$03:CDDA 4A LSR ; \
$03:CDDB 4A LSR ; } $00 = [$1540] / 4
$03:CDDC 85 00 STA $00 ; /
$03:CDDE BD 28 15 LDA.W $1528,X ; \
$03:CDE1 0A ASL ; |
$03:CDE2 0A ASL ; |
$03:CDE3 0A ASL ; |
$03:CDE4 0A ASL ; } A = [$1528] * 16 | [$00]
$03:CDE5 05 00 ORA $00 ; /
$03:CDE7 A8 TAY ; Y = index into $CD37
$03:CDE8 B9 37 CD LDA.W $CD37,Y ; \
$03:CDEB 9D 02 16 STA.W $1602,X ; / [$1602] = $CD37[Y]: animation frame
$03:CDEE 60 RTS ; Return
$03:CDEF BD 40 15 LDA.W $1540,X ; \
$03:CDF2 D0 11 BNE $CE05 ; / Timer [$1540] running: keep sinking
$03:CDF4 BD 70 15 LDA.W $1570,X ; \
$03:CDF7 F0 04 BEQ $CDFD ; / Main sprite: go to CDFD
$03:CDF9 9E C8 14 STZ.W $14C8,X ; Helper sprite: erase it (status 0)
$03:CDFC 60 RTS ; Return
$03:CDFD 9E 1C 15 STZ.W $151C,X ; State = 0 (main sprite picks a new pipe)
$03:CE00 A9 30 LDA.B #$30 ; \
$03:CE02 9D 40 15 STA.W $1540,X ; / Timer = $30 (wait before reappearing)
$03:CE05 A9 10 LDA.B #$10 ; \
$03:CE07 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = $10 (sink into the pipe)
$03:CE09 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:CE0D 60 RTS ; Return
$03:CE0E BD 40 15 LDA.W $1540,X ; \
$03:CE11 D0 17 BNE $CE2A ; / Timer [$1540] running: animate
$03:CE13 FE 34 15 INC.W $1534,X ; Stomp count [$1534] + 1
$03:CE16 BD 34 15 LDA.W $1534,X ; \
$03:CE19 C9 03 CMP.B #$03 ; } Not the third stomp: go back to state 3 via $CDCF
$03:CE1B D0 B2 BNE $CDCF ; /
$03:CE1D A9 05 LDA.B #$05 ; \
$03:CE1F 9D 1C 15 STA.W $151C,X ; / Third stomp: state = 5 (fall)
$03:CE22 74 AA STZ RAM_SpriteSpeedY,X ; Y speed = 0
$03:CE24 A9 23 LDA.B #$23 ; \
$03:CE26 8D F9 1D STA.W $1DF9 ; / Play sound effect $23
$03:CE29 60 RTS ; Return
$03:CE2A BC 70 15 LDY.W $1570,X ; \
$03:CE2D D0 13 BNE $CE42 ; / Y = [$1570]; helper sprites branch to CE42
$03:CE2F C9 24 CMP.B #$24 ; \
$03:CE31 D0 05 BNE $CE38 ; / Main sprite: timer = $24?
$03:CE33 A0 29 LDY.B #$29 ; \
$03:CE35 8C FC 1D STY.W $1DFC ; / Play sound effect $29 (once)
$03:CE38 A5 14 LDA RAM_FrameCounterB ; \
$03:CE3A 4A LSR ; |
$03:CE3B 4A LSR ; |
$03:CE3C 29 01 AND.B #$01 ; } [$1602] = ([$14] / 4) & 1: flicker between two frames
$03:CE3E 9D 02 16 STA.W $1602,X ; /
$03:CE41 60 RTS ; Return
$03:CE42 C9 10 CMP.B #$10 ; \
$03:CE44 D0 05 BNE $CE4B ; / Helper: timer = $10?
$03:CE46 A0 2A LDY.B #$2A ; \
$03:CE48 8C FC 1D STY.W $1DFC ; / Play sound effect $2A (once)
$03:CE4B 4A LSR ; \
$03:CE4C 4A LSR ; |
$03:CE4D 4A LSR ; } Y = timer / 8
$03:CE4E A8 TAY ; /
$03:CE4F B9 56 CE LDA.W $CE56,Y ; \
$03:CE52 9D 02 16 STA.W $1602,X ; / [$1602] = $CE56[Y]: recoil animation frame
$03:CE55 60 RTS ; Return
;;; $CE56..CE56: Data: recoil animation frames ;;;
$03:CE56 .db $16,$16,$15,$14 ; Helper recoil animation frames by timer / 8
;;; $CE5A: Koopa Kid states 5-6 and Mario contact ;;;
;; State 5: falls (Y speed + 3 up to $40); on reaching Y >= $85 in the lower screen goes to state 6 with a $80
;; timer and impact effect.
;; State 6: sinks at Y speed 4; when the timer ends erases the sprite, increments [$13C6], sets end-of-level
;; timer [$1493] = $FF and music $0B.
;; $03CEA7: Mario contact: falling stomps score points, bounce Mario and put the sprite in state 4; the second
;; stomp of the main sprite
;; kills the other sprites; otherwise Mario is hurt.
$03:CE5A 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:CE5E B5 AA LDA RAM_SpriteSpeedY,X ; \
$03:CE60 C9 40 CMP.B #$40 ; } Y speed < $40: accelerate
$03:CE62 10 05 BPL $CE69 ; /
$03:CE64 18 CLC ; \
$03:CE65 69 03 ADC.B #$03 ; } Y speed += 3 (fall)
$03:CE67 95 AA STA RAM_SpriteSpeedY,X ; /
$03:CE69 BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:CE6C F0 19 BEQ $CE87 ; / Y high = 0: still above the lower screen, skip
$03:CE6E B5 D8 LDA RAM_SpriteYLo,X ; \
$03:CE70 C9 85 CMP.B #$85 ; } Y low < $85: not landed yet, skip
$03:CE72 90 13 BCC $CE87 ; /
$03:CE74 A9 06 LDA.B #$06 ; \
$03:CE76 9D 1C 15 STA.W $151C,X ; / State = 6 (landed)
$03:CE79 A9 80 LDA.B #$80 ; \
$03:CE7B 9D 40 15 STA.W $1540,X ; / Timer = $80
$03:CE7E A9 20 LDA.B #$20 ; \
$03:CE80 8D FC 1D STA.W $1DFC ; / Play sound effect $20 (impact)
$03:CE83 22 28 85 02 JSL.L $8528 ; Spawn impact effect ($8528)
$03:CE87 80 A6 BRA $CE2F ; Join the flicker animation ($CE2F)
$03:CE89 BD 40 15 LDA.W $1540,X ; \
$03:CE8C D0 10 BNE $CE9E ; / Wait while the timer [$1540] runs
$03:CE8E 9E C8 14 STZ.W $14C8,X ; Erase the sprite (status 0)
$03:CE91 EE C6 13 INC.W $13C6 ; [$13C6]++ (boss defeated/level goal flag)
$03:CE94 A9 FF LDA.B #$FF ; \
$03:CE96 8D 93 14 STA.W $1493 ; / [$1493] = $FF (end-of-level timer)
$03:CE99 A9 0B LDA.B #$0B ; \
$03:CE9B 8D FB 1D STA.W $1DFB ; / Change music to $0B
$03:CE9E A9 04 LDA.B #$04 ; \
$03:CEA0 95 AA STA RAM_SpriteSpeedY,X ; / Y speed = 4
$03:CEA2 22 1A 80 01 JSL.L UpdateYPosNoGrvty ; Apply Y speed (no gravity)
$03:CEA6 60 RTS ; Return
$03:CEA7 22 DC A7 01 JSL.L MarioSprInteract ; Check Mario/sprite contact (carry set if touching)
$03:CEAB 90 44 BCC $CEF1 ; No contact: return
$03:CEAD A5 7D LDA RAM_MarioSpeedY ; \
$03:CEAF C9 10 CMP.B #$10 ; } Mario Y speed < $10 (signed): not stomping, Mario is hurt
$03:CEB1 30 3A BMI $CEED ; /
$03:CEB3 22 99 AB 01 JSL.L DisplayContactGfx ; Show contact stars
$03:CEB7 A9 02 LDA.B #$02 ; \
$03:CEB9 22 E5 AC 02 JSL.L GivePoints ; / Give points (score index 2)
$03:CEBD 22 33 AA 01 JSL.L BoostMarioSpeed ; Bounce Mario upward
$03:CEC1 A9 02 LDA.B #$02 ; \
$03:CEC3 8D F9 1D STA.W $1DF9 ; / Play sound effect $02
$03:CEC6 BD 70 15 LDA.W $1570,X ; \
$03:CEC9 D0 10 BNE $CEDB ; / Helper sprite: skip the main-sprite effects
$03:CECB A9 28 LDA.B #$28 ; \
$03:CECD 8D FC 1D STA.W $1DFC ; / Play sound effect $28
$03:CED0 BD 34 15 LDA.W $1534,X ; \
$03:CED3 C9 02 CMP.B #$02 ; } If [$1534] = 2 (second stomp), kill the other sprites below
$03:CED5 D0 04 BNE $CEDB ; /
$03:CED7 22 C8 A6 03 JSL.L KillMostSprites ; Kill most sprites on screen
$03:CEDB A9 04 LDA.B #$04 ; \
$03:CEDD 9D 1C 15 STA.W $151C,X ; / State = 4 (stomped)
$03:CEE0 A9 50 LDA.B #$50 ; \
$03:CEE2 BC 70 15 LDY.W $1570,X ; |
$03:CEE5 F0 02 BEQ $CEE9 ; |
$03:CEE7 A9 1F LDA.B #$1F ; } Timer = $50 for the main sprite, $1F for helpers
$03:CEE9 9D 40 15 STA.W $1540,X ; /
$03:CEEC 60 RTS ; Return
$03:CEED 22 B7 F5 00 JSL.L HurtMario ; Hurt Mario
$03:CEF1 60 RTS ; Return
;;; $CEF2..CF7A: Table: Koopa Kid X offsets ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:CEF2 .db $F8,$08,$F8,$08,$00,$00,$F8,$08 ; X offsets: bytes $00-$07 (frames 0-1)
$03:CEFA .db $F8,$08,$00,$00,$F8,$00,$00,$00 ; X offsets: bytes $08-$0F (frames 1-2)
$03:CF02 .db $00,$00,$FB,$00,$FB,$03,$00,$00 ; X offsets: bytes $10-$17 (frames 2-3)
$03:CF0A .db $F8,$08,$00,$00,$08,$00,$F8,$08 ; X offsets: bytes $18-$1F (frames 4-5)
$03:CF12 .db $00,$00,$00,$00,$F8,$00,$00,$00 ; X offsets: bytes $20-$27 (frames 5-6)
$03:CF1A .db $00,$00,$F8,$00,$08,$00,$00,$00 ; X offsets: bytes $28-$2F (frames 6-7)
$03:CF22 .db $F8,$08,$00,$06,$00,$00,$F8,$08 ; X offsets: bytes $30-$37 (frames 8-9)
$03:CF2A .db $00,$02,$00,$00,$F8,$08,$00,$04 ; X offsets: bytes $38-$3F (frames 9-10)
$03:CF32 .db $00,$08,$F8,$08,$00,$00,$08,$00 ; X offsets: bytes $40-$47 (frames 10-11)
$03:CF3A .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets: bytes $48-$4F (frames 12-13)
$03:CF42 .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets: bytes $50-$57 (frames 13-14)
$03:CF4A .db $08,$00,$F8,$08,$00,$00,$08,$00 ; X offsets: bytes $58-$5F (frames 14-15)
$03:CF52 .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets: bytes $60-$67 (frames 16-17)
$03:CF5A .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets: bytes $68-$6F (frames 17-18)
$03:CF62 .db $00,$00,$F8,$08,$00,$00,$08,$00 ; X offsets: bytes $70-$77 (frames 18-19)
$03:CF6A .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets: bytes $78-$7F (frames 20-21)
$03:CF72 .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets: bytes $80-$87 (frames 21-22)
$03:CF7A .db $00,$00 ; X offsets: bytes $88-$89 (frames 22-22)
;;; $CF7C..D004: Table: Koopa Kid X offsets (state 6) ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:CF7C .db $F8,$08,$F8,$08,$00,$00,$F8,$08 ; X offsets, state 6: bytes $00-$07 (frames 0-1)
$03:CF84 .db $F8,$08,$00,$00,$F8,$00,$08,$00 ; X offsets, state 6: bytes $08-$0F (frames 1-2)
$03:CF8C .db $00,$00,$FB,$00,$FB,$03,$00,$00 ; X offsets, state 6: bytes $10-$17 (frames 2-3)
$03:CF94 .db $F8,$08,$00,$00,$08,$00,$F8,$08 ; X offsets, state 6: bytes $18-$1F (frames 4-5)
$03:CF9C .db $00,$00,$00,$00,$F8,$00,$08,$00 ; X offsets, state 6: bytes $20-$27 (frames 5-6)
$03:CFA4 .db $00,$00,$F8,$00,$08,$00,$00,$00 ; X offsets, state 6: bytes $28-$2F (frames 6-7)
$03:CFAC .db $F8,$08,$00,$06,$00,$08,$F8,$08 ; X offsets, state 6: bytes $30-$37 (frames 8-9)
$03:CFB4 .db $00,$02,$00,$08,$F8,$08,$00,$04 ; X offsets, state 6: bytes $38-$3F (frames 9-10)
$03:CFBC .db $00,$08,$F8,$08,$00,$00,$08,$00 ; X offsets, state 6: bytes $40-$47 (frames 10-11)
$03:CFC4 .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets, state 6: bytes $48-$4F (frames 12-13)
$03:CFCC .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets, state 6: bytes $50-$57 (frames 13-14)
$03:CFD4 .db $08,$00,$F8,$08,$00,$00,$08,$00 ; X offsets, state 6: bytes $58-$5F (frames 14-15)
$03:CFDC .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets, state 6: bytes $60-$67 (frames 16-17)
$03:CFE4 .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets, state 6: bytes $68-$6F (frames 17-18)
$03:CFEC .db $00,$00,$F8,$08,$00,$00,$08,$00 ; X offsets, state 6: bytes $70-$77 (frames 18-19)
$03:CFF4 .db $F8,$08,$00,$00,$00,$00,$F8,$08 ; X offsets, state 6: bytes $78-$7F (frames 20-21)
$03:CFFC .db $00,$00,$00,$00,$F8,$08,$00,$00 ; X offsets, state 6: bytes $80-$87 (frames 21-22)
$03:D004 .db $00,$00 ; X offsets, state 6: bytes $88-$89 (frames 22-22)
; SMWCentral Pwns!
;;; $D006..D08E: Table: Koopa Kid Y offsets ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:D006 .db $04,$04,$14,$14,$00,$00,$04,$04 ; Y offsets: bytes $00-$07 (frames 0-1)
$03:D00E .db $14,$14,$00,$00,$00,$08,$F8,$00 ; Y offsets: bytes $08-$0F (frames 1-2)
$03:D016 .db $00,$00,$00,$08,$F8,$F8,$00,$00 ; Y offsets: bytes $10-$17 (frames 2-3)
$03:D01E .db $05,$05,$00,$F8,$F8,$00,$05,$05 ; Y offsets: bytes $18-$1F (frames 4-5)
$03:D026 .db $00,$00,$00,$00,$00,$08,$F8,$00 ; Y offsets: bytes $20-$27 (frames 5-6)
$03:D02E .db $00,$00,$00,$08,$00,$00,$00,$00 ; Y offsets: bytes $28-$2F (frames 6-7)
$03:D036 .db $05,$05,$00,$F8,$00,$00,$05,$05 ; Y offsets: bytes $30-$37 (frames 8-9)
$03:D03E .db $00,$F8,$00,$00,$05,$05,$00,$0F ; Y offsets: bytes $38-$3F (frames 9-10)
$03:D046 .db $F8,$F8,$05,$05,$00,$F8,$F8,$00 ; Y offsets: bytes $40-$47 (frames 10-11)
$03:D04E .db $00,$00,$00,$00,$00,$00,$00,$00 ; Y offsets: bytes $48-$4F (frames 12-13)
$03:D056 .db $00,$00,$00,$00,$05,$05,$00,$F8 ; Y offsets: bytes $50-$57 (frames 13-14)
$03:D05E .db $F8,$00,$05,$05,$00,$F8,$F8,$00 ; Y offsets: bytes $58-$5F (frames 14-15)
$03:D066 .db $04,$04,$02,$00,$00,$00,$04,$04 ; Y offsets: bytes $60-$67 (frames 16-17)
$03:D06E .db $01,$00,$00,$00,$04,$04,$00,$00 ; Y offsets: bytes $68-$6F (frames 17-18)
$03:D076 .db $00,$00,$05,$05,$00,$F8,$F8,$00 ; Y offsets: bytes $70-$77 (frames 18-19)
$03:D07E .db $05,$05,$00,$00,$00,$00,$05,$05 ; Y offsets: bytes $78-$7F (frames 20-21)
$03:D086 .db $03,$00,$00,$00,$05,$05,$04,$00 ; Y offsets: bytes $80-$87 (frames 21-22)
$03:D08E .db $00,$00 ; Y offsets: bytes $88-$89 (frames 22-22)
;;; $D090..D118: Table: Koopa Kid Y offsets (state 6) ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:D090 .db $04,$04,$14,$14,$00,$00,$04,$04 ; Y offsets, state 6: bytes $00-$07 (frames 0-1)
$03:D098 .db $14,$14,$00,$00,$00,$08,$00,$00 ; Y offsets, state 6: bytes $08-$0F (frames 1-2)
$03:D0A0 .db $00,$00,$00,$08,$F8,$F8,$00,$00 ; Y offsets, state 6: bytes $10-$17 (frames 2-3)
$03:D0A8 .db $05,$05,$00,$F8,$F8,$00,$05,$05 ; Y offsets, state 6: bytes $18-$1F (frames 4-5)
$03:D0B0 .db $00,$00,$00,$00,$00,$08,$00,$00 ; Y offsets, state 6: bytes $20-$27 (frames 5-6)
$03:D0B8 .db $00,$00,$00,$08,$08,$00,$00,$00 ; Y offsets, state 6: bytes $28-$2F (frames 6-7)
$03:D0C0 .db $05,$05,$00,$F8,$F8,$00,$05,$05 ; Y offsets, state 6: bytes $30-$37 (frames 8-9)
$03:D0C8 .db $00,$F8,$F8,$00,$05,$05,$00,$0F ; Y offsets, state 6: bytes $38-$3F (frames 9-10)
$03:D0D0 .db $F8,$F8,$05,$05,$00,$F8,$F8,$00 ; Y offsets, state 6: bytes $40-$47 (frames 10-11)
$03:D0D8 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Y offsets, state 6: bytes $48-$4F (frames 12-13)
$03:D0E0 .db $00,$00,$00,$00,$05,$05,$00,$F8 ; Y offsets, state 6: bytes $50-$57 (frames 13-14)
$03:D0E8 .db $F8,$00,$05,$05,$00,$F8,$F8,$00 ; Y offsets, state 6: bytes $58-$5F (frames 14-15)
$03:D0F0 .db $04,$04,$02,$00,$00,$00,$04,$04 ; Y offsets, state 6: bytes $60-$67 (frames 16-17)
$03:D0F8 .db $01,$00,$00,$00,$04,$04,$00,$00 ; Y offsets, state 6: bytes $68-$6F (frames 17-18)
$03:D100 .db $00,$00,$05,$05,$00,$F8,$F8,$00 ; Y offsets, state 6: bytes $70-$77 (frames 18-19)
$03:D108 .db $05,$05,$00,$00,$00,$00,$05,$05 ; Y offsets, state 6: bytes $78-$7F (frames 20-21)
$03:D110 .db $03,$00,$00,$00,$05,$05,$04,$00 ; Y offsets, state 6: bytes $80-$87 (frames 21-22)
$03:D118 .db $00,$00 ; Y offsets, state 6: bytes $88-$89 (frames 22-22)
;;; $D11A..D1A2: Table: Koopa Kid tile numbers ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:D11A .db $20,$20,$26,$26,$08,$00,$2E,$2E ; Tile numbers: bytes $00-$07 (frames 0-1)
$03:D122 .db $24,$24,$08,$00,$00,$28,$02,$00 ; Tile numbers: bytes $08-$0F (frames 1-2)
$03:D12A .db $00,$00,$04,$28,$12,$12,$00,$00 ; Tile numbers: bytes $10-$17 (frames 2-3)
$03:D132 .db $22,$22,$04,$12,$12,$00,$20,$20 ; Tile numbers: bytes $18-$1F (frames 4-5)
$03:D13A .db $08,$00,$00,$00,$00,$28,$02,$00 ; Tile numbers: bytes $20-$27 (frames 5-6)
$03:D142 .db $00,$00,$0A,$28,$13,$00,$00,$00 ; Tile numbers: bytes $28-$2F (frames 6-7)
$03:D14A .db $20,$20,$0C,$02,$00,$00,$20,$20 ; Tile numbers: bytes $30-$37 (frames 8-9)
$03:D152 .db $0C,$02,$00,$00,$22,$22,$06,$03 ; Tile numbers: bytes $38-$3F (frames 9-10)
$03:D15A .db $12,$12,$20,$20,$06,$12,$12,$00 ; Tile numbers: bytes $40-$47 (frames 10-11)
$03:D162 .db $2A,$2A,$00,$00,$00,$00,$2C,$2C ; Tile numbers: bytes $48-$4F (frames 12-13)
$03:D16A .db $00,$00,$00,$00,$20,$20,$06,$12 ; Tile numbers: bytes $50-$57 (frames 13-14)
$03:D172 .db $12,$00,$20,$20,$06,$12,$12,$00 ; Tile numbers: bytes $58-$5F (frames 14-15)
$03:D17A .db $22,$22,$08,$00,$00,$00,$20,$20 ; Tile numbers: bytes $60-$67 (frames 16-17)
$03:D182 .db $08,$00,$00,$00,$2E,$2E,$08,$00 ; Tile numbers: bytes $68-$6F (frames 17-18)
$03:D18A .db $00,$00,$4E,$4E,$60,$43,$43,$00 ; Tile numbers: bytes $70-$77 (frames 18-19)
$03:D192 .db $4E,$4E,$64,$00,$00,$00,$62,$62 ; Tile numbers: bytes $78-$7F (frames 20-21)
$03:D19A .db $64,$00,$00,$00,$62,$62,$64,$00 ; Tile numbers: bytes $80-$87 (frames 21-22)
$03:D1A2 .db $00,$00 ; Tile numbers: bytes $88-$89 (frames 22-22)
;;; $D1A4..D22C: Table: Koopa Kid tile numbers (state 6) ;;;
;; Used by the draw routine at $03D484: 6 tiles per frame, 23 frames, indexed by [$1602] * 6 + tile.
$03:D1A4 .db $20,$20,$26,$26,$48,$00,$2E,$2E ; Tile numbers, state 6: bytes $00-$07 (frames 0-1)
$03:D1AC .db $24,$24,$48,$00,$40,$28,$42,$00 ; Tile numbers, state 6: bytes $08-$0F (frames 1-2)
$03:D1B4 .db $00,$00,$44,$28,$52,$52,$00,$00 ; Tile numbers, state 6: bytes $10-$17 (frames 2-3)
$03:D1BC .db $22,$22,$44,$52,$52,$00,$20,$20 ; Tile numbers, state 6: bytes $18-$1F (frames 4-5)
$03:D1C4 .db $48,$00,$00,$00,$40,$28,$42,$00 ; Tile numbers, state 6: bytes $20-$27 (frames 5-6)
$03:D1CC .db $00,$00,$4A,$28,$53,$00,$00,$00 ; Tile numbers, state 6: bytes $28-$2F (frames 6-7)
$03:D1D4 .db $20,$20,$4C,$1E,$1F,$00,$20,$20 ; Tile numbers, state 6: bytes $30-$37 (frames 8-9)
$03:D1DC .db $4C,$1F,$1E,$00,$22,$22,$44,$03 ; Tile numbers, state 6: bytes $38-$3F (frames 9-10)
$03:D1E4 .db $52,$52,$20,$20,$44,$52,$52,$00 ; Tile numbers, state 6: bytes $40-$47 (frames 10-11)
$03:D1EC .db $2A,$2A,$00,$00,$00,$00,$2C,$2C ; Tile numbers, state 6: bytes $48-$4F (frames 12-13)
$03:D1F4 .db $00,$00,$00,$00,$20,$20,$46,$52 ; Tile numbers, state 6: bytes $50-$57 (frames 13-14)
$03:D1FC .db $52,$00,$20,$20,$46,$52,$52,$00 ; Tile numbers, state 6: bytes $58-$5F (frames 14-15)
$03:D204 .db $22,$22,$48,$00,$00,$00,$20,$20 ; Tile numbers, state 6: bytes $60-$67 (frames 16-17)
$03:D20C .db $48,$00,$00,$00,$2E,$2E,$48,$00 ; Tile numbers, state 6: bytes $68-$6F (frames 17-18)
$03:D214 .db $00,$00,$4E,$4E,$66,$68,$68,$00 ; Tile numbers, state 6: bytes $70-$77 (frames 18-19)
$03:D21C .db $4E,$4E,$6A,$00,$00,$00,$62,$62 ; Tile numbers, state 6: bytes $78-$7F (frames 20-21)
$03:D224 .db $6A,$00,$00,$00,$62,$62,$6A,$00 ; Tile numbers, state 6: bytes $80-$87 (frames 21-22)
$03:D22C .db $00,$00 ; Tile numbers, state 6: bytes $88-$89 (frames 22-22)
;;; $D22E: Table: Koopa Kid OAM properties (LemmyGfxProp) ;;;
;; Used by the draw routine at $03D484 (ORed with $10): 6 tiles per frame, 23 frames. The next table is
;; WendyGfxProp (state 6).
$03:D22E .db $05,$45,$05,$45,$05,$00,$05,$45 ; OAM properties: bytes $00-$07 (frames 0-1)
$03:D236 .db $05,$45,$05,$00,$05,$05,$05,$00 ; OAM properties: bytes $08-$0F (frames 1-2)
$03:D23E .db $00,$00,$05,$05,$05,$45,$00,$00 ; OAM properties: bytes $10-$17 (frames 2-3)
$03:D246 .db $05,$45,$05,$05,$45,$00,$05,$45 ; OAM properties: bytes $18-$1F (frames 4-5)
$03:D24E .db $05,$00,$00,$00,$05,$05,$05,$00 ; OAM properties: bytes $20-$27 (frames 5-6)
$03:D256 .db $00,$00,$05,$05,$05,$00,$00,$00 ; OAM properties: bytes $28-$2F (frames 6-7)
$03:D25E .db $05,$45,$05,$05,$00,$00,$05,$45 ; OAM properties: bytes $30-$37 (frames 8-9)
$03:D266 .db $45,$45,$00,$00,$05,$45,$05,$05 ; OAM properties: bytes $38-$3F (frames 9-10)
$03:D26E .db $05,$45,$05,$45,$45,$05,$45,$00 ; OAM properties: bytes $40-$47 (frames 10-11)
$03:D276 .db $05,$45,$00,$00,$00,$00,$05,$45 ; OAM properties: bytes $48-$4F (frames 12-13)
$03:D27E .db $00,$00,$00,$00,$05,$45,$45,$05 ; OAM properties: bytes $50-$57 (frames 13-14)
$03:D286 .db $45,$00,$05,$45,$05,$05,$45,$00 ; OAM properties: bytes $58-$5F (frames 14-15)
$03:D28E .db $05,$45,$05,$00,$00,$00,$05,$45 ; OAM properties: bytes $60-$67 (frames 16-17)
$03:D296 .db $05,$00,$00,$00,$05,$45,$05,$00 ; OAM properties: bytes $68-$6F (frames 17-18)
$03:D29E .db $00,$00,$07,$47,$07,$07,$47,$00 ; OAM properties: bytes $70-$77 (frames 18-19)
$03:D2A6 .db $07,$47,$07,$00,$00,$00,$07,$47 ; OAM properties: bytes $78-$7F (frames 20-21)
$03:D2AE .db $07,$00,$00,$00,$07,$47,$07,$00 ; OAM properties: bytes $80-$87 (frames 21-22)
$03:D2B6 .db $00,$00 ; OAM properties: bytes $88-$89 (frames 22-22)
;;; $D2B8: Lemmy and Wendy OAM tables and drawing (WendyGfxProp) ;;;
;; Data: tile properties (YXPPCCCT), OAM size bits (per tile, 6 tiles per frame) and tile counts (per frame,
;; 23 frames) for Lemmy and Wendy, then the draw routine.
;; Draw routine (called from the Lemmy/Wendy pipe code at $03CC14 with the sprite index in X): puts the frame
;; [$1602]'s tiles into OAM.
;; Sprite state 6 (Wendy) uses the Wendy tables ($CF7C, $D090, $D1A4, WendyGfxProp,
;; $D3CC); other states use the Lemmy tables.
;; Quirk: OAM size values of 4 appear in the size tables; probably unintended leftovers (the size bits are 0
;; or 2).
;; Parameters: X: sprite index. Returns: X preserved; OAM slots from the draw info index filled.
$03:D2B8 .db $09,$49,$09,$49,$09,$00,$09,$49 ; Wendy tile properties, frames 0-1 (6 tiles per frame)
$03:D2C0 .db $09,$49,$09,$00,$09,$09,$09,$00 ; Wendy tile properties, frames 1-2 (6 tiles per frame)
$03:D2C8 .db $00,$00,$09,$09,$09,$49,$00,$00 ; Wendy tile properties, frames 2-3 (6 tiles per frame)
$03:D2D0 .db $09,$49,$09,$09,$49,$00,$09,$49 ; Wendy tile properties, frames 4-5 (6 tiles per frame)
$03:D2D8 .db $09,$00,$00,$00,$09,$09,$09,$00 ; Wendy tile properties, frames 5-6 (6 tiles per frame)
$03:D2E0 .db $00,$00,$09,$09,$09,$00,$00,$00 ; Wendy tile properties, frames 6-7 (6 tiles per frame)
$03:D2E8 .db $09,$49,$09,$09,$09,$00,$09,$49 ; Wendy tile properties, frames 8-9 (6 tiles per frame)
$03:D2F0 .db $49,$49,$49,$00,$09,$49,$09,$09 ; Wendy tile properties, frames 9-10 (6 tiles per frame)
$03:D2F8 .db $09,$49,$09,$49,$49,$09,$49,$00 ; Wendy tile properties, frames 10-11 (6 tiles per frame)
$03:D300 .db $09,$49,$00,$00,$00,$00,$09,$49 ; Wendy tile properties, frames 12-13 (6 tiles per frame)
$03:D308 .db $00,$00,$00,$00,$09,$49,$49,$09 ; Wendy tile properties, frames 13-14 (6 tiles per frame)
$03:D310 .db $49,$00,$09,$49,$09,$09,$49,$00 ; Wendy tile properties, frames 14-15 (6 tiles per frame)
$03:D318 .db $09,$49,$09,$00,$00,$00,$09,$49 ; Wendy tile properties, frames 16-17 (6 tiles per frame)
$03:D320 .db $09,$00,$00,$00,$09,$49,$09,$00 ; Wendy tile properties, frames 17-18 (6 tiles per frame)
$03:D328 .db $00,$00,$05,$45,$05,$05,$45,$00 ; Wendy tile properties, frames 18-19 (6 tiles per frame)
$03:D330 .db $05,$45,$05,$00,$00,$00,$05,$45 ; Wendy tile properties, frames 20-21 (6 tiles per frame)
$03:D338 .db $05,$00,$00,$00,$05,$45,$05,$00 ; Wendy tile properties, frames 21-22 (6 tiles per frame)
$03:D340 .db $00,$00 ; Wendy tile properties, frames 22-22 (6 tiles per frame)
$03:D342 .db $02,$02,$02,$02,$02,$04,$02,$02 ; Lemmy OAM size bits, frames 0-1 (6 tiles per frame)
$03:D34A .db $02,$02,$02,$04,$02,$02,$00,$04 ; Lemmy OAM size bits, frames 1-2 (6 tiles per frame)
$03:D352 .db $04,$04,$02,$02,$00,$00,$04,$04 ; Lemmy OAM size bits, frames 2-3 (6 tiles per frame)
$03:D35A .db $02,$02,$02,$00,$00,$04,$02,$02 ; Lemmy OAM size bits, frames 4-5 (6 tiles per frame)
$03:D362 .db $02,$04,$04,$04,$02,$02,$00,$04 ; Lemmy OAM size bits, frames 5-6 (6 tiles per frame)
$03:D36A .db $04,$04,$02,$02,$00,$04,$04,$04 ; Lemmy OAM size bits, frames 6-7 (6 tiles per frame)
$03:D372 .db $02,$02,$02,$00,$04,$04,$02,$02 ; Lemmy OAM size bits, frames 8-9 (6 tiles per frame)
$03:D37A .db $02,$00,$04,$04,$02,$02,$02,$00 ; Lemmy OAM size bits, frames 9-10 (6 tiles per frame)
$03:D382 .db $00,$00,$02,$02,$02,$00,$00,$04 ; Lemmy OAM size bits, frames 10-11 (6 tiles per frame)
$03:D38A .db $02,$02,$04,$04,$04,$04,$02,$02 ; Lemmy OAM size bits, frames 12-13 (6 tiles per frame)
$03:D392 .db $04,$04,$04,$04,$02,$02,$02,$00 ; Lemmy OAM size bits, frames 13-14 (6 tiles per frame)
$03:D39A .db $00,$04,$02,$02,$02,$00,$00,$04 ; Lemmy OAM size bits, frames 14-15 (6 tiles per frame)
$03:D3A2 .db $02,$02,$02,$04,$04,$04,$02,$02 ; Lemmy OAM size bits, frames 16-17 (6 tiles per frame)
$03:D3AA .db $02,$04,$04,$04,$02,$02,$02,$04 ; Lemmy OAM size bits, frames 17-18 (6 tiles per frame)
$03:D3B2 .db $04,$04,$02,$02,$02,$00,$00,$04 ; Lemmy OAM size bits, frames 18-19 (6 tiles per frame)
$03:D3BA .db $02,$02,$02,$04,$04,$04,$02,$02 ; Lemmy OAM size bits, frames 20-21 (6 tiles per frame)
$03:D3C2 .db $02,$04,$04,$04,$02,$02,$02,$04 ; Lemmy OAM size bits, frames 21-22 (6 tiles per frame)
$03:D3CA .db $04,$04 ; Lemmy OAM size bits, frames 22-22 (6 tiles per frame)
$03:D3CC .db $02,$02,$02,$02,$02,$04,$02,$02 ; Wendy OAM size bits, frames 0-1 (6 tiles per frame)
$03:D3D4 .db $02,$02,$02,$04,$02,$02,$00,$04 ; Wendy OAM size bits, frames 1-2 (6 tiles per frame)
$03:D3DC .db $04,$04,$02,$02,$00,$00,$04,$04 ; Wendy OAM size bits, frames 2-3 (6 tiles per frame)
$03:D3E4 .db $02,$02,$02,$00,$00,$04,$02,$02 ; Wendy OAM size bits, frames 4-5 (6 tiles per frame)
$03:D3EC .db $02,$04,$04,$04,$02,$02,$00,$04 ; Wendy OAM size bits, frames 5-6 (6 tiles per frame)
$03:D3F4 .db $04,$04,$02,$02,$00,$04,$04,$04 ; Wendy OAM size bits, frames 6-7 (6 tiles per frame)
$03:D3FC .db $02,$02,$02,$00,$00,$04,$02,$02 ; Wendy OAM size bits, frames 8-9 (6 tiles per frame)
$03:D404 .db $02,$00,$00,$04,$02,$02,$02,$00 ; Wendy OAM size bits, frames 9-10 (6 tiles per frame)
$03:D40C .db $00,$00,$02,$02,$02,$00,$00,$04 ; Wendy OAM size bits, frames 10-11 (6 tiles per frame)
$03:D414 .db $02,$02,$04,$04,$04,$04,$02,$02 ; Wendy OAM size bits, frames 12-13 (6 tiles per frame)
$03:D41C .db $04,$04,$04,$04,$02,$02,$02,$00 ; Wendy OAM size bits, frames 13-14 (6 tiles per frame)
$03:D424 .db $00,$04,$02,$02,$02,$00,$00,$04 ; Wendy OAM size bits, frames 14-15 (6 tiles per frame)
$03:D42C .db $02,$02,$02,$04,$04,$04,$02,$02 ; Wendy OAM size bits, frames 16-17 (6 tiles per frame)
$03:D434 .db $02,$04,$04,$04,$02,$02,$02,$04 ; Wendy OAM size bits, frames 17-18 (6 tiles per frame)
$03:D43C .db $04,$04,$02,$02,$02,$00,$00,$04 ; Wendy OAM size bits, frames 18-19 (6 tiles per frame)
$03:D444 .db $02,$02,$02,$04,$04,$04,$02,$02 ; Wendy OAM size bits, frames 20-21 (6 tiles per frame)
$03:D44C .db $02,$04,$04,$04,$02,$02,$02,$04 ; Wendy OAM size bits, frames 21-22 (6 tiles per frame)
$03:D454 .db $04,$04 ; Wendy OAM size bits, frames 22-22 (6 tiles per frame)
$03:D456 .db $04,$04,$02,$03,$04,$02,$02,$02 ; Lemmy: tiles - 1, frames 0-7
$03:D45E .db $03,$03,$05,$04,$01,$01,$04,$04 ; Lemmy: tiles - 1, frames 8-15
$03:D466 .db $02,$02,$02,$04,$02,$02,$02 ; Lemmy: tiles - 1, frames 16-22
$03:D46D .db $04,$04,$02,$03,$04,$02,$02,$02 ; Wendy: tiles - 1, frames 0-7
$03:D475 .db $04,$04,$05,$04,$01,$01,$04,$04 ; Wendy: tiles - 1, frames 8-15
$03:D47D .db $02,$02,$02,$04,$02,$02,$02 ; Wendy: tiles - 1, frames 16-22
$03:D484 20 60 B7 JSR.W GetDrawInfoBnk3 ; Get draw info: [$00]/[$01] = screen X/Y, Y = OAM index
$03:D487 BD 02 16 LDA.W $1602,X ; \
$03:D48A 0A ASL ; |
$03:D48B 0A ASL ; |
$03:D48C 7D 02 16 ADC.W $1602,X ; |
$03:D48F 7D 02 16 ADC.W $1602,X ; |
$03:D492 85 02 STA $02 ; / $02 = [$1602] * 6: offset of this animation frame (6 tiles per frame)
$03:D494 B5 C2 LDA RAM_SpriteState,X ; \
$03:D496 C9 06 CMP.B #$06 ; |
$03:D498 F0 45 BEQ $D4DF ; / Sprite state = 6 (Wendy)? Yes: draw Wendy ($03D4DF)
$03:D49A DA PHX ; Save sprite index
$03:D49B BD 02 16 LDA.W $1602,X ; \
$03:D49E AA TAX ; |
$03:D49F BD 56 D4 LDA.W $D456,X ; |
$03:D4A2 AA TAX ; / X = number of tiles in this frame - 1 ($D456)
$03:D4A3 DA PHX ; Save tile counter
$03:D4A4 8A TXA ; \
$03:D4A5 18 CLC ; |
$03:D4A6 65 02 ADC $02 ; |
$03:D4A8 AA TAX ; / X = frame offset + tile counter: index into the per-tile tables
$03:D4A9 A5 00 LDA $00 ; \
$03:D4AB 18 CLC ; |
$03:D4AC 7D F2 CE ADC.W $CEF2,X ; |
$03:D4AF 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite screen X + X offset of this tile ($CEF2)
$03:D4B2 A5 01 LDA $01 ; \
$03:D4B4 18 CLC ; |
$03:D4B5 7D 06 D0 ADC.W $D006,X ; |
$03:D4B8 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite screen Y + Y offset of this tile ($D006)
$03:D4BB BD 1A D1 LDA.W $D11A,X ; \
$03:D4BE 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $D11A[X]
$03:D4C1 BD 2E D2 LDA.W LemmyGfxProp,X ; \
$03:D4C4 09 10 ORA.B #$10 ; |
$03:D4C6 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = LemmyGfxProp[X] | $10 (sprite priority bits = 1)
$03:D4C9 5A PHY ; Save OAM index
$03:D4CA 98 TYA ; \
$03:D4CB 4A LSR ; |
$03:D4CC 4A LSR ; |
$03:D4CD A8 TAY ; / Y = OAM index / 4: index into the OAM size table
$03:D4CE BD 42 D3 LDA.W $D342,X ; \
$03:D4D1 99 60 04 STA.W OAM_TileSize,Y ; / OAM size bits = $D342[X] (2 = 16x16, 0 = 8x8)
$03:D4D4 7A PLY ; Restore OAM index
$03:D4D5 C8 INY ; \
$03:D4D6 C8 INY ; |
$03:D4D7 C8 INY ; |
$03:D4D8 C8 INY ; / Next OAM slot: Y += 4
$03:D4D9 FA PLX ; Restore tile counter
$03:D4DA CA DEX ; \
$03:D4DB 10 C6 BPL $D4A3 ; / Loop for every tile of the frame (counter down to 0)
$03:D4DD FA PLX ; Restore sprite index
$03:D4DE 60 RTS ; Return
$03:D4DF DA PHX ; Wendy: save sprite index
$03:D4E0 BD 02 16 LDA.W $1602,X ; \
$03:D4E3 AA TAX ; |
$03:D4E4 BD 6D D4 LDA.W $D46D,X ; |
$03:D4E7 AA TAX ; / X = number of tiles in this frame - 1 ($D46D)
$03:D4E8 DA PHX ; Save tile counter
$03:D4E9 8A TXA ; \
$03:D4EA 18 CLC ; |
$03:D4EB 65 02 ADC $02 ; |
$03:D4ED AA TAX ; / X = frame offset + tile counter: index into the per-tile tables
$03:D4EE A5 00 LDA $00 ; \
$03:D4F0 18 CLC ; |
$03:D4F1 7D 7C CF ADC.W $CF7C,X ; |
$03:D4F4 99 00 03 STA.W OAM_DispX,Y ; / OAM X = sprite screen X + X offset of this tile ($CF7C)
$03:D4F7 A5 01 LDA $01 ; \
$03:D4F9 18 CLC ; |
$03:D4FA 7D 90 D0 ADC.W $D090,X ; |
$03:D4FD 99 01 03 STA.W OAM_DispY,Y ; / OAM Y = sprite screen Y + Y offset of this tile ($D090)
$03:D500 BD A4 D1 LDA.W $D1A4,X ; \
$03:D503 99 02 03 STA.W OAM_Tile,Y ; / OAM tile = $D1A4[X]
$03:D506 BD B8 D2 LDA.W WendyGfxProp,X ; \
$03:D509 09 10 ORA.B #$10 ; |
$03:D50B 99 03 03 STA.W OAM_Prop,Y ; / OAM properties = WendyGfxProp[X] | $10 (sprite priority bits = 1)
$03:D50E 5A PHY ; Save OAM index
$03:D50F 98 TYA ; \
$03:D510 4A LSR ; |
$03:D511 4A LSR ; |
$03:D512 A8 TAY ; / Y = OAM index / 4: index into the OAM size table
$03:D513 BD CC D3 LDA.W $D3CC,X ; \
$03:D516 99 60 04 STA.W OAM_TileSize,Y ; / OAM size bits = $D3CC[X] (2 = 16x16, 0 = 8x8)
$03:D519 7A PLY ; Restore OAM index
$03:D51A C8 INY ; \
$03:D51B C8 INY ; |
$03:D51C C8 INY ; |
$03:D51D C8 INY ; / Next OAM slot: Y += 4
$03:D51E FA PLX ; Restore tile counter
$03:D51F CA DEX ; \
$03:D520 10 C6 BPL $D4E8 ; / Loop for every tile of the frame (counter down to 0)
$03:D522 80 B9 BRA $D4DD ; Restore sprite index and return ($03D4DD)
;;; $D524..D66E: Table: Peach message letter sprites ;;;
;; 4 bytes per letter: X, Y, tile, OAM properties ($0E). 84 letters in 4 lines (Y = $20, $30, $40, $50). Rows
;; below are offset by 2: each row starts at the tile of a letter.
$03:D524 .db $18,$20 ; Letter 0: X, Y (table: X, Y, tile, properties per letter)
$03:D526 .db $A1,$0E,$20,$20,$88,$0E,$28,$20 ; Tile, prop of letter 0; X, Y, tile, prop of 1; X, Y of 2
$03:D52E .db $AB,$0E,$30,$20,$99,$0E,$38,$20 ; Tile, prop of letter 2; X, Y, tile, prop of 3; X, Y of 4
$03:D536 .db $A8,$0E,$40,$20,$BF,$0E,$48,$20 ; Tile, prop of letter 4; X, Y, tile, prop of 5; X, Y of 6
$03:D53E .db $AC,$0E,$58,$20,$88,$0E,$60,$20 ; Tile, prop of letter 6; X, Y, tile, prop of 7; X, Y of 8
$03:D546 .db $8B,$0E,$68,$20,$AF,$0E,$70,$20 ; Tile, prop of letter 8; X, Y, tile, prop of 9; X, Y of 10
$03:D54E .db $8C,$0E,$78,$20,$9E,$0E,$80,$20 ; Tile, prop of letter 10; X, Y, tile, prop of 11; X, Y of 12
$03:D556 .db $AD,$0E,$88,$20,$AE,$0E,$90,$20 ; Tile, prop of letter 12; X, Y, tile, prop of 13; X, Y of 14
$03:D55E .db $AB,$0E,$98,$20,$8C,$0E,$A8,$20 ; Tile, prop of letter 14; X, Y, tile, prop of 15; X, Y of 16
$03:D566 .db $99,$0E,$B0,$20,$AC,$0E,$C0,$20 ; Tile, prop of letter 16; X, Y, tile, prop of 17; X, Y of 18
$03:D56E .db $A8,$0E,$C8,$20,$AF,$0E,$D0,$20 ; Tile, prop of letter 18; X, Y, tile, prop of 19; X, Y of 20
$03:D576 .db $8C,$0E,$D8,$20,$AB,$0E,$E0,$20 ; Tile, prop of letter 20; X, Y, tile, prop of 21; X, Y of 22
$03:D57E .db $BD,$0E,$18,$30,$A1,$0E,$20,$30 ; Tile, prop of letter 22; X, Y, tile, prop of 23; X, Y of 24
$03:D586 .db $88,$0E,$28,$30,$AB,$0E,$30,$30 ; Tile, prop of letter 24; X, Y, tile, prop of 25; X, Y of 26
$03:D58E .db $99,$0E,$38,$30,$A8,$0E,$40,$30 ; Tile, prop of letter 26; X, Y, tile, prop of 27; X, Y of 28
$03:D596 .db $BE,$0E,$48,$30,$AD,$0E,$50,$30 ; Tile, prop of letter 28; X, Y, tile, prop of 29; X, Y of 30
$03:D59E .db $98,$0E,$58,$30,$8C,$0E,$68,$30 ; Tile, prop of letter 30; X, Y, tile, prop of 31; X, Y of 32
$03:D5A6 .db $A0,$0E,$70,$30,$AB,$0E,$78,$30 ; Tile, prop of letter 32; X, Y, tile, prop of 33; X, Y of 34
$03:D5AE .db $99,$0E,$80,$30,$9E,$0E,$88,$30 ; Tile, prop of letter 34; X, Y, tile, prop of 35; X, Y of 36
$03:D5B6 .db $8A,$0E,$90,$30,$8C,$0E,$98,$30 ; Tile, prop of letter 36; X, Y, tile, prop of 37; X, Y of 38
$03:D5BE .db $AC,$0E,$A0,$30,$AC,$0E,$A8,$30 ; Tile, prop of letter 38; X, Y, tile, prop of 39; X, Y of 40
$03:D5C6 .db $BE,$0E,$B0,$30,$B0,$0E,$B8,$30 ; Tile, prop of letter 40; X, Y, tile, prop of 41; X, Y of 42
$03:D5CE .db $A8,$0E,$C0,$30,$AC,$0E,$C8,$30 ; Tile, prop of letter 42; X, Y, tile, prop of 43; X, Y of 44
$03:D5D6 .db $98,$0E,$D0,$30,$99,$0E,$D8,$30 ; Tile, prop of letter 44; X, Y, tile, prop of 45; X, Y of 46
$03:D5DE .db $BE,$0E,$18,$40,$88,$0E,$20,$40 ; Tile, prop of letter 46; X, Y, tile, prop of 47; X, Y of 48
$03:D5E6 .db $9E,$0E,$28,$40,$8B,$0E,$38,$40 ; Tile, prop of letter 48; X, Y, tile, prop of 49; X, Y of 50
$03:D5EE .db $98,$0E,$40,$40,$99,$0E,$48,$40 ; Tile, prop of letter 50; X, Y, tile, prop of 51; X, Y of 52
$03:D5F6 .db $AC,$0E,$58,$40,$8D,$0E,$60,$40 ; Tile, prop of letter 52; X, Y, tile, prop of 53; X, Y of 54
$03:D5FE .db $AB,$0E,$68,$40,$99,$0E,$70,$40 ; Tile, prop of letter 54; X, Y, tile, prop of 55; X, Y of 56
$03:D606 .db $8C,$0E,$78,$40,$9E,$0E,$80,$40 ; Tile, prop of letter 56; X, Y, tile, prop of 57; X, Y of 58
$03:D60E .db $8B,$0E,$88,$40,$AC,$0E,$98,$40 ; Tile, prop of letter 58; X, Y, tile, prop of 59; X, Y of 60
$03:D616 .db $88,$0E,$A0,$40,$AB,$0E,$A8,$40 ; Tile, prop of letter 60; X, Y, tile, prop of 61; X, Y of 62
$03:D61E .db $8C,$0E,$B8,$40,$8E,$0E,$C0,$40 ; Tile, prop of letter 62; X, Y, tile, prop of 63; X, Y of 64
$03:D626 .db $A8,$0E,$C8,$40,$99,$0E,$D0,$40 ; Tile, prop of letter 64; X, Y, tile, prop of 65; X, Y of 66
$03:D62E .db $9E,$0E,$D8,$40,$8E,$0E,$18,$50 ; Tile, prop of letter 66; X, Y, tile, prop of 67; X, Y of 68
$03:D636 .db $AD,$0E,$20,$50,$A8,$0E,$30,$50 ; Tile, prop of letter 68; X, Y, tile, prop of 69; X, Y of 70
$03:D63E .db $AD,$0E,$38,$50,$88,$0E,$40,$50 ; Tile, prop of letter 70; X, Y, tile, prop of 71; X, Y of 72
$03:D646 .db $9B,$0E,$48,$50,$8C,$0E,$58,$50 ; Tile, prop of letter 72; X, Y, tile, prop of 73; X, Y of 74
$03:D64E .db $88,$0E,$68,$50,$AF,$0E,$70,$50 ; Tile, prop of letter 74; X, Y, tile, prop of 75; X, Y of 76
$03:D656 .db $88,$0E,$78,$50,$8A,$0E,$80,$50 ; Tile, prop of letter 76; X, Y, tile, prop of 77; X, Y of 78
$03:D65E .db $88,$0E,$88,$50,$AD,$0E,$90,$50 ; Tile, prop of letter 78; X, Y, tile, prop of 79; X, Y of 80
$03:D666 .db $99,$0E,$98,$50,$A8,$0E,$A0,$50 ; Tile, prop of letter 80; X, Y, tile, prop of 81; X, Y of 82
$03:D66E .db $9E,$0E,$A8,$50,$BD,$0E ; Tile, prop of letter 82; X, Y, tile, prop of letter 83 (last)
;;; $D674: Draw Peach message letters ;;;
;; Draws the letters of Princess Peach's message revealed so far: [$1921] letters from the table at
;; $D524 as 8x8 sprites, written to OAM from $0200 up.
;; The letter count is advanced by the Peach sprite code ($AEAF) with timers from $AE5B.
;; Parameters: X: sprite index (preserved).
;; Called by:
;; $03:AEAF: Peach state 5: ending picture steps
;; $03:AF30: Peach state 6: fade ending color
$03:D674 DA PHX ; Save sprite index
$03:D675 C2 30 REP #$30 ; A, X and Y 16-bit
$03:D677 AE 21 19 LDX.W $1921 ; \
$03:D67A F0 2C BEQ $D6A8 ; / X = number of letters revealed so far ([$1921]); none: nothing to draw
$03:D67C CA DEX ; X = index of the last letter
$03:D67D A0 00 00 LDY.W #$0000 ; Y = 0: offset into the OAM buffer at $0200
$03:D680 DA PHX ; Save letter index
$03:D681 8A TXA ; \
$03:D682 0A ASL ; |
$03:D683 0A ASL ; |
$03:D684 AA TAX ; / X = letter index * 4 (4 bytes per letter in the table)
$03:D685 BD 24 D5 LDA.W $D524,X ; \
$03:D688 99 00 02 STA.W OAM_ExtendedDispX,Y ; / OAM Y and X of this letter (one 16-bit write: X, Y from the table)
$03:D68B BD 26 D5 LDA.W $D526,X ; \
$03:D68E 99 02 02 STA.W OAM_ExtendedTile,Y ; / OAM tile and properties of this letter (16-bit write)
$03:D691 5A PHY ; Save OAM offset
$03:D692 98 TYA ; \
$03:D693 4A LSR ; |
$03:D694 4A LSR ; |
$03:D695 A8 TAY ; / Y = OAM offset / 4: index into the OAM size table
$03:D696 E2 20 SEP #$20 ; A 8-bit
$03:D698 A9 00 LDA.B #$00 ; \
$03:D69A 99 20 04 STA.W $0420,Y ; / OAM size entry ($0420 table) = 0: 8x8 sprite, X < 256
$03:D69D C2 20 REP #$20 ; A 16-bit
$03:D69F 7A PLY ; Restore OAM offset
$03:D6A0 FA PLX ; Restore letter index
$03:D6A1 C8 INY ; \
$03:D6A2 C8 INY ; |
$03:D6A3 C8 INY ; |
$03:D6A4 C8 INY ; / Next OAM slot: Y += 4
$03:D6A5 CA DEX ; \
$03:D6A6 10 D8 BPL $D680 ; / Loop for all revealed letters
$03:D6A8 E2 30 SEP #$30 ; A, X and Y 8-bit
$03:D6AA FA PLX ; Restore sprite index
$03:D6AB 60 RTS ; Return
;;; $D6AC..D6FC: Padding: FF fill ;;;
$03:D6AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:D6FC .db $FF,$FF,$FF,$FF
;;; $D700..D708: Table: bridge segment X positions ;;;
;; X pixel position of each of the 12 bridge segments broken by BreakBridge: $B0 down to $00 in steps of $10.
$03:D700 .db $B0,$A0,$90,$80,$70,$60,$50,$40 ; Bridge segment X positions: $B0 down to $40 (16 px apart)
$03:D708 .db $30,$20,$10,$00 ; Bridge segment X positions: $30 down to $00
;;; $D70C: Reznor bridge: wait for two dead Reznors ;;;
;; Called from the Reznor sprite code ($03989F) every frame for the sprite in slot 7. Sums the four Reznor-
;; dead flags ([$1520]-[$1523]); with fewer than 2 dead it returns, otherwise it falls into BreakBridge.
;; Called by:
;; $03:989F: Reznor: unlocked, slot 7 setup (ReznorNotLocked)
$03:D70C DA PHX ; Save sprite index
$03:D70D AD 20 15 LDA.W RAM_Reznor1Dead ; \
$03:D710 18 CLC ; |
$03:D711 6D 21 15 ADC.W RAM_Reznor2Dead ; |
$03:D714 6D 22 15 ADC.W RAM_Reznor3Dead ; |
$03:D717 6D 23 15 ADC.W RAM_Reznor4Dead ; / A = number of dead Reznors (flags [$1520]-[$1523])
$03:D71A C9 02 CMP.B #$02 ; \
$03:D71C 90 39 BCC $D757 ; / Fewer than 2 Reznors dead: leave the bridge alone ($03D757)
;;; $D71E: Break bridge one segment at a time (BreakBridge) ;;;
;; Once 2 Reznors are dead, destroys the bridge from the outside in, a segment pair (left and mirrored right)
;; every $40 frames: spawns smoke puffs and plays sound $07 at the start,
;; then $04 frames later replaces both blocks with Map16 tile $25 and queues a stripe image that blanks 3 BG
;; tiles on the two rows of each block.
;; [$1B9F] = number of segments broken (0-12); [$14A7] = segment timer, [$98]/[$9A] = block position scratch.
;; Sub-entries: $03D759 mirrors the block X ($0170 - X), $03D766 smoke puffs, $03D77F erases one block and
;; queues the tilemap update.
$03:D71E AE 9F 1B LDX.W $1B9F ; X = [$1B9F]: number of bridge segments already broken
$03:D721 E0 0C CPX.B #$0C ; \
$03:D723 B0 32 BCS $D757 ; / All 12 segments gone: return ($03D757)
$03:D725 BF 00 D7 03 LDA.L $D700,X ; \
$03:D729 85 9A STA RAM_BlockXLo ; |
$03:D72B 64 9B STZ RAM_BlockXHi ; / Block X = $D700[X]: X position of this bridge segment (left side)
$03:D72D A9 B0 LDA.B #$B0 ; \
$03:D72F 85 98 STA RAM_BlockYLo ; |
$03:D731 64 99 STZ RAM_BlockYHi ; / Block Y = $00B0: row of the bridge
$03:D733 AD A7 14 LDA.W $14A7 ; \
$03:D736 F0 12 BEQ $D74A ; / Segment timer [$14A7] = 0: start breaking this segment ($03D74A)
$03:D738 C9 3C CMP.B #$3C ; \
$03:D73A D0 1B BNE $D757 ; / Timer != $3C: nothing to do this frame
$03:D73C 20 7F D7 JSR.W $D77F ; Replace the left block with an empty tile
$03:D73F 20 59 D7 JSR.W $D759 ; Mirror the block X position to the right side
$03:D742 20 7F D7 JSR.W $D77F ; Replace the right block too
$03:D745 EE 9F 1B INC.W $1B9F ; Next segment: [$1B9F]++
$03:D748 80 0D BRA $D757 ; Done ($03D757)
$03:D74A 20 66 D7 JSR.W $D766 ; Smoke puffs at both blocks
$03:D74D A9 40 LDA.B #$40 ; \
$03:D74F 8D A7 14 STA.W $14A7 ; / Segment timer [$14A7] = $40
$03:D752 A9 07 LDA.B #$07 ; \
$03:D754 8D FC 1D STA.W $1DFC ; / Play sound effect $07 ([$1DFC])
$03:D757 FA PLX ; Restore sprite index
$03:D758 6B RTL ; Return
$03:D759 C2 20 REP #$20 ; A 16-bit
$03:D75B A9 70 01 LDA.W #$0170 ; \
$03:D75E 38 SEC ; |
$03:D75F E5 9A SBC RAM_BlockXLo ; |
$03:D761 85 9A STA RAM_BlockXLo ; / Block X = $0170 - Block X: mirror about the bridge center (X = $00B8)
$03:D763 E2 20 SEP #$20 ; A 8-bit
$03:D765 60 RTS ; Return
$03:D766 20 6C D7 JSR.W $D76C ; Smoke puff at the left block
$03:D769 20 59 D7 JSR.W $D759 ; Mirror X, then fall into the puff code for the right block
$03:D76C C2 20 REP #$20 ; A 16-bit
$03:D76E A5 9A LDA RAM_BlockXLo ; \
$03:D770 38 SEC ; |
$03:D771 E5 1A SBC RAM_ScreenBndryXLo ; |
$03:D773 C9 00 01 CMP.W #$0100 ; / Carry set if the block is off-screen horizontally (X - [$1A] >= $0100)
$03:D776 E2 20 SEP #$20 ; A 8-bit
$03:D778 B0 04 BCS $D77E ; Off-screen: no smoke
$03:D77A 22 44 8A 02 JSL.L $8A44 ; Spawn a smoke puff at the block position ($8A44)
$03:D77E 60 RTS ; Return
$03:D77F A5 9A LDA RAM_BlockXLo ; \
$03:D781 4A LSR ; |
$03:D782 4A LSR ; |
$03:D783 4A LSR ; |
$03:D784 85 01 STA $01 ; / $01 = block X / 8 (tile column)
$03:D786 4A LSR ; \
$03:D787 05 98 ORA RAM_BlockYLo ; / A = block row ([$98]) | block column (X / 16): Map16 index within a screen
$03:D789 C2 20 REP #$20 ; A 16-bit
$03:D78B 29 FF 00 AND.W #$00FF ; Keep the low byte only
$03:D78E A6 9B LDX RAM_BlockXHi ; \
$03:D790 F0 06 BEQ $D798 ; |
$03:D792 18 CLC ; |
$03:D793 69 B0 01 ADC.W #$01B0 ; |
$03:D796 A2 04 LDX.B #$04 ; / Block X high byte set: Map16 index += $01B0 (second screen), X = 4 (tilemap page 2)
$03:D798 86 00 STX $00 ; $00 = tilemap page offset (0 or 4)
$03:D79A C2 10 REP #$10 ; Index 16-bit
$03:D79C AA TAX ; X = Map16 index
$03:D79D E2 20 SEP #$20 ; A 8-bit
$03:D79F A9 25 LDA.B #$25 ; \
$03:D7A1 9F 00 C8 7E STA.L $7EC800,X ; / Map16 tile low byte = $25 (empty tile)
$03:D7A5 A9 00 LDA.B #$00 ; \
$03:D7A7 9F 00 C8 7F STA.L $7FC800,X ; / Map16 tile high byte = 0
$03:D7AB C2 20 REP #$20 ; A 16-bit
$03:D7AD AF 7B 83 7F LDA.L $7F837B ; \
$03:D7B1 AA TAX ; / X = current write index of the stripe image buffer
$03:D7B2 A9 5A C0 LDA.W #$C05A ; \
$03:D7B5 18 CLC ; |
$03:D7B6 65 00 ADC $00 ; |
$03:D7B8 9F 7D 83 7F STA.L $7F837D,X ; / Stripe record 1: VRAM address $5AC0 + [$01] (tile column), +$0400 if page 2
$03:D7BC 09 00 20 ORA.W #$2000 ; \
$03:D7BF 9F 83 83 7F STA.L $7F8383,X ; / Stripe record 2: VRAM address = record 1 + $20 (next tilemap row)
$03:D7C3 A9 40 02 LDA.W #$0240 ; \
$03:D7C6 9F 7F 83 7F STA.L $7F837F,X ; |
$03:D7CA 9F 85 83 7F STA.L $7F8385,X ; / Both records: header $0240 = RLE, count - 1 = 2 (three tiles)
$03:D7CE A9 FC 38 LDA.W #$38FC ; \
$03:D7D1 9F 81 83 7F STA.L $7F8381,X ; |
$03:D7D5 9F 87 83 7F STA.L $7F8387,X ; / Both records: data = tile $FC (blank), attributes $38
$03:D7D9 A9 FF 00 LDA.W #$00FF ; \
$03:D7DC 9F 89 83 7F STA.L $7F8389,X ; / End of stripe image marker $FF
$03:D7E0 8A TXA ; \
$03:D7E1 18 CLC ; |
$03:D7E2 69 0C 00 ADC.W #$000C ; |
$03:D7E5 8F 7B 83 7F STA.L $7F837B ; / Stripe buffer index += $0C (two 6-byte records)
$03:D7E9 E2 30 SEP #$30 ; A, X and Y 8-bit
$03:D7EB 60 RTS ; Return
;;; $D7EC: Mode 7 room: clear map, draw Iggy platform (IggyPlatform) ;;;
;; Data: IggyPlatform = 16x16 block numbers of the tilting platform ($00 = empty); $D8EC = 4 tile
;; numbers per block (2x2 tiles, column order).
;; Code ($03D958, called from game mode code at $0097D8): clears the whole Mode 7 tilemap to tile $FF, then,
;; for Iggy/Larry rooms only ([$0D9B] bit 6 clear),
;; draws the platform at tilemap row 16, column 16 and keeps a copy of the block layout at $0AF6-$0BF5.
;; Quirk: the second tile row of each block row is written by repeating the same blocks with [$03] = 1.
$03:D7EC .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 0, blocks 0-7 (block numbers)
$03:D7F4 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 0, blocks 8-15 (block numbers)
$03:D7FC .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 1, blocks 0-7 (block numbers)
$03:D804 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 1, blocks 8-15 (block numbers)
$03:D80C .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 2, blocks 0-7 (block numbers)
$03:D814 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 2, blocks 8-15 (block numbers)
$03:D81C .db $00,$00,$15,$16,$17,$18,$17,$18 ; Platform layout row 3, blocks 0-7 (block numbers)
$03:D824 .db $17,$18,$17,$18,$19,$1A,$00,$00 ; Platform layout row 3, blocks 8-15 (block numbers)
$03:D82C .db $00,$00,$01,$02,$03,$04,$03,$04 ; Platform layout row 4, blocks 0-7 (block numbers)
$03:D834 .db $03,$04,$03,$04,$05,$12,$00,$00 ; Platform layout row 4, blocks 8-15 (block numbers)
$03:D83C .db $00,$00,$00,$07,$04,$03,$04,$03 ; Platform layout row 5, blocks 0-7 (block numbers)
$03:D844 .db $04,$03,$04,$03,$08,$00,$00,$00 ; Platform layout row 5, blocks 8-15 (block numbers)
$03:D84C .db $00,$00,$00,$09,$0A,$04,$03,$04 ; Platform layout row 6, blocks 0-7 (block numbers)
$03:D854 .db $03,$04,$03,$0B,$0C,$00,$00,$00 ; Platform layout row 6, blocks 8-15 (block numbers)
$03:D85C .db $00,$00,$00,$00,$0D,$0E,$04,$03 ; Platform layout row 7, blocks 0-7 (block numbers)
$03:D864 .db $04,$03,$0F,$10,$00,$00,$00,$00 ; Platform layout row 7, blocks 8-15 (block numbers)
$03:D86C .db $00,$00,$00,$00,$11,$02,$03,$04 ; Platform layout row 8, blocks 0-7 (block numbers)
$03:D874 .db $03,$04,$05,$12,$00,$00,$00,$00 ; Platform layout row 8, blocks 8-15 (block numbers)
$03:D87C .db $00,$00,$00,$00,$00,$07,$04,$03 ; Platform layout row 9, blocks 0-7 (block numbers)
$03:D884 .db $04,$03,$08,$00,$00,$00,$00,$00 ; Platform layout row 9, blocks 8-15 (block numbers)
$03:D88C .db $00,$00,$00,$00,$00,$09,$0A,$04 ; Platform layout row 10, blocks 0-7 (block numbers)
$03:D894 .db $03,$0B,$0C,$00,$00,$00,$00,$00 ; Platform layout row 10, blocks 8-15 (block numbers)
$03:D89C .db $00,$00,$00,$00,$00,$00,$13,$03 ; Platform layout row 11, blocks 0-7 (block numbers)
$03:D8A4 .db $04,$14,$00,$00,$00,$00,$00,$00 ; Platform layout row 11, blocks 8-15 (block numbers)
$03:D8AC .db $00,$00,$00,$00,$00,$00,$00,$13 ; Platform layout row 12, blocks 0-7 (block numbers)
$03:D8B4 .db $14,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 12, blocks 8-15 (block numbers)
$03:D8BC .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 13, blocks 0-7 (block numbers)
$03:D8C4 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 13, blocks 8-15 (block numbers)
$03:D8CC .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 14, blocks 0-7 (block numbers)
$03:D8D4 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 14, blocks 8-15 (block numbers)
$03:D8DC .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 15, blocks 0-7 (block numbers)
$03:D8E4 .db $00,$00,$00,$00,$00,$00,$00,$00 ; Platform layout row 15, blocks 8-15 (block numbers)
$03:D8EC .db $FF,$FF ; Block tile table, blocks 0-0 (4 tile numbers per block)
$03:D8EE .db $FF,$FF,$FF,$FF,$24,$34,$25,$0B ; Block tile table, blocks 0-2 (4 tile numbers per block)
$03:D8F6 .db $26,$36,$0E,$1B,$0C,$1C,$0D,$1D ; Block tile table, blocks 2-4 (4 tile numbers per block)
$03:D8FE .db $0E,$1E,$29,$39,$2A,$3A,$2B,$3B ; Block tile table, blocks 4-6 (4 tile numbers per block)
$03:D906 .db $26,$38,$20,$30,$21,$31,$27,$37 ; Block tile table, blocks 6-8 (4 tile numbers per block)
$03:D90E .db $28,$38,$FF,$FF,$22,$32,$0E,$33 ; Block tile table, blocks 8-10 (4 tile numbers per block)
$03:D916 .db $0C,$1C,$0D,$1D,$0E,$3C,$2D,$3D ; Block tile table, blocks 10-12 (4 tile numbers per block)
$03:D91E .db $FF,$FF,$07,$17,$0E,$23,$0E,$04 ; Block tile table, blocks 12-14 (4 tile numbers per block)
$03:D926 .db $0C,$1C,$0D,$1D,$0E,$09,$0E,$2C ; Block tile table, blocks 14-16 (4 tile numbers per block)
$03:D92E .db $0A,$1A,$FF,$FF,$24,$34,$2B,$3B ; Block tile table, blocks 16-18 (4 tile numbers per block)
$03:D936 .db $FF,$FF,$07,$17,$0E,$18,$0E,$19 ; Block tile table, blocks 18-20 (4 tile numbers per block)
$03:D93E .db $0A,$1A,$02,$12,$03,$13,$03,$08 ; Block tile table, blocks 20-22 (4 tile numbers per block)
$03:D946 .db $03,$05,$03,$05,$03,$14,$03,$15 ; Block tile table, blocks 22-24 (4 tile numbers per block)
$03:D94E .db $03,$05,$03,$05,$03,$08,$03,$06 ; Block tile table, blocks 24-26 (4 tile numbers per block)
$03:D956 .db $0F,$1F ; Block tile table, blocks 26-26 (4 tile numbers per block)
$03:D958 C2 10 REP #$10 ; Index 16-bit
$03:D95A 9C 15 21 STZ.W $2115 ; VMAIN = 0: VRAM address increments after each $2118 write
$03:D95D 9C 16 21 STZ.W $2116 ; \
$03:D960 9C 17 21 STZ.W $2117 ; / VRAM address = $0000: start of the Mode 7 tilemap
$03:D963 A2 00 40 LDX.W #$4000 ; X = $4000: size of the 128 x 128 tilemap
$03:D966 A9 FF LDA.B #$FF ; A = tile $FF (blank)
$03:D968 8D 18 21 STA.W $2118 ; \
$03:D96B CA DEX ; |
$03:D96C D0 FA BNE $D968 ; / Fill the whole Mode 7 tilemap with tile $FF
$03:D96E E2 10 SEP #$10 ; Index 8-bit
$03:D970 2C 9B 0D BIT.W $0D9B ; \
$03:D973 70 1B BVS $D990 ; / Bit 6 of [$0D9B] set (not Iggy/Larry): no platform, return
$03:D975 8B PHB ; \
$03:D976 4B PHK ; |
$03:D977 AB PLB ; / Data bank = $03 (old bank saved)
$03:D978 A9 EC LDA.B #$EC ; \
$03:D97A 85 05 STA $05 ; |
$03:D97C A9 D7 LDA.B #$D7 ; |
$03:D97E 85 06 STA $06 ; |
$03:D980 A9 03 LDA.B #$03 ; |
$03:D982 85 07 STA $07 ; / [$05] = $03D7EC: pointer to the platform block layout (IggyPlatform)
$03:D984 A9 10 LDA.B #$10 ; \
$03:D986 85 00 STA $00 ; |
$03:D988 A9 08 LDA.B #$08 ; |
$03:D98A 85 01 STA $01 ; / [$00] = $0810: VRAM address of the platform (tilemap row 16, column 16)
$03:D98C 20 91 D9 JSR.W $D991 ; Draw the platform into the tilemap
$03:D98F AB PLB ; Restore data bank
$03:D990 6B RTL ; Return
$03:D991 9C 15 21 STZ.W $2115 ; VMAIN = 0 again
$03:D994 A0 00 LDY.B #$00 ; Y = 0: index into the platform layout
$03:D996 84 02 STY $02 ; $02 = index of the first block of this row
$03:D998 A9 00 LDA.B #$00 ; A = 0
$03:D99A 85 03 STA $03 ; $03 = 0: first of the two tile rows of this block row
$03:D99C A5 00 LDA $00 ; \
$03:D99E 8D 16 21 STA.W $2116 ; |
$03:D9A1 A5 01 LDA $01 ; |
$03:D9A3 8D 17 21 STA.W $2117 ; / VRAM address = [$00]/[$01]
$03:D9A6 A4 02 LDY $02 ; Y = first block of this row
$03:D9A8 A9 10 LDA.B #$10 ; \
$03:D9AA 85 04 STA $04 ; / $04 = 16 blocks per row
$03:D9AC B7 05 LDA [$05],Y ; A = block number from the layout
$03:D9AE 99 F6 0A STA.W $0AF6,Y ; Keep a copy of the layout at $0AF6 + Y
$03:D9B1 0A ASL ; \
$03:D9B2 0A ASL ; |
$03:D9B3 05 03 ORA $03 ; |
$03:D9B5 AA TAX ; / X = block * 4 + [$03]: index into the block tile table
$03:D9B6 BF EC D8 03 LDA.L $D8EC,X ; \
$03:D9BA 8D 18 21 STA.W $2118 ; / Write the first tile of this block row ($D8EC)
$03:D9BD BF EE D8 03 LDA.L $D8EE,X ; \
$03:D9C1 8D 18 21 STA.W $2118 ; / Write the second tile ($D8EE = table + 2)
$03:D9C4 C8 INY ; Next block
$03:D9C5 C6 04 DEC $04 ; \
$03:D9C7 D0 E3 BNE $D9AC ; / Repeat for 16 blocks
$03:D9C9 A5 00 LDA $00 ; \
$03:D9CB 18 CLC ; |
$03:D9CC 69 80 ADC.B #$80 ; |
$03:D9CE 85 00 STA $00 ; |
$03:D9D0 90 02 BCC $D9D4 ; |
$03:D9D2 E6 01 INC $01 ; / [$00]/[$01] += $0080: next Mode 7 tilemap row
$03:D9D4 A5 03 LDA $03 ; \
$03:D9D6 49 01 EOR.B #$01 ; |
$03:D9D8 D0 C0 BNE $D99A ; / Toggle [$03]: if it was 0, redo the blocks for the second tile row ($03D99A)
$03:D9DA 98 TYA ; \
$03:D9DB D0 B9 BNE $D996 ; / Y = 0 after the last block (wrapped past 256)? Else next block row
$03:D9DD 60 RTS ; Return
;;; $D9DE..DD66: Table: Mode 7 picture tile maps ;;;
;; Tile number maps for the Mode 7 boss pictures, copied to the buffer $7E:C680 by $DEDF.
;; Frames $00-$1D are 4x4 tiles (16 bytes). Tile numbers come in pairs: even = normal, odd (= even | 1) =
;; horizontally mirrored.
;; From +$1E0 the pictures are 8 tiles wide; the last 4 rows are selected by frame number, the other rows of
;; the 12-row picture come from fixed positions +$320-$38F.
$03:D9DE .db $FF,$00,$FF,$FF,$02,$04,$06,$FF ; 4x4 tile picture, frame $00, tile rows 0-1 ($FF blank)
$03:D9E6 .db $08,$0A,$0C,$FF,$0E,$10,$12,$FF ; 4x4 tile picture, frame $00, tile rows 2-3 ($FF blank)
$03:D9EE .db $FF,$00,$FF,$FF,$02,$04,$06,$FF ; 4x4 tile picture, frame $01, tile rows 0-1 ($FF blank)
$03:D9F6 .db $08,$0A,$0C,$FF,$0E,$14,$16,$FF ; 4x4 tile picture, frame $01, tile rows 2-3 ($FF blank)
$03:D9FE .db $FF,$00,$FF,$FF,$02,$04,$06,$FF ; 4x4 tile picture, frame $02, tile rows 0-1 ($FF blank)
$03:DA06 .db $08,$0A,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $02, tile rows 2-3 ($FF blank)
$03:DA0E .db $46,$48,$4A,$FF,$4C,$4E,$50,$FF ; 4x4 tile picture, frame $03, tile rows 0-1 ($FF blank)
$03:DA16 .db $52,$54,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $03, tile rows 2-3 ($FF blank)
$03:DA1E .db $FF,$FF,$FF,$FF,$B2,$B4,$06,$FF ; 4x4 tile picture, frame $04, tile rows 0-1 ($FF blank)
$03:DA26 .db $D2,$D4,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $04, tile rows 2-3 ($FF blank)
$03:DA2E .db $FF,$1C,$FF,$FF,$1E,$20,$22,$FF ; 4x4 tile picture, frame $05, tile rows 0-1 ($FF blank)
$03:DA36 .db $24,$26,$28,$FF,$FF,$2A,$2C,$FF ; 4x4 tile picture, frame $05, tile rows 2-3 ($FF blank)
$03:DA3E .db $FF,$2E,$30,$FF,$32,$34,$35,$33 ; 4x4 tile picture, frame $06, tile rows 0-1 ($FF blank)
$03:DA46 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $06, tile rows 2-3 ($FF blank)
$03:DA4E .db $FF,$2E,$30,$FF,$32,$34,$35,$33 ; 4x4 tile picture, frame $07, tile rows 0-1 ($FF blank)
$03:DA56 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $07, tile rows 2-3 ($FF blank)
$03:DA5E .db $FF,$2E,$30,$FF,$32,$34,$35,$33 ; 4x4 tile picture, frame $08, tile rows 0-1 ($FF blank)
$03:DA66 .db $36,$38,$39,$37,$3E,$40,$41,$3F ; 4x4 tile picture, frame $08, tile rows 2-3 ($FF blank)
$03:DA6E .db $5A,$FF,$FF,$FF,$5C,$5E,$06,$FF ; 4x4 tile picture, frame $09, tile rows 0-1 ($FF blank)
$03:DA76 .db $08,$0A,$0C,$FF,$0E,$10,$12,$FF ; 4x4 tile picture, frame $09, tile rows 2-3 ($FF blank)
$03:DA7E .db $5A,$FF,$FF,$FF,$5C,$5E,$06,$FF ; 4x4 tile picture, frame $0A, tile rows 0-1 ($FF blank)
$03:DA86 .db $08,$0A,$0C,$FF,$0E,$14,$16,$FF ; 4x4 tile picture, frame $0A, tile rows 2-3 ($FF blank)
$03:DA8E .db $5A,$FF,$FF,$FF,$5C,$5E,$06,$FF ; 4x4 tile picture, frame $0B, tile rows 0-1 ($FF blank)
$03:DA96 .db $08,$0A,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $0B, tile rows 2-3 ($FF blank)
$03:DA9E .db $6C,$6E,$FF,$FF,$72,$74,$50,$FF ; 4x4 tile picture, frame $0C, tile rows 0-1 ($FF blank)
$03:DAA6 .db $52,$54,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $0C, tile rows 2-3 ($FF blank)
$03:DAAE .db $FF,$BE,$FF,$FF,$DC,$DE,$06,$FF ; 4x4 tile picture, frame $0D, tile rows 0-1 ($FF blank)
$03:DAB6 .db $D2,$D4,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $0D, tile rows 2-3 ($FF blank)
$03:DABE .db $60,$62,$FF,$FF,$64,$66,$22,$FF ; 4x4 tile picture, frame $0E, tile rows 0-1 ($FF blank)
$03:DAC6 .db $24,$26,$28,$FF,$FF,$2A,$2C,$FF ; 4x4 tile picture, frame $0E, tile rows 2-3 ($FF blank)
$03:DACE .db $FF,$68,$69,$FF,$32,$6A,$6B,$33 ; 4x4 tile picture, frame $0F, tile rows 0-1 ($FF blank)
$03:DAD6 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $0F, tile rows 2-3 ($FF blank)
$03:DADE .db $FF,$68,$69,$FF,$32,$6A,$6B,$33 ; 4x4 tile picture, frame $10, tile rows 0-1 ($FF blank)
$03:DAE6 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $10, tile rows 2-3 ($FF blank)
$03:DAEE .db $FF,$68,$69,$FF,$32,$6A,$6B,$33 ; 4x4 tile picture, frame $11, tile rows 0-1 ($FF blank)
$03:DAF6 .db $36,$38,$39,$37,$3E,$40,$41,$3F ; 4x4 tile picture, frame $11, tile rows 2-3 ($FF blank)
$03:DAFE .db $7A,$7C,$FF,$FF,$7E,$80,$82,$FF ; 4x4 tile picture, frame $12, tile rows 0-1 ($FF blank)
$03:DB06 .db $84,$86,$0C,$FF,$0E,$10,$12,$FF ; 4x4 tile picture, frame $12, tile rows 2-3 ($FF blank)
$03:DB0E .db $7A,$7C,$FF,$FF,$7E,$80,$06,$FF ; 4x4 tile picture, frame $13, tile rows 0-1 ($FF blank)
$03:DB16 .db $84,$86,$0C,$FF,$0E,$14,$16,$FF ; 4x4 tile picture, frame $13, tile rows 2-3 ($FF blank)
$03:DB1E .db $7A,$7C,$FF,$FF,$7E,$80,$06,$FF ; 4x4 tile picture, frame $14, tile rows 0-1 ($FF blank)
$03:DB26 .db $84,$86,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $14, tile rows 2-3 ($FF blank)
$03:DB2E .db $A0,$A2,$A4,$FF,$A6,$A8,$AA,$FF ; 4x4 tile picture, frame $15, tile rows 0-1 ($FF blank)
$03:DB36 .db $52,$54,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $15, tile rows 2-3 ($FF blank)
$03:DB3E .db $FF,$B8,$FF,$FF,$D6,$D8,$DA,$FF ; 4x4 tile picture, frame $16, tile rows 0-1 ($FF blank)
$03:DB46 .db $D2,$D4,$0C,$FF,$0E,$18,$1A,$FF ; 4x4 tile picture, frame $16, tile rows 2-3 ($FF blank)
$03:DB4E .db $88,$8A,$8C,$FF,$8E,$90,$92,$FF ; 4x4 tile picture, frame $17, tile rows 0-1 ($FF blank)
$03:DB56 .db $94,$96,$28,$FF,$FF,$2A,$2C,$FF ; 4x4 tile picture, frame $17, tile rows 2-3 ($FF blank)
$03:DB5E .db $98,$9A,$9B,$99,$9C,$9E,$9F,$9D ; 4x4 tile picture, frame $18, tile rows 0-1 ($FF blank)
$03:DB66 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $18, tile rows 2-3 ($FF blank)
$03:DB6E .db $98,$9A,$9B,$99,$9C,$9E,$9F,$9D ; 4x4 tile picture, frame $19, tile rows 0-1 ($FF blank)
$03:DB76 .db $36,$38,$39,$37,$42,$44,$45,$43 ; 4x4 tile picture, frame $19, tile rows 2-3 ($FF blank)
$03:DB7E .db $98,$9A,$9B,$99,$9C,$9E,$9F,$9D ; 4x4 tile picture, frame $1A, tile rows 0-1 ($FF blank)
$03:DB86 .db $36,$38,$39,$37,$3E,$40,$41,$3F ; 4x4 tile picture, frame $1A, tile rows 2-3 ($FF blank)
$03:DB8E .db $FF,$FF,$FF,$FF,$FF,$CC,$FF,$FF ; 4x4 tile picture, frame $1B, tile rows 0-1 ($FF blank)
$03:DB96 .db $C0,$C2,$C4,$FF,$E0,$E2,$E4,$FF ; 4x4 tile picture, frame $1B, tile rows 2-3 ($FF blank)
$03:DB9E .db $FF,$FF,$FF,$FF,$FF,$CC,$FF,$FF ; 4x4 tile picture, frame $1C, tile rows 0-1 ($FF blank)
$03:DBA6 .db $C6,$C8,$CA,$FF,$E6,$E8,$EA,$FF ; 4x4 tile picture, frame $1C, tile rows 2-3 ($FF blank)
$03:DBAE .db $FF,$FF,$FF,$FF,$FF,$CD,$FF,$FF ; 4x4 tile picture, frame $1D, tile rows 0-1 ($FF blank)
$03:DBB6 .db $C5,$C3,$C1,$FF,$E5,$E3,$E1,$FF ; 4x4 tile picture, frame $1D, tile rows 2-3 ($FF blank)
$03:DBBE .db $FF,$90,$92,$94,$96,$FF,$FF,$FF ; 8 tiles wide picture rows at +$1E0 (4 rows per frame, frame = offset / 16)
$03:DBC6 .db $FF,$B0,$B2,$B4,$B6,$38,$FF,$FF ; 8 tiles wide picture rows at +$1E8 (4 rows per frame, frame = offset / 16)
$03:DBCE .db $FF,$D0,$D2,$D4,$D6,$58,$5A,$FF ; 8 tiles wide picture rows at +$1F0 (4 rows per frame, frame = offset / 16)
$03:DBD6 .db $FF,$F0,$F2,$F4,$F6,$78,$7A,$FF ; 8 tiles wide picture rows at +$1F8 (4 rows per frame, frame = offset / 16)
$03:DBDE .db $FF,$90,$92,$94,$96,$FF,$FF,$FF ; 8 tiles wide picture rows at +$200 (4 rows per frame, frame = offset / 16)
$03:DBE6 .db $FF,$98,$9A,$9C,$B6,$38,$FF,$FF ; 8 tiles wide picture rows at +$208 (4 rows per frame, frame = offset / 16)
$03:DBEE .db $FF,$D0,$D2,$D4,$D6,$58,$5A,$FF ; 8 tiles wide picture rows at +$210 (4 rows per frame, frame = offset / 16)
$03:DBF6 .db $FF,$F0,$F2,$F4,$F6,$78,$7A,$FF ; 8 tiles wide picture rows at +$218 (4 rows per frame, frame = offset / 16)
$03:DBFE .db $FF,$90,$92,$94,$96,$FF,$FF,$FF ; 8 tiles wide picture rows at +$220 (4 rows per frame, frame = offset / 16)
$03:DC06 .db $FF,$98,$BA,$BC,$B6,$38,$FF,$FF ; 8 tiles wide picture rows at +$228 (4 rows per frame, frame = offset / 16)
$03:DC0E .db $FF,$D8,$DA,$DC,$D6,$58,$5A,$FF ; 8 tiles wide picture rows at +$230 (4 rows per frame, frame = offset / 16)
$03:DC16 .db $FF,$F8,$FA,$FC,$F6,$78,$7A,$FF ; 8 tiles wide picture rows at +$238 (4 rows per frame, frame = offset / 16)
$03:DC1E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$240 (4 rows per frame, frame = offset / 16)
$03:DC26 .db $FF,$FF,$90,$92,$94,$96,$FF,$FF ; 8 tiles wide picture rows at +$248 (4 rows per frame, frame = offset / 16)
$03:DC2E .db $FF,$FF,$98,$BA,$BC,$B6,$38,$FF ; 8 tiles wide picture rows at +$250 (4 rows per frame, frame = offset / 16)
$03:DC36 .db $FF,$FF,$D8,$DA,$DC,$D6,$58,$5A ; 8 tiles wide picture rows at +$258 (4 rows per frame, frame = offset / 16)
$03:DC3E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$260 (4 rows per frame, frame = offset / 16)
$03:DC46 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$268 (4 rows per frame, frame = offset / 16)
$03:DC4E .db $FF,$FF,$90,$92,$94,$96,$FF,$FF ; 8 tiles wide picture rows at +$270 (4 rows per frame, frame = offset / 16)
$03:DC56 .db $FF,$FF,$98,$BA,$BC,$B6,$38,$FF ; 8 tiles wide picture rows at +$278 (4 rows per frame, frame = offset / 16)
$03:DC5E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$280 (4 rows per frame, frame = offset / 16)
$03:DC66 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$288 (4 rows per frame, frame = offset / 16)
$03:DC6E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$290 (4 rows per frame, frame = offset / 16)
$03:DC76 .db $FF,$FF,$90,$92,$94,$96,$FF,$FF ; 8 tiles wide picture rows at +$298 (4 rows per frame, frame = offset / 16)
$03:DC7E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2A0 (4 rows per frame, frame = offset / 16)
$03:DC86 .db $FF,$90,$92,$94,$96,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2A8 (4 rows per frame, frame = offset / 16)
$03:DC8E .db $FF,$98,$BA,$BC,$B6,$38,$FF,$FF ; 8 tiles wide picture rows at +$2B0 (4 rows per frame, frame = offset / 16)
$03:DC96 .db $FF,$D8,$DA,$DC,$D6,$58,$5A,$FF ; 8 tiles wide picture rows at +$2B8 (4 rows per frame, frame = offset / 16)
$03:DC9E .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2C0 (4 rows per frame, frame = offset / 16)
$03:DCA6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2C8 (4 rows per frame, frame = offset / 16)
$03:DCAE .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2D0 (4 rows per frame, frame = offset / 16)
$03:DCB6 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF ; 8 tiles wide picture rows at +$2D8 (4 rows per frame, frame = offset / 16)
$03:DCBE .db $04,$06,$08,$0A,$0B,$09,$07,$05 ; 8 tiles wide picture rows at +$2E0 (4 rows per frame, frame = offset / 16)
$03:DCC6 .db $24,$26,$28,$2A,$2C,$29,$27,$25 ; 8 tiles wide picture rows at +$2E8 (4 rows per frame, frame = offset / 16)
$03:DCCE .db $FF,$84,$86,$88,$89,$87,$85,$FF ; 8 tiles wide picture rows at +$2F0 (4 rows per frame, frame = offset / 16)
$03:DCD6 .db $FF,$A4,$A6,$A8,$A9,$A7,$A5,$FF ; 8 tiles wide picture rows at +$2F8 (4 rows per frame, frame = offset / 16)
$03:DCDE .db $04,$06,$08,$0A,$0B,$09,$07,$05 ; 8 tiles wide picture rows at +$300 (4 rows per frame, frame = offset / 16)
$03:DCE6 .db $24,$26,$28,$2D,$2B,$29,$27,$25 ; 8 tiles wide picture rows at +$308 (4 rows per frame, frame = offset / 16)
$03:DCEE .db $FF,$84,$86,$88,$89,$87,$85,$FF ; 8 tiles wide picture rows at +$310 (4 rows per frame, frame = offset / 16)
$03:DCF6 .db $FF,$A4,$A6,$0C,$0D,$A7,$A5,$FF ; 8 tiles wide picture rows at +$318 (4 rows per frame, frame = offset / 16)
$03:DCFE .db $80,$82,$83,$8A,$82,$83,$8C,$8E ; Animated rows, variant 0 ([$1427] & 3), row 0
$03:DD06 .db $A0,$A2,$A3,$C4,$A2,$A3,$AC,$AE ; Animated rows, variant 0 ([$1427] & 3), row 1
$03:DD0E .db $80,$8A,$8A,$8A,$8A,$8A,$8C,$8E ; Animated rows, variant 1 ([$1427] & 3), row 0
$03:DD16 .db $A0,$60,$61,$C4,$60,$61,$AC,$AE ; Animated rows, variant 1 ([$1427] & 3), row 1
$03:DD1E .db $80,$03,$01,$8A,$00,$02,$8C,$8E ; Animated rows, variant 2 ([$1427] & 3), row 0
$03:DD26 .db $A0,$23,$21,$C4,$20,$22,$AC,$AE ; Animated rows, variant 2 ([$1427] & 3), row 1
$03:DD2E .db $80,$00,$02,$8A,$03,$01,$AA,$8E ; Animated rows, variant 3 ([$1427] & 3), row 0
$03:DD36 .db $A0,$20,$22,$C4,$23,$21,$AC,$AE ; Animated rows, variant 3 ([$1427] & 3), row 1
$03:DD3E .db $C0,$C2,$C4,$C4,$C4,$CA,$CC,$CE ; Static row 4 of the 12-row picture
$03:DD46 .db $E0,$E2,$E4,$E6,$E8,$EA,$EC,$EE ; Static row 5 of the 12-row picture
$03:DD4E .db $40,$42,$44,$46,$48,$4A,$4C,$4E ; Static row 6 of the 12-row picture
$03:DD56 .db $FF,$62,$64,$66,$68,$6A,$6C,$FF ; Static row 7 of the 12-row picture
$03:DD5E .db $10,$12,$14,$16,$18,$1A,$1C,$1E ; Row 1 of the 12-row picture (frame < $2C)
$03:DD66 .db $10,$30,$32,$34,$36,$1A,$1C,$1E ; Row 1 of the 12-row picture (frame >= $2C)
;;; $DD6E: Pointer table: boss palettes, low bytes (KoopaPalPtrLo) ;;;
;; Low bytes of the bank 0 addresses of the 12-byte palettes for boss numbers 0-4.
$03:DD6E .db $BC,$A4,$98,$78,$6C ; Boss palette pointers, low bytes (bank 0): $B2BC, $B2A4, $B298, $B378, $B36C
;;; $DD73: Mode 7 boss graphics and palette setup (KoopaPalPtrHi) ;;;
;; High bytes of the palette pointers, ExGFX file numbers per boss ($DD78), then the setup routine
;; ($03DD7D, called from Reznor and Koopa kid init code):
;; stores the boss number in [$13FC], copies the boss palette (6 colors) to $0707, decompresses the ExGFX file
;; and converts its 128 3bpp tiles to Mode 7 8bpp tile pairs (normal + mirrored) in VRAM,
;; and blanks the 96-byte tilemap buffer at $7E:C680. Boss 4 also draws an 8x8 tile block and sets Mode 7
;; values [$2C], [$38], [$39].
;; Parameters: X: sprite index (preserved). Sub-routine $03DDE5 converts one tile with the help of
;; $03DE39/$03DE3C.
$03:DD73 .db $B2,$B2,$B2,$B3,$B3 ; Boss palette pointers, high bytes
$03:DD78 .db $0B,$0B,$0B,$21,$00 ; ExGFX file per boss (0-4): $0B, $0B, $0B, $21, none
$03:DD7D DA PHX ; Save sprite index
$03:DD7E 8B PHB ; \
$03:DD7F 4B PHK ; |
$03:DD80 AB PLB ; / Data bank = $03 (old bank saved)
$03:DD81 B4 C2 LDY RAM_SpriteState,X ; \
$03:DD83 8C FC 13 STY.W $13FC ; / [$13FC] = boss number (the sprite state)
$03:DD86 C0 04 CPY.B #$04 ; \
$03:DD88 D0 0D BNE $DD97 ; / Boss 4 only: extra setup; others go to $03DD97
$03:DD8A 20 8E DE JSR.W $DE8E ; Draw the 8x8 tile block into the Mode 7 tilemap
$03:DD8D A9 48 LDA.B #$48 ; \
$03:DD8F 85 2C STA $2C ; / Mode 7 center Y low byte [$2C] = $48
$03:DD91 A9 14 LDA.B #$14 ; \
$03:DD93 85 38 STA $38 ; |
$03:DD95 85 39 STA $39 ; / Mode 7 matrix values [$38] = [$39] = $14 (probably the zoom)
$03:DD97 A9 FF LDA.B #$FF ; \
$03:DD99 85 5D STA RAM_ScreensInLvl ; / [$5D] (screens in level) = $FF
$03:DD9B 1A INC A ; A = 0
$03:DD9C 85 5E STA $5E ; [$5E] = 0
$03:DD9E AC FC 13 LDY.W $13FC ; Y = boss number
$03:DDA1 BE 78 DD LDX.W $DD78,Y ; X = ExGFX file for this boss ($DD78), 0 = none
$03:DDA4 B9 6E DD LDA.W KoopaPalPtrLo,Y ; \
$03:DDA7 85 00 STA $00 ; |
$03:DDA9 B9 73 DD LDA.W KoopaPalPtrHi,Y ; |
$03:DDAC 85 01 STA $01 ; |
$03:DDAE 64 02 STZ $02 ; / [$00] = $00:xxxx: pointer to the boss palette in bank 0
$03:DDB0 A0 0B LDY.B #$0B ; \
$03:DDB2 B7 00 LDA [$00],Y ; |
$03:DDB4 99 07 07 STA.W $0707,Y ; |
$03:DDB7 88 DEY ; |
$03:DDB8 10 F8 BPL $DDB2 ; / Copy 12 bytes (6 colors) of the palette to the CGRAM mirror at $0707
$03:DDBA A9 80 LDA.B #$80 ; \
$03:DDBC 8D 15 21 STA.W $2115 ; / VMAIN = $80: VRAM address increments after $2119 writes
$03:DDBF 9C 16 21 STZ.W $2116 ; \
$03:DDC2 9C 17 21 STZ.W $2117 ; / VRAM address = $0000
$03:DDC5 9B TXY ; Y = ExGFX file number
$03:DDC6 F0 0F BEQ $DDD7 ; None: skip the graphics upload
$03:DDC8 22 28 BA 00 JSL.L $BA28 ; Decompress ExGFX file Y to $7E:AD00 and point [$00] at it
$03:DDCC A9 80 LDA.B #$80 ; \
$03:DDCE 85 03 STA $03 ; / $03 = $80: number of 3bpp tiles to convert
$03:DDD0 20 E5 DD JSR.W $DDE5 ; Convert one tile (normal and mirrored copy) and upload it
$03:DDD3 C6 03 DEC $03 ; \
$03:DDD5 D0 F9 BNE $DDD0 ; / Repeat for all 128 tiles (256 Mode 7 tiles)
$03:DDD7 A2 5F LDX.B #$5F ; \
$03:DDD9 A9 FF LDA.B #$FF ; |
$03:DDDB 9F 80 C6 7E STA.L $7EC680,X ; |
$03:DDDF CA DEX ; |
$03:DDE0 10 F7 BPL $DDD9 ; / Fill the 96-byte Mode 7 tilemap buffer at $7E:C680 with tile $FF (blank)
$03:DDE2 AB PLB ; Restore data bank
$03:DDE3 FA PLX ; Restore sprite index
$03:DDE4 6B RTL ; Return
$03:DDE5 A2 00 LDX.B #$00 ; \
$03:DDE7 9B TXY ; / X = Y = 0: pixel buffer index and source byte index
$03:DDE8 A9 08 LDA.B #$08 ; \
$03:DDEA 85 05 STA $05 ; / $05 = 8 rows per tile
$03:DDEC 20 39 DE JSR.W $DE39 ; Read bitplanes 0 and 1 of this row into the pixel buffer
$03:DDEF 5A PHY ; \
$03:DDF0 98 TYA ; |
$03:DDF1 4A LSR ; |
$03:DDF2 18 CLC ; |
$03:DDF3 69 0F ADC.B #$0F ; |
$03:DDF5 A8 TAY ; / Y = Y / 2 + $0F: offset of bitplane 2 of this row
$03:DDF6 20 3C DE JSR.W $DE3C ; Read bitplane 2 of this row (pixel index X unchanged)
$03:DDF9 A0 08 LDY.B #$08 ; Y = 8 pixels per row
$03:DDFB BD A3 1B LDA.W $1BA3,X ; \
$03:DDFE 0A ASL ; |
$03:DDFF 2A ROL ; |
$03:DE00 2A ROL ; |
$03:DE01 2A ROL ; |
$03:DE02 29 07 AND.B #$07 ; |
$03:DE04 9D A3 1B STA.W $1BA3,X ; / A = 3-bit color of this pixel: rotate the three collected plane bits down
$03:DE07 8D 19 21 STA.W $2119 ; Write the pixel to the Mode 7 tile data (VRAM high byte)
$03:DE0A E8 INX ; \
$03:DE0B 88 DEY ; |
$03:DE0C D0 ED BNE $DDFB ; / Next pixel; repeat for the 8 pixels of the row
$03:DE0E 7A PLY ; Restore source byte index
$03:DE0F C6 05 DEC $05 ; \
$03:DE11 D0 D9 BNE $DDEC ; / Repeat for 8 rows
$03:DE13 A9 07 LDA.B #$07 ; A = 7: index of the last pixel in row 0
$03:DE15 AA TAX ; X = A
$03:DE16 A0 08 LDY.B #$08 ; \
$03:DE18 84 05 STY $05 ; / $05 = 8 pixels per row
$03:DE1A BC A3 1B LDY.W $1BA3,X ; \
$03:DE1D 8C 19 21 STY.W $2119 ; |
$03:DE20 CA DEX ; |
$03:DE21 C6 05 DEC $05 ; |
$03:DE23 D0 F5 BNE $DE1A ; / Write this row backwards (mirrored tile)
$03:DE25 18 CLC ; \
$03:DE26 69 08 ADC.B #$08 ; |
$03:DE28 C9 40 CMP.B #$40 ; |
$03:DE2A 90 E9 BCC $DE15 ; / Next row: A += 8, until all 8 rows are done
$03:DE2C C2 20 REP #$20 ; A 16-bit
$03:DE2E A5 00 LDA $00 ; \
$03:DE30 18 CLC ; |
$03:DE31 69 18 00 ADC.W #$0018 ; |
$03:DE34 85 00 STA $00 ; / [$00] += $18: next 3bpp tile (24 bytes)
$03:DE36 E2 20 SEP #$20 ; A 8-bit
$03:DE38 60 RTS ; Return
$03:DE39 20 3C DE JSR.W $DE3C ; Read two bitplane bytes (calls the routine below twice)
$03:DE3C DA PHX ; Save pixel index
$03:DE3D B7 00 LDA [$00],Y ; A = next bitplane byte of the row
$03:DE3F 5A PHY ; Save source index
$03:DE40 A0 08 LDY.B #$08 ; Y = 8 bits
$03:DE42 0A ASL ; \
$03:DE43 7E A3 1B ROR.W $1BA3,X ; |
$03:DE46 E8 INX ; |
$03:DE47 88 DEY ; |
$03:DE48 D0 F8 BNE $DE42 ; / Shift each bit of A into bit 7 of the pixel buffer bytes $1BA3 + X ...
$03:DE4A 7A PLY ; Restore source index
$03:DE4B C8 INY ; Y = next source byte
$03:DE4C FA PLX ; Restore pixel index
$03:DE4D 60 RTS ; Return
;;; $DE4E..DE86: Table: 8x8 Mode 7 tile block ;;;
;; Tile numbers (8 rows of 8) drawn by $DE8E; the last entry $3F is probably the corner.
$03:DE4E .db $40,$41,$42,$43,$44,$45,$46,$47 ; Tile row 0 of the 8x8 tile block
$03:DE56 .db $50,$51,$52,$53,$54,$55,$56,$57 ; Tile row 1 of the 8x8 tile block
$03:DE5E .db $60,$61,$62,$63,$64,$65,$66,$67 ; Tile row 2 of the 8x8 tile block
$03:DE66 .db $70,$71,$72,$73,$74,$75,$76,$77 ; Tile row 3 of the 8x8 tile block
$03:DE6E .db $48,$49,$4A,$4B,$4C,$4D,$4E,$4F ; Tile row 4 of the 8x8 tile block
$03:DE76 .db $58,$59,$5A,$5B,$5C,$5D,$5E,$5F ; Tile row 5 of the 8x8 tile block
$03:DE7E .db $68,$69,$6A,$6B,$6C,$6D,$6E,$6F ; Tile row 6 of the 8x8 tile block
$03:DE86 .db $78,$79,$7A,$7B,$7C,$7D,$7E,$3F ; Tile row 7 of the 8x8 tile block
;;; $DE8E: Draw 8x8 tile block into Mode 7 map ;;;
;; Writes the 64 tile numbers of $DE4E as 8 rows of 8 tiles into the Mode 7 tilemap at VRAM word address
;; $0A9C (row 21, column 28), one row per $80 words.
;; Only used for boss 4 by the setup routine.
;; Called by:
;; $03:DD8A: Mode 7 boss graphics and palette setup (KoopaPalPtrHi)
$03:DE8E 9C 15 21 STZ.W $2115 ; VMAIN = 0: VRAM address increments after $2118 writes
$03:DE91 C2 20 REP #$20 ; A 16-bit
$03:DE93 A9 1C 0A LDA.W #$0A1C ; \
$03:DE96 85 00 STA $00 ; / [$00] = $0A1C: VRAM address of the block minus one tilemap row ($80)
$03:DE98 A2 00 LDX.B #$00 ; X = 0: index into $DE4E
$03:DE9A C2 20 REP #$20 ; A 16-bit
$03:DE9C A5 00 LDA $00 ; \
$03:DE9E 18 CLC ; |
$03:DE9F 69 80 00 ADC.W #$0080 ; |
$03:DEA2 85 00 STA $00 ; |
$03:DEA4 8D 16 21 STA.W $2116 ; / [$00] += $80 (next tilemap row) and set it as the VRAM address
$03:DEA7 E2 20 SEP #$20 ; A 8-bit
$03:DEA9 A0 08 LDY.B #$08 ; Y = 8 tiles per row
$03:DEAB BF 4E DE 03 LDA.L $DE4E,X ; \
$03:DEAF 8D 18 21 STA.W $2118 ; / Write the tile number to the Mode 7 tilemap
$03:DEB2 E8 INX ; \
$03:DEB3 88 DEY ; |
$03:DEB4 D0 F5 BNE $DEAB ; / Repeat for 8 tiles
$03:DEB6 E0 40 CPX.B #$40 ; \
$03:DEB8 90 E0 BCC $DE9A ; / Repeat for 8 rows (64 tiles)
$03:DEBA 60 RTS ; Return
;;; $DEBB..DED7: Tables: Mode 7 scroll offsets and animation ;;;
;; $DEBB: scroll offsets ($0100, $0110). $DEBF/03DEC7/03DECF: animated top strip tiles.
;; $DED7: source offsets of animated rows.
$03:DEBB .db $00,$01,$10,$01 ; Mode 7 scroll offsets: X = $0100, Y = $0110 (16-bit words)
$03:DEBF .db $6E,$70,$FF,$50,$FE,$FE,$FF,$57 ; Top strip tiles 1-2 for animation frames 0-3
$03:DEC7 .db $72,$74,$52,$54,$3C,$3E,$55,$53 ; Top strip tiles 3-4 for animation frames 0-3
$03:DECF .db $76,$56,$56,$FF,$FF,$FF,$51,$FF ; Top strip tiles 5-6 for animation frames 0-3
$03:DED7 .db $20,$03,$30,$03,$40,$03,$50,$03 ; Animated row offsets: $0320, $0330, $0340, $0350
;;; $DEDF: Position Mode 7 picture, build tilemap ;;;
;; Called each frame by the boss and Reznor code. Sets the Mode 7 scroll [$3A]/[$3C] so the picture sits at
;; the sprite position in X/Y,
;; then builds the tilemap in the buffer at $7E:C680: either a 4x4 picture frame ([$0D9B] bit 0 clear) or a
;; 12-row, 8-wide picture with animated rows ([$0D9B] bit 0 set).
;; [$1BA2]: bits 0-6 = frame number, bit 7 = flip horizontally (reads rows backwards and swaps tile numbers
;; with their mirror, bit 0).
;; [$1BA1]: only its sign (bit 15 of the word) is used. $03DFAE: computes one scroll value (Y = 0: horizontal,
;; Y = 2: vertical).
;; Parameters: X: sprite index (preserved). A is lost.
;; Called by:
;; $01:CDD8: Morton, Roy and Ludwig main routine (WallKoopaKids)
;; $01:D036: Ludwig sub-states: walk and jump; hit and death states
;; $03:98BE: Reznor ring: sign and level end (ReznorSignCode)
;; $03:A2A1: Bowser main logic
$03:DEDF 8B PHB ; \
$03:DEE0 4B PHK ; |
$03:DEE1 AB PLB ; / Data bank = $03 (old bank saved)
$03:DEE2 BD E0 14 LDA.W RAM_SpriteXHi,X ; \
$03:DEE5 EB XBA ; |
$03:DEE6 B5 E4 LDA RAM_SpriteXLo,X ; / A = sprite X position (16 bit)
$03:DEE8 A0 00 LDY.B #$00 ; \
$03:DEEA 20 AE DF JSR.W $DFAE ; / Mode 7 H-scroll [$3A] = [$1A] + $0100 - sprite X
$03:DEED BD D4 14 LDA.W RAM_SpriteYHi,X ; \
$03:DEF0 EB XBA ; |
$03:DEF1 B5 D8 LDA RAM_SpriteYLo,X ; / A = sprite Y position (16 bit)
$03:DEF3 A0 02 LDY.B #$02 ; \
$03:DEF5 20 AE DF JSR.W $DFAE ; / Mode 7 V-scroll [$3C] = [$1C] + $0110 - sprite Y
$03:DEF8 DA PHX ; Save sprite index
$03:DEF9 C2 30 REP #$30 ; A, X and Y 16-bit
$03:DEFB 64 06 STZ $06 ; $06 = 0: write index into the tilemap buffer $7E:C680
$03:DEFD A0 03 00 LDY.W #$0003 ; Y = 3: row width - 1 (4 tiles)
$03:DF00 AD 9B 0D LDA.W $0D9B ; \
$03:DF03 4A LSR ; |
$03:DF04 90 3E BCC $DF44 ; / [$0D9B] bit 0 clear: 4x4 tile picture, go to $03DF44
$03:DF06 AD 28 14 LDA.W $1428 ; \
$03:DF09 29 03 00 AND.W #$0003 ; |
$03:DF0C 0A ASL ; |
$03:DF0D AA TAX ; / X = ([$1428] & 3) * 2: top strip animation frame
$03:DF0E BF BF DE 03 LDA.L $DEBF,X ; \
$03:DF12 8F 81 C6 7E STA.L $7EC681 ; / Top strip tiles 1-2 = $DEBF[X]
$03:DF16 BF C7 DE 03 LDA.L $DEC7,X ; \
$03:DF1A 8F 83 C6 7E STA.L $7EC683 ; / Top strip tiles 3-4 = $DEC7[X]
$03:DF1E BF CF DE 03 LDA.L $DECF,X ; \
$03:DF22 8F 85 C6 7E STA.L $7EC685 ; / Top strip tiles 5-6 = $DECF[X]
$03:DF26 A9 08 00 LDA.W #$0008 ; \
$03:DF29 85 06 STA $06 ; / $06 = 8: the rows below start after the 8-tile top strip
$03:DF2B A2 80 03 LDX.W #$0380 ; X = $0380: table offset of the second row
$03:DF2E AD A2 1B LDA.W $1BA2 ; \
$03:DF31 29 7F 00 AND.W #$007F ; |
$03:DF34 C9 2C 00 CMP.W #$002C ; |
$03:DF37 90 03 BCC $DF3C ; |
$03:DF39 A2 88 03 LDX.W #$0388 ; / If frame ([$1BA2] & $7F) >= $2C use offset $0388 instead
$03:DF3C 8A TXA ; A = table offset of the second row
$03:DF3D A2 0A 00 LDX.W #$000A ; X = $0A: pass counter (11 rows to copy)
$03:DF40 A0 07 00 LDY.W #$0007 ; Y = 7: row width - 1 (8 tiles)
$03:DF43 38 SEC ; Carry set: skip the frame offset calculation
$03:DF44 84 00 STY $00 ; $00 = row width - 1
$03:DF46 B0 0D BCS $DF55 ; Carry set (8-wide picture): start copying
$03:DF48 AD A2 1B LDA.W $1BA2 ; \
$03:DF4B 29 7F 00 AND.W #$007F ; |
$03:DF4E 0A ASL ; |
$03:DF4F 0A ASL ; |
$03:DF50 0A ASL ; |
$03:DF51 0A ASL ; / A = ([$1BA2] & $7F) * 16: offset of the frame in $D9DE
$03:DF52 A2 03 00 LDX.W #$0003 ; X = 3: four rows per frame
$03:DF55 86 02 STX $02 ; $02 = number of passes left
$03:DF57 48 PHA ; Save the table offset
$03:DF58 AC A1 1B LDY.W $1BA1 ; \
$03:DF5B 10 03 BPL $DF60 ; |
$03:DF5D 18 CLC ; |
$03:DF5E 65 00 ADC $00 ; / If [$1BA2] bit 7 is set (flipped): start at the end of the row
$03:DF60 A8 TAY ; Y = table offset
$03:DF61 E2 20 SEP #$20 ; A 8-bit
$03:DF63 A6 06 LDX $06 ; X = write index into the tilemap buffer
$03:DF65 A5 00 LDA $00 ; \
$03:DF67 85 04 STA $04 ; / $04 = row width - 1: tile counter
$03:DF69 B9 DE D9 LDA.W $D9DE,Y ; A = tile number from the picture table
$03:DF6C C8 INY ; Next table byte
$03:DF6D 2C A2 1B BIT.W $1BA2 ; \
$03:DF70 10 04 BPL $DF76 ; / Not flipped: keep the tile
$03:DF72 49 01 EOR.B #$01 ; \
$03:DF74 88 DEY ; |
$03:DF75 88 DEY ; / Flipped: use the mirrored tile (toggle bit 0) and walk backwards
$03:DF76 9F 80 C6 7E STA.L $7EC680,X ; Store the tile in the tilemap buffer
$03:DF7A E8 INX ; Next buffer byte
$03:DF7B C6 04 DEC $04 ; \
$03:DF7D 10 EA BPL $DF69 ; / Repeat for the whole row
$03:DF7F 86 06 STX $06 ; Save the buffer write index
$03:DF81 C2 20 REP #$20 ; A 16-bit
$03:DF83 68 PLA ; \
$03:DF84 38 SEC ; |
$03:DF85 65 00 ADC $00 ; / A = saved table offset + row width: next row
$03:DF87 A6 02 LDX $02 ; X = passes left
$03:DF89 E0 04 00 CPX.W #$0004 ; \
$03:DF8C F0 BA BEQ $DF48 ; / Pass 4: switch to the frame dependent rows ($03DF48)
$03:DF8E E0 08 00 CPX.W #$0008 ; \
$03:DF91 D0 03 BNE $DF96 ; |
$03:DF93 A9 60 03 LDA.W #$0360 ; / Pass 8: next source = $0360 (static rows)
$03:DF96 E0 0A 00 CPX.W #$000A ; \
$03:DF99 D0 0B BNE $DFA6 ; |
$03:DF9B AD 27 14 LDA.W $1427 ; |
$03:DF9E 29 03 00 AND.W #$0003 ; |
$03:DFA1 0A ASL ; |
$03:DFA2 A8 TAY ; |
$03:DFA3 B9 D7 DE LDA.W $DED7,Y ; / Pass 10: next source = $DED7[([$1427] & 3) * 2] (animated rows)
$03:DFA6 CA DEX ; \
$03:DFA7 10 AC BPL $DF55 ; / Next pass; repeat until X < 0
$03:DFA9 E2 30 SEP #$30 ; A, X and Y 8-bit
$03:DFAB FA PLX ; Restore sprite index
$03:DFAC AB PLB ; Restore data bank
$03:DFAD 6B RTL ; Return
$03:DFAE DA PHX ; Save X
$03:DFAF BB TYX ; X = Y (0 = horizontal, 2 = vertical)
$03:DFB0 C2 20 REP #$20 ; A 16-bit
$03:DFB2 49 FF FF EOR.W #$FFFF ; \
$03:DFB5 1A INC A ; |
$03:DFB6 18 CLC ; |
$03:DFB7 7F BB DE 03 ADC.L $DEBB,X ; |
$03:DFBB 18 CLC ; |
$03:DFBC 75 1A ADC RAM_ScreenBndryXLo,X ; |
$03:DFBE 95 3A STA $3A,X ; / Scroll [$3A+X] = -A + $DEBB[X] + screen boundary ([$1A] or [$1C])
$03:DFC0 E2 20 SEP #$20 ; A 8-bit
$03:DFC2 FA PLX ; Restore X
$03:DFC3 60 RTS ; Return
;;; $DFC4..DFC4: Table: palette set offsets ;;;
;; 8 offsets in steps of $0E into $B69E, indexed by [$1429] at $03E039; probably lightning flash palette
;; sets.
$03:DFC4 .db $00,$0E,$1C,$2A,$38,$46,$54,$62 ; Offsets (14 apart) into $B69E, probably palette sets
;;; $DFCC: Bowser room palette and lightning flash ;;;
;; Called from Bowser's INIT/main (JSL at BowserFight). Appends an 8-color CGRAM upload record (start color 0)
;; to the palette buffer at [$0681].
;; Color 0 (backdrop) flashes with thunder: a random delay in [$1FFC] counts down, then [$1FFB] steps through
;; $B5DE colors and sound $18 plays.
;; Colors 1-7 come from a 14-byte row of $B69E selected by [$1429]; [$190D] non-zero (hedged: no
;; lightning) keeps the backdrop color [$0701].
;; Called by:
;; $03:A259: Bowser fight sprite main (BowserFight)
$03:DFCC DA PHX ; Save X
$03:DFCD AE 81 06 LDX.W $0681 ; X = palette buffer write index [$0681]
$03:DFD0 A9 10 LDA.B #$10 ; \
$03:DFD2 9D 82 06 STA.W $0682,X ; / Record header: byte count = $10 (8 colors)
$03:DFD5 9E 83 06 STZ.W $0683,X ; CGRAM start address = 0 (backdrop color)
$03:DFD8 9E 84 06 STZ.W $0684,X ; \
$03:DFDB 9E 85 06 STZ.W $0685,X ; / Default color 0 = $0000 (replaced below)
$03:DFDE 9B TXY ; Y = write index (X is reused)
$03:DFDF AE FB 1F LDX.W $1FFB ; X = [$1FFB] (lightning flash step, 0 = no flash running)
$03:DFE2 D0 37 BNE $E01B ; Flash running: continue it at $03E01B
$03:DFE4 AD 0D 19 LDA.W $190D ; \
$03:DFE7 F0 07 BEQ $DFF0 ; / [$190D] (probably disables lightning) = 0: go check for a new flash
$03:DFE9 C2 20 REP #$20 ; A 16-bit
$03:DFEB AD 01 07 LDA.W $0701 ; A = [$0701] (current backdrop color)
$03:DFEE 80 41 BRA $E031 ; Use it unchanged as color 0
$03:DFF0 A5 14 LDA RAM_FrameCounterB ; A = [RAM_FrameCounterB]
$03:DFF2 4A LSR ; \
$03:DFF3 90 41 BCC $E036 ; / Only act on odd frames
$03:DFF5 CE FC 1F DEC.W $1FFC ; \
$03:DFF8 D0 3C BNE $E036 ; / Count down [$1FFC] (delay to next flash); not zero: no new flash
$03:DFFA AA TAX ; X = frame counter / 2 (random-looking index)
$03:DFFB BF 08 F7 04 LDA.L $F708,X ; Read a byte from ROM $04F708 as a pseudo-random number
$03:DFFF 29 07 AND.B #$07 ; \
$03:E001 AA TAX ; / X = random 0-7
$03:E002 BF F8 F6 04 LDA.L $F6F8,X ; \
$03:E006 8D FC 1F STA.W $1FFC ; / [$1FFC] = $F6F8[X] (frames until the next flash)
$03:E009 BF 00 F7 04 LDA.L $F700,X ; \
$03:E00D 8D FB 1F STA.W $1FFB ; / [$1FFB] = $F700[X] (flash length in steps)
$03:E010 AA TAX ; X = [$1FFB]
$03:E011 A9 08 LDA.B #$08 ; \
$03:E013 8D FD 1F STA.W $1FFD ; / [$1FFD] = 8 (frames for the first step)
$03:E016 A9 18 LDA.B #$18 ; \
$03:E018 8D FC 1D STA.W $1DFC ; / Play sound effect $18 (thunder)
$03:E01B CE FD 1F DEC.W $1FFD ; Step timer [$1FFD]--
$03:E01E 10 08 BPL $E028 ; Still >= 0: keep the same step
$03:E020 CE FB 1F DEC.W $1FFB ; Next step: [$1FFB]--
$03:E023 A9 04 LDA.B #$04 ; \
$03:E025 8D FD 1F STA.W $1FFD ; / [$1FFD] = 4 (frames per later step)
$03:E028 8A TXA ; \
$03:E029 0A ASL ; |
$03:E02A AA TAX ; } X = [$1FFB] * 2: word index into the flash color table
$03:E02B C2 20 REP #$20 ; A 16-bit
$03:E02D BF DE B5 00 LDA.L $B5DE,X ; A = flash color $B5DE[X]
$03:E031 99 84 06 STA.W $0684,Y ; Color 0 (backdrop) in the buffer = A
$03:E034 E2 20 SEP #$20 ; A 8-bit
$03:E036 AE 29 14 LDX.W $1429 ; X = [$1429] (probably Bowser's phase / palette row)
$03:E039 BF C4 DF 03 LDA.L $DFC4,X ; \
$03:E03D AA TAX ; / X = row offset (row * $0E) into the palette table
$03:E03E A9 0E LDA.B #$0E ; \
$03:E040 85 00 STA $00 ; / Byte counter = $0E (colors 1-7)
$03:E042 BF 9E B6 00 LDA.L $B69E,X ; Copy a palette byte from $B69E[X]...
$03:E046 99 86 06 STA.W $0686,Y ; ...into the buffer (colors 1-7 of the record)
$03:E049 E8 INX ; Next source byte
$03:E04A C8 INY ; Next buffer byte
$03:E04B C6 00 DEC $00 ; \
$03:E04D D0 F3 BNE $E042 ; / Loop for all 14 bytes
$03:E04F BB TYX ; X = end of record
$03:E050 9E 86 06 STZ.W $0686,X ; Write terminator 0 after the record
$03:E053 E8 INX ; \
$03:E054 E8 INX ; |
$03:E055 E8 INX ; |
$03:E056 E8 INX ; } Buffer index += 4 (so [$0681] = old index + 18)
$03:E057 8E 81 06 STX.W $0681 ; Store the new palette buffer index
$03:E05A FA PLX ; Restore X
$03:E05B 6B RTL ; Return
;;; $E05C..E3FC: Padding ($FF) ;;;
$03:E05C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E064 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E06C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E074 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E07C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E084 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E08C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E094 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E09C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E0FC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E104 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E10C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E114 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E11C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E124 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E12C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E134 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E13C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E144 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E14C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E154 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E15C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E164 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E16C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E174 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E17C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E184 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E18C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E194 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E19C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E1FC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E204 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E20C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E214 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E21C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E224 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E22C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E234 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E23C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E244 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E24C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E254 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E25C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E264 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E26C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E274 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E27C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E284 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E28C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E294 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E29C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E2FC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E304 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E30C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E314 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E31C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E324 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E32C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E334 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E33C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E344 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E34C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E354 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E35C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E364 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E36C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E374 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E37C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E384 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E38C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E394 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E39C .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3A4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3AC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3B4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3BC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3C4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3CC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3D4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3DC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3E4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3EC .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3F4 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:E3FC .db $FF,$FF,$FF,$FF
;;; $E400: Ending music block header (disassembled as code) ;;;
;; Not code: these bytes are the start of the SPC700 music bank 3 block uploaded by UploadMusicBank3
;; ($03E400). Disassembler produced DEC/RTS.
$03:E400 C6 19 DEC RAM_MarioPowerUp ; Unreferenced as code: the start of the ending music block header (see UploadMusicBank3)
$03:E402 60 RTS ; Header continues: length probably $19C6, SPC address probably $1360
;;; $E403..FDDB: Ending music bank 3 data (SPC700) ;;;
;; Music sequence data for the ending, uploaded to the SPC700 as one block starting at $03E400. Not 65816
;; data.
$03:E403 .db $13,$78,$13,$BE,$14,$F2,$14,$1C
$03:E40B .db $16,$78,$13,$BE,$14,$F2,$14,$1C
$03:E413 .db $16,$78,$13,$BE,$14,$F2,$14,$1C
$03:E41B .db $16,$9E,$13,$AE,$13,$BE,$13,$DE
$03:E423 .db $13,$CE,$13,$EE,$13,$FE,$13,$0E
$03:E42B .db $14,$1E,$14,$2E,$14,$3E,$14,$4E
$03:E433 .db $14,$5E,$14,$6E,$14,$7E,$14,$8E
$03:E43B .db $14,$9E,$14,$AE,$14,$00,$00,$94
$03:E443 .db $21,$00,$00,$00,$00,$00,$00,$00
$03:E44B .db $00,$00,$00,$00,$00,$00,$00,$97
$03:E453 .db $21,$BB,$21,$51,$22,$F7,$21,$33
$03:E45B .db $22,$15,$22,$D9,$21,$73,$22,$92
$03:E463 .db $22,$B4,$23,$E2,$23,$00,$00,$00
$03:E46B .db $00,$00,$00,$CC,$23,$0F,$24,$C9
$03:E473 .db $22,$B4,$23,$E2,$23,$00,$23,$00
$03:E47B .db $00,$1A,$23,$CC,$23,$0F,$24,$44
$03:E483 .db $24,$6B,$24,$AF,$24,$00,$00,$00
$03:E48B .db $00,$00,$00,$8E,$24,$DF,$24,$35
$03:E493 .db $25,$6E,$25,$B2,$25,$5C,$25,$00
$03:E49B .db $00,$0F,$25,$91,$25,$E2,$25,$12
$03:E4A3 .db $26,$8D,$26,$B1,$26,$61,$26,$00
$03:E4AB .db $00,$3A,$26,$A0,$26,$E1,$26,$11
$03:E4B3 .db $27,$7E,$27,$A8,$27,$54,$27,$00
$03:E4BB .db $00,$33,$27,$94,$27,$0F,$24,$D1
$03:E4C3 .db $22,$B4,$23,$E2,$23,$00,$23,$7E
$03:E4CB .db $23,$50,$23,$CC,$23,$0F,$24,$14
$03:E4D3 .db $28,$54,$28,$80,$28,$4C,$28,$2C
$03:E4DB .db $28,$FD,$27,$6B,$28,$A4,$28,$C8
$03:E4E3 .db $28,$E7,$28,$7D,$29,$23,$29,$5F
$03:E4EB .db $29,$41,$29,$05,$29,$9F,$29,$D1
$03:E4F3 .db $22,$BE,$29,$E2,$23,$00,$23,$7E
$03:E4FB .db $23,$50,$23,$CC,$23,$0F,$24,$14
$03:E503 .db $28,$F5,$29,$0D,$2A,$4C,$28,$2C
$03:E50B .db $28,$FD,$27,$6B,$28,$A4,$28,$47
$03:E513 .db $2A,$66,$2A,$00,$2B,$A2,$2A,$E0
$03:E51B .db $2A,$C0,$2A,$84,$2A,$24,$2B,$79
$03:E523 .db $2B,$43,$2B,$E2,$23,$00,$23,$E2
$03:E52B .db $2B,$AE,$2B,$CC,$23,$0F,$24,$47
$03:E533 .db $2C,$18,$2C,$0D,$2A,$4C,$28,$5F
$03:E53B .db $2C,$30,$2C,$6B,$28,$A4,$28,$25
$03:E543 .db $2A,$66,$2A,$00,$2B,$A2,$2A,$E0
$03:E54B .db $2A,$C0,$2A,$84,$2A,$24,$2B,$7F
$03:E553 .db $2C,$98,$2C,$0C,$2D,$C8,$2C,$F6
$03:E55B .db $2C,$E0,$2C,$B0,$2C,$00,$00,$C2
$03:E563 .db $14,$00,$00,$76,$1E,$C5,$1E,$F0
$03:E56B .db $1E,$A2,$1E,$03,$1F,$2A,$1F,$49
$03:E573 .db $1F,$68,$1F,$A4,$1F,$0A,$20,$4C
$03:E57B .db $20,$E9,$1F,$C8,$1F,$83,$1F,$2C
$03:E583 .db $20,$7B,$20,$A6,$20,$C8,$20,$5A
$03:E58B .db $21,$04,$21,$3E,$21,$22,$21,$E6
$03:E593 .db $20,$7A,$21,$D2,$14,$E2,$14,$2C
$03:E59B .db $15,$4C,$15,$3C,$15,$5C,$15,$6C
$03:E5A3 .db $15,$7C,$15,$8C,$15,$9C,$15,$AC
$03:E5AB .db $15,$CC,$15,$BC,$15,$DC,$15,$EC
$03:E5B3 .db $15,$AE,$13,$4E,$14,$5E,$14,$6E
$03:E5BB .db $14,$7E,$14,$8E,$14,$6E,$14,$FC
$03:E5C3 .db $15,$6E,$14,$7E,$14,$8E,$14,$9E
$03:E5CB .db $14,$0C,$16,$00,$00,$3D,$16,$93
$03:E5D3 .db $17,$BD,$17,$1B,$17,$57,$17,$99
$03:E5DB .db $16,$00,$00,$E7,$17,$3D,$16,$93
$03:E5E3 .db $17,$BD,$17,$1B,$17,$57,$17,$DE
$03:E5EB .db $16,$00,$00,$E7,$17,$00,$18,$EF
$03:E5F3 .db $18,$10,$19,$89,$18,$BC,$18,$55
$03:E5FB .db $18,$00,$00,$E7,$17,$31,$19,$E4
$03:E603 .db $19,$05,$1A,$8A,$19,$B7,$19,$5F
$03:E60B .db $19,$00,$00,$E7,$17,$C8,$1A,$AB
$03:E613 .db $1B,$CC,$1B,$3F,$1B,$77,$1B,$91
$03:E61B .db $1B,$00,$00,$E7,$17,$ED,$1B,$6E
$03:E623 .db $1C,$8F,$1C,$1B,$1C,$48,$1C,$5B
$03:E62B .db $1C,$00,$00,$E7,$17,$C8,$1A,$AB
$03:E633 .db $1B,$CC,$1B,$3F,$1B,$77,$1B,$91
$03:E63B .db $1B,$01,$1B,$E7,$17,$B0,$1C,$70
$03:E643 .db $1D,$90,$1D,$19,$1D,$4A,$1D,$5D
$03:E64B .db $1D,$E2,$1C,$AE,$1D,$3D,$16,$93
$03:E653 .db $17,$BD,$17,$1B,$17,$57,$17,$99
$03:E65B .db $16,$7C,$16,$E7,$17,$3D,$16,$93
$03:E663 .db $17,$BD,$17,$1B,$17,$57,$17,$DE
$03:E66B .db $16,$7C,$16,$E7,$17,$00,$18,$EF
$03:E673 .db $18,$10,$19,$89,$18,$BC,$18,$55
$03:E67B .db $18,$34,$18,$E7,$17,$26,$1A,$A6
$03:E683 .db $1A,$B7,$1A,$4E,$1A,$67,$1A,$80
$03:E68B .db $1A,$40,$1A,$E7,$17,$32,$16,$00
$03:E693 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:E69B .db $00,$00,$00,$00,$00,$3A,$16,$00
$03:E6A3 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:E6AB .db $00,$00,$00,$00,$00,$C1,$1D,$D4
$03:E6B3 .db $1D,$58,$1E,$F8,$1D,$3E,$1E,$0A
$03:E6BB .db $1E,$E6,$1D,$24,$1E,$2C,$15,$4C
$03:E6C3 .db $15,$2C,$15,$5C,$15,$6C,$15,$7C
$03:E6CB .db $15,$6C,$15,$9C,$15,$FF,$00,$1C
$03:E6D3 .db $16,$00,$00,$DA,$04,$E2,$16,$E3
$03:E6DB .db $90,$1B,$00,$E4,$01,$00,$DA,$12
$03:E6E3 .db $E2,$1E,$DB,$0A,$DE,$14,$19,$27
$03:E6EB .db $0C,$6D,$B4,$0C,$2E,$B7,$B9,$30
$03:E6F3 .db $6E,$B7,$0C,$2D,$B9,$0C,$6E,$BB
$03:E6FB .db $C6,$0C,$2D,$BB,$30,$6E,$B9,$0C
$03:E703 .db $2D,$B3,$0C,$6E,$B4,$0C,$2D,$B7
$03:E70B .db $B9,$30,$6E,$B7,$0C,$2D,$B8,$0C
$03:E713 .db $6E,$B9,$C6,$0C,$2D,$B9,$30,$6E
$03:E71B .db $B7,$0C,$2D,$B8,$00,$DA,$12,$DB
$03:E723 .db $0F,$DE,$14,$14,$20,$48,$6D,$B7
$03:E72B .db $18,$B9,$48,$B7,$0C,$B4,$B5,$30
$03:E733 .db $B7,$0C,$C6,$B9,$B7,$B9,$48,$B7
$03:E73B .db $18,$B4,$DA,$00,$DB,$05,$DE,$14
$03:E743 .db $19,$27,$30,$6B,$C7,$0C,$C7,$B7
$03:E74B .db $0C,$2C,$B9,$BC,$06,$7B,$BB,$BC
$03:E753 .db $0C,$69,$BB,$18,$C6,$0C,$C7,$B3
$03:E75B .db $0C,$2C,$B7,$BB,$06,$7B,$B9,$BB
$03:E763 .db $0C,$69,$B9,$18,$C6,$0C,$C7,$B2
$03:E76B .db $0C,$2C,$B4,$B9,$06,$7B,$B7,$B9
$03:E773 .db $0C,$69,$B7,$18,$C6,$0C,$C7,$06
$03:E77B .db $4B,$AD,$AF,$B0,$B2,$B4,$B5,$30
$03:E783 .db $6B,$B4,$0C,$C7,$B7,$0C,$2C,$B9
$03:E78B .db $BC,$06,$7B,$BB,$BC,$0C,$69,$BB
$03:E793 .db $18,$C6,$0C,$C7,$B3,$0C,$2C,$B7
$03:E79B .db $BB,$06,$7B,$B9,$BB,$0C,$69,$B9
$03:E7A3 .db $18,$C6,$0C,$C7,$B2,$0C,$2C,$B4
$03:E7AB .db $B9,$06,$7B,$B7,$B9,$0C,$69,$B7
$03:E7B3 .db $18,$C6,$0C,$C7,$06,$4B,$AD,$AF
$03:E7BB .db $B0,$B2,$B4,$B5,$DA,$12,$DB,$08
$03:E7C3 .db $DE,$14,$1F,$25,$0C,$6D,$B0,$0C
$03:E7CB .db $2E,$B4,$B4,$30,$6E,$B4,$0C,$2D
$03:E7D3 .db $B4,$0C,$6E,$B7,$C6,$0C,$2D,$B7
$03:E7DB .db $30,$6E,$B3,$0C,$2D,$AF,$0C,$6E
$03:E7E3 .db $AE,$0C,$2D,$B2,$B2,$30,$6E,$B2
$03:E7EB .db $0C,$2D,$B2,$0C,$6E,$B4,$C6,$0C
$03:E7F3 .db $2D,$B4,$30,$6E,$B4,$0C,$2D,$B4
$03:E7FB .db $DA,$12,$DB,$0C,$DE,$14,$1B,$26
$03:E803 .db $0C,$6D,$AB,$0C,$2E,$B0,$B0,$30
$03:E80B .db $6E,$B0,$0C,$2D,$B0,$0C,$6E,$B3
$03:E813 .db $C6,$0C,$2D,$B3,$30,$6E,$AF,$0C
$03:E81B .db $2D,$AB,$0C,$6E,$AB,$0C,$2E,$AE
$03:E823 .db $AE,$30,$6E,$AE,$0C,$2D,$AE,$0C
$03:E82B .db $6E,$B1,$C6,$0C,$2D,$B1,$30,$6E
$03:E833 .db $B1,$0C,$2D,$B1,$DA,$04,$DB,$08
$03:E83B .db $DE,$14,$19,$28,$0C,$3B,$C7,$9C
$03:E843 .db $C7,$9C,$C7,$9C,$C7,$9C,$C7,$9B
$03:E84B .db $C7,$9B,$C7,$9B,$C7,$9B,$C7,$9A
$03:E853 .db $C7,$9A,$C7,$9A,$C7,$9A,$C7,$99
$03:E85B .db $C7,$99,$C7,$99,$C7,$99,$DA,$08
$03:E863 .db $DB,$0C,$DE,$14,$19,$28,$0C,$6E
$03:E86B .db $98,$9F,$93,$9F,$98,$9F,$93,$9F
$03:E873 .db $97,$9F,$93,$9F,$97,$9F,$93,$9F
$03:E87B .db $96,$9F,$93,$9F,$96,$9F,$93,$9F
$03:E883 .db $95,$9C,$90,$9C,$95,$9C,$90,$9C
$03:E88B .db $DA,$05,$DB,$14,$DE,$00,$00,$00
$03:E893 .db $E9,$F3,$17,$08,$0C,$4B,$D1,$0C
$03:E89B .db $4C,$D2,$0C,$49,$D1,$0C,$4B,$D2
$03:E8A3 .db $00,$0C,$6E,$B9,$0C,$2D,$BB,$BC
$03:E8AB .db $30,$6E,$B9,$0C,$2D,$B8,$0C,$6E
$03:E8B3 .db $B7,$0C,$2D,$B8,$B9,$30,$6E,$B4
$03:E8BB .db $0C,$C7,$12,$6E,$B4,$06,$6D,$B3
$03:E8C3 .db $0C,$2C,$B2,$12,$6E,$B4,$06,$6D
$03:E8CB .db $B3,$0C,$2C,$B2,$0C,$2E,$B4,$B2
$03:E8D3 .db $30,$4E,$B7,$C6,$00,$30,$6D,$B0
$03:E8DB .db $0C,$C6,$AF,$C6,$AD,$AB,$AC,$AD
$03:E8E3 .db $B4,$30,$C6,$24,$B4,$18,$B0,$0C
$03:E8EB .db $AF,$B0,$B1,$30,$B2,$06,$C7,$AB
$03:E8F3 .db $AD,$AF,$B0,$B2,$B4,$B5,$06,$7B
$03:E8FB .db $B4,$B5,$0C,$69,$B4,$18,$C6,$0C
$03:E903 .db $C7,$06,$4B,$AF,$B0,$B2,$B4,$B5
$03:E90B .db $B6,$06,$7B,$B7,$B9,$0C,$69,$B7
$03:E913 .db $18,$C6,$0C,$C7,$06,$4B,$B2,$B4
$03:E91B .db $B5,$B7,$B9,$BB,$30,$BC,$C6,$BB
$03:E923 .db $0C,$C7,$06,$4B,$BB,$BC,$BB,$B9
$03:E92B .db $B7,$B5,$0C,$6E,$B5,$0C,$2D,$B5
$03:E933 .db $B9,$30,$6E,$B6,$0C,$2D,$B6,$0C
$03:E93B .db $6E,$B4,$0C,$2D,$B4,$B4,$30,$6E
$03:E943 .db $B1,$0C,$C7,$12,$6E,$AD,$06,$6D
$03:E94B .db $AD,$0C,$2C,$AD,$12,$6E,$AD,$06
$03:E953 .db $6D,$AD,$0C,$2C,$AD,$0C,$2E,$AD
$03:E95B .db $AD,$30,$4E,$B2,$C6,$0C,$6E,$B0
$03:E963 .db $0C,$2D,$B0,$B5,$30,$6E,$B0,$0C
$03:E96B .db $2D,$B0,$0C,$6E,$B0,$0C,$2D,$B0
$03:E973 .db $B0,$30,$6E,$AB,$0C,$C7,$12,$6E
$03:E97B .db $A9,$06,$6D,$A9,$0C,$2C,$A9,$12
$03:E983 .db $6E,$A9,$06,$6D,$A9,$0C,$2C,$A9
$03:E98B .db $0C,$2E,$A9,$A9,$30,$4E,$AF,$C6
$03:E993 .db $0C,$C7,$9D,$C7,$9D,$C7,$9E,$C7
$03:E99B .db $9E,$C7,$9C,$C7,$9C,$C7,$99,$C7
$03:E9A3 .db $99,$C7,$9A,$C7,$9A,$C7,$9A,$C7
$03:E9AB .db $9A,$C7,$97,$C7,$97,$C7,$97,$C7
$03:E9B3 .db $97,$0C,$91,$A1,$98,$A1,$92,$A1
$03:E9BB .db $98,$A1,$93,$9F,$98,$9F,$95,$9F
$03:E9C3 .db $90,$9F,$8E,$9D,$95,$9D,$8E,$9D
$03:E9CB .db $90,$91,$93,$9D,$8E,$9D,$93,$9D
$03:E9D3 .db $8E,$9D,$0C,$6E,$B9,$0C,$2D,$BB
$03:E9DB .db $BC,$30,$6E,$B9,$0C,$2D,$B8,$0C
$03:E9E3 .db $6E,$B7,$0C,$2D,$B8,$B9,$30,$6E
$03:E9EB .db $C0,$0C,$C7,$0C,$6E,$C0,$0C,$2D
$03:E9F3 .db $BF,$C0,$18,$6E,$BC,$0C,$2E,$BC
$03:E9FB .db $18,$6E,$B9,$30,$4E,$BC,$C6,$00
$03:EA03 .db $06,$7B,$B4,$B5,$0C,$69,$B4,$18
$03:EA0B .db $C6,$0C,$C7,$06,$4B,$AF,$B0,$B2
$03:EA13 .db $B4,$B5,$B6,$06,$7B,$B7,$B9,$0C
$03:EA1B .db $69,$B7,$18,$C6,$0C,$C7,$06,$4B
$03:EA23 .db $B2,$B4,$B5,$B7,$B9,$BB,$30,$BC
$03:EA2B .db $BB,$60,$BC,$0C,$6E,$B5,$0C,$2D
$03:EA33 .db $B5,$B9,$30,$6E,$B6,$0C,$2D,$B6
$03:EA3B .db $0C,$6E,$B4,$0C,$2D,$B4,$B4,$30
$03:EA43 .db $6E,$BD,$0C,$C7,$0C,$6E,$B9,$0C
$03:EA4B .db $2D,$B9,$B9,$18,$6E,$B9,$0C,$2E
$03:EA53 .db $B5,$18,$6E,$B5,$30,$4E,$B7,$C6
$03:EA5B .db $0C,$6E,$B0,$0C,$2D,$B0,$B5,$30
$03:EA63 .db $6E,$B0,$0C,$2D,$B0,$0C,$6E,$B0
$03:EA6B .db $0C,$2D,$B0,$B0,$30,$6E,$B7,$0C
$03:EA73 .db $C7,$0C,$6E,$B5,$0C,$2D,$B5,$B5
$03:EA7B .db $18,$6E,$B5,$0C,$2E,$B2,$18,$6E
$03:EA83 .db $B2,$30,$4E,$B4,$C6,$0C,$C7,$98
$03:EA8B .db $C7,$98,$C7,$98,$C7,$98,$C7,$9C
$03:EA93 .db $C7,$9C,$C7,$99,$C7,$99,$C7,$95
$03:EA9B .db $C7,$95,$C7,$97,$C7,$97,$C7,$9C
$03:EAA3 .db $C7,$9C,$C7,$9C,$C7,$9C,$0C,$91
$03:EAAB .db $9D,$98,$9D,$92,$9E,$98,$9E,$93
$03:EAB3 .db $9F,$9A,$9F,$95,$A1,$9C,$A1,$8E
$03:EABB .db $9A,$95,$9A,$93,$9F,$9A,$9F,$98
$03:EAC3 .db $9F,$93,$9F,$98,$98,$97,$96,$0C
$03:EACB .db $6E,$B9,$0C,$2D,$BB,$BC,$30,$6E
$03:EAD3 .db $B9,$0C,$2D,$B8,$0C,$6E,$B7,$0C
$03:EADB .db $2D,$B8,$B9,$30,$6E,$C0,$0C,$C7
$03:EAE3 .db $00,$30,$6D,$B0,$0C,$C6,$AF,$C6
$03:EAEB .db $AD,$AB,$AC,$AD,$B4,$30,$C6,$0C
$03:EAF3 .db $6E,$B5,$0C,$2D,$B5,$B9,$30,$6E
$03:EAFB .db $B6,$0C,$2D,$B6,$0C,$6E,$B4,$0C
$03:EB03 .db $2D,$B4,$B4,$30,$6E,$BD,$0C,$C7
$03:EB0B .db $0C,$6E,$B0,$0C,$2D,$B0,$B5,$30
$03:EB13 .db $6E,$B0,$0C,$2D,$B0,$0C,$6E,$B0
$03:EB1B .db $0C,$2D,$B0,$B0,$30,$6E,$B7,$0C
$03:EB23 .db $C7,$06,$7B,$B4,$B5,$0C,$69,$B4
$03:EB2B .db $18,$C6,$0C,$C7,$06,$4B,$AF,$B0
$03:EB33 .db $B2,$B4,$B5,$B6,$06,$7B,$B7,$B9
$03:EB3B .db $0C,$69,$B7,$18,$C6,$0C,$C7,$06
$03:EB43 .db $4B,$B2,$B4,$B5,$B7,$B9,$BB,$0C
$03:EB4B .db $C7,$98,$C7,$98,$C7,$98,$C7,$98
$03:EB53 .db $C7,$9C,$C7,$9C,$C7,$99,$C7,$99
$03:EB5B .db $0C,$91,$9D,$98,$9D,$92,$9E,$98
$03:EB63 .db $9E,$93,$9F,$9A,$9F,$95,$A1,$9C
$03:EB6B .db $A1,$DA,$12,$18,$6D,$AD,$0C,$B4
$03:EB73 .db $C7,$C7,$0C,$2D,$B4,$0C,$6E,$B3
$03:EB7B .db $0C,$2D,$B4,$0C,$6E,$B5,$0C,$2D
$03:EB83 .db $B4,$B1,$30,$6E,$AD,$0C,$2D,$AD
$03:EB8B .db $0C,$6E,$B4,$0C,$2D,$B2,$0C,$6D
$03:EB93 .db $B4,$0C,$2D,$B2,$0C,$6E,$B4,$0C
$03:EB9B .db $2D,$B2,$C7,$0C,$6D,$AD,$30,$C6
$03:EBA3 .db $C7,$00,$DB,$0F,$DE,$14,$14,$20
$03:EBAB .db $DA,$12,$18,$6D,$B9,$0C,$C0,$C7
$03:EBB3 .db $C7,$0C,$2D,$C0,$0C,$6E,$BF,$0C
$03:EBBB .db $2D,$C0,$0C,$6E,$C1,$0C,$2D,$C0
$03:EBC3 .db $BD,$30,$6E,$B9,$0C,$2D,$B9,$0C
$03:EBCB .db $6E,$C0,$0C,$2D,$BE,$0C,$6D,$C0
$03:EBD3 .db $0C,$2D,$BE,$0C,$6E,$C0,$0C,$2D
$03:EBDB .db $BE,$C7,$0C,$6D,$B9,$30,$C6,$C7
$03:EBE3 .db $DA,$12,$18,$6D,$A8,$0C,$AB,$C7
$03:EBEB .db $C7,$0C,$2D,$AB,$0C,$6E,$AA,$0C
$03:EBF3 .db $2D,$AB,$0C,$6E,$AD,$0C,$2D,$AB
$03:EBFB .db $A8,$30,$6E,$A5,$0C,$2D,$A5,$0C
$03:EC03 .db $6E,$AB,$0C,$2D,$AA,$0C,$6D,$AB
$03:EC0B .db $0C,$2D,$AA,$0C,$6E,$AB,$0C,$2D
$03:EC13 .db $AA,$C7,$0C,$6D,$A4,$30,$C6,$C7
$03:EC1B .db $DB,$05,$DE,$19,$19,$35,$DA,$00
$03:EC23 .db $30,$6B,$A8,$0C,$C6,$A7,$A8,$AD
$03:EC2B .db $48,$B4,$0C,$B3,$B4,$30,$B9,$B4
$03:EC33 .db $60,$B2,$DB,$08,$DE,$19,$18,$34
$03:EC3B .db $DA,$00,$30,$6B,$9F,$0C,$C6,$9E
$03:EC43 .db $9F,$A5,$48,$AB,$0C,$AA,$AB,$30
$03:EC4B .db $B4,$AB,$60,$AA,$0C,$C7,$99,$C7
$03:EC53 .db $99,$C7,$99,$C7,$99,$C7,$99,$C7
$03:EC5B .db $99,$C7,$99,$C7,$99,$C7,$98,$C7
$03:EC63 .db $98,$C7,$98,$C7,$98,$C7,$98,$C7
$03:EC6B .db $98,$C7,$98,$C7,$98,$0C,$95,$9F
$03:EC73 .db $90,$9F,$95,$9F,$90,$9F,$95,$9F
$03:EC7B .db $90,$9F,$95,$9F,$90,$8F,$8E,$9E
$03:EC83 .db $95,$9E,$8E,$9E,$95,$9E,$8E,$9E
$03:EC8B .db $95,$9E,$8E,$9E,$90,$92,$18,$6D
$03:EC93 .db $AB,$0C,$B2,$C7,$C7,$0C,$2D,$B2
$03:EC9B .db $0C,$6E,$B1,$0C,$2D,$B2,$0C,$6E
$03:ECA3 .db $B4,$0C,$2D,$B2,$AF,$30,$6E,$AB
$03:ECAB .db $0C,$2D,$B2,$18,$4E,$B0,$B0,$10
$03:ECB3 .db $6D,$B0,$10,$6E,$B2,$10,$6E,$B3
$03:ECBB .db $30,$B4,$C7,$00,$18,$6D,$A3,$0C
$03:ECC3 .db $A9,$C7,$C7,$0C,$2D,$A9,$0C,$6E
$03:ECCB .db $A8,$0C,$2D,$A9,$0C,$6E,$AB,$0C
$03:ECD3 .db $2D,$A9,$A6,$30,$6E,$A3,$0C,$2D
$03:ECDB .db $A9,$18,$4E,$A8,$A8,$10,$6D,$A8
$03:ECE3 .db $10,$6E,$A9,$10,$6E,$AA,$30,$AC
$03:ECEB .db $C7,$30,$69,$AB,$0C,$C6,$A9,$AB
$03:ECF3 .db $AF,$48,$B2,$0C,$B0,$B2,$48,$B0
$03:ECFB .db $18,$B2,$60,$B4,$30,$69,$A3,$0C
$03:ED03 .db $C6,$A3,$A6,$A9,$48,$AB,$0C,$A9
$03:ED0B .db $AB,$48,$A8,$18,$AB,$60,$AC,$0C
$03:ED13 .db $C7,$97,$C7,$97,$C7,$97,$C7,$97
$03:ED1B .db $C7,$97,$C7,$97,$C7,$97,$C7,$97
$03:ED23 .db $C7,$9C,$C7,$9C,$C7,$9C,$C7,$9C
$03:ED2B .db $C7,$97,$C7,$97,$C7,$97,$C7,$97
$03:ED33 .db $0C,$93,$9D,$8E,$9D,$93,$9D,$8E
$03:ED3B .db $9D,$93,$9D,$8E,$9D,$93,$9D,$95
$03:ED43 .db $97,$98,$9F,$93,$9F,$98,$9F,$93
$03:ED4B .db $9F,$90,$A0,$97,$A0,$90,$A0,$92
$03:ED53 .db $94,$18,$6D,$AB,$0C,$B2,$C7,$C7
$03:ED5B .db $0C,$2D,$B2,$0C,$6E,$B1,$0C,$2D
$03:ED63 .db $B2,$0C,$6E,$B4,$0C,$2D,$B2,$C7
$03:ED6B .db $30,$6E,$AB,$0C,$2D,$B2,$18,$4E
$03:ED73 .db $B0,$B0,$10,$6D,$B0,$10,$6E,$B2
$03:ED7B .db $10,$6E,$B3,$18,$2E,$B4,$C7,$30
$03:ED83 .db $4E,$B7,$00,$18,$6D,$B7,$0C,$BE
$03:ED8B .db $C7,$C7,$0C,$2D,$BE,$0C,$6E,$BD
$03:ED93 .db $0C,$2D,$BE,$0C,$6E,$C0,$0C,$2D
$03:ED9B .db $BE,$C7,$30,$6E,$B7,$0C,$2D,$BE
$03:EDA3 .db $18,$4E,$BC,$BC,$10,$6D,$BC,$10
$03:EDAB .db $6E,$BE,$10,$6E,$BF,$18,$2E,$C0
$03:EDB3 .db $C7,$06,$C7,$AB,$AD,$AF,$B0,$B2
$03:EDBB .db $B4,$B5,$18,$6D,$A3,$0C,$A9,$C7
$03:EDC3 .db $C7,$0C,$2D,$A9,$0C,$6E,$A8,$0C
$03:EDCB .db $2D,$A9,$0C,$6E,$AB,$0C,$2D,$A9
$03:EDD3 .db $C7,$30,$6E,$A3,$0C,$2D,$A9,$18
$03:EDDB .db $4E,$A8,$A8,$10,$6D,$A8,$10,$6E
$03:EDE3 .db $A9,$10,$6E,$AA,$18,$2E,$AB,$C7
$03:EDEB .db $30,$4E,$AF,$30,$69,$AB,$0C,$C6
$03:EDF3 .db $A9,$AB,$AF,$48,$B2,$0C,$B0,$B2
$03:EDFB .db $30,$B0,$B2,$30,$B4,$B3,$30,$69
$03:EE03 .db $A3,$0C,$C6,$A3,$A6,$A9,$48,$AB
$03:EE0B .db $0C,$A9,$AB,$30,$A8,$AB,$30,$AB
$03:EE13 .db $AF,$0C,$C7,$97,$C7,$97,$C7,$97
$03:EE1B .db $C7,$97,$C7,$97,$C7,$97,$C7,$97
$03:EE23 .db $C7,$97,$C7,$9C,$C7,$9C,$C7,$9C
$03:EE2B .db $C7,$9C,$DA,$01,$18,$AF,$C7,$A7
$03:EE33 .db $C6,$0C,$93,$9D,$8E,$9D,$93,$9D
$03:EE3B .db $8E,$9D,$93,$9D,$8E,$9D,$93,$9D
$03:EE43 .db $95,$97,$98,$9F,$93,$9F,$98,$9F
$03:EE4B .db $93,$9F,$18,$8C,$C7,$93,$C6,$DA
$03:EE53 .db $05,$DB,$14,$DE,$00,$00,$00,$E9
$03:EE5B .db $F3,$17,$06,$18,$4C,$D1,$C7,$30
$03:EE63 .db $6D,$D2,$DA,$04,$DB,$0A,$DE,$22
$03:EE6B .db $19,$38,$60,$5E,$BC,$C6,$DA,$01
$03:EE73 .db $60,$C6,$C6,$C6,$00,$DA,$04,$DB
$03:EE7B .db $08,$DE,$20,$18,$36,$60,$5D,$B4
$03:EE83 .db $C6,$DA,$01,$60,$C6,$C6,$C6,$DA
$03:EE8B .db $04,$DB,$0C,$DE,$21,$1A,$37,$60
$03:EE93 .db $5D,$AB,$C6,$DA,$01,$60,$C6,$C6
$03:EE9B .db $C6,$DA,$04,$DB,$0A,$DE,$22,$18
$03:EEA3 .db $36,$60,$5D,$A4,$C6,$DA,$01,$60
$03:EEAB .db $C6,$C6,$C6,$DA,$04,$DB,$0F,$10
$03:EEB3 .db $5D,$B0,$C7,$B0,$AE,$C7,$AE,$AD
$03:EEBB .db $C7,$AD,$AC,$C7,$AC,$30,$AB,$24
$03:EEC3 .db $A7,$6C,$A6,$60,$C6,$DA,$04,$DB
$03:EECB .db $0F,$10,$5D,$AB,$C7,$AB,$A8,$C7
$03:EED3 .db $A8,$A9,$C7,$A9,$A9,$C7,$A9,$30
$03:EEDB .db $A6,$24,$A3,$6C,$A2,$60,$C6,$DA
$03:EEE3 .db $04,$DB,$0F,$10,$5D,$A8,$C7,$A8
$03:EEEB .db $A4,$C7,$A4,$A4,$C7,$A4,$A4,$C7
$03:EEF3 .db $A4,$30,$A3,$24,$9D,$6C,$9C,$60
$03:EEFB .db $C6,$DA,$08,$DB,$0A,$DE,$22,$19
$03:EF03 .db $38,$10,$5D,$8C,$8C,$8C,$90,$90
$03:EF0B .db $90,$91,$91,$91,$92,$92,$92,$30
$03:EF13 .db $93,$24,$93,$6C,$8C,$60,$C6,$DA
$03:EF1B .db $01,$E2,$12,$DB,$0A,$DE,$14,$19
$03:EF23 .db $28,$18,$7C,$A7,$0C,$A8,$AB,$AD
$03:EF2B .db $30,$AB,$0C,$AD,$AF,$C6,$AF,$30
$03:EF33 .db $AD,$0C,$A7,$A8,$AB,$AD,$30,$AB
$03:EF3B .db $0C,$AC,$AD,$C6,$AD,$60,$AB,$60
$03:EF43 .db $77,$C6,$00,$DA,$02,$DB,$0A,$18
$03:EF4B .db $79,$A7,$0C,$A8,$AB,$AD,$30,$AB
$03:EF53 .db $0C,$AD,$AF,$C6,$AF,$30,$AD,$0C
$03:EF5B .db $A7,$A8,$AB,$AD,$30,$AB,$0C,$AC
$03:EF63 .db $AD,$C6,$AD,$60,$AB,$C6,$DA,$01
$03:EF6B .db $DB,$0C,$DE,$14,$19,$28,$06,$C6
$03:EF73 .db $18,$79,$A7,$0C,$A8,$AB,$AD,$30
$03:EF7B .db $AB,$0C,$AD,$AF,$C6,$AF,$30,$AD
$03:EF83 .db $0C,$A7,$A8,$AB,$AD,$30,$AB,$0C
$03:EF8B .db $AC,$AD,$C6,$AD,$60,$AB,$60,$75
$03:EF93 .db $C6,$DA,$01,$DB,$0A,$DE,$14,$19
$03:EF9B .db $28,$18,$7B,$C7,$60,$98,$97,$96
$03:EFA3 .db $95,$C6,$C6,$C6,$DA,$01,$DB,$0A
$03:EFAB .db $DE,$14,$19,$28,$18,$7B,$C7,$0C
$03:EFB3 .db $C7,$24,$9F,$30,$B0,$0C,$C7,$24
$03:EFBB .db $9F,$30,$AF,$0C,$C7,$24,$9F,$30
$03:EFC3 .db $AE,$0C,$C7,$24,$9F,$30,$B1,$60
$03:EFCB .db $C6,$C6,$C6,$DA,$01,$DB,$0A,$DE
$03:EFD3 .db $14,$19,$28,$18,$7B,$C7,$18,$C7
$03:EFDB .db $48,$A8,$18,$C7,$48,$A7,$18,$C7
$03:EFE3 .db $48,$A6,$18,$C7,$48,$A5,$60,$C6
$03:EFEB .db $C6,$C6,$DA,$01,$DB,$0A,$DE,$14
$03:EFF3 .db $19,$28,$18,$7B,$C7,$24,$C7,$3C
$03:EFFB .db $AB,$24,$C7,$3C,$AB,$24,$C7,$3C
$03:F003 .db $AB,$24,$C7,$3C,$AB,$60,$C6,$C6
$03:F00B .db $C6,$DA,$01,$DB,$0A,$DE,$14,$19
$03:F013 .db $28,$18,$7B,$C7,$30,$C7,$B4,$30
$03:F01B .db $C7,$B3,$30,$C7,$B2,$30,$C7,$B4
$03:F023 .db $60,$C6,$C6,$C6,$DA,$04,$DB,$08
$03:F02B .db $DE,$22,$18,$14,$08,$5C,$C7,$A9
$03:F033 .db $C7,$A9,$AD,$C7,$24,$AA,$0C,$C7
$03:F03B .db $08,$A9,$A8,$C7,$A8,$A8,$C7,$24
$03:F043 .db $AB,$0C,$C7,$08,$C7,$E2,$1C,$DA
$03:F04B .db $04,$DB,$0A,$DE,$22,$18,$14,$08
$03:F053 .db $5D,$AC,$AD,$C7,$AF,$B0,$C7,$24
$03:F05B .db $AD,$0C,$C7,$08,$AC,$AB,$C7,$AC
$03:F063 .db $AD,$C7,$24,$B4,$0C,$C7,$08,$C7
$03:F06B .db $00,$DA,$04,$DB,$0C,$DE,$22,$18
$03:F073 .db $14,$08,$5C,$C7,$A4,$C7,$A4,$A9
$03:F07B .db $C7,$24,$A4,$0C,$C7,$08,$A4,$A4
$03:F083 .db $C7,$A4,$A4,$C7,$24,$A5,$0C,$C7
$03:F08B .db $08,$C7,$DA,$06,$DB,$0A,$DE,$22
$03:F093 .db $18,$14,$08,$5D,$B8,$B9,$C7,$BB
$03:F09B .db $BC,$C7,$24,$B9,$0C,$C7,$08,$B8
$03:F0A3 .db $B7,$C7,$B8,$B9,$C7,$24,$C0,$0C
$03:F0AB .db $C7,$08,$C7,$DA,$0D,$DB,$0F,$DE
$03:F0B3 .db $22,$18,$14,$01,$C7,$08,$C7,$18
$03:F0BB .db $4E,$C7,$9D,$C7,$9E,$C7,$9F,$C7
$03:F0C3 .db $9F,$18,$9E,$08,$C7,$C7,$9D,$18
$03:F0CB .db $C6,$08,$C7,$C7,$AB,$DA,$0D,$DB
$03:F0D3 .db $0F,$DE,$22,$18,$14,$08,$C7,$18
$03:F0DB .db $4E,$C7,$98,$C7,$98,$C7,$9A,$C7
$03:F0E3 .db $99,$18,$A1,$08,$C7,$C7,$A3,$18
$03:F0EB .db $C6,$08,$C7,$C7,$A4,$DA,$08,$DB
$03:F0F3 .db $0A,$DE,$22,$18,$14,$08,$C7,$18
$03:F0FB .db $5F,$91,$08,$C7,$C7,$91,$18,$92
$03:F103 .db $08,$C7,$C7,$92,$18,$93,$08,$C7
$03:F10B .db $C7,$93,$18,$95,$08,$95,$90,$8F
$03:F113 .db $18,$8E,$08,$C6,$C7,$93,$18,$C6
$03:F11B .db $08,$C7,$C7,$98,$DA,$04,$DB,$14
$03:F123 .db $08,$C7,$18,$6C,$D1,$08,$D2,$C7
$03:F12B .db $D1,$18,$D1,$08,$D2,$C7,$D1,$18
$03:F133 .db $D1,$08,$D2,$C7,$D1,$D1,$C7,$D1
$03:F13B .db $D2,$D1,$D1,$18,$D2,$08,$C6,$C7
$03:F143 .db $D2,$18,$C6,$08,$C7,$C7,$D2,$DA
$03:F14B .db $04,$DB,$0A,$DE,$22,$19,$38,$18
$03:F153 .db $4D,$B4,$08,$C7,$C7,$B4,$E3,$60
$03:F15B .db $18,$18,$B4,$08,$C7,$C7,$B7,$18
$03:F163 .db $B7,$08,$C7,$C7,$B7,$18,$B7,$C7
$03:F16B .db $00,$DA,$04,$DB,$08,$DE,$20,$18
$03:F173 .db $36,$18,$4D,$A4,$08,$C7,$C7,$A4
$03:F17B .db $18,$A4,$08,$C7,$C7,$A7,$18,$A7
$03:F183 .db $08,$C7,$C7,$A7,$18,$A7,$C7,$DA
$03:F18B .db $04,$DB,$0C,$DE,$21,$1A,$37,$18
$03:F193 .db $4D,$AD,$08,$C7,$C7,$AD,$18,$AD
$03:F19B .db $08,$C7,$C7,$AF,$18,$AF,$08,$C7
$03:F1A3 .db $C7,$AF,$18,$AF,$C7,$DA,$04,$DB
$03:F1AB .db $0A,$DE,$22,$18,$36,$18,$4D,$A9
$03:F1B3 .db $08,$C7,$C7,$A9,$18,$A9,$08,$C7
$03:F1BB .db $C7,$AB,$18,$AB,$08,$C7,$C7,$AB
$03:F1C3 .db $18,$AB,$C7,$DA,$04,$DB,$0F,$08
$03:F1CB .db $4D,$C7,$C7,$9A,$18,$9A,$08,$C7
$03:F1D3 .db $C7,$9A,$18,$9A,$08,$C7,$C7,$9F
$03:F1DB .db $18,$9F,$18,$C7,$18,$7D,$9F,$DA
$03:F1E3 .db $04,$DB,$0F,$08,$4C,$C7,$C7,$8E
$03:F1EB .db $18,$8E,$08,$C7,$C7,$8E,$18,$8E
$03:F1F3 .db $08,$C7,$C7,$93,$18,$93,$18,$C7
$03:F1FB .db $18,$7E,$93,$DA,$08,$DB,$0A,$DE
$03:F203 .db $22,$19,$38,$08,$5F,$C7,$C7,$8E
$03:F20B .db $18,$8E,$08,$C7,$C7,$8E,$18,$8E
$03:F213 .db $08,$C7,$C7,$93,$18,$93,$18,$C7
$03:F21B .db $18,$7F,$93,$DA,$00,$DB,$0A,$08
$03:F223 .db $6C,$C7,$C7,$D0,$18,$D0,$08,$C7
$03:F22B .db $C7,$D0,$18,$D0,$08,$C7,$C7,$D0
$03:F233 .db $18,$D0,$18,$C7,$D0,$24,$C7,$00
$03:F23B .db $DA,$04,$E2,$16,$E3,$90,$1C,$DB
$03:F243 .db $0A,$DE,$22,$19,$38,$18,$4C,$B4
$03:F24B .db $08,$C7,$C7,$B4,$18,$B4,$08,$C7
$03:F253 .db $C7,$B7,$18,$B7,$08,$C7,$C7,$B7
$03:F25B .db $18,$B7,$C7,$00,$DA,$04,$DB,$08
$03:F263 .db $DE,$20,$18,$36,$18,$4C,$A4,$08
$03:F26B .db $C7,$C7,$A4,$18,$A4,$08,$C7,$C7
$03:F273 .db $A7,$18,$A7,$08,$C7,$C7,$A7,$18
$03:F27B .db $A7,$C7,$DA,$04,$DB,$0C,$DE,$21
$03:F283 .db $1A,$37,$18,$4C,$AD,$08,$C7,$C7
$03:F28B .db $AD,$18,$AD,$08,$C7,$C7,$AF,$18
$03:F293 .db $AF,$08,$C7,$C7,$AF,$18,$AF,$C7
$03:F29B .db $DA,$04,$DB,$0A,$DE,$22,$18,$36
$03:F2A3 .db $18,$4C,$A9,$08,$C7,$C7,$A9,$18
$03:F2AB .db $A9,$08,$C7,$C7,$AB,$18,$AB,$08
$03:F2B3 .db $C7,$C7,$AB,$18,$AB,$C7,$DA,$04
$03:F2BB .db $DB,$0F,$08,$4C,$C7,$C7,$9A,$18
$03:F2C3 .db $9A,$08,$C7,$C7,$9A,$18,$9A,$08
$03:F2CB .db $C7,$C7,$9F,$18,$9F,$08,$C7,$C7
$03:F2D3 .db $C7,$18,$7D,$9F,$DA,$04,$DB,$0F
$03:F2DB .db $08,$4B,$C7,$C7,$8E,$18,$8E,$08
$03:F2E3 .db $C7,$C7,$8E,$18,$8E,$08,$C7,$C7
$03:F2EB .db $93,$18,$93,$08,$C7,$C7,$C7,$18
$03:F2F3 .db $7E,$93,$DA,$08,$DB,$0A,$DE,$22
$03:F2FB .db $19,$38,$08,$5E,$C7,$C7,$8E,$18
$03:F303 .db $8E,$08,$C7,$C7,$8E,$18,$8E,$08
$03:F30B .db $C7,$C7,$93,$18,$93,$08,$C7,$C7
$03:F313 .db $C7,$18,$7F,$93,$DA,$00,$DB,$0A
$03:F31B .db $08,$6B,$C7,$C7,$D0,$18,$D0,$08
$03:F323 .db $C7,$C7,$D0,$18,$D0,$08,$C7,$C7
$03:F32B .db $D0,$18,$D0,$C7,$08,$D0,$DB,$14
$03:F333 .db $08,$D1,$D1,$DA,$00,$DB,$0A,$DE
$03:F33B .db $22,$19,$38,$08,$5D,$A8,$C7,$AB
$03:F343 .db $AD,$C7,$24,$AB,$0C,$C7,$08,$AD
$03:F34B .db $AF,$C7,$B0,$AF,$AE,$24,$AD,$0C
$03:F353 .db $C7,$08,$A7,$A8,$C7,$AB,$AD,$C7
$03:F35B .db $24,$AB,$0C,$C7,$08,$AC,$AD,$C7
$03:F363 .db $AE,$AD,$AC,$24,$AB,$0C,$C7,$08
$03:F36B .db $AC,$00,$DA,$06,$DB,$0A,$DE,$22
$03:F373 .db $19,$38,$08,$5D,$A8,$C7,$AB,$AD
$03:F37B .db $C7,$24,$AB,$0C,$C7,$08,$AD,$AF
$03:F383 .db $C7,$B0,$AF,$AE,$24,$AD,$0C,$C7
$03:F38B .db $08,$A7,$A8,$C7,$AB,$AD,$C7,$24
$03:F393 .db $AB,$0C,$C7,$08,$AC,$AD,$C7,$AE
$03:F39B .db $AD,$AC,$24,$AB,$0C,$C7,$08,$AC
$03:F3A3 .db $00,$DA,$12,$DB,$05,$DE,$22,$19
$03:F3AB .db $28,$60,$6B,$B4,$30,$B3,$08,$C6
$03:F3B3 .db $C6,$B3,$BB,$C6,$B9,$48,$B7,$18
$03:F3BB .db $B2,$60,$B1,$DA,$06,$DB,$08,$DE
$03:F3C3 .db $14,$1F,$30,$08,$6B,$A4,$C7,$A4
$03:F3CB .db $A8,$C7,$24,$A4,$0C,$C7,$08,$A8
$03:F3D3 .db $AB,$C7,$AB,$A7,$A7,$24,$A7,$0C
$03:F3DB .db $C7,$08,$A3,$A2,$C7,$A6,$A6,$C7
$03:F3E3 .db $24,$A6,$0C,$C7,$08,$A6,$A8,$C7
$03:F3EB .db $AB,$A8,$A8,$24,$A8,$0C,$C7,$08
$03:F3F3 .db $A8,$08,$6D,$A4,$C7,$A4,$A8,$C7
$03:F3FB .db $24,$A4,$0C,$C7,$08,$A8,$AB,$C7
$03:F403 .db $AB,$A7,$A7,$24,$A7,$0C,$C7,$08
$03:F40B .db $A3,$A2,$C7,$A6,$A6,$C7,$24,$A6
$03:F413 .db $0C,$C7,$08,$A6,$A8,$C7,$AB,$A8
$03:F41B .db $A8,$24,$A8,$0C,$C7,$08,$A8,$DA
$03:F423 .db $06,$DB,$0C,$DE,$14,$1F,$30,$08
$03:F42B .db $6D,$9F,$C7,$A8,$A4,$C7,$24,$A8
$03:F433 .db $0C,$C7,$08,$A4,$A7,$C7,$A7,$AB
$03:F43B .db $AB,$24,$A3,$0C,$C7,$08,$9F,$9F
$03:F443 .db $C7,$A2,$A2,$C7,$24,$A2,$0C,$C7
$03:F44B .db $08,$A2,$A5,$C7,$A8,$A5,$A5,$24
$03:F453 .db $A5,$0C,$C7,$08,$A5,$DA,$0D,$DB
$03:F45B .db $0F,$01,$C7,$18,$4E,$C7,$9F,$C7
$03:F463 .db $9F,$C7,$9F,$C7,$9F,$C7,$9F,$C7
$03:F46B .db $9F,$C7,$9F,$C7,$9F,$DA,$0D,$DB
$03:F473 .db $0F,$18,$4E,$C7,$9C,$C7,$9C,$C7
$03:F47B .db $9B,$C7,$9B,$C7,$9A,$C7,$9A,$C7
$03:F483 .db $99,$C7,$99,$DA,$08,$DB,$0A,$DE
$03:F48B .db $14,$1F,$30,$18,$6F,$98,$C7,$18
$03:F493 .db $93,$08,$C7,$C7,$93,$18,$97,$C7
$03:F49B .db $18,$93,$08,$C7,$C7,$93,$18,$96
$03:F4A3 .db $C7,$18,$93,$08,$C7,$C7,$93,$18
$03:F4AB .db $95,$C7,$18,$90,$08,$C7,$C7,$90
$03:F4B3 .db $DA,$00,$DB,$14,$18,$6B,$D1,$08
$03:F4BB .db $D2,$C7,$D1,$18,$D1,$08,$D2,$C7
$03:F4C3 .db $D1,$18,$D1,$08,$D2,$C7,$D1,$D1
$03:F4CB .db $C7,$D1,$D2,$D1,$D1,$18,$D1,$08
$03:F4D3 .db $D2,$C7,$D1,$18,$D1,$08,$D2,$C7
$03:F4DB .db $D1,$18,$D1,$08,$D2,$C7,$D1,$D1
$03:F4E3 .db $C7,$D1,$D2,$D1,$D1,$08,$AD,$C7
$03:F4EB .db $AF,$B0,$C7,$24,$AD,$0C,$C7,$08
$03:F4F3 .db $AC,$AB,$C7,$AC,$AD,$C7,$24,$A8
$03:F4FB .db $0C,$C7,$08,$C7,$A8,$C7,$A4,$A1
$03:F503 .db $C7,$A8,$A4,$C7,$A1,$A4,$C7,$AB
$03:F50B .db $30,$C6,$C7,$00,$01,$C7,$18,$C7
$03:F513 .db $9D,$C7,$9E,$C7,$9F,$C7,$9F,$18
$03:F51B .db $9E,$08,$C7,$C7,$9E,$18,$C6,$08
$03:F523 .db $9E,$C7,$9F,$18,$C6,$08,$C7,$C7
$03:F52B .db $A3,$A4,$C7,$A4,$A6,$C7,$A6,$18
$03:F533 .db $C7,$98,$C7,$98,$C7,$9A,$C7,$99
$03:F53B .db $18,$A1,$08,$C7,$C7,$A1,$18,$C6
$03:F543 .db $08,$A1,$C7,$A3,$18,$C6,$08,$C7
$03:F54B .db $C7,$9A,$9C,$C7,$9C,$9D,$C7,$9D
$03:F553 .db $18,$91,$08,$C7,$C7,$91,$18,$92
$03:F55B .db $08,$C7,$C7,$92,$18,$93,$08,$C7
$03:F563 .db $C7,$93,$18,$95,$08,$95,$90,$8F
$03:F56B .db $18,$8E,$08,$C6,$C7,$8E,$18,$C6
$03:F573 .db $08,$8E,$C7,$93,$18,$C6,$08,$C7
$03:F57B .db $C7,$93,$95,$C7,$95,$97,$C7,$97
$03:F583 .db $18,$D1,$08,$D2,$C7,$D1,$18,$D1
$03:F58B .db $08,$D2,$C7,$D1,$18,$D1,$08,$D2
$03:F593 .db $C7,$D1,$D1,$C7,$D1,$D2,$D1,$D1
$03:F59B .db $18,$D2,$08,$C6,$C7,$D2,$18,$C6
$03:F5A3 .db $08,$D2,$C7,$D2,$18,$C6,$08,$C6
$03:F5AB .db $C7,$D1,$D2,$C7,$D1,$D2,$D1,$D1
$03:F5B3 .db $08,$A9,$C7,$A9,$AD,$C7,$24,$AA
$03:F5BB .db $0C,$C7,$08,$A9,$A8,$C7,$A8,$A8
$03:F5C3 .db $C7,$24,$AB,$0C,$C7,$08,$C7,$AD
$03:F5CB .db $C7,$AD,$AD,$C7,$A9,$C7,$C7,$A9
$03:F5D3 .db $A9,$C7,$A8,$30,$C6,$C7,$08,$AD
$03:F5DB .db $C7,$AF,$B0,$C7,$24,$AD,$0C,$C7
$03:F5E3 .db $08,$AC,$AB,$C7,$AC,$AD,$C7,$24
$03:F5EB .db $B4,$0C,$C7,$08,$C7,$B4,$C7,$B3
$03:F5F3 .db $B4,$C7,$B0,$C7,$C7,$B0,$AD,$C7
$03:F5FB .db $B0,$30,$C6,$C7,$00,$48,$B0,$08
$03:F603 .db $AD,$C6,$B0,$48,$B4,$08,$B3,$C6
$03:F60B .db $B4,$30,$B9,$30,$B4,$60,$B0,$01
$03:F613 .db $C7,$18,$C7,$9D,$C7,$9E,$C7,$9F
$03:F61B .db $C7,$9F,$18,$9E,$08,$C7,$C7,$9D
$03:F623 .db $18,$C6,$08,$C7,$C7,$AB,$18,$C6
$03:F62B .db $08,$B0,$C7,$B0,$AF,$C7,$AF,$AE
$03:F633 .db $C7,$AE,$18,$C7,$98,$C7,$98,$C7
$03:F63B .db $9A,$C7,$99,$18,$A1,$08,$C7,$C7
$03:F643 .db $A3,$18,$C6,$08,$C7,$C7,$A4,$18
$03:F64B .db $C6,$08,$A8,$C7,$A8,$A7,$C7,$A7
$03:F653 .db $A6,$C7,$A6,$18,$91,$08,$C7,$C7
$03:F65B .db $91,$18,$92,$08,$C7,$C7,$92,$18
$03:F663 .db $93,$08,$C7,$C7,$93,$18,$95,$08
$03:F66B .db $95,$90,$8F,$18,$8E,$08,$C6,$C7
$03:F673 .db $93,$18,$C6,$08,$C7,$C7,$98,$18
$03:F67B .db $C6,$08,$98,$C7,$98,$97,$C7,$97
$03:F683 .db $96,$C7,$96,$18,$D1,$08,$D2,$C7
$03:F68B .db $D1,$18,$D1,$08,$D2,$C7,$D1,$18
$03:F693 .db $D1,$08,$D2,$C7,$D1,$D1,$C7,$D1
$03:F69B .db $D2,$D1,$D1,$18,$D2,$08,$C6,$C7
$03:F6A3 .db $D2,$18,$C6,$08,$C7,$C7,$D2,$18
$03:F6AB .db $C6,$08,$D2,$C7,$D1,$D2,$C7,$D1
$03:F6B3 .db $D2,$C7,$D1,$DA,$04,$18,$6C,$AD
$03:F6BB .db $B4,$08,$B4,$C7,$B4,$B3,$C7,$B4
$03:F6C3 .db $B5,$C6,$B4,$B1,$C7,$24,$AD,$0C
$03:F6CB .db $C7,$08,$AD,$B4,$C6,$B2,$B4,$C6
$03:F6D3 .db $B2,$B4,$C6,$B2,$B0,$C7,$AD,$30
$03:F6DB .db $C6,$C7,$00,$DA,$04,$18,$6B,$A8
$03:F6E3 .db $AB,$08,$AB,$C7,$AB,$AA,$C7,$AB
$03:F6EB .db $AD,$C6,$AB,$A8,$C7,$24,$A5,$0C
$03:F6F3 .db $C7,$08,$A5,$AB,$C6,$AA,$AB,$C6
$03:F6FB .db $AA,$AB,$C6,$AA,$A8,$C7,$A4,$30
$03:F703 .db $C6,$C7,$18,$C7,$08,$AD,$C6,$AC
$03:F70B .db $AD,$C6,$B4,$C6,$C6,$AD,$AD,$C6
$03:F713 .db $AC,$AD,$C6,$B4,$C6,$C6,$AD,$AF
$03:F71B .db $C6,$B1,$18,$C7,$08,$AD,$C6,$AC
$03:F723 .db $AD,$C6,$B2,$C6,$C6,$AD,$AD,$C6
$03:F72B .db $AC,$AD,$C6,$B2,$30,$C6,$01,$C7
$03:F733 .db $18,$C7,$9F,$C7,$9F,$C7,$9F,$C7
$03:F73B .db $9F,$C7,$9E,$C7,$9E,$C7,$9E,$C7
$03:F743 .db $9E,$18,$C7,$99,$C7,$99,$C7,$99
$03:F74B .db $C7,$99,$C7,$98,$C7,$98,$C7,$98
$03:F753 .db $C7,$98,$18,$95,$08,$C7,$C7,$95
$03:F75B .db $18,$90,$08,$C7,$C7,$90,$18,$95
$03:F763 .db $08,$C7,$C7,$95,$18,$95,$08,$95
$03:F76B .db $90,$8F,$18,$8E,$08,$C7,$C7,$8E
$03:F773 .db $18,$95,$08,$C7,$C7,$95,$18,$8E
$03:F77B .db $08,$C7,$C7,$8E,$8E,$C7,$8E,$90
$03:F783 .db $C7,$92,$18,$D1,$08,$D2,$C7,$D1
$03:F78B .db $18,$D1,$08,$D2,$C7,$D1,$18,$D1
$03:F793 .db $08,$D2,$C7,$D1,$D1,$C7,$D1,$D2
$03:F79B .db $D1,$D1,$18,$D1,$08,$D2,$C7,$D1
$03:F7A3 .db $18,$D1,$08,$D2,$C7,$D1,$18,$D1
$03:F7AB .db $08,$D2,$C7,$D1,$D2,$C7,$D1,$D2
$03:F7B3 .db $C7,$D1,$18,$AB,$B2,$08,$B2,$C7
$03:F7BB .db $B2,$B1,$C7,$B2,$B4,$C6,$B2,$AF
$03:F7C3 .db $C7,$24,$AB,$0C,$C7,$08,$B2,$18
$03:F7CB .db $B0,$B0,$10,$B0,$B2,$B3,$18,$B4
$03:F7D3 .db $C7,$AB,$C6,$00,$18,$A3,$A9,$08
$03:F7DB .db $A9,$C7,$A9,$A8,$C7,$A9,$AB,$C6
$03:F7E3 .db $A9,$A6,$C7,$24,$A3,$0C,$C7,$08
$03:F7EB .db $A9,$18,$A8,$A8,$10,$A8,$A9,$AA
$03:F7F3 .db $18,$AB,$C7,$A3,$C6,$18,$C7,$08
$03:F7FB .db $AB,$C6,$AA,$AB,$C6,$B2,$C6,$C6
$03:F803 .db $AB,$AB,$C6,$AA,$AB,$C6,$B2,$C6
$03:F80B .db $C6,$AB,$AD,$C6,$AF,$30,$B0,$10
$03:F813 .db $B0,$AF,$AD,$AB,$06,$AD,$AF,$B0
$03:F81B .db $B2,$B3,$B4,$B5,$B6,$30,$B7,$01
$03:F823 .db $C7,$18,$C7,$9D,$C7,$9D,$C7,$9D
$03:F82B .db $C7,$9D,$C7,$9C,$10,$9C,$9D,$9E
$03:F833 .db $18,$9F,$C7,$9B,$C6,$18,$C7,$97
$03:F83B .db $C7,$97,$C7,$97,$C7,$97,$C7,$9F
$03:F843 .db $10,$9F,$A0,$A1,$18,$A3,$C7,$A3
$03:F84B .db $C6,$18,$93,$08,$C7,$C7,$93,$18
$03:F853 .db $8E,$08,$C7,$C7,$8E,$18,$93,$08
$03:F85B .db $C7,$C7,$93,$18,$93,$08,$93,$95
$03:F863 .db $97,$18,$98,$08,$C7,$C7,$98,$10
$03:F86B .db $98,$9A,$9B,$18,$9C,$C7,$93,$C6
$03:F873 .db $18,$D1,$08,$D2,$C7,$D1,$18,$D1
$03:F87B .db $08,$D2,$C7,$D1,$18,$D1,$08,$D2
$03:F883 .db $C7,$D1,$D1,$C7,$D1,$D2,$D1,$D1
$03:F88B .db $18,$D1,$08,$D2,$C7,$D1,$10,$D2
$03:F893 .db $D2,$D2,$18,$D1,$08,$D2,$C7,$D1
$03:F89B .db $D2,$C7,$D1,$D2,$D1,$D1,$08,$A9
$03:F8A3 .db $C7,$A9,$AD,$C7,$24,$AA,$0C,$C7
$03:F8AB .db $08,$A9,$A8,$C7,$A8,$A8,$C7,$24
$03:F8B3 .db $AB,$0C,$C7,$08,$C7,$08,$AD,$C7
$03:F8BB .db $AF,$B0,$C7,$24,$AD,$0C,$C7,$08
$03:F8C3 .db $AC,$AB,$C7,$AC,$AD,$C7,$24,$B4
$03:F8CB .db $0C,$C7,$08,$C7,$00,$DA,$04,$DB
$03:F8D3 .db $0C,$DE,$22,$18,$14,$08,$5C,$A4
$03:F8DB .db $C7,$A4,$A9,$C7,$24,$A4,$0C,$C7
$03:F8E3 .db $08,$A4,$A4,$C7,$A4,$A4,$C7,$24
$03:F8EB .db $A5,$0C,$C7,$08,$C7,$48,$B0,$08
$03:F8F3 .db $AD,$C6,$B0,$60,$B4,$01,$C7,$18
$03:F8FB .db $C7,$9D,$C7,$9E,$C7,$9F,$C7,$9F
$03:F903 .db $18,$9E,$08,$C7,$C7,$9D,$18,$C6
$03:F90B .db $08,$C7,$C7,$AB,$18,$C7,$98,$C7
$03:F913 .db $98,$C7,$9A,$C7,$99,$18,$A1,$08
$03:F91B .db $C7,$C7,$A3,$18,$C6,$08,$C7,$C7
$03:F923 .db $A4,$18,$91,$08,$C7,$C7,$91,$18
$03:F92B .db $92,$08,$C7,$C7,$92,$18,$93,$08
$03:F933 .db $C7,$C7,$93,$18,$95,$08,$95,$90
$03:F93B .db $8F,$18,$8E,$08,$C6,$C7,$93,$18
$03:F943 .db $C6,$08,$C7,$C7,$98,$18,$D1,$08
$03:F94B .db $D2,$C7,$D1,$18,$D1,$08,$D2,$C7
; the transition between E000 and F000 is off, I know. You can go count the bytes and find the exact point, if you want then.
$03:F953 .db $D1,$18,$D1,$08,$D2,$C7,$D1,$D1
$03:F95B .db $C7,$D1,$D2,$D1,$D1,$18,$D2,$08
$03:F963 .db $C6,$C7,$D2,$18,$C6,$08,$C7,$C7
$03:F96B .db $D2,$DA,$04,$DB,$0A,$DE,$22,$19
$03:F973 .db $38,$18,$4D,$B4,$08,$C7,$C7,$B4
$03:F97B .db $18,$B4,$08,$C7,$C7,$B7,$18,$B7
$03:F983 .db $08,$C7,$C7,$B7,$18,$B7,$C7,$00
$03:F98B .db $DA,$04,$DB,$08,$DE,$20,$18,$36
$03:F993 .db $18,$4D,$A4,$08,$C7,$C7,$A4,$18
$03:F99B .db $A4,$08,$C7,$C7,$A7,$18,$A7,$08
$03:F9A3 .db $C7,$C7,$A7,$18,$A7,$C7,$DA,$04
$03:F9AB .db $DB,$0C,$DE,$21,$1A,$37,$18,$4D
$03:F9B3 .db $AD,$08,$C7,$C7,$AD,$18,$AD,$08
$03:F9BB .db $C7,$C7,$AF,$18,$AF,$08,$C7,$C7
$03:F9C3 .db $AF,$18,$AF,$C7,$DA,$04,$DB,$0A
$03:F9CB .db $DE,$22,$18,$36,$18,$4D,$A9,$08
$03:F9D3 .db $C7,$C7,$A9,$18,$A9,$08,$C7,$C7
$03:F9DB .db $AB,$18,$AB,$08,$C7,$C7,$AB,$18
$03:F9E3 .db $AB,$C7,$DA,$04,$DB,$0F,$08,$4D
$03:F9EB .db $C7,$C7,$9A,$18,$9A,$08,$C7,$C7
$03:F9F3 .db $9A,$18,$9A,$08,$C7,$C7,$9F,$18
$03:F9FB .db $9F,$08,$C7,$C7,$C7,$18,$7D,$9F
$03:FA03 .db $DA,$04,$DB,$0F,$08,$4C,$C7,$C7
$03:FA0B .db $8E,$18,$8E,$08,$C7,$C7,$8E,$18
$03:FA13 .db $8E,$08,$C7,$C7,$93,$18,$93,$08
$03:FA1B .db $C7,$C7,$C7,$18,$7E,$93,$DA,$08
$03:FA23 .db $DB,$0A,$DE,$22,$19,$38,$08,$5F
$03:FA2B .db $C7,$C7,$8E,$18,$8E,$08,$C7,$C7
$03:FA33 .db $8E,$18,$8E,$08,$C7,$C7,$93,$18
$03:FA3B .db $93,$08,$C7,$C7,$C7,$18,$7F,$93
$03:FA43 .db $DA,$00,$DB,$0A,$08,$6C,$C7,$C7
$03:FA4B .db $D0,$18,$D0,$08,$C7,$C7,$D0,$18
$03:FA53 .db $D0,$08,$C7,$C7,$D0,$18,$D0,$C7
$03:FA5B .db $08,$D0,$DB,$14,$08,$D1,$D1,$DA
$03:FA63 .db $06,$DB,$0A,$DE,$22,$19,$38,$08
$03:FA6B .db $6F,$B4,$C7,$B7,$B9,$C7,$24,$B7
$03:FA73 .db $0C,$C7,$08,$B9,$BB,$C7,$BC,$BB
$03:FA7B .db $BA,$24,$B9,$0C,$C7,$08,$B3,$B4
$03:FA83 .db $C7,$B7,$B9,$C7,$24,$B7,$0C,$C7
$03:FA8B .db $08,$B8,$B9,$C7,$BA,$B9,$B8,$24
$03:FA93 .db $B7,$0C,$C7,$08,$B8,$00,$08,$B9
$03:FA9B .db $C7,$BB,$BC,$C7,$24,$B9,$0C,$C7
$03:FAA3 .db $08,$B8,$B7,$C7,$B8,$B9,$C7,$24
$03:FAAB .db $C0,$0C,$C7,$08,$C7,$00,$18,$91
$03:FAB3 .db $08,$C7,$C7,$91,$18,$92,$08,$C7
$03:FABB .db $C7,$92,$18,$93,$08,$C7,$C7,$93
$03:FAC3 .db $18,$95,$08,$C7,$C7,$95,$DA,$04
$03:FACB .db $DB,$0A,$DE,$22,$19,$38,$18,$5D
$03:FAD3 .db $C0,$08,$C7,$C7,$C0,$E3,$78,$18
$03:FADB .db $18,$C0,$08,$C7,$C7,$C3,$18,$C3
$03:FAE3 .db $08,$C7,$C7,$C3,$18,$C3,$C3,$00
$03:FAEB .db $DA,$04,$DB,$0A,$DE,$22,$19,$38
$03:FAF3 .db $18,$5D,$C0,$08,$C7,$C7,$C0,$18
$03:FAFB .db $C0,$08,$C7,$C7,$C3,$18,$C3,$08
$03:FB03 .db $C7,$C7,$C3,$18,$C3,$C3,$00,$DA
$03:FB0B .db $04,$DB,$08,$DE,$20,$18,$36,$18
$03:FB13 .db $5D,$A4,$08,$C7,$C7,$A4,$18,$A4
$03:FB1B .db $08,$C7,$C7,$A7,$18,$A7,$08,$C7
$03:FB23 .db $C7,$A7,$18,$A7,$A7,$DA,$04,$DB
$03:FB2B .db $0C,$DE,$21,$1A,$37,$18,$5D,$B9
$03:FB33 .db $08,$C7,$C7,$B9,$18,$B9,$08,$C7
$03:FB3B .db $C7,$BB,$18,$BB,$08,$C7,$C7,$BB
$03:FB43 .db $18,$BB,$BB,$DA,$04,$DB,$0A,$DE
$03:FB4B .db $22,$18,$36,$18,$5D,$A9,$08,$C7
$03:FB53 .db $C7,$A9,$18,$A9,$08,$C7,$C7,$AB
$03:FB5B .db $18,$AB,$08,$C7,$C7,$AB,$18,$AB
$03:FB63 .db $AB,$DA,$04,$DB,$0F,$08,$5D,$C7
$03:FB6B .db $C7,$9A,$18,$9A,$08,$C7,$C7,$9A
$03:FB73 .db $18,$9A,$08,$C7,$C7,$9F,$18,$9F
$03:FB7B .db $08,$C7,$C7,$9F,$08,$7D,$C7,$C7
$03:FB83 .db $9F,$DA,$04,$DB,$0F,$08,$5C,$C7
$03:FB8B .db $C7,$8E,$18,$8E,$08,$C7,$C7,$8E
$03:FB93 .db $18,$8E,$08,$C7,$C7,$93,$18,$93
$03:FB9B .db $08,$C7,$C7,$93,$08,$7E,$C7,$C7
$03:FBA3 .db $93,$DA,$08,$DB,$0A,$DE,$22,$19
$03:FBAB .db $38,$08,$5F,$C7,$C7,$8E,$18,$8E
$03:FBB3 .db $08,$C7,$C7,$8E,$18,$8E,$08,$C7
$03:FBBB .db $C7,$93,$18,$93,$08,$C7,$C7,$C7
$03:FBC3 .db $08,$7F,$C7,$C7,$93,$DA,$00,$DB
$03:FBCB .db $0A,$08,$6C,$C7,$C7,$D0,$18,$D0
$03:FBD3 .db $08,$C7,$C7,$D0,$18,$D0,$08,$C7
$03:FBDB .db $C7,$D0,$18,$D0,$C7,$08,$D0,$DB
$03:FBE3 .db $14,$08,$D1,$D1,$DA,$04,$DE,$14
$03:FBEB .db $19,$30,$DB,$0A,$08,$4F,$B9,$C6
$03:FBF3 .db $B7,$B9,$C6,$24,$B7,$0C,$C6,$08
$03:FBFB .db $B9,$BB,$C6,$C7,$BB,$C6,$24,$B9
$03:FC03 .db $0C,$C6,$08,$C6,$B9,$C6,$B7,$B9
$03:FC0B .db $C6,$24,$B7,$0C,$C6,$08,$B8,$B9
$03:FC13 .db $C6,$C7,$B9,$C6,$24,$B7,$0C,$C6
$03:FC1B .db $08,$B8,$DE,$16,$18,$30,$DB,$0A
$03:FC23 .db $08,$4E,$AD,$C6,$AB,$AD,$C6,$24
$03:FC2B .db $AB,$0C,$C6,$08,$AD,$AF,$C6,$C7
$03:FC33 .db $AF,$C6,$24,$AD,$0C,$C6,$08,$C6
$03:FC3B .db $AD,$C6,$AB,$AD,$C6,$24,$AB,$0C
$03:FC43 .db $C7,$08,$AC,$AD,$C6,$C7,$AD,$C6
$03:FC4B .db $24,$AB,$0C,$C6,$08,$AC,$00,$DE
$03:FC53 .db $15,$19,$31,$DB,$08,$08,$4E,$A8
$03:FC5B .db $C6,$A4,$A8,$C6,$24,$A8,$0C,$C6
$03:FC63 .db $08,$A8,$AB,$C6,$C7,$AB,$C6,$24
$03:FC6B .db $A7,$0C,$C6,$08,$C6,$A6,$C6,$A6
$03:FC73 .db $A6,$C6,$24,$A6,$0C,$C6,$08,$A6
$03:FC7B .db $A8,$C6,$C7,$A8,$C6,$24,$A8,$0C
$03:FC83 .db $C6,$08,$A8,$DA,$06,$DB,$0C,$DE
$03:FC8B .db $14,$1A,$30,$08,$4E,$A4,$C6,$A4
$03:FC93 .db $A4,$C6,$24,$A4,$0C,$C6,$08,$A4
$03:FC9B .db $A7,$C6,$C7,$A7,$C6,$24,$A3,$0C
$03:FCA3 .db $C6,$08,$C6,$A2,$C6,$A2,$A2,$C6
$03:FCAB .db $24,$A2,$0C,$C6,$08,$A2,$A5,$C6
$03:FCB3 .db $C7,$A5,$C6,$24,$A5,$0C,$C6,$08
$03:FCBB .db $A5,$08,$B9,$C6,$BB,$BC,$C6,$24
$03:FCC3 .db $B9,$0C,$C6,$08,$B8,$B7,$C6,$B8
$03:FCCB .db $B9,$C6,$24,$C0,$0C,$C6,$08,$C6
$03:FCD3 .db $00,$08,$A9,$C6,$A9,$AD,$C6,$24
$03:FCDB .db $AA,$0C,$C6,$08,$A9,$A8,$C6,$A8
$03:FCE3 .db $A8,$C6,$24,$AB,$0C,$C6,$08,$C6
$03:FCEB .db $08,$AD,$C6,$AF,$B0,$C6,$24,$AD
$03:FCF3 .db $0C,$C6,$08,$AC,$AB,$C6,$AC,$AD
$03:FCFB .db $C6,$24,$B4,$0C,$C6,$08,$C6,$00
$03:FD03 .db $DA,$04,$DB,$0C,$DE,$22,$18,$14
$03:FD0B .db $08,$5C,$A4,$C6,$A4,$A9,$C6,$24
$03:FD13 .db $A4,$0C,$C6,$08,$A4,$A4,$C6,$A4
$03:FD1B .db $A4,$C6,$24,$A5,$0C,$C6,$08,$C6
$03:FD23 .db $DA,$04,$DB,$0A,$DE,$22,$19,$38
$03:FD2B .db $60,$5E,$BC,$C6,$DA,$01,$10,$9F
$03:FD33 .db $C6,$C6,$C6,$AF,$C6,$60,$C6,$C6
$03:FD3B .db $00,$DA,$04,$DB,$08,$DE,$20,$18
$03:FD43 .db $36,$60,$5D,$B4,$C6,$DA,$01,$10
$03:FD4B .db $C7,$A3,$C6,$C6,$C6,$B3,$60,$C6
$03:FD53 .db $C6,$DA,$04,$DB,$0C,$DE,$21,$1A
$03:FD5B .db $37,$60,$5D,$AB,$C6,$DA,$01,$10
$03:FD63 .db $C7,$C7,$A7,$C6,$C6,$C6,$60,$B7
$03:FD6B .db $C6,$DA,$04,$DB,$0A,$DE,$22,$18
$03:FD73 .db $36,$60,$5D,$A4,$C6,$DA,$01,$10
$03:FD7B .db $C7,$C7,$C7,$AB,$C6,$C6,$60,$C6
$03:FD83 .db $C6,$DA,$04,$DB,$0F,$10,$5D,$A4
$03:FD8B .db $C7,$A4,$A2,$C7,$A2,$A1,$C7,$A1
$03:FD93 .db $A0,$C7,$A0,$60,$9F,$9B,$C6,$DA
$03:FD9B .db $0D,$DB,$0F,$10,$5D,$9C,$C7,$9C
$03:FDA3 .db $9C,$C7,$9C,$98,$C7,$98,$98,$C7
$03:FDAB .db $98,$60,$97,$97,$C6,$DA,$08,$DB
$03:FDB3 .db $0A,$DE,$22,$19,$38,$10,$5D,$98
$03:FDBB .db $C7,$98,$96,$C7,$96,$95,$C7,$95
$03:FDC3 .db $94,$C7,$94,$60,$93,$93,$C6,$00
$03:FDCB .db $00,$00,$05,$E8,$00,$00,$00,$00
$03:FDD3 .db $00,$00,$00,$00,$00,$00,$00,$00
$03:FDDB .db $00,$00,$00,$00,$00
;;; $FDE0..FFF8: Padding ($FF) ;;;
$03:FDE0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FDE8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FDF0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FDF8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE00 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE08 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE10 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE18 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE20 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE28 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE30 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE38 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE40 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE48 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE50 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE58 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE60 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE68 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE70 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE78 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE80 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE88 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE90 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FE98 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEA0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEA8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEB0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEB8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEC0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEC8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FED0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FED8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEE0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEE8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEF0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FEF8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF00 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF08 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF10 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF18 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF20 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF28 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF30 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF38 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF40 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF48 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF50 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF58 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF60 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF68 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF70 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF78 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF80 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF88 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF90 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FF98 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFA0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFA8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFB0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFB8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFC0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFC8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFD0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFD8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFE0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFE8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFF0 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
$03:FFF8 .db $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF