bytestream.s

;
; Bytestream module.
; This implement a kind of bytecode based scripting system with simple compact commands.
; This is not definitely not as fast as pure assembler, but it's much more compact
;
#include "params.h"
#include "game_enums.h"

    .zero 

_gCurrentStream             .dsb 2   ; @stream script_command
_gCurrentStreamStop         .dsb 1   ; @enum stream_stop_flags  (1=Stop 2=Wait 4=Refresh 8=PartialRefresh, OR'd)
_gDelayStream               .dsb 2
_gStreamCutScene            .dsb 1   ; 1 = In a cut scene @bool
_gStreamSkipPoint           .dsb 2   ; Pointer to a label where we can jump if the user presses spaces during a cut scene

_gCurrentItem               .dsb 1   ; Used to handle the e_ITEM_CURRENT value, set by DispatchStream  @enum item_id
_gStreamItemPtr             .dsb 2   ; Used to store the address of an item of interest (gItems+6*item id)  @ptr16 item
_gStreamAssociatedItemPtr   .dsb 2   ; associated item pointer, needs to be behind _gStreamItemPtr in memory  @ptr16 item
_gCurrentAssociatedItem     .dsb 1   ; Similar to _gCurrentItem but for containers  @enum item_id

_gStreamLocationPtr         .dsb 2   ; Used to store the address of a location of interest (gLocations+10*location id) @ptr16 location
_gStreamNextPtr             .dsb 2   ; Updated after the functions that prints stuff to know how long the string was 
_gStreamReturnPtr           .dsb 2   ; The ONE level of subfunction we are allowed to call using GOSUB and RETURN

    .text 

_ByteStreamCallbacks
    .word _ByteStreamCommand_END
    .word _ByteStreamCommand_RECTANGLE
    .word _ByteStreamCommand_FILL_RECTANGLE
    .word _ByteStreamCommand_TEXT
    .word _ByteStreamCommand_WHITE_BUBBLE
    .word _ByteStreamCommand_BLACK_BUBBLE
    .word _ByteStreamCommand_WAIT
    .word _ByteStreamCommand_BITMAP
    .word _ByteStreamCommand_FADE_BUFFER
    .word _ByteStreamCommand_JUMP
    .word _ByteStreamCommand_JUMP_IF_TRUE
    .word _ByteStreamCommand_JUMP_IF_FALSE
    .word _ByteStreamCommand_INFO_MESSAGE
    .word _ByteStreamCommand_DISPLAY_IMAGE
    .word _ByteStreamCommand_DISPLAY_IMAGE_ONLY
    .word _ByteStreamCommand_END_AND_REFRESH
    .word _ByteStreamCommand_ERROR_MESSAGE
    .word _ByteStreamCommand_SET_ITEM_LOCATION
    .word _ByteStreamCommand_SET_ITEM_FLAGS
    .word _ByteStreamCommand_UNSET_ITEM_FLAGS
    .word _ByteStreamCommand_SET_ITEM_DESCRIPTION
    .word _ByteStreamCommand_SET_LOCATION_DIRECTION
    .word _ByteStreamCommand_UNLOCK_ACHIEVEMENT
    .word _ByteStreamCommand_INCREASE_SCORE
    .word _ByteStreamCommand_GAME_OVER
    .word _ByteStreamCommand_CLEAR_FULL_TEXT_AREA
    .word _ByteStreamCommand_SET_SCENE_IMAGE
    .word _ByteStreamCommand_DISPLAY_IMAGE_NOBLIT
    .word _ByteStreamCommand_CLEAR_TEXT_AREA
    .word _ByteStreamCommand_GOSUB
    .word _ByteStreamCommand_RETURN
    .word _ByteStreamCommand_DO_ONCE
    .word _ByteStreamCommand_SET_CUTSCENE
    .word _ByteStreamCommand_PLAY_SOUND
    .word _ByteStreamCommand_WAIT_RANDOM
    .word _ByteStreamCommand_START_CLOCK
    .word _ByteStreamCommand_STOP_CLOCK
    .word _ByteStreamCommand_END_AND_PARTIAL_REFRESH
    .word _ByteStreamCommand_LOAD_MUSIC
    .word _ByteStreamCommand_STOP_MUSIC                  ; Implemented in akyplayer.s
    .word _ByteStreamCommand_WAIT_KEYPRESS               ; Implemented in keyboard.s -> Result in _gInputKey
    .word _ByteStreamCommand_QUICK_MESSAGE
    .word _ByteStreamCommand_SET_SKIP_POINT
    .word _ByteStreamCommand_SET_PLAYER_LOCATTION
    .word _ByteStreamCommand_SET_CURRENT_ITEM
    .word _ByteStreamCommand_COMMAND_CALL_NATIVE
    .word _ByteStreamCommand_COMBINE_ITEMS
    .word _ByteStreamCommand_KEYPRESS_MESSAGE
    .word _ClearBubbleCount                              ; COMMAND_CLEAR_BUBBLES — alias to the existing helper (no args, returns via rts)
    .word _ByteStreamCommand_SET_STRIDE                  ; COMMAND_SET_STRIDE — sets _gSourceStride for the next BITMAP, auto-reverts to 40
    .word _ByteStreamCommand_DISPLAY_IMAGE_NO_CLEAR_TEXT


; Checks if there's a stream delay active.
; If no delay is active, does nothing and returns zero
; If there's a delay, decrements it and returns 1
_DecrementDelayStream
.(
    lda _gDelayStream+0             ; Are we executing a WAIT command?
    ora _gDelayStream+1
    bne decrement
    rts                             ;  A contains zero value

decrement    
    lda _gDelayStream+0             ; Decrement and wait
    bne skip
    dec _gDelayStream+1
skip
    dec _gDelayStream+0
    lda #1
    rts
.)

; Loop that executes a stream stream.
; Handles the skipable cut scenes as well as timed delays (in numbers of frames)
_HandleByteStream
    ;jmp _HandleByteStream
.(
    jsr _DecrementDelayStream 
    bne end_stream                   ; Still decrementing the delay

    lda _gCurrentStream+0            ; Do we have a valid stream pointer?
    ora _gCurrentStream+1
    beq end_stream

    lda #<$a000                      ; By default, all the draw commands to to the screen
    sta _gDrawAddress+0
    lda #>$a000
    sta _gDrawAddress+1

    lda #0                           ; And we make sure we are in running mode
    sta _gCurrentStreamStop

loop_next_command                    ; Command loop
    jsr _ByteStreamGetNextByte       ; Fetch the next command id (increments the pointer, return the value in X and a)
    cpx #_COMMAND_COUNT              ; Is it a valid command?
    bcc valid_command
    jsr _Panic                       ; Probably corrupted stream, definitely not a valid command
valid_command
    
    asl                              ; Multiply the command id by 2...
    tax
    lda _ByteStreamCallbacks+0,x     ; ...and use it as an index in the command callbak table
    sta auto_callback+0
    lda _ByteStreamCallbacks+1,x
    sta auto_callback+1
auto_callback = *+1
    jsr $0000                        ; Call the function

    lda _gStreamCutScene             ; Is the cut scene mode enabled?
    beq check_stream_end

delay_stream_loop                    ; Delay loop
    jsr _DecrementDelayStream        ; Decrement the delay loop
    beq check_stream_end             ; Done

    jsr _WaitIRQ                     ; Wait one frame

    lda _gStreamSkipPoint+0           ; If we have a skip point and the keyboard is pressed, jump there immediately
    ora _gStreamSkipPoint+1           ; This is used to skip the intro sequence when reaching the market place.
    beq delay_stream_loop
    jsr _ReadKeyNoBounce
    beq delay_stream_loop

    lda _gStreamSkipPoint+0           ; Jump the stream to the skip point position
    sta _gCurrentStream+0
    lda _gStreamSkipPoint+1
    sta _gCurrentStream+1

    lda #0
    sta _gStreamSkipPoint+0           ; Clear the skip point
    sta _gStreamSkipPoint+1
    sta _gDelayStream+0
    sta _gDelayStream+1

check_stream_end
    lda _gCurrentStreamStop          ; Should we contine the execution of commands?
    beq loop_next_command            ; Can be triggered by END, WAIT, END_AND_REFRESH

end_stream    
    rts
.)

    
; _param0=pointer to the new byteStream
_PlayStreamAsm
.(
    lda _param0+0
    sta _gCurrentStream+0
    lda _param0+1
    sta _gCurrentStream+1
+_PlayStreamAsm_gCurrentStream
    lda #0
	sta _gDelayStream
    sta _gCurrentStreamStop
    sta _gStreamCutScene

loop
    jsr _WaitIRQ
    jsr _HandleByteStream        ; Eventually perform a delay if gDelayStream is set

    lda _gCurrentStreamStop
    and #FLAG_END_STREAM
    bne stream_stop

    lda _gCurrentStream+0
    bne loop
    lda _gCurrentStream+1
    bne loop
quit
    rts
stream_stop
    lda _gCurrentStreamStop
    and #FLAG_REFRESH_SCENE
    beq check_partial_refresh
    jmp _LoadScene
check_partial_refresh    
    lda _gCurrentStreamStop
    and #FLAG_PARTIAL_REFRESH
    beq quit
+_RefreshSceneInformation
    lda #16+4
    sta _param0
    jsr _ClearMessageWindowAsm
    jmp _PrintSceneInformation
.)


; _param0=id of the element we are searching for in the table
; _param1=pointer to a table with id:stream pointer
;
; Each entry is 3 bytes (id, stream_lo, stream_hi) so the table with 85+ entries is now longer than 255 bytes
_DispatchStream
.(
    ; Store the item id into "CurrentItem"
    lda _param0         ; @enum item_id
    sta _gCurrentItem

search_loop
    ldy #0
    lda (_param1),y     ; Check the ID in the table  @enum item_id
    cmp _param0         ; Does that match the ID we are looking for?
    beq matched
    cmp #MAPPING_REDIRECT  ; Redirect: retry with a different table?
    beq redirect
    cmp #MAPPING_DEFAULT   ; End of table (default handler)?
    beq matched

    ; Advance _param1 to the next entry
    clc
    lda _param1
    adc #3
    sta _param1
    bcc search_loop
    inc _param1+1
    bne search_loop     ; Always (table never starts in zero page)

matched
    iny                 ; Y=1, _PlayMatchedStream expects Y at the stream-pointer lo byte
    jmp _PlayMatchedStream

redirect
    ; Replace the table pointer with the redirect target and restart the search
    iny                 ; Y=1
    lda (_param1),y
    pha
    iny                 ; Y=2
    lda (_param1),y
    sta _param1+1
    pla
    sta _param1
    jmp _DispatchStream
.)


; Dispatches a two-item action by searching a mapping table for a (param0, param2) pair.
; Currently used exclusively by the COMBINE instruction.
;
; _param0=id of the first item
; _param1=pointer to a mapping table [id1, id2, stream_lo, stream_hi, ...] terminated by id2=255
; _param2=id of the second item
;
; The two item IDs are sorted (smaller first) before searching, matching the COMBINE_MAPPING
; macro which auto-sorts its entries the same way. This halves the table size vs storing both
; orderings, and since containers always have the smallest IDs (0..e_ITEM__Last_Container),
; the sorted _param0 is the only one that needs checking for the container fallback.
;
; If a match is found in the table, plays the associated stream.
; If no match is found, checks whether _param0 is a container and _param2 a compatible item.
; If so, interprets as a TAKE command with both items. Otherwise plays the default error stream.
_DispatchStream2
.(
    ; Store the item id into "CurrentItem" and sort so the smaller ID
    ; is in _param0, larger in _param2. This matches the COMBINE_MAPPING
    ; table which auto-sorts entries the same way.
    lda _param0
    sta _gCurrentItem
    cmp _param2
    bcc sorted                           ; _param0 < _param2, already in order
    beq sorted                           ; Equal, no swap needed
    ldx _param2                          ; Swap: A = _param0 (larger), X = _param2 (smaller)
    sta _param2
    stx _param0
sorted

    ldy #0
search_loop
    lda (_param1),y     ; Get the first ID from the table
    iny
    tax                 ; Copy to X
    lda (_param1),y     ; Check the second in the table
    iny
    cmp #MAPPING_DEFAULT ; Is it the end of the table?
    beq end_of_table

    cpx _param0         ; Does that match the first ID we are looking for?
    bne no_match
    cmp _param2         ; Does that match the second ID we are looking for?
    beq _PlayMatchedStream

no_match
    iny                 ; Skip the stream pointer
    iny
    jmp search_loop

    ; Shared by _DispatchStream and _DispatchStream2:
    ; Reads the stream pointer at (_param1),y and plays it.
+_PlayMatchedStream
    lda (_param1),y     ; Copy the stream pointer to _param0
    sta _param0+0
    iny
    lda (_param1),y
    sta _param0+1
    jmp _PlayStreamAsm

end_of_table
    ; No explicit match found in the table.
    ; Y currently points at the default error stream pointer.
    ; Since items are sorted, _param0 has the smaller ID.
    ; Containers have the smallest IDs, so only _param0 can be a container.
    lda _param0+0
    cmp #(e_ITEM__Last_Container + 1)
    bcs _PlayMatchedStream               ; _param0 is NOT a container -> play default error stream

    ; _param0 might be a container. Check if _param2 needs one.
    sty tmp2                             ; Preserve Y (points to default error stream)
    ldx _param0+0                        ; X = potential container ID
    lda _param2+0                        ; A = potential item ID
    jsr _ByteStreamComputeItemPtr        ; _gStreamItemPtr -> item[_param2]
    ldy #5
    lda (_gStreamItemPtr),y              ; usable_containers of _param2
    pha                                  ; Save A — the LDY below would clobber Z and we still need to test for zero
    ldy tmp2                             ; Restore Y for _PlayMatchedStream
    pla                                  ; A back; PLA sets Z based on popped value
    beq _PlayMatchedStream               ; _param2 doesn't need a container -> play default error stream

    ; Match: _param0 = container, _param2 = item needing container
    ; Set up word buffer as [TAKE, item, container] and hand off to TakeItem
    lda _param2+0
    sta _gWordBuffer+1                   ; Item
    lda _param0+0
    sta _gWordBuffer+2                   ; Container
    lda #e_WORD_TAKE
    sta _gWordBuffer+0
    lda #3
    sta _gWordCount
    jmp _TakeItem
.)


; Fetch the value in _gCurrentStream, increment the pointer, return the value in X and a
_ByteStreamGetNextByte
.(
    ldy #0
    lda (_gCurrentStream),y
    inc _gCurrentStream+0
    bne skip    
    inc _gCurrentStream+1
skip
    tax
    rts
.)


_ByteStreamFetchLocationID
.(
    lda (_gCurrentStream),y      // location ID @enum location_id
    cmp #e_LOC_CURRENT
    bne keep_location_id
use_current_location_id    
    lda _gCurrentLocation        // Use the current location
keep_location_id    
    iny
    rts
.)


; Fetches the next byte from the stream and if matches e_ITEM_CURRENT replaces by _gCurrentItem
; Then uses the value to compute the _gStreamItemPtr pointer
_ByteStreamFetchItemID
.(
    lda (_gCurrentStream),y      // item ID @enum item_id
    cmp #e_ITEM_CURRENT
    bne keep_item_id
use_current_item_id    
    lda _gCurrentItem            // Use the current item
keep_item_id    
    iny
    ; fall-through into _ByteStreamComputeItemPtr
; A=Item ID
; Return a pointer on the item in _gStreamItemPtr
; sizeof(item) = 6
; 6 = 4n+2n = n<<2 + n<<1
+_ByteStreamComputeItemPtr
    stx tmp1
    ldx #0
    jsr _ByteStreamComputeItemPtrIndexX
    ldx tmp1
    rts

+_ByteStreamComputeItemPtrIndexX    
    // Item ID
    sta _gStreamItemPtr+0,x
    lda #0
    sta _gStreamItemPtr+1,x

    // x2
    asl _gStreamItemPtr+0,x
    rol _gStreamItemPtr+1,x

    // x4
    lda _gStreamItemPtr+0,x
    asl
    sta tmp0+0
    lda _gStreamItemPtr+1,x
    rol
    sta tmp0+1

    // x6
    clc
    lda _gStreamItemPtr+0,x
    adc tmp0+0
    sta _gStreamItemPtr+0,x
    lda _gStreamItemPtr+1,x
    adc tmp0+1
    sta _gStreamItemPtr+1,x

    // Item pointer
    clc
    lda _gStreamItemPtr+0,x
    adc #<_gItems
    sta _gStreamItemPtr+0,x
    lda _gStreamItemPtr+1,x
    adc #>_gItems
    sta _gStreamItemPtr+1,x
    rts
.)

; A=Refernce Item ID
; Return a pointer on the item in _gStreamItemPtr as well as _gStreamAssociatedItemPtr if there's an associated item (or a copy of it if not)
_ByteStreamComputeDualItemPtr
.(
    ; Fetch the first item
    jsr _ByteStreamComputeItemPtr
    ldy #3
    lda (_gStreamItemPtr),y      // gItems->associated_item (+3) = read associated_item id    
    cmp #255
    beq end_associated_item
    ldx #2
    jsr _ByteStreamComputeItemPtrIndexX
end_associated_item
    rts
.)




; A=Location ID
; Return a pointer on the location in _gStreamLocationPtr
; sizeof(location) = 8 
; 10 = 8n+2n = n<<3 + n<<1
_ByteStreamComputeLocationPtr
    // Location ID
    sta _gStreamLocationPtr+0
    lda #0
    sta _gStreamLocationPtr+1

    // x2
    asl _gStreamLocationPtr+0
    rol _gStreamLocationPtr+1

    // x4
    asl _gStreamLocationPtr+0
    rol _gStreamLocationPtr+1

    // x8
    asl _gStreamLocationPtr+0
    rol _gStreamLocationPtr+1

    // Item pointer
    clc
    lda _gStreamLocationPtr+0
    adc #<_gLocations
    sta _gStreamLocationPtr+0
    lda _gStreamLocationPtr+1
    adc #>_gLocations
    sta _gStreamLocationPtr+1

    rts


_ByteStreamCommand_END
.(
    lda #FLAG_END_STREAM   ; Stop
+_ByteStreamCommandEndWithStopCode
    sta _gCurrentStreamStop
    lda #0
	sta _gCurrentStream+0
    sta _gCurrentStream+1
	sta _gDelayStream
    rts
.)

; .byt COMMAND_END_AND_REFRESH
_ByteStreamCommand_END_AND_REFRESH
.(
    ;jmp _ByteStreamCommandEndAndRefresh
    lda #FLAG_END_STREAM|FLAG_REFRESH_SCENE   ; Stop and refresh scene
    bne _ByteStreamCommandEndWithStopCode
.)


; .byt COMMAND_END_AND_PARTIAL_REFRESH
_ByteStreamCommand_END_AND_PARTIAL_REFRESH
.(
    ;jmp _ByteStreamCommandEndAndRefresh
    lda #FLAG_END_STREAM|FLAG_PARTIAL_REFRESH   ; Stop and refresh the scene information (ie: we don't run all the image loading)
    bne _ByteStreamCommandEndWithStopCode
.)


; .byt COMMAND_WAIT,duration
_ByteStreamCommand_WAIT
.(
    ; In theory the delay could be 8 or 16 bits based on the value, but the code does not use that at the moment
    jsr _ByteStreamGetNextByte
    stx _gDelayStream+0
 
    ; If we are in a cutscene we don't count WAIT instructions as a way to go back to gameplay
    lda _gStreamCutScene
    bne end_stream_stop
    lda #FLAG_WAIT
    sta _gCurrentStreamStop
end_stream_stop    
    rts
.)


;.byt COMMAND_WAIT_RANDOM,base_duration,rand_mask
_ByteStreamCommand_WAIT_RANDOM
.(
    ; In theory the delay could be 8 or 16 bits based on the value, but the code does not use that at the moment
    jsr _ByteStreamGetNextByte
    stx _gDelayStream+0

    ; Call the internal 32 bit randomize function, result is in _randseedLow+0/+1/+2/+3
    jsr _rand32
    jsr _ByteStreamGetNextByte
    txa
    and _randseedLow+0
    clc
    adc _gDelayStream+0
    sta _gDelayStream+0
    
    ; If we are in a cutscene we don't count WAIT instructions as a way to go back to gameplay
    lda _gStreamCutScene
    bne end_stream_stop
    lda #FLAG_WAIT
    sta _gCurrentStreamStop
end_stream_stop    
    rts
.)


_ByteStreamCommand_FADE_BUFFER
    jmp _BlitBufferToHiresWindow


; We can only use GOSUB once, and then we need to RETURN
; Multiple level of GOSUB are not supported, and calling another stream while we are in a GOSUB will probably cause havok
 _ByteStreamCommand_GOSUB
    ; Store the current pointer+2 into the return register
    clc
    lda _gCurrentStream+0
    adc #2
    sta _gStreamReturnPtr+0
    lda _gCurrentStream+1
    adc #0
    sta _gStreamReturnPtr+1

    ; Then overwrite the current stream pointer with the one provided in the GOSUB instruction parameters
    ldy #0
    lda (_gCurrentStream),y
    tax                           ; Temporary so we don't change the stream pointer while using it
    iny
    lda (_gCurrentStream),y
    stx _gCurrentStream+0
    sta _gCurrentStream+1
    rts


; We can only use RETURN if GOSUB has been called before
 _ByteStreamCommand_RETURN
    lda _gStreamReturnPtr+0
    sta _gCurrentStream+0
    lda _gStreamReturnPtr+1
    sta _gCurrentStream+1
    rts


; .byt COMMAND_SET_CUT_SCENE,flag
_ByteStreamCommand_SET_CUTSCENE
.(
    ldy #0
    lda (_gCurrentStream),y       ; Get the cut scene flag
    sta _gStreamCutScene
    lda #1
    jmp _ByteStreamMoveByA
.)

; param0.ptr=registerList;asm("jsr _PlaySoundAsm"); }
; .byt COMMAND_PLAY_SOUND,<sound,>sound
_ByteStreamCommand_PLAY_SOUND
.(
    lda _gSoundEnabled
    beq no_sound

    ldy #0
    lda (_gCurrentStream),y       ; Get the sound file address (low byte)
    sta _param0+0
    iny
    lda (_gCurrentStream),y       ; Get the sound file address (high byte)
    sta _param0+1
    jsr _PlaySoundAsm

no_sound    
    lda #2
    jmp _ByteStreamMoveByA
.)


