mirrors
/
AbePralle-FGB
mirror of https://github.com/AbePralle/FGB.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
AbePralle-FGB/Source/Gfx.asm

7715 lines
188 KiB
NASM
Raw Normal View History

[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
;***************************************************************************
[Refactor] Fully building - Font data now aligned properly in memory
2020-06-15 06:19:36 +01:00
;* Gfx.asm - graphics support routines
[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
;* 12.17.99 by Abe Pralle
;*
;***************************************************************************
[Refactor] Fully building - Font data now aligned properly in memory
2020-06-15 06:19:36 +01:00
INCLUDE "Source/Defs.inc"
INCLUDE "Source/Levels.inc"
INCLUDE "Source/Start.inc"
[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
MAX_PER_TURN EQU 32
FAST_SCROLL_THRESHOLD EQU 2
SECTION "Graphics",ROM0
;---------------------------------------------------------------------
; Routine: InitGfx
; Description: Sets up some basic graphics stuff - One time
;---------------------------------------------------------------------
InitGfx::
push bc
push de
push hl
;set up game state
ld a,$ff
ld [amLinkMaster],a
xor a
ld [lastLinkAction],a
ld [amChangingMap],a
ld [heroesPresent],a
ld a,(hero0_data & $ff)
ld [curHeroAddressL],a
ld a,(HERO_BA_FLAG | HERO_BS_FLAG | HERO_HAIKU_FLAG)
ld [heroesAvailable],a
xor a
ld [heroesUsed],a
ld [randomLoc],a
ldio [musicEnabled],a
ld [musicBank],a
ld [musicAddress],a
ld [musicAddress+1],a
ld [heroesLocked],a
ld [hero0_puffCount],a
ld [hero1_puffCount],a
ld [inLoadMethod],a
ld c,16
ld hl,inventory
.clearInventory
ld [hl+],a
dec c
jr nz,.clearInventory
;ld a,%10100001
;ld [inventory],a
;ld a,%00000011
;ld [inventory+1],a
xor a
ld [musicOverride1],a
ld [musicOverride4],a
ld a,64
ld [fadeRange],a
ld a,APPOMATTOXMAPINDEX
ld [appomattoxMapIndex],a
ld a,BANK(init_flightCodes)
call SetActiveROM
ld a,FLIGHTCODEBANK
ld bc,256
ld de,flightCode
ld hl,init_flightCodes
call MemCopy
xor a
ldio [dmaLoad],a
ld [displayType],a
ld a,1
ldio [curROMBank],a
call DisplayOff
call SetupSpriteHandler
;sound off
xor a
ldio [$ff26],a
;envelopes to zero
xor a
ldio [$ff12],a ;zero envelope all instruments
ldio [$ff17],a
ldio [$ff1c],a
ldio [$ff21],a
;turn on sound master control
ld a,$80
ldio [$ff26],a
ld a,$ff
ldio [$ff24],a ;full volume both channels
ldio [$ff25],a ;all sounds to both channels
;setup vector to hblank
ld a,$c3
ld [hblankVector],a ;opcode of jp
ld hl,OnHBlank
ld a,l
ld [hblankVector+1],a
ld a,h
ld [hblankVector+2],a
;enable VBlank interrupts
ld a,[$ffff]
or 1
ld [$ffff],a
;turn LCD on
ld a,%11000011
ld [$ff40], a ;lcdc control
;clear all level states to zero
ld a,LEVELSTATEBANK
ld [$ff70],a
ld c,0 ;loop 256 times
ld hl,levelState
xor a
.clearStateLoop
ld [hl+],a
dec c
jr nz,.clearStateLoop
ld a,1 ;fade from white the first time
ld [standardFadeColor],a
;enable interrupts
ei
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: VMemCopy
; Arguments: a - VRAM bank of destination
[Refactor] Fully building - Font data now aligned properly in memory
2020-06-15 06:19:36 +01:00
; c - number of 16-byte blocks (tiles) to copy
[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
; de - dest
; hl - source
; Alters: af
; [$ff4f] VRAM bank
; Description: Copies bytes from source to destination in VRAM.
; If screen is active it utilizes DMA loading, otherwise
; a normal copy is performed. DMA copies exceeding
; 2048 bytes may produce weird results.
;---------------------------------------------------------------------
VMemCopy::
push bc
push de
push hl
push af
;test if screen is on
ldio a,[$ff40]
and %10000000
jr nz,.screenIsOn
.screenIsOff
pop af
ldio [$ff4f],a ;switch VRAM bank
.setLoop
ld b,16
.bytesLoop
ld a,[hl+]
ld [de],a
inc de
dec b
jr nz,.bytesLoop
dec c
jr nz,.setLoop
jr .done
.screenIsOn ;copy using DMA
pop af
call InitDMALoad
call WaitDMALoad
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: MemSet
; Arguments: a - RAM bank of destination
; bc - length in bytes
; d - byte to set to
; hl - dest
; Alters: af
; [$ff70] RAM bank
; Description: Sets each byte in the range to be the specified value.
;---------------------------------------------------------------------
MemSet::
push bc
push de
push hl
ldio [$ff70],a
.loop ld a,d
ld [hl+],a
dec bc
xor a
cp b
jr nz,.loop
cp c
jr nz,.loop
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: MemCopy
; Arguments: a - RAM bank
; bc - non-zero length in bytes
; de - destination starting address
; hl - source start address
; Alters: af
; [$ff70] RAM bank
; Description: Copies each of "bc" # of bytes from source to dest.
; Alters the RAM bank to specified but does not revert
; to original during or after copying.
;---------------------------------------------------------------------
MemCopy::
push bc
push de
push hl
ldio [$ff70],a ;set RAM
.copy ld a,[hl+]
ld [de],a
inc de
xor a
dec bc
cp b
jr nz,.copy
cp c
jr nz,.copy
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: InitDMALoad
; Arguments: a - VRAM bank of destination
; c - length in multiples of 16 bytes
; de - dest
; hl - source
; Alters: af
; Description: Preps appropriate variables for DMA transfer to take
; place on VBlank. Note may be called multiple times
; (er, twice) to set up values for bank 0 and bank 1
; transfer. Note that transfers for bank 0 and bank 1
; combined should not exceed 2048 bytes (and perhaps
; a bit less)
;---------------------------------------------------------------------
InitDMALoad::
or a
jr nz,.prepBank1
.prepBank0
ld a,l
ld [dmaLoadSrc0],a
ld a,h
ld [dmaLoadSrc0+1],a
ld a,e
ld [dmaLoadDest0],a
ld a,d
ld [dmaLoadDest0+1],a
ld a,c
dec a
ld [dmaLoadLen0],a
ldio a,[dmaLoad]
or 1
ldio [dmaLoad],a
ret
.prepBank1
ld a,l
ld [dmaLoadSrc1],a
ld a,h
ld [dmaLoadSrc1+1],a
ld a,e
ld [dmaLoadDest1],a
ld a,d
ld [dmaLoadDest1+1],a
ld a,c
dec a
ld [dmaLoadLen1],a
ldio a,[dmaLoad]
or 2
ldio [dmaLoad],a
ret
;---------------------------------------------------------------------
; Routine: WaitDMALoad
; Alters: af
;---------------------------------------------------------------------
WaitDMALoad::
push bc
push de
push hl
.wait
ldio a,[dmaLoad]
and %11
jr nz,.wait
call GetInput
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: DMALoad
; Arguments: a - VRAM bank of destination
; c - byte length / 16
; hl - source
; de - dest
; Alters: af
; Description: Combines InitDMALoad and WaitDMALoad.
;---------------------------------------------------------------------
DMALoad::
call InitDMALoad
call WaitDMALoad
ret
;---------------------------------------------------------------------
; Routine: DisplayOff
; Arguments:
; Alters: af
; Description: Waits for VBlank then turns of the display
;---------------------------------------------------------------------
DisplayOff::
;skip if the display is off already
ld a,[$ff40]
and %10000000
ret z
;turn display off
ld a,[$ffff] ;get interrupts enabled
push af ;save original value
and %11111110 ;turn off vblank interrupt
ld [$ffff],a ;"interrupt THIS!"
.wait ld a,[$ff44] ;get line being drawn
cp 144 ;wait until line is >= 144
jr c,.wait
ld a,[$ff40] ;LCDC register
and %01111111 ;turn off screen
ld [$ff40],a
pop af ;retrieve original interrupt settings
ld [$ffff],a
.waitVRAM
ld a,[$ff41] ;STAT register
and %00000010 ;bit 1 needs to be zero to access VRAM
jr nz,.waitVRAM
ret
;---------------------------------------------------------------------
; Subroutine: LoadNextLevel
; Arguments:
; Alters: af
; Description: Does all the prep work of setting up the next level
; based on arguments stored in memory
;---------------------------------------------------------------------
LoadNextLevel::
push bc
push de
push hl
.reload
ld a,1
ld [amChangingMap],a
;xor a
;ld [timeToChangeLevel],a
;save old level's level state
ld a,LEVELSTATEBANK
ld [$ff70],a
ld a,[curLevelStateIndex]
ld l,a
ld h,((levelState>>8) & $ff)
ldio a,[mapState]
or a
jr nz,.stateNotZero
ld a,1
.stateNotZero
ld [hl],a
;clear joystick input
xor a
ld [curJoy0],a
ld [curJoy1],a
ldio [jiggleDuration],a
ld [jiggleType],a ;normal jiggle
call PrepLevel
ld a,[timeToChangeLevel]
or a
jr nz,.reload
;set interrupt controller flag so the interrupt will happen
ld a,[$ffff] ;interrupt enable control register
or %00000011 ;enable vblank and hblank interrupts
ld [$ffff],a ;store that back in the IEC
call DrawMapToBackBuffer
;ld b,METHOD_CHECK
;call IterateAllLists
;initialize some values
xor a
ldio [backBufferReady],a
xor a
ld [amChangingMap],a
ei ;enable interrupts
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: PrepLevel
; Description: Sets up some basic graphics stuff
;---------------------------------------------------------------------
PrepLevel::
push bc
push de
push hl
;reset some stuff
xor a
ld [levelCheckSkip],a
ld [levelCheckSkip+1],a
ld [levelCheckSkip+2],a
ld [levelCheckSkip+3],a
ld a,MAX_PER_TURN
ld [iterateNumObjects],a
ld hl,timeToChangeLevel
ld a,[hl]
ld [hl],0
cp 2 ;2=skip init & load in next
jp z,.loadMap
;restore default vector to hblank
ld hl,OnHBlank
call InstallHBlankHandler
xor a
ldh [$ff43], a ;set screen offsets to 0
ldh [$ff42], a
xor a
ldh [$ff4a], a ;set window offsets to 7,0
ld a,7
ldh [$ff4b], a
xor a
ld [specialFX],a
ld [paletteBufferReady],a
ld [mapColor],a
ld [mapColor+1],a
ld [bgAttributes],a
ld [bgTileMap],a
ld [checkInputInMainLoop],a
ld [dialogJoyIndex],a
ld [heroJoyIndex],a
ld [hero0_index],a
ld [hero1_index],a
ld [heroesIdle],a
ld [allIdle],a
ld [mapDialogClassIndex],a
ld [dialogSettings],a ;no border, no press B
ld [amShowingDialog],a
ld [objTimerBase],a
ld [objTimer60ths],a
ld [heroTimerBase],a
ld [heroTimerBase],a
ld [lineZeroHorizontalOffset],a
ld [samplePlaying],a
ld [guardAlarm],a
ld [dialogNPC_speakerIndex],a
ld [dialogNPC_heroIndex],a
ld [dialogBalloonClassIndex],a
ld [envEffectType],a
;clear the horizontal offsets
ld bc,144
ld d,0
ld hl,horizontalOffset
ld a,TILEINDEXBANK
call MemSet
ld a,1
ld [canJoinMap],a
ld de,0
call SetDialogSkip
call SetDialogForward
;---------------------------
xor a
;turn all sounds off
ldio [$ff12],a ;sound 1 envelope
ldio [$ff17],a ;sound 2 envelope
ldio [$ff1a],a ;sound 3 output
ldio [$ff21],a ;sound 4 envelope
ld a,$ff
ld [$ff24],a ;full volume both channels
;---------------------------
ld a,$ff
ld [dialogSpeakerIndex],a
;ld a,$21 ;fast=2, slow=1
;ld a,$22 ;fast=2, slow=2
ld a,$42
ldio [scrollSpeed],a
;set up each entry of bgTileMap to be its own index for a
;speed trick in the map redraw
ld c,0
ld hl,bgTileMap
xor a
.initBGTileMap
ld [hl+],a
inc a
dec c
jr nz,.initBGTileMap
ld a,%00100111 ;background palette colors
ld [$ff47],a
ld a,1
ld [scrollSprites],a
call LoadGraphics
;go back to VRAM bank zero
xor a ;Switch to tile map
ld [$ff00+$4f],a ;(VRAM bank 0)
call SetupGamePalettes
;load in inventory items tiles 246-254
ld a,BANK(BGTiles1024)
call SetActiveROM
ld a,1
;xor a
ld c,9 ;#characters
ld de,$8f60
ld hl,BGTiles1024+$3f70
call VMemCopy
call LoadFont
ld a,1
ld c,1 ;1 character
ld de,$8ff0
ld hl,blankTileData
call VMemCopy
;set up hblank interrupt
ld a,143
ld [$ff45],a ;set lyc
xor a
ld [hblankFlag],a ;don't show dialog window
ld a,[$ff0f] ;clear LCDC interrupt flag
and %11111101
ld [$ff0f],a
ld a,119
ldio [hblankWinOn],a
ld a,143
ldio [hblankWinOff],a
ld a,%00001100 ;setup stat for lyc = ly
ld [$ff41],a
ld a,[$ffff] ;enable hblank interrupt
or %00000010
ld [$ffff],a
ld a,$98
ld [backBufferDestHighByte],a
call ResetSprites
.loadMap
; load in a map
ld a,BANK(ResetList)
call SetActiveROM
call ResetList
call ClearFGBGFlags
ld hl,curLevelIndex
ld a,[hl+]
ld h,[hl]
ld l,a
call LoadMap
.done
pop hl
pop de
pop bc
ret
LoadFont::
;load in font into $8c80 (tiles 200-253)
ld a,BANK(fontData)
call SetActiveROM
xor a
ld c,62 ;# characters
ld de,$8c00
ld hl,fontData
jp VMemCopy
;---------------------------------------------------------------------
; Routine: SetupSpriteHandler
; Description: Copies the routine required for sprite DMA to high
; RAM and initializes the sprites to off
;---------------------------------------------------------------------
SetupSpriteHandler::
ld hl,oamHandlerStart ;src addr
ld de,SpriteDMAHandler ;dest addr
ld c,(oamHandlerFinish - oamHandlerStart) ;# of bytes
.loop ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.loop
call ResetSprites
ret
oamHandlerStart:
ld a,((spriteOAMBuffer>>8) & $ff) ;addr of start (in $100's)
ld [$ff00+$46],a ;start sprite dma
ld a,$28 ;start a delay loop
.wait dec a
jr nz,.wait
ret
oamHandlerFinish:
;---------------------------------------------------------------------
; Routine: SetupCommonColor
; Arguments: b - Color Spec for entry to set up
; de - color for entry
; Description: Sets all 8 palettes (bg AND sprite) to have the same
; colors for the specified entry.
; Note: The format specification should have bit 7 set so it
; auto-selects the next palette
;---------------------------------------------------------------------
SetupCommonColor::
push af
push bc
push hl
ld a,FADEBANK
ld [$ff70],a
ld a,b
ld h,((gamePalette>>8) & $ff)
and %00000110 ;color # * 2
add (gamePalette & $ff)
ld l,a
ld a,b
ld c,16
.loop
ld a,e ;Get low byte of color
ld [hl+],a ;store it in game palette
ld a,d ;Get high byte of color
ld [hl+],a ;store in game palette
ld a,l ;skip next 3 colors in game palette
add 6
ld l,a
dec c
jr nz,.loop
pop hl
pop bc
pop af
ret
;---------------------------------------------------------------------
; Routine: SetupGamePalettes
; Description: Sets up [gamePalette] the in-game colors but sets
; the actual hardware to be all standard
;---------------------------------------------------------------------
SetupGamePalettes:
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
ld a,%10000000 ;color specs
ld [$ff68],a
ld [$ff6a],a
ld bc,$0000 ;standard fade color
ld hl,standardFadeColor
ld a,[hl]
ld [hl],0
or a
jr z,.fadeColorSet
ld bc,$7fff ;color 1 = white
.fadeColorSet
ld hl,.stdPaletteData
ld de,gamePalette
ld a,32 ;set up 64 bytes (32 colors)
.loop push af
ld a,[hl+]
ld [de],a ;copy of palette
inc de
ld a,[hl+]
ld [de],a
inc de
ld a,c
ld [$ff69],a ;bg palette
ld [$ff6b],a ;fg palette
ld a,b
ld [$ff69],a ;bg palette
ld [$ff6b],a ;fg palette
pop af
dec a
jr nz,.loop
;repeat for FG colors
ld hl,.stdPaletteData
ld c,32 ;set up 64 bytes (32 colors)
.loopFG ld a,[hl+]
ld [de],a ;copy of palette
inc de
ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.loopFG
pop hl
pop de
pop bc
ret
.stdPaletteData
DW $0000, $2108, $4210, $7fff ;Palette 0 (Grey)
DW $0000, $000A, $001f, $7fff ;Palette 1 (Red)
DW $0000, $5000, $7e00, $7fff ;Palette 2 (Blue)
DW $0000, $0140, $03e0, $7fff ;Palette 3 (Green)
DW $0000, $4008, $5192, $7fff ;Palette 4 (Purple)
DW $0000, $01cd, $03fe, $7fff ;Palette 5 (Yellow)
DW $0000, $00d1, $09ff, $7fff ;Palette 6 (Brown)
DW $0000, $4412, $799c, $7fff ;Palette 7 (Fuscia)
;---------------------------------------------------------------------
; Routines: IndexToPointerDE
; IndexToPointerHL
; Arguments: a - index 1-255 of object
; Returns: de/hl - pointer $d010-$dff0 to object
;---------------------------------------------------------------------
IndexToPointerDE::
swap a
jr z,.null
ld e,a
and %00001111
add $d0
ld d,a
ld a,e
and %11110000
ld e,a
ret
.null
ld de,0
ret
IndexToPointerHL::
swap a
jr z,.null
ld l,a
and %00001111
add $d0
ld h,a
ld a,l
and %11110000
ld l,a
ret
.null
ld hl,0
ret
SECTION "TileCopyRoutines",ROM0
;---------------------------------------------------------------------
; Routines: AddHL16
; AddDE16
; Alters: af, (hl or de)
;---------------------------------------------------------------------
AddHL16::
ld a,l
add 16
ld l,a
ret nc
inc h
ret
AddDE16::
ld a,e
add 16
ld e,a
ret nc
inc d
ret
;---------------------------------------------------------------------
; Routines: TileIndexLToAddressHL
; TileIndexEToAddressDE
; Arguments: l/e - tile index (0-255)
; Returns: hl/de - address of tile index ($9000 +/- index*16)
;---------------------------------------------------------------------
TileIndexLToAddressHL:
push af
;shift "l" 4 left and into a
xor a ;clear a to zero (new high byte)
sla l ;shift into carry
rla ;carry into a
sla l ;repeat total of 4 times
rla ;carry into a
sla l
rla
sla l
rla
or $90 ;add base addr of $9000
cp $98 ;>=$9800?
jr c,.allSet
sub $10 ;signed #'s means >$9800 should be $8800+
.allSet
ld h,a ;a into h; hl is now $9000+/-offset
pop af
ret
TileIndexEToAddressDE:
push af
;shift "e" 4 left and into a
xor a ;clear a to zero (new high byte)
sla e ;shift into carry
rla ;carry into a
sla e ;repeat total of 4 times
rla ;carry into a
sla e
rla
sla e
rla
or $90 ;add base addr of $9000
cp $98
jr c,.allSet
sub $10
.allSet
ld d,a ;a into d; de is now $9000+/-offset
pop af
ret
;---------------------------------------------------------------------
; Routine: TileCopyRotateCCW
; Arguments: l - Source tile index (0-255)
; e - Dest tile index
; Description: Copies pixels from source tile to dest tile, rotating
; 90 degrees counter clock-wise in the process
; Note: Assumes VRAM to be already accessible
;---------------------------------------------------------------------
TileCopyRotateCCW:
push af
push bc
push de
push hl
call TileCopyIndicesToAddresses
;Set up outer loop
ld a,8 ;outer loop 8 times
;Beginning of outer loop / Set up inner loop
.outer1 push de ;save source start
push af ;save outer loop counter
ld a,8 ;inner loop 8 times
.inner1 push af ;save loop counter on stack
ld a,[de] ;get next even byte
rrca
rl b
ld [de],a
inc de
ld a,[de] ;get next odd byte
rrca
rl c
ld [de],a
inc de
pop af ;retrieve loop counter
dec a
jr nz,.inner1
ld a,b ;save next two bytes of result
ld [hl+],a
ld a,c
ld [hl+],a
pop af ;retrieve outer loop counter
pop de ;reset srcptr to start of tile
dec a
jr nz,.outer1
pop hl
pop de
pop bc
pop af
ret
;---------------------------------------------------------------------
; Routines: TileCopy
; TileCopyShiftLeft
; TileCopyShiftRight
; TileCopyShiftLeftOverlay
; TileCopyShiftRightOverlay
; TileCopyShiftUp
; TileCopyShiftDown
; Arguments: e - Source tile index (0-15)
; l - Dest tile index (0-15)
; Description: Copies tiles while shifting 4 pixels in the specified
; direction (except for plain TileCopy). Tile patterns
; should be stored in $c000-$c0ff. "Overlay" routines
; OR the source with the destination.
;---------------------------------------------------------------------
TileCopy:
push af
push bc
push de
push hl
call TileCopyIndicesToAddresses
ld c,16 ;loop 16 times
.loop ld a,[de] ;get a byte
inc de
ld [hl+],a ;put it in dest
dec c
jr nz,.loop
pop hl
pop de
pop bc
pop af
ret
TileCopyShiftLeft:
push af
push bc
push de
push hl
call TileCopyIndicesToAddresses
ld c,16 ;loop 16 times
.loop ld a,[de] ;get a byte
inc de
swap a ;flip nibbles
and $f0 ;clear out lower four bits
ld [hl+],a ;put it in dest
dec c
jr nz,.loop
pop hl
pop de
pop bc
pop af
ret
TileCopyShiftRight:
push af
push bc
push de
push hl
call TileCopyIndicesToAddresses
ld c,16 ;loop 16 times
.loop ld a,[de] ;get a byte
inc de
swap a ;flip nibbles
and $0f ;clear out upper four bits
ld [hl+],a ;put it in dest
dec c
jr nz,.loop
pop hl
pop de
pop bc
pop af
ret
TileCopyShiftLeftOverlay:
push af
push bc
push de
push hl
call TileCopyIndicesToAddresses
ld c,16 ;loop 16 times
.loop ld a,[de] ;get a byte
inc de
swap a ;flip nibbles
and $f0 ;clear out lower four bits
or [hl] ;combine with dest
ld [hl+],a
dec c
jr nz,.loop
pop hl
pop de
pop bc
pop af
ret
TileCopyShiftRightOverlay:
push af
push bc
push de
push hl
;Get tile addresses
call TileCopyIndicesToAddresses
ld c,16 ;loop 16 times
.loop ld a,[de] ;get a byte
inc de
swap a ;flip nibbles
and $0f ;clear out upper four bits
or [hl] ;combine with dest
ld [hl+],a
dec c
jr nz,.loop
pop hl
pop de
pop bc
pop af
ret
TileCopyIndicesToAddresses:
push bc
ld c,4
ld h,0
ld d,0
.loop
sla l
rl h
sla e
rl d
dec c
jr nz,.loop
pop bc
ld a,((backBuffer>>8) & $ff)
add a,h
ld h,a
ld a,((backBuffer>>8) & $ff)
add a,d
ld d,a
ret
TileCopyShiftUp:
push bc
push de
push hl
call TileCopyIndicesToAddresses
ld a,e ;source += 8
add 8
ld e,a
ld c,8 ;loop 8 times
.loop ld a,[de] ;get a byte
inc de
ld [hl+],a ;put it in dest
dec c
jr nz,.loop
;clear 4 rows (8 bytes)
ld c,8
xor a
.clear
ld [hl+],a
dec c
jr nz,.clear
pop hl
pop de
pop bc
ret
TileCopyShiftDown:
push bc
push de
push hl
call TileCopyIndicesToAddresses
;clear 4 rows (8 bytes)
ld c,8
xor a
.clear
ld [hl+],a
dec c
jr nz,.clear
ld c,8 ;loop 8 times
.loop ld a,[de] ;get a byte
inc de
ld [hl+],a ;put it in dest
dec c
jr nz,.loop
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: DuplicateTilesToSpriteMem
; Arguments: a - number of tiles to duplicate (1+)
; c - index of first tile in tile mem
; Alters: af
; Description: Copies {a} number of tiles (a*16 bytes) from $c000
; (backBuffer) to $8000 + c*16.
; Note: Uses current VRAM bank
;---------------------------------------------------------------------
DuplicateTilesToSpriteMem:
push bc
push de
push hl
ld b,a ;tiles remaining
;de = $8000 + c*16
ld a,c
swap a
and %00001111
add $80
ld d,a
ld a,c
swap a
and %11110000
ld e,a
;hl = $c000
ld hl,backBuffer
.next_tile
;tiles 128-255 are in VRAM shared between sprites and tiles
;and do not need to be copied.
ld a,c
cp 128
jr nc,.after_copy
push bc
ld c,1 ;1*16 bytes
ld a,1 ;VRAM bank 1
call VMemCopy
pop bc
.after_copy
;de+=16, hl+=16
call AddHL16
call AddDE16
;tileNum++, tilesRemaining--
inc c
dec b
jr nz,.next_tile
pop hl
pop de
pop bc
ret
IF 0
push bc
push de
push hl
ld b,a
ld l,c
call TileIndexLToAddressHL
.next_tile
ld a,h
cp $90
jr c,.no_copy_necessary
;dest addr = source addr - $1000
ld a,h
sub $10
ld d,a
ld e,l
;source addr
ld hl,$c000
ld c,16
.copy ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.copy
jr .after_copy
.no_copy_necessary
ld de,16
add hl,de
.after_copy
dec b
jr nz,.next_tile
pop hl
pop de
pop bc
ret
ENDC
;---------------------------------------------------------------------
; Routine: GenerateFacings
; Arguments: a - index (0-255) of the first of two consecutive
; tiles (frame1 and frame2) which should be facing
; east. Tiles should be located at $c000
; (backBuffer).
; [curObjWidthHeight] - copy of FG attribute flags
; Description: Creates the following tiles at $9000-$97ff (indices
; 0-127) and $8800-$8fff (128-255):
; a - North facing, frame 1
; a+1 - Top half of North facing, frame 2
; a+2 - Bottom half of North facing, frame 2
; a+3...a+5 - East facing (frame1, left frame2, right
; frame2)
;
; Duplicates any tiles in area $9000-$9800 into
; $8000-$8800 for tile<->sprite purposes
;---------------------------------------------------------------------
GenerateFacings::
push af
push bc
push de
push hl
ld c,a ;starting index
ldio a,[curObjWidthHeight] ;retrieve flags
bit BIT_2X2,a
jr z,.generate1x1
jp .generate2x2
.generate1x1
ld a,[curObjWidthHeight] ;attribute flags
bit BIT_NOROTATE,a
jr nz,.createNonRotatedSprites
.createRotatedSprites
;create non-split frames for sprites
ld e,0 ;source index
ld l,2 ;dest index
call TileCopyRotateCCW
inc e
inc l
call TileCopyRotateCCW
jr .copyTilesToSpriteMem
.createNonRotatedSprites
;create non-split frames for sprites
ld e,0 ;source index
ld l,2 ;dest index
call TileCopy
inc e
inc l
call TileCopy
.copyTilesToSpriteMem
ld a,4
call DuplicateTilesToSpriteMem
;East-facing frames
ld e,0 ;source index in e
ld l,3 ;dest index in l
call TileCopy
inc e ;source to next frame
inc l ;set dest index to next frame
call TileCopyShiftRight
inc l
call TileCopyShiftLeft
ld a,[curObjWidthHeight] ;attribute flags
bit BIT_NOROTATE,a
jr nz,.copyNorthNoRotate
;North facings
ld l,0 ;dest is +0 (North)
ld e,3 ;Set source ptr to +3 (East)
call TileCopyRotateCCW
inc e
inc l
inc l
call TileCopyRotateCCW
inc e
dec l
call TileCopyRotateCCW
jr .copyBufferToVMem
.copyNorthNoRotate
ld e,1
ld l,6
call TileCopy
ld e,6
ld l,1
call TileCopyShiftDown
inc l
call TileCopyShiftUp
.copyBufferToVMem
;Copy 6 tiles beginning at $c000+ to $9000+(c*16).
;Next location after $97f0 is $8800.
ld a,c
cp 122 ;122+6 < 128
jr c,.copySet ;to $9000+
cp 128
jr nc,.copySet ;to $8800+
.copyOneByOne ;split across different banks
ld e,c
call TileIndexEToAddressDE ;destination
ld hl,$c000 ;source
ld b,6 ;tiles to copy
ld c,1 ;copy 16 bytes at a time
.nextTile
ld a,1 ;VRAM Bank 1
call VMemCopy
call AddDE16
call AddHL16
ld a,d
cp $98
jr nz,.destPtrOkay
ld d,$88
.destPtrOkay
dec b
jr nz,.nextTile
jp .done
.copySet
ld e,a
call TileIndexEToAddressDE
ld hl,$c000
ld c,6 ;6*16
ld a,1
call VMemCopy
jp .done
.generate2x2
;East-facing 2x2
ld e,0 ;source index in e
ld l,10 ;dest index in l
call TileCopy
inc e
inc l
call TileCopy
inc e
inc l
call TileCopy
inc e
inc l
call TileCopy
inc e
inc l
call TileCopyShiftRight
inc l
call TileCopyShiftLeft
inc e
call TileCopyShiftRightOverlay
inc l
call TileCopyShiftLeft
inc e
inc l
call TileCopyShiftRight
inc l
call TileCopyShiftLeft
inc e
call TileCopyShiftRightOverlay
inc l
call TileCopyShiftLeft
ld e,10
ld l,2
call TileCopyRotateCCW
inc e
ld l,0
call TileCopyRotateCCW
inc e
ld l,3
call TileCopyRotateCCW
inc e
ld l,1
call TileCopyRotateCCW
inc e
ld l,8
call TileCopyRotateCCW
inc e
ld l,6
call TileCopyRotateCCW
inc e
ld l,4
call TileCopyRotateCCW
inc e
ld l,9
call TileCopyRotateCCW
inc e
ld l,7
call TileCopyRotateCCW
inc e
ld l,5
call TileCopyRotateCCW
;Copy 20 tiles beginning at $c000+ to $9000+(c*16).
;Next location after $97f0 is $8800.
ld a,c
cp 108 ;108+20 < 128
jr c,.copySet20 ;to $9000+
cp 128
jr nc,.copySet20 ;to $8800+
.copyOneByOne20 ;split across different banks
ld e,c
call TileIndexEToAddressDE ;destination
ld hl,$c000 ;source
ld b,20 ;tiles to copy
ld c,1 ;copy 16 bytes at a time
.nextTile20
ld a,1 ;VRAM Bank 1
call VMemCopy
call AddDE16
call AddHL16
ld a,d
cp $98
jr nz,.destPtrOkay20
ld d,$88
.destPtrOkay20
dec b
jr nz,.nextTile20
jr .done
.copySet20
ld e,a
call TileIndexEToAddressDE
ld hl,$c000
ld c,20 ;20*16
ld a,1
call VMemCopy
jp .done
.done
pop hl
pop de
pop bc
pop af
ret
[Refactor] Updated for latest RGBDS assembler
2022-01-08 03:29:25 +00:00
SECTION "Graphics2",ROM0
[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
;---------------------------------------------------------------------
; Routine: LoadGraphics
; Arguments:
;---------------------------------------------------------------------
LoadGraphics:
ld a,BANK(BGTiles)
call SetActiveROM
;switch to vram bank 1
ld a,1
;ld [$ff4f],a
call .loadBlank
;switch to vram bank 0
xor a
;ld [$ff4f],a
call .loadBlank
;load 86 explosion sprites
ld a,MAP0ROM
call SetActiveROM
xor a
ld c,86 ;#sprites
ld de,$8000
ld hl,explosionSprites
call VMemCopy
IF 0
;load 80 explosion sprites
ld a,MAP0ROM
call SetActiveROM
ld hl,explosionSprites
ld de,$8000
ld b,80 ;# sprites
.outer ld c,16 ;16 bytes each
.inner ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.inner
dec b
jr nz,.outer
ENDC
ret
.loadBlank
;load a blank tile to tile 0 of VRAM bank "a"
;xor a
ld c,1 ;1 tile
ld de,$9000
ld hl,BGTiles ;1st tile is blank
call VMemCopy
ret
IF 0
ld hl,blankTile ;address to get graphics from
ld de, $9000 ;destination address (Tile VRAM)
ld c, 1 * 16 ;copy 1 tile of 16 bytes
.loop ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.loop
ret
ENDC
;---------------------------------------------------------------------
; Routine: LoadSprites
; Arguments: a - ROM bank containing sprites
; c - number of sprites to load
; hl - starting addr of sprites to load
; de - dest addr of sprites to load
; Alters: af
; Description: Loads specified number of sprites to VRAM bank 0
; specified location. Switches back to CLASSROM when
; done. Must be done on VBLANK or when display is off
;---------------------------------------------------------------------
LoadSprites::
push bc
push de
push hl
call SetActiveROM
xor a ;VRAM bank 0
ld [$ff4f],a
.outer ld b,16 ;copy 16 bytes
.inner ld a,[hl+]
ld [de],a
inc de
dec b
jr nz,.inner
dec c
jr nz,.outer
ld a,CLASSROM
call SetActiveROM
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: PrepareForInitialMapDraw
; Description: Sets relevant variables so the map can be drawn
;---------------------------------------------------------------------
PrepareForInitialMapDraw::
call AdjustCameraToHero
call RestrictCameraToBounds
ld hl,mapLeft
ld a,[desiredMapLeft]
ld [hl+],a ;mapLeft
add 20
ld [hl+],a ;mapRight
inc a
ld [hl+],a ;mapRightPlusOne
ld a,[desiredMapTop]
ld [hl+],a ;mapTop
add 18
ld [hl+],a ;mapBottom
inc a
ld [hl+],a ;mapBottomPlusOne
xor a
ld [curPixelOffset_x],a
ld [curPixelOffset_y],a
ld [desiredPixelOffset_x],a
ld [desiredPixelOffset_y],a
ld [scrollAccelState_x],a
ld [scrollAccelState_y],a
;set up a table for speedy AI
;east offset is +1
ld a,1
ld [mapOffsetEast],a ;low byte
xor a
ld [mapOffsetEast+1],a ;high byte
;west offset is -1
ld a,$ff
ld [mapOffsetWest],a
ld [mapOffsetWest+1],a
;south offset is +pitch
xor a
ld [mapOffsetSouth+1],a
ld a,[mapPitch]
ld [mapOffsetSouth],a
;north offset is -pitch
cpl
inc a
ld [mapOffsetNorth],a
ld a,$ff
ld [mapOffsetNorth+1],a
ret
;---------------------------------------------------------------------
; Routine: AdjustCameraToHero
; Arguments: None.
; Description: Centers camera on hero, then adjusts so that maximum
; amount of space on in all 4 directions is visible
;
;---------------------------------------------------------------------
AdjustCameraToHero::
ld a,[displayType]
or a
jr z,.mapType
;cinema type
xor a
ld [camera_i],a
ld [camera_j],a
ret
.mapType
push bc
push de
push hl
ld a,OBJBANK ;Get Location of hero
ld [$ff70],a
;hl = &heroX_object
LDHL_CURHERODATA HERODATA_OBJ
ld a,[hl+]
ld e,a
ld a,[hl]
ld d,a
ld a,[de]
ld l,a
ld [tempL],a
inc de
ld a,[de]
ld h,a
ld [tempH],a
call ConvertLocHLToXY ;convert to x,y indices
ld a,h
ld [camera_i],a
ld a,l
ld [camera_j],a
ld a,MAPBANK
ld [$ff70],a
ldio a,[firstMonster]
ld c,a ;c class of first monster
;find nearest wall to the north of location
ld a,[tempL] ;hl will track location
ld l,a
ld a,[tempH]
ld h,a
ld b,0 ;b will track north offset
ld d,$ff ;de = -pitch
ld a,[mapPitch]
cpl
add 1
ld e,a
push hl
.nloop add hl,de
inc b
ld a,[hl]
or a
jr z,.nloop ;nothing at all here
cp c ;found something, check if monster
jr nc,.nloop ;don't count monsters
call GetBGAttributes
and (BG_FLAG_WALKOVER|BG_FLAG_SHOOTOVER)
ld a,MAPBANK
ldio [$ff70],a
jr nz,.nloop
;b is tile distance of closest wall to the north
pop hl ;retrieve original location
push bc ;save north count b
ld b,0 ;b counts clear tiles to south
ld d,0 ;de is offset to go south
ld a,[mapPitch]
ld e,a
push hl ;push original location again
.sloop add hl,de
inc b
ld a,[hl]
or a
jr z,.sloop
cp c
jr nc,.sloop
call GetBGAttributes
and (BG_FLAG_WALKOVER|BG_FLAG_SHOOTOVER)
ld a,MAPBANK
ldio [$ff70],a
jr nz,.sloop
;now b is distance of closest wall to south
pop hl ;retrieve original location
ld a,b
pop bc ;retrieve north distance
ld c,a ;b=north, c=south dist
;---------------Scroll Camera South---------------------------
;while(s_dist >= 10 && n_dist<8){
; move camera to south;
; south dist--;
; north dist++;
;}
.cam_south_loop
ld a,c ;s_dist >= 10?
cp 10
jr c,.cam_south_loopDone
ld a,b
cp 7
jr nc,.cam_south_loopDone ;n_dist < 8?
call .moveCameraSouth
jr .cam_south_loop
.cam_south_loopDone
;---------------Scroll Camera North---------------------------
;while(n_dist >= 9 && s_dist<9){
; move camera to north;
; south dist++;
; north dist--;
;}
.cam_north_loop
ld a,b ;n_dist >= 9?
cp 9
jr c,.cam_north_loopDone
ld a,c
cp 9
jr nc,.cam_north_loopDone ;s_dist < 9?
call .moveCameraNorth
jr .cam_north_loop
.cam_north_loopDone
ld a,c ;save distances for later use
ld [distToWall_S],a
ld a,b
ld [distToWall_N],a
;----------------------------
; Handle east/west scrolling
;----------------------------
ld b,0 ;b counts clear tiles to west
ld d,h ;save hl in de
ld e,l
ldio a,[firstMonster]
ld c,a
dec hl
.wloop inc b
ld a,[hl-] ;get location
or a
jr z,.wloop ;loop if empty
cp c
jr nc,.wloop ;loop if monster
call GetBGAttributes
and (BG_FLAG_WALKOVER|BG_FLAG_SHOOTOVER)
ld a,MAPBANK
ldio [$ff70],a
jr nz,.wloop
;now b is distance of closest wall to west
ld h,d ;set hl back to original location
ld l,e
ld d,b ;store west distance in d
ld b,0
inc hl
.eloop inc b
ld a,[hl+] ;get location
or a
jr z,.eloop ;loop if empty
cp c
jr nc,.eloop ;loop if monster
call GetBGAttributes
and (BG_FLAG_WALKOVER|BG_FLAG_SHOOTOVER)
ld a,MAPBANK
ldio [$ff70],a
jr nz,.eloop
;now b is distance of closest wall to east
ld c,b ;b=west, c=east dist
ld b,d
;---------------Scroll Camera East----------------------------
;while(e_dist >= 11 && w_dist<9){
; move camera to east;
; east dist--;
; west dist++;
;}
.cam_east_loop
ld a,c ;e_dist >= 11?
cp 11
jr c,.cam_east_loopDone
ld a,b
cp 9
jr nc,.cam_east_loopDone ;w_dist < 10?
ld a,[camera_i]
inc a
ld [camera_i],a
dec c
inc b
jr .cam_east_loop
.cam_east_loopDone
;---------------Scroll Camera West----------------------------
;while(w_dist >= 10 && e_dist<10){
; move camera to west;
; east dist++;
; west dist--;
;}
.cam_west_loop
ld a,b ;w_dist >= 10?
cp 10
jr c,.cam_west_loopDone
ld a,c
cp 9
jr nc,.cam_west_loopDone ;e_dist < 10?
ld a,[camera_i]
dec a
ld [camera_i],a
inc c
dec b
jr .cam_west_loop
.cam_west_loopDone
ld a,c ;save distances for later use
ld [distToWall_E],a
ld a,b
ld [distToWall_W],a
.done
pop hl
pop de
pop bc
ret
.moveCameraSouth
ld a,[camera_j]
inc a
ld [camera_j],a
dec c
inc b
ret
.moveCameraNorth
ld a,[camera_j]
dec a
ld [camera_j],a
inc c
dec b
ret
;---------------------------------------------------------------------
; Routine: GentleCameraAdjust
; Arguments: None.
; Description: Adjusts the camera to the hero but then goes with the
; old camera position if it doesn't make much difference
;---------------------------------------------------------------------
GentleCameraAdjust::
ld a,[displayType]
or a
ret nz ;done if cinema display type
push bc
push de
push hl
;save previous camera i,j
ld a,[camera_i]
ld b,a
ld a,[camera_j]
ld c,a
push bc
call AdjustCameraToHero
pop bc ;retrieve old camera coords
ld a,[camera_i]
cp b
jr z,.checkCamera_j ;new_i==old_i, don't bother
jr c,.new_i_lt_old_i
;new i > old i
sub b ;d = new_i - old_i
ld d,a
ld a,[distToWall_E] ;a = dist_E + offset
add d
cp 11
jr c,.useOldCamera_i ;only good if east dist < 11
jr .checkCamera_j
.new_i_lt_old_i
;new i < old i
sub b ;d = old_i - new_i
cpl
inc a
ld d,a
ld a,[distToWall_W]
add d
cp 9
jr c,.useOldCamera_i ;only good if west dist < 10
jr .checkCamera_j
.useOldCamera_i
;we can use the old camera pos and be less jerky
ld a,b
ld [camera_i],a
.checkCamera_j
ld a,[camera_j]
cp c
jr z,.done ;new_j==old_j, don't bother
jr c,.new_j_lt_old_j
;new j > old j
sub c ;d = new_j - old_j
ld d,a
ld a,[distToWall_S] ;a = dist_S + offset
add d
cp 10
jr c,.useOldCamera_j ;only good if south dist < 10
jr .done
.new_j_lt_old_j
;new j < old j
sub c ;d = old_j - new_j
cpl
inc a
ld d,a
ld a,[distToWall_N]
add d
cp 9
jr c,.useOldCamera_j ;only good if north dist < 9
jr .done
.useOldCamera_j
;we can use the old camera pos and be less jerky
ld a,c
ld [camera_j],a
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: RestrictCameraToBounds
; Arguments: None.
;---------------------------------------------------------------------
RestrictCameraToBounds::
ld a,[displayType]
or a
jr nz,.cinemaType
push hl
;set map left/right based on camera_i
ld a,[camera_i]
sub 9
jr z,.left_le_0
jr nc,.left_gt_0
.left_le_0
ld a,1 ;set to 1 if < 1
.left_gt_0
ld hl,mapMaxLeft
cp [hl]
jr z,.left_le_max
jr c,.left_le_max
ld a,[hl] ;left = maxLeft
.left_le_max
ld [desiredMapLeft],a
;now see about top/bottom boundaries using camera_j
ld a,[camera_j]
sub 8
jr z,.top_le_0
jr nc,.top_gt_0
.top_le_0
ld a,1 ;set to one if less than one
.top_gt_0
ld hl,mapMaxTop
cp [hl]
jr z,.top_le_max
jr c,.top_le_max
ld a,[hl] ;top = maxTop
.top_le_max
ld [desiredMapTop],a
pop hl
ret
.cinemaType
push hl
;set map left/right based on camera_i
ld a,[camera_i]
sub 9
jr z,.left_ge_0
jr nc,.left_ge_0
.left_lt_0
xor a ;set to 0 if < 0
.left_ge_0
ld hl,mapMaxLeft
cp [hl]
jr z,.left_le_max2
jr c,.left_le_max2
ld a,[hl] ;left = maxLeft
.left_le_max2
ld [desiredMapLeft],a
;now see about top/bottom boundaries using camera_j
ld a,[camera_j]
sub 8
jr z,.top_ge_0
jr nc,.top_ge_0
.top_lt_0
xor a ;set to zero if less than zero
.top_ge_0
ld hl,mapMaxTop
cp [hl]
jr z,.top_le_max2
jr c,.top_le_max2
ld a,[hl] ;top = maxTop
.top_le_max2
ld [desiredMapTop],a
pop hl
ret
;---------------------------------------------------------------------
; Routine: ScrollToCamera
; Description: Scrolls from old camera view to new camera position.
; Increments of 2 pixels if difference < 4 tiles,
; increments of 4 pixels if >= 4 tiles
; Update: Uses [scrollSpeed][7:4] for fast, [3:0] slow
; instead of 4 and 2.
;---------------------------------------------------------------------
ScrollToCamera::
push bc
push de
push hl
;calculate tiles different in x & store in d
ld a,[mapLeft]
ld b,a
ld a,[desiredMapLeft]
sub b
jr nc,.gotPositiveXDiff
cpl
inc a
.gotPositiveXDiff
ld d,a
;calculate tiles different in y & store in e
ld a,[mapTop]
ld b,a
ld a,[desiredMapTop]
sub b
jr nc,.gotPositiveYDiff
cpl
inc a
.gotPositiveYDiff
ld e,a
;setup d,e with x-pixel step-size and max value
push de
ld a,d
cp FAST_SCROLL_THRESHOLD
jr c,.setupXForSlow
ld a,[scrollAccelState_x]
or a
jr z,.setupXForSlow
;get fast scroll speed in 9
ldio a,[scrollSpeed]
swap a
and $0f
ld d,a
;ld a,8
;sub d
;ld e,a
;ld d,4
;ld e,4
;ld a,[desiredPixelOffset_x] ;make sure its a multiple of 4
;and %00000100
;ld [desiredPixelOffset_x],a
jr .checkLeft
.setupXForSlow
;get slow scroll speed in d
ldio a,[scrollSpeed]
and $0f
ld d,a
.checkLeft
;make sure current pixel offset is an even multiple of the speed
;offset &= ~(speed - 1)
;off mask off dec cpl
;1 - and %111 0001 0000 1111
;2 - and %110 0010 0001 1110
;4 - and %100 0100 0011 1100
;8 - and %000 1000 0111 1000
ld a,d
dec a
;first scroll sprites right by value to be masked off
ld e,a
ld hl,desiredPixelOffset_x
ld a,[hl]
and e
push de
ld d,a
call ScrollSpritesRight
pop de
ld a,e
cpl
and %00000111
ld e,a
ld a,[hl]
and e
ld [hl],a
ld a,8
sub d
ld e,a
;ld a,[desiredPixelOffset_x] ;make sure its a multiple of 4
;and %00000100
;ld [desiredPixelOffset_x],a
ld a,[mapLeft]
ld b,a
ld a,[desiredMapLeft]
cp b
jr z,.checkPixelOffset
jr c,.desired_lt_current
jr .desired_gt_current
.checkPixelOffset
ld a,[desiredPixelOffset_x]
or a
jr z,.x_offsetOkay
push af
ld a,[scrollSprites]
or a
jr z,.afterScrollRight1
call ScrollSpritesRight
.afterScrollRight1
pop af
jr .scrollPixelsLeft
.x_offsetOkay
;reset accelleration if no scroll
xor a
ld [scrollAccelState_x],a
jr .leftRightAdjustDone
.desired_gt_current
;desired is > current
ld a,[scrollSprites]
or a
jr z,.afterScrollSpritesLeft1
call ScrollSpritesLeft
.afterScrollSpritesLeft1
ld a,[desiredPixelOffset_x]
cp e
jr nc,.atMaxLeftPixelOffset
add d
ld [desiredPixelOffset_x],a
jr .leftRightAdjustDone
.atMaxLeftPixelOffset
ld hl,scrollAccelState_x
inc [hl]
xor a
ld [desiredPixelOffset_x],a
ld a,b
inc a
jr .recalcMapLeftRight
.desired_lt_current
ld a,[scrollSprites]
or a
jr z,.afterScrollSpritesRight2
call ScrollSpritesRight
.afterScrollSpritesRight2
ld a,[desiredPixelOffset_x]
or a
jr z,.atMinLeftPixelOffset
.scrollPixelsLeft
sub d
ld [desiredPixelOffset_x],a
or a
jr nz,.leftRightAdjustDone
ld hl,scrollAccelState_x
inc [hl]
jr .leftRightAdjustDone
.atMinLeftPixelOffset
ld a,e
ld [desiredPixelOffset_x],a
ld a,b
dec a
.recalcMapLeftRight
ld hl,mapLeft
ld [hl+],a ;mapLeft, mapRight, mapRight+1
add 20
ld [hl+],a
inc a
ld [hl+],a
.leftRightAdjustDone
;setup d,e with y-pixel step-size and max value
pop de
ld a,e
cp FAST_SCROLL_THRESHOLD
jr c,.setupYForSlow
or a
jr z,.setupYForSlow
ldio a,[scrollSpeed]
swap a
and $0f
ld d,a
ld a,8
sub d
ld e,a
;ld d,4
;ld e,4
;ld a,[desiredPixelOffset_y] ;make sure its a multiple of 4
;and %00000100
;ld [desiredPixelOffset_y],a
jr .checkTop
.setupYForSlow
ldio a,[scrollSpeed]
and $0f
ld d,a
ld a,8
sub d
ld e,a
;ld d,2
;ld e,6
.checkTop
;make sure current pixel offset is an even multiple of the speed
;offset &= ~(speed - 1)
;1 - and %111 0001 0000 1111
;2 - and %110 0010 0001 1110
;4 - and %100 0100 0011 1100
;8 - and %000 1000 0111 1000
ld a,d
dec a
;first scroll sprites down by value to be masked off to snap
;them to the new grid
ld e,a
ld hl,desiredPixelOffset_y
ld a,[hl]
and e
push de
ld d,a
call ScrollSpritesDown
pop de
ld a,e
cpl
and %00000111
ld e,a
ld a,[hl]
and e
ld [hl],a
ld a,8
sub d
ld e,a
ld a,[mapTop]
ld b,a
ld a,[desiredMapTop]
cp b
jr z,.checkPixelOffsetTB
jr c,.desired_tb_lt_current
jr .desired_tb_gt_current
.checkPixelOffsetTB
ld a,[desiredPixelOffset_y]
or a
jr z,.y_offsetOkay
push af
ld a,[scrollSprites]
or a
jr z,.afterScrollSpritesDown1
call ScrollSpritesDown
.afterScrollSpritesDown1
pop af
jr .scrollPixelsUp
.y_offsetOkay
;reset accelleration if no scroll
xor a
ld [scrollAccelState_y],a
jr .topBottomAdjustDone
.desired_tb_gt_current
;desired is > current
ld a,[scrollSprites]
or a
jr z,.afterScrollSpritesUp1
call ScrollSpritesUp
.afterScrollSpritesUp1
ld a,[desiredPixelOffset_y]
cp e
jr nc,.atMaxTopPixelOffset
add d
ld [desiredPixelOffset_y],a
jr .topBottomAdjustDone
.atMaxTopPixelOffset
ld hl,scrollAccelState_y
inc [hl]
xor a
ld [desiredPixelOffset_y],a
ld a,b
inc a
jr .recalcMapTopBottom
.desired_tb_lt_current
ld a,[scrollSprites]
or a
jr z,.afterScrollSpritesDown2
call ScrollSpritesDown
.afterScrollSpritesDown2
ld a,[desiredPixelOffset_y]
or a
jr z,.atMinTopPixelOffset
.scrollPixelsUp
sub d
ld [desiredPixelOffset_y],a
or a
jr nz,.topBottomAdjustDone
ld hl,scrollAccelState_y
inc [hl]
jr .topBottomAdjustDone
.atMinTopPixelOffset
ld a,e
ld [desiredPixelOffset_y],a
ld a,b
dec a
.recalcMapTopBottom
ld hl,mapTop
ld [hl+],a ;mapTop, mapBottom, mapBottom+1
add 18
ld [hl+],a
inc a
ld [hl+],a
.topBottomAdjustDone
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routines: ScrollSpritesLeft
; ScrollSpritesRight
; ScrollSpritesUp
; ScrollSpritesDown
; Arguments: d - pixels to scroll
; Alters: af
; Description: Scrolls each of the 40 sprites (if their y-pos!=0)
; "d" # of pixels in the desired direction.
;---------------------------------------------------------------------
ScrollSpritesLeft::
push af
push bc
push de
push hl
xor a
sub d
ld d,a
jr ScrollSpritesLRCommon
ScrollSpritesRight::
push af
push bc
push de
push hl
ScrollSpritesLRCommon:
ld hl,spriteOAMBuffer
ld bc,3
ld e,40
.loop ld a,[hl+]
or a
jr z,.afterChange ;sprite inactive
ld a,[hl]
add d
ld [hl],a
.afterChange
add hl,bc
dec e
jr nz,.loop
.done
pop hl
pop de
pop bc
pop af
ret
ScrollSpritesUp::
push af
push bc
push de
push hl
xor a
sub d
ld d,a
jr ScrollSpritesUDCommon
ScrollSpritesDown::
push af
push bc
push de
push hl
ScrollSpritesUDCommon:
ld hl,spriteOAMBuffer
ld bc,4
ld e,40
.loop ld a,[hl]
or a
jr z,.afterChange ;sprite inactive
add d
ld [hl],a
.afterChange
add hl,bc
dec e
jr nz,.loop
.done
pop hl
pop de
pop bc
pop af
ret
;---------------------------------------------------------------------
; Routine: DrawMapToBackBuffer
; Description: Sets relevant variables so the map can be drawn
; Note: Uses [temp] to store tile attributes
;---------------------------------------------------------------------
DrawMapToBackBuffer::
ld a,[displayType]
or a
jr z,.mapType
jp DrawCinemaToBackBuffer
.mapType
push bc
push de
push hl
call SetupDrawCommon
.outer push bc ;save vertical count "b" on stack
push de ;save starting ptr to dest (hl) and source (de)
push hl
;----copy 21 bg tiles into backBuffer/attributeBuffer
;save starting point, copy tile pattern numbers
push de
push hl
ld a,MAPBANK
ld [$ff70],a
ld b,((bgTileMap>>8) & $ff)
call .copy7BGTiles
call .copy7BGTiles
call .copy7BGTiles
;start over copying attributes
pop hl
pop de
push de
push hl
ld a,h ;backBuffer -> attributeBuffer
add 3
ld h,a
ld b,((bgAttributes>>8) & $ff)
call .copy7BGAttributes
call .copy7BGAttributes
call .copy7BGAttributes
;back to start again
pop hl
pop de
push de
push hl
;recopy FG tiles from shadow buffers
ld a,TILESHADOWBANK
ld [$ff70],a
ldio a,[firstMonster]
ld b,a
call .copy7FGTiles
call .copy7FGTiles
call .copy7FGTiles
pop hl
pop de
ld a,MAPBANK
ld [$ff70],a
ld a,h
add 3
ld h,a
call .copy7FGAttributes
call .copy7FGAttributes
call .copy7FGAttributes
;row done
;---begin old code 3--------------------------------------------------
IF 0
;copy tile patterns & attributes for any BG tiles to ---------
;tile & attribute shadow buffers
;save starting point
push de
push hl
;use hl for map source / shadow buffer dest
ld h,d
ld l,e
;setup loop
ld a,MAPBANK
ld [$ff70],a
ldio a,[firstMonster]
ld b,a
ld c,21
.copyBGTiles
ld a,[hl]
cp b
jr c,.isBGTile
inc hl
dec c
jr nz,.copyBGTiles
jr .copyBGTilesDone
.isBGTile
ld d,((bgTileMap>>8) & $ff)
ld e,a
ld a,TILESHADOWBANK
ld [$ff70],a
ld a,[de]
ld [hl],a
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld d,((bgAttributes>>8) & $ff)
ld a,[de]
and %00000111
ld [hl+],a
ld a,MAPBANK
ld [$ff70],a
dec c
jr nz,.copyBGTiles
.copyBGTilesDone
;retrieve starting point & save again
pop hl
pop de
push de
push hl
;copy set of 21 bytes from TILESHADOWBANK to backBuffer
ld a,TILESHADOWBANK
ld [$ff70],a
call .copy21
;retrieve starting point
pop hl
pop de
;copy set of 21 bytes from ATTRSHADOWBANK to backBuffer
ld a,h
add 3
ld h,a
ld a,ATTRSHADOWBANK
ld [$ff70],a
call .copy21
ENDC
;row done
;----end old code 3---------------------------------------------------
;------begin old code 2-----------------------------------------------
IF 0
;copy tile pattern numbers from map/buffer to backBuffer
ld a,MAPBANK
ld [$ff70],a
ldio a,[firstMonster] ;get index of first fg class
ld b,a
ld c,21
push de
push hl
.copyTileNumbers
ld a,[de] ;next class number from map
cp b
jr nc,.isFGTile
;lookup tile used for background
push bc
ld b,((bgTileMap>>8) & $ff)
ld c,a
ld a,[bc]
ld [hl+],a
inc de
pop bc
dec c
jr nz,.copyTileNumbers
jr .setupCopyAttributes
.isFGTile
;lookup class number in tile shadow buffer
;push bc
ld a,TILESHADOWBANK
ld [$ff70],a
ld a,[de]
inc de
ld [hl+],a
ld a,MAPBANK
ld [$ff70],a
dec c
jr nz,.copyTileNumbers
.setupCopyAttributes
pop hl ;go back to start of line
pop de
ld a,h ;copy to attributeBuffer
add 3
ld h,a
ld c,21 ;loop 21 times
.copyAttributes
ld a,[de] ;next class number from map
cp b
jr nc,.isFGAttribute
;BG Attribute
push bc
ld b,((bgAttributes>>8) & $ff)
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
inc de
pop bc
dec c
jr nz,.copyAttributes
jr .rowDone
.isFGAttribute
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de]
ld [hl+],a
inc de
ld a,MAPBANK
ld [$ff70],a
dec c
jr nz,.copyAttributes
.rowDone
ENDC
;------end old code 2-----------------------------------------------
;old loop code
;-------old code begin------------------------------------------------
IF 0
ld a,MAPBANK ;set RAM bank to the map bank
ld [$ff70],a
ld c,21 ;times to loop horizontally
.inner push bc
ld a,[de] ;load a tile index from level map
cp b ;index of first monster
jr c,.isBGTile ;< first monster
.isFGTile
;retrieve FG tile info from shadow buffers parallel to main map
ld a,ATTRSHADOWBANK ;set RAM bank to the attribute shadow bank
ld [$ff70],a
ld a,[de] ;attributes
ldio [temp],a
ld a,TILESHADOWBANK ;set RAM bank to the tile shadow bank
ld [$ff70],a
ld a,[de] ;tile to draw
inc de
ld [hl],a ;store tile in backBuffer
ld a,MAPBANK ;set RAM bank to the map bank
ld [$ff70],a
jr .gotTile
.isBGTile
inc de
or a
jr z,.isNullTile
ld c,a
;ld a,TILEINDEXBANK ;select RAM bank of tile index maps
;ld [$ff70],a
ld b,((bgAttributes>>8)&$ff)
ld a,[bc] ;attributes for this tile
and %00000111 ;get palette only
ldio [temp],a ;store for later
ld b,((bgTileMap>>8)&$ff) ;get ptr to tile to draw in bc
ld a,[bc] ;get tile to draw
ld [hl],a ;store tile in backBuffer
jr .gotTile
.isNullTile
ld [temp],a ;attributes zero
ld [hl],a ;store tile in backBuffer
.gotTile
push hl
ld a,h
add 3 ;768 bytes to get from backbuffer to attr buffer
ld h,a
ld a,[temp] ;get attributes for this tile
ld [hl],a ;store attribute in buffer
pop hl ;back to map buffer
.afterDrawTile
inc hl
;inner loop termination test
pop bc
dec c
jr nz,.inner
ENDC
;-------old code end--------------------------------------------------
pop hl ;retrieve initial pointers
pop de
ld a,[mapPitch] ;mapPtr += mapPitch
add e
ld e,a
jr nc,.hlNoCarry
inc d
.hlNoCarry
ld a,32 ;bgTileMapPtr += 32
add l
ld l,a
jr nc,.deNoCarry
inc h
.deNoCarry
;loop the outer loop again?
pop bc
dec b
jr nz,.outer
call PostDrawCommon
.done ;map is drawn, bitch
ld a,MAPBANK ;set RAM bank to the map bank
ld [$ff00+$70],a
pop hl
pop de
pop bc
ret
.copy7BGTiles
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
ld [hl+],a
ret
.copy7BGAttributes
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ld a,[de]
inc de
ld c,a
ld a,[bc]
and %00000111
ld [hl+],a
ret
.copy7FGTiles
ld a,[hl]
cp b
jr c,.notMonster0
ld a,[de] ;get monster tile
ld [hl],a
.notMonster0
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster1
ld a,[de] ;get monster tile
ld [hl],a
.notMonster1
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster2
ld a,[de] ;get monster tile
ld [hl],a
.notMonster2
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster3
ld a,[de] ;get monster tile
ld [hl],a
.notMonster3
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster4
ld a,[de] ;get monster tile
ld [hl],a
.notMonster4
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster5
ld a,[de] ;get monster tile
ld [hl],a
.notMonster5
inc hl
inc de
ld a,[hl]
cp b
jr c,.notMonster6
ld a,[de] ;get monster tile
ld [hl],a
.notMonster6
inc hl
inc de
ret
.copy7FGAttributes
ld a,[de]
cp b
jr c,.fgNotMonster0
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster0
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster1
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster1
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster2
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster2
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster3
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster3
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster4
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster4
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster5
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster5
inc hl
inc de
ld a,[de]
cp b
jr c,.fgNotMonster6
ld a,ATTRSHADOWBANK
ld [$ff70],a
ld a,[de] ;get monster tile
ld [hl],a
ld a,MAPBANK
ld [$ff70],a
.fgNotMonster6
inc hl
inc de
ret
IF 0
;loop unrolled for max speed
.copy21
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ld a,[de]
inc de
ld [hl+],a
ret
ENDC
SetupDrawCommon:
;set VRAM bank to zero
ld a,MAPBANK
ld [$ff00+$4f],a
;find address to start getting tile indices from
ld a,[mapPitchMinusOne]
ld c,a
ld a,[mapTop]
ld e,a
xor a
.jTimesPitch
sla e ;times two
rla ;carry from low bit into high bit
srl c ;c is pitch-1, counter of how many times to shift
jr nz,.jTimesPitch
ld d,a ;high byte into d; de is now == j * pitch
ld a,[mapLeft]
add e
ld e,a ;de is now (j*pitch) + i
ld hl,map ;add in base address of map
add hl,de
ld d,h
ld e,l
;get memory address of backBuffer in hl
ld hl,backBuffer
;start looping
ld b,19 ;times to loop vertically
ret
PostDrawCommon:
;if the map is scrolled as far as possible right and/or down we
;need to clear the right and/or bottom border so the jiggle effect
;won't look goofy
ld a,[mapMaxLeft]
ld b,a
ld a,[mapLeft]
cp b
jr c,.rightBorderOkay
;set up vertical loop clearing tiles to zero
ld hl,(backBuffer + 20)
ld de,32
ld c,19
xor a
.vloop ld [hl],a
add hl,de
dec c
jr nz,.vloop
.rightBorderOkay
;does bottom border need clearing?
ld a,[mapMaxTop]
ld b,a
ld a,[mapTop]
cp b
jr c,.done
;set up horizontal loop clearing tiles to zero
ld hl,(backBuffer + (32*18))
ld c,21
xor a
.hloop ld [hl+],a
dec c
jr nz,.hloop
.done
ret
;---------------------------------------------------------------------
; Routine: DrawCinemaToBackBuffer
; Alters: af
; Description: Sets relevant variables so the map can be drawn
; Note: Uses [temp] to store tile attributes
;---------------------------------------------------------------------
DrawCinemaToBackBuffer::
push bc
push de
push hl
call SetupDrawCommon
.outer push de ;save starting ptr to dest (hl) and source (de)
push hl
ld c,21 ;times to loop horizontally
.inner push bc
;retrieve tile info from shadow buffers parallel to main map
ld a,ATTRSHADOWBANK ;set RAM bank to the attribute shadow bank
ld [$ff70],a
ld a,[de] ;attributes
ldio [temp],a
ld a,TILESHADOWBANK ;set RAM bank to the tile shadow bank
ld [$ff70],a
ld a,[de] ;tile to draw
inc de
ld [hl],a ;store tile in backBuffer
push hl
ld a,h
add 3 ;768 bytes to get from backbuffer to attr buffer
ld h,a
ld a,[temp] ;get attributes for this tile
ld [hl],a ;store attribute in buffer
pop hl ;back to map buffer
.afterDrawTile
inc hl
;inner loop termination test
pop bc
dec c
jr nz,.inner
pop hl ;retrieve initial pointers
pop de
ld a,[mapPitch] ;mapPtr += mapPitch
add e
ld e,a
jr nc,.hlNoCarry
inc d
.hlNoCarry
ld a,32 ;bgTileMapPtr += 32
add l
ld l,a
jr nc,.deNoCarry
inc h
.deNoCarry
;loop the outer loop again?
dec b
jr nz,.outer
call PostDrawCommon
.done ;map is drawn, bitch
ld a,MAPBANK ;set RAM bank to the map bank
ld [$ff00+$70],a
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: ShowTitle
; Arguments: de - pointer to text
; Description: Shows the text centered on-screen and waits until
; the user presses a button to continue.
; Alters: a,hl
;---------------------------------------------------------------------
ShowTitle::
push bc
ld a,[de] ;length of text
inc de
ld c,a
ld hl,spriteOAMBuffer+3
.loop
xor a ;sprite attributes
ld [hl-],a
ld a,[de] ;letter
inc de
ld [hl-],a
ld a,16 ;calculate x coordinate
sub c
sla a ;times 8 for pixels
sla a
sla a
ld [hl-],a ;y coordinate
ld a,80
ld [hl],a
ld a,l ;add 7 to hl
add 7
ld l,a
ld a,h
adc 0
ld h,a
dec c
jr nz,.loop
pop bc
ret
;---------------------------------------------------------------------
; Routines: SetSpeakerToFirstHero
; Arguments: None.
; Returns: c - index of first hero present
; [dialogSpeakerIndex]
; [dialogJoyIndex]
; Alters: af, c
; Description: Finds the first hero on the map and sets up
; some dialog parameters based on who it is.
;---------------------------------------------------------------------
SetSpeakerToFirstHero::
push de
push hl
xor a
ld hl,hero0_index
call .setParameters
or a
jr nz,.done
ld a,1
ld hl,hero1_index
call .setParameters
.done
pop hl
pop de
ret
.setParameters
ld [dialogJoyIndex],a
ld a,[hl-] ;get hero index
or a ;non-zero?
ret z ;not present
ld c,a ;class index
ld de,HERODATA_TYPE
add hl,de
ld a,[hl]
ld [dialogSpeakerIndex],a ;flag indicating speaker
ld a,1 ;operation successful
ret
;---------------------------------------------------------------------
; Routines: SetSpeakerFromHeroIndex
; Arguments: c - index of speaking hero
; Returns: [dialogSpeakerIndex]
; [dialogJoyIndex]
; Alters: af
; Description:
;---------------------------------------------------------------------
SetSpeakerFromHeroIndex::
push de
push hl
ld hl,hero0_index
ld a,[hl-]
cp c
ld a,0
jr nz,.setHero1
call .setParameters
jr .done
.setHero1
ld a,1
ld hl,hero1_data
call .setParameters
.done
pop hl
pop de
ret
.setParameters
ld [dialogJoyIndex],a
ld de,HERODATA_TYPE
add hl,de
ld a,[hl]
ld [dialogSpeakerIndex],a ;flag indicating speaker
ret
;---------------------------------------------------------------------
; Routine: SetPressBDialog
;---------------------------------------------------------------------
SetPressBDialog:
ld a,DLG_BORDER | DLG_PRESSB
ld [dialogSettings],a
ret
;---------------------------------------------------------------------
; Routine: SetDialogJoy::
; Arguments: None.
; Returns: hl - pointer to appropriate joy inputs
; Alters: af,hl
;---------------------------------------------------------------------
SetDialogJoy::
ld a,[displayType]
cp 1
jr z,.cinemaType
ld a,[canJoinMap]
cp 2 ;asynchronous join?
jr z,.cinemaType
ld hl,curInput0
ld a,[dialogJoyIndex]
or a
ret z
inc hl
ret
.cinemaType
ld hl,myJoy
ret
;---------------------------------------------------------------------
; Routine: CheckDialogContinue
; Arguments: None.
; Returns: a - 1 if done (B is pressed), 0 if not done
; Alters: af
; Description: Calls CheckDialogSkip and then sees if button B of
; the speaker's joystick is pressed.
;---------------------------------------------------------------------
CheckDialogContinue::
push hl
call CheckSkip
call SetDialogJoy
ld a,[dialogSettings]
and DLG_WAITRELEASE
jr nz,.waitRelease
ld a,[hl]
and JOY_B
jr z,.returnFalse
ld hl,dialogSettings
set DLG_WAITRELEASE_BIT,[hl]
jr .returnFalse
.waitRelease
ld a,[hl]
and JOY_B
jr nz,.returnFalse
ld hl,dialogSettings
res DLG_WAITRELEASE_BIT,[hl]
bit DLG_CLEARSKIP_BIT,[hl]
jr z,.afterClearSkip
res DLG_CLEARSKIP_BIT,[hl]
push hl
ld de,0
call SetDialogSkip
pop hl
.afterClearSkip
bit DLG_NOCLEAR_BIT,[hl]
res DLG_NOCLEAR_BIT,[hl]
jr nz,.returnTrue
call ClearDialog
.returnTrue
ld a,1
jr .done
.returnFalse
xor a
.done
pop hl
ret
;---------------------------------------------------------------------
; Routines: ShowDialogAtTop
; ShowDialogAtTopNoWait
; ShowDialogAtBottom
; ShowDialogAtBottomNoWait
; ClearDialog
; Arguments: [dialogBank] - bank containing text
; c - class index of speaking character
; de - pointer to gtx text
; Description: Shows the text centered at the top or bottom dialog
; bar & waits until the user presses a button to
; continue.
; Alters: none
; Note: Format of gtx:
; BYTE number of lines
; REPT[nLines]:
; BYTE spaces to center
; BYTE num chars in line
; BYTE[nChars] characters
;---------------------------------------------------------------------
ShowDialogNPC::
ld a,[dialogNPC_heroIndex]
ld c,a
call SetSpeakerFromHeroIndex
ld a,[dialogNPC_speakerIndex]
ld c,a
call ShowDialogAtTop
call ClearDialog
ret
ShowDialogHero::
ld a,[dialogNPC_heroIndex]
ld c,a
call SetSpeakerFromHeroIndex
call ShowDialogAtBottom
call ClearDialog
ret
ShowDialogAtTop::
ld a,[dialogBank]
push af
push bc
push de
push hl
call ChooseFromDialogAlternates
ld b,0 ;lines to skip at top
call ShowDialogCommon
call ShowDialogAtTopCommon
call ShowDialogWait
pop hl
pop de
pop bc
pop af
ret
ShowDialogAtTopNoWait::
ld a,[dialogBank]
push af
push bc
push de
push hl
call ChooseFromDialogAlternates
ld b,0 ;lines to skip at top
call ShowDialogCommon
call ShowDialogAtTopCommon
pop hl
pop de
pop bc
pop af
ret
ShowDialogAtTopCommon::
call DrawDialogBorderAtBottom
call GfxBlitBackBufferToWindow
xor a
ldh [$ff4a], a ;set window y position
ld a,[de] ;number of lines
rlca ;times 8 = pixels for window
rlca
rlca
add 7
ld [hblankWinOff],a
ld a,143
ld [hblankWinOn],a
ld a,[hblankFlag]
bit 1,a
jr nz,.afterSetLYC
ld a,143
ld [$ff45],a ;lyc
ld a,[hblankFlag]
.afterSetLYC
or %10 ;allow window to show
ld [hblankFlag],a
ld a,OBJROM
call SetActiveROM
ret
ShowDialogAtBottom::
ld a,[dialogBank]
push af
push bc
push de
push hl
call ChooseFromDialogAlternates
ld b,1 ;lines to skip at top
call ShowDialogCommon
call ShowDialogAtBottomCommon
call ShowDialogWait
pop hl
pop de
pop bc
pop af
ret
ShowDialogAtBottomNoWait::
ld a,[dialogBank]
push af
push bc
push de
push hl
call ChooseFromDialogAlternates
ld b,1 ;lines to skip at top
call ShowDialogCommon
call ShowDialogAtBottomCommon
pop hl
pop de
pop bc
pop af
ret
ShowDialogAtBottomCommon::
call DrawDialogBorderAtTop
call GfxBlitBackBufferToWindow
ld a,143
ld [hblankWinOff],a
;set window y pos. Req'd for actual GBC, not emulator
ld a,[de] ;# lines
cpl
add 1+17 ;(max lines) - (text lines+1)
rlca
rlca
rlca ;times 8
ldh [$ff4a], a ;set window y position
ld a,[de] ;number of lines
rlca ;times 8 = pixels for window
rlca
rlca
add 8
cpl ;make negative (+1), subtract from 143
add 144 ;+1 2's compl, +143
ld [hblankWinOn],a
ld a,[hblankFlag]
bit 1,a
jr nz,.afterSetLYC
ld a,[hblankWinOn]
ld [$ff45],a ;lyc
ld a,[hblankFlag]
.afterSetLYC
or %10 ;allow window to show
ld [hblankFlag],a
ld a,OBJROM
call SetActiveROM
ret
ClearDialog::
push af
xor a
ld [amShowingDialog],a
ld a,[hblankFlag] ;turn off dialog box and window
and %11111101
ld [hblankFlag],a
call VWait
;call InstallGamePalette
ld a,1
ldio [paletteBufferReady],a
call VWait
pop af
ret
ShowDialogWait::
;change both heroes to idle
ld a,[heroesIdle]
push af
ld a,1
ld [heroesIdle],a
call .waitInputZero
.wait
call UpdateObjects
call RedrawMap
call CheckDialogContinue
or a
jr z,.wait
;call .waitInput
;call .waitInputZero
pop af
ld [heroesIdle],a
ret
.waitInputZero
DialogWaitInputZero::
call UpdateObjects
call RedrawMap
ld h,((curInput0>>8) & $ff)
ld a,[dialogJoyIndex]
add (curInput0 & $ff)
ld l,a
ld a,[hl]
and %11110000
jr nz,DialogWaitInputZero
ret
;---------------------------------------------------------------------
; Routines: ShowDialogCommon
; Arguments: a - bank message is in
; b - lines to skip at top
; c - class index of speaking character
; de - pointer to gtx text beginning with #lines
; Description:
; Alters: af
; Note: Format of gtx:
; BYTE number of lines
; REPT[nLines]:
; BYTE spaces to center
; BYTE num chars in line
; BYTE[nChars] characters
;---------------------------------------------------------------------
ShowDialogCommon::
push de
push bc ;save class index of speaking character
call SetActiveROM
ld a,1
ld [amShowingDialog],a
;wait until the backbuffer is blitted
.waitBackBuffer
ldio a,[backBufferReady]
or a
jr z,.canMessWithBackBuffer
call VWait
jr .waitBackBuffer
.canMessWithBackBuffer
;clear the backbuffer and attribute buffer for given #lines
ld a,[de] ;b = number of lines + 1
add 1
ld b,a
ld hl,backBuffer
.clearLines
call ClearGTXLine
push bc
ld bc,32
add hl,bc
pop bc
dec b
jr nz,.clearLines
;xor a
;.outer1 ld c,32
;.inner1 ld [hl+],a
;dec c
;jr nz,.inner1
;dec b
;jr nz,.outer1
;ld a,[de] ;b = number of lines + 1
;add 1
;ld b,a
;ld hl,attributeBuffer
;xor a
;.outer2 ld c,32
;.inner2 ld [hl+],a
;dec c
;jr nz,.inner2
;dec b
;jr nz,.outer2
;adjust hl down a line?
pop bc
push bc
ld hl,backBuffer
bit 0,b
jr z,.hlOkay
ld bc,32
add hl,bc
.hlOkay
;for each line of text...
ld a,[de] ;b = number of lines
inc de
ld b,a
.line
call WriteGTXLine
;go to next line
dec b
jr nz,.line
;retrieve class index of speaking character and
;blit that tile to the top-left corner of the buffer
pop bc
call DrawTileToTLCorner
;call GfxBlitBackBufferToWindow
pop de
ret
;---------------------------------------------------------------------
; Routine: ClearGTXLine
; Arguments:
; hl - backbuffer location to draw at
; Alters: af
;---------------------------------------------------------------------
ClearGTXLine::
push bc
push hl
push hl
;clear backbuffer
xor a
ld c,32
.loop ld [hl+],a
dec c
jr nz,.loop
;clear attr buffer
xor a
pop hl
ld bc,$300
add hl,bc
ld c,32
.loop2 ld [hl+],a
dec c
jr nz,.loop2
pop hl
pop bc
ret
;---------------------------------------------------------------------
; Routine: WriteGTXLine
; Arguments: de - pointer to gtx text beginning with centerSpaces
; hl - location to draw at
; Alters: hl,de
;---------------------------------------------------------------------
WriteGTXLine::
;advance hl spaces required to center text
push bc
ld b,0
ld a,[de]
inc de
ld c,a
add hl,bc
;get the char count for this line
ld a,[de]
inc de
ld c,a
or a
jr z,.afterLoop
;copy the characters to the buffer
.loop ld a,[de]
inc de
ld [hl+],a
dec c
jr nz,.loop
.afterLoop
;advance hl to next line
ld a,l
and ~31
add 32
ld l,a
ld a,0
adc h
ld h,a
pop bc
ret
GfxBlitBackBufferToWindow::
;xor a
;ld c,38 ;38*16 = 608
;ld de,$9c00 ;dest = window map memory
;ld hl,$c000 ;source
;call VMemCopy
;ret
ld a,$9c ;copy to window map memory
ldio [backBufferDestHighByte],a
ld a,1
ldio [backBufferReady],a
.vwait call VWait
ldio a,[backBufferReady] ;wait until buffer is copied
or a
jr nz,.vwait
ld a,$98 ;go back to copying to bg map memory
ldio [backBufferDestHighByte],a
ret
GfxShowStandardTextBox::
;set interrupt to turn window off at bottom of screen
ld a,143
ld [hblankWinOff],a
;set window y pos. Req'd for actual GBC, not emulator
ld a,96
ldh [$ff4a], a ;set window y position
ld [hblankWinOn],a
ld a,[hblankFlag]
bit 1,a
jr nz,.afterSetLYC
ld a,[hblankWinOn]
ld [$ff45],a ;lyc
ld a,[hblankFlag]
.afterSetLYC
or %10 ;allow window to show
ld [hblankFlag],a
ret
DrawDialogBorderAtTop:
push hl
ld hl,$c000 ;9c00
call DrawDialogBorder
pop hl
ret
DrawDialogBorderAtBottom:
push de
push hl
ld hl,$c000 ;9c00
ld a,[de] ;num lines
ld d,a
xor a
srl d
rra
srl d
rra
srl d
rra
ld e,a
add hl,de
call DrawDialogBorder
pop hl
pop de
ret
DrawDialogBorder:
push bc
push hl
ld a,[dialogSettings]
and DLG_BORDER
jr z,.done
;draw border at edge
push hl
;xor a
;ldio [$ff4f],a ;VRAM bank
ld c,20
ld a,252
.drawBorder
ld [hl+],a
dec c
jr nz,.drawBorder
dec hl
ld a,[dialogSettings]
and DLG_PRESSB
jr z,.clearBG
ld [hl],253
.clearBG
pop hl
;clear bg attributes
ld bc,$300
add hl,bc
;ld a,1
;ldio [$ff4f],a ;VRAM bank
ld c,20
xor a
.clearBGLoop
ld [hl+],a
dec c
jr nz,.clearBGLoop
.done
pop hl
pop bc
ret
DrawTileToTLCorner: ;class index in c, 1 line down in b
.drawTile
ld hl,backBuffer
bit 0,b
jr z,.hlOkay
ld l,32
.hlOkay
ld a,c
or a
jr z,.useNullTile ;use null tile
ld a,TILEINDEXBANK
ld [$ff70],a
ld b,((fgAttributes>>8) & $ff)
ld a,[bc]
bit 5,a ;2x2 monster?
jr nz,.speaker2x2
and %00000111
or %00001000 ;coming from bank 1
ld h,((attributeBuffer>>8) & $ff)
ld [hl],a
ld h,((backBuffer>>8) & $ff)
ld b,((fgTileMap>>8) & $ff)
ld a,[bc] ;a is tile to draw
add 3 ;get right-facing
ld [hl],a
ret
.speaker2x2
and %00000111 ;color
or %00001000 ;coming from bank 1
push hl
push hl
ld h,((attributeBuffer>>8) & $ff)
ld [hl+],a
ld [hl+],a
push de
ld de,30
add hl,de
pop de
ld [hl+],a
ld [hl-],a
ld h,((backBuffer>>8) & $ff)
ld b,((fgTileMap>>8) & $ff)
ld a,[bc] ;a is tile to draw
add 12 ;get right-facing
ld [hl+],a
inc a
ld [hl+],a
pop hl
sub 3
ld [hl+],a
inc a
ld [hl+],a
pop hl
;kludge for two-color BRAINIAC
ld a,[dialogSettings]
bit DLG_BRAINIAC_BIT,a
ret z
res DLG_BRAINIAC_BIT,a
ld [dialogSettings],a
ld h,((attributeBuffer>>8) & $ff)
inc hl
ld a,8+3 ;green color from bank 1
ld [hl],a
push de
ld de,32
add hl,de
pop de
ld [hl+],a
ret
.useNullTile
xor a
ld [hl],a
ld h,((attributeBuffer>>8) & $ff)
ld [hl],a
ret
;---------------------------------------------------------------------
; Routine: ChooseFromDialogAlternates
; Arguments: de - pointer to gtx text
; Returns: de - adjusted pointer
; Alters: de
; Description: de points to start of an indeterminate number of
; byte triplets of the form:
; [mask] [offsetL] [offsetH]
; This routine finds a mask that (when ANDed) matches
; the value in [dialogSpeakerIndex] and jumps to the
; gtx alternate beginning at the given offset. The
; offset given for the cursor being at a position of
; 1 past [offsetH] of the matching triplet.
;---------------------------------------------------------------------
ChooseFromDialogAlternates:
push af
push bc
push hl
call SetActiveROM
ld h,d
ld l,e
ld a,[dialogSpeakerIndex]
ld c,a
.attemptMatch
ld a,[hl+] ;mask
and c
jr nz,.foundMatch
inc hl ;skip offset to look at next mask
inc hl
jr .attemptMatch
.foundMatch
ld a,[hl+] ;retrieve offset to start of gtx proper
ld e,a
ld a,[hl+]
ld d,a
add hl,de
ld d,h
ld e,l
pop hl
pop bc
pop af
ret
;---------------------------------------------------------------------
; Routine: CheckSkip
; Arguments: None.
; Returns: Nothing.
; Alters: af
; Description: Intended for use in cinemas and in-game dialog,
; resets the pc and sp to an address set with
; SetDialogSkip. Sets to the skip address if start is
; pushed, to fast-forward address if B is pushed.
;---------------------------------------------------------------------
CheckSkip::
push hl
ld a,[displayType]
cp 1
jr z,.cinemaType
ld a,[canJoinMap] ;asynchronous join?
cp 2
jr z,.cinemaType
ld hl,curInput0
ld a,[dialogJoyIndex] ;0 or 1
add l
ld l,a
jr .afterSetJoy
.cinemaType
ld hl,myJoy
.afterSetJoy
ld a,[hl] ;get the input
and JOY_START
jr nz,.startPressed
ld a,[hl]
and JOY_B
jr z,.done ;no buttons pushed
.abPressed
push hl
ld hl,levelCheckSkip ;fast forward address
jr .restore
.startPressed
push hl
ld hl,levelCheckSkip+2 ;skip address
.restore
ld a,[hl]
or a
jr nz,.addressOkay
inc hl
ld a,[hl-]
or a
jr nz,.addressOkay
pop hl
jr .done
.addressOkay
;make the class/object ROM the current
ld a,OBJROM
call SetActiveROM
xor a
ld e,[hl]
ld [hl],a
inc hl
ld d,[hl]
ld [hl],a
pop hl
cp d
jr nz,.addrOkay
cp e
jr z,.done ;null address
.addrOkay
ld a,$f0
call WaitInputZero
;reset all one-shot dialog options
ld hl,dialogSettings
res DLG_BRAINIAC_BIT,[hl]
res DLG_NOCLEAR_BIT,[hl]
res DLG_CLEARSKIP_BIT,[hl]
;restore stack pointer
ld a,[levelCheckStackPos]
ld l,a
ld a,[levelCheckStackPos+1]
ld h,a
ld sp,hl
;push return address on stack and go there
push de
ret
.done
pop hl
ret
;---------------------------------------------------------------------
; Routine: Delay
; Arguments: a - number of 1/60 seconds to delay
; Alters: af
; Description: Updates and displays objects for specified number of
; 1/60 seconds. Jumps to [levelCheckSkip] if start
; button is pressed if addr is non-null.
;---------------------------------------------------------------------
Delay::
push bc
push de
push hl
.delay push af
call UpdateObjects
call RedrawMap
call CheckSkip
.keepGoing
pop af
dec a
jr nz,.delay
.waitBlit
ldio a,[backBufferReady]
or a
jr nz,.waitBlit
;if we're in a cinema and we get a YANK from the remote player
;then we need to kill into the cinema script
ld a,[timeToChangeLevel]
or a
jr z,.done
ld a,[inLoadMethod]
or a
jr z,.done
call BlackoutPalette
ld a,[loadStackPosL]
ld l,a
ld a,[loadStackPosH]
ld h,a
ld sp,hl
jp AfterLoadLevelMethod
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: GetRandomNumZeroToN
; Arguments: a - maximum desired random number "N"
; Returns: a - random number between 0 and N
; Alters: af
;---------------------------------------------------------------------
GetRandomNumZeroToN::
or a
ret z
push bc
push hl
inc a
jr z,.handleFF
ld b,a ;b is N
PUSHROM
ld a,BANK(randomTable)
call SetActiveROM
ld hl,randomLoc
inc [hl]
ld l,[hl]
ld h,((randomTable>>8) & $ff)
ld a,[hl]
bit 7,b
jr nz,.loop ;N+1>=128
;divide raw number by two until it's less than limit*2
ld c,b
sla c ;c = (limit * 2) + 1
inc c
.fastReduce
cp c ;a < limit*2 + 1?
jr c,.loop ;yes, go to slower precision work
srl a ;a/=2
jr .fastReduce
.loop cp b ;subtract N while r > N
jr c,.done
sub b
jr .loop
.done
ld b,a
POPROM
ld a,b
pop hl
pop bc
ret
.handleFF
PUSHROM
ld a,BANK(randomTable)
call SetActiveROM
ld hl,randomLoc
inc [hl]
ld l,[hl]
ld h,((randomTable>>8) & $ff)
ld a,[hl]
ld b,a
POPROM
ld a,b
pop hl
pop bc
ret
;---------------------------------------------------------------------
; Routine: GetRandomNumMask
; Arguments: a - bit mask for random number
; Returns: a - random number
; Alters: af
;---------------------------------------------------------------------
GetRandomNumMask::
push bc
push hl
ld b,a ;b is bitmask
PUSHROM
ld a,BANK(randomTable)
call SetActiveROM
ld hl,randomLoc
inc [hl]
ld l,[hl]
ld h,((randomTable>>8) & $ff)
ld a,[hl]
and b
.done
ld b,a
POPROM
ld a,b
pop hl
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetupFadeFromWhite
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeFromWhite::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set cur palette to be all white
ld hl,fadeCurPalette
call FadeCommonSetPaletteToWhite
;set final palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
FadeCommonSetPaletteToWhite::
ld c,64
.loop
ld a,$ff
ld [hl+],a
ld a,$7f
ld [hl+],a
dec c
jr nz,.loop
ret
CopyPalette64::
FadeCommonCopyPalette::
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
ld c,128
.loop ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.loop
pop hl
pop de
pop bc
ret
CopyPalette32::
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
ld c,64
.loop ld a,[hl+]
ld [de],a
inc de
dec c
jr nz,.loop
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: InstallGamePalette
; Arguments: None.
; Alters: af
; Description: Sets gamePalette to be installed to the hardware
; on the next VBlank.
;---------------------------------------------------------------------
InstallGamePalette::
push hl
push de
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld a,1
ldio [paletteBufferReady],a
.wait
ldio a,[paletteBufferReady] ;wait for vblank to install it
or a
jr nz,.wait
pop de
pop hl
ret
;---------------------------------------------------------------------
; Routine: SetupFadeToWhite
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeToWhite::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set final palette to be all white
ld hl,fadeFinalPalette
call FadeCommonSetPaletteToWhite
;set cur palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetupFadeFromBlack
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeFromStandard::
SetupFadeFromBlack::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set cur palette to be all white
ld hl,fadeCurPalette
call FadeCommonSetPaletteToBlack
;set final palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetupFadeToBlack
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeToStandard::
SetupFadeToBlack::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set final palette to be all black
ld hl,fadeFinalPalette
call FadeCommonSetPaletteToBlack
;set cur palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
FadeCommonSetPaletteToBlack::
ld c,64
xor a
.loop
ld [hl+],a
ld [hl+],a
dec c
jr nz,.loop
ret
;---------------------------------------------------------------------
; Routine: SetupFadeFromBlackBGOnly
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeFromBlackBGOnly::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
;set cur palette to be all black
ld hl,fadeCurPalette
call FadeCommonSetPaletteToBlackBGOnly
;set final palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
ld a,32
ld [fadeRange],a
pop af
call FadeInit
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: BlackoutPalette
; Arguments:
; Alters: af
; Description: Sets fadeCurPalette and final palette to all black
;---------------------------------------------------------------------
BlackoutPalette::
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
ld hl,fadeFinalPalette
call FadeCommonSetPaletteToBlack
ld hl,fadeCurPalette
call FadeCommonSetPaletteToBlack
;turn off any existing fade
ld hl,specialFX
res 0,[hl] ;reset fade bit
;install the current palette on the next VBlank
ld a,1
ldio [paletteBufferReady],a
.wait
ldio a,[paletteBufferReady] ;wait for vblank to install it
or a
jr nz,.wait
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetupFadeToBlackBGOnly
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeToBlackBGOnly::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
;set final palette BG Colors to be all black
ld hl,fadeFinalPalette
call FadeCommonSetPaletteToBlackBGOnly
;set cur palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld a,32
ld [fadeRange],a
pop af
call FadeInit
pop hl
pop de
pop bc
ret
FadeCommonSetPaletteToBlackBGOnly::
ld c,32
xor a
.loop
ld [hl+],a
ld [hl+],a
dec c
jr nz,.loop
ret
;---------------------------------------------------------------------
; Routine: SetupFadeFromSaturated
; Arguments: a - steps
; b - amount of saturation (white) to start at
; Alters: af
;---------------------------------------------------------------------
SetupFadeFromSaturated::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;copy game palette to starting palette and ending palette
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld l,b ;saturation
;add saturation to each color
ld h,64
.setup call FadeCommonGetColor
dec de
dec de
call GetRedComponent
call .saturate
call SetRedComponent
call GetGreenComponent
call .saturate
call SetGreenComponent
call GetBlueComponent
call .saturate
call SetBlueComponent
;save color
ld a,c
ld [de],a
inc de
ld a,b
ld [de],a
inc de
dec h
jr nz,.setup
pop af
call FadeInit
pop hl
pop de
pop bc
ret
.saturate
add l
bit 7,l
jr nz,.satneg
cp 32 ;over the limit?
ret c
ld a,$1f
ret
.satneg
xor a
ret
;---------------------------------------------------------------------
; Routine: SetupFadeToGamePalette
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeToGamePalette::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set final palette to be current game palette
ld hl,gamePalette
ld de,fadeFinalPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetupFadeToHalfbrite
; Arguments: a - steps
; Alters: af
;---------------------------------------------------------------------
SetupFadeToHalfbrite::
push bc
push de
push hl
push af
ld a,FADEBANK
ld [$ff70],a
;set final palette to be halfbrite game palette
ld hl,gamePalette
ld de,fadeCurPalette
ld c,64
.copyHalfbrite
push bc
ld a,[hl+]
ld c,a
ld a,[hl-]
ld b,a
call GetRedComponent
srl a
call SetRedComponent
call GetGreenComponent
srl a
call SetGreenComponent
call GetBlueComponent
srl a
call SetBlueComponent
ld a,c
ld [hl+],a
ld a,b
ld [hl+],a
pop bc
dec c
jr nz,.copyHalfbrite
;set cur palette to be copy of current game palette
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
pop af
call FadeInit
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: FadeCommonGetColor
; Arguments: de - ptr to next color
; Returns: bc - next color
; Alters: af,de
;---------------------------------------------------------------------
FadeCommonGetColor:
ld a,[de]
inc de
ld c,a
ld a,[de]
inc de
ld b,a
ret
;---------------------------------------------------------------------
; Routine: FadeInit
; Arguments: a - number of steps
; [fadeCurPalette], [fadeFinalPalette] already setup
; with palettes to fade between
; Alters: af
; Description: Sets up and uses fadeDelta[32*3]
; and fadeError[32*3].
; FadeStep must then be called every vblank until
; [specialFX:0] becomes zero.
;---------------------------------------------------------------------
FadeInit::
push bc
push de
push hl
ld [fadeSteps],a
ld [fadeStepsToGo],a
ld a,FADEBANK
ld [$ff70],a
;for each color component, difference is (c2-c1)
;subtract each element of fadeCurPalette from fadeFinalPalette
;and store separate RGB offsets in fadeDelta.
;fadeCurPalette RGB elements in fadeCurRGB.
;clear out fadeError and fadeDelta
ld hl,fadeError
ld de,fadeDelta
ld c,192
xor a
.clearError
ld [hl+],a
ld [de],a
inc de
dec c
jr nz,.clearError
;begin by storing each color component of each color in
;fadeCurPalette into fadeDelta
ld a,64
ld hl,fadeDelta
ld de,fadeCurPalette
.copyCurToDelta
push af
call FadeCommonGetColor
call GetRedComponent
ld [hl+],a
call GetGreenComponent
ld [hl+],a
call GetBlueComponent
ld [hl+],a
pop af
dec a
jr nz,.copyCurToDelta
;copy fadeDelta[192] to fadeCurRGB[192].
;ld hl,fadeDelta
;ld de,fadeCurRGB
;ld c,192
;.copyToCurRGB
;ld a,[hl+]
;ld [de],a
;inc de
;dec c
;jr nz,.copyToCurRGB
;fadeDelta[...] = fadeFinalPalette[...] - fadeDelta[...]
ld a,64
ld hl,fadeDelta
ld de,fadeFinalPalette
.findStep
push af
call FadeCommonGetColor
call GetRedComponent
sub [hl]
ld [hl+],a
call GetGreenComponent
sub [hl]
ld [hl+],a
call GetBlueComponent
sub [hl]
ld [hl+],a
pop af
dec a
jr nz,.findStep
;indicate we've got a fade goin on
ld a,FX_FADE
ld [specialFX],a
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: FadeStep
; Alters: af
; Description: Peforms the next step of the fade in progress.
; Should only be called if [specialFX] & FX_FADE is 1.
; fadeRange is reset to 64 afterwards.
;---------------------------------------------------------------------
FadeStep::
push bc
push de
push hl
.waitReady
ldio a,[paletteBufferReady] ;wait for vblank
or a
jr nz,.waitReady
;loop 64 times, adding the fade delta for each component
;to the error. If error >= 32:
; error -= 32;
; increment component;
;Then flag the newly created palette to be displayed
ld a,FADEBANK
ld [$ff70],a
ld a,[fadeStepsToGo]
dec a
ld [fadeStepsToGo],a
jr z,.lastFade
;ld c,64
;ld hl,fadeError
;ld de,fadeCurRGB
;
;.fadeInner
;ld a,[de] ;red component
;call .addDeltaToError
;ld [de],a
;inc de
;
;ld a,[de] ;green component
;call .addDeltaToError
;ld [de],a
;inc de
;ld a,[de] ;blue component
;call .addDeltaToError
;ld [de],a
;inc de
;;dec c
;jr nz,.fadeInner
;copy RGB palette to 15-bit palette
;ld a,64
;ld bc,0
;ld hl,fadeCurRGB
;ld de,fadeCurPalette
;.RGBtoCur
;push af
;ld a,[hl+]
;call SetRedComponent
;ld a,[hl+]
;call SetGreenComponent
;ld a,[hl+]
;call SetBlueComponent
;ld a,c
;ld [de],a
;inc de
;ld a,b
;ld [de],a
;inc de
;pop af
;dec a
;jr nz,.RGBtoCur
ld a,[fadeRange]
ld hl,fadeError
ld de,fadeCurPalette
.fadeInner
push af
;get current color in bc, though keep de where it was
call FadeCommonGetColor
dec de
dec de
call GetRedComponent
call .addDeltaToError
call SetRedComponent ;store component
call GetGreenComponent
call .addDeltaToError
call SetGreenComponent ;store component
call GetBlueComponent
call .addDeltaToError
call SetBlueComponent ;store component
;store back in cur table
ld a,c
ld [de],a
inc de
ld a,b
ld [de],a
inc de
pop af
dec a
jr nz,.fadeInner
.install
;make mapColor the current color 0
ld de,mapColor
ld hl,fadeCurPalette
ld a,[hl+]
ld [de],a
inc de
ld a,[hl+]
ld [de],a
;install the current palette on the next VBlank
ld a,1
ldio [paletteBufferReady],a
pop hl
pop de
pop bc
ret
.lastFade
;finally copy actual palette
ld hl,fadeFinalPalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld a,64
ld [fadeRange],a
xor a
ld [specialFX],a
jr .install
.addDeltaToError
;accepts: a - color value
;returns: a - new color value
push bc
push af
ld a,[fadeSteps]
ld b,a
cpl
add 1
ld c,a
push hl
push de
ld de,$ff40 ;-192
add hl,de
pop de
ld a,[hl]
pop hl
bit 7,a ;negative?
jr nz,.negative
.positive
add a,[hl]
cp b
jr c,.done
;>=32
ld c,0
.while_pos_ge_32
sub b
inc c
cp b
jr nc,.while_pos_ge_32
ld [hl+],a
pop af
add c
pop bc
ret
.negative
add a,[hl]
cp c
jr nc,.done
;<= -32
ld b,0
.while_neg_le_n32
sub c
inc b
cp c
jr c,.while_neg_le_n32
ld [hl+],a
pop af
sub b
pop bc
ret
.done
ld [hl+],a
pop af
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetColor0AllPalettes
; Arguments: bc - color to set to
; hl - ptr to start of palettes
; Alters: af
;---------------------------------------------------------------------
SetColor0AllPalettes::
push de
push hl
ld d,16
.loop ld a,c
ld [hl+],a
ld a,b
ld [hl+],a
ld a,l
add 6
ld l,a
dec d
jr nz,.loop
pop hl
pop de
ret
;---------------------------------------------------------------------
; Routine: SetColors123AllPalettes
; Arguments: bc - color to set to
; hl - ptr to start of palettes
; Alters: af
;---------------------------------------------------------------------
SetColors123AllPalettes::
push de
push hl
ld d,16
.loop
inc hl
inc hl
ld e,3
.inner
ld a,c
ld [hl+],a
ld a,b
ld [hl+],a
dec e
jr nz,.inner
dec d
jr nz,.loop
pop hl
pop de
ret
;---------------------------------------------------------------------
; Routine: LighteningOut
; Alters: af
;---------------------------------------------------------------------
LighteningOut::
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
;white background
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld hl,fadeCurPalette
ld bc,$7fff
call SetColor0AllPalettes
ld a,128
ldio [paletteBufferReady],a
ld c,3
call .pause
ld bc,0
ld hl,fadeCurPalette
call SetColors123AllPalettes
ld a,128
ldio [paletteBufferReady],a
ld c,7
call .pause
pop hl
pop de
pop bc
ret
.pause call VWait
dec c
jr nz,.pause
ret
;---------------------------------------------------------------------
; Routine: LighteningIn
; Alters: af
;---------------------------------------------------------------------
LighteningIn::
push bc
push de
push hl
ld a,FADEBANK
ld [$ff70],a
;black fg on white background
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld hl,fadeCurPalette
ld bc,$7fff
call SetColor0AllPalettes
ld bc,0
call SetColors123AllPalettes
ld a,128
ldio [paletteBufferReady],a
ld c,7
call .pause
;normal fg on white background
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld hl,fadeCurPalette
ld bc,$7fff
call SetColor0AllPalettes
ld a,128
ldio [paletteBufferReady],a
ld c,3
call .pause
;normal
ld hl,gamePalette
ld de,fadeCurPalette
call FadeCommonCopyPalette
ld a,128
ldio [paletteBufferReady],a
pop hl
pop de
pop bc
ret
.pause call VWait
dec c
jr nz,.pause
ret
;---------------------------------------------------------------------
; Routines: GetRedComponent
; GetGreenComponent
; GetBlueComponent
; SetRedComponent
; SetGreenComponent
; SetBlueComponent
; Arguments: Get: bc - 15 bit BGR value
; Set: bc - 15 bit BGR value, a - value to set
; Returns: Get: a - color component
; Alters: af, bc
;---------------------------------------------------------------------
GetRedComponent::
ld a,c
and %00011111
ret
GetGreenComponent::
push de
ld a,b
IF 1
ld e,c
sla e
rla
sla e
rla
sla e
rla
and %00011111
pop de
ret
ENDC
IF 0
ld e,c
sla e
rl d
sla e
rl d
sla e
rl d
ld a,d
and %00011111
pop de
ret
ENDC
GetBlueComponent::
ld a,b
rrca
rrca
and %00011111
ret
SetRedComponent::
push af
ld a,c
and %11100000
ld c,a
pop af
or c
ld c,a
ret
SetGreenComponent::
push de
ld d,a
rrca
rrca
rrca
and %00000011
ld e,a
ld a,b
and %01111100
or e
ld b,a
ld a,d
swap a
rlca
and %11100000
ld d,a
ld a,c
and %00011111
or d
ld c,a
pop de
ret
SetBlueComponent::
push af
ld a,b
and %00000011
ld b,a
pop af
rlca
rlca
or b
ld b,a
ret
;---------------------------------------------------------------------
; Routine: PlaySound
; Arguments: hl - addr of table 1st byte of which indicates sound
; type (1-4) and remainder is data specific to that
; type.
; Alters: af, hl
;---------------------------------------------------------------------
PlaySound::
ld a,[hl+]
cp 1
jr nz,.check2
xor a
ld [musicOverride1],a
call PlaySoundChannel1
ld a,3
ld [musicOverride1],a
ret
.check2
cp 2
jr nz,.check4
call PlaySoundChannel2
ret
.check4
cp 4
jr nz,.done
xor a
ld [musicOverride4],a
call PlaySoundChannel4
ld a,3
ld [musicOverride4],a
ret
.done
ret
;---------------------------------------------------------------------
; Routine: PlaySoundChannel1
; Arguments: hl - addr of 5 sound bytes for sweep, duty/len,
; envelope, freq_lo, and freq_high
; Alters: af, hl
;---------------------------------------------------------------------
PlaySoundChannel1::
ld a,[musicOverride1]
or a
ret nz
.playSound
ld a,[hl+]
ldio [$ff10],a
ld a,[hl+]
ldio [$ff11],a
ld a,[hl+]
ldio [$ff12],a
ld a,[hl+]
ldio [$ff13],a
ld a,[hl+]
ldio [$ff14],a
ret
;---------------------------------------------------------------------
; Routine: PlaySoundChannel2
; Arguments: hl - addr of 4 sound bytes for duty/len,
; envelope, freq_lo, and freq_high
; Alters: af, hl
;---------------------------------------------------------------------
PlaySoundChannel2::
ld a,[hl+]
ldio [$ff16],a
ld a,[hl+]
ldio [$ff17],a
ld a,[hl+]
ldio [$ff18],a
ld a,[hl+]
ldio [$ff19],a
ret
;---------------------------------------------------------------------
; Routine: PlaySoundChannel3
; Arguments: hl - addr of 4 sound bytes channel 4
; Alters: af, hl
;---------------------------------------------------------------------
PlaySoundChannel3::
ld a,$80
ldio [$ff1a],a
ld a,[hl+]
ldio [$ff1b],a
ld a,[hl+]
ldio [$ff1c],a
ld a,[hl+]
ldio [$ff1d],a
ld a,[hl+]
ldio [$ff1e],a
ret
;---------------------------------------------------------------------
; Routine: PlaySoundChannel4
; Arguments: hl - addr of 4 sound bytes for length, envelope,
; frequency, and consecutive
; Alters: af, hl
;---------------------------------------------------------------------
PlaySoundChannel4::
ld a,[musicOverride4]
or a
ret nz
.playSound
ld a,[hl+]
ldio [$ff20],a
ld a,[hl+]
ldio [$ff21],a
ld a,[hl+]
ldio [$ff22],a
ld a,[hl+]
ldio [$ff23],a
ret
;---------------------------------------------------------------------
; Routine: WaitInput
; Arguments: a - button mask [7:4] buttons, [3:0] dpad
; Alters: af
;---------------------------------------------------------------------
WaitInput::
push bc
push de
ld b,a
.wait
push bc
push hl
call UpdateObjects
call RedrawMap
pop hl
pop bc
ld h,((curJoy0>>8) & $ff)
ld a,[dialogJoyIndex]
add (curJoy0 & $ff)
ld l,a
ld a,[hl]
and b
jr z,.wait
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: WaitInputZero
; Arguments: a - button mask [7:4] buttons, [3:0] dpad
; hl - address of joystick button code to check
; Alters: af
;---------------------------------------------------------------------
WaitInputZero::
push bc
push de
ld b,a
.wait
push bc
push hl
call UpdateObjects
call RedrawMap
pop hl
pop bc
ld a,[hl]
and b
jr nz,.wait
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: WaitInputClick
; Arguments: a - button mask [7:4] buttons, [3:0] dpad
; Alters: af
; Description: WaitInputZero
; WaitInput
; WaitInputZero
;---------------------------------------------------------------------
WaitInputClick::
push bc
push hl
ld b,a
ld hl,myJoy
call WaitInputZero
ld a,b
call WaitInput
ld a,b
call WaitInputZero
pop hl
pop bc
ret
;---------------------------------------------------------------------
; Routine: ResetSprites
; Arguments: none
; Alters: af
; Description: Sets all spritesUsed flags to false and sets each
; sprite y position in the OAM buffer to zero.
;---------------------------------------------------------------------
ResetSprites::
push bc
push de
push hl
;clear sprites used table
ld a,TILEINDEXBANK
ld [$ff70],a
ld hl,spritesUsed
xor a
ld c,40
.clr2 ld [hl+],a
dec c
jr nz,.clr2
;clear sprites
ld hl,spriteOAMBuffer
ld c,40
ld de,3
.clr3
ld [hl+],a
add hl,de
dec c
jr nz,.clr3
xor a
ld [oamFindPos],a
ld a,40
ld [numFreeSprites],a
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: AllocateSprite
; Arguments: none
; Returns: a - 00-9C=success (lowptr), ff=failure
; Alters: af
; Description: Loops through spritesUsed flag table, finds a free
; sprite, and returns that sprite's loPtr.
;---------------------------------------------------------------------
AllocateSprite::
;any free sprites?
ld a,[numFreeSprites]
or a
jr nz,.freeSpriteExists
ld a,$ff
ret
.freeSpriteExists
push bc
push de
push hl
dec a
ld [numFreeSprites],a
;we know there's at least one free sprite so start at
;the the search position (which is guaranteed to be
;<= pos of first free) and loop till we find it
ld a,TILEINDEXBANK
ld [$ff70],a
ld h,((spritesUsed>>8)&$ff)
ld a,[oamFindPos]
ld l,a
.loop ld a,[hl+] ;get sprite used flag
or a
jr nz,.loop ;not free
.foundSprite
dec hl
ld a,1 ;mark sprite as used
ld [hl],a
ld a,l ;return loptr in a
inc a
ld [oamFindPos],a
ld a,l
;change 1-byte offset to 4-byte offset (loPtr)
rlca ;times 2
rlca ;times 2 again
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: FreeSprite
; Arguments: a - loptr to sprite
; Alters: af
; Description: Sets the sprite's YPOS to zero
; Flags the sprite as unused
; oamFindPos = min(thisPos, oamFindPos)
; numFreeSprites++
;---------------------------------------------------------------------
FreeSprite::
;if loptr is $ff then don't bother
cp $ff
ret z
push hl
ld l,a
ld h,((spriteOAMBuffer>>8) & $ff)
xor a
ld [hl],a ;ypos to zero
ld a,TILEINDEXBANK
ld [$ff70],a
rrc l ;convert loptr to sprite index
rrc l
ld h,((spritesUsed>>8) & $ff)
xor a
ld [hl],a ;clear sprite used flag
;set find pos to be mininum
ld a,[oamFindPos]
cp l
jr c,.findPosIsMin
ld a,l
ld [oamFindPos],a
.findPosIsMin
;add one to # of free sprites
ld hl,numFreeSprites
inc [hl]
pop hl
ret
;---------------------------------------------------------------------
; Routine: CreateMetaSprite
; Arguments:
; bc - width (b) and height (c) of metasprite, in 8x8
; tiles.
; d - initial pattern number for first sprite.
; e - default attributes for each sprite.
; hl - ptr to location to store metasprite info. Should
; be w*h + 1 in size.
; [metaSprite_x], [metaSprite_y] - location of TL corner
; Alters: af
;---------------------------------------------------------------------
CreateMetaSprite::
push bc
push de
push hl
ld a,[metaSprite_x]
ld [metaSprite_first_x],a
;calculate width times height
push bc
xor a
.calcTotalSize
add a,b
dec c
jr nz,.calcTotalSize
pop bc
;store total sprites used in metaSpriteInfo
ld [hl+],a
;go through and allocate each sprite, set it up, and store its
;loptr in the metaSpriteInfo
push bc
.height pop af ;setup width from original value
push af
ld b,a
ld a,[metaSprite_first_x]
ld [metaSprite_x],a
.width call AllocateSprite
ld [hl+],a ;save loptr
;set up sprite
push hl
ld l,a
ld h,((spriteOAMBuffer>>8) & $ff)
ld a,[metaSprite_y]
ld [hl+],a
ld a,[metaSprite_x]
ld [hl+],a
add 8
ld [metaSprite_x],a
ld a,d ;pattern number
ld [hl+],a
inc d
ld [hl],e ;attributes
pop hl
dec b
jr nz,.width
ld a,[metaSprite_y]
add 8
ld [metaSprite_y],a
dec c
jr nz,.height
.done
pop bc
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: CreateMetaSpriteUsingMask
; Arguments:
; bc - width (b) and height (c) of metasprite, in 8x8
; tiles.
; d - initial pattern number for first sprite.
; e - default attributes for each sprite.
; hl - ptr to location to store metasprite info. Should
; be w*h + 1 in size and location 1+ should contain
; a zero if its corresponding sprite is not to
; be allocated after all.
; [metaSprite_x], [metaSprite_y] - location of TL corner
; Alters: af
;---------------------------------------------------------------------
CreateMetaSpriteUsingMask::
push bc
push de
push hl
ld a,[metaSprite_x]
ld [metaSprite_first_x],a
;calculate width times height
push bc
xor a
.calcTotalSize
add a,b
dec c
jr nz,.calcTotalSize
pop bc
;store total sprites used in metaSpriteInfo
ld [hl+],a
;go through and allocate each sprite marked with non-zero,
;set it up, and store its loptr in the metaSpriteInfo
push bc
.height pop af ;setup width from original value
push af
ld b,a
ld a,[metaSprite_first_x]
ld [metaSprite_x],a
.width ld a,[hl] ;load flag from destination
or a
ld a,$ff
jr z,.afterAllocate
call AllocateSprite
.afterAllocate
ld [hl+],a ;save loptr
cp $ff
jr z,.afterSetup
;set up sprite
push hl
ld l,a
ld h,((spriteOAMBuffer>>8) & $ff)
ld a,[metaSprite_y]
ld [hl+],a
ld a,[metaSprite_x]
ld [hl+],a
ld a,d ;pattern number
ld [hl+],a
ld [hl],e ;attributes
pop hl
.afterSetup
ld a,[metaSprite_x]
add 8
ld [metaSprite_x],a
inc d
dec b
jr nz,.width
ld a,[metaSprite_y]
add 8
ld [metaSprite_y],a
dec c
jr nz,.height
.done
pop bc
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: ScrollMetaSprite
; Arguments: bc - x (b) and y (c) offset to scroll each sprite.
; hl - ptr to metaSpriteInfo created with
; CreateMetaSprite
; Alters: af
;---------------------------------------------------------------------
ScrollMetaSprite::
push de
ld a,[hl+] ;number of sprites
.loop
push af
ld a,[hl+] ;loptr to sprite
ld e,a
ld d,((spriteOAMBuffer>>8) & $ff)
ld a,[de] ;get the y position
add c ;add y offset
ld [de],a
inc de
ld a,[de] ;get the x position
add b ;add x offset
ld [de],a
inc de
pop af
dec a
jr nz,.loop
pop de
ret
;---------------------------------------------------------------------
; Routine: SetMetaSpritePos
; Arguments: bc - desired x (b) and y (c) pixel position in sprite
; coords
; hl - ptr to metaSpriteInfo created with
; CreateMetaSprite
; Alters: af
;---------------------------------------------------------------------
SetMetaSpritePos::
push bc
push hl
inc hl ;go to y pos of first sprite
ld l,[hl]
ld h,((spriteOAMBuffer>>8) & $ff)
ld a,c ;desired y pos
sub [hl]
ld c,a ;becomes offset to scroll
inc hl
ld a,b
sub [hl]
ld b,a ;becomes offset to scroll
pop hl
call ScrollMetaSprite
pop bc
ret
;---------------------------------------------------------------------
; Routine: FreeMetaSprite
; Arguments: hl - ptr to metaSpriteInfo created with
; CreateMetaSprite
; Alters: af
;---------------------------------------------------------------------
FreeMetaSprite::
push bc
push hl
ld a,[hl+] ;number of sprites
ld c,a
.freeASprite
ld a,[hl+] ;get loptr
call FreeSprite
dec c
jr nz,.freeASprite
pop hl
pop bc
ret
;---------------------------------------------------------------------
; Routine: CreateBigExplosion
; Arguments: bc - tile width and height of explosion area
; d - max sprites (must be >0)
; e - flags for allowed explosion types:
; :0 - small round explosions
; :1 - shrapnel plus
; :2 - big (2x2) round explosions (4 sprites ea)
; hl - TL map corner (e.g. $d0ca) of explosion
; [bulletColor]
; Returns: Nothing.
; Alters: af
; Description: Creates a big explosion of randomly dispersed smaller
; explosions within the given area.
;
;---------------------------------------------------------------------
CreateBigExplosion::
push bc
push de
push hl
;limit the number of sprites according to the system's
;resources
ld a,[numFreeSprites]
cp d
jr nc,.numSpritesOkay
ld d,a
.numSpritesOkay
or a
jr nz,.continue
jp .done
.continue
call ConvertLocHLToXY
ld a,[bulletColor]
.loop ;limit myself to smaller explosions if I have less than 4
;sprites left
push af
push hl
ld a,d
cp 4
jr nc,.afterLimitToSmaller
res 2,e ;remove larger fr possible explosions flags
ld a,e
or a
jr nz,.afterLimitToSmaller
ld d,1
jr .afterCreateExplosion
.afterLimitToSmaller
;select random tile position within area
;width
ld a,b
dec a
call GetRandomNumZeroToN
add h
ld h,a
;height
ld a,c
dec a
call GetRandomNumZeroToN
add l
ld l,a
call ConvertXYToLocHL
ld a,l
ld [bulletLocation],a
ld a,h
ld [bulletLocation+1],a
;choose random explosion
ld a,e
call GetRandomNumMask
bit 2,a
jr z,.checkType1
.isType2
bit 2,e ;this type allowed?
jr z,.isType0
;type two - big 2x2 explosion
ld a,6
ld [bulletColor],a
push bc
ld b,32
call .create2x2Frame
inc hl
call .create2x2Frame
push de
ld d,0
ld a,[mapPitch]
ld e,a
add hl,de
pop de
dec hl
call .create2x2Frame
inc hl
call .create2x2Frame
pop bc
dec d
dec d
dec d
jr .afterCreateExplosion
.checkType1
bit 1,a
jr z,.isType0
.isType1
bit 1,e ;this type allowed?
jr z,.isType2
;type one - shrapnel
ld a,64
jr .determinedFrame
.isType0 ;default
bit 0,e ;this type allowed?
jr z,.isType1
;type zero - small round explosion
ld a,5
ld [bulletColor],a
ld a,16
.determinedFrame
push bc
ld b,a
call CreateExplosion
call .offsetSprite
pop bc
.afterCreateExplosion
pop hl
.beforeRestoreColor
pop af
ld [bulletColor],a
dec d
jr z,.done
jp .loop
.done
pop hl
pop de
pop bc
ret
.offsetSprite
or a
ret z
push de
push hl
call IndexToPointerHL ;get ptr to explosion class
ld a,OBJBANK
ldio [$ff70],a
ld de,OBJ_SPRITELO
add hl,de
ld l,[hl]
ld h,((spriteOAMBuffer>>8) & $ff)
ld a,%111
call GetRandomNumMask
add [hl]
ld [hl+],a
ld a,%111
call GetRandomNumMask
add [hl]
ld [hl],a
pop hl
pop de
ret
.create2x2Frame
ld a,l
ld [bulletLocation],a
ld a,h
ld [bulletLocation+1],a
call CreateExplosion
ld a,b
add 8
ld b,a
ret
;---------------------------------------------------------------------
; Routine: BlitMap
; Arguments: bc - tile width and height of area to copy
; de - destination XY coords
; hl - source XY coords
; Returns: Nothing.
; Alters: af
; Description: Copies a section of the current map, not overwriting
; any objects
;---------------------------------------------------------------------
BlitMap::
push bc
push de
push hl
push hl
ld h,d
ld l,e
call ConvertXYToLocHL
ld d,h
ld e,l
pop hl
call ConvertXYToLocHL
ld a,MAPBANK
ldio [$ff70],a
.blitMapOuter
push bc
push de
push hl
ldio a,[firstMonster]
ld c,a
.blitMapInner
ld a,[de]
cp c ;< first monster?
jr nc,.blitSkip
ld a,[hl]
ld [de],a
.blitSkip
inc hl
inc de
dec b
jr nz,.blitMapInner
pop hl
pop de
push hl
ld a,[mapPitch]
ld h,0
ld l,a
add hl,de
ld d,h
ld e,l
pop hl
ld a,[mapPitch]
ld b,0
ld c,a
add hl,bc
pop bc
dec c
jr nz,.blitMapOuter
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: ConvertLocHLToXY
; Arguments: hl - location ($D000-$DFFF)
; Returns: hl - h = x index, l = y index
; Alters: a,hl
; Description: x = location & (pitch-1)
; y = (location - $D000) / pitch
;---------------------------------------------------------------------
ConvertLocHLToXY::
ld a,[mapPitchMinusOne]
and l
push af ;push a (x index) on stack
ld a,h ;subtract $D000 from hl by adding $3000
add $30
ld h,a
ld a,[mapPitchMinusOneComplement] ;times to left-shift
.shift rlca ;shift a bit left out of a
jr nc,.shiftDone ;hl<<=1 if bits left in a
sla l
rl h
jr .shift
.shiftDone
ld l,h
pop af
ld h,a ;h = x index, l = y index
ret
;---------------------------------------------------------------------
; Routine: ConvertXYToLocHL
; Arguments: hl - h = x index, l = y index
; Returns: hl - location ptr ($D000-$DFFF)
; Alters: a,hl
; Description: hl = $d000 + (y * pitch) + x
; Instead of having y in the LoByte and left-shifting it
; by the bits in the pitch, we'll put y in the HiByte
; and right-shift it by 8-bitsInPitch. Fewer ops.
;---------------------------------------------------------------------
ConvertXYToLocHL::
push de
;multiply y*pitch
ld a,[mapPitchMinusOneComplement]
ld d,l
ld e,0
.shift rlca ;if bits left in A then keep shifting
jr nc,.shiftDone
srl d
rr e
jr .shift
.shiftDone
ld l,h ;add x + $d000
ld h,$d0
add hl,de
pop de
ret
;---------------------------------------------------------------------
; Routine: LCheckGetVectorToState
; Arguments: hl - address of method table
; Returns: hl - methodTable[mapState]
; Alters: af,hl
; Description: Use the VECTORTOSTATE macro.
;---------------------------------------------------------------------
LCheckGetVectorToState::
push de
ldio a,[mapState]
ld d,0
ld e,a
sla e
rl d
add hl,de
pop de
ld a,[hl+]
ld h,[hl]
ld l,a
ret
;---------------------------------------------------------------------
; Routine: SaveIdle
; Arguments: None.
; Returns:
; Alters: af,hl
; Description: Saves the current state of [heroesIdle] and [allIdle]
; in [dialogIdleSettings] and activates both idle
; settings
;---------------------------------------------------------------------
SaveIdle::
ld a,[heroesIdle]
rlca
ld hl,allIdle
or [hl]
ld [dialogIdleSettings],a
ld a,1
ld [heroesIdle],a
ld [allIdle],a
ret
;---------------------------------------------------------------------
; Routine: RestoreIdle
; Arguments: None.
; Returns:
; Alters: af,hl
; Description: Restores the idle settings to what they were previous
; to SaveIdle
;---------------------------------------------------------------------
RestoreIdle::
ld a,[dialogIdleSettings]
push af
and 1
ld [allIdle],a
pop af
srl a
ld [heroesIdle],a
ret
;---------------------------------------------------------------------
; Routine: MakeIdle
; Arguments: None.
; Returns:
; Alters: af
; Description: Sets [heroesIdle] and [allIdle] to 1
;---------------------------------------------------------------------
MakeIdle::
ld a,1
ld [heroesIdle],a
ld [allIdle],a
ret
;---------------------------------------------------------------------
; Routine: MakeNonIdle
; Arguments: None.
; Returns:
; Alters: af
; Description: Sets [heroesIdle] and [allIdle] to 0
;---------------------------------------------------------------------
MakeNonIdle::
xor a
ld [heroesIdle],a
ld [allIdle],a
ret
;---------------------------------------------------------------------
; Routine: UseAlternatePalette
; Arguments: None.
; Returns: Nothing.
; Alters: af
; Description: Darkens colors 1 & 2 of each palette, intended for
; use on the light-background maps.
;---------------------------------------------------------------------
UseAlternatePalette::
push bc
push hl
ld a,FADEBANK
ldio [$ff70],a
ld c,16
ld hl,gamePalette+2
.loop call .halve
call .halve
inc hl
inc hl
inc hl
inc hl
dec c
jr nz,.loop
pop hl
pop bc
ret
.halve
ld a,[hl+] ;color[i]>>=1;
ld b,a
ld a,[hl]
rrca
rr b
and %00111101
ld [hl-],a
ld a,b
and %11101111
ld [hl+],a
inc hl
ret
;---------------------------------------------------------------------
; Routine: GetMyHero
; Arguments: None.
; Returns: a - class index of local hero (i.e. not remote)
; hl - pointer to hero0_data or hero1_data approprately
; Alters: af, hl
;---------------------------------------------------------------------
GetMyHero::
ld a,[amLinkMaster]
cp 0
jr z,.getHero1
;get hero zero if link master
ld a,[hero0_index]
ld hl,hero0_data
ret
.getHero1
ld a,[hero1_index]
ld hl,hero1_data
ret
;---------------------------------------------------------------------
; Routine: GetBGAttributes
; Arguments: a - class index
; Alters: af
; Returns: a - attributes for given class index
; Returns full set off attributes including:
; [2:0] - color FLAG_PALETTE
; [3] - can walk over FLAG_WALKOVER
; [4] - can shoot over FLAG_SHOOTOVER
;---------------------------------------------------------------------
GetBGAttributes::
push hl
ld l,a
ld h,((bgAttributes>>8) & $ff)
ld a,TILEINDEXBANK
ldio [$ff70],a
ld a,[hl]
pop hl
ret
;---------------------------------------------------------------------
; Routine: UpdateDialogBalloons
; Arguments: de - intial pos in [spritesUsed]
; hl - initial pos in spriteOAMBuffer
; Alters: af, de, hl
;---------------------------------------------------------------------
UpdateDialogBalloons::
ld a,[amShowingDialog]
or a
ret nz ;no balloons during dialog
ldio a,[updateTimer]
and %00010000
ret z ;all blank
push bc
call FindNextFreeSprite
jr z,.done
ld a,[dialogBalloonClassIndex]
ld c,a
call GetFirst
.setNextBalloon
or a
jr z,.done
call PutBalloonAboveObject
;remake de from hl
push de
inc hl
inc hl
inc hl
inc hl
call .remakeDEfromHL
call FindNextFreeSprite
pop de
jr z,.done
call GetNextObject
jr .setNextBalloon
.done
call .remakeDEfromHL
pop bc
ret
.remakeDEfromHL
ld a,l ;e = l/4
rrca
rrca
ld e,a
ld d,((spritesUsed>>8)&$ff)
ret
;---------------------------------------------------------------------
; Routine: DisableDialogBalloons
; Arguments: a - mask of objects (up to 8) to disable. %101
; would disable the first and third speakers, etc.
; Speakers after the eigth are disabled.
; Alters: af
;---------------------------------------------------------------------
DisableDialogBalloons::
push bc
push de
push hl
ld b,a
ld a,[dialogBalloonClassIndex]
or a
jr z,.done
ld c,a
call GetFirst
.disableNext
or a
jr z,.done
ld a,b
or a
jr z,.disableAfter8
and 1
jr z,.continue
ld a,1
call SetMisc
.continue
srl b
call GetNextObject
jr .disableNext
.disableAfter8
ld b,8
ld a,[dialogBalloonClassIndex]
ld c,a
call GetFirst
.find9th
or a
jr z,.done
call GetNextObject
dec b
jr nz,.find9th
.disableAfter8Next
or a
jr z,.done
ld a,1
call SetMisc
call GetNextObject
jr .disableAfter8Next
.done
pop hl
pop de
pop bc
ret
;---------------------------------------------------------------------
; Routine: FindNextFreeSprite
; Arguments: de - ptr to position within spritesUsed to begin
; resetting
; hl - ptr to sprite OAM buffer corresponding to
; de
; Alters: af,de,hl
; Returns: a - 0 on failure
;---------------------------------------------------------------------
FindNextFreeSprite:
ld a,e
cp 40
jr nc,.notFound
push bc
ld a,TILEINDEXBANK
ldio [$ff70],a
ld bc,4
.checkNext
ld a,[de]
or a
jr z,.foundIt
inc de
add hl,bc
ld a,e
cp 40
jr c,.checkNext
pop bc
.notFound
xor a
ret
.foundIt
ld a,1
or a
pop bc
ret
;---------------------------------------------------------------------
; Routine: PutBalloonAboveObject
; Arguments: de - ptr to object
; hl - ptr to sprite OAM buffer
; Alters: af
;---------------------------------------------------------------------
PutBalloonAboveObject:
push de
push hl
ld [hl],0 ;zero sprite in case we don't use it
push hl
call GetMisc
pop hl
or a
jr nz,.done ;already spoke
call GetCurLocation
call ConvertLocHLToSpriteCoords
ld d,h
ld e,l
pop hl
push hl
ld a,e
or a
jr z,.afterAdjustCoords ;leave zero at zero
sub 8
ld e,a
ld a,d
add 8
ld d,a
.afterAdjustCoords
ld [hl],e ;y coord
inc hl
ld [hl],d ;x coord
inc hl
ld a,80 ;pattern number
ld [hl+],a
xor a
ld [hl],a ;palette/etc
.done
pop hl
pop de
ret
;---------------------------------------------------------------------
; Routine: ResetFreeSprites
; Arguments: de - ptr to position within spritesUsed to begin
; resetting
; hl - ptr to sprite OAM buffer corresponding to
; de
; Alters: af,de,hl
; Returns: Nothing.
; Description: Sets y=0 of all sprites after initial position not
; flagged as in use; necessary for resetting
; environmental effects
;---------------------------------------------------------------------
ResetFreeSprites::
ld a,e
cp 40
ret nc
push bc
ld a,TILEINDEXBANK
ldio [$ff70],a
ld bc,4
.resetNext
ld a,[de]
or a
jr nz,.afterReset
ld [hl],a ;ypos = 0
.afterReset
add hl,bc
inc de
ld a,e
cp 40
jr c,.resetNext
pop bc
ret
;---------------------------------------------------------------------
; Routine: SetEnvEffect
; Arguments: a - env effect such as ENV_RAIN
; Alters: af
; Returns: Nothing.
; Description: Sets an environmental effect and quickly updates it
; a number of times to be in full swing by the time
; the player sees it
;---------------------------------------------------------------------
SetEnvEffect::
push bc
ld [envEffectType],a
ld c,16
.updateEffect
call UpdateEnvEffect
dec c
jr nz,.updateEffect
pop bc
ret
;---------------------------------------------------------------------
; Routine: UpdateEnvEffect
; Arguments: None.
; Alters: af
; Returns: Nothing.
; Description: Sets unused sprites to be dialog/rain/snow etc based
; on [envEffectType]. Calls UpdateDialogBalloons and
; ResetFreeSprites
;---------------------------------------------------------------------
UpdateEnvEffect::
push bc
push de
push hl
ld de,spritesUsed
ld hl,spriteOAMBuffer
ld c,0
ld a,[dialogBalloonClassIndex]
or a
jr z,.afterUpdateBalloons
inc c
call nz,UpdateDialogBalloons
.afterUpdateBalloons
ld a,[envEffectType]
or a
jr z,.afterEffect
ldio a,[randomLoc]
push af
ld a,[asyncRandLoc]
ldio [randomLoc],a
ld a,[envEffectType]
call .updateAppropriate
ldio a,[randomLoc]
ldio [asyncRandLoc],a
pop af
ldio [randomLoc],a
.afterEffect
call ResetFreeSprites
pop hl
pop de
pop bc
ret
.updateAppropriate
inc c
cp ENV_RAIN
jr nz,.checkSnow
ld d,e
LONGCALLNOARGS EnvRain
ret
.checkSnow
cp ENV_SNOW
jr nz,.checkDirt
ld d,e
LONGCALLNOARGS EnvSnow
ret
.checkDirt
cp ENV_DIRT
jr nz,.checkClouds
ld d,e
LONGCALLNOARGS EnvDirt
ret
.checkClouds
cp ENV_CLOUDS
jr nz,.checkWindySnow
ld d,e
LONGCALLNOARGS EnvClouds
ret
.checkWindySnow
cp ENV_WINDYSNOW
jr nz,.checkCounter
ld d,e
LONGCALLNOARGS EnvWindySnow
ret
.checkCounter
cp ENV_COUNTER
jr nz,.checkDisco
;reset first two sprites to y=16
ld hl,spriteOAMBuffer
ld de,4
ld [hl],16
add hl,de
ld [hl],16
ret
.checkDisco
cp ENV_DISCO
ret nz
LONGCALLNOARGS EnvDisco
ret
;---------------------------------------------------------------------
SECTION "GfxSupport",ROMX
;---------------------------------------------------------------------
EnvRain:
call EnvSetupDEHL
ld b,0
.nextDrop
call FindNextFreeSprite
ret z
inc b
ld a,[hl]
or a
jr nz,.updatePosition
.newDrop
;create new raindrop
ld a,63
call GetRandomNumMask
cpl
add 16
ld [hl+],a ;ypos
ld a,255
call GetRandomNumMask
;add 8
;ld [hl],a
;ld a,63
;call GetRandomNumMask
;add [hl]
;sub 64
ld [hl+],a ;xpos
ld [hl],81 ;pattern
inc hl
ld [hl],2 ;palette
inc hl
inc de
jr .nextDrop
.updatePosition
ld a,[hl]
add 8
ld [hl],a
and 184
cp 184
jr nz,.afterRemove
.remove
ld [hl],0
.afterRemove
inc hl
ld a,[hl]
add 4
ld [hl+],a
ld a,[hl+]
cp 81 ;rain pattern
jr z,.dropOkay
;change into a rain sprite
dec hl
ld [hl],81
inc hl
ld [hl],2
;push hl
;dec hl
;dec hl
;ld [hl],0 ;reset sprite
;pop hl
.dropOkay
inc hl
inc de
jp .nextDrop
EnvSnow:
call EnvSetupDEHL
ld b,0
.nextFlake
call FindNextFreeSprite
ret z
inc b
ld a,[hl]
or a
jr nz,.updatePosition
.newFlake
;create new snowflake
ld a,63
call GetRandomNumMask
cpl
add 16
ld [hl+],a ;ypos
ld a,255
call GetRandomNumMask
;add 8
;ld [hl],a
;ld a,63
;call GetRandomNumMask
;add [hl]
;sub 10
ld [hl+],a ;xpos
ld [hl],74 ;pattern
inc hl
ld [hl],0 ;palette
inc hl
inc de
jr .nextFlake
.updatePosition
ld a,[hl]
;add 4
inc a
ld [hl],a
and 184
cp 184
jr nz,.afterRemove
.remove
ld [hl],0
.afterRemove
;get deltax offset for this flake mem loc + y loc
ld a,l
rrca
rrca
add [hl] ;plus y coord
and 63
push hl
add (flakeSineTable & $ff)
ld l,a
ld a,0
adc ((flakeSineTable>>8)&$ff)
ld h,a
ld a,[hl]
pop hl
inc hl
add [hl]
ld [hl+],a ;new x coord
ld a,[hl+]
cp 74 ;flake pattern
jr z,.flakeOkay
;change into a snowflake sprite
dec hl
ld [hl],74
inc hl
ld [hl],0
;push hl
;dec hl
;dec hl
;ld [hl],0 ;reset sprite
;pop hl
.flakeOkay
inc hl
inc de
jp .nextFlake
EnvDirt:
call EnvSetupDEHL
ld b,0
.nextGrit
call FindNextFreeSprite
ret z
inc b
ld a,[hl]
or a
jr nz,.updatePosition
.newGrit
;create new sand
ld a,127
call GetRandomNumMask
ld [hl],a ;ypos
ld a,31
call GetRandomNumMask
add [hl]
sub 10
ld [hl+],a
ld a,63
call GetRandomNumMask
cpl
add 8
ld [hl+],a ;xpos
ld [hl],72 ;pattern
inc hl
ld [hl],6 ;palette
inc hl
inc de
jr .nextGrit
.updatePosition
ld a,l ;y += (-1,0,1,2)
rrca
rrca
and %11
sub 1
add [hl]
ld [hl+],a
ld a,[hl]
add 8
ld [hl+],a
and 184
cp 184
jr nz,.afterRemove
.remove
push hl
dec hl
dec hl
ld [hl],0
pop hl
.afterRemove
ld a,[hl+]
cp 72 ;grit pattern
jr z,.gritOkay
push hl
dec hl
dec hl
dec hl
ld [hl],0 ;reset sprite
pop hl
.gritOkay
inc hl
inc de
jp .nextGrit
EnvWindySnow:
call EnvSetupDEHL
ld b,0
.nextFlake
call FindNextFreeSprite
ret z
inc b
ld a,[hl]
or a
jr nz,.updatePosition
.newFlake
;create new flake
ld a,127
call GetRandomNumMask
ld [hl],a ;ypos
ld a,31
call GetRandomNumMask
add [hl]
sub 10
ld [hl+],a
ld a,63
call GetRandomNumMask
cpl
add 168
ld [hl+],a ;xpos
ld [hl],74 ;pattern
inc hl
ld [hl],0 ;palette
inc hl
inc de
jr .nextFlake
.updatePosition
ld a,l ;y += (-1,0,1,2)
rrca
rrca
and %11
sub 1
add [hl]
ld [hl+],a
ld a,[hl]
sub 8
ld [hl+],a
and 248
cp 248
jr nz,.afterRemove
.remove
push hl
dec hl
dec hl
ld [hl],0
pop hl
.afterRemove
ld a,[hl+]
cp 74 ;flake pattern
jr z,.flakeOkay
;change into a snowflake sprite
dec hl
ld [hl],74
inc hl
ld [hl],0
;push hl
;dec hl
;dec hl
;dec hl
;ld [hl],0 ;reset sprite
;pop hl
.flakeOkay
inc hl
inc de
jp .nextFlake
EnvClouds:
call EnvSetupDEHL
ld b,0
.nextCloud
call FindNextFreeSprite
ret z
inc b
ld a,[hl]
or a
jr nz,.updatePosition
ld a,b
and %11
jr nz,.addToCloud
;one in 8 chance of creating a cloud
ld a,1
call GetRandomNumMask
or a
jr z,.newCloud
inc hl
inc hl
inc hl
inc hl
inc de
jr .nextCloud
.newCloud
;create new cloud
ld a,144
call GetRandomNumZeroToN
add 16
ld [hl+],a ;ypos
ld [$c01e],a
ld a,63
call GetRandomNumMask
cpl
ld [hl+],a ;xpos
ld [$c01f],a
ld a,3
call GetRandomNumMask
add 82
ld [hl+],a ;pattern
ld [hl],4 ;palette
inc hl
inc de
jr .nextCloud
.addToCloud
push de
ld a,7
call GetRandomNumMask
ld d,a
ld a,[$c01e]
add d
ld [hl+],a ;ypos
ld a,7
call GetRandomNumMask
ld d,a
ld a,[$c01f]
add d
ld [hl+],a ;xpos
ld a,3
call GetRandomNumMask
add 82
ld [hl+],a ;pattern
ld [hl],4 ;palette
inc hl
pop de
inc de
jr .nextCloud
.updatePosition
inc hl
;bit 2,l
;jr z,.updateOnTimer
jr .updateOnTimer
inc [hl]
jr .afterIncr
.updateOnTimer
ldio a,[updateTimer]
and 1
jr z,.afterIncr
inc [hl]
.afterIncr
ld a,[hl]
cp 178
jr nz,.afterRemove
dec hl
ld [hl],0
inc hl
.afterRemove
inc hl
inc hl
inc hl
inc de
jp .nextCloud
EnvSetupDEHL:
ld d,((spritesUsed>>8)&$ff)
ld a,e
rlca
rlca
ld l,a
ld h,((spriteOAMBuffer>>8)&$ff)
ret
flakeSineTable:
DB $ff,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
DB 0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0
DB 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,$ff
DB 0,0,$ff,0,0,$ff,0,0,$ff,0,$ff,0,0,$ff,0,0
;---------------------------------------------------------------------
; EnvDisco
; Uses binary data "discoLights" to set all colors to purple in
; drawing buffer except where lights are flashing. Uses levelVars[0]
; to determine current frame
;---------------------------------------------------------------------
EnvDisco:
push bc
push de
push hl
;setup hl to point to light data for appropriate frame
ld de,20*18
ld hl,discoLights
ld a,[levelVars]
or a
jr z,.frameSet
.times360
add hl,de
dec a
jr nz,.times360
.frameSet
ld de,attributeBuffer
ld b,18 ;18 rows
.outer
ld c,20 ;20 columns
.inner
ld a,[hl+]
or a
jr nz,.afterSetColor
ld a,[de]
or %111
ld [de],a
.afterSetColor
inc de
dec c
jr nz,.inner
push hl
ld hl,12
add hl,de
ld d,h
ld e,l
pop hl
dec b
jr nz,.outer
pop hl
pop de
pop bc
ret
discoLights:
INCBIN "Data/discolights.dat"
;Not in HOME
;---------------------------------------------------------------------
[Refactor] Fully building - Font data now aligned properly in memory
2020-06-15 06:19:36 +01:00
SECTION "FontSection",ROMX,BANK[MAP0ROM],ALIGN[4]
[Refactor] Basic source code organization
2020-05-31 04:23:06 +01:00
fontData:
INCBIN "Data/font.bin"
blankTileData:
DW 0,0,0,0,0,0,0,0
explosionSprites:
INCBIN "Data/Sprites/explosions0-85.bin"
SECTION "ReservedSpriteDMAHandler",HRAM[$FF80]
SpriteDMAHandler::
DS (oamHandlerFinish - oamHandlerStart)
;---------------------------------------------------------------------
SECTION "GfxSupportSection",ROMX[$4000]
;---------------------------------------------------------------------
;$4000
randomTable:
DB $9f,$d2,$e6,$e7,$70,$db,$11,$63,$6b,$37,$99,$98,$30,$9c,$d9,$35
DB $65,$af,$56,$ee,$b1,$00,$fd,$c7,$61,$48,$df,$45,$2e,$41,$6d,$9b
DB $13,$40,$d8,$fa,$91,$02,$29,$e0,$cb,$5d,$28,$fb,$2f,$77,$ea,$f9
DB $7e,$92,$5b,$75,$b5,$fc,$ae,$a2,$71,$cc,$a9,$3f,$7f,$7d,$ad,$7c
DB $73,$a5,$f8,$03,$9e,$25,$f6,$e8,$4d,$33,$b3,$44,$aa,$26,$08,$6e
DB $82,$97,$96,$19,$c8,$b4,$ba,$d3,$1f,$d0,$f5,$06,$54,$86,$49,$e2
DB $69,$43,$0b,$b0,$f1,$83,$a8,$9d,$38,$42,$ef,$e4,$74,$12,$20,$a0
DB $55,$01,$66,$23,$3d,$51,$c0,$79,$10,$de,$eb,$d5,$09,$8e,$5e,$67
DB $4a,$7a,$3e,$4b,$68,$8d,$e9,$62,$1b,$dd,$da,$bb,$53,$22,$3c,$b6
DB $ff,$81,$24,$8b,$d4,$6f,$d7,$9a,$d6,$21,$f4,$0a,$b2,$bc,$a7,$36
DB $34,$64,$c5,$a6,$4e,$b9,$f3,$0e,$f0,$3b,$cd,$0d,$17,$ec,$1a,$8a
DB $e3,$16,$93,$05,$c9,$14,$c1,$cf,$52,$2c,$1e,$bf,$88,$27,$1d,$f7
DB $5c,$ac,$ab,$3a,$bd,$a1,$f2,$04,$e5,$2d,$e1,$c2,$15,$fe,$8c,$6a
DB $2b,$84,$1c,$d1,$47,$c6,$58,$c3,$0f,$ce,$5f,$90,$8f,$76,$60,$0c
DB $94,$2a,$6c,$89,$39,$46,$18,$95,$7b,$dc,$b7,$72,$78,$5a,$57,$ca
DB $4f,$a4,$59,$07,$32,$c4,$ed,$b8,$50,$85,$a3,$31,$4c,$87,$80,$be
;0=star 1=moon 2=flower 3=crouton 4=i 5=monkey 6=wrench 7=man
;$4100
init_flightCodes:
DB $0f
DB $00,$00,$06
DB $00,$00,$23
DB $00,$00,$29
DB $00,$00,$3a
DB $00,$00,$47
DB $00,$00,$59
DB $00,$00,$66
DB $00,$00,$a3
DB $00,$00,$a8
DB $00,$00,$0a
DB $00,$00,$3d
DB $63,$02,$71 ;initial landing star flower wrench crouton
DB $33,$53,$81 ;mouse landing monkey crouton crouton crouton
DB $65,$70,$c7 ;farm landing man star wrench monkey
DB $12,$01,$55 ;palace star moon moon flower
DB $00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
DB $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00