;============================================================================
; Faxanadu (U).nes
;
; PRG15_MIRROR ($c000 - $ffff)
;============================================================================

.segment "PRG15_MIRROR"
.ORG $c000

;============================================================================
; Write attribute data for the HUD to the PPU.
;
; The attribute data will be written from
; HUD_ATTRIBUTE_DATA_BY_INDEX based on the
; UI_AttributeDataIndex set when loading the
; screen.
;
; INPUTS:
;     UI_AttributeDataIndex:
;         The index into the lookup table for the current
;         screen.
;
;     HUD_ATTRIBUTE_DATA_BY_INDEX:
;         The lookup table of attribute data to write.
;
; OUTPUTS:
;     PPUADDR:
;         The updated PPU address.
;
;     PPUDATA:
;         The written data.
;
; CALLS:
;     UI_DrawHUD
;
; XREFS:
;     Screen_SetupNew
;============================================================================
[c000]UI_SetHUDPPUAttributes:; [$c000]
;
; Set the PPUADDR to 0x23C0, the top row where the status
; bar resides.
;
[c000]LDA #$23
[c002]STA a:PPUADDR; Set upper PPUADDR as 0x23.
[c005]LDA #$c0
[c007]STA a:PPUADDR; Set upper PPUADDR as 0xC0.
[c00a]LDX a:UI_AttributeDataIndex; X = HUD attribute data index, computed when setting up the screen.
[c00d]LDA HUD_ATTRIBUTE_DATA_BY_INDEX,X; Load the value for the attribute data.


;
; Write 8 bytes based on data from the lookup table
; HUD_ATTRIBUTE_DATA_BY_INDEX at index
; UI_AttributeDataIndex.
;
[c010]LDX #$08; X = 8 (loop counter).

[c012]@_writeLoop:; [$c012]
[c012]STA a:PPUDATA; Write to the PPU.
[c015]DEX; X--
[c016]BNE @_writeLoop; If X > 0, loop.


;
; Draw the HUD.
;
[c018]JMP UI_DrawHUD; Jump to draw the HUD.


;============================================================================
; Attribute data used for the HUD.
;
; These are indexed by values from lookup table
; PALETTE_INDEX_TO_UI_BG_ATTRIBUTE_INDEX (stored in
; UI_AttributeDataIndex.
;
; Only values 0, 1, 2, and 3 are used.
;
; The rest seem to be unused, but many end up styled to
; better match regions of the game.
;
; XREFS:
;     UI_SetHUDPPUAttributes
;============================================================================

;
; XREFS:
;     UI_SetHUDPPUAttributes
;
[c01b]HUD_ATTRIBUTE_DATA_BY_INDEX:; [$c01b]
[c01b].byte $00; [0]: Dartmoor, Castle of Fraternal, King Grieve's Room
[c01c].byte $55; [1]: Start Screen
[c01d].byte $aa; [2]: Most exterior areas.
[c01e].byte $ff; [3]: Most interior areas.
[c01f].byte $41; [4]: Here and below are unused.
[c020].byte $20; [5]:
[c021].byte $04; [6]:
[c022].byte $07; [7]:
[c023].byte $08; [8]:
[c024].byte $09; [9]:
[c025].byte $0a; [10]:
[c026].byte $61; [11]:
[c027].byte $20; [12]:
[c028].byte $04; [13]:
[c029].byte $0b; [14]:
[c02a].byte $0c; [15]:
[c02b].byte $0d; [16]:
[c02c].byte $0e; [17]:
[c02d].byte $56; [18]:
[c02e].byte $20; [19]:
[c02f].byte $03; [20]:
[c030].byte $0f; [21]:
[c031].byte $10; [22]:
[c032].byte $11; [23]:

;============================================================================
; DEADCODE
;============================================================================
[c033]DEADCODE_FUN_PRG15_MIRROR__c033:; [$c033]
[c033]LDY #$00
[c035]LDA (Temp_Addr_L),Y
[c037]STA PPU_TargetAddr
[c039]INY
[c03a]LDA (Temp_Addr_L),Y
[c03c]STA PPU_TargetAddr_U
[c03e]INY
[c03f]LDA (Temp_Addr_L),Y
[c041]PHA
[c042]JSR PPUBuffer_QueueCommandOrLength
[c045]PLA
[c046]STA Temp_00
[c048]LDY #$03

[c04a]@LAB_PRG15_MIRROR__c04a:; [$c04a]
[c04a]LDA (Temp_Addr_L),Y
[c04c]STA PPUBuffer,X
[c04f]INX
[c050]INY
[c051]DEC Temp_00
[c053]BNE @LAB_PRG15_MIRROR__c04a
[c055]STX PPUBuffer_WriteOffset
[c057]RTS

;============================================================================
; Draw the player's state on the HUD UI.
;
; INPUTS:
;     Player_MP:
;         The player's current MP.
;
; OUTPUTS:
;     None
;
; CALLS:
;     UI_DrawTimeValue
;     UI_DrawGoldValue
;     UI_DrawPlayerExperience
;     UI_DrawPlayerHP
;     Player_SetMP
;     PPUBuffer_DrawAll
;
; XREFS:
;     UI_SetHUDPPUAttributes
;============================================================================
[c058]UI_DrawHUD:; [$c058]
[c058]LDA #$00
[c05a]JSR UI_DrawTimeValue; Draw the time value.
[c05d]JSR UI_DrawGoldValue; Draw the gold value.
[c060]JSR PPUBuffer_DrawAll; Flush to the PPU.
[c063]JSR UI_DrawPlayerExperience; Draw the player experience value.
[c066]JSR PPUBuffer_DrawAll; Flush to the PPU.
[c069]JSR PPUBuffer_DrawAll; Flush to the PPU.
[c06c]JSR UI_DrawPlayerHP; Draw the player's HP bar.
[c06f]JSR PPUBuffer_DrawAll; Flush to the PPU.
[c072]LDA a:Player_MP; Load the player's MP.
[c075]JSR Player_SetMP; Set it and draw.
[c078]JMP PPUBuffer_DrawAll; Flush to the PPU.

;============================================================================
; Increase the player's HP.
;
; This will be capped to 80HP.
;
; INPUTS:
;     A:
;         The number of health points to add.
;
;     Player_HP_U:
;         The upper byte of player health to add to.
;
; OUTPUTS:
;     Player_HP_U:
;         The new upper byte of player health.
;
; CALLS:
;     UI_DrawPlayerHPValue
;
; XREFS:
;     Player_HandleTouchBread
;     Player_FillHPAndMP
;     Player_UseRedPotion
;============================================================================
[c07b]Player_AddHP:; [$c07b]
;
; Update the player's HP with the provided value.
;
[c07b]CLC; Clear carry so it's not added.
[c07c]ADC a:Player_HP_U; Add the provided HP to the player's health.
[c07f]STA a:Player_HP_U; Store as the new health.


;
; Check against the cap.
;
[c082]CMP #$50; Cap at 80 HP.
[c084]BCC @_drawHP; Jump if it's under.
[c086]LDA #$50; Else, cap it to 80HP.
[c088]STA a:Player_HP_U; Store as the new health.

[c08b]@_drawHP:; [$c08b]
[c08b]JMP UI_DrawPlayerHPValue

;============================================================================
; Decrease the player's HP.
;
; If the HP hits <= 0, and an elixir is in the inventory, it will be used.
; If it hits <= 0 and there's no elixir, the player will die.
;
; INPUTS
;     Player_HP_U:
;     Player_HP_L:
;         The player's current health.
;
;     Arg_PlayerHealthDelta_U:
;     Arg_PlayerHealthDelta_L:
;         The health to add.
;
;     SpecialItems:
;         The player's current special items.
;
; OUTPUTS:
;     Player_HP_U:
;     Player_HP_L:
;         The new player health.
;
;     PlayerIsDead:
;         Set to 1 if the player dies.
;
; CALLS:
;     UI_DrawPlayerHP
;     Player_UseElixir
;
; XREFS:
;     Player_ApplyDamage
;     Player_HandleHitByMagic
;     SpriteBehavior_FlashScreenHitPlayer
;============================================================================
[c08e]Player_ReduceHP:; [$c08e]
;
; Reduce the lower byte of player health.
;
[c08e]LDA a:Player_HP_L; Load the lower byte of the player's health.
[c091]SEC
[c092]SBC a:Arg_PlayerHealthDelta_L; Subtract the specified lower byte of health.
[c095]STA a:Player_HP_L; Store it as the new player health.


;
; Reduce the upper byte of player health.
;
[c098]LDA a:Player_HP_U; Load the upper byte of the player's health.
[c09b]SBC a:Arg_PlayerHealthDelta_U; Subtract the specified upper byte of health.
[c09e]STA a:Player_HP_U; Store it as the new player health.
[c0a1]BCS @_isStillAlive; If there's still health left, the player is still alive.


;
; The player is out of health. They may die.
;
[c0a3]LDA #$00
[c0a5]STA a:Player_HP_U; Set the player's upper byte of health to 0.
[c0a8]JSR UI_DrawPlayerHP; Draw the health.


;
; Check if the player has an elixir before killing them.
;
[c0ab]LDA a:SpecialItems; Load the player's special items.
[c0ae]AND #$08; Check if the player has an elixir.
[c0b0]BEQ @_killPlayer; If not, kill the player.


;
; The player has an elixir. Fill up their health instead
; of killing the player.
;
[c0b2]JMP Player_UseElixir; Use the Elixir.


;
; Mark the player as dead.
;
[c0b5]@_killPlayer:; [$c0b5]
[c0b5]LDA #$01; Mark the player as dead.
[c0b7]STA a:PlayerIsDead; Store that.


;
; Draw the player's health.
;
[c0ba]@_isStillAlive:; [$c0ba]
[c0ba]JMP UI_DrawPlayerHP; Draw player health.

;============================================================================
; Draw the player's health.
;
; INPUTS:
;     Player_HP_U:
;         The full value of the player's health.
;
; OUTPUTS:
;     None
;
; CALLS:
;     UI_DrawPlayerHPValue
;
; XREFS:
;     Player_ReduceHP
;     Player_UseHourGlass
;     UI_DrawHUD
;============================================================================
[c0bd]UI_DrawPlayerHP:; [$c0bd]
[c0bd]LDA a:Player_HP_U; Load the player's current health.
[c0c0]JMP UI_DrawPlayerHPValue; Draw it.

;============================================================================
; Decrement the MP for a spell.
;
; This will look at the selected magic type and deduct the
; cost from the player's total MP if there's enough to cast.
;
; INPUTS:
;     Player_MP:
;         The player's current MP.
;
;     SelectedMagic:
;         The selected magic.
;
;     MAGIC_COSTS:
;         The table of magic costs per spell.
;
; OUTPUTS:
;     C:
;         0 = Cost deducted for the spell.
;         1 = Not enough MP for the spell.
;
;     Player_MP:
;         The new MP amount.
;
; CALLS:
;     Player_SetMP
;
; XREFS:
;     Player_CastMagic
;============================================================================
[c0c3]Player_ReduceMP:; [$c0c3]
[c0c3]LDX a:SelectedMagic; Load the selected magic spell.
[c0c6]LDA a:Player_MP; Load the player's total MP.
[c0c9]SEC
[c0ca]SBC MAGIC_COSTS,X; Look up the cost of this spell.
[c0cd]BCC @_notEnoughMP; If there's not enough MP for the spell, then jump.


;
; The player has enough MP for the spell.
;
[c0cf]STA a:Player_MP; Else, store the reduced MP.
[c0d2]JSR Player_SetMP; Set that on the player and draw.
[c0d5]CLC; Clear the carry flag to indicate a success.
[c0d6]RTS


;
; The player does not have enough mana.
;
[c0d7]@_notEnoughMP:; [$c0d7]
[c0d7]SEC; Set the carry flag to 1 to indicate not enough MP.
[c0d8]RTS

;============================================================================
; Add points to the player's MP.
;
; This will be capped to 80 points.
;
; INPUTS:
;     A:
;         The MP to add.
;
;     Player_MP:
;         The player's current MP.
;
; OUTPUTS:
;     Player_MP:
;         The new MP.
;
; CALLS:
;     Player_SetMP
;
; XREFS:
;     Player_FillHPAndMP
;============================================================================
[c0d9]Player_AddMP:; [$c0d9]
;
; Add the provided MP to the player's MP.
;
[c0d9]CLC; Clear carry so it's not added.
[c0da]ADC a:Player_MP; Add to the player's  MP.
[c0dd]STA a:Player_MP; Store it.
[c0e0]CMP #$50; Check if it's > 80 points.
[c0e2]BCC @_drawMP; If we're under the cap, return.


;
; Cap the MP to the total allowed amount.
;
[c0e4]LDA #$50; Cap to 80 points.


;
; Store it.
;
[c0e6]STA a:Player_MP

[c0e9]@_drawMP:; [$c0e9]
[c0e9]JMP Player_SetMP; Set the player's mana points and draw.

;============================================================================
; NOTE: This is used exclusively by the Unknown 29 sprite behavior.
;
; XREFS:
;     SpriteBehavior_Unknown_29_SomeSetup
;============================================================================
[c0ec]Player_Something_ChangeHP:; [$c0ec]
[c0ec]TXA
[c0ed]PHA
[c0ee]LDA #$00
[c0f0]STA a:Temp1_SomethingChangedHP
[c0f3]STA a:Temp2_SomethingChangedHP
[c0f6]LDX #$10
[c0f8]ROL a:Arg_PlayerHealthDelta_L
[c0fb]ROL a:Arg_PlayerHealthDelta_U

[c0fe]@LAB_PRG15_MIRROR__c0fe:; [$c0fe]
[c0fe]ROL a:Temp1_SomethingChangedHP
[c101]ROL a:Temp2_SomethingChangedHP
[c104]LDA a:Temp1_SomethingChangedHP
[c107]CMP a:SpriteBehaviorUnknown20_SomethingXOrY
[c10a]LDA a:Temp2_SomethingChangedHP
[c10d]SBC a:BYTE_04bf
[c110]BCC @LAB_PRG15_MIRROR__c124
[c112]LDA a:Temp1_SomethingChangedHP
[c115]SBC a:SpriteBehaviorUnknown20_SomethingXOrY
[c118]STA a:Temp1_SomethingChangedHP
[c11b]LDA a:Temp2_SomethingChangedHP
[c11e]SBC a:BYTE_04bf
[c121]STA a:Temp2_SomethingChangedHP

[c124]@LAB_PRG15_MIRROR__c124:; [$c124]
[c124]ROL a:Arg_PlayerHealthDelta_L
[c127]ROL a:Arg_PlayerHealthDelta_U
[c12a]DEX
[c12b]BNE @LAB_PRG15_MIRROR__c0fe
[c12d]PLA
[c12e]TAX
[c12f]RTS

;============================================================================
; Clear sprite state.
;
; This will clear out all the current sprites and the
; selected weapon, and reset the screen color mode.
;
; INPUTS:
;     PPU_Mask:
;         The current screen color mode.
;
; OUTPUTS:
;     CurrentSprites_Entities:
;         The cleared sprite entities.
;
;     CurrentSprites_HP:
;         The cleared sprite HPs.
;
;     CurrentSprites_HitCounter:
;         The cleared sprite hit counters.
;
;     CurrentSprites_Behaviors:
;         The cleared sprite subtypes.
;
;     PPU_Mask:
;         The new color mode with greyscale removed.
;
;     IScript_PortraitID:
;         Set to 0xFF.
;
; CALLS:
;     CurrentSprite_ResetPPUTileOffset
;
; XREFS:
;     EndGame_Begin
;     Game_MainLoop
;     Player_HandleDeath
;     Screen_SetupSprites
;============================================================================
[c130]Screen_ClearSprites:; [$c130]
[c130]LDX #$07; X = 7 (loop counter -- looping 8 times)

[c132]@_clearSpritesLoop:; [$c132]
[c132]LDA #$ff
[c134]STA CurrentSprites_Entities,X; Set sprite to 0xFF (cleared).
[c137]LDA #$00
[c139]STA CurrentSprites_HP,X; Set sprite hit points to 0.
[c13c]STA CurrentSprites_HitCounter,X; Set sprite hit counter to 0.
[c13f]STA CurrentSprites_Behaviors,X; Set sprite subtype to 0.
[c142]DEX; X--
[c143]BPL @_clearSpritesLoop; If we're not done, loop.


;
; We're out of the loop. Reset the PPU draw offset and restore
; screen state.
;
[c145]JSR CurrentSprite_ResetPPUTileOffset; Reset the PPU offset.
[c148]LDA #$ff
[c14a]STA a:IScript_PortraitID; Clear any portrait shown on screen.
[c14d]LDA PPU_Mask; Load the current screen color mode.
[c14f]AND #$fe; Set to color mode (clear bit 1)
[c151]STA PPU_Mask; Store the new color mode.
[c153]RTS

;============================================================================
; Load extra information about the contents of the screen.
;
; This may include data such as sprite values, NPC IScript
; entrypoints, and special screen events (such as boss kill
; triggers).
;
; INPUTS:
;     Area_CurrentArea:
;         The area being loaded.
;
;     Area_CurrentScreen:
;         The screen being loaded within the area.
;
;     AREA_SPRITE_ADDRESSES:
;         The table of areas to screen lists.
;
; OUTPUTS:
;     Sprites_ReadInfoAddr:
;         The starting read address for the screen info.
;
;     CurrentScreen_SpecialEventID:
;         The screen's loaded special event ID (0xFF if
;         there is none).
;
;     Screen_ExtraInfoAddr:
;     Temp_Addr_L:
;         Used internally and clobbered.
;
; CALLS:
;     Screen_LoadSpecialEventID
;
; XREFS:
;     Screen_LoadSpriteInfo
;============================================================================
[c154]Screen_LoadAllScreenInfo:; [$c154]
;
; Set the address of the sprites-for-screen lookup table
; for the area.
;
[c154]LDA Area_CurrentArea; A = Current area index.
[c156]ASL A; Convert to a word offset for the lookup table.


