; 
; def check_dots():
;     r = actor_row[zp.current_actor]
;     c = actor_col[zp.current_actor]
;     if has_dot(r, c):
;         dot_eaten_row[zp.current_actor] = r
;         dot_eaten_col[zp.current_actor] = c
; 
;         # Update maze here so we can check which player closed off a box
;         addr = mazerow(r)
;         addr[c] &= ~TILE_DOT
; 
;         player_score[zp.current_actor] += DOT_SCORE
check_dots nop
    lda actor_row,x
    sta r
    lda actor_col,x
    sta c
    jsr has_dot
    beq ?1

    ldy r
    jsr mazerow
    ldy c
    lda (mazeaddr),y
    and #CLEAR_TILE_DOT
    sta (mazeaddr),y

    ; update damage! Needs to update both screens
    jsr damage_char

    lda #DOT_SCORE
    jsr add_score
?1  rts


save_index .byte 0

; def paint_boxes():
paint_boxes nop
;     x = 0
;     pad.addstr(28, 0, "Checking box:")
;     while x < NUM_BOX_PAINTING_PARAMS * 16:
    ldy #0
    sty param_index
?loop ldy param_index
    cpy #MAX_BOX_PAINTING
    bcc ?1
    rts

;         if box_painting[x] > 0:
?1  lda box_painting_c,y
    beq ?skip
;             c1 = box_painting[x]
;             r1 = box_painting[x + 1]
;             r2 = box_painting[x + 2]
;             i = box_painting[x + 3]

    inc debug_paint_box

    sta c1
    lda box_painting_r1,y
    sta r1
    lda box_painting_r2,y
    sta r2
    lda box_painting_actor,y ; player number
;             box_log.debug("Painting box line, player %d at %d,%d" % (i, r1, c1))
;             pad.addstr(30, 0, "painting box line at %d,%d" % (r1, c1))
;             addr = screenrow(r1)
    ldy r1
    jsr mazerow
    ldy c1
    lda #$24 ; $ sign
    sta (mazeaddr),y
    iny
    lda #$23 ; # sign
    sta (mazeaddr),y
    iny
    lda #$24 ; $ sign
    sta (mazeaddr),y
    iny
    lda #$23 ; # sign
    sta (mazeaddr),y
    iny
    lda #$24 ; $ sign
    sta (mazeaddr),y

    lda c1
    sta c
    lda r1
    sta r
    lda #5
    sta size
    jsr damage_string
;             for c in range(BOX_WIDTH):
;                 if i == 0:
;                     addr[c1 + c] = ord("X")
;                 else:
;                     addr[c1 + c] = ord(".")
;             r1 += 1
    inc r1
;             print "ROW", r1
;             if r1 >= r2:
;                 box_painting[x] = 0
    lda r1
    cmp r2
    bcs ?finish

;             box_painting[x + 1] = r1
    ldy param_index
    sta box_painting_r1,y
    inc param_index
    bne ?loop ; always

?finish ldy param_index
    lda #0
    sta box_painting_c,y

;         x += NUM_BOX_PAINTING_PARAMS
?skip inc param_index
    bne ?loop ; always

; 
; def init_static_background():
;     zp.current_actor = 0
;     while zp.current_actor < zp.num_players:
;         row = player_score_row[zp.current_actor]
;         pad.addstr(row - 1, MAZE_SCORE_COL, "       ")
;         pad.addstr(row, MAZE_SCORE_COL,     "Player%d" % (zp.current_actor + 1))
;         zp.current_actor += 1

clear_panel nop
    ldx #MAZE_RIGHT_COL+1
    lda #0
?1  jsr text_put_col
    inx
    cpx #40
    bcc ?1
    rts

init_panel nop
    jsr clear_panel

    ldy #1
    jsr mazerow
    ldy #MAZE_PANEL_COL
    ldx #0
?1  lda player1_text,x
    beq ?2
    sta (mazeaddr),y
    iny
    inx
    bne ?1
?2  
    ldy #6
    jsr mazerow
    ldy #MAZE_PANEL_COL
    ldx #0
?3  lda player2_text,x
    beq ?4
    sta (mazeaddr),y
    iny
    inx
    bne ?3
?4
    ldx #0
    jsr print_score
    jsr print_lives
    inx
    jsr print_score
    jsr print_lives
    rts

player1_text .byte "PLAYER1", 0
player2_text .byte "PLAYER2", 0



; def show_lives(row, num):
;     i = 1
;     col = SCREEN_COLS
;     while col > MAZE_SCORE_COL:
;         col -= 1
;         if i < num:
;             c = "*"
;         else:
;             c = " "
;         pad.addch(row, col, ord(c))
;         i += 1
update_lives nop
    lda #MAZE_SCORE_COL
    sta c
    lda player_lives_row,x
    sta r
    lda #6
    sta size
    jsr damage_string

print_lives nop
    ldy player_lives_row,x
    jsr mazerow
    lda player_lives,x
    cmp #6
    bcc ?ok
    lda #6
?ok sta scratch_col
    lda #40
    sec
    sbc scratch_col
    sta scratch_col
    ldy #MAZE_SCORE_COL
?loop cpy scratch_col
    bcc ?blank
    lda #'*'
    bne ?show
?blank lda #0
?show sta (mazeaddr),y
    iny
    cpy #40
    bcc ?loop
    rts


print_hex pha
    stx param_x
    lsr
    lsr
    lsr
    lsr
    tax
    lda hexdigit,x
    sta (mazeaddr),y
    iny
    pla
    and #$0f
    tax
    lda hexdigit,x
    sta (mazeaddr),y
    iny
    ldx param_x
    rts