; .byt COMMAND_LOAD_MUSIC,musicId
_ByteStreamCommand_LOAD_MUSIC
.(
	; unsigned char loaderId = *gCurrentStream++;
    jsr _ByteStreamGetNextByte
    cpx _gCurrentMusicFileIndex
    beq music_already_loaded             ; We only load the music if it's not already the one in memory
    
    ; Load the requested bitmap
    stx _gCurrentMusicFileIndex
    stx _LoaderEntryIndex
    lda #<_ArkosMusic
    sta _LoaderAddressLow
    lda #>_ArkosMusic
    sta _LoaderAddressHigh
    jsr _LoadFileFromDirectory    

music_already_loaded
    lda _gMusicEnabled
    beq no_music
    lda #1+2+4+8+16+32        ; All the three channels are used
    sta _MusicMixerMask
    lda #<_ArkosMusic
    sta _param0+0
    lda #>_ArkosMusic
    sta _param0+1
    jmp _StartMusic
no_music
    rts    
.)



; .byt COMMAND_DO_ONCE,1,<label,>label
_ByteStreamCommand_DO_ONCE
.(
    ldy #0
    lda (_gCurrentStream),y       ; Get the counter
    bne not_done
    iny
    lda (_gCurrentStream),y       ; Script address
    tax                           ; Temporary so we don't change the stream pointer while using it
    iny
    lda (_gCurrentStream),y
    stx _gCurrentStream+0
    sta _gCurrentStream+1
    rts
not_done    
    tax                            ; Decrement the counter
    dex
    txa
    sta (_gCurrentStream),y        ; Write down the counter
    lda #3                         ; Skip counter and address
    jmp _ByteStreamMoveByA
.)