;
; Set the starting address of the screen data.
;
[c157]TAY; Y = A
[c158]LDA AREA_SPRITE_ADDRESSES,Y; Load the upper byte of the address.
[c15b]STA Temp_Addr_L; Store for reading.
[c15d]LDA AREA_SPRITE_ADDRESSES+1,Y; Load the lower byte of thea ddress.
[c160]STA Temp_Addr_U; Store it.


;
; Check the first byte of the address. If 0xFF,
; nothing will be loaded.
;
[c162]LDY #$01; Y = 1
[c164]LDA (Temp_Addr_L),Y; Load the address for the screens list.
[c166]CMP #$ff; Is it 0xFF?
[c168]BEQ RETURN_C1B3; If so, there's nothing to load. Return.


;
; Set the start address for a screen's sprite and metadata
; information.
;
[c16a]LDA Area_CurrentScreen; A = Current screen index.
[c16c]ASL A; Convert to a word offset for the lookup table.
[c16d]TAY; Y = A


;
; Read the address for the screen information.
;
[c16e]LDA (Temp_Addr_L),Y; Load the lower byte of the screen address.
[c170]STA Sprites_ReadInfoAddr; Store it as the lower byte of the of the sprites read address.
[c172]INY; Y++
[c173]LDA (Temp_Addr_L),Y; Load the upper byte.
[c175]STA Sprites_ReadInfoAddr_U; And store it.


;
; Find the end of the sprites list for the screen.
;
; Sprites are in 2-byte pairs of (Entity ID, Sprite Value).
; This will skip those bytes until the end of the list is
; hit.
;
[c177]LDY #$00; Y = 0

[c179]@_readLoop:; [$c179]
[c179]LDA (Sprites_ReadInfoAddr),Y; Load the next byte from the screen data.
[c17b]CMP #$ff; Is it 0xFF?
[c17d]BNE @_prepareNextLoopIter; If not, jump to prepare for the next loop


;
; The sprite information is 0xFF, so we're done looping.
; Read the screen information.
;
[c17f]INY; Y++
[c180]TYA; A = Y
[c181]CLC
[c182]ADC Sprites_ReadInfoAddr; Increment the read address by 2 bytes.
[c184]STA Screen_ExtraInfoAddr
[c186]LDA Sprites_ReadInfoAddr_U; Load the upper byte.
[c188]ADC #$00; Add carry, if lower byte overflowed.
[c18a]STA Screen_ExtraInfoAddr_U; Store as the new upper byte.
[c18c]JMP Screen_LoadSpecialEventID; Read the extra screen information.


;
; Increment by 2 (the sprite entity and value).
;
[c18f]@_prepareNextLoopIter:; [$c18f]
[c18f]INY; Y++
[c190]INY; Y++
[c191]BNE @_readLoop; If Y > 0, loop.

;
; v-- Fall through --v
;

;============================================================================
; Clear the special event ID for the current screen.
;
; This disables any custom logic specific to certain screens.
;
; INPUTS:
;     None.
;
; OUTPUTS:
;     CurrentScreen_SpecialEventID:
;         Set to 0xFF (unset).
;
; XREFS:
;     Screen_LoadSpecialEventID
;============================================================================
[c193]Screen_SetNoSpecialEventID:; [$c193]
;
; No special event information was found for the screen.
; Clear that state (set to 0xFF).
;
[c193]LDA #$ff
[c195]STA a:CurrentScreen_SpecialEventID; Clear the special event ID (0xFF).
[c198]RTS

;============================================================================
; Load extra information about the current screen.
;
; Screens may contain a special event ID, which adds custom
; logic to perform on each tick on a screen. This is used
; for three things:
;
; 1. Managing the pushable block status on the path to
;    Mascon.
; 2. Boss battle logic.
; 3. Final boss logic.
;
; INPUTS:
;     Screen_ExtraInfoAddr:
;     Screen_ExtraInfoAddr+1:
;         The address containing the extra screen
;         information.
;
; OUTPUTS:
;     CurrentScreen_SpecialEventID:
;         The special event ID loaded from the screen info,
;         or 0xFF (unset) if not found.
;
; XREFS:
;     Screen_LoadAllScreenInfo
;============================================================================
[c199]Screen_LoadSpecialEventID:; [$c199]
;
; Begin scanning for a 0xFF in the screen information. This
; will indicate the start of extra information for the screen
; (special screen event states, IScripts entrypoint references).
;
[c199]LDY #$00; Y = 0 (loop counter)

[c19b]@_scanLoop:; [$c19b]
[c19b]LDA (Screen_ExtraInfoAddr),Y; Load the next byte in the screen info data.
[c19d]CMP #$ff; Is it 0xFF?
[c19f]BNE @_noFFMarker; If so, we found the start of the extra data to load. Jump.


;
; We found the start of the extra info for the screen. We're
; looking for 0x80, which indicates special event code will
; run on this screen every tick. The type of event will be
; indicated in the following byte.
;
; An example of this would be running code when a boss is
; defeated, producing an item.
;
[c1a1]INY; Y++
[c1a2]LDA (Screen_ExtraInfoAddr),Y; Load the next byte to see what we're working with.
[c1a4]CMP #$80; Is it 0x80?
[c1a6]BNE Screen_SetNoSpecialEventID; If not, then we won't be running special event code on this screen.


;
; This screen runs special event code. Load it.
;
[c1a8]INY; Y++
[c1a9]LDA (Screen_ExtraInfoAddr),Y; Load the next byte containing the special event ID.
[c1ab]STA a:CurrentScreen_SpecialEventID; Store it while on the screen.
[c1ae]RTS

[c1af]@_noFFMarker:; [$c1af]
[c1af]INY; Y++


;
; If we hit 256 loops, we're done.
;
[c1b0]BNE @_scanLoop; If we haven't wrapped, then loop.
[c1b2]RTS; Else, we're done.

;
; XREFS:
;     Screen_LoadAllScreenInfo
;
[c1b3]RETURN_C1B3:; [$c1b3]
[c1b3]RTS

;============================================================================
; Load information on a sprite from the screens list.
;
; This will read the next sprite entity ID in the screen
; information, followed by the block X/Y position where
; the sprite should be placed.
;
; INPUTS:
;     CurrentROMBank:
;         The current ROM bank.
;
;     Sprites_ReadInfoAddr:
;     Sprites_ReadInfoAddr+1:
;         The address in the screens table to read from.
;
; OUTPUTS:
;     CurrentSprite_Entity:
;         The loaded sprite entity ID.
;
;     CurrentSprite_XPos:
;         The loaded block X position of the sprite.
;
;     CurrentSprite_YPos:
;         The loaded block Y position of the sprite.
;
;     Sprites_ReadInfoAddr:
;     Sprites_ReadInfoAddr+1:
;         The updated address in the screens table to read
;         from.
;
; CALLS:
;     Screen_LoadAllScreenInfo
;     Sprites_PopulateNextAvailableSprite
;     MMC1_UpdateROMBank
;     MMC1_UpdatePRGBankToStackA
;
; XREFS:
;     Game_MainLoop
;     Screen_SetupSprites
;============================================================================
[c1b4]Screen_LoadSpriteInfo:; [$c1b4]
;
; Switch to ROM bank 11, where sprite information lives.
;
[c1b4]LDA a:CurrentROMBank; Load the current ROM bank.
[c1b7]PHA; Push it to the stack.
[c1b8]LDX #$0b
[c1ba]JSR MMC1_UpdateROMBank; Switch to bank 11.


;
; Load all the sprites for this screen.
;
[c1bd]JSR Screen_LoadAllScreenInfo; Load the sprite information for the screen.


;
; Switch bank to our previous bank.
;
[c1c0]PLA; Pop A (our saved bank).
[c1c1]TAX; X = A
[c1c2]JSR MMC1_UpdateROMBank; And switch back to it.


;
; Begin our loop for reading all sprites for the screen.
;
[c1c5]@_readSpriteLoop:; [$c1c5]
[c1c5]LDY #$00; Y =  0 (info read offset)


;
; Switch back to ROM bank 11 (sprite info).
;
[c1c7]LDA a:CurrentROMBank; A = current ROM bank
[c1ca]PHA; Push to the stack.
[c1cb]LDX #$0b
[c1cd]JSR MMC1_UpdateROMBank; Switch to bank 11.


;
; Read information on the next sprite on the screen.
;
[c1d0]LDA (Sprites_ReadInfoAddr),Y; Read the current byte of the screen information.
[c1d2]CMP #$ff; Is it 0xFF (our end-of-sprites list)?
[c1d4]BEQ @_restoreBankAndReturn; If it is, we're done. Restore our bank and return.


;
; Store the sprite's entity ID.
;
[c1d6]STA a:CurrentSprite_Entity; Store this byte as the sprite entity ID.


;
; Load the sprite's Y block position.
;
; This will be the upper nibble of the byte following the
; sprite entity ID.
;
[c1d9]INY; Y++
[c1da]LDA (Sprites_ReadInfoAddr),Y; Load the next byte.
[c1dc]AND #$f0; Take only the upper nibble.
[c1de]STA a:CurrentSprite_YPos; Store it as the sprite's starting Y position.


;
; Load the sprite's X block position.
;
; This will be the lower nibble, which will then be placed
; in the upper nibble.
;
[c1e1]LDA (Sprites_ReadInfoAddr),Y; Load the same byte.
[c1e3]ASL A; Shift the X coordinate from the lower nibble to the upper nibble.
[c1e4]ASL A
[c1e5]ASL A
[c1e6]ASL A
[c1e7]STA a:CurrentSprite_XPos; Store as the sprite's X position.


;
; Restore our bank.
;
[c1ea]PLA; Pull A (the saved bank) from the stack.
[c1eb]TAX; X = A
[c1ec]JSR MMC1_UpdateROMBank; And switch back to it.


;
; Finish processing this sprite. We'll add to the next
; available slot and fill in any information needed based
; on what we loaded.
;
[c1ef]JSR Sprites_PopulateNextAvailableSprite; Add this sprite to the next available slot.


;
; Increment the read address for the next sprite in the
; screen data.
;
[c1f2]LDA Sprites_ReadInfoAddr; A = lower byte of the screen information address
[c1f4]CLC
[c1f5]ADC #$02; Increment by 2 (sprite entity ID and position).
[c1f7]STA Sprites_ReadInfoAddr; Store as the new lower byte of the address.
[c1f9]LDA Sprites_ReadInfoAddr_U; A = upper byte of the screen information address
[c1fb]ADC #$00; Add carry if the lower byte overflowed.
[c1fd]STA Sprites_ReadInfoAddr_U; Store it as the new upper byte of the address.
[c1ff]JMP @_readSpriteLoop; Loop to read the next sprite.

[c202]@_restoreBankAndReturn:; [$c202]
[c202]JMP MMC1_UpdatePRGBankToStackA

