george-emu/src/roms/george.asm

; .setcpu "65C02"
    .include "./macro.inc"

; okay so rn i wanna set up a very basic system init, and write a few subroutines to draw characters at x,y coordinates
n = $01 ; temporary storage for data stack operations

key_row = $200 ; used for character lookup when key pressed
key_col = $201
cursor = $202

char_buffer = $300 ; 256 byte character buffer

kb_row = $4400 ; keyboard hardware register
kb_row_cache = $203 ; cache 

    .org $8000

reset:
    sei
    ldx #0; initialize data stack pointer

initdisplay:
    lda #$20
    ldy #0

cleardisplay:
    sta $6000,y
    sta $6100,y
    sta $6200,y
    sta $6300,y
    sta $6400,y
    sta $6500,y
    sta $6600,y
    sta $6700,y ; this goes slightly over but it's fine
    iny
    bne cleardisplay
    ; cli

main:
    jsr keyboard
    ; key_zero:
    ;     stz keyboard_cache, x
    ;     dex
    ;     bpl key_zero
    ; fim: 
    ;     cli
    ;     bra fim
    ; jsr kitty_keys
    jmp main

; ; copying @smal rn: https://github.com/smaldragon/KittyEMU/blob/main/roms/foxmon.asm
; char_timer = $10
; line_buffer = $0200
; char_cur = $11
; line_buffer_i = $12
; line_buffer_l = $13

; keyboard_cache = $14
; line_cur = $20

; irq:

;     lda line_buffer_i
;     lda $e0
;     lda $6f
;     sei
;     stz char_cur
;     lda line_buffer_i
;     sta line_buffer_l
;     ldx #4

; kitty_keys: ; reads pressed key and writes keymap value to char_cur
;     phx 
;     txa
;     asl
;     asl
;     asl
;     asl
;     asl ; i think this is supposed to be once for every keyboard row
;     tax
;     lda kb_row, x
;     plx

;     pha
;     cmp keyboard_cache, x
;     bne change
;     jmp nochange
;     change:
;         bit7:
;             asl keyboard_cache, x
;             bcs bit6
;             bit #0b10000000
;             beq bit6
;             pha
;             lda keymap_7, x
;             sta char_cur
;             pla
;         bit6:
;             asl keyboard_cache, x
;             bcs bit5
;             bit #0b01000000
;             beq bit5
;             pha
;             lda keymap_6, x
;             sta char_cur
;             pla
;         bit5:
;             asl keyboard_cache, x
;             bcs bit4
;             bit #0b00100000
;             beq bit4
;             pha
;             lda keymap_5, x
;             sta char_cur
;             pla
;         bit4:
;             asl keyboard_cache, x
;             bcs bit3
;             bit #0b00010000
;             beq bit3
;             pha
;             lda keymap_4, x
;             sta char_cur
;             pla
;         bit3:
;             asl keyboard_cache, x
;             bcs bit2
;             bit #0b00001000
;             beq bit2
;             pha
;             lda keymap_3, x
;             sta char_cur
;             pla
;         bit2:
;             asl keyboard_cache, x
;             bcs bit1
;             bit #0b00000100
;             beq bit1
;             pha
;             lda keymap_2, x
;             sta char_cur
;             pla
;         bit1:
;             asl keyboard_cache, x
;             bcs bit0
;             bit #0b00000010
;             beq bit0
;             pha
;             lda keymap_1, x
;             sta char_cur
;             pla
;         bit0:
;             asl keyboard_cache, x
;             bcs bitend
;             bit #0b00000001
;             beq bitend
;             pha
;             lda keymap_0, x
;             sta char_cur
;             pla
;         bitend:
;     nochange:
;         pla
;         sta keyboard_cache, x
;         dex
;         bmi keyend
;         jmp kitty_keys
;         keyend:

;     write:
;         lda char_cur
;         ldy cursor
;         sta $6000, y
;         inc cursor
;         rts


; ; col = keyboard row, row = keyboard bit placement inverted
; keymap_0:
;     .byte "??????"
; keymap_1:
;     .byte "wqdzx "
; keymap_2:
;     .byte "esvfc "
; keymap_3:
;     .byte "rghbn?"
; keymap_4:
;     .byte "tykjm?"
; keymap_5:
;     .byte "ui?l??"
; keymap_6:
;     .byte "op?21?"
; keymap_7:
;     .byte "??a43?"
;
;
keyboard:
    ldy #0
    x

not_keyboard:
    ldy #0 
    .check_row: ; loop through each row
        lda kb_row, y
        beq .skip_row ; if row has no key pressed, skip checking which key
        sta kb_row_cache, y ; if key pressed, cache it
        lda kb_row, y
        cmp kb_row_cache, y ; has key changed?
        beq key_down
        .skip_row:
            iny
            cpy #5
            bne .check_row
    rts

key_down:               ; a is loaded with the row byte
    phy
    sty key_row         ; store character row
    ldy #0
    .find_col:          ; test each row bit, store column if key pressed
        lsr             ; test bit 7
        bcs store_col       ; if unset, don't go store character columnb
        .skip:
            iny
            cpy #8
            bne .find_col   ; loop until we've checked each bit

store_col:
    sty key_col

keymap_index:
    push
    lda key_col
    stz 1, x
    sta 0, x
    push
    lda #8
    stz 1, x
    sta 0, x
    push
    lda key_row
    stz 1, x
    sta 0, x
    jsr mult
    jsr plus
    lda 0, x
    tay

print: ; we've stored the character position, now let's 
    lda keymap, y
    ldy cursor
    sta $6000, y
    inc cursor
    ply
    rts

keymap:
    .byte "?outrew?"
    .byte "?piygsq?"
    .byte "a??khvd?"
    .byte "42ljbfz?"
    .byte "31?mncx?"
    .byte "?????  m"

draw:
    ; push_coords #0, #0
    ; push_char #$00
    ; jsr draw_char
    rts

draw_char: ; draw a character c at (x, y) (n1: x n2: y n3: c -- )
    lda 0, x ; load a with character to draw
    pop ; and pop it off the stack
    jsr get_char_address ; calculate where to put the character in memory
    sta (0, x) ; store a at the address pointed to on the stack
    rts

get_char_address:   ; gets vram address for a character at (x, y),
                    ; (n1: x n2: y -- n: $6000 + x + (64 * y))
    ;jsr push_lit ; push 64 onto stack, low byte first
    ;.byte 64
    ;.byte 0
    pha
    lda #64
    push ; doing this instead until `push_lit` is fixed
    sta 0, x
    stz 1, x
    jsr mult ; multiply 64 with y (n2)
    jsr plus ; add result with x (n1)

    ;jsr push_lit ; push vram address onto the stack
    ;.byte $00
    ;.byte $60
    lda #$60
    push
    sta 1, x
    stz 0, x
    jsr plus ; add vram start address to result

    pla
    rts

fill: ; fills an area from (x1, y1) to (x2, y2) will character c, (n1: c n2: x1 n3: y1 n4: x2 n5: y2 -- )
    jsr get_char_address

isr: ; interrupt service routine
    pha
    phx
    phy
    ; jsr irq
    ply
    plx
    pla
    rti

    .include "math.inc"

    .org $fffc
    .word reset
    .word isr