;
; example.asm for TR8
;
.org 0

; address of the frame interrupt vector
.equ INT_VECT 0xff00

    ; setup an int handler so we
    ; can use the frame interrupt to sync
    ; and play sounds in background
    ld a, >INT_VECT
    ld x, <INT_VECT
    ld b, <int_handler
    ld [a : x], b
    inc x
    ld b, >int_handler
    ld [a : x], b

    ; enable interrupts
    cif

    ld b, 0
loop:
    call fill_screen
    push b

    ; update sprite position

    ld a, >incx
    ld x, <incx
    ld y, [a : x]
    ld a, >px
    ld x, <px
    ld b, [a : x]
    ; px + incx
    add b, y
    ; 128 - 16
    cmp b, 112
    bnc
    jmp turn_x

    ; new x
    ld [a : x], b
    jmp update_y

turn_x:
    ld a, >incx
    ld x, <incx
    call turn

update_y:
    ld a, >incy
    ld x, <incy
    ld y, [a : x]
    ld a, >py
    ld x, <py
    ld b, [a : x]
    ; py + incy
    add b, y
    ; 128 - 16
    cmp b, 112
    bnc
    jmp turn_y

    ; new y
    ld [a : x], b
    jmp update_done

turn_y:
    ld a, >incy
    ld x, <incy
    call turn

update_done:

    call draw_sprite

    ; wait 1 frame
    halt

    pop b
    jmp loop

;
; Make the sprite change direction and queue a sound
;
; in: [a : x] inc*
turn:
    ;  1 -> -1
    ; -1 -> 1
    ld y, [a : x]
    ld b, 254
    xor y, b
    ld [a : x], y

    ; change color
    ld b, [sp + 2]
    inc b
    and b, 15
    ld [sp + 2], b

    ; play an effect when we turn
    ; alternating two sounds

    ld x, <effect
    ld a, >effect
    ld y, [a : x]
    xor y, 3
    ld [a : x], y

    call sound_queue_effect
    ret

;
; fill frame-buffer
;
; in: reg b color
fill_screen:
    ld a, 0xbf
    ld x, 0
    ld y, 0x40
fill_loop:
    ld [a : x], b
    inc x
    bno
    jmp fill_loop
    inc a
    dec y
    bnz
    jmp fill_loop
    ret

;
; Draw the sprite
;
; in: coordinates in px, py
draw_sprite:
    ; blitter in settings mode
    ld x, 128
    ld a, 0xb0
    port a, x

    ; setup
    inc a
    ; source
    ld x, <sprite
    port a, x
    ld x, >sprite
    port a, x
    ; destination
    ld y, <px
    ld b, >px
    ld x, [b : y]
    port a, x
    ld y, <py
    ld b, >py
    ld x, [b : y]
    port a, x
    ; size 16x16
    ld x, 16
    port a, x
    port a, x

    ; now blit
    dec a
    ld x, 3
    ; 3: write with transparent color support
    port a, x
    ret

sprite:
    .incpng "assets/icon.png"

incx:
    .db 1
px:
    .db 18
incy:
    .db 1
py:
    .db 64

effect:
    .db 1

;
; Our int handler plays / stops sounds
;
int_handler:
    push a
    push b
    push x
    push y
    call sound_play
    pop y
    pop x
    pop b
    pop a
    iret

;
; Queue a sound effect to be played
;
; in: y sound index (1 based)
sound_queue_effect:
    ; can't be interrupted
    sif

    ld a, >sound_efx
    ld x, <sound_efx
    dec y
    ld b, y
    add y, y
    add y, b
    add x, y
    bo
    inc a

    ; effect addr
    ld b, >sound_queue
    ld y, <sound_queue
    push x
    ld x, [a : x]
    ld [b : y], x
    pop x
    inc x
    bo
    inc a
    inc y
    bo
    inc b
    push x
    ld x, [a : x]
    ld [b : y], x
    pop x

    inc x
    bo
    inc a
    ; x has length
    ld x, [a : x]

    ; current is 0
    inc y
    bo
    inc b
    ld a, 0
    ld [b : y], a

    ; length
    inc y
    bo
    inc b
    ld [b : y], x

    cif
    ret

;
; Plays sound in our queue
;
; To be run from the interrupt handler. Can't play effects which data is at 0x0000.
; It is very simple and uses only channel 0.
;
sound_play:
    ld b, >sound_queue
    ld y, <sound_queue

    ; check we have a valid addr in the queue (not 0x0000)
    ld x, [b : y]
    inc y
    bo
    inc b
    ld a, [b : y]
    cmp a, 0
    bnz
    jmp sound_play_has_addr
    cmp x, 0
    bz
    ret

sound_play_has_addr:
    push a

    inc y
    bo
    inc b

    ; is already playing?
    ld a, [b : y]
    cmp a, 0
    bz
    jmp sound_play_start

    ; the sound is active
    pop a
    ld a, [b : y]

    ; another frame
    inc a
    ld [b : y], a

    inc y
    bo
    inc b

    ; is the end?
    ld x, [b : y]
    cmp x, a
    bnc
    ret

    ; no active sound now: set addr to 0x0000
    ld b, >sound_queue
    ld y, <sound_queue
    ld x, 0
    ld [b : y], x
    inc y
    bo
    inc b
    ld [b : y], x

    ; stop the sound
    ld b, 0xc0
    ld y, 0xb0
    port b, y

    ld b, 0xc1
    ld y, 0x11
    port b, y
    ret

sound_play_start:
    ; we start playing
    inc a
    ld [b : y], a

    pop a
    ; a : x has the effect addr

sound_loop:
    ld y, [a : x]
    cmp y, 0xff
    bz
    ret

    ld b, 0xc0
    port b, y

    inc x
    bo
    inc a

    ld y, [a : x]

    ld b, 0xc1
    port b, y

    inc x
    bo
    inc a

    jmp sound_loop

sound_queue:
    ; effect addr, current frame count, length
    .ds 4, 0

sound_efx:
    ; addr to the instrument data
    .dw sound_efx_data0
    ; length in frames
    .db 2
    .dw sound_efx_data1
    .db 2

sound_efx_data0:
    ; register, value
    .db 0x20, 0x01
    .db 0x40, 0x10
    .db 0x60, 0xF0
    .db 0x80, 0x77
    .db 0xA0, 0x81
    .db 0x23, 0x01
    .db 0x43, 0x00
    .db 0x63, 0xF0
    .db 0x83, 0x77
    .db 0xe0, 0x03
    .db 0xB0, 0x31
    ; end of sequence marker
    .db 0xff

sound_efx_data1:
    ; register, value
    .db 0x20, 0x01
    .db 0x40, 0x10
    .db 0x60, 0xF0
    .db 0x80, 0x77
    .db 0xA0, 0xb0
    .db 0x23, 0x01
    .db 0x43, 0x00
    .db 0x63, 0xF0
    .db 0x83, 0x77
    .db 0xe0, 0x03
    .db 0xB0, 0x31
    ; end of sequence marker
    .db 0xff