;============================================================================
; Populate the loaded sprite in the next available slot.
;
; This will set the default state of the sprite, the
; sprite's HP, hitbox type, subtype, and behavior
; addresses.
;
; If the sprite can't fit on the screen, it will not be
; loaded.
;
; INPUTS:
;     CurrentSprite_Entity:
;         The loaded sprite entity ID.
;
;     CurrentSprite_XPos:
;         The loaded block X position.
;
;     CurrentSprite_YPos:
;         The loaded block Y position.
;
; OUTPUTS:
;     CurrentSprites_Entities:
;         The updated sprite entities.
;
;     CurrentSprites_Flags:
;         The updated sprite flags.
;
;     CurrentSprites_Phases:
;         The updated sprite phases.
;
;     CurrentSprites_HitByMagicBehavior:
;         The updated behaviors when hit by magic.
;
;     CurrentSprites_XPos_Full:
;         The updated sprite X positions.
;
;     CurrentSprites_YPos:
;         The updated sprite Y positions.
;
;     CurrentSprites_HitBoxTypes:
;         The updated sprite hit box types.
;
;     CurrentSprites_HP:
;         The updated sprite HPs.
;
;     CurrentSprites_BehaviorAddrs_L:
;         The updated sprite behavior address lower bytes.
;
;     CurrentSprites_BehaviorAddrs_U:
;         The updated sprite behavior address upper bytes.
;
;     CurrentSprites_Behaviors:
;         The updated sprite subtypes.
;
; CALLS:
;     Sprites_LoadSpriteValue
;
; XREFS:
;     Screen_LoadSpriteInfo
;============================================================================
[c205]Sprites_PopulateNextAvailableSprite:; [$c205]
;
; Prepare the sprite loop.
;
[c205]LDX #$07; 7 = loop counter

[c207]@_loop:; [$c207]
[c207]STX a:CurrentSpriteIndex; Set it
[c20a]LDA CurrentSprites_Entities,X; Load the sprite entity at this index.
[c20d]CMP #$ff; Is it 0xFF (unset)?
[c20f]BNE @_prepareNextIter; If not, jump to prepare for next loop.


;
; This sprite index is unset. Populate it.
;
[c211]LDA #$00; 0 = unset
[c213]STA CurrentSprites_Phases,X; Clear the sprite phase.
[c216]STA CurrentSprites_Flags,X; Clear the sprite flags.
[c219]LDA #$ff; 0xFF = unset
[c21b]STA CurrentSprites_HitByMagicBehavior,X; Clear the hit by magic behavior.


;
; Set the sprite's starting X/Y position.
;
[c21e]LDA a:CurrentSprite_XPos; Load the current sprite X position to set.
[c221]STA CurrentSprites_XPos_Full,X; Set for the sprite index.
[c223]LDA a:CurrentSprite_YPos; Load the Y position.
[c226]STA CurrentSprites_YPos,X; Set for the sprite index.
[c228]LDA a:CurrentSprite_Entity; Load the sprite entity.
[c22b]STA CurrentSprites_Entities,X; Set it.
[c22e]TAY; Y = A (entity)
[c22f]LDA SPRITE_ENTITIES_HITBOX_TYPES,Y; Load the hitbox type for the entity.
[c232]STA CurrentSprites_HitBoxTypes,X; Set it.
[c235]LDA SPRITE_ENTITIES_HP,Y; Load the HP for the entity.
[c238]STA CurrentSprites_HP,X; Set it.


;
; Prepare the behavior scripts for the entity.
;
[c23b]TYA; A = Y (entity)
[c23c]ASL A; Convert to a word boundary.
[c23d]TAY; Y = A
[c23e]LDA SPRITE_BSCRIPTS,Y; Load the lower byte of the behavior script for the entity.
[c241]STA CurrentSprites_BehaviorAddrs_L,X; Set the lower byte of the address.
[c244]LDA SPRITE_BSCRIPTS+1,Y; Load the upper byte.
[c247]STA CurrentSprites_BehaviorAddrs_U,X; Set the upper byte.
[c24a]LDA #$ff; A = 0xFF (unset)
[c24c]STA CurrentSprites_Behaviors,X; Clear the current behavior state.
[c24f]JMP Sprites_LoadSpriteValue; Load the value for the sprite and return.

[c252]@_prepareNextIter:; [$c252]
[c252]LDX a:CurrentSpriteIndex; X = current sprite index.
[c255]DEX; X--
[c256]BPL @_loop; If >= 0, loop.
[c258]RTS


;============================================================================
; Banks storing the images for a range of sprites.
;
; XREFS:
;     Sprites_StoreBankForCurrentSprite
;============================================================================

;
; XREFS:
;     Sprites_StoreBankForCurrentSprite
;
[c259]SPRITE_IMAGE_BANKS:; [$c259]
[c259].byte $06; [0]: Bank for sprites 0-54

;
; XREFS:
;     Sprites_StoreBankForCurrentSprite
;
[c25a]SPRITE_IMAGE_BANKS_1_:; [$c25a]
[c25a].byte $07; [1]: Bank for sprites 55-100

;============================================================================
; Load the value for a sprite from the screen's sprite info table.
;
; This loads the value information associated with a sprite
; on the screen. This may represent a message ID or some
; other value, depending on the sprite and situation.
;
; INPUTS:
;     X:
;         The sprite index to load the value for,
;
;     CurrentROMBank:
;         The currently-loaded ROM bank.
;
;     Screen_ExtraInfoAddr:
;     Screen_ExtraInfoAddr+1:
;         The current address for the extra sprite values
;         on the screen.
;
; OUTPUTS:
;     CurrentSprites_Values:
;         The updated sprite values.
;
;     Screen_ExtraInfoAddr:
;     Screen_ExtraInfoAddr+1:
;         The incremented address for the extra sprite
;         values on the screen.
;
; CALLS:
;     MMC1_UpdateROMBank
;     MMC1_UpdatePRGBankToStackA
;
; XREFS:
;     Sprites_PopulateNextAvailableSprite
;============================================================================
[c25b]Sprites_LoadSpriteValue:; [$c25b]
[c25b]TXA; A = X (sprite index)
[c25c]TAY; Y = A


;
; Save the current ROM bank and switch to bank 11.
;
[c25d]LDA a:CurrentROMBank; Get the current ROM bank.
[c260]PHA; Push to the stack.
[c261]LDX #$0b; X = 11 (bank)
[c263]JSR MMC1_UpdateROMBank; Switch to bank 11.


;
; Restore our sprite index to X so it's not clobbered
; when this returns.
;
[c266]TYA; A = Y
[c267]TAX; X = A


;
; Load the extra information for this sprite and store it
; in the sprite list.
;
[c268]LDY #$00; Y = 0
[c26a]LDA (Screen_ExtraInfoAddr),Y; A = Extra information for the sprite.
[c26c]STA CurrentSprites_Values,X; Store in CurrentSprites_Values.
[c26f]CMP #$ff; Is it 0xFF (unset)?
[c271]BEQ @_restoreBankAndReturn; If so, we're done. Jump.


;
; Increment the position in the info data.
;
[c273]INC Screen_ExtraInfoAddr; Increment the lower byte of the offset in the extra info data.
[c275]BNE @_restoreBankAndReturn; If this didn't wrap to 0, we're done. Jump.
[c277]INC Screen_ExtraInfoAddr_U; Else, increment the upper byte as well.

[c279]@_restoreBankAndReturn:; [$c279]
[c279]JMP MMC1_UpdatePRGBankToStackA; Restore the bank saved to the stack.

;============================================================================
; Determine and store the bank for images for the current sprite.
;
; This will determine which bank would store images for the
; currently-processed sprite.
;
; If the sprite entity ID is 0-54, this will be bank 6.
;
; If the sprite entity ID is 55-100, this will be bank 7.
;
; INPUTS:
;     CurrentSprite_Entity:
;         The entity ID for the currently-processed sprite.
;
;     SPRITE_IMAGE_BANKS:
;         The lookup table for sprite entity IDs to banks.
;
; OUTPUTS:
;     CurrentSprite_TilesBank:
;         The bank for the images for this sprite.
;
; XREFS:
;     GameLoop_LoadSpriteImages
;============================================================================
[c27c]Sprites_StoreBankForCurrentSprite:; [$c27c]
[c27c]LDY #$00; Y = 0
[c27e]LDA a:CurrentSprite_Entity; A = current sprite entity
[c281]CMP #$37; Is it < sprite 55 (Unused Child sprite)?
[c283]BCC @_loadBank; If yes, then load bank from table at index 0.
[c285]INY; Else, load bank from table at index 1.


;
; Load the image for the bank.
;
[c286]@_loadBank:; [$c286]
[c286]LDA SPRITE_IMAGE_BANKS,Y; Load the address for the sprite entity.
[c289]STA a:CurrentSprite_TilesBank; Store as the bank for this sprite.

[c28c]@_return:; [$c28c]
[c28c]RTS

;============================================================================
; Load images for all sprites on the scren.
;
; This will loop through each sprite and load the images,
; drawing them in the PPU buffer.
;
; If any sprites become off-screen (vertically), they'll be
; removed.
;
; As a special case, if the sprite is the boss Pakukame, a
; Lilith will be spawned.
;
; INPUTS:
;     CurrentSpriteIndex:
;         The current sprite index at the start of this
;         call.
;
;     CurrentSprites_Entities:
;         The list of sprite entities for all sprites on
;         screen.
;
; OUTPUTS:
;     CurrentSprites_Entities:
;         Updated if sprites are removed or added.
;
;     CurrentSprites_PPUOffsets:
;         PPU tile offsets for sprite data.
;
;     CurrentSprite_Entity:
;         Clobbered.
;
; CALLS:
;     CurrentSprite_ResetPPUTileOffset
;     PPUBuffer_WaitUntilClear
;     Sprites_LoadImageForCurrentSprite
;     Sprites_StoreBankForCurrentSprite
;
; XREFS:
;     Game_MainLoop
;     Game_SetupAndLoadOutsideArea
;     Game_SetupEnterBuilding
;     Game_SetupEnterScreen
;     Game_SetupExitBuilding
;     Game_SetupNewArea
;     Game_Start
;     IScripts_ClearPortraitImage
;============================================================================
[c28d]GameLoop_LoadSpriteImages:; [$c28d]
;
; Save state and prepare for image loading.
;
[c28d]LDA a:CurrentSpriteIndex; A = current sprite index
[c290]PHA; Push it to the stack.
[c291]JSR CurrentSprite_ResetPPUTileOffset; Reset the PPU drawing coordinates.


;
; Begin our loop for all 7 sprite slots.
;
[c294]LDX #$07; X = 7 (sprite index counter)


;
; Set this as the currently-processed sprite, and update
; the entity.
;
; We'll only process if the entity is not unset.
;
[c296]@_loop:; [$c296]
[c296]STX a:CurrentSpriteIndex; Store it as the currently-processed sprite index.
[c299]LDA CurrentSprites_Entities,X; Load the associated sprite entity ID.
[c29c]CMP #$ff; Is it 0xFF (unset)?
[c29e]BEQ @_nextLoop; If so, jump and prepare for the next loop.
[c2a0]STA a:CurrentSprite_Entity; Store this as the entity at this index.


;
; Load the image for this sprite.
;
[c2a3]JSR Sprites_StoreBankForCurrentSprite; Store the image bank for the current sprite.
[c2a6]JSR Sprites_LoadImageForCurrentSprite; Load the sprite's image from the bank.


;
; Special-case the Pakukame boss. If that was placed, then
; replace it with a Lilith instead. They spawn Liliths.
;
[c2a9]LDA a:CurrentSprite_Entity; Load the current entity.
[c2ac]CMP #$30; Is it the Pakukame boss?
[c2ae]BNE @_loadSpriteInfo; If not, jump.


;
; This is the Pakukame. Swap in a Lilith and load the image.
;
; This will then restore the entity back to Pakukame.
; Effectively, each Lilith on screen seems to be backed by
; a Pakukame.
;
[c2b0]LDA a:CurrentSprite_Entity; Load the Pakukame entity ID
[c2b3]PHA; Push to the stack.
[c2b4]LDA CurrentSprite_StartPPUTileOffset; Load the sprite's starting PPU tile offset.
[c2b6]PHA; Push it to the stack.
[c2b7]LDA #$09; A = 9 (Lilith)
[c2b9]STA a:CurrentSprite_Entity; Store as the new entity.
[c2bc]JSR Sprites_StoreBankForCurrentSprite; Store the bank for Lilith.
[c2bf]JSR Sprites_LoadImageForCurrentSprite; Load Lilth's image from the bank.
[c2c2]PLA; Pop the PPU offset row.
[c2c3]STA CurrentSprite_StartPPUTileOffset; Store it again.
[c2c5]PLA; Pop the current sprite entity.
[c2c6]STA a:CurrentSprite_Entity; Store it again.


;
; Store the starting PPU tile offset for the sprite.
;
; This will be stored in this sprite's slot in the current
; sprites information.
;
[c2c9]@_loadSpriteInfo:; [$c2c9]
[c2c9]LDX a:CurrentSpriteIndex; X = current sprite index
[c2cc]LDA CurrentSprite_StartPPUTileOffset; A = Start PPU tile offset
[c2ce]STA CurrentSprites_PPUOffsets,X; Set this in the PPU tile offsets for this sprite.


;
; Check if the sprite is on-screen or off-screen.
;
; If the Y position is off the screen (row 30 or higher),
; then the sprite will be unset.
;
[c2d1]LDA CurrentSprites_YPos,X; Load the Y position for this sprite.
[c2d3]CMP #$f0; Is it less than 0xF0?
[c2d5]BCC @_nextLoop; If so, loop.


;
; It's off-screen. Unset it.
;
[c2d7]LDA #$ff; Else, it's off the screen.
[c2d9]STA CurrentSprites_Entities,X; Unset the entity.


;
; Done with any loading required for the sprite. Prepare for
; the next loop, if needed.
;
[c2dc]@_nextLoop:; [$c2dc]
[c2dc]LDX a:CurrentSpriteIndex; X = current sprite index (loop counter).
[c2df]DEX; X--
[c2e0]BPL @_loop; If X >= 0, loop.