; .byt COMMAND_SET_SKIP_POINT,<label,>label
_ByteStreamCommand_SET_SKIP_POINT
.(
    jsr _ByteStreamGetNextByte
    stx _gStreamSkipPoint+0
    jsr _ByteStreamGetNextByte
    stx _gStreamSkipPoint+1
    rts
.)


; .byt COMMAND_CALL_NATIVE,<address,>address
_ByteStreamCommand_COMMAND_CALL_NATIVE
.(
    ; Fetch the native routine address
    jsr _ByteStreamGetNextByte
    sta _auto_jmp+0
    jsr _ByteStreamGetNextByte
    sta _auto_jmp+1

    ; jmp to it
_auto_jmp = *+1    
    jmp $1234
.)



; .byt COMMAND_JUMP_IF_TRUE,<label,>label,expression
_ByteStreamCommand_JUMP_IF_TRUE
    lda #OPCODE_BEQ                          // F0
    bne common
_ByteStreamCommand_JUMP_IF_FALSE
    lda #OPCODE_BNE                          // D0
common
.(
    sta _auto_conditionCheckItemLocation+0
    sta _auto_conditionCheckPlayerLocation+0
    sta _auto_conditionCheckItemContainer+0
    sta _auto_conditionCheckAdressValue+0
    eor #OPCODE_BEQ-OPCODE_BNE               //  0b100000
    sta _auto_conditionCheckItemFlag+0       // Item flags check is inverted
    ldy #2
    lda (_gCurrentStream),y       ; @enum operator_id
    bne checkItemFlag

checkItemLocation                // OPERATOR_CHECK_ITEM_LOCATION 0 
    ; check =  (gItems[itemId].location == locationId);
    iny
    jsr _ByteStreamFetchItemID
    jsr _ByteStreamFetchLocationID // location id
    ldy #2
    cmp (_gStreamItemPtr),y      // gItems->location (+2)
_auto_conditionCheckItemLocation
    bne _ByteStreamCommand_JUMP   // BNE/BEQ depending of the command
    jmp _ByteStreamMoveBy5

checkPlayerLocation              // OPERATOR_CHECK_PLAYER_LOCATION 2 
    ; check =  (gItems[itemId].location == locationId);
    iny
    jsr _ByteStreamFetchLocationID // location id
    ldy #2
    cmp _gCurrentLocation         // Player position
_auto_conditionCheckPlayerLocation    
    bne _ByteStreamCommand_JUMP   // BNE/BEQ depending of the command
    lda #4
    jmp _ByteStreamMoveByA

; .byt COMMAND_JUMP,<label,>label
+_ByteStreamCommand_JUMP
    ldy #0
    lda (_gCurrentStream),y       ; @word @stream script_command
    tax                           ; Temporary so we don't change the stream pointer while using it
    iny
    lda (_gCurrentStream),y
    stx _gCurrentStream+0
    sta _gCurrentStream+1
    rts

checkItemContainer
    ; check =  (gItems[itemId].flags & flagId);
    iny
    jsr _ByteStreamFetchItemID
    lda (_gCurrentStream),y      // container item ID (compared to associated_item)  @enum item_id
    ldy #3
    cmp (_gStreamItemPtr),y      // gItems->associated_item (+3)
_auto_conditionCheckItemContainer
    bne _ByteStreamCommand_JUMP   // BNE/BEQ depending of the command
    jmp _ByteStreamMoveBy5

checkItemFlag                    // OPERATOR_CHECK_ITEM_FLAG 1
    cmp #OPERATOR_CHECK_PLAYER_LOCATION
    beq checkPlayerLocation
    cmp #OPERATOR_CHECK_ITEM_CONTAINER
    beq checkItemContainer
    cmp #OPERATOR_CHECK_ADDRESS_VALUE
    beq checkAdressValue
    ; check =  (gItems[itemId].flags & flagId);
    iny
    jsr _ByteStreamFetchItemID
    lda (_gCurrentStream),y      // flag ID  @enum item_flags
    ldy #4
    and (_gStreamItemPtr),y      // gItems->flags (+4)
_auto_conditionCheckItemFlag
    bne _ByteStreamCommand_JUMP   // BNE/BEQ depending of the command

+_ByteStreamMoveBy5    ; Continue (jump not taken)
    lda #5
+_ByteStreamMoveByA    
    clc 
    adc _gCurrentStream+0
    sta _gCurrentStream+0
    lda _gCurrentStream+1
    adc #0
    sta _gCurrentStream+1
    rts

checkAdressValue                 // OPERATOR_CHECK_ADDRESS_VALUE,<address,>address,value
    ; check =  (*address == value);
    iny
    lda (_gCurrentStream),y      // <address
    sta _auto_cmp+0
    iny
    lda (_gCurrentStream),y      // >address
    sta _auto_cmp+1
    iny
    lda (_gCurrentStream),y      // value
_auto_cmp = *+1    
    cmp $1234
_auto_conditionCheckAdressValue
    bne _ByteStreamCommand_JUMP   // BNE/BEQ depending of the command
    lda #6
    jmp _ByteStreamMoveByA
.)