print_low_nibble stx param_x
    and #$0f
    tax
    lda hexdigit,x
    sta (mazeaddr),y
    iny
    ldx param_x
    rts


; def update_score():
update_score nop
    lda #MAZE_SCORE_COL
    sta c
    lda player_score_row,x
    sta r
    lda #6
    sta size
    jsr damage_string

print_score nop
    ldy player_score_row,x
    jsr mazerow
    ldy #MAZE_SCORE_COL
    lda player_score_h,x
    jsr print_low_nibble
    lda player_score_m,x
    jsr print_hex
    lda player_score_l,x
    jsr print_hex
    rts
;     row = player_score_row[zp.current_actor]
;     if actor_status[zp.current_actor] == GAME_OVER:
;         pad.addstr(row - 1, MAZE_SCORE_COL, "GAME   ")
;         pad.addstr(row, MAZE_SCORE_COL,     "   OVER")
;     else:
;         pad.addstr(row + 1, MAZE_SCORE_COL, " %06d" % player_score[zp.current_actor])
;         show_lives(row + 2, player_lives[zp.current_actor])
; 




init_damage lda #0
    sta damageindex1
    sta damageindex2
    sta damageptr
    sta damageptr1
    sta damageptr2
    lda #damagepage1
    sta damageptr+1
    sta damageptr1+1
    lda #damagepage2
    sta damageptr2+1
    lda #0
    sta tdamageindex1
    lda #128
    sta tdamageindex2
    rts

restorebg_driver
    ; copy damaged characters back to screen
    ;jsr copytexthgr
    ldy #0
    sty param_count
restorebg_loop1 ldy param_count
    cpy damageindex
    bcc restorebg_cont  ; possible there's no damage, so have to check first
    ldy #0
    sty damageindex  ; clear damage index for this page
    rts
restorebg_cont lda (damageptr),y ; groups of 4 x1 -> x2, y1 -> y2
    sta param_x
    iny
    lda (damageptr),y
    sta param_col
    iny
    lda (damageptr),y
    sta param_y
    iny
    lda (damageptr),y
    sta param_row
    iny
    sty param_count

    ldy param_y
restorebg_row lda textrows_h,y
.if DEBUG_BOUNDS
    cpy #24
    bcc ?1
    jsr debug_bounds
.endif
?1  lda textrows_h,y
    sta restorebg_row_smc+2
    lda textrows_l,y
    sta restorebg_row_smc+1
    ldx param_x
restorebg_row_smc lda $ffff,x
.if DEBUG_BOUNDS
    cpx #40
    bcc ?1
    jsr debug_bounds
.endif
?1  jsr fastfont
    inx
    cpx param_col
    bcc restorebg_row_smc
    iny
    cpy param_row
    beq restorebg_row
    bcc restorebg_row
    bcs restorebg_loop1


; text position in r, c. add single char to both pages!
damage_char nop
    lda #1
    sta size
    ; fallthrough

; text position in r, c; string length in size
damage_string nop
    ldy tdamageindex1
    lda c
    sta TEXTDAMAGE,y
    iny
    lda r
    sta TEXTDAMAGE,y
    iny
    lda size
    sta TEXTDAMAGE,y
    iny
    sty tdamageindex1

    ldy tdamageindex2
    lda c
    sta TEXTDAMAGE,y
    iny
    lda r
    sta TEXTDAMAGE,y
    iny
    lda size
    sta TEXTDAMAGE,y
    iny
    sty tdamageindex2

    lda damagestart
    bmi ?2
    lda tdamageindex1
    sta tdamageindex
    rts
?2  lda tdamageindex2
    sta tdamageindex
    rts


restoretext nop
    ldy damagestart
    sty param_index
?loop1 ldy param_index
    cpy tdamageindex
    bcc ?cont  ; possible there's no damage, so have to check first
    lda damagestart
    sta tdamageindex  ; clear damage index for this page
    rts
?cont lda TEXTDAMAGE,y ; groups of 4 x1 -> x2, y1 -> y2
    sta param_col
    iny
    lda TEXTDAMAGE,y
    sta param_row
    iny
    lda TEXTDAMAGE,y
    sta param_count
    iny
    sty param_index
    jsr fasttiles
    beq ?loop1




; Draw sprites by looping through the list of sprites
renderstart
    lda #0
    sta damageindex
    sta param_index

renderloop
    ldx param_index
    jsr evaluate_status
    lda actor_active,x
    beq renderskip      ; skip if zero
    bmi renderend ; end if negative
    jsr get_sprite
    lda actor_l,x
    sta jsrsprite_smc+1
    lda actor_h,x
    sta jsrsprite_smc+2
    lda actor_x,x
    sta param_x
    lda actor_y,x
    sta param_y
    jmp jsrsprite_smc
jsrsprite_smc
    jsr $ffff           ; wish you could JSR ($nnnn)

    ldy damageindex
    lda scratch_col      ; contains the byte index into the line
    sta (damageptr),y
    iny
    clc
    adc damage_w
    sta (damageptr),y
    iny

    ; need to convert hgr y values to char rows
    lda param_y
    lsr a
    lsr a
    lsr a
    sta (damageptr),y
    iny
    lda param_y
    clc
    adc damage_h
    lsr a
    lsr a
    lsr a
    sta (damageptr),y
    iny
    sty damageindex

renderskip
    inc param_index
    bne renderloop

renderend
    rts