;
; We're done. Restore the original current sprite index and
; wait until everything's drawn to the screen.
;
[c2e2]PLA; Pull A (current sprite index) from the stack.
[c2e3]STA a:CurrentSpriteIndex; Store that back as the current sprite index.
[c2e6]JMP PPUBuffer_WaitUntilClear; Wait until everything's drawn to the screen.

;============================================================================
; Update a magic spell and run a magic-dependent handler.
;
; This is called for every tick of a magic spell. It's put
; on the stack by CastMagic_RunSpellHandler.
;
; This will update the visibility of the magic, set
; X/Y positions factoring in the screen scroll, and
; then set some state that ultimately is not used by
; the production build of Faxanadu.
;
; It will then call a magic-dependent update handler.
;
; INPUTS:
;     CastMagic_Type:
;         The magic type that was cast.
;
;     CastMagic_XPos_Full:
;         The X position of the magic.
;
;     CastMagic_YPos_Full:
;         The Y position of the magic.
;
;     Screen_Maybe_ScrollXCounter:
;     Player_Something_ScrollPosY:
;         Referenced but ultimately unused.
;
; OUTPUTS:
;     Arg_DrawSprite_PosX:
;     Arg_DrawSprite_PosY:
;         X and Y coordinates for the magic, used
;         for appearance management.
;
;     Unused_Sprite_ScrollPosX:
;     Unused_Sprite_ScrollPosY:
;         Set but unused.
;
; CALLS:
;     CastMagic_CalculateVisibility
;============================================================================
[c2e9]CastMagic_RunUpdateSpellHandler:; [$c2e9]
;
; These two lines are deadcode. It might be the developers
; attempting to hard-code Deluge and Thunder during testing?
; Each gets overriden immediately.
;
[c2e9]LDA #$00; A = 0 (deadcode)
[c2eb]LDA #$01; A = 1 (deadcode)
[c2ed]LDA a:CastMagic_Type; A = Cast magic type


;
; If 0xFF, return.
;
[c2f0]BMI @_return


;
; This was an active, cast magic spell. Set state.
;
[c2f2]JSR CastMagic_CalculateVisibility; Calculate visibility for the magic spell based on foreground elements.


;
; Manage the X position of the spell.
;
[c2f5]LDA a:CastMagic_XPos_Full; Load the magic's X position.
[c2f8]STA Arg_DrawSprite_PosX; Set as an argument for future appearance updates.


;
; Set some unused state not used in the finished game.
;
[c2fa]LDA Screen_Maybe_ScrollXCounter
[c2fc]STA Unused_Sprite_ScrollPosX


;
; Manage the Y position of the spell.
;
[c2fe]LDA a:CastMagic_YPos_Full
[c301]STA Arg_DrawSprite_PosY; Set as an argument for future appearance updates.


;
; Set more unused state not used in the finished game.
;
[c303]LDA Player_Something_ScrollPosY
[c305]STA Unused_Sprite_ScrollPosY


;
; Set the finish handler for this type as the next function
; to run.
;
[c307]LDA a:CastMagic_Type; Load the magic type.
[c30a]ASL A; Convert to a word boundary for the lookup table.
[c30b]TAY; Y = A
[c30c]LDA DAT_bb28,Y; Load the lower byte of the finish handler.
[c30f]PHA; Push to the stack.
[c310]LDA DAT_bb27,Y; Load the upper byte.
[c313]PHA; Push.

[c314]@_return:; [$c314]
[c314]RTS; Return and then call the function.

;============================================================================
; Calculate the visibility of the cast magic.
;
; This will check the cast magic against any foreground
; blocks, checking if it's fully visible, partially
; obscured, or fully obscured.
;
; INPUTS:
;     CastMagic_XPos_Full:
;         The X pixel position of the magic.
;
;     CastMagic_YPos_Full:
;         The Y pixel position of the magic.
;
; OUTPUTS:
;     Temp_MovingSpriteVisibility:
;         The visibility state of the cast magic.
;
;     MovingSpriteVisibility:
;         The visibility state of the cast magic.
;
;     Arg_PixelPosX:
;     Arg_PixelPosX:
;         Clobbered.
;
; CALLS:
;     Area_ConvertPixelsToBlockPos
;     ScreenBuffer_LoadBlockProperty
;
; XREFS:
;     CastMagic_RunUpdateSpellHandler
;============================================================================
[c315]CastMagic_CalculateVisibility:; [$c315]
;
; Set the default to visible.
;
[c315]LDA #$00
[c317]STA Temp_MovingSpriteVisibility; Set the default visibility to visible.


;
; Convert the cast magic's position to block positions.
;
[c319]LDA a:CastMagic_YPos_Full; Load the magic's Y position.
[c31c]STA Arg_PixelPosY; Set it as an argument for getting the block property.
[c31e]LDA a:CastMagic_XPos_Full; Load the magic's X position.
[c321]CLC
[c322]ADC #$04; Add 4 to that to better check block alignment.
[c324]STA Arg_PixelPosX; Set it as an argument.
[c326]JSR Area_ConvertPixelsToBlockPos; Convert to a block position.
[c329]JSR ScreenBuffer_LoadBlockProperty; Get the block property for this position.


;
; Check if a block overlaps the left.
;
[c32c]CMP #$04; Is this block type 4?
[c32e]BEQ @_leftIsObscured; If so, the left is obscured.
[c330]CMP #$0d; Else, is this block type 13?
[c332]BEQ @_leftIsObscured; If so, the left is obscured.
[c334]CMP #$09; Else, is this block type 9?
[c336]BNE @_checkRightObscured; If not, the left is not obscured. Start checking the right.


;
; This is a foreground layer block. The trailing part
; is obscured.
;
[c338]@_leftIsObscured:; [$c338]
[c338]LDA Temp_MovingSpriteVisibility; Load the cast magic's visibility state.
[c33a]ORA #$01; Mark the left-hand side as obscured.
[c33c]STA Temp_MovingSpriteVisibility; Store it.


;
; Now check the right-hand side of the magic.
;
[c33e]@_checkRightObscured:; [$c33e]
[c33e]LDA Arg_PixelPosX; Load the pixel X position.
[c340]CLC
[c341]ADC #$08; Add 8 to it, to better check the right side.
[c343]STA Arg_PixelPosX; Store as the new pixel argument.
[c345]JSR Area_ConvertPixelsToBlockPos; Convert to a block position.
[c348]JSR ScreenBuffer_LoadBlockProperty; Load the block property.


;
; Check if a block overlaps the right.
;
[c34b]CMP #$04; Is this block 4?
[c34d]BNE @_checkNeedToFlipBits; If not, it's not obscured.
[c34f]CMP #$04; Again, is this block 4?
[c351]BEQ @_rightIsObscured; If so, the right is obscured.
[c353]CMP #$0d; Else, is this block 13?
[c355]BEQ @_rightIsObscured; If so, the right is obscured.
[c357]CMP #$09; Else, is this block 9?
[c359]BNE @_checkNeedToFlipBits; If not, it's not obscured. Move to the next step.


;
; The trailing side of the magic is obscured.
;
[c35b]@_rightIsObscured:; [$c35b]
[c35b]LDA Temp_MovingSpriteVisibility; Load the cast magic's visibility state.
[c35d]ORA #$02; Mark the right-hand side as obscured.
[c35f]STA Temp_MovingSpriteVisibility; Store it.


;
; Check if the magic is partially-obscured (just left or
; right). If so, make sure the flips are flipped for the
; facing direction.
;
[c361]@_checkNeedToFlipBits:; [$c361]
[c361]LDX a:CurrentSpriteIndex; X = current sprite index.
[c364]LDA a:CastMagic_Flags; A = cast magic flags.
[c367]AND #$40; Is it facing right?
[c369]BEQ @_facingRight; If so, there's nothing to do. We're done.
[c36b]LDA Temp_MovingSpriteVisibility; A = cast magic visibility
[c36d]BEQ @_storeVisibility; If the block is fully visible, jump.
[c36f]CMP #$03; Else, is it full obscured?
[c371]BEQ @_storeVisibility; If yes, jump.


;
; Swap the bits to face the other direction.
;
[c373]EOR #$03; Swap the visibility of leading and trailing flags.
[c375]JMP @_storeVisibility; Jump to store.

[c378]@_facingRight:; [$c378]
[c378]LDA Temp_MovingSpriteVisibility; Load the previously-calculated visibility from above.

[c37a]@_storeVisibility:; [$c37a]
[c37a]STA MovingSpriteVisibility; Store the new visibility state.
[c37c]RTS

;============================================================================
; Set the appearance of the magic sprite.
;
; This will take in an offset into the magic's list of
; frames and set that as the new appearance.
;
; INPUTS:
;     A:
;         The offset into the list of frames.
;
;     CastMagic_Type:
;         The type of cast magic.
;
;     SPRITE_MAGIC_IMAGE_ADDRS_U:
;         The lookup table of upper addresses of magic
;         sprite images.
;
; CALLS:
;     Sprite_SetAppearanceAddrFromOffset
;
; XREFS:
;     CastMagic_FinishHandler_Death
;     CastMagic_FinishHandler_Deluge
;     CastMagic_FinishHandler_DelugeOrDeathAfterHit
;     CastMagic_FinishHandler_Fire
;     CastMagic_FinishHandler_HitWallEffect
;     CastMagic_FinishHandler_Thunder
;     CastMagic_FinishHandler_Tilte
;     CastMagic_FinishHandler_TilteAfterFirstHit
;============================================================================
[c37d]CastMagic_SetAppearance:; [$c37d]
[c37d]LDY a:CastMagic_Type; Y = cast magic type
[c380]CLC
[c381]ADC SPRITE_MAGIC_IMAGE_ADDRS_U,Y; Add the value from the lookup table.
[c384]JMP Sprite_SetAppearanceAddrFromOffset; Set the sprite appearance.


;============================================================================
; Table of upper address bytes for magic sprite images.
;
; XREFS:
;     CastMagic_SetAppearance
;============================================================================

;
; XREFS:
;     CastMagic_SetAppearance
;
[c387]SPRITE_MAGIC_IMAGE_ADDRS_U:; [$c387]
[c387].byte $95; [0]: Deluge
[c388].byte $99; [1]: Thunder
[c389].byte $9b; [2]: Fire
[c38a].byte $9d; [3]: Death
[c38b].byte $a1; [4]: Tilte
[c38c].byte $a5; [5]: UNUSED: Deluge after first hit
[c38d].byte $99; [6]: Thunder after first hit
[c38e].byte $9b; [7]: Fire after first hit
[c38f].byte $a5; [8]: UNUSED: Death after first hit
[c390].byte $a5; [9]: UNUSED
[c391].byte $a5; [10]: UNUSED: Hit wall effect
[c392].byte $a5; [11]: Tilte after first hit

;============================================================================
; Set whether a cast magic's sprite is flipped based on the cast direction.
;
; INPUTS:
;     CastMagic_Flags:
;         The cast magic's flags.
;
; OUTPUTS:
;     CurrentSprite_FlipMask:
;         The sprite's flip state.
;
; XREFS:
;     CastMagic_FinishHandler_Death
;     CastMagic_FinishHandler_Deluge
;     CastMagic_FinishHandler_DelugeOrDeathAfterHit
;     CastMagic_FinishHandler_Fire
;     CastMagic_FinishHandler_Thunder
;     CastMagic_FinishHandler_Tilte
;============================================================================
[c393]CastMagic_UpdateSpriteDirection:; [$c393]
[c393]LDA a:CastMagic_Flags; Load the cast magic's flags.
[c396]AND #$40; Take only the facing direction bit.
[c398]STA CurrentSprite_FlipMask; Set as the sprite's flip mask.
[c39a]RTS

;============================================================================
; Finish updating the Deluge spell.
;
; This will maintain the sprite's direction and update
; the appearance.
;
; INPUTS:
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_UpdateSpriteDirection
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb27]
;============================================================================
[c39b]CastMagic_FinishHandler_Deluge:; [$c39b]
[c39b]JSR CastMagic_UpdateSpriteDirection; Set the sprite's direction.
[c39e]LDA InterruptCounter; Load the interrupt counter.
[c3a0]LSR A; Shift the interrupt counter to generate an appearance index.
[c3a1]LSR A
[c3a2]AND #$03; Keep the 2 right-most bits (effectively, bits 3 and 4 of the interrupt counter).
[c3a4]JMP CastMagic_SetAppearance; Set that as the appearance index.

;============================================================================
; Finish updating the Thunder spell.
;
; This will maintain the sprite's direction and update
; the appearance.
;
; It will update the appearance for 2 frames at a time,
; and wait 2 frames in-between.
;
; INPUTS:
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_UpdateSpriteDirection
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb29]
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb33]
;============================================================================
[c3a7]CastMagic_FinishHandler_Thunder:; [$c3a7]
[c3a7]JSR CastMagic_UpdateSpriteDirection; Set the sprite's direction.
[c3aa]LDA InterruptCounter; Load the interrupt counter.
[c3ac]LSR A; Shift the interrupt counter to generate a value to check against.
[c3ad]LSR A
[c3ae]BCS @_return; If this should not update the appearance, return.
[c3b0]AND #$01; Keep the right-most bit (effectively, bit 2 of the interrupt counter).
[c3b2]JMP CastMagic_SetAppearance; Set that as the appearance index.

[c3b5]@_return:; [$c3b5]
[c3b5]RTS

;============================================================================
; Finish updating the Fire spell.
;
; This will maintain the sprite's direction and update
; the appearance.
;
; It will run for 2 frames, skip 2 frames, run for 2 frames,
; etc.
;
; INPUTS:
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_UpdateSpriteDirection
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb2b]
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb35]
;============================================================================
[c3b6]CastMagic_FinishHandler_Fire:; [$c3b6]
[c3b6]LDA InterruptCounter; Load the interrupt counter.
[c3b8]AND #$02; Is bit 1 set?
[c3ba]BNE @_updateFire; If so, jump to update.
[c3bc]RTS

[c3bd]@_updateFire:; [$c3bd]
[c3bd]JSR CastMagic_UpdateSpriteDirection; Set the sprite's direction.
[c3c0]LDA InterruptCounter; Load the interrupt counter.
[c3c2]LSR A; Shift the interrupt counter to generate an appearance index.
[c3c3]LSR A
[c3c4]AND #$01; Keep the right-most bit (effectively, bit 2 of the interrupt counter).
[c3c6]JMP CastMagic_SetAppearance; Set that as the appearance index.