; .byt COMMAND_SET_PLAYER_LOCATION,location
_ByteStreamCommand_SET_PLAYER_LOCATTION
.(
    jsr _ByteStreamGetNextByte
    stx _gCurrentLocation
    rts
.)


; Can be used to change in a script what the current item is (by default that is set to the item that triggered the script)
; .byt COMMAND_SET_CURRENT_ITEM,item
_ByteStreamCommand_SET_CURRENT_ITEM
.(
    jsr _ByteStreamGetNextByte
    stx _gCurrentItem
    rts
.)


; Can be used to set the location of any item
; .byt COMMAND_SET_ITEM_LOCATION,item,location
_ByteStreamCommand_SET_ITEM_LOCATION
.(
    ldy #0
    jsr _ByteStreamFetchItemID
    lda (_gCurrentStream),y      // location id  @enum location_id
    cmp #e_LOC_CURRENT
    bne store_location
    lda _gCurrentLocation        // Use the current player location
store_location    
    ldy #2
    sta (_gStreamItemPtr),y      // gItems->location (+2) = location id
    sta tmp2                     // Save the location in tmp2 (tmp0 AND tmp1 are modified by _ByteStreamComputeItemPtr)
    
    ; If the item is in a container and the location is not the inventory, we need to empty it
    cmp #e_LOC_INVENTORY
    beq end_container
    iny
    lda (_gStreamItemPtr),y      // gItems->associated_item (+3) = read associated_item id    
    cmp #255
    beq end_container
    pha
    lda #255
    sta (_gStreamItemPtr),y      // gItems->associated_item (+3) = clear associated_item id in item  
    pla
    jsr _ByteStreamComputeItemPtr  // Get the container pointer
    lda #255
    sta (_gStreamItemPtr),y      // gItems->associated_item (+3) = clear associated_item id  in container
    iny
    lda (_gStreamItemPtr),y      // gItems->flags (+4) = read flags
    and #ITEM_FLAG_IS_CONTAINER
    bne end_container            // If the associated object is a container, it stays where it is
    ldy #2
    lda tmp2                     // Reload the saved location so the transported items don't stay in the inventory
    sta (_gStreamItemPtr),y      // gItems->location (+2) = location id
end_container   
    
    lda #2
    jmp _ByteStreamMoveByA
.)




; Combines two or three items into a result, intelligently placing it based on input locations
; .byt COMMAND_COMBINE_ITEMS,item1,item2,item3_or_255,result
_ByteStreamCommand_COMBINE_ITEMS
.(
    ; Start with destination = current location, no container
destinationLocation   = tmp2
destinationContainer  = tmp3
destinationID         = tmp4
    lda _gCurrentLocation
    sta destinationLocation         ; Use current location by default
    lda #255
    sta destinationContainer        ; no container by default

    ldy #0
    jsr _CombineProcessSourceItem   ; First source item
    ldy #1
    jsr _CombineProcessSourceItem   ; Second source item
    ldy #2
    jsr _CombineProcessSourceItem   ; Third source item
    ldy #3
    lda (_gCurrentStream),y         ; Target item ID  @enum item_id
    sta destinationID

    lda destinationContainer        ; If one of the source items was in a container, we try to reuse it to store the result...
    cmp #255
    beq no_container                ; ...there was not container to reuse

    jsr _ByteStreamComputeItemPtr   ; Fetch the container status
    ldy #2
    lda (_gStreamItemPtr),y         ; Location field
    cmp #e_LOC_GONE_FOREVER
    beq no_container                ; ...the container was destroyed

    lda destinationID
    jsr _ByteStreamComputeItemPtr   ; Fetch the destination item status
    ldy #5
    lda (_gStreamItemPtr),y         ; Does that item require a container?
    beq no_container                ; ...no container needed

    ; Put the result in a container 
    ldy #2
    lda destinationLocation
    sta (_gStreamItemPtr),y         ; result->location = destination
    iny
    lda destinationContainer
    sta (_gStreamItemPtr),y         ; result->associated_item = container
    jsr _ByteStreamComputeItemPtr
    lda destinationID
    bne done

no_container
    lda destinationID
    jsr _ByteStreamComputeItemPtr
    ldy #2
    lda destinationLocation
    sta (_gStreamItemPtr),y         ; result->location = destination
    lda #255
done
    ldy #3
    sta (_gStreamItemPtr),y         ; result->associated_item
    lda #4
    jmp _ByteStreamMoveByA

; Destructively process a source items from the stream,
; We need to remember the location and eventual container to reuse that in the final result item
_CombineProcessSourceItem
    lda (_gCurrentStream),y 
    cmp #255                        ; Valid item ID?
    beq end_process_source_item       
    jsr _ByteStreamComputeDualItemPtr ; _gStreamItemPtr = item, _gStreamAssociatedItemPtr = container
    ldy #2
    lda (_gStreamItemPtr),y         ; item->location
    cmp _gCurrentLocation
    beq no_location_update
    sta destinationLocation         ; Update destination to item's location
no_location_update
    lda #e_LOC_GONE_FOREVER
    sta (_gStreamItemPtr),y         ; item->location = gone forever
    iny
    lda (_gStreamItemPtr),y         ; item->associated_item
    cmp #255
    beq end_process_source_item
    sta destinationContainer        ; Update destination container
    
    lda #255                        ; Clear the container's back-reference to the consumed item
    sta (_gStreamAssociatedItemPtr),y ; container->associated_item = 255
end_process_source_item
    rts
.)

