cursor.z80

; TODO diagonals (should be supported)

keyrepeat_ctr: defb 0 ; counts how long a key was held down for (before repeating)
keyrepeat_dirs: defb 0 ; what keys were held down since last time
fire_pressed: defb 0 ; whether fire was held down since last time
key_delay: equ 8
key_repeat: equ 6

cursor_moved: defb 0  ; 0 if cursor did not move since last frane; nonzero if it did
old_cursor_hl: defw 0  ; handy way to keep track of where the cursor was (screen memory) last frame

controller_flags_xoffs: defb 0 ; x-offset
controller_flags_yoffs: defb 0 ; y-offset

init_cursor_controller:
                xor a
                ld (keyrepeat_ctr), a
                ld (keyrepeat_dirs), a
                ld (fire_pressed), a
                ld (cursor_moved), a
                ld (old_cursor_hl), a
                ld (old_cursor_hl+1), a

                ld (controller_flags_xoffs), a
                ld (controller_flags_yoffs), a
                ld a, (controller_flags_xy_pos)
                ret

erase_old_cursor:
                ; TODO optimize and be smarter?
                ld a, (cursor_moved)
                and a
                ret z
                ld hl, (old_cursor_hl)
                xor a ; because palette black is 0 ; TODO BACKGROUND IMAGES
                call box_at_hl
                ret

draw_cursor:
                ; is the cursor on a tile with fire still held?
                ; if so, we follow the tile
                ld a, (controller_flags_tile_captured)
                and a
                jr z, @tile_not_captured
                ld a, (controller_flags_xy_pos)
                ld l, a
                ld h, (tiles-1)/256
                ; is tile falling
                ld a, (hl)
                bit IS_FALLING_BIT, a
                jr nz, @captured_falling_tile ; tile is falling so y-offset matches tile
                bit IS_SLIDER_BIT, a
                jr nz, @captured_sliding_tile ; tile is sliding so y-offset or x-offset matches tile (according to slider direction)
                jp @tile_not_captured

    @captured_sliding_tile:
                ; is it vertical or horizontal?
                ; if vertical, use same logic as falling tile (handy)
                ld hl, slider_info
                bit SLIDER_AXIS_BIT, (hl)
                jr z, @captured_vertical_slider

    @captured_horizontal_slider:
                and 15
                rra
                ld l, a
                ld a, (controller_flags_xy_pos)
                ld c, a ; backup
                call grid_xy_in_C_and_A_to_screen_de
                ld a, e
                add l
                ld l, a
                ld h, d
                jp @+_draw_cursor

    @captured_vertical_slider:
    @captured_falling_tile:
                ; get the offset for top-left into hl
                and 15
                ld h, a
                ld l, 0
                srl h
                rr l
                ld a, (controller_flags_xy_pos)
                ld c, a ; backup
                call grid_xy_in_C_and_A_to_screen_de
                ld a, e
                add l
                ld l, a
                ld a, d
                add h
                ld h, a
                jp @+_draw_cursor

@tile_not_captured:
                ld a, (controller_flags_xy_pos)
                ld c, a ; backup
                call grid_xy_in_C_and_A_to_screen_de
                ; cursor draw expects screen location in hl not de
                ex de, hl
                ; TODO only draw the cursor if the flashing counter tells us to
                ; i.e. redraw the title where the cursor would be,  the cursor is flashing
                ; what does that mean? well, if fire is held then we draw the cursor
                ; for four frames and then hide it for four frames, etc.  we have a ctr for it.
                ;ld a, (controller_flags_flashing_ctr)
                ;and 4
                ;ret nz ; four frames with bit cleared => draw cursor. four frames with bit set => don't draw cursor
                ; however we don't really want to have to draw the whole tile under the cursor, just the bit
                ; where the cursor is.
                ; so, cheat for now.  draw the cursor always, but in one of two colours.
                ; red usually, but white/red if flashing.
@_draw_cursor:
                ld a, (controller_flags_flashing_ctr)
                and 4
                jr nz, @white
@red:
                ld a, palette_index_red * 17
                ld (old_cursor_hl), hl
                call box_at_hl
                ret
@white:
                ld a, palette_index_white * 17
                ld (old_cursor_hl), hl
                call box_at_hl
                ret