;============================================================================
; Finish updating the Death spell.
;
; This will maintain the sprite's direction and update
; the appearance.
;
; INPUTS:
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_UpdateSpriteDirection
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb2d]
;============================================================================
[c3c9]CastMagic_FinishHandler_Death:; [$c3c9]
[c3c9]JSR CastMagic_UpdateSpriteDirection; Update the sprite's direction.
[c3cc]LDA InterruptCounter; Load the interrupt counter.
[c3ce]LSR A; Shift the interrupt counter to generate an appearance index.
[c3cf]LSR A
[c3d0]LSR A
[c3d1]AND #$03; Keep the 2 right-most bits (effectively, bits 3 and 4 of the interrupt counter).
[c3d3]JMP CastMagic_SetAppearance; Set that as the appearance index.

;============================================================================
; Finish updating the Tilte spell.
;
; This will set the appearance to 0, 1, 2, or 3,
; based on the current phase of the magic spell and
; the interrupt counter.
;
; The appearance will be:
;
; * 0: Magic phase is even;
;      Interrupt counter has bit 3 set.
;
; * 1: Magic phase is even;
;      Interrupt counter does not have bit 3 set.
;
; * 2: Magic phase is odd;
;      Interrupt counter has bit 1 and 2 unset.
;
; * 3: Magic phase is odd;
;      Interrupt counter has bit 1 unset and 2 set.
;
; INPUTS:
;     CastMagic_Phase:
;         The phase of the magic spell.
;
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb2f]
;============================================================================
[c3d6]CastMagic_FinishHandler_Tilte:; [$c3d6]
[c3d6]JSR CastMagic_UpdateSpriteDirection; Update the sprite's direction.


;
; Check if the first bit of the magic's phase is 0 or 1.
;
[c3d9]LDA a:CastMagic_Phase; Load the magic's phase.
[c3dc]LSR A; Shift bit 0 into Carry.
[c3dd]BCS @_phaseIs1; If it's set, jump.


;
; The magic phase is 0. Update the appearance.
;
; The appearance value will be 1 if the interrupt counter
; does not have bit 3 set.
;
[c3df]LDY #$00; Y = 0
[c3e1]LDA InterruptCounter; A = interrupt counter
[c3e3]AND #$08; Keep bit 3.
[c3e5]BEQ @_setAppearance1; If 0, jump to use 0 as the appearance value.
[c3e7]INY; Y++ (appearance value == 1)

[c3e8]@_setAppearance1:; [$c3e8]
[c3e8]TYA; A = 0 or 1 (appearance value)
[c3e9]JMP CastMagic_SetAppearance; Set the appearance of the magic.


;
; The magic phase is 1. Update the appearance if the
; interrupt counter has bit 1 unset.
;
[c3ec]@_phaseIs1:; [$c3ec]
[c3ec]LDA InterruptCounter; Load the interrupt counter.
[c3ee]LSR A; Divide by 2.
[c3ef]LSR A; And place in Carry.
[c3f0]BCC @_setAppearance2; If 0, jump to update appearance.
[c3f2]RTS


;
; The appearance will be updated based on the interrupt
; counter. It will be 3 if bit 2 is unset, or 4 if set.
;
[c3f3]@_setAppearance2:; [$c3f3]
[c3f3]AND #$01; Keep bit 0.
[c3f5]CLC
[c3f6]ADC #$02; Add 2.
[c3f8]JMP CastMagic_SetAppearance; Set the appearance of the magic.

;============================================================================
; UNUSED: Finish handling updates to Deluge and Death spells that have
; collided at least once.
;
; This would maintain the sprite's direction and appearance.
;
; It's never actually run, due to both these spells clearing
; immediately when colliding.
;
; INPUTS:
;     None.
;
; OUTPUTS:
;     None.
;
; CALLS:
;     CastMagic_SetAppearance
;     CastMagic_UpdateSpriteDirection
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb31]
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb37]
;============================================================================
[c3fb]CastMagic_FinishHandler_DelugeOrDeathAfterHit:; [$c3fb]
[c3fb]JSR CastMagic_UpdateSpriteDirection; Update the sprite direction.
[c3fe]LDA #$00
[c400]JMP CastMagic_SetAppearance; Set the appearance to 0.

;============================================================================
; UNUSED: Add a Magic Hit Wall effect.
;
; This was meant to be used by the Deluge and Fire magic.
; Upon hitting a wall, it would briefly spawn two explosion
; sprites (using the diagonal Tilte sprite) up against the
; collided block, before disappearing.
;
; This may have been wired off because there appears to be
; a race condition in the Fire spell, where it may not
; always show.
;
; This can be reactivated using the following Game Genie
; codes:
;
; ZAVLOUNN
; ZEUUSUNN
;
; INPUTS:
;     CastMagic_Unused_HitWallDeltaPosY:
;         The delta Y position for the hit wall sprite.
;
;     CastMagic_YPos_Full:
;         The Y position of the magic sprite.
;
; OUTPUTS:
;     CurrentSprite_FlipMask:
;         Set to 0.
;
;     Arg_DrawSprite_PosY:
;     Temp_00:
;         Clobbered.
;
; CALLS:
;     CastMagic_SetAppearance
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb3b]
;============================================================================
[c403]CastMagic_FinishHandler_HitWallEffect:; [$c403]
;
; Set the default flip mask of the sprite to 0 (face right).
;
[c403]LDA #$00
[c405]STA CurrentSprite_FlipMask; Set flip mask to face right.


;
; Calculate a multiplier used to position the explosion
; sprites.
;
; This will be the delta Y position * 2.
;
[c407]LDA a:CastMagic_Unused_HitWallDeltaPosY; A = Delta Y position.
[c40a]ASL A; A *= 2
[c40b]STA Temp_00; Save it temporarily.


;
; Position and draw the top explosion sprite.
;
; This will be MagicY - (DeltaY * 2).
;
[c40d]LDA a:CastMagic_YPos_Full; A = Magic Y position.
[c410]SEC
[c411]SBC Temp_00; A -= Effect delta Y position.
[c413]STA Arg_DrawSprite_PosY; Set as the new sprite's Y position.
[c415]LDA #$02
[c417]JSR CastMagic_SetAppearance; Draw the top explosion sprite at that position.


;
; Position and draw the bottom explosion sprite.
;
; This will be MagicY + 16 + (DeltaY * 2).
;
[c41a]LDA a:CastMagic_Unused_HitWallDeltaPosY; A = Delta Y position.
[c41d]ASL A; A *= 2
[c41e]CLC
[c41f]ADC #$10; A += 16
[c421]CLC
[c422]ADC a:CastMagic_YPos_Full; A += Magic Y position.
[c425]STA Arg_DrawSprite_PosY; Save it as the new sprite's Y position.
[c427]LDA #$03
[c429]JMP CastMagic_SetAppearance; Draw the bottom explosion sprite at that position.

;============================================================================
; TODO: Document CastMagic_FinishHandler_TilteAfterFirstHit
;
; INPUTS:
;     None.
;
; OUTPUTS:
;     TODO
;
; XREFS:
;     CAST_MAGIC_UPDATE_FINISH_HANDLERS [$PRG14::bb3d]
;============================================================================
[c42c]CastMagic_FinishHandler_TilteAfterFirstHit:; [$c42c]
[c42c]LDA #$00
[c42e]STA CurrentSprite_FlipMask
[c430]LDX #$03

[c432]@_loop:; [$c432]
[c432]LDA a:CastMagic_Counter
[c435]ASL A
[c436]PHA
[c437]STA Temp_00
[c439]EOR MAGICHITHANDLER_c42c_ARRAY1,X
[c43c]BPL @LAB_PRG15_MIRROR__c442
[c43e]STA Temp_00
[c440]INC Temp_00

[c442]@LAB_PRG15_MIRROR__c442:; [$c442]
[c442]LDA a:CastMagic_XPos_Full
[c445]CLC
[c446]ADC Temp_00
[c448]STA Arg_DrawSprite_PosX
[c44a]PLA
[c44b]STA Temp_00
[c44d]EOR $c470,X
[c450]BPL @LAB_PRG15_MIRROR__c456
[c452]STA Temp_00
[c454]INC Temp_00

[c456]@LAB_PRG15_MIRROR__c456:; [$c456]
[c456]LDA a:CastMagic_YPos_Full
[c459]CLC
[c45a]ADC Temp_00
[c45c]STA Arg_DrawSprite_PosY
[c45e]TXA
[c45f]PHA
[c460]LDA $c474,X
[c463]JSR CastMagic_SetAppearance
[c466]PLA
[c467]TAX
[c468]DEX
[c469]BPL @_loop
[c46b]RTS

[c46c]MAGICHITHANDLER_c42c_ARRAY1:; [$c46c]
[c46c].byte $ff; [0]:
[c46d].byte $00; [1]:

;
; XREFS:
;     CastMagic_FinishHandler_TilteAfterFirstHit
;
[c46e]MAGICHITHANDLER_c42c_ARRAY1_2_:; [$c46e]
[c46e].byte $ff; [2]:

;
; XREFS:
;     CastMagic_FinishHandler_TilteAfterFirstHit
;
[c46f]MAGICHITHANDLER_c42c_ARRAY1_3_:; [$c46f]
[c46f].byte $00; [3]:
[c470].byte $ff; [0]:
[c471].byte $ff; [1]:
[c472].byte $00; [2]:

;
; XREFS:
;     CastMagic_FinishHandler_TilteAfterFirstHit
;
[c473]BYTE_ARRAY_PRG15_MIRROR__c470_3_:; [$c473]
[c473].byte $00; [3]:
[c474].byte $00; [0]:
[c475].byte $02; [1]:
[c476].byte $01; [2]:

;
; XREFS:
;     CastMagic_FinishHandler_TilteAfterFirstHit
;
[c477]BYTE_ARRAY_PRG15_MIRROR__c474_3_:; [$c477]
[c477].byte $03; [3]:

;============================================================================
; Check whether the user wants to use the selected item.
;
; This will check if the player has both initiated an action
; to use the item and is in a position to use one.
;
; If these conditions are met, the action handler for the
; item will be invoked.
;
; INPUTS:
;     Player_Flags:
;         The player's current flags.
;
;     Joy1_ButtonMask:
;         The currently-held buttons.
;
;     Joy1_ChangedButtonMask:
;         The newly-pressed buttons.
;
;     SelectedItem:
;         The selected item.
;
; OUTPUTS:
;     None
;
; XREFS:
;     EndGame_MainLoop
;     Game_MainLoop
;============================================================================
[c478]GameLoop_CheckUseCurrentItem:; [$c478]
[c478]LDA Player_Flags; Load the player's flags.


;
; Check if the player is in a state where they'd be allowed
; to use an item.
;
[c47a]AND #$05
[c47c]BNE GameLoop_UseItem_Return


;
; Check if the Down button has been pressed. If not, return.
;
[c47e]LDA Joy1_ButtonMask; Load the button mask.
[c480]AND #$04; Check if the Down button is pressed.
[c482]BEQ GameLoop_UseItem_Return; If not, return.


;
; Check if the B button has been pressed. If not, return.
;
[c484]LDA a:Joy1_ChangedButtonMask; Load the changed button mask.
[c487]AND #$40; Check if the B button is pressed.
[c489]BEQ GameLoop_UseItem_Return; If not, return.


;
; Down-B was pressed. The item can be used, if a valid one is
; selected. Figure out if there's a valid one first...
;
[c48b]LDA a:SelectedItem; Load the selected item.
[c48e]ASL A; Multiply by 2 to get a word boundary for address lookup.
[c48f]TAY; Y = A
[c490]CPY #$22; Is it a valid item?
[c492]BCS GameLoop_UseItem_Return; If not, return.


;
; Look up this item in the jump table and run it.
;
[c494]LDA USE_ITEM_JUMP_TABLE+1,Y; Load the lower byte of the item handler address.
[c497]PHA; Push it.
[c498]LDA USE_ITEM_JUMP_TABLE,Y; Load the upper byte.
[c49b]PHA; Push it.

;
; XREFS:
;     GameLoop_CheckUseCurrentItem
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c49d]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c49f]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4a1]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4a3]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4a5]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4a7]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4a9]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4ab]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4ad]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4b1]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4b3]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4b5]
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4b9]
;
[c49c]GameLoop_UseItem_Return:; [$c49c]
[c49c]RTS


;============================================================================
; Handler functions for using specific items.
;
; XREFS:
;     GameLoop_CheckUseCurrentItem
;============================================================================

;
; XREFS:
;     GameLoop_CheckUseCurrentItem
;
[c49d]USE_ITEM_JUMP_TABLE:; [$c49d]
[c49d].word GameLoop_UseItem_Return-1; [0]: Ring of Elf
[c49f].word GameLoop_UseItem_Return-1; [1]: Ring of Ruby
[c4a1].word GameLoop_UseItem_Return-1; [2]: Ring of Dworf
[c4a3].word GameLoop_UseItem_Return-1; [3]: Demon's Ring
[c4a5].word GameLoop_UseItem_Return-1; [4]: "A" Key
[c4a7].word GameLoop_UseItem_Return-1; [5]: "K" Key
[c4a9].word GameLoop_UseItem_Return-1; [6]: "Q" Key
[c4ab].word GameLoop_UseItem_Return-1; [7]: "J" Key
[c4ad].word GameLoop_UseItem_Return-1; [8]: "Jo" Key
[c4af].word Player_UseMattock-1; [9]: Mattock
[c4b1].word GameLoop_UseItem_Return-1; [10]: Magical Rod
[c4b3].word GameLoop_UseItem_Return-1; [11]: Crystal
[c4b5].word GameLoop_UseItem_Return-1; [12]: Lamp
[c4b7].word Player_UseHourGlass-1; [13]: Hour Glass
[c4b9].word GameLoop_UseItem_Return-1; [14]: Book
[c4bb].word Player_UseWingBoots-1; [15]: Wing Boots
[c4bd].word Player_UseRedPotion-1; [16]: Red Potion

;============================================================================
; Clear the selected item.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     SelectedItem:
;         The cleared item selection.
;
; CALLS:
;     UI_ClearSelectedItemPic
;
; XREFS:
;     Player_UseHourGlass
;     Player_UseMattock
;     Player_UseRedPotion
;     Player_UseWingBoots
;============================================================================
[c4bf]Player_ClearSelectedItem:; [$c4bf]
[c4bf]PHA; Push A to the stack.
[c4c0]LDA #$ff
[c4c2]STA a:SelectedItem; Set selected item to 0xFF (unset).
[c4c5]JSR UI_ClearSelectedItemPic; Update the UI for the cleared image.
[c4c8]PLA; Pop A from the stack.
[c4c9]RTS