// .byt COMMAND_SET_ITEM_FLAGS,item,flags
 _ByteStreamCommand_SET_ITEM_FLAGS
 .(
    ldy #0
    jsr _ByteStreamFetchItemID
    lda (_gCurrentStream),y      // flag mask  @enum item_flags
    ldy #4
    ora (_gStreamItemPtr),y      // gItems->flags (+4) |= flag mask
    sta (_gStreamItemPtr),y      // gItems->flags (+4) |= flag mask

    lda #2
    jmp _ByteStreamMoveByA
 .)

; .byt COMMAND_UNSET_ITEM_FLAGS,item,flags
 _ByteStreamCommand_UNSET_ITEM_FLAGS
 .(
    ldy #0
    jsr _ByteStreamFetchItemID
    lda (_gCurrentStream),y      // flag mask (inverted: bits to KEEP)  @enum item_flags
    ldy #4
    and (_gStreamItemPtr),y      // gItems->flags (+4) &= flag mask
    sta (_gStreamItemPtr),y      // gItems->flags (+4) |= flag mask

    lda #2
    jmp _ByteStreamMoveByA
 .)

; .byt COMMAND_SET_ITEM_DESCRIPTION,item,description,0
_ByteStreamCommand_SET_ITEM_DESCRIPTION
.(
    ldy #0
    jsr _ByteStreamFetchItemID
    lda #1
    jsr _ByteStreamMoveByA

    ldy #0
    lda _gCurrentStream+0
    sta (_gStreamItemPtr),y      // gItems->description (+0) = <_gCurrentStream
    iny
    lda _gCurrentStream+1
    sta (_gStreamItemPtr),y      // gItems->description (+1) = >_gCurrentStream

+FindNullTerminator
    ; Find the null terminator
    ldy #0
search_loop
    lda (_gCurrentStream),y      // item ID  @enum item_id
    beq found_zero
    iny
    bne search_loop

found_zero
    iny
    tya

    jmp _ByteStreamMoveByA
.)



; .byt COMMAND_SET_SCENE_IMAGE,imageId
_ByteStreamCommand_SET_SCENE_IMAGE
.(
    ldy #0
    lda (_gCurrentStream),y      // Image ID
    sta _gSceneImage

    ; TODO: In theory should implement that so we don't have double loading
    ;LoadFileAt(gSceneImage,ImageBuffer);	
    lda _gSceneImage:sta _LoaderEntryIndex
    lda #<_ImageBuffer:sta _LoaderAddressLow
    lda #>_ImageBuffer:sta _LoaderAddressHigh
    jsr _LoadFileFromDirectory

    lda #1
    jmp _ByteStreamMoveByA
.)


;                                     +0       +1        +2
; .byt COMMAND_SET_LOCATION_DIRECTION,location,direction,value
_ByteStreamCommand_SET_LOCATION_DIRECTION
.(
    ldy #0
    lda (_gCurrentStream),y      // location ID  @enum location_id
    jsr _ByteStreamComputeLocationPtr

    iny
    lda (_gCurrentStream),y      // Direction to update  @enum direction_id
    sta tmp0

    iny
    lda (_gCurrentStream),y      // New destination location for this direction  @enum location_id

    ldy tmp0
    sta (_gStreamLocationPtr),y  // _gStreamLocationPtr->directions[requested direction] (+0) = new value

    jsr _PrintSceneDirections

    lda #3
    jmp _ByteStreamMoveByA
.)



; .byt COMMAND_UNLOCK_ACHIEVEMENT,achievement
_ByteStreamCommand_UNLOCK_ACHIEVEMENT
.(
    ldy #0
    lda (_gCurrentStream),y             // Achievement value  @enum achievement
    sta _param0
    jsr _UnlockAchievementAsm

    lda #1
    jmp _ByteStreamMoveByA
.)

; .byt COMMAND_INCREASE_SCORE,<points,>points
_ByteStreamCommand_INCREASE_SCORE
.(
    clc

    ldy #0
    lda (_gCurrentStream),y             // Number of points (low)
    adc _gScore+0                       // Add to existing score
    sta _gScore+0
    lda #0
    sta (_gCurrentStream),y             // Resets the score value to make sure we don't give points twice if the command is called twice

    iny
    lda (_gCurrentStream),y             // Number of points (high)
    adc _gScore+1
    sta _gScore+1
    lda #0
    sta (_gCurrentStream),y             // Resets the score value to make sure we don't give points twice if the command is called twice

    lda #2
    jmp _ByteStreamMoveByA
.)


; .byt COMMAND_GAME_OVER,condition
_ByteStreamCommand_GAME_OVER
.(
    ldy #0
    lda (_gCurrentStream),y             // Gameover condition
    sta _gGameOverCondition

    jsr _StopClock                      // Also stop the clock to be fair to the player

    lda #1
    jmp _ByteStreamMoveByA
.)

; .byt COMMAND_START_CLOCK
_ByteStreamCommand_START_CLOCK
    jmp _StartClock

; .byt COMMAND_STOP_CLOCK
_ByteStreamCommand_STOP_CLOCK
    jmp _StopClock



_ByteStreamCommandFetchRectangleData
.(
    ; Fetch x/y/width/height/pattern parameters
    ldy #0
loop    
    lda (_gCurrentStream),y
    sta _gDrawPosX,y
    iny
    cpy #5
    bne loop
    ; Increment the pointer
    jmp _ByteStreamMoveBy5
.)    


_ByteStreamCommand_RECTANGLE
    jsr _ByteStreamCommandFetchRectangleData
	jmp _DrawFilledRectangle


_ByteStreamCommand_FILL_RECTANGLE
    jsr _ByteStreamCommandFetchRectangleData
	jmp _DrawFilledRectangle


_ByteStreamCommand_TEXT
    ; Fetch x/y/pattern
    ldy #0
    lda (_gCurrentStream),y
    sta _gDrawPosX

    iny
    lda (_gCurrentStream),y
    sta _gDrawPosY

    iny
    lda (_gCurrentStream),y
    sta _gDrawPattern

    ; Store the current pointer 
    clc
    lda _gCurrentStream+0
    adc #3
    sta _gDrawExtraData+0
    lda _gCurrentStream+1
    adc #0
    sta _gDrawExtraData+1

    ; Print the string (modifies the ExtraData pointer to point to the next string)
    jsr _PrintFancyFont

    ; Update the pointer
    lda _gDrawExtraData+0
    sta _gCurrentStream+0
    lda _gDrawExtraData+1
    sta _gCurrentStream+1
    rts


; _param0+0/+1=pointer to message
; Returns len in y and a
_GetStringLen
.(
    ldy #0
loop    
    lda (_param0),y
    beq end_loop2
    iny
    jmp loop

end_loop2
    tya
    rts
.)


; Adjust the pointer to the next position (_param0+y+1)
_Adjust_gStreamNextPtr
.(
    tya
    sec
    adc _param0+0
    sta _gStreamNextPtr+0
    lda _param0+1
    adc #0
    sta _gStreamNextPtr+1

    rts
.)