update_cursor_position:
                ; update the data structures associated with the current cursor position and state
                ;
                ; initially assume cursor did not move
                xor a
                ld (cursor_moved), a
                ; controller can be periodically disabled during game logic
                ; so check that first
                ld a, (controller_flags_disabled)
                and a
                ret nz
    @check_fire:
                ; If fire is not held, then cursor moves up/down/left/right,
                ; subject to boundaries (i.e. cannot pass through tile==2)
                ;
                ; If fire is held, and the cell contains a tile, then you can only
                ; move left or right if the tile can move left or right
                ; NB CANNOT MOVE UP OR DOWN, WITH FIRE HELD!
                ;
                ; If fire is held, and the cell does not contain a tile, then cursor
                ; moves just as if fire is not held

                ld a, (controller_flags_fire)
                and a
                jp nz, @+check_dirs_with_fire_pressed
                ; fire was not pressed
                ; reset the flashing cursor counter
                ; reset the 'captured' flag
                ; reset the 'fire was held down' flag
                xor a
                ld (controller_flags_tile_captured), a
                ld (controller_flags_flashing_ctr), a
                ld (fire_pressed), a

    @movements_no_tile:
                ; either fire was not pressed (as fall through from above)
                ; or fire was pressed but we're not over a block that can move
    @check_directions:
                ld a, (controller_flags_dirs)
                ; if NOTHING to do, do nothing
                and a
                jr nz, @some_directions_are_pressed
                xor a
                ld (keyrepeat_dirs), a
                ld (keyrepeat_ctr), a
                ret
    @some_directions_are_pressed:
                ; if the same directions were held down from before,
                ; do nothing (unless keyrepeat tells us to do something)
                ld b, a ; backup
                ld a, (keyrepeat_dirs)
                cp b
                jr z, @same_dirs_still_held
                ld a, key_delay
                ld (keyrepeat_ctr), a
                ld a, b
                ld (keyrepeat_dirs), a
                jr @check_up
    @same_dirs_still_held:
                ld a, (keyrepeat_ctr)
                dec a
                ld (keyrepeat_ctr), a
                ret nz
                ld a, key_repeat
                ld (keyrepeat_ctr), a
                ld a, b
    @check_up:
                ; was UP pressed?
                bit controller_flags_dirs_up_bit,a
                jr z, @+check_down ; no, up was not pressed

                ; yes, up was pressed
                ; todo: also check left/right for diagonal movement

                ; get new position
                ; (first get current position)
                ld a, (controller_flags_xy_pos)
                sub 16 ; go up a row

                ; see if the tile in the new position is
                ; penetrable...
                ld l, a
                ld h, tiles/256
                ld a, (hl)
                cp IMPENETRABLE_TILE
                ret z

                ; all good, we can move there
                call trigger_sfx_cursor

                ld a, l
                ld (controller_flags_xy_pos), a
                ; mark the OLD location as dirty
                ; (old location was the row below this one)
                add a, 16
                call push_dirty_tile
                ld a, 1 ; TODO optimize, a is already nonzero
                ld (cursor_moved), a
                ret

    @check_down:
                ; was DOWN pressed?
                bit controller_flags_dirs_down_bit,a
                jr z, @+check_left ; no, down was not pressed

                ; yes, down was pressed
                ; todo: also check left/right for diagonal movement

                ; get new position
                ; (first get current position)
                ld a, (controller_flags_xy_pos)
                add a, 16
                ; see if the tile in the new position is
                ; penetrable...
                ld l, a
                ld h, tiles/256
                ld a, (hl)
                cp IMPENETRABLE_TILE
                ret z
                
                ; all good, we can move there
                call trigger_sfx_cursor

                ld a, l
                ld (controller_flags_xy_pos), a
                ; mark the OLD location as dirty
                ; (old location was the row above this one)
                sub 16
                call push_dirty_tile
                ld a, 1 ; TODO optimize, a is already nonzero
                ld (cursor_moved), a
                ret

    @check_left:
                ; was LEFT pressed 
                bit controller_flags_dirs_left_bit,a
                jr z, @+check_right ; no

                ; yes, left was pressed
                ; get new position
                ; (first get current position)
                ld a, (controller_flags_xy_pos)
                dec a
                ; see if the tile in the new position is
                ; penetrable...
                ld l, a
                ld h, tiles/256
                ld a, (hl)
                cp IMPENETRABLE_TILE
                ret z

                ; all good, we can move there
                call trigger_sfx_cursor

                ld a, l
                ld (controller_flags_xy_pos), a
                ; mark the OLD location as dirty
                ; (old location was the column right of this one)
                inc a
                call push_dirty_tile
                ld a, 1 ; TODO optimize, a is already nonzero
                ld (cursor_moved), a
                ret

    @check_right:
                ; was RIGHT pressed?
                bit controller_flags_dirs_right_bit,a
                ; ; jr z, @+done ; no ; TODO OPTIMIZE AS RET Z
                ret z

                ; yes, right was pressed
                ; get new position
                ; (first get current position)
                ld a, (controller_flags_xy_pos)
                inc a
                ; see if the tile in the new position is
                ; penetrable...
                ld l, a ; e = y*12 + x
                ld h, tiles/256
                ld a, (hl)
                cp IMPENETRABLE_TILE
                ret z

                ; all good, we can move there
                call trigger_sfx_cursor

                ld a, l
                ld (controller_flags_xy_pos), a
                ; mark the OLD location as dirty
                ; (old location was the column left of this one)
                dec a
                call push_dirty_tile
                ld a, 1 ; TODO optimize, a is already nonzero
                ld (cursor_moved), a
                ret

    @check_dirs_with_fire_pressed:
                ; first some admin:
                ; FIRE is held down - so increment frame counter for flashing
                ; cursor if the flag for 'is captured' is already set
                ; (implying it is "still" held down)
                ld a, (controller_flags_tile_captured)
                and a
                jr z, @+skip_capture
                ld a, (controller_flags_flashing_ctr)
                inc a
        @skip_capture:
                ; (flashing_ctr is either incremented, or zero. neat.)
                ld (controller_flags_flashing_ctr), a
                ; also, trigger a sound effect just for pressing fire
                ld a, (fire_pressed)
                and a
                jr nz, @+skip_sfx
                inc a
                ld (fire_pressed), a
                call trigger_sfx_shove

        @skip_sfx:
                ; Now for the movement (i.e. push left / push right)
                ; There are a lot of cases to consider here
                ; TODO optimise.  We should be able to make determination here pretty
                ; quickly, and right now there's quite a lot of back-and-forth

                ; 1. determine if there is a (movable) tile at current position
                ; (first get current position)
                ld a, (controller_flags_xy_pos)
                ld l, a
                ld h, tiles/256
                ld a, (hl)
                ; is it moveable tile (i.e. >= NUM_NON_TILES)
                cp NUM_NON_TILES
                ; No? ok, then just move like there's no tile (i.e. ignore fact FIRE is held)
                jp c, @movements_no_tile
                ; Yes? Ok, it's a moveable tile, great, let's keep checking other conditions.
                ; 2.  is it already falling maybe? can't move a falling tile
                dec h ; (point to tiles_flags)
                ld a, (hl)
                bit IS_FALLING_BIT, a
                ; if it's falling, don't permit any movements at all
                ; TODO check gameplay, is this correct? feels correct but that's just my guess.
                ret nz
                ; 3. similarly, it might not be falling yet (but the tile under
                ; it could be mid falling, so effectively we're in 'mid air') - same rule
                ; applies - you can't move it if it's in mid air
                ; TODO optimise, now we're pushing and popping HL, ugh.
                ; TODO does this condition apply for something that has landed 'onto' where
                ; the slider is (or will be)?
                push hl
                ld a, l
                add 16
                ld l, a
                ld a, (hl)
                pop hl
                bit IS_FALLING_BIT, a
                ; if it's 'effectively in mid air' then again ignore the FIRE and just
                ; move cursor as if there's no tile being controlled
                jp nz, @movements_no_tile
                ; ok fire was pressed AND we have a moveable tile under us
                ; now the excitement begins!!
                ; Mark as captured (we reset this when FIRE is let go)
                ld a, (controller_flags_tile_captured)
                and a
                jr nz, @we_already_captured_earlier
                ld a, 1
                ld (controller_flags_tile_captured), a
                ; also - essentially this means the cursor moved because it may have jumped in position
                ; now, to meet the tile that was in this location
                ld (cursor_moved), a
                ld a, 4 ; seed with 4 which is when we first change cursor colour (so that the colour change is immediate on this frame)
                ld (controller_flags_flashing_ctr), a
    @we_already_captured_earlier:
                ; are we also pressing left or right?
                ld a, (controller_flags_dirs)
                and %00001111
                ; if not, do nothing else
                jr nz, @+some_directions_are_pressed
                xor a
                ld (keyrepeat_dirs), a
                ld (keyrepeat_ctr), a
                ret
    @some_directions_are_pressed:
                ; if the same directions were held down from before,
                ; do nothing (unless keyrepeat tells us to do something)
                ld b, a ; backup
                ld a, (keyrepeat_dirs)
                cp b
                jr z, @+same_dirs_still_held
                ld a, key_delay
                ld (keyrepeat_ctr), a
                ld a, b
                ld (keyrepeat_dirs), a
                jp @check_push_left
    @same_dirs_still_held:
                ld a, (keyrepeat_ctr)
                dec a
                ld (keyrepeat_ctr), a
                ret nz
                ld a, key_repeat
                ld (keyrepeat_ctr), a
                ld a, b

    @check_push_left:
                ; This implements the shove_left action.

                ; was LEFT pressed 
                bit controller_flags_dirs_left_bit, a
                jp z, @+check_push_right ; no

                ; yes, left was pressed (with fire)
                call trigger_sfx_cursor

                ; get new position
                ; with 'old' position in D and 'new' position in E
                ld d, l
                ld e, l
                dec e ; dec = 'left'
                call can_I_push_here
                ret nz

                ; all good, we can move there
                ; copy old tile to new place
                jp shove_block_h_d_e

    @check_push_right:
                ; was RIGHT pressed?
                bit controller_flags_dirs_right_bit,a
                ret z ; no, RIGHT was not pressed, and we already checked LEFT, so we're done

                ; yes, right was pressed (with fire)
                call trigger_sfx_cursor

                ; get new position (left = dec l, right = inc l)
                ld d, l
                ld e, l
                inc e ; inc = 'right'
                call can_I_push_here
                ret nz

                ; all good, we can move there
                ; copy old tile to new place
                jp shove_block_h_d_e


lock_controller:
                ld a, 1
                ld (controller_flags_disabled), a
                ret

unlock_controller:
                xor a
                ld (controller_flags_disabled), a
                ret


@check_adjust_slider_for_moved_tile_in_stack:
                ; SLIDER - if this tile WAS in the slider stack, then we also need to
                ; clear the 'is_slider' bit from the old position, and reduce the height of
                ; the slider stack (to equal the remaining height of all tiles STRICTLY BELOW
                ; this one), and clear the 'is_slider bit from all the tiles strictly above us
                ; in the slider stack.
                dec h ; point to flags
                ld a, (hl)
                and IS_SLIDER_MASK
                ret z

                ; clear the slider flag (in fact clear all flags, that old position is now empty)
                ; clear the flags above us too, and call 'check falling tile' on those
                push hl ; let's remember where we started
        @next:
                xor a
                ld (hl), a
                ld a, l
                sub 16
                ld l, a
                ld a, (hl)
                and IS_SLIDER_MASK
                jr nz, @-next
        @finished_clearing_flags_for_slider_stack:
                ; now work out new height of the slider stack
                ; get y-coord of slider and subtract y-coord of this tile
                pop hl
                ld a, l
                and 240
                rrca
                rrca
                rrca
                rrca ; get y-coord only into a
                ld b, a
                ld a, (slider_xy)
                and 240
                rrca
                rrca
                rrca
                rrca ; get y-coord only into a
                sub b
                dec a ; subtract one because we have removed a tile from the stack
                ld (slider_stack_height), a
                ret


can_I_push_here:
                ; on entry, D is the grid YX of the source
                ;           E is the grid YX of the destination
                ;
                ; return:  Z FLAG set if it's ok to move a tile into destination
                ;          Z FLAG clear (i.e. NZ condition) if you cannot
                ;
                ; TODO more edge cases here.  what happens when the tile being shoved is part
                ; of the stack on top of a vertical slider?  it seems to do the following:
                ;  if the slider is grid-aligned then this just works (look left or right and
                ;  see a space), but if the slider is part-way then the tile will move to the
                ;  nearest grid-aligned y-coordinate after being shoved.  So in some cases that
                ;  means the tile y-coordinate will be 'rounded up' and jump up, or 'rounded down'
                ;  and jump down.  In either case, the tile might find itself immediately on
                ;  solid ground, or it might start to fall, etc.
                ; ....
                ld h, tiles/256 ; TODO optimize out if that's what it is already (per caller)
                ld l, e
                ld a, (hl)
                and a ; check if it is zero.  you can only push a tile into zero
                ret nz
                ; yet another edge case - even if this space is zero now, if there's something
                ; ABOVE it, that is partially obstructing and falling INTO this space already, we can't move into it now.
                ld a, l
                sub 16
                ld l, a
                dec h ; (point to tiles_flags)
                ld a, (hl)
                ; is it falling or slider? if so, it might be already partially obstructing the space, we can't move into that space
                bit IS_FALLING_BIT, a
                jr z, @+_not_falling

                ; falling block above the dest square.  is it encroaching?
                and 15 ; get the y-coordinate-offset of the falling block
                ret ; if it's nonzero, then falling block is not grid-aligned (it's poking downwards into
                    ; where we want to move our tile)
                    ; if it's zero, then we're good

        @_not_falling:
                ; block above the dest is not a faller.
                ; if sliders are vertical, we need to check if it's a slider
                ; (if sliders are horiz, we need a different check)
                ld a, (slider_info)
                and a
                ret z ; no slider, nothing else to check

                ; get current type
                bit SLIDER_AXIS_BIT, a
                jr nz, @_horiz_slider_checks

                ; vert slider type
                ; ok so see if the block above the dest is a slider
                ld a, (hl)
                bit IS_SLIDER_BIT, a
                ret z ; not a slider above us, so we're done - this is SUCCESS - you can move here!

                ; we also have to check the slider y offset.  if it's zero, then we're actually
                ; fine to move into this space, because the slider is at a grid-aligned coordinate and
                ; there's enough space to sneak in under it.
                and 15 ; get the y-coordinate-offset of the slider
                ret ; if it's nonzero, then slider is not grid-aligned (it's poking downwards into
                    ; where we want to move our tile)
                    ; if it's zero, then we're good

        @_horiz_slider_checks:
                ; TODO
                sub a ; set Z flag
                ret