;============================================================================
; Use the player's Elixir.
;
; This will remove the Elixir from the inventory and update the player's
; health.
;
; This then falls through to Player_FillHPAndMP.
;
; INPUTS:
;     SpecialItems:
;         The special items bitmask to update.
;
;     Player_HP_U:
;         The player's HP.
;
;     Player_MP:
;         The player's MP.
;
; OUTPUTS:
;     SpecialItems:
;         The new special items bitmask with the
;         Elixir removed.
;
;     Player_HP_U:
;         The player's updated HP.
;
;     Player_MP:
;         The player's updated MP.
;
; CALLS:
;     Player_AddHP
;     Player_AddMP
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;     WaitForNextFrame
;     Sprites_FlipRanges
;
; XREFS:
;     Player_ReduceHP
;============================================================================
[c4ca]Player_UseElixir:; [$c4ca]
[c4ca]LDA a:SpecialItems; Load the special items.
[c4cd]AND #$f7; Clear the elixir bit.
[c4cf]STA a:SpecialItems; Store it.


;
; Run the "Use Elixir" IScript.
;
; IScript 0x85 via jump to IScripts_Begin.
;
[c4d2]LDA #$85; 0x85 == Use Elixir.
[c4d4]JSR MMC1_LoadBankAndJump; Run IScript:
[c4d7].byte BANK_12_LOGIC; Bank = 12
[c4d8].word IScripts_Begin-1; Address = IScripts_Begin

;============================================================================
; Progressively fill the player's HP and MP.
;
; This will add 4HP and 4MP at a time, playing a sound
; effect for each segment. This appears to the player as
; the HP and MP bars filling up.
;
; INPUTS:
;     SpecialItems:
;         The special items bitmask to update.
;
;     Player_HP_U:
;         The player's HP.
;
;     Player_MP:
;         The player's MP.
;
; OUTPUTS:
;     SpecialItems:
;         The new special items bitmask with the
;         Elixir removed.
;
;     Player_HP_U:
;         The player's updated HP.
;
;     Player_MP:
;         The player's updated MP.
;
; CALLS:
;     Player_AddHP
;     Player_AddMP
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;     WaitForNextFrame
;     Sprites_FlipRanges
;
; XREFS:
;     Player_FillHPAndMP
;============================================================================
[c4da]Player_FillHPAndMP:; [$c4da]
;
; Progressively fill the HP, 4 units at a time.
;
; Start by playing the sound.
;
[c4da]LDA #$13; Set sound 0x13 (fill HP/MP bar).
[c4dc]JSR Sound_PlayEffect; Play it.


;
; Add the HP.
;
[c4df]LDA #$04; Set the HP to 4 units.
[c4e1]JSR Player_AddHP; Add it to the player.
[c4e4]JSR Game_DrawScreenInFrozenState; Draw the screen, and prevent updating until done.


;
; Wait 4 frames of updates before filling up the next units
; of HP, to help animate the bar.
;
[c4e7]JSR WaitForNextFrame; Wait a bit.
[c4ea]JSR Sprites_FlipRanges
[c4ed]JSR WaitForNextFrame
[c4f0]JSR Sprites_FlipRanges
[c4f3]JSR WaitForNextFrame
[c4f6]JSR Sprites_FlipRanges
[c4f9]JSR WaitForNextFrame
[c4fc]JSR Sprites_FlipRanges


;
; Check if we're done filling up HP.
;
[c4ff]LDA a:Player_HP_U; Load the player's HP.
[c502]CMP #$50; Is it below the cap of 80HP?
[c504]BCC Player_FillHPAndMP; If so, loop.


;
; Progressively fill the MP, 4 units at a time.
;
; Start by playing the sound.
;
[c506]@_fillMPLoop:; [$c506]
[c506]LDA #$13; Set sound 0x13 (fill HP/MP bar).
[c508]JSR Sound_PlayEffect; Play it.


;
; Add the MP.
;
[c50b]LDA #$04; Set the MP to 4 units.
[c50d]JSR Player_AddMP; Add it to the player.
[c510]JSR Game_DrawScreenInFrozenState; Draw the screen but keep all sprites frozen.


;
; Wait 4 frames of updates before filling up the next units
; of MP, to help animate the bar.
;
[c513]JSR WaitForNextFrame; Wait a bit.
[c516]JSR Sprites_FlipRanges
[c519]JSR WaitForNextFrame
[c51c]JSR Sprites_FlipRanges
[c51f]JSR WaitForNextFrame
[c522]JSR Sprites_FlipRanges
[c525]JSR WaitForNextFrame
[c528]JSR Sprites_FlipRanges


;
; Check if we're done filling up MP.
;
[c52b]LDA a:Player_MP; Load the player's MP.
[c52e]CMP #$50; Is it below the cap of 80MP?
[c530]BCC @_fillMPLoop; If so, loop.
[c532]RTS

;============================================================================
; Use the Red Potion item.
;
; This will play the Red Potion message and a sound
; effect, and remove the item from the inventory.
;
; Health will be progressively filled.
;
; INPUTS:
;     Player_HP_U:
;         The player's HP.
;
; OUTPUTS:
;     Player_HP_U:
;         The player's updated HP.
;
; CALLS:
;     Game_DrawScreenInFrozenState
;     MMC1_LoadBankAndJump
;     Player_ClearSelectedItem
;     Player_AddHP
;     Sound_PlayEffect
;     Sprites_FlipRanges
;     WaitForNextFrame
;
; XREFS:
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4bd]
;============================================================================
[c533]Player_UseRedPotion:; [$c533]
;
; Run the "Used Red Potion" IScript.
;
; IScript 0x80 via jump to IScripts_Begin.
;
[c533]LDA #$80; 0x80 == Use Red Potion IScript.
[c535]JSR MMC1_LoadBankAndJump; Run IScript:
[c538].byte BANK_12_LOGIC; Bank = 12
[c539].word IScripts_Begin-1; Address = IScripts_Begin

[c53b]@_afterFarJump:; [$c53b]
[c53b]JSR Player_ClearSelectedItem; Clear the selected item.


;
; Play the initial sound effect.
;
[c53e]LDA #$1a; 0x1A == Initial item used sound effect.
[c540]JSR Sound_PlayEffect; Play it.


;
; Set up the HP fill loop. This will fill up to 80.
;
[c543]LDX #$50; X = Maximum HP / our loop counter.

[c545]@_loop:; [$c545]
[c545]TXA; A = X
[c546]PHA; Push it to the stack.


;
; Play the unit fill sound effect.
;
[c547]LDA #$13; 0x13 = Unit of HP fill sound effect.
[c549]JSR Sound_PlayEffect; Play the sound.


;
; Add 2HP.
;
[c54c]LDA #$02
[c54e]JSR Player_AddHP; Add the 2HP to the player.
[c551]JSR Game_DrawScreenInFrozenState


;
; Wait 4 frames worth of updates before filling the next 2HP.
;
[c554]JSR WaitForNextFrame
[c557]JSR Sprites_FlipRanges
[c55a]JSR WaitForNextFrame
[c55d]JSR Sprites_FlipRanges
[c560]JSR WaitForNextFrame
[c563]JSR Sprites_FlipRanges
[c566]JSR WaitForNextFrame
[c569]JSR Sprites_FlipRanges


;
; Check if we're done.
;
[c56c]PLA; Pop the max HP.
[c56d]TAX; X = A
[c56e]LDA a:Player_HP_U; Load the player's current HP.
[c571]CMP #$50; Is the player at max HP?
[c573]BCS @_return; If so, return.
[c575]DEX; X--
[c576]BNE @_loop; If X > 0, loop.

[c578]@_return:; [$c578]
[c578]RTS

;============================================================================
; Use the Wing Boots item.
;
; This will play the Wing Boots message and a sound
; effect, and remove the item from the inventory.
;
; The duration of the Wing Boots will depend on the
; player's title:
;
; * 40 seconds: Novice, Aspirant, Battler, Fighter
; * 30 seconds: Adept, Chevalier, Veteran, Warrior
; * 20 seconds: Swordman, Hero, Soldier, Myrmidon
; * 10 seconds: Champion, Superhero, Paladin, Lor
;
; INPUTS:
;     PlayerTitle:
;         The player's current title.
;
;     TITLE_TO_WINGBOOTS_DURATION:
;         The table of player titles to Wingboots duration.
;
; OUTPUTS:
;     DurationWingBoots:
;         The starting number of seconds remaining for the
;         Wing Boots.
;
; CALLS:
;     Player_ClearSelectedItem:
;     Sound_PlayEffect
;     MMC1_LoadBankAndJump
;     UI_DrawTimeValue
;
; XREFS:
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4bb]
;============================================================================
[c579]Player_UseWingBoots:; [$c579]
;
; Run the "Wing Boots Used" IScript.
;
; IScript 0x83 via jump to IScripts_Begin.
;
[c579]LDA #$83; 0x83 == Wing Boots used IScript.
[c57b]JSR MMC1_LoadBankAndJump; Run IScript:
[c57e].byte BANK_12_LOGIC; Bank = 12
[c57f].word IScripts_Begin-1; Address = IScripts_Begin


;
; Remove the item.
;
[c581]@_afterFarJump:; [$c581]
[c581]JSR Player_ClearSelectedItem; Clear the selected item.


;
; Play a sound effect for the item usage.
;
[c584]LDA #$1a; Set the sound to play to 0x1A (special item sound).
[c586]JSR Sound_PlayEffect; Play the sound.


;
; Calculate the index into the duration table based on
; the player's title.
;
[c589]LDA a:PlayerTitle; Load the player's title.
[c58c]LSR A; Divide by 4.
[c58d]LSR A
[c58e]TAX; X = A (index)
[c58f]LDA TITLE_TO_WINGBOOTS_DURATION,X; Look up in the duration table.
[c592]STA a:DurationWingBoots; Set that as the starting duration.
[c595]JSR UI_DrawTimeValue; Draw the time on the HUD.
[c598]RTS


;============================================================================
; Wing Boots durations by player title.
;
; The duration decreases every 4 player titles.
;
; XREFS:
;     Player_UseWingBoots
;============================================================================

;
; XREFS:
;     Player_UseWingBoots
;
[c599]TITLE_TO_WINGBOOTS_DURATION:; [$c599]
[c599].byte $28; [0]: 40 seconds: Novice, Aspirant, Battler, Fighter
[c59a].byte $1e; [1]: 30 seconds: Adept, Chevalier, Veteran, Warrior
[c59b].byte $14; [2]: 20 seconds: Swordman, Hero, Soldier, Myrmidon
[c59c].byte $0a; [3]: 10 seconds: Champion, Superhero, Paladin, Lord

;============================================================================
; Decrement the Wing Boot's duration.
;
; This will decrement and then draw the time in the HUD.
;
; INPUTS:
;     DurationWingBoots:
;         The remaining duration for the Wing Boots.
;
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     DurationWingBoots:
;         The new duration for the Wing Boots.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     UI_DrawTimeValue
;
; XREFS:
;     GameLoop_CountdownItems
;============================================================================
[c59d]Game_DecWingBootsDuration:; [$c59d]
;
; Check if there's any time remaining on the Wing Boots.
;
[c59d]LDA a:DurationWingBoots; Load the remaining time on the Wing Boots.
[c5a0]BMI @_return; If the counter is unset (0xFF), return.


;
; Update the player's status to mark Wing Boots as on.
;
[c5a2]LDA Player_StatusFlag; Load the player's status flags.
[c5a4]ORA #$80; Enable the Wing Boots bit.
[c5a6]STA Player_StatusFlag; Store it.


;
; Update at most once every second.
;
[c5a8]LDA InterruptCounter; Load the interrupt counter.
[c5aa]AND #$3f; Check if we're at the 1 second mark.
[c5ac]BNE @_return; If not, return.


;
; Reduce time on the Wing Boots by a second.
;
[c5ae]DEC a:DurationWingBoots; Decrement the remaining time for the Wing Boots.
[c5b1]LDA a:DurationWingBoots; Load that duration
[c5b4]BMI @_wingBootsDone; If it wrapped from 0 to 0xFF, it's used up. Jump.
[c5b6]JMP UI_DrawTimeValue; Else, draw the time remaining.


;
; The Wing Boots ran out. Remove the flag from the player's
; status.
;
[c5b9]@_wingBootsDone:; [$c5b9]
[c5b9]LDA Player_StatusFlag; Load the player's status flags.
[c5bb]AND #$7f; Clear the Wing Boots flag.
[c5bd]STA Player_StatusFlag; Store it.


;
; Run "Wing Boots are gone" IScript.
;
; IScript 0x96 via jump to IScripts_Begin.
;
[c5bf]LDA #$96; 0x96 == Wing Boots are gone IScript.
[c5c1]JSR MMC1_LoadBankAndJump; Run the IScript:
[c5c4].byte BANK_12_LOGIC; Bank = 12
[c5c5].word IScripts_Begin-1; Address = IScripts_Begin


;
; It will resume here.
;
[c5c7]@_return:; [$c5c7]
[c5c7]RTS

;============================================================================
; Use the Hour Glass.
;
; This will invoke the IScript for the Hour Glass's
; message, play a sound, and begin the Hour Glass
; effect.
;
; The player's health will be reduced by half in the
; process.
;
; INPUTS:
;     Player_HP_U:
;     Player_HP_L:
;         The player's current health.
;
; OUTPUTS:
;     Player_HP_U:
;     Player_HP_L:
;         The player's new health, reduced by half.
;
;     DurationHourGlass:
;         The duration of the Hour Glass.
;
;     Music_Current:
;         The music to play while the Hour Glass is
;         active.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_ClearSelectedItem
;     Sound_PlayEffect
;     UI_DrawPlayerHP
;
; XREFS:
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4b7]
;============================================================================
[c5c8]Player_UseHourGlass:; [$c5c8]
;
; Run the "Hour Glass Used" IScript.
;
; IScript 0x82 via jump to IScripts_Begin.
;
[c5c8]LDA #$82; Set the IScript to run to 0x82.
[c5ca]JSR MMC1_LoadBankAndJump; Run IScript:
[c5cd].byte BANK_12_LOGIC; Bank = 12
[c5ce].word IScripts_Begin-1; Address = IScripts_Begin