; _param0+0/+1=pointer to message
; _param1=color
_PrintStatusMessageNextLineAsm
    clc
    lda _gStatusMessageLocation+0
    adc #40
    sta tmp0+0
    sta tmp1+0
    lda _gStatusMessageLocation+1
    adc #0
    sta tmp0+1
    sta tmp1+1
    jmp _PrintStatusMessageAddr

_PrintStatusMessageAsm
    ;rts
    ;jmp _PrintStatusMessageAsm
.(
    ; char* ptrScreen=(char*)0xbb80+40*22;
    lda _gStatusMessageLocation+0
    sta tmp0+0
    sta tmp1+0
    lda _gStatusMessageLocation+1
    sta tmp0+1
    sta tmp1+1
+_PrintStatusMessageAddr
    ; Write the color code
    ldy #1
    lda _param1
    sta (tmp0),y
    sta (tmp1),y

    ; Clear the rest of the line
    lda #32
loop_clear
    iny
    sta (tmp0),y
    sta (tmp1),y
    cpy #39
    bne loop_clear

    ; Write the message
    clc
    lda tmp0+0
    adc #2
    sta tmp0+0
    lda tmp0+1
    adc #0
    sta tmp0+1

    clc
    lda tmp1+0
    adc #2
    sta tmp1+0
    lda tmp1+1
    adc #0
    sta tmp1+1

    ldy #0
loop_message    
    lda (_param0),y
    beq end_message
    sta (tmp0),y
    sta (tmp1),y
    iny
    jmp loop_message
end_message    
    ; Adjust the pointer to the next position (_param0+y+1)
    jmp _Adjust_gStreamNextPtr
.)


; _param0+0/+1=pointer to message
_PrintInformationMessageAsm
.(
    ; Set the color
    lda #3
    sta _param1

    ; Print the message
    jsr _PrintStatusMessageAsm

    ; Wait a bit after the message is displayed
    jmp _WaitAfterMessage
.)


; _param0+0/+1=pointer to message
_PrintErrorMessageShortAsm
.(
    ; Set a short delay
    lda #50
    pha 
    jmp print_error_common
+_PrintErrorMessageAsmAX    
    sta _param0+0
    stx _param0+1
+_PrintErrorMessageAsm
    jsr _PlayErrorSound

    lda _param0+0
    sta _gCurrentStream+0
    lda _param0+1
    sta _gCurrentStream+1
    jsr _ByteStreamCommand_ERROR_MESSAGE

    lda #0
	sta _gCurrentStream+0
    sta _gCurrentStream+1

    jmp _RefreshSceneInformation

print_error_common
    ; Set the color
    lda #1
    sta _param1

    ; Print the message
    jsr _PrintStatusMessageNextLineAsm

    ; Play a 'Ping' sound
    jsr _PlayErrorSound

    ; Wait a bit after the message is displayed
    pla 
    jmp _WaitAfterMessageCommon
.)

_LongWaitAfterMessage
.(
    lda #150
    bne _WaitAfterMessageCommon
+_ShortWait
    lda #12
    bne _WaitAfterMessageCommon
+_WaitAfterMessage
    ; Wait 75 frames
    lda #75
+_WaitAfterMessageCommon    
    sta _param0+0
    lda #0
    sta _param0+1

    jmp _WaitFramesAsm
.)

; QUICK_MESSAGE has no pause
; INFO_MESSAGE has the standard 75 frame, and is generally followed by WAIT(50*2), total = 175 frames

; Uses _gCurrentStream and _gStreamNextPtr
; .byt COMMAND_KEYPRESS_MESSAGE,message,0
_ByteStreamCommand_KEYPRESS_MESSAGE
.(
    jsr _ByteStreamCommand_QUICK_MESSAGE
    jsr _WaitAfterMessage                ; 75 frame pause
    jmp _ByteStreamCommand_WAIT_KEYPRESS ; Then wait for keypress
.)

; .byt COMMAND_INFO_MESSAGE,message,0
_ByteStreamCommand_INFO_MESSAGE
.(
    jsr _ByteStreamCommand_QUICK_MESSAGE

    ; Wait a bit after the message is displayed
    jmp _LongWaitAfterMessage
.)

; .byt COMMAND_QUICK_MESSAGE,message,0
_ByteStreamCommand_QUICK_MESSAGE
.(
    ; PrintInformationMessage(gCurrentStream);    // Should probably return the length or pointer to the end of string
    ; _param0+0/+1=pointer to message (stored in gCurrentStream)
    lda _gCurrentStream+0
    sta _param0+0
    lda  _gCurrentStream+1
    sta _param0+1

    ; Set the double height attribute
    lda #10
    sta _param1

    ; Set a different screen location for the big messages
    lda #<($bb80+40*20)
    sta tmp0+0
    lda #>($bb80+40*20)
    sta tmp0+1
    lda #<($bb80+40*21)
    sta tmp1+0
    lda #>($bb80+40*21)
    sta tmp1+1
    
    jsr _PrintStatusMessageAddr

    ; gCurrentStream += strlen(gCurrentStream)+1;
    lda _gStreamNextPtr+0
    sta _gCurrentStream+0
    lda _gStreamNextPtr+1
    sta _gCurrentStream+1
    rts
.)


; PrintErrorMessage(gTextAGenericWhiteBag);    // "It's just a white generic bag"
; Uses _gCurrentStream and _gStreamNextPtr
_ByteStreamCommand_ERROR_MESSAGE
.(
    ; Make the window purple
    lda #16+5
    sta _param0
    jsr _ClearMessageWindowAsm            ; Clear X

    jmp _ByteStreamCommand_INFO_MESSAGE
.)


; _param0=paper color
_ClearMessageAndInventoryWindow
.(
    ldx #1+23+4-18-1
    jmp common_bit
+_ClearMessageWindowAsmX
    stx _param0+0
+_ClearMessageWindowAsm
    ldx #1+23-18-1
common_bit
    ; Pointer to first line of the "window"
    lda #<$bb80+40*17
    sta tmp0+0
    lda #>$bb80+40*17
    sta tmp0+1

    ; Top fluff
    lda _param0
    and #7          ; Ink color
    ldy #0
    sta (tmp0),y
    iny
    lda #"/"
    sta (tmp0),y
    iny
    lda #127
loop_top_fluff    
    sta (tmp0),y
    iny
    cpy #38
    bne loop_top_fluff
    lda #"\"
    sta (tmp0),y

    ; Then start painting the bit area
    jsr _Add40ToTmp0

loop_line
    ; Erase the 39 last characters of that line
    ldy #39
    lda #32
loop_column
    sta (tmp0),y
    dey
    bne loop_column

    ; Paper color at the start of the line
    lda _param0
    sta (tmp0),y

    ; Next line
    jsr _Add40ToTmp0

    dex
    bne loop_line

    ; Bottom fluff
    lda _param0
    and #7          ; Ink color
    ldy #0
    sta (tmp0),y
    iny
    lda #"<"
    sta (tmp0),y
    iny
    lda #"="
loop_bottom_fluff    
    sta (tmp0),y
    iny
    cpy #38
    bne loop_bottom_fluff
    lda #"#"
    sta (tmp0),y
    rts
.)



; param0 +0 = xPos
; param0 +1 = yPos
; param1 +0 = width
; param1 +1 = height
; param2 +0 = fillValue
; _gDrawAddress = base address of the target buffer
_DrawRectangleOutlineAsm
.(
    ; Caller must initialize _gDrawAddress (typically $A000 for HIRES screen or _ImageBuffer for off-screen drawing). 
    ; HandleByteStream sets it to $A000 on entry; the BLACK_BUBBLE/WHITE_BUBBLE handler overrides it to _ImageBuffer.

    lda _param2+0
    sta _gDrawPattern  ; fillValue

    ; Left side
    lda _param0+0
	sta _gDrawPosX     ; xPos

    ldx _param0+1
    inx
	stx _gDrawPosY     ; yPos+1

    ldx _param1+1
    dex
    dex
	stx _gDrawHeight   ; height-2

;a jmp a

	jsr _DrawVerticalLine

    ; Right side
    clc
    lda _param0+0
    adc _param1+0
    sec
    sbc #1
	sta _gDrawPosX     ; xPos+width-1

	jsr _DrawVerticalLine

    ; Top side
    ldx _param0+0
    inx
	stx _gDrawPosX     ; xPos+1

    dec _gDrawPosY     ; yPos

    ldx _param1+0
    dex
    dex
	stx _gDrawWidth    ; width-2

	jsr _DrawHorizontalLine

    ; Bottom side
    clc
    lda _param0+1
    adc _param1+1
    sec
    sbc #1
	sta _gDrawPosY     ; yPos+height-1

	jmp _DrawHorizontalLine
.)    