shove_block_h_d_e:
                ; move the tile info pointed to by YX in D to the new YX in E
                ;
                push de
                ld h, tiles/256
                ld l, d
                ld a, (hl)
                ld l, e
                ld (hl), a
                ld l, d
                ld (hl), 0

                dec h
                ; we're now pointing at the 'old' flags.
                ; This contains the Y-offset if tile was sliding/falling
                ; so blank out this old location (whatever it was)
                ; before clearing the flags
                ; TODO NEED TO HANDLE HORIZ SLIDER HERE i.e. THAT MIGHT NEED THE 18x16 CASE
                ; TODO JUST NEED A GENERIC "BLANK THIS OLD THING" ROUTINE ACTUALLY, THAT FIGURES OUT WHAT TO DO
                ; (SHOULDN'T NEED TO BE PART OF CURSOR.Z80)
                push hl ; TODO optimize out the push/pop here
                ld c, l
                ld a, (hl)
                ld b, a
                call grid_xy_in_C_flags_in_b_to_screen_de
                call defer_fillrect_16x16_black_at_de
                pop hl

                inc h ; point back to tiles
                push hl
                call @check_adjust_slider_for_moved_tile_in_stack
                pop hl

                ; finally, clear old flags
                ; (we can't do that before the above call, because it needs to check if the flag was set)
                dec h
                ld (hl), 0
                inc h

                ; and mark this as our new cursor position
                pop de
                ld a, e
                ld (controller_flags_xy_pos), a
                ; mark the new location as dirty
                call push_dirty_tile
                ld a, 1 ; TODO optimize, a is already nonzero
                ld (cursor_moved), a

                ; add a check if the newly-shoved tile is now maybe falling
                ld l, e
                call queue_check_falling_tile_l

                ; add a check to see if the one ABOVE us in the OLD location is now falling
                ld a, d
                sub 16
                ld l, a
                ld e, l ; need this again in a sec
                call queue_check_falling_tile_l ; FIX ME, INEFFICIENT, WE SUB 16 ABOVE AND THIS CALL JUST ADDS IT BACK AGAIN

                ; mark the old location as dirty
                ld a, e ; from backup
                call push_dirty_tile
                ret