;
; Remove the item.
;
[c5d0]@_afterFarJump:; [$c5d0]
[c5d0]JSR Player_ClearSelectedItem; Clear the selected item.


;
; Play a sound effect for the item usage.
;
[c5d3]LDA #$1a; Set the sound to play to 0x1A (special item sound).
[c5d5]JSR Sound_PlayEffect; Play the sound.


;
; Reduce the player's health by half. This is the cost of
; the Hour Glass.
;
[c5d8]LSR a:Player_HP_U; Divide the upper value of the player's HP by half.
[c5db]ROR a:Player_HP_L; Divide the lower byte of the player's HP by half, and add carry from the upper.
[c5de]JSR UI_DrawPlayerHP; Draw the new HP.


;
; Set the duration of the Hour Glass to 15 seconds.
;
[c5e1]LDA #$0f; Set the duration to 15 seconds.
[c5e3]STA a:DurationHourGlass


;
; Change the music.
;
[c5e6]LDA #$0b; Set the new music to play.
[c5e8]STA Music_Current; And play it.
[c5ea]RTS

;============================================================================
; Decrement the Hour Glass's duration.
;
; INPUTS:
;     DurationHourGlass:
;         The remaining duration for the Hour Glass.
;
;     InterruptCounter:
;         The current interrupt counter.
;
; OUTPUTS:
;     DurationHourGlass:
;         The new duration for the Hour Glass..
;
;     Music_Current:
;         The restored music for the area.
;
; CALLS:
;     MMC1_LoadBankAndJump
;
; XREFS:
;     GameLoop_CountdownItems
;============================================================================
[c5eb]Game_DecHourGlassDuration:; [$c5eb]
;
; Check if there's any time remaining on the Hour Glass.
;
[c5eb]LDA a:DurationHourGlass; Load the remaining time on the Hour Glass.
[c5ee]BMI @_return; If the counter is unset (0xFF), return.


;
; Update at most once every second.
;
[c5f0]LDA InterruptCounter; Load the interrupt counter.
[c5f2]AND #$3f; Check if we're at the 1 second mark.
[c5f4]BNE @_return; If not, return.


;
; Reduce time on the Hour Glass by a second.
;
[c5f6]DEC a:DurationHourGlass; Decrement the remaining time for the Hour Glass.
[c5f9]BPL @_return; If it wrapped from 0 to 0xFF, it's used up. Jump.


;
; Run "Hour Glass is gone" IScript.
;
; IScript 0x97 via jump to IScripts_Begin.
;
[c5fb]LDA #$97; 0x97 == Hour Glass is gone IScript.
[c5fd]JSR MMC1_LoadBankAndJump; Run the IScript:
[c600].byte BANK_12_LOGIC; Bank = 12
[c601].word IScripts_Begin-1; Address = IScripts_Begin


;
; Load the area's default music.
;
[c603]@_afterFarJump:; [$c603]
[c603]LDA a:Areas_DefaultMusic; Load the music for the area.
[c606]STA Music_Current; Store it.

[c608]@_return:; [$c608]
[c608]RTS

;============================================================================
; Add 100XP to the player's experience.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     Temp_Int24:
;     Temp_Int24+1:
;         Clobbered.
;
; CALLS:
;     Player_UpdateExperience
;
; XREFS:
;     Player_PickUpGlove
;     Player_PickUpOintment
;============================================================================
[c609]Player_Add100XP:; [$c609]
[c609]LDA #$64; A = 100 (lower byte of XP)
[c60b]STA a:Temp_Int24; Store it as an argument.
[c60e]LDA #$00; A = 0 (upper byte of XP).
[c610]STA a:Temp_Int24_M; Store it as an argument.
[c613]JMP Player_UpdateExperience; Update the player's experience using those values.

;============================================================================
; Use the Mattock.
;
; This will check if the Mattock can be used at the current
; player position. If so, it will invoke the IScript for the
; Mattock's message, play a sound, and update the level state.
;
; INPUTS:
;     Area_CurrentArea:
;         The current area.
;
;     Player_PosX_Block:
;         The player's current X position.
;
;     Player_PosY:
;         The player's current Y position.
;
;     Player_Flags:
;         The player's flags.
;
;     USE_MATTOCK_BLOCK_DISTANCES:
;         TODO
;
; OUTPUTS:
;     Arg_PixelPosX:
;     Arg_PixelPosY:
;         Clobbered.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_ClearSelectedItem
;     Sound_PlayEffect
;     WaitForNextFrame
;     Area_SetBlocks
;
; XREFS:
;     USE_ITEM_JUMP_TABLE [$PRG15_MIRROR::c4af]
;============================================================================
[c616]Player_UseMattock:; [$c616]
;
; Check if the block check position will be in bounds.
;
; The offset will be dependent on the facing direction.
;
; If facing left, this will check the block immediately
; to the left (0xFF -- wrapping around the screen).
;
; If facing right, this will check block + 16 (within or
; at the end of the blocks to clear).
;
[c616]LDY #$00; Lookup table index = 0 (default)
[c618]LDA Player_Flags; Load the player's flags.
[c61a]AND #$40; Is the player facing right?
[c61c]BEQ @LAB_PRG15_MIRROR__c61f; If not, jump.


;
; The player is facing right. Set our offset into the block
; distances table to 1.
;
[c61e]INY; Lookup table index = 1

[c61f]@LAB_PRG15_MIRROR__c61f:; [$c61f]
[c61f]LDA Player_PosX_Block; Get the player's X position.
[c621]CLC
[c622]ADC USE_MATTOCK_BLOCK_DISTANCES,Y; Add the block distance for the facing direction.
[c625]CMP #$f0; Is the player too near to the right edge of the screen?
[c627]BCS @_return; If so, return.


;
; Begin fetching the block at this offset.
;
; Same logic as above for block calculation.
;
[c629]STA Arg_PixelPosX; Store the calculated position as the X argument.
[c62b]LDA Player_PosY; Load the player's current Y position.
[c62d]STA Arg_PixelPosY; Store that as the Y argument.
[c62f]JSR Area_ConvertPixelsToBlockPos; Convert those pixel positions to block positions.


;
; Check if the screen buffer contains the blocks to clear.
; If not, there's nothing to do.
;
; Each block is composed of 4 tiles, which are represented
; in the lookup table. This only needs to check for the
; presence of one of those blocks.
;
[c632]LDA Area_CurrentArea; Load the current area.
[c634]ASL A; Convert to a 4 byte index.
[c635]ASL A
[c636]TAY; Y = index
[c637]LDA ScreenBuffer,X; Load the value from the screen buffer.
[c63a]CMP USE_MATTOCK_BLOCK_TRANSITIONS,Y; Is this block already cleared by the Mattock?
[c63d]BEQ @_useMattock; If not, use the Mattock to clear them.
[c63f]RTS; Else, return.


;
; The Mattock will be used. Store the offsets into the
; screen buffer and array on the stack for later.
;
[c640]@_useMattock:; [$c640]
[c640]TXA; A = X
[c641]PHA; Push to the stack.
[c642]TYA; A = Y
[c643]PHA; Push to the stack.


;
; Run the "Used Mattock" IScript.
;
; IScript 0x81 via jump to IScripts_Begin.
;
[c644]LDA #$81
[c646]JSR MMC1_LoadBankAndJump; Run IScript:
[c649].byte BANK_12_LOGIC; Bank = 12
[c64a].word IScripts_Begin-1; Address = IScripts_Begin


;
; Remove the Mattock.
;
[c64c]@_afterFarJump:; [$c64c]
[c64c]JSR Player_ClearSelectedItem; Clear the selected item.


;
; Play the sound effect for the Mattock usage.
;
[c64f]LDA #$1a; 0x1A == Special item sound effect.
[c651]JSR Sound_PlayEffect; Play it.


;
; Prepare for the loop.
;
; This loop will handle animating the destruction/crumbling
; of blocks. This uses 4 frames of animation, all defined in
; USE_MATTOCK_BLOCK_TRANSITIONS.
;
[c654]PLA; Pull A from the stack.
[c655]TAY; Y = A
[c656]PLA; Pull A from the stack.
[c657]TAX; X = A


;
; Only update every 4 frames, to get a quick animation effect.
;
[c658]@_loop:; [$c658]
[c658]JSR WaitForNextFrame; Wait for 4 frames.
[c65b]JSR WaitForNextFrame
[c65e]JSR WaitForNextFrame
[c661]JSR WaitForNextFrame


;
; Update the screen to place the next block in the sequence.
;
[c664]TYA; A = Y
[c665]PHA; Push to the stack.
[c666]TXA; A = X
[c667]PHA; Push to the stack.
[c668]LDA USE_MATTOCK_BLOCK_TRANSITIONS,Y; Load the block for this position.
[c66b]STA ScreenBuffer,X; And store it in the screen buffer.
[c66e]JSR Area_SetBlocks; Update the level data.


;
; Update to the next block.
;
[c671]TXA; A = X
[c672]CLC
[c673]ADC #$10; A += 32
[c675]TAX; X = A
[c676]LDA a:Arg_BlockAttributesIndex; Load a value.
[c679]STA ScreenBuffer,X; And write it to the screen buffer.
[c67c]JSR Area_SetBlocks; Upate the level data.


;
; Prepare for the next loop iteration.
;
[c67f]PLA; Pull A from the stack.
[c680]TAX; X = A
[c681]PLA; Pull A from the stack.
[c682]TAY; Y = A
[c683]INY; Y++
[c684]TYA; A = Y
[c685]AND #$03; Have we finished updating the blocks?
[c687]BEQ @_return; If so, return.
[c689]JMP @_loop; Else, loop.

[c68c]@_return:; [$c68c]
[c68c]RTS


;============================================================================
; Block distances for checking if a player is on-screen.
;
; This is used when using the Mattock.
;
; XREFS:
;     Player_UseMattock
;============================================================================

;
; XREFS:
;     Player_UseMattock
;
[c68d]USE_MATTOCK_BLOCK_DISTANCES:; [$c68d]
[c68d].byte $ff; [0]:

;
; XREFS:
;     Player_UseMattock
;
[c68e]USE_MATTOCK_BLOCK_DISTANCES_1_:; [$c68e]
[c68e].byte $10; [1]:


;============================================================================
; New block IDs to place when clearing blocks.
;
; This is divided into regions, each with 4 blocks.
; Those 4 blocks are an animation transition between
; the placed blocks (index 0 within a group) and
; cleared blocks (index 3).
;
; XREFS:
;     Player_UseMattock
;============================================================================

;
; XREFS:
;     Player_UseMattock
;
[c68f]USE_MATTOCK_BLOCK_TRANSITIONS:; [$c68f]
[c68f].byte $00; [0]: Eolis
[c690].byte $00; [1]:
[c691].byte $00; [2]:
[c692].byte $00; [3]:
[c693].byte $63; [4]: Apolune
[c694].byte $85; [5]:
[c695].byte $86; [6]:
[c696].byte $42; [7]:
[c697].byte $00; [8]: Forepaw
[c698].byte $00; [9]:
[c699].byte $00; [10]:
[c69a].byte $00; [11]:
[c69b].byte $00; [12]: Mascon
[c69c].byte $00; [13]:
[c69d].byte $00; [14]:
[c69e].byte $00; [15]:
[c69f].byte $00; [16]: Victim
[c6a0].byte $00; [17]:
[c6a1].byte $00; [18]:
[c6a2].byte $00; [19]:
[c6a3].byte $00; [20]: Conflate
[c6a4].byte $00; [21]:
[c6a5].byte $00; [22]:
[c6a6].byte $00; [23]:
[c6a7].byte $00; [24]: Daybreak
[c6a8].byte $00; [25]:
[c6a9].byte $00; [26]:
[c6aa].byte $00; [27]:
[c6ab].byte $00; [28]: Evil Fortress
[c6ac].byte $00; [29]:
[c6ad].byte $00; [30]:
[c6ae].byte $00; [31]:

;============================================================================
; Clear timers on all temporary status items.
;
; This applies to the Glove, Ointment, Wing Boots, and
; Hour Glass.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     DurationGlove:
;     DurationHourGlass:
;     DurationOintment:
;     DurationWingBoots:
;         All set to 0xFF (not active).
;
; XREFS:
;     Game_Start
;     Player_Spawn
;============================================================================
[c6af]Game_ClearTimedItems:; [$c6af]
[c6af]LDA #$ff
[c6b1]STA a:DurationGlove; Clear the Glove duration.
[c6b4]STA a:DurationOintment; Clear the Ointment duration.
[c6b7]STA a:DurationWingBoots; Clear the Wing Boots duration.
[c6ba]STA a:DurationHourGlass; Clear the Hour Glass duration.
[c6bd]RTS

;============================================================================
; Handle picking up the Hour Glass.
;
; This will invoke the IScript, play the sound, and add
; the Hour Glass to the inventory.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     None
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;     Player_PickUpItem
;
; XREFS:
;     Player_PickUp
;============================================================================
[c6be]Player_PickUpHourGlass:; [$c6be]
;
; Run the "Got Hour Glass" IScript.
;
; IScript 0x8A via jump to IScripts_Begin.
;
[c6be]LDA #$8a; 0x8A == Hour Glass picked up IScript.
[c6c0]JSR MMC1_LoadBankAndJump; Run IScript:
[c6c3].byte BANK_12_LOGIC; Bank = 12
[c6c4].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c6c6]@_afterFarJump:; [$c6c6]
[c6c6]LDA #$08; 0x08 == Item picked up sound.
[c6c8]JSR Sound_PlayEffect; Play it.


;
; Pick up the item.
;
[c6cb]LDA #$0d; 0xD == Hour Glass.
[c6cd]JMP Player_PickUpItem; Pick it up.

;============================================================================
; Handle picking up the Wing Boots for the quest.
;
; This will invoke the IScript, play the sound, and add
; the Wing Boots to the inventory.
;
; INPUTS:
;     Quests:
;         The player's current completed quests.
;
; OUTPUTS:
;     Quests:
;         The updated set of completed quests.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_PickUpItem
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c6d0]Player_PickUpWingBootsWithQuest:; [$c6d0]
[c6d0]LDA a:Quests; Load the completed quests.
[c6d3]ORA #$08; Mark this quest as completed.
[c6d5]STA a:Quests; Store it back out.

;
; v-- Fall through --v
;

