build script! no more manually rebuilding cozette!
This commit is contained in:
@@ -0,0 +1,11 @@
|
||||
.org $00
|
||||
|
||||
.byte $80
|
||||
|
||||
.org $8000
|
||||
|
||||
reset:
|
||||
bbr7 $00, reset
|
||||
|
||||
.org $fffc
|
||||
.word reset
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
+238
@@ -0,0 +1,238 @@
|
||||
; .setcpu "65C02"
|
||||
.include "./macro.inc"
|
||||
|
||||
.org $8000
|
||||
|
||||
n = $01 ; temporary storage for data stack operations
|
||||
|
||||
temp = $20 ; scratchpad page
|
||||
|
||||
cursor = $300
|
||||
cursor_x = cursor
|
||||
cursor_y = cursor + 1
|
||||
|
||||
rand_index = $200
|
||||
|
||||
reset:
|
||||
sei
|
||||
ldx #0; initialize data stack pointer
|
||||
|
||||
init:
|
||||
cli
|
||||
|
||||
main:
|
||||
jsr print
|
||||
jsr rand_draw
|
||||
jmp main
|
||||
|
||||
newline: ; sets cursor to start of next line
|
||||
stz cursor_x
|
||||
lda cursor_y
|
||||
cmp #28
|
||||
bne .end
|
||||
stz cursor_y
|
||||
rts
|
||||
.end:
|
||||
inc cursor_y
|
||||
rts
|
||||
|
||||
text:
|
||||
.byte 1,2,3,2,4
|
||||
.asciiz "- george loves u <3"
|
||||
|
||||
random_y:
|
||||
.byte 25,12,0,20,4,25,5,13
|
||||
.byte 20, 1, 1, 22, 12, 19, 19, 19
|
||||
.byte 9, 0, 4, 18, 13, 14, 4, 16
|
||||
.byte 8, 17, 21, 14, 23, 21, 9, 0
|
||||
.byte 14, 10, 14, 2, 26, 18, 15, 23
|
||||
.byte 12, 2, 5, 4, 25, 20, 27, 4
|
||||
.byte 28, 21, 3, 22, 11, 25, 2, 25
|
||||
.byte 13, 17, 17, 24, 8, 8, 20, 21
|
||||
.byte 11, 24, 27, 25, 8, 12, 7, 0
|
||||
.byte 27, 12, 19, 27, 10, 3, 19, 2
|
||||
.byte 2, 23, 22, 5, 26, 28, 4, 16
|
||||
.byte 18, 7, 10, 9, 6, 19, 9, 2
|
||||
.byte 14, 8, 14, 18, 18, 2, 13, 0
|
||||
.byte 15, 26, 3, 23, 17, 12, 18, 11
|
||||
.byte 4, 16, 17, 22, 9, 25, 3, 15
|
||||
.byte 28, 3, 6, 14, 25, 5, 21, 8
|
||||
.byte 15, 18, 15, 5, 28, 6, 15, 4
|
||||
.byte 10, 1, 16, 24, 6, 9, 22, 3
|
||||
.byte 17, 18, 10, 19, 27, 11, 22, 16
|
||||
.byte 22, 17, 15, 6, 23, 11, 11, 11
|
||||
.byte 4, 15, 5, 25, 19, 1, 8, 26
|
||||
.byte 21, 20, 17, 27, 11, 3, 11, 20
|
||||
.byte 15, 28, 0, 6, 14, 23, 20, 21
|
||||
.byte 17, 20, 16, 15, 19, 6, 21, 19
|
||||
.byte 15, 27, 1, 22, 7, 0, 5, 2
|
||||
.byte 14, 24, 15, 4, 20, 16, 1, 14
|
||||
.byte 4, 16, 4, 8, 13, 26, 3, 9
|
||||
.byte 12, 25, 5, 0, 7, 17, 14, 20
|
||||
.byte 2, 26, 2, 27, 18, 23, 5, 8
|
||||
.byte 4, 21, 10, 11, 28, 22, 6, 6
|
||||
.byte 10, 13, 23, 12, 20, 28, 20, 1
|
||||
.byte 27, 19, 25, 6, 1, 10, 1
|
||||
|
||||
random_x:
|
||||
.byte 42, 59, 11, 5, 18, 0, 26, 1
|
||||
.byte 61, 16, 1, 51, 36, 47, 23, 1
|
||||
.byte 16, 50, 46, 4, 55, 31, 15, 2
|
||||
.byte 45, 21, 59, 53, 15, 43, 0, 2
|
||||
.byte 64, 31, 38, 41, 25, 12, 12, 3
|
||||
.byte 30, 13, 64, 44, 21, 8, 48, 3
|
||||
.byte 46, 1, 2, 33, 4, 32, 59, 28
|
||||
.byte 4, 24, 58, 53, 21, 41, 30, 2
|
||||
.byte 56, 53, 31, 10, 42, 12, 9, 54
|
||||
.byte 14, 14, 24, 29, 43, 60, 54, 26
|
||||
.byte 5, 53, 17, 55, 27, 46, 31, 3
|
||||
.byte 26, 44, 63, 30, 10, 34, 62, 48
|
||||
.byte 42, 47, 51, 7, 55, 32, 14, 21
|
||||
.byte 15, 26, 52, 37, 48, 0, 13, 2
|
||||
.byte 50, 20, 35, 32, 8, 41, 2, 24
|
||||
.byte 18, 9, 52, 22, 52, 12, 19, 32
|
||||
.byte 29, 46, 34, 58, 54, 51, 43, 57
|
||||
.byte 62, 10, 12, 57, 36, 39, 4, 30
|
||||
.byte 38, 9, 30, 32, 33, 57, 3, 25
|
||||
.byte 21, 36, 59, 30, 19, 39, 9, 60
|
||||
.byte 34, 50, 52, 37, 34, 42, 3, 33
|
||||
.byte 40, 19, 2, 26, 10, 38, 46, 30
|
||||
.byte 3, 1, 19, 16, 26, 58, 42, 49
|
||||
.byte 63, 1, 63, 41, 0, 21, 41, 19
|
||||
.byte 21, 45, 44, 52, 20, 5, 11, 64
|
||||
.byte 1, 62, 16, 5, 5, 8, 58, 56
|
||||
.byte 16, 26, 6, 37, 19, 16, 25, 29
|
||||
.byte 64, 59, 16, 6, 41, 28, 8, 51
|
||||
.byte 54, 5, 19, 28, 13, 38, 52, 35
|
||||
.byte 42, 13, 34, 33, 61, 61, 7, 27
|
||||
.byte 38, 33, 9, 57, 10, 30, 8, 4
|
||||
.byte 46, 3, 39, 46, 62, 20, 48, 7
|
||||
|
||||
|
||||
; increments the cursor line by line, looping to (0, 0) after (63, 28)
|
||||
|
||||
inc_cursor:
|
||||
lda cursor_x
|
||||
cmp #63
|
||||
beq .newline
|
||||
inc cursor_x
|
||||
rts
|
||||
.newline:
|
||||
lda cursor_y
|
||||
cmp #28
|
||||
beq .newscreen
|
||||
stz cursor_x
|
||||
inc cursor_y
|
||||
rts
|
||||
.newscreen:
|
||||
stz cursor_y
|
||||
stz cursor_x
|
||||
rts
|
||||
|
||||
; zeroes out the display, resets cursor to 0,0
|
||||
|
||||
clear:
|
||||
lda #0
|
||||
ldy #0
|
||||
|
||||
.loop:
|
||||
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 .loop
|
||||
stz cursor
|
||||
stz cursor + 1
|
||||
rts
|
||||
|
||||
|
||||
; prints string from cursor position, stopping at end of string or at 256 chars, whichever comes first
|
||||
; $6000 + (64*Y) + X
|
||||
; THIS WILL WRITE OUT OF BOUNDS IF THE CURSOR IS OUT OF BOUNDS/STRING IS TOO LONG
|
||||
|
||||
; TODO: figure out a simple way of writing arbitrary length strings
|
||||
|
||||
print:
|
||||
jsr cursor_addr
|
||||
ldy #0
|
||||
; y_overflow = temp + 5
|
||||
.loop:
|
||||
lda text, y
|
||||
beq .end
|
||||
sta (temp), y
|
||||
iny
|
||||
bra .loop
|
||||
.end:
|
||||
rts
|
||||
|
||||
|
||||
; calculates real vram address from cursor (x, y)
|
||||
|
||||
cursor_addr:
|
||||
stz temp
|
||||
stz temp + 1
|
||||
lda cursor_y
|
||||
beq .add_x ; if y's zero just add x
|
||||
.y_mult:
|
||||
; multiply by 64
|
||||
clc
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
sta temp
|
||||
.add_x:
|
||||
clc
|
||||
lda cursor_x
|
||||
adc temp
|
||||
sta temp
|
||||
lda #0
|
||||
adc temp + 1
|
||||
sta temp + 1
|
||||
clc
|
||||
|
||||
lda #$60
|
||||
adc temp + 1
|
||||
sta temp + 1
|
||||
rts
|
||||
|
||||
|
||||
rand_draw:
|
||||
ldx rand_index
|
||||
lda random_x, x
|
||||
sta cursor_x
|
||||
lda random_y, x
|
||||
sta cursor_y
|
||||
jsr cursor_addr
|
||||
inc rand_index
|
||||
rts
|
||||
|
||||
|
||||
isr: ; interrupt service routine
|
||||
pha
|
||||
phx
|
||||
phy
|
||||
; jsr irq
|
||||
ply
|
||||
plx
|
||||
pla
|
||||
rti
|
||||
|
||||
.include "math.inc"
|
||||
|
||||
.org $fffc
|
||||
.word reset
|
||||
.word isr
|
||||
Binary file not shown.
+189
@@ -0,0 +1,189 @@
|
||||
; .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 #0
|
||||
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
|
||||
|
||||
print_test:
|
||||
lda #0
|
||||
sta key_row
|
||||
lda #5
|
||||
sta key_col
|
||||
push_coords #5, #5
|
||||
|
||||
main:
|
||||
; jsr printtext
|
||||
; key_zero:
|
||||
; stz keyboard_cache, x
|
||||
; dex
|
||||
; bpl key_zero
|
||||
; fim:
|
||||
; cli
|
||||
; bra fim
|
||||
jsr print
|
||||
; jsr print
|
||||
stp
|
||||
jmp main
|
||||
|
||||
|
||||
|
||||
; keyboard: ; reads keyboard registers and stores the column and row of the first key found
|
||||
; ; TODO: make this routine store up to 8 indices (for 8 key rollover)
|
||||
; 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
|
||||
; ; jmp key_down
|
||||
; 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
|
||||
; rts
|
||||
|
||||
; store_col:
|
||||
; sty key_col
|
||||
; jsr print
|
||||
; rts
|
||||
|
||||
|
||||
|
||||
|
||||
print: ; x y -- prints the key indexed with key_col and key_row at position x, y
|
||||
|
||||
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
|
||||
lda keymap, y
|
||||
push
|
||||
sta 0, x
|
||||
stz 1, x
|
||||
jsr draw_char
|
||||
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 keyboard
|
||||
ply
|
||||
plx
|
||||
pla
|
||||
rti
|
||||
|
||||
.include "math.inc"
|
||||
|
||||
.org $fffc
|
||||
.word reset
|
||||
.word isr
|
||||
Binary file not shown.
@@ -0,0 +1,124 @@
|
||||
; .setcpu "65C02"
|
||||
.include "./macro.inc"
|
||||
|
||||
.org $8000
|
||||
|
||||
n = $01 ; temporary storage for data stack operations
|
||||
key_buffer = $200
|
||||
|
||||
reset:
|
||||
sei
|
||||
ldx #0; initialize data stack pointer
|
||||
|
||||
initdisplay:
|
||||
lda #0
|
||||
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 read_keys
|
||||
lda key_buffer
|
||||
sta $6000
|
||||
; lda $4400
|
||||
; sta $6000
|
||||
jmp main
|
||||
|
||||
; first, let's do the simplest case of just the letter a being pressed
|
||||
; 1. check row 2 ($4402, where the a key is) for pressed keys
|
||||
; 2. if any keys are pressed, check if the key is a (bit 0)
|
||||
; 3. if the key is not a, store zero in the key buffer
|
||||
; 4. if the key is a, store the ascii for a in the key buffer
|
||||
; 5. return
|
||||
|
||||
; so u don't have to scroll: key_buffer = $200
|
||||
; key buffer just shows the current state of the keyboard
|
||||
; it is not a queue of keys to print
|
||||
|
||||
read_keys:
|
||||
lda $4402 ; check row 2
|
||||
beq check_key ; if there're any keys, check which
|
||||
clear_buffer:
|
||||
stz key_buffer
|
||||
rts
|
||||
check_key: ; if there is a key pressed, check if it's a
|
||||
ror
|
||||
bmi store_key
|
||||
rts
|
||||
store_key:
|
||||
; in a sec we'll set up ascii table lookup,
|
||||
; for now let's just load the ascii byte for a
|
||||
lda #$61
|
||||
sta key_buffer
|
||||
rts
|
||||
|
||||
draw:
|
||||
push_coords #0, #0
|
||||
push_char #$af
|
||||
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
|
||||
|
||||
irq:
|
||||
rts
|
||||
|
||||
isr: ; interrupt service routine
|
||||
pha
|
||||
phx
|
||||
phy
|
||||
jsr irq
|
||||
ply
|
||||
plx
|
||||
pla
|
||||
rti
|
||||
|
||||
.include "math.inc"
|
||||
|
||||
.org $fffc
|
||||
.word reset
|
||||
.word isr
|
||||
Binary file not shown.
@@ -0,0 +1,215 @@
|
||||
; .setcpu "65C02"
|
||||
.include "./macro.inc"
|
||||
|
||||
.org $8000
|
||||
|
||||
n = $01 ; temporary storage for data stack operations
|
||||
|
||||
temp = $20 ; scratchpad page
|
||||
str_ptr = $30
|
||||
|
||||
cursor = $300
|
||||
cursor_x = cursor
|
||||
cursor_y = cursor + 1
|
||||
|
||||
char_buf = $302
|
||||
char_buf_index = char_buf + 8
|
||||
|
||||
reset:
|
||||
sei
|
||||
ldx #0; initialize data stack pointer
|
||||
|
||||
init:
|
||||
lda #$31
|
||||
sta str_ptr
|
||||
lda #$80
|
||||
sta str_ptr + 1
|
||||
|
||||
jsr clear
|
||||
lda #0
|
||||
sta cursor_x
|
||||
lda #0
|
||||
sta cursor_y
|
||||
cli
|
||||
|
||||
main:
|
||||
jsr print
|
||||
jmp main
|
||||
|
||||
newline: ; sets cursor to start of next line
|
||||
stz cursor_x
|
||||
lda cursor_y
|
||||
cmp #28
|
||||
bne .end
|
||||
stz cursor_y
|
||||
rts
|
||||
.end:
|
||||
inc cursor_y
|
||||
rts
|
||||
|
||||
text:
|
||||
.asciiz "hello <3"
|
||||
|
||||
; increments the cursor line by line, looping to (0, 0) after (63, 28)
|
||||
|
||||
inc_cursor:
|
||||
lda cursor_x
|
||||
cmp #63
|
||||
beq .newline
|
||||
inc cursor_x
|
||||
rts
|
||||
.newline:
|
||||
lda cursor_y
|
||||
cmp #28
|
||||
beq .newscreen
|
||||
stz cursor_x
|
||||
inc cursor_y
|
||||
rts
|
||||
.newscreen:
|
||||
stz cursor_y
|
||||
stz cursor_x
|
||||
rts
|
||||
|
||||
; zeroes out the display, resets cursor to 0,0
|
||||
|
||||
clear:
|
||||
lda #0
|
||||
ldy #0
|
||||
|
||||
.loop:
|
||||
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 .loop
|
||||
stz cursor
|
||||
stz cursor + 1
|
||||
rts
|
||||
|
||||
|
||||
; prints string from cursor position, stopping at end of string or at 256 chars, whichever comes first
|
||||
; $6000 + (64*Y) + X
|
||||
; THIS WILL WRITE OUT OF BOUNDS IF THE CURSOR IS OUT OF BOUNDS/STRING IS TOO LONG
|
||||
|
||||
; TODO: figure out a simple way of writing arbitrary length strings
|
||||
; and
|
||||
|
||||
print:
|
||||
jsr cursor_addr
|
||||
ldy #0
|
||||
; y_overflow = temp + 5
|
||||
.loop:
|
||||
lda (str_ptr), y
|
||||
beq .end
|
||||
sta (temp), y
|
||||
iny
|
||||
bra .loop
|
||||
.end:
|
||||
rts
|
||||
|
||||
|
||||
; calculates real vram address from cursor (x, y)
|
||||
|
||||
cursor_addr:
|
||||
stz temp
|
||||
stz temp + 1
|
||||
lda cursor_y
|
||||
beq .add_x ; if y's zero just add x
|
||||
.y_mult:
|
||||
; multiply by 64
|
||||
clc
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
asl
|
||||
rol temp + 1
|
||||
sta temp
|
||||
.add_x:
|
||||
clc
|
||||
lda cursor_x
|
||||
adc temp
|
||||
sta temp
|
||||
lda #0
|
||||
adc temp + 1
|
||||
sta temp + 1
|
||||
clc
|
||||
|
||||
lda #$60
|
||||
adc temp + 1
|
||||
sta temp + 1
|
||||
rts
|
||||
|
||||
|
||||
|
||||
; print_text:
|
||||
; lda text,y
|
||||
; beq .end
|
||||
; sta $6000, y
|
||||
; iny
|
||||
; bra print_text
|
||||
; .end:
|
||||
; ldy #0
|
||||
; 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
|
||||
Binary file not shown.
@@ -0,0 +1,62 @@
|
||||
.macro breakpoint ; $02 isn't a valid instruction, the emulator will see this and halt, dump memory contents
|
||||
.byte $02
|
||||
.endm
|
||||
|
||||
.macro pop ; drops a data stack cell
|
||||
inx
|
||||
inx
|
||||
.endm
|
||||
|
||||
.macro pop2 ; drops 2 data stack cells
|
||||
inx
|
||||
inx
|
||||
inx
|
||||
inx
|
||||
.endm
|
||||
|
||||
.macro push ; push a data stack cell
|
||||
dex
|
||||
dex
|
||||
.endm
|
||||
|
||||
.macro push2 ; push 2 data stack cells
|
||||
dex
|
||||
dex
|
||||
dex
|
||||
dex
|
||||
.endm
|
||||
|
||||
.macro push_char, char; pushes an ascii character code onto the stack
|
||||
lda \char
|
||||
push
|
||||
sta 0, x ; char low byte
|
||||
stz 1, x ; char high byte
|
||||
.endm
|
||||
|
||||
.macro push_coords, coord_x, coord_y ; push a set of (x,y) coordinates onto the data stack
|
||||
lda \coord_x
|
||||
push
|
||||
sta 0, x ; low byte
|
||||
stz 1,x ; high byte is zero
|
||||
lda \coord_y
|
||||
push
|
||||
sta 0,x ; same here
|
||||
stz 1,x
|
||||
.endm
|
||||
|
||||
.macro to_r ; pop the top of the stack off and save it in the return (hardware) stack: (n -- )
|
||||
lda 1, x
|
||||
pha
|
||||
lda 0, x
|
||||
pha
|
||||
pop
|
||||
.endm
|
||||
|
||||
.macro from_r ; pop the top of the return stack off and put it on the data stack: ( -- n)
|
||||
push
|
||||
pla
|
||||
sta 0, x
|
||||
pla
|
||||
sta 1, x
|
||||
.endm
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
; --- Data Stack --- ;
|
||||
; on this channel we love garth wilson: https://wilsonminesco.com/stacks/StackOps.ASM
|
||||
; data stack is built up of 2-byte cells
|
||||
|
||||
|
||||
; TODO: this is broken, jumping here does nothing to the stack and skips several instructions, could be an emulator problem tho
|
||||
; push_lit: ; this bad boy lets you inline a literal (low byte first) right after `jsr push_lit` and put it on the stack, once again, on this channel we love garth wilson
|
||||
; push2
|
||||
; phx
|
||||
; tsx
|
||||
; txa
|
||||
; tay
|
||||
; plx
|
||||
|
||||
; lda $102, y
|
||||
; sta 0, x
|
||||
; clc
|
||||
; adc #2
|
||||
; sta $102, y
|
||||
|
||||
; lda $103, y
|
||||
; sta 1, x
|
||||
; adc #0
|
||||
; sta $103, y
|
||||
|
||||
; fetch:
|
||||
; lda (0, x)
|
||||
; pha
|
||||
; inc 0, x
|
||||
; bne .1
|
||||
; inc 1, x
|
||||
; .1:
|
||||
; lda (0, x)
|
||||
; bra put
|
||||
; push
|
||||
|
||||
; put:
|
||||
; sta 1, x
|
||||
; pla
|
||||
; sta 0, x
|
||||
; rts
|
||||
|
||||
plus: ; add: (n1 n2 -- n1+n2)
|
||||
clc
|
||||
lda 0, x
|
||||
adc 2, x
|
||||
sta 2, x
|
||||
lda 1, x
|
||||
adc 3, x
|
||||
sta 3, x
|
||||
pop
|
||||
rts
|
||||
|
||||
|
||||
mult: ; multiply: (n1 n2 -- n1*n2), frankly, i don't know how this works, but TODO: will try to figure it out later
|
||||
phy
|
||||
stz n
|
||||
ldy #0
|
||||
.1:
|
||||
lsr 3, x
|
||||
ror 2, x
|
||||
bcc .2
|
||||
clc
|
||||
lda n
|
||||
adc 0, x
|
||||
sta n
|
||||
tya
|
||||
adc 1, x
|
||||
tay
|
||||
.2:
|
||||
asl 0, x
|
||||
rol 1, x
|
||||
lda 2, x
|
||||
ora 3, x
|
||||
bne .1
|
||||
lda n
|
||||
sta 2, x
|
||||
sty 3, x
|
||||
pop
|
||||
ply
|
||||
rts
|
||||
@@ -0,0 +1,88 @@
|
||||
; .setcpu "65C02"
|
||||
.include "./macro.inc"
|
||||
|
||||
.org $8000
|
||||
|
||||
n = $01 ; temporary storage for data stack operations
|
||||
|
||||
reset:
|
||||
sei
|
||||
ldx #0; initialize data stack pointer
|
||||
|
||||
initdisplay:
|
||||
lda #0
|
||||
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 draw
|
||||
jmp main
|
||||
|
||||
draw:
|
||||
push_coords #0, #0
|
||||
push_char #$af
|
||||
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
|
||||
Binary file not shown.
+173
@@ -0,0 +1,173 @@
|
||||
; .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
|
||||
jmp main
|
||||
|
||||
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
|
||||
lda #9
|
||||
sta $6000
|
||||
jmp main
|
||||
|
||||
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
|
||||
Binary file not shown.
+187
@@ -0,0 +1,187 @@
|
||||
; .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 #0
|
||||
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
|
||||
|
||||
print_test:
|
||||
lda #0
|
||||
sta key_row
|
||||
lda #5
|
||||
sta key_col
|
||||
push_coords #5, #5
|
||||
|
||||
main:
|
||||
; jsr printtext
|
||||
; key_zero:
|
||||
; stz keyboard_cache, x
|
||||
; dex
|
||||
; bpl key_zero
|
||||
; fim:
|
||||
; cli
|
||||
; bra fim
|
||||
jsr print
|
||||
; jsr print
|
||||
jmp main
|
||||
|
||||
|
||||
; keyboard: ; reads keyboard registers and stores the column and row of the first key found
|
||||
; ; TODO: make this routine store up to 8 indices (for 8 key rollover)
|
||||
; 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
|
||||
; ; jmp key_down
|
||||
; 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
|
||||
; rts
|
||||
|
||||
; store_col:
|
||||
; sty key_col
|
||||
; jsr print
|
||||
; rts
|
||||
|
||||
|
||||
|
||||
|
||||
print: ; x y -- prints the key indexed with key_col and key_row at position x, y
|
||||
|
||||
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
|
||||
lda keymap, y
|
||||
push
|
||||
sta 0, x
|
||||
stz 1, x
|
||||
jsr draw_char
|
||||
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 keyboard
|
||||
ply
|
||||
plx
|
||||
pla
|
||||
rti
|
||||
|
||||
.include "math.inc"
|
||||
|
||||
.org $fffc
|
||||
.word reset
|
||||
.word isr
|
||||
Reference in New Issue
Block a user