; Used by scenes like showing the newspaper or the map of england
; - Loads an image
; - Display a title string
; - Fades the image in
; .byt COMMAND_FULLSCREEN_ITEM,imageId,description,0
_ByteStreamCommand_DISPLAY_IMAGE
.(
    jsr _ByteStreamCommand_DISPLAY_IMAGE_NOBLIT
    ; BlitBufferToHiresWindow();
    jmp _BlitBufferToHiresWindow
.)

_ByteStreamCommand_DISPLAY_IMAGE_ONLY
.(
    jsr _ByteStreamCommand_DISPLAY_IMAGE_NO_CLEAR_TEXT
    jmp _BlitBufferToHiresWindow
.)    

; .byt COMMAND_FULLSCREEN_ITEM_NOBLIT,imageId,description,0
_ByteStreamCommand_DISPLAY_IMAGE_NOBLIT
.(  
    ; _param0=paper color
    ; ClearMessageWindow(16+4);
    lda #16+4
    sta _param0+0
    jsr _ClearMessageWindowAsm
+_ByteStreamCommand_DISPLAY_IMAGE_NO_CLEAR_TEXT
    ; The HIRES window is about to be repainted with a non-scene image, so any bubbles previously on screen are gone — drop them from the recovery state.
    jsr _ClearBubbleCount
	; unsigned char loaderId = *gCurrentStream++;
    ; LoadFileAt(loaderId,ImageBuffer);
    jsr _ByteStreamGetNextByte
    stx _LoaderEntryIndex
    lda #<_ImageBuffer
    sta _LoaderAddressLow
    lda #>_ImageBuffer
    sta _LoaderAddressHigh
    jmp _LoadFileFromDirectory
.)


; .byt COMMAND_CLEAR_TEXT_AREA,16+(paper_color&7)
_ByteStreamCommand_CLEAR_TEXT_AREA
.(
    ; _param0=paper color
    ; ClearMessageWindow(16+4);
    jsr _ByteStreamGetNextByte
    stx _param0+0
    jmp _ClearMessageWindowAsm
.)


; .byt COMMAND_CLEAR_FULL_TEXT_AREA,16+(paper_color&7)
_ByteStreamCommand_CLEAR_FULL_TEXT_AREA
.(
    ; _param0=paper color
    ; ClearMessageWindow(16+4);
    jsr _ByteStreamGetNextByte
    stx _param0+0
    jmp _ClearMessageAndInventoryWindow
.)


; .byt COMMAND_SET_STRIDE,stride
_ByteStreamCommand_SET_STRIDE
    jsr _ByteStreamGetNextByte
    stx _gSourceStride
    rts


; .byt COMMAND_BITMAP,imageId,w,h
; Stride is read from _gSourceStride (defaults to 40, set by SET_STRIDE for one-shot overrides).
_ByteStreamCommand_BITMAP
.( 
	; unsigned char loaderId = *gCurrentStream++;
    jsr _ByteStreamGetNextByte
    cpx _gCurrentSpriteSheetIndex
    beq image_already_loaded             ; We only load the image if it's not already the one in memory
    
    ; Load the requested bitmap
    stx _gCurrentSpriteSheetIndex
    stx _LoaderEntryIndex
    lda #<_SecondImageBuffer
    sta _LoaderAddressLow
    lda #>_SecondImageBuffer
    sta _LoaderAddressHigh
    jsr _LoadFileFromDirectory    

image_already_loaded
    ; Load the coordinates and draw the sprite
    ; These should probably be optimize with a simple function that takes a bit mask of which variables to update
    jsr _ByteStreamGetNextByte
    stx _gDrawWidth
    jsr _ByteStreamGetNextByte
    stx _gDrawHeight

    jsr _ByteStreamGetNextByte
    stx _gDrawSourceAddress+0
    jsr _ByteStreamGetNextByte
    stx _gDrawSourceAddress+1

    jsr _ByteStreamGetNextByte
    stx _gDrawAddress+0
    jsr _ByteStreamGetNextByte
    stx _gDrawAddress+1

    jsr _BlitSprite
    lda #40
    sta _gSourceStride                   ; auto-revert SET_STRIDE one-shot
    rts
.)



_InitializeGraphicMode
.(
    jsr _ClearTextWindow

    lda #ATTRIBUTE_HIRES   ; Make the attribute appear black until we need to change it to white (in which case we need to apply |128 to it)
    sta $bb80+40*0  	   ; Switch to HIRES, using video inverse to keep the 6 pixels white

    lda #ATTRIBUTE_TEXT
	sta $a000+40*128       ; Switch to TEXT

	; from the old BASIC code, will fix later
	; CYAN on BLACK for the scene description
    lda #7
	sta $BB80+40*16    ; Line with the arrow character and the clock
    lda #6
	sta $BB80+40*17

	; BLUE background for the log output
	lda #16+4
    sta _param0
    jsr _ClearMessageWindowAsm

	; BLACK background for the inventory area
    lda #16
	sta $BB80+40*24
	sta $BB80+40*25
	sta $BB80+40*26
	sta $BB80+40*27

	; Initialize the ALT charset numbers
    MEMCPY(_g7DigitDisplayChars,_gSevenDigitDisplay,8*11)
    rts
.)



