mirror of
https://github.com/pret/pokeyellow.git
synced 2026-05-11 21:29:31 -05:00
1061 lines
24 KiB
NASM
1061 lines
24 KiB
NASM
UpdatePlayerSprite: ; 4da5 (1:4da5)
|
|
ld a, [wSpriteStateData2]
|
|
and a
|
|
jr z, .checkIfTextBoxInFrontOfSprite
|
|
cp $ff
|
|
jr z, .disableSprite
|
|
dec a
|
|
ld [wSpriteStateData2], a
|
|
jr .disableSprite
|
|
; check if a text box is in front of the sprite by checking if the lower left
|
|
; background tile the sprite is standing on is greater than $5F, which is
|
|
; the maximum number for map tiles
|
|
.checkIfTextBoxInFrontOfSprite
|
|
aCoord 8, 9
|
|
ld [hTilePlayerStandingOn], a
|
|
cp $60
|
|
jr c, .lowerLeftTileIsMapTile
|
|
.disableSprite
|
|
ld a, $ff
|
|
ld [wSpriteStateData1 + 2], a
|
|
ret
|
|
.lowerLeftTileIsMapTile
|
|
ld a, [wUpdateSpritesEnabled]
|
|
push af
|
|
ld a, $ff
|
|
ld [wUpdateSpritesEnabled], a
|
|
call DetectCollisionBetweenSprites
|
|
pop af
|
|
ld [wUpdateSpritesEnabled], a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [wWalkCounter]
|
|
and a
|
|
jr nz, .moving
|
|
ld a, [wPlayerMovingDirection]
|
|
; check if down
|
|
bit PLAYER_DIR_BIT_DOWN, a
|
|
jr z, .checkIfUp
|
|
xor a ; ld a, SPRITE_FACING_DOWN
|
|
jr .next
|
|
.checkIfUp
|
|
bit PLAYER_DIR_BIT_UP, a
|
|
jr z, .checkIfLeft
|
|
ld a, SPRITE_FACING_UP
|
|
jr .next
|
|
.checkIfLeft
|
|
bit PLAYER_DIR_BIT_LEFT, a
|
|
jr z, .checkIfRight
|
|
ld a, SPRITE_FACING_LEFT
|
|
jr .next
|
|
.checkIfRight
|
|
bit PLAYER_DIR_BIT_RIGHT, a
|
|
jr z, .notMoving
|
|
ld a, SPRITE_FACING_RIGHT
|
|
jr .next
|
|
.next
|
|
ld [wSpriteStateData1 + 9], a ; facing direction
|
|
ld a, [wFontLoaded]
|
|
bit 0, a
|
|
jr z, .moving
|
|
.notMoving
|
|
; zero the animation counters
|
|
xor a
|
|
ld [wSpriteStateData1 + 7], a
|
|
ld [wSpriteStateData1 + 8], a
|
|
call Func_4e32
|
|
jr .skipSpriteAnim
|
|
.moving
|
|
ld a, [wd736]
|
|
bit 7, a ; is the player sprite spinning due to a spin tile?
|
|
jr nz, .skipSpriteAnim
|
|
call Func_5274
|
|
call Func_4e32
|
|
.skipSpriteAnim
|
|
; If the player is standing on a grass tile, make the player's sprite have
|
|
; lower priority than the background so that it's partially obscured by the
|
|
; grass. Only the lower half of the sprite is permitted to have the priority
|
|
; bit set by later logic.
|
|
ld a, [hTilePlayerStandingOn]
|
|
ld c, a
|
|
ld a, [wGrassTile]
|
|
cp c
|
|
ld a, $0
|
|
jr nz, .next2
|
|
ld a, $80
|
|
.next2
|
|
ld [wSpriteStateData2 + $07], a
|
|
ret
|
|
|
|
Func_4e32: ; 4e32 (1:4e32)
|
|
ld a, [wSpriteStateData1 + 8]
|
|
ld b, a
|
|
ld a, [wSpriteStateData1 + 9]
|
|
add b
|
|
ld [wSpriteStateData1 + 2], a
|
|
ret
|
|
|
|
UpdateNPCSprite: ; 4e3e (1:4e3e)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
swap a
|
|
dec a
|
|
add a
|
|
ld hl, wMapSpriteData
|
|
add l
|
|
ld l, a
|
|
ld a, [hl] ; read movement byte 2
|
|
ld [wCurSpriteMovement2], a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
inc l
|
|
ld a, [hl] ; c1x1
|
|
and a
|
|
jp z, InitializeSpriteStatus
|
|
call CheckSpriteAvailability
|
|
ret c ; if sprite is invisible, on tile >=$60, in grass or player is currently walking
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
inc l
|
|
ld a, [hl] ; c1x1
|
|
bit 7, a
|
|
jp nz, InitializeSpriteFacingDirection ; c1x1 >= $80
|
|
ld b, a
|
|
ld a, [wFontLoaded]
|
|
bit 0, a
|
|
jp nz, notYetMoving
|
|
ld a, b
|
|
cp $2
|
|
jp z, UpdateSpriteMovementDelay ; c1x1 == 2
|
|
cp $3
|
|
jp z, UpdateSpriteInWalkingAnimation ; c1x1 == 3
|
|
cp $4
|
|
jp z, Func_5357
|
|
ld a, [wWalkCounter]
|
|
and a
|
|
ret nz ; don't do anything yet if player is currently moving (redundant, already tested in CheckSpriteAvailability)
|
|
call InitializeSpriteScreenPosition
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $6
|
|
ld l, a
|
|
ld a, [hl] ; c2x6: movement byte 1
|
|
inc a
|
|
jp z, .randomMovement ; value $FF
|
|
inc a
|
|
jp z, .randomMovement ; value $FE
|
|
; scripted movement
|
|
dec a
|
|
ld [hl], a ; increment movement byte 1 (movement data index)
|
|
dec a
|
|
push hl
|
|
ld hl, wNPCNumScriptedSteps
|
|
dec [hl] ; decrement wNPCNumScriptedSteps
|
|
pop hl
|
|
ld de, wNPCMovementDirections
|
|
call LoadDEPlusA ; a = [wNPCMovementDirections + movement byte 1]
|
|
cp $e0
|
|
jp z, ChangeFacingDirection
|
|
cp $ff
|
|
jr nz, .next
|
|
; reached end of wNPCMovementDirections list
|
|
ld [hl], a ; store $ff in movement byte 1, disabling scripted movement
|
|
ld hl, wd730
|
|
res 0, [hl]
|
|
xor a
|
|
ld [wSimulatedJoypadStatesIndex], a
|
|
ld [wWastedByteCD3A], a
|
|
ret
|
|
.next
|
|
cp $fe
|
|
jr nz, .asm_4ecb
|
|
; current NPC movement data is $fe. this seems buggy
|
|
ld [hl], $1 ; set movement byte 1 to $1
|
|
ld de, wNPCMovementDirections
|
|
call LoadDEPlusA ; a = [wNPCMovementDirections + $fe] (?)
|
|
.asm_4ecb
|
|
push af
|
|
call Func_5288
|
|
pop bc
|
|
ld a, b
|
|
jr nc, .determineDirection
|
|
ret
|
|
.randomMovement
|
|
call GetTileSpriteStandsOn
|
|
call Random
|
|
.determineDirection
|
|
ld b, a
|
|
ld a, [wCurSpriteMovement2]
|
|
cp $d0
|
|
jr z, .moveDown ; movement byte 2 = $d0 forces down
|
|
cp $d1
|
|
jr z, .moveUp ; movement byte 2 = $d1 forces up
|
|
cp $d2
|
|
jr z, .moveLeft ; movement byte 2 = $d2 forces left
|
|
cp $d3
|
|
jr z, .moveRight ; movement byte 2 = $d3 forces right
|
|
ld a, b
|
|
cp $40 ; a < $40: down (or left)
|
|
jr nc, .notDown
|
|
ld a, [wCurSpriteMovement2]
|
|
cp $2
|
|
jr z, .moveLeft ; movement byte 2 = $2 only allows left or right
|
|
.moveDown
|
|
ld de, 2*SCREEN_WIDTH
|
|
add hl, de ; move tile pointer two rows down
|
|
lb de, 1, 0
|
|
lb bc, 4, SPRITE_FACING_DOWN
|
|
jr TryWalking
|
|
.notDown
|
|
cp $80 ; $40 <= a < $80: up (or right)
|
|
jr nc, .notUp
|
|
ld a, [wCurSpriteMovement2]
|
|
cp $2
|
|
jr z, .moveRight ; movement byte 2 = $2 only allows left or right
|
|
.moveUp
|
|
ld de, -2*SCREEN_WIDTH
|
|
add hl, de ; move tile pointer two rows up
|
|
lb de, -1, 0
|
|
lb bc, 8, SPRITE_FACING_UP
|
|
jr TryWalking
|
|
.notUp
|
|
cp $c0 ; $80 <= a < $c0: left (or up)
|
|
jr nc, .notLeft
|
|
ld a, [wCurSpriteMovement2]
|
|
cp $1
|
|
jr z, .moveUp ; movement byte 2 = $1 only allows up or down
|
|
.moveLeft
|
|
dec hl
|
|
dec hl ; move tile pointer two columns left
|
|
lb de, 0, -1
|
|
lb bc, 2, SPRITE_FACING_LEFT
|
|
jr TryWalking
|
|
.notLeft ; $c0 <= a: right (or down)
|
|
ld a, [wCurSpriteMovement2]
|
|
cp $1
|
|
jr z, .moveDown ; movement byte 2 = $1 only allows up or down
|
|
.moveRight
|
|
inc hl
|
|
inc hl ; move tile pointer two columns right
|
|
lb de, 0, 1
|
|
lb bc, 1, SPRITE_FACING_RIGHT
|
|
jr TryWalking
|
|
|
|
; changes facing direction by zeroing the movement delta and calling TryWalking
|
|
ChangeFacingDirection: ; 4f43 (1:4f43)
|
|
ld de, $0
|
|
; fall through
|
|
|
|
; b: direction (1,2,4 or 8)
|
|
; c: new facing direction (0,4,8 or $c)
|
|
; d: Y movement delta (-1, 0 or 1)
|
|
; e: X movement delta (-1, 0 or 1)
|
|
; hl: pointer to tile the sprite would walk onto
|
|
; set carry on failure, clears carry on success
|
|
TryWalking: ; 4f46 (1:4f46)
|
|
push hl
|
|
call Func_5337
|
|
pop hl
|
|
push de
|
|
ld c, [hl]
|
|
call CanWalkOntoTile
|
|
pop de
|
|
ret c
|
|
call Func_5349
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
ld [hl], $10 ; c1x9 (update facing direction)
|
|
dec h
|
|
inc l
|
|
ld [hl], $3
|
|
jp UpdateSpriteImage
|
|
|
|
; update the walking animation parameters for a sprite that is currently walking
|
|
UpdateSpriteInWalkingAnimation: ; 4f61 (1:4f61)
|
|
call Func_5274
|
|
.noNextAnimationFrame
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $3
|
|
ld l, a
|
|
ld a, [hli] ; c1x3 (movement Y delta)
|
|
ld b, a
|
|
ld a, [hl] ; c1x4 (screen Y position)
|
|
add b
|
|
ld [hli], a ; update screen Y position
|
|
ld a, [hli] ; c1x5 (movement X delta)
|
|
ld b, a
|
|
ld a, [hl] ; c1x6 (screen X position)
|
|
add b
|
|
ld [hl], a ; update screen X position
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
inc h
|
|
ld a, [hl] ; c2x0 (walk animantion counter)
|
|
dec a
|
|
ld [hl], a ; update walk animantion counter
|
|
ret nz
|
|
ld a, $6 ; walking finished, update state
|
|
add l
|
|
ld l, a
|
|
ld a, [hl] ; c2x6 (movement byte 1)
|
|
cp $fe
|
|
jr nc, .initNextMovementCounter ; values $fe and $ff
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
dec h
|
|
ld [hl], $1 ; c1x1 = 1 (movement status ready)
|
|
ret
|
|
.initNextMovementCounter
|
|
call Random
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
ld a, [hRandomAdd]
|
|
and $7f
|
|
ld [hl], a ; c2x8: set next movement delay to a random value in [0,$7f]
|
|
dec h ; note that value 0 actually makes the delay $100 (bug?)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
ld [hl], $2 ; c1x1 = 2 (movement status)
|
|
inc l
|
|
inc l
|
|
xor a
|
|
ld b, [hl] ; c1x3 (movement Y delta)
|
|
ld [hli], a ; reset movement Y delta
|
|
inc l
|
|
ld c, [hl] ; c1x5 (movement X delta)
|
|
ld [hl], a ; reset movement X delta
|
|
ret
|
|
|
|
; update delay value (c2x8) for sprites in the delayed state (c1x1)
|
|
UpdateSpriteMovementDelay: ; 4fa9 (1:4fa9)
|
|
ld h, $c2
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $6
|
|
ld l, a
|
|
ld a, [hl] ; c2x6: movement byte 1
|
|
inc l
|
|
inc l
|
|
cp $fe
|
|
jr nc, .tickMoveCounter ; values $fe or $ff
|
|
ld [hl], $0
|
|
jr .moving
|
|
.tickMoveCounter
|
|
dec [hl] ; c2x8: frame counter until next movement
|
|
jr nz, notYetMoving
|
|
.moving
|
|
dec h
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
ld [hl], $1 ; c1x1 = 1 (mark as ready to move)
|
|
notYetMoving: ; 4fc5 (1:4fc5)
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
ld [hl], $0 ; c1x8 = 0 (walk animation frame)
|
|
jp UpdateSpriteImage
|
|
|
|
InitializeSpriteFacingDirection: ; 4fd1 (1:4fd1)
|
|
ld a, [wd72d]
|
|
bit 5, a
|
|
jr nz, notYetMoving
|
|
res 7, [hl]
|
|
ld a, [wPlayerDirection]
|
|
bit PLAYER_DIR_BIT_UP, a
|
|
jr z, .notFacingDown
|
|
ld c, SPRITE_FACING_DOWN
|
|
jr .facingDirectionDetermined
|
|
.notFacingDown
|
|
bit PLAYER_DIR_BIT_DOWN, a
|
|
jr z, .notFacingUp
|
|
ld c, SPRITE_FACING_UP
|
|
jr .facingDirectionDetermined
|
|
.notFacingUp
|
|
bit PLAYER_DIR_BIT_LEFT, a
|
|
jr z, .notFacingRight
|
|
ld c, SPRITE_FACING_RIGHT
|
|
jr .facingDirectionDetermined
|
|
.notFacingRight
|
|
ld c, SPRITE_FACING_LEFT
|
|
.facingDirectionDetermined
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $9
|
|
ld l, a
|
|
ld [hl], c ; c1x9: set facing direction
|
|
jr notYetMoving
|
|
|
|
InitializeSpriteStatus: ; 4fff (1:4fff)
|
|
ld [hl], $1 ; $c1x1: set movement status to ready
|
|
inc l
|
|
ld [hl], $ff ; $c1x2: set sprite image to $ff (invisible/off screen)
|
|
inc h
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $2
|
|
ld l, a
|
|
ld a, $8
|
|
ld [hli], a ; $c2x2: set Y displacement to 8
|
|
ld [hl], a ; $c2x3: set X displacement to 8
|
|
call InitializeSpriteScreenPosition ; could have done fallthrough here
|
|
ret
|
|
|
|
; calculates the spprite's scrren position form its map position and the player position
|
|
InitializeSpriteScreenPosition: ; 5012 (1:5012)
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $4
|
|
ld l, a
|
|
ld a, [wYCoord]
|
|
ld b, a
|
|
ld a, [hl] ; c2x4 (Y position + 4)
|
|
sub b ; relative to player position
|
|
call Func_5033
|
|
sub $4 ; - 4
|
|
dec h
|
|
ld [hli], a ; c1x4 (screen Y position)
|
|
inc h
|
|
ld a, [wXCoord]
|
|
ld b, a
|
|
ld a, [hli] ; c2x6 (X position + 4)
|
|
sub b ; relative to player position
|
|
call Func_5033
|
|
dec h
|
|
ld [hl], a ; c1x6 (screen X position)
|
|
ret
|
|
|
|
Func_5033: ; 5033 (1:5033)
|
|
jr nc, .asm_503c
|
|
cpl
|
|
inc a
|
|
swap a
|
|
cpl
|
|
inc a
|
|
ret
|
|
.asm_503c
|
|
swap a
|
|
ret
|
|
|
|
; tests if sprite is off screen or otherwise unable to do anything
|
|
CheckSpriteAvailability: ; 503f (1:503f)
|
|
predef IsObjectHidden
|
|
ld a, [$ffe5]
|
|
and a
|
|
jp nz, .spriteInvisible
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $6
|
|
ld l, a
|
|
ld a, [hl] ; c2x6: movement byte 1
|
|
cp $fe
|
|
jr c, .skipXVisibilityTest ; movement byte 1 < $fe (i.e. the sprite's movement is scripted)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $4
|
|
ld l, a
|
|
ld b, [hl] ; c2x4: Y pos (+4)
|
|
ld a, [wYCoord]
|
|
cp b
|
|
jr z, .skipYVisibilityTest
|
|
jr nc, .spriteInvisible ; above screen region
|
|
add $8 ; screen is 9 tiles high
|
|
cp b
|
|
jr c, .spriteInvisible ; below screen region
|
|
.skipYVisibilityTest
|
|
inc l
|
|
ld b, [hl] ; c2x5: X pos (+4)
|
|
ld a, [wXCoord]
|
|
cp b
|
|
jr z, .skipXVisibilityTest
|
|
jr nc, .spriteInvisible ; left of screen region
|
|
add $9 ; screen is 10 tiles wide
|
|
cp b
|
|
jr c, .spriteInvisible ; right of screen region
|
|
.skipXVisibilityTest
|
|
; make the sprite invisible if a text box is in front of it
|
|
; $5F is the maximum number for map tiles
|
|
call GetTileSpriteStandsOn
|
|
ld d, $60
|
|
ld a, [hli]
|
|
cp d
|
|
jr nc, .spriteInvisible ; standing on tile with ID >=$60 (bottom left tile)
|
|
ld a, [hld]
|
|
cp d
|
|
jr nc, .spriteInvisible ; standing on tile with ID >=$60 (bottom right tile)
|
|
ld bc, -20
|
|
add hl, bc ; go back one row of tiles
|
|
ld a, [hli]
|
|
cp d
|
|
jr nc, .spriteInvisible ; standing on tile with ID >=$60 (top left tile)
|
|
ld a, [hl]
|
|
cp d
|
|
jr c, .spriteVisible ; standing on tile with ID >=$60 (top right tile)
|
|
.spriteInvisible
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $2
|
|
ld l, a
|
|
ld [hl], $ff ; c1x2
|
|
scf
|
|
jr .done
|
|
.spriteVisible
|
|
ld c, a
|
|
ld a, [wWalkCounter]
|
|
and a
|
|
jr nz, .done ; if player is currently walking, we're done
|
|
call UpdateSpriteImage
|
|
inc h
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $7
|
|
ld l, a
|
|
ld a, [wGrassTile]
|
|
cp c
|
|
ld a, $0
|
|
jr nz, .notInGrass
|
|
ld a, $80
|
|
.notInGrass
|
|
ld [hl], a ; c2x7
|
|
and a
|
|
.done
|
|
ret
|
|
|
|
UpdateSpriteImage: ; 50ba (1:50ba)
|
|
ld h, $c1
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
ld a, [hli] ; c1x8: walk animation frame
|
|
ld b, a
|
|
ld a, [hl] ; c1x9: facing direction
|
|
add b
|
|
ld b, a
|
|
ld a, [$ff93] ; current sprite offset
|
|
add b
|
|
ld b, a
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $2
|
|
ld l, a
|
|
ld [hl], b ; c1x2: sprite to display
|
|
ret
|
|
|
|
; tests if sprite can walk the specified direction
|
|
; b: direction (1,2,4 or 8)
|
|
; c: ID of tile the sprite would walk onto
|
|
; d: Y movement delta (-1, 0 or 1)
|
|
; e: X movement delta (-1, 0 or 1)
|
|
; set carry on failure, clears carry on success
|
|
CanWalkOntoTile: ; 50d1 (1:50d1)
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $6
|
|
ld l, a
|
|
ld a, [hl] ; c2x6 (movement byte 1)
|
|
cp $fe
|
|
jr nc, .notScripted ; values $fe and $ff
|
|
; always allow walking if the movement is scripted
|
|
and a
|
|
ret
|
|
.notScripted
|
|
call _IsTilePassable
|
|
jr c, .impassable
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $6
|
|
ld l, a
|
|
ld a, [hl] ; $c2x6 (movement byte 1)
|
|
inc a
|
|
jr z, .impassable ; if $ff, no movement allowed (however, changing direction is)
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $4
|
|
ld l, a
|
|
ld a, [hli] ; c1x4 (screen Y pos)
|
|
add $4 ; align to blocks (Y pos is always 4 pixels off)
|
|
add d ; add Y delta
|
|
cp $80 ; if value is >$80, the destination is off screen (either $81 or $FF underflow)
|
|
jr nc, .impassable ; don't walk off screen
|
|
inc l
|
|
ld a, [hl] ; c1x6 (screen X pos)
|
|
add e ; add X delta
|
|
cp $90 ; if value is >$90, the destination is off screen (either $91 or $FF underflow)
|
|
jr nc, .impassable ; don't walk off screen
|
|
push de
|
|
push bc
|
|
ld a, [wUpdateSpritesEnabled]
|
|
push af
|
|
ld a, $ff
|
|
ld [wUpdateSpritesEnabled], a
|
|
call DetectCollisionBetweenSprites
|
|
pop af
|
|
ld [wUpdateSpritesEnabled], a
|
|
pop bc
|
|
pop de
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $c
|
|
ld l, a
|
|
ld a, [hl] ; c1xc (directions in which sprite collision would occur)
|
|
and b ; check against chosen direction (1,2,4 or 8)
|
|
jr nz, .impassable ; collision between sprites, don't go there
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $2
|
|
ld l, a
|
|
ld a, [hli] ; c2x2 (sprite Y displacement, initialized at $8, keep track of where a sprite did go)
|
|
bit 7, d ; check if going upwards (d=$ff)
|
|
jr nz, .upwards
|
|
add d
|
|
cp $5
|
|
;jr c, .impassable (bugfix) ; if c2x2+d < 5, don't go ;bug: this tests probably were supposed to prevent sprites
|
|
jr .checkHorizontal ; from walking out too far, but this line makes sprites get stuck
|
|
.upwards ; whenever they walked upwards 5 steps
|
|
sub $1 ; on the other hand, the amount a sprite can walk out to the
|
|
jr c, .impassable ; if d2x2 == 0, don't go ; right of bottom is not limited (until the counter overflows)
|
|
.checkHorizontal
|
|
ld d, a
|
|
ld a, [hl] ; c2x3 (sprite X displacement, initialized at $8, keep track of where a sprite did go)
|
|
bit 7, e ; check if going left (e=$ff)
|
|
jr nz, .left
|
|
add e
|
|
cp $5 ; compare, but no conditional jump like in the vertical check above (bug?)
|
|
jr .passable
|
|
.left
|
|
sub $1
|
|
jr c, .impassable ; if d2x3 == 0, don't go
|
|
.passable
|
|
ld [hld], a ; update c2x3
|
|
ld [hl], d ; update c2x2
|
|
and a ; clear carry (marking success)
|
|
ret
|
|
.impassable
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
ld [hl], $2 ; c1x1 = 2 (set movement status to delayed)
|
|
inc l
|
|
inc l
|
|
xor a
|
|
ld [hli], a ; c1x3 = 0 (clear Y movement delta)
|
|
inc l
|
|
ld [hl], a ; c1x5 = 0 (clear X movement delta)
|
|
inc h
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
call Random
|
|
ld a, [hRandomAdd]
|
|
and $7f
|
|
ld [hl], a ; c2x8: set next movement delay to a random value in [0,$7f] (again with delay $100 if value is 0)
|
|
scf ; set carry (marking failure to walk)
|
|
ret
|
|
|
|
; calculates the tile pointer pointing to the tile the current sprite stancs on
|
|
; this is always the lower left tile of the 2x2 tile blocks all sprites are snapped to
|
|
; hl: output pointer
|
|
GetTileSpriteStandsOn: ; 516a (1:516a)
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $4
|
|
ld l, a
|
|
ld a, [hli] ; c1x4: screen Y position
|
|
add $4 ; align to 2*2 tile blocks (Y position is always off 4 pixels to the top)
|
|
and $f8 ; in case object is currently moving (XXX why changed to $f8?)
|
|
srl a ; screen Y tile * 4
|
|
ld c, a
|
|
ld b, $0
|
|
inc l
|
|
ld a, [hl] ; c1x6: screen Y position
|
|
srl a
|
|
srl a
|
|
srl a ; screen X tile
|
|
add SCREEN_WIDTH ; screen X tile + 20
|
|
ld d, $0
|
|
ld e, a
|
|
coord hl, 0, 0
|
|
add hl, bc
|
|
add hl, bc
|
|
add hl, bc
|
|
add hl, bc
|
|
add hl, bc
|
|
add hl, de ; wTileMap + 20*(screen Y tile + 1) + screen X tile
|
|
ret
|
|
|
|
; loads [de+a] into a
|
|
LoadDEPlusA: ; 5192 (1:5192)
|
|
add e
|
|
ld e, a
|
|
jr nc, .noCarry
|
|
inc d
|
|
.noCarry
|
|
ld a, [de]
|
|
ret
|
|
|
|
DoScriptedNPCMovement: ; 5199 (1:5199)
|
|
; This is an alternative method of scripting an NPC's movement and is only used
|
|
; a few times in the game. It is used when the NPC and player must walk together
|
|
; in sync, such as when the player is following the NPC somewhere. An NPC can't
|
|
; be moved in sync with the player using the other method.
|
|
ld a, [wd730]
|
|
bit 7, a
|
|
ret z
|
|
ld hl, wd72e
|
|
bit 7, [hl]
|
|
set 7, [hl]
|
|
jp z, InitScriptedNPCMovement
|
|
ld hl, wNPCMovementDirections2
|
|
ld a, [wNPCMovementDirections2Index]
|
|
add l
|
|
ld l, a
|
|
jr nc, .noCarry
|
|
inc h
|
|
.noCarry
|
|
ld a, [hl]
|
|
; check if moving up
|
|
cp NPC_MOVEMENT_UP
|
|
jr nz, .checkIfMovingDown
|
|
call GetSpriteScreenYPointer
|
|
ld c, SPRITE_FACING_UP
|
|
ld a, -2
|
|
jr .move
|
|
.checkIfMovingDown
|
|
cp NPC_MOVEMENT_DOWN
|
|
jr nz, .checkIfMovingLeft
|
|
call GetSpriteScreenYPointer
|
|
ld c, SPRITE_FACING_DOWN
|
|
ld a, 2
|
|
jr .move
|
|
.checkIfMovingLeft
|
|
cp NPC_MOVEMENT_LEFT
|
|
jr nz, .checkIfMovingRight
|
|
call GetSpriteScreenXPointer
|
|
ld c, SPRITE_FACING_LEFT
|
|
ld a, -2
|
|
jr .move
|
|
.checkIfMovingRight
|
|
cp NPC_MOVEMENT_RIGHT
|
|
jr nz, .noMatch
|
|
call GetSpriteScreenXPointer
|
|
ld c, SPRITE_FACING_RIGHT
|
|
ld a, 2
|
|
jr .move
|
|
.noMatch
|
|
cp $ff
|
|
ret
|
|
.move
|
|
ld b, a
|
|
ld a, [hl]
|
|
add b
|
|
ld [hl], a
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $9
|
|
ld l, a
|
|
ld a, c
|
|
ld [hl], a ; facing direction
|
|
call AnimScriptedNPCMovement
|
|
ld hl, wScriptedNPCWalkCounter
|
|
dec [hl]
|
|
ret nz
|
|
ld a, 8
|
|
ld [wScriptedNPCWalkCounter], a
|
|
ld hl, wNPCMovementDirections2Index
|
|
inc [hl]
|
|
ret
|
|
|
|
InitScriptedNPCMovement: ; 5209 (1:5209)
|
|
xor a
|
|
ld [wNPCMovementDirections2Index], a
|
|
ld a, 8
|
|
ld [wScriptedNPCWalkCounter], a
|
|
jp AnimScriptedNPCMovement
|
|
|
|
GetSpriteScreenYPointer: ; 5215 (1:5215)
|
|
ld a, $4
|
|
ld b, a
|
|
jr GetSpriteScreenXYPointerCommon
|
|
|
|
GetSpriteScreenXPointer: ; 521a (1:521a)
|
|
ld a, $6
|
|
ld b, a
|
|
|
|
GetSpriteScreenXYPointerCommon: ; 521d (1:521d)
|
|
ld hl, wSpriteStateData1
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add l
|
|
add b
|
|
ld l, a
|
|
ret
|
|
|
|
AnimScriptedNPCMovement: ; 5226 (1:5226)
|
|
ld hl, wSpriteStateData2
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $e
|
|
ld l, a
|
|
ld a, [hl] ; VRAM slot
|
|
dec a
|
|
swap a
|
|
ld b, a
|
|
ld hl, wSpriteStateData1
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $9
|
|
ld l, a
|
|
ld a, [hl] ; facing direction
|
|
cp SPRITE_FACING_DOWN
|
|
jr z, .anim
|
|
cp SPRITE_FACING_UP
|
|
jr z, .anim
|
|
cp SPRITE_FACING_LEFT
|
|
jr z, .anim
|
|
cp SPRITE_FACING_RIGHT
|
|
jr z, .anim
|
|
ret
|
|
.anim
|
|
add b
|
|
ld b, a
|
|
ld [hSpriteVRAMSlotAndFacing], a
|
|
call AdvanceScriptedNPCAnimFrameCounter
|
|
ld hl, wSpriteStateData1
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $2
|
|
ld l, a
|
|
ld a, [hSpriteVRAMSlotAndFacing]
|
|
ld b, a
|
|
ld a, [hSpriteAnimFrameCounter]
|
|
add b
|
|
ld [hl], a
|
|
ret
|
|
|
|
AdvanceScriptedNPCAnimFrameCounter: ; 5264 (1:5264)
|
|
call Func_5274
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
ld a, [hl] ; intra-animation frame counter
|
|
and $3
|
|
ld [hSpriteAnimFrameCounter], a
|
|
ret
|
|
|
|
Func_5274: ; 5274 (1:5274)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $7
|
|
ld l, a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [hl] ; c1x7 (counter until next walk animation frame)
|
|
inc a
|
|
and $3
|
|
ld [hl], a ; c1x7 += 1
|
|
ret nz ; c1x7 = 0
|
|
inc l
|
|
ld a, [hl] ; c1x8 (walk animation frame)
|
|
inc a
|
|
and $3
|
|
ld [hl], a ; advance to next animation frame every 4 ticks (16 ticks total for one step)
|
|
ret
|
|
|
|
Func_5288: ; 5288 (1:5288)
|
|
; nice lookup table
|
|
; a is supposedly [wNPCMovementDirections + $fe]
|
|
cp $5
|
|
jr z, .asm_52af
|
|
cp $4
|
|
jr z, .asm_52aa
|
|
cp $6
|
|
jr z, .asm_52b4
|
|
cp $7
|
|
jr z, .asm_52b9
|
|
cp $11
|
|
jr z, .asm_52c3
|
|
cp $12
|
|
jr z, .asm_52be
|
|
cp $13
|
|
jr z, .asm_52c8
|
|
cp $14
|
|
jr z, .asm_52cd
|
|
xor a
|
|
ret
|
|
; set 1?
|
|
.asm_52aa
|
|
call Func_531f
|
|
jr .asm_52e6
|
|
.asm_52af
|
|
call Func_5325
|
|
jr .asm_52e6
|
|
.asm_52b4
|
|
call Func_5331
|
|
jr .asm_52e6
|
|
.asm_52b9
|
|
call Func_532b
|
|
jr .asm_52e6
|
|
; set 2?
|
|
.asm_52be
|
|
call Func_531f
|
|
jr .asm_52fa
|
|
.asm_52c3
|
|
call Func_5325
|
|
jr .asm_52fa
|
|
.asm_52c8
|
|
call Func_5331
|
|
jr .asm_52fa
|
|
.asm_52cd
|
|
call Func_532b
|
|
jr .asm_52fa
|
|
; set 3? (unused)
|
|
.asm_52d2
|
|
call Func_531f
|
|
jr .asm_530b
|
|
.asm_52d7
|
|
call Func_5325
|
|
jr .asm_530b
|
|
.asm_52dc
|
|
call Func_5331
|
|
jr .asm_530b
|
|
.asm_52e1
|
|
call Func_532b
|
|
jr .asm_530b
|
|
|
|
.asm_52e6
|
|
call Func_5337
|
|
call Func_5349
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
ld [hl], $8
|
|
dec h
|
|
inc l
|
|
ld [hl], $4
|
|
call UpdateSpriteImage
|
|
scf
|
|
ret
|
|
|
|
.asm_52fa
|
|
call Func_5337
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
ld [hl], $8
|
|
dec h
|
|
inc l
|
|
ld [hl], $3
|
|
call UpdateSpriteImage
|
|
scf
|
|
ret
|
|
|
|
.asm_530b
|
|
call Func_5337
|
|
call Func_5349
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
ld [hl], $8
|
|
dec h
|
|
inc l
|
|
ld [hl], $3
|
|
call UpdateSpriteImage
|
|
scf
|
|
ret
|
|
|
|
Func_531f: ; 531f (1:531f)
|
|
lb de, 1, 0
|
|
ld c, SPRITE_FACING_DOWN
|
|
ret
|
|
|
|
Func_5325: ; 5325 (1:5325)
|
|
lb de, -1, 0
|
|
ld c, SPRITE_FACING_UP
|
|
ret
|
|
|
|
Func_532b: ; 532b (1:532b)
|
|
lb de, 0, 1
|
|
ld c, SPRITE_FACING_RIGHT
|
|
ret
|
|
|
|
Func_5331: ; 5331 (1:5331)
|
|
lb de, 0, -1
|
|
ld c, SPRITE_FACING_LEFT
|
|
ret
|
|
|
|
Func_5337: ; 5337 (1:5337)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $9
|
|
ld l, a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld [hl], c ; c1x9 (update facing direction)
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $3
|
|
ld l, a
|
|
ld [hl], d ; c1x3 (update Y movement delta)
|
|
inc l
|
|
inc l
|
|
ld [hl], e ; c1x5 (update X movement delta)
|
|
ret
|
|
|
|
Func_5349: ; 5349 (1:5349)
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $4
|
|
ld l, a
|
|
ld a, [hl] ; c2x4: Y position
|
|
add d
|
|
ld [hli], a ; update Y position
|
|
ld a, [hl] ; c2x5: X position
|
|
add e
|
|
ld [hl], a ; update X position
|
|
ret
|
|
|
|
Func_5357: ; 5357 (1:5357)
|
|
call Func_5274
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $3
|
|
ld l, a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld a, [hli]
|
|
add a
|
|
ld b, a
|
|
ld a, [hl]
|
|
add b
|
|
ld [hli], a
|
|
ld a, [hli]
|
|
add a
|
|
ld b, a
|
|
ld a, [hl]
|
|
add b
|
|
ld [hl], a
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
ld l, a
|
|
ld h, wSpriteStateData2 / $100
|
|
dec [hl]
|
|
ret nz
|
|
ld a, $6
|
|
add l
|
|
ld l, a
|
|
ld a, [hl]
|
|
cp $fe
|
|
jr nc, .asm_5386
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
ld h, wSpriteStateData1 / $100
|
|
ld [hl], $1
|
|
ret
|
|
.asm_5386
|
|
call Random
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
add $8
|
|
ld l, a
|
|
ld h, wSpriteStateData2 / $100
|
|
ld a, [hRandomAdd]
|
|
and $7f
|
|
ld [hl], a
|
|
dec h
|
|
ld a, [H_CURRENTSPRITEOFFSET]
|
|
inc a
|
|
ld l, a
|
|
ld [hl], $2
|
|
inc l
|
|
inc l
|
|
xor a
|
|
ld b, [hl]
|
|
ld [hli], a
|
|
inc l
|
|
ld c, [hl]
|
|
ld [hl], a
|
|
ret |