;============================================================================
; Handle picking up the Wing Boots.
;
; This will invoke the IScript, play the sound, and add
; the Wing Boots to the inventory.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     None
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_PickUpItem
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c6d8]Player_PickUpWingBoots:; [$c6d8]
;
; Run the "Got Wing Boots" IScript.
;
; IScript 0x89 via jump to IScripts_Begin.
;
[c6d8]LDA #$89; 0x89 == Wing boots picked up IScript.
[c6da]JSR MMC1_LoadBankAndJump; Run IScript:
[c6dd].byte BANK_12_LOGIC; Bank = 12
[c6de].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c6e0]@_afterFarJump:; [$c6e0]
[c6e0]LDA #$08; 0x8 == Item pick-up sound.
[c6e2]JSR Sound_PlayEffect; Play it.


;
; Pick up the item.
;
[c6e5]LDA #$0f; 0xF == Wing Boots.
[c6e7]JMP Player_PickUpItem; Pick it up.

;============================================================================
; Pick up the Battle Suit and add to the inventory.
;
; This will invoke the IScript, play the sound, and then
; attempt to cap the armor insert position and add the item
; there.
;
; BUGS:
;     This has a bug where it checks the caps against the
;     WEAPON slots, not the ARMOR slots!
;
;     Player_PickUpDragonSlayer has the inverse
;     bug.
;
; INPUTS:
;     NumberOfWeapons:
;         The number of weapons the player is carrying.
;
; OUTPUTS:
;     ArmorInventory:
;         The updated armor inventory.
;
;     NumberOfArmors:
;         The number of armors in the inventory.
;
;     See CALLS.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c6ea]Player_PickUpBattleSuit:; [$c6ea]
;
; Run the "Got Battle Suit" IScript.
;
; IScript 0x8B via jump to IScripts_Begin.
;
[c6ea]LDA #$8b; 0x8B == Battle Suit picked up IScript.
[c6ec]JSR MMC1_LoadBankAndJump; Run IScript:
[c6ef].byte BANK_12_LOGIC; Bank = 12
[c6f0].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c6f2]@_afterFarJump:; [$c6f2]
[c6f2]LDA #$08; 0x08 == Item picked up sound.
[c6f4]JSR Sound_PlayEffect; Play it.


;
; Cap the number of WEAPONS in the inventory.
;
; Yes, weapons. This *should* be armor. This code is swapped
; with the code that equips the Dragon Slayer.
;
[c6f7]LDX a:NumberOfWeapons; X = Number of weapons.
[c6fa]CPX #$04; If < 4
[c6fc]BCC @_addItem; Then, add it to the latest slot.
[c6fe]LDX #$03; Else, cap X to 3.


;
; Add the Battle Suit to the inventory.
;
[c700]@_addItem:; [$c700]
[c700]LDA #$03; 0x03 == Battle Suit
[c702]STA ArmorInventory,X; Set in the inventory slot


;
; Increase the number of armors collected.
;
[c705]INX; X++
[c706]STX a:NumberOfArmors; Store as the number of armors.
[c709]RTS

;============================================================================
; Pick up the Battle Helmet and add to the inventory.
;
; This will invoke the IScript, play the sound, and then
; cap the shield insertion point and add the item there.
;
; Keep in mind, the Battle Helmet is considered a shield in
; this game.
;
; INPUTS:
;     NumberOfShields:
;         The number of shields the player is carrying.
;
; OUTPUTS:
;     ShieldInventory:
;         The updated armor inventory.
;
;     NumberOfShields:
;         The number of armors in the inventory.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c70a]Player_PickUpBattleHelmet:; [$c70a]
;
; Run the "Got Battle Helmet" IScript.
;
; IScript 0x8C via jump to IScripts_Begin.
;
[c70a]LDA #$8c; 0x8C == Battle Helmet picked up IScript.
[c70c]JSR MMC1_LoadBankAndJump; Run it.
[c70f].byte BANK_12_LOGIC; Bank = 12
[c710].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c712]@_afterFarJump:; [$c712]
[c712]LDA #$08; 0x08 == Item picked up sound.
[c714]JSR Sound_PlayEffect; Play it.


;
; Cap the number of shields in the inventory.
;
[c717]LDX a:NumberOfShields; X = Number of shields.
[c71a]CPX #$04; If X < 4:
[c71c]BCC @_addItem; Then, add to the latest slot.
[c71e]LDX #$03; Else, cap X to 3.


;
; Add the Battle Helmet to the inventory.
;
[c720]@_addItem:; [$c720]
[c720]LDA #$03; 0x03 == Battle Helmet.
[c722]STA ShieldInventory,X; Set in the inventory slot.


;
; Increase the number of shields collected.
;
[c725]INX; X++
[c726]STX a:NumberOfShields; Store as the number of shields.
[c729]RTS

;============================================================================
; Pick up the Dragon Slayer and add to the inventory.
;
; This will invoke the IScript, play the sound, and then
; attempt to cap the armor insert position and add the item
; there.
;
; BUGS:
;     This has a bug where it checks the caps against the
;     ARMOR slots, not the WEAPON slots!
;
;     Player_PickUpBattleSuit has the inverse
;     bug.
;
; INPUTS:
;     NumberOfArmors:
;         The number of armors the player is carrying.
;
; OUTPUTS:
;     WeaponInventory:
;         The updated weapon inventory.
;
;     NumberOfWeapons:
;         The number of weapons in the inventory.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c72a]Player_PickUpDragonSlayer:; [$c72a]
;
; Run the "Got Dragon Slayer" IScript.
;
; IScript 0x8D via jump to IScripts_Begin.
;
[c72a]LDA #$8d; 0x8D == Dragon Slayer picked up IScript.
[c72c]JSR MMC1_LoadBankAndJump; Run it.
[c72f].byte BANK_12_LOGIC; Bank = 12
[c730].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c732]@_afterFarJump:; [$c732]
[c732]LDA #$08; 0x08 == Item picked up sound.
[c734]JSR Sound_PlayEffect; Play it.


;
; Cap the number of ARMORS in the inventory.
;
; Yes, armors. This *should* be weapons. This code is swapped
; with the code that equips the Battle Suit.
;
[c737]LDX a:NumberOfArmors; X = number of armors.
[c73a]CPX #$04; If < 4
[c73c]BCC @_addItem; Then, add it to the latest slot.
[c73e]LDX #$03; Else, cap X to 3.


;
; Add the Dragon Slayer to the inventory.
;
[c740]@_addItem:; [$c740]
[c740]LDA #$03; 0x03 == Dragon Slayer
[c742]STA WeaponInventory,X; Set in the inventory slot.


;
; Increase the number of weapons collected.
;
[c745]INX; X++
[c746]STX a:NumberOfWeapons; Store as the number of weapons.
[c749]RTS

;============================================================================
; Handle picking up the Mattock for the quest.
;
; This will invoke the IScript, play the sound, and set
; the Mattock bit in the quests and in the inventory.
;
; INPUTS:
;     Quests:
;         The current completed quests.
;
; OUTPUTS:
;     Quests:
;         The updated completed quests.
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_PickUpItem
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c74a]Player_PickUpMattockWithQuest:; [$c74a]
[c74a]LDA a:Quests; Load the quests bitmask.
[c74d]ORA #$10; Bit 0x10 == Mattock
[c74f]STA a:Quests; Save it.

;
; v-- Fall through to the next function. --v
;

;============================================================================
; Handle picking up the Mattock.
;
; This will invoke the IScript, play the sound, and add
; the Mattock to the inventory.
;
; INPUTS:
;     None
;
; OUTPUTS:
;     None
;
; CALLS:
;     MMC1_LoadBankAndJump
;     Player_PickUpItem
;     Sound_PlayEffect
;
; XREFS:
;     Player_PickUp
;============================================================================
[c752]Player_PickUpMattock:; [$c752]
;
; Run the "Got Mattock" IScript.
;
; IScript 0x88 via jump to IScripts_Begin.
;
[c752]LDA #$88; 0x88 == Mattock picked up IScript.
[c754]JSR MMC1_LoadBankAndJump; Run IScript:
[c757].byte BANK_12_LOGIC; Bank = 12
[c758].word IScripts_Begin-1; Address = IScripts_Begin


;
; Play the sound effect for picking up an item.
;
[c75a]@_afterFarJump:; [$c75a]
[c75a]LDA #$08; 0x08 == Item picked up sound.
[c75c]JSR Sound_PlayEffect; Play it.


;
; Load the Mattock into the inventory.
;
[c75f]LDA #$09; 0x09 == Mattock
[c761]JMP Player_PickUpItem; Pick up the Mattock.

;============================================================================
; Handle picking up an item.
;
; INPUTS:
;     A:
;         The sprite entity that was interacted with.
;
;         This will determine the proper handler for the
;         item pick-up.
;
; OUTPUTS:
;     See CALLS.
;
; CALLS:
;     Player_PickUpBattleHelmet
;     Player_PickUpBattleSuit
;     Player_PickUpBlackOnyx
;     Player_PickUpDragonSlayer
;     Player_PickUpElixir
;     PRG15::87cf
;     Player_PickUpHourGlass
;     Player_PickUpMagicalRod
;     Player_PickUpMattock
;     Player_PickUpMattockWithQuest
;     Player_PickUpOintment
;     Player_PickUpPendant
;     Player_PickUpPoison
;     Player_PickUpRedPotion
;     Player_PickUpWingBoots
;     Player_PickUpWingBootsWithQuest
;
; XREFS:
;     Player_HandleTouchItem
;============================================================================
[c764]Player_PickUp:; [$c764]
;
; Check if this is the Mattock.
;
[c764]CMP #$50; 0x50 == Mattock
[c766]BEQ Player_PickUpMattock; If 0x50, this is the Mattock. Pick it up.


;
; Check if this is the Magical Rod.
;
[c768]CMP #$57; 0x57 == Magical Rod
[c76a]BNE @_checkBattleSuit
[c76c]JMP Player_PickUpMagicalRod; This is the Magical Rod. Pick it up.


;
; Check if this is the battle suit.
;
[c76f]@_checkBattleSuit:; [$c76f]
[c76f]CMP #$58; 0x58 == Battle Suit
[c771]BNE @_checkBattleHelmet
[c773]JMP Player_PickUpBattleSuit; This is the Battle Suit. Pick it up.


;
; Check if this is the battle helmet.
;
[c776]@_checkBattleHelmet:; [$c776]
[c776]CMP #$59; 0x59 == Battle Helmet
[c778]BEQ Player_PickUpBattleHelmet; This is the Battle Helmet. Pick it up.


;
; Check if this is the Dragon Slayer.
;
[c77a]CMP #$5a; 0x5A == Dragon Slayer
[c77c]BEQ Player_PickUpDragonSlayer; This is the Dragon Slayer. Pick it up.


;
; Check if this is the Mattock.
;
[c77e]CMP #$5b; 0x5B == Mattock
[c780]BEQ Player_PickUpMattockWithQuest; This is the Mattock. Pick it up.


;
; Check if this is the Wing Boots.
;
[c782]CMP #$55; 0x55 == Wing Boots
[c784]BNE @_checkWingBootsQuest8
[c786]JMP Player_PickUpWingBoots; This is the Wing Boots. Pick it up.


;
; Check if this is the Wing Boots (with Quest 0x08).
;
[c789]@_checkWingBootsQuest8:; [$c789]
[c789]CMP #$5c; 0x5C == Wing Boots for Quest 8
[c78b]BNE @_checkHourGlass
[c78d]JMP Player_PickUpWingBootsWithQuest; This is the Wing Boots for Quest 8. Pick it up.


;
; Check if this is the Hour Glass.
;
[c790]@_checkHourGlass:; [$c790]
[c790]CMP #$56; 0x56 == Hour Glass
[c792]BNE @_checkRedPotion
[c794]JMP Player_PickUpHourGlass; This is the Hour Glass.  Pick it up.


;
; Check if this is the Red Potion.
;
[c797]@_checkRedPotion:; [$c797]
[c797]CMP #$5d; 0x5D == Red Potion (1)
[c799]BNE @_checkPoison
[c79b]JMP Player_PickUpRedPotion; This is the Red Potion (1).  Pick it up.


;
; Check if this is the Poison.
;
[c79e]@_checkPoison:; [$c79e]
[c79e]CMP #$5e; 0x5E == Poison
[c7a0]BNE @_checkGlove1
[c7a2]JMP Player_PickUpPoison; This is the Poison.  Pick it up.

[c7a5]@_checkGlove1:; [$c7a5]
[c7a5]CMP #$5f; 0x5F == Glove
[c7a7]BEQ Player_PickUpGlove; This is the Glove.  Pick it up.


;
; Check if this is the Ointment.
;
[c7a9]CMP #$60; 0x60 == Ointment
[c7ab]BNE @_checkGlove2
[c7ad]JMP Player_PickUpOintment; This is the Ointment.  Pick it up.

[c7b0]@_checkGlove2:; [$c7b0]
[c7b0]SEC
[c7b1]SBC #$48
[c7b3]TAY
[c7b4]BEQ Player_PickUpGlove; This is the Glove. Pick it up.


;
; Check if this is the Black Onyx.
;
[c7b6]DEY; 0x49 == Black Onyx
[c7b7]BEQ Player_PickUpBlackOnyx; If 0x49, this is the Black Onyx.  Pick it up.


;
; Check if this is the Pendant.
;
[c7b9]DEY; 0x4A == Pendant
[c7ba]BEQ Player_PickUpPendant; If 0x4A, this is the pendant.  Pick it up.


;
; Check if this is the Red Potion (another variant).
;
[c7bc]DEY; 0x4B == Red Potion (2)
[c7bd]BEQ Player_PickUpRedPotion; If 0x4B, this is the Red Potion (2).  Pick it up.


;
; Check if this is the Poison.
;
[c7bf]DEY; 0x4C == Poison
[c7c0]BEQ Player_PickUpPoison; If 0x4C, this is the Poison.  Pick it up.


;
; Check if this is the Elixir.
;
[c7c2]DEY; 0x4D == Elixir
[c7c3]BNE @_checkOintment
[c7c5]JMP Player_PickUpElixir; This is the Elixir.  Pick it up.


;
; Check if this is the Ointment.
;
[c7c8]@_checkOintment:; [$c7c8]
[c7c8]DEY; 0x4E == Ointment
[c7c9]BNE @_exit
[c7cb]JMP Player_PickUpOintment; This is the Ointment.  Pick it up.

[c7ce]@_exit:; [$c7ce]
[c7ce]RTS