; Bubble state arrays (per-call _Bubbles* and persistent _BubbleList*) live in BSS in overlay RAM — see last_module.s. MAX_BUBBLE comes from scripting.h.
.(
+_ByteStreamCommand_WHITE_BUBBLE
    ldx #64                        ; White on Black Color pattern
    bne draw_bubble
+_ByteStreamCommand_BLACK_BUBBLE
    ldx #127                       ; White on Black Color pattern
draw_bubble
.(
_count         = reg4
_coordinates   = reg5
tmpCount       = reg6

    stx _gDrawPattern

    ; Bubbles are drawn into _ImageBuffer (off-screen), then partial-blitted to $A000 at the end. 
    ; This avoids visible flicker and means scene refreshes that re-blit the buffer to screen will preserve the bubbles.
    lda #<_ImageBuffer
    sta _gDrawAddress+0
    lda #>_ImageBuffer
    sta _gDrawAddress+1

    jsr _ByteStreamGetNextByte     ; Number of bubbles
    stx _count                     ; This call's count (max MAX_BUBBLE)
    lda _gCurrentLocation          ; Tag the bubbles with the scene they belong to
    sta _BubbleScene

    lda _gCurrentStream+0          ; Memorize the pointer for the later passes
    sta _coordinates+0
    lda _gCurrentStream+1
    sta _coordinates+1

    ;
    ; Draw the black outline of the speech bubble
    ;
    .(
    ldx _count
    stx tmpCount
loop_bubble
    jsr _ByteStreamGetNextByte  ; X Pos (pixel)
    dex
    stx _param0+0
    ; Convert pixel X-1 to byte column for the final blit (6 pixels per byte on HIRES)
    lda _gTableDivBy6,x
    ldy tmpCount
    sta _BubblesX-1,y

    jsr _ByteStreamGetNextByte  ; Y Pos
    dex
    stx _param0+1
    ; Save Y-1 (top-left of outline) for the final blit
    ldy tmpCount                ; Reload Y — _ByteStreamGetNextByte clobbered it
    txa
    sta _BubblesY-1,y

    jsr _ByteStreamGetNextByte   ; Skip offset Y

    lda #2+2
    sta _param1+0       ; Initial width

    lda #15+2
    sta _param1+1       ; Initial height

    lda _gDrawPattern
    sta _param2+0       ; Pattern

    ; Iterate over the string
    lda #0
    sta cur_char
loop_compute_size
    ldx cur_char
    stx prev_char
    jsr _ByteStreamGetNextByte
    stx cur_char
    beq end_compute_size
    bmi offset
character            ; Get the character width from the font information gFont12x14Width[car-32]+1;
    sec
    lda _param1+0
    adc _gFont12x14Width-32,x
    sta _param1+0    

    ; prev_char + cur_char -> kerning
    jsr _GetKerningValue
    sec
    lda _param1+0    
    sbc kerning
    sta _param1+0    
      
    bne loop_compute_size
offset               ; Signed offset to handle things like AV or To properly
    clc
    txa
    adc _param1+0
    sta _param1+0    
    bne loop_compute_size
end_compute_size
    ; Store the pixel outline width (used by the fill pass below)
    lda _param1+0
    ldx tmpCount
    sta _BubblesWidth-1,x

    ; Compute the byte width spanned by the outline rectangle for the final blit:
    ;   right_byte = _gTableDivBy6[(X-1) + outline_width - 1]
    ;   byte_width = right_byte - left_byte + 1
    clc
    lda _param0+0               ; pixel X-1
    adc _param1+0               ; + pixel outline width
    tax
    dex                         ; right pixel = X-1 + W - 1
    sec
    lda _gTableDivBy6,x         ; right byte column
    ldy tmpCount
    sbc _BubblesX-1,y           ; - left byte column (already converted)
    clc
    adc #1                      ; +1 for inclusive count
    sta _BubblesByteWidth-1,y

    jsr _DrawRectangleOutlineAsm

    dec tmpCount
    bne loop_bubble
    .)

    ;
    ; Fill the bubble rectangles with the opposite color
    ;
    lda _gDrawPattern
    eor #63
    sta _gDrawPattern

    .( 
    ; Restore the coordinates
    lda _coordinates+0
    sta _gCurrentStream+0
    lda _coordinates+1
    sta _gCurrentStream+1

    ldx _count
    stx tmpCount
loop_bubble
    jsr _ByteStreamGetNextByte  ; X Pos
    stx _gDrawPosX

    jsr _ByteStreamGetNextByte  ; Y Pos
    stx _gDrawPosY

    jsr _ByteStreamGetNextByte   ; Skip offset Y

    lda #15
    sta _gDrawHeight

    ; Iterate over the string
loop_compute_size
    jsr _ByteStreamGetNextByte
    bne loop_compute_size

    ; Restore the computed width
    ldx tmpCount
    sec
    lda _BubblesWidth-1,x
    sbc #2
    sta _gDrawWidth

    jsr _DrawFilledRectangle

    dec tmpCount
    bne loop_bubble
    .)
    
    ;
    ; Print the actual text in the original color
    ;
    lda _gDrawPattern
    eor #63
    sta _gDrawPattern

    .( 
    ; Restore the coordinates
    lda _coordinates+0
    sta _gCurrentStream+0
    lda _coordinates+1
    sta _gCurrentStream+1

    ldx _count
    stx tmpCount
loop_bubble
    jsr _ByteStreamGetNextByte  ; X Pos
    inx                         ; Offset X
    stx _gDrawPosX

    jsr _ByteStreamGetNextByte  ; Y Pos
    stx _gDrawPosY

    jsr _ByteStreamGetNextByte  ; Offset Y
    clc
    txa
    adc _gDrawPosY
    sta _gDrawPosY

    lda #15
    sta _gDrawHeight

    lda _gCurrentStream+0
    sta _gDrawExtraData+0
    lda _gCurrentStream+1
    sta _gDrawExtraData+1
    
    jsr _PrintFancyFont

    lda _gDrawExtraData+0
    sta _gCurrentStream+0
    lda _gDrawExtraData+1
    sta _gCurrentStream+1

    dec tmpCount
    bne loop_bubble
    .)

    ;
    ; Append this call's bubbles to the persistent list, then blit ALL bubbles in the list from _ImageBuffer to $A000. 
    ; Re-blitting older bubbles is harmless (same pixels in the buffer) and lets us share _BlitBubbles with the reverse path in _RestoreBubblesFromHires.
    ;
    .(
    ldx _count                  ; this call's count
    ldy _BubbleCount            ; current accumulated index (start offset for this call)
copy_loop
    lda _BubblesX-1,x
    sta _BubbleListX,y
    lda _BubblesY-1,x
    sta _BubbleListY,y
    lda _BubblesByteWidth-1,x
    sta _BubbleListWidth,y
    iny
    dex
    bne copy_loop
    sty _BubbleCount
    .)

; These are used here, but also in _RestoreBubblesFromHires and _BlitBubbles
&sourcePtr   = tmp2  ; base address of the source buffer @ptr16
&targetPtr   = tmp3  ; base address of the target buffer @ptr16
&bubbleCount = tmp4  ; number of bubbles to blit (1..MAX_BUBBLE_TOTAL)

    ; Forward blit: src=_ImageBuffer, dst=$A000
    lda #<_ImageBuffer
    sta sourcePtr+0
    lda #>_ImageBuffer
    sta sourcePtr+1
    lda #<$A000
    sta targetPtr+0
    lda #>$A000
    sta targetPtr+1
    lda _BubbleCount
    sta bubbleCount
    jmp _BlitBubbles
.)



;
; Recovers the on-screen bubble rectangles back into _ImageBuffer.
; Called from LoadScene right after the new scene image is loaded into the buffer but before the script re-runs / the buffer is re-blitted to HIRES. 
; The HIRES window still holds the OLD scene with the bubbles painted on top, so we copy each bubble's bounding box from $A000 back into _ImageBuffer at the same offset. 
; After this, the regular BlitBufferToHiresWindow at the end of LoadScene will restore the bubbles with no visible flicker.
;
; If _BubbleCount is zero (no bubbles currently on HIRES — e.g. after DISPLAY_IMAGE or _PlayMonkeyKing repainted the window), the routine is a no-op.
;
+_RestoreBubblesFromHires
.(
    ; If the location changed since the bubbles were drawn, the pixels still on HIRES
    ; belong to the *previous* scene — drop the recovery state and return. Otherwise
    ; the bubbles would smear into the new scene's image.
    lda _gCurrentLocation
    cmp _BubbleScene
    beq scene_match
    ; Clears the persistent bubble list. 
    ; Called from any code path that repaints the HIRES window with non-scene content (DISPLAY_IMAGE, _PlayMonkeyKing) and from the recovery routine after it has finished copying bubbles back from HIRES.
+_ClearBubbleCount
    lda #0
    sta _BubbleCount
end
    rts

scene_match
    lda _BubbleCount
    beq end                     ; no bubbles to recover

    sta bubbleCount             ; count input for _BlitBubbles

    ; Reset _BubbleCount to 0 — once we're done copying from HIRES, the script will re-run and the bubble handler will re-accumulate the list from scratch.
    jsr _ClearBubbleCount

    ; Reverse blit: src=$A000 (HIRES), dst=_ImageBuffer
    lda #<$A000
    sta sourcePtr+0
    lda #>$A000
    sta sourcePtr+1
    lda #<_ImageBuffer
    sta targetPtr+0
    lda #>_ImageBuffer
    sta targetPtr+1
.)  ; Fall through into _BlitBubbles
;
; Iterates the _BubbleList* arrays and copies each bubble's bounding box from (src_base + offset) to (dst_base + offset). 
; Used by both the forward blit (buffer→HIRES) at the end of WHITE_BUBBLE/BLACK_BUBBLE handlers — after the
; just-drawn bubbles have been appended to the list — and the reverse blit (HIRES→buffer) inside _RestoreBubblesFromHires.
;
_BlitBubbles
.(
offset      = tmp0

    lda #17
    sta _gDrawHeight                ; outline + fill = 15 + 2

    lda #40
    sta _gSourceStride

loop
    ; Compute byte offset = BubbleListY[i] * 40 + BubbleListX[i]
    ldx bubbleCount
    ldy _BubbleListY-1,x
    clc
    lda _gTableMulBy40Low,y
    adc _BubbleListX-1,x
    sta offset+0
    lda _gTableMulBy40High,y
    adc #0
    sta offset+1

    ; gDrawSourceAddress = src + offset
    clc
    lda offset+0
    adc sourcePtr+0
    sta _gDrawSourceAddress+0
    lda offset+1
    adc sourcePtr+1
    sta _gDrawSourceAddress+1

    ; gDrawAddress = dst + offset
    clc
    lda offset+0
    adc targetPtr+0
    sta _gDrawAddress+0
    lda offset+1
    adc targetPtr+1
    sta _gDrawAddress+1

    lda _BubbleListWidth-1,x
    sta _gDrawWidth

    jsr _BlitRectangle

    dec bubbleCount
    bne loop
    rts
.)
.)