PCEAS_Startup_File

From ArchaicPixels: HuC and PCEAS Documentation

Jump to: navigation, search
;
; STARTUP.INC - MagicKit startup code equates and macros
;
; ----
; this block defines names for joypad
; direction and button bits
JOY_I = $01
JOY_II = $02
JOY_SEL = $04
JOY_RUN = $08
JOY_UP = $10
JOY_RIGHT = $20
JOY_DOWN = $40
JOY_LEFT = $80
JOY_TYPE6 = $50
JOY_III = $01
JOY_IV = $02
JOY_V = $04
JOY_VI = $08
JOY_BITI = $0
JOY_BITII = $1
JOY_BITSEL = $2
JOY_BITRUN = $3
JOY_BITUP = $4
JOY_BITRT = $5
JOY_BITDN = $6
JOY_BITLT = $7
JOY_BITIII = $0
JOY_BITIV = $1
JOY_BITV = $2
JOY_BITVI = $3
; ----
; this block defines names for interrupt
; vectors
;
IRQ2 = 0
IRQ1 = 1
TIMER = 2
NMI = 3
VSYNC = 4
HSYNC = 5
SOFT_RESET = 6
; ----
; setvec(num, addr)
; ----
; num, vector number (see defines above)
; addr, address of the new routine
; ----
setvec
.macro
lda \1
ldx #LOW(\2)
ldy #HIGH(\2)
jsr set_intvec
.endm
; ----
; vec_on(num)
; ----
; num, vector to enable
; ----
vec_on
.macro
.if
(\1 = 5)
smb #6,<irq_m
.else
smb \1,<irq_m
.endif
.endm
; ----
; vec_off(num)
; ----
; num, vector to disable
; ----
vec_off
.macro
.if
(\1 = 5)
rmb #6,<irq_m
.else
rmb \1,<irq_m
.endif
.endm
; ----
; vsync([nb])
; ----
; nb, number of frames to be sync'ed on
; ----
vsync
.macro
.if
(\# = 0)
lda #1
.else
lda \1
.endif
jsr wait_vsync
.endm
;===================================================================
;
; STARTUP.ASM - MagicKit standard startup code
;
; first, set MOUSE to default on:
;
SUPPORT_MOUSE
.equ
1
.list
.ifdef
HUC
.include
"huc.inc"
; HUC
.include
"huc_opt.inc"
.endif
; HUC
.include
"standard.inc"
; HUCARD
; ----
; setup flexible boundaries for startup code
; and user program's "main".
;
START_BANK
.equ
0
LIB1_BANK
.equ
START_BANK
LIB2_BANK
.equ
START_BANK+1
.ifdef
HUC
FONT_BANK
.equ
START_BANK+1
.if
(CDROM)
CONST_BANK
.equ
START_BANK+2
DATA_BANK
.equ
START_BANK+3
.else
PSG_BANK
.equ
START_BANK+2
CONST_BANK
.equ
START_BANK+3
DATA_BANK
.equ
START_BANK+4
.endif
.else
; HuC (because of .proc/.endp) does not use MAIN_BANK
MAIN_BANK
.equ
START_BANK+2
.endif
; HUC
; ----
; if FONT_VADDR is not specified, then specify it
; (VRAM address to load font into)
;
.ifndef
FONT_VADDR
FONT_VADDR
.equ
$0800
.endif
; ----
; system variables
;
.zp
zp_ptr1:
.ds
2
.bss
.if
(CDROM)
; CDROM def's in system.inc
.include
"system.inc"
.else
; ie HuCard
.org
$2200
user_jmptbl:
; user interrupt vectors
irq2_jmp:
.ds
2
; IRQ2 (BRK instruction and external IRQ)
irq1_jmp:
.ds
2
; IRQ1 (VDC interrupt)
timer_jmp:
.ds
2
; TIMER
nmi_jmp:
.ds
2
; NMI (unused)
vsync_hook:
.ds
2
; VDC vertical sync routine
hsync_hook:
.ds
2
; VDC horizontal sync rountine
bg_x1:
.ds
2
bg_x2:
.ds
2
bg_y1:
.ds
2
bg_y2:
.ds
2
.org
$2227
joyena:
.ds
1
; soft reset enable (bit 0/pad 1, bit 1/pad2, etc.)
joy:
.ds
5
; 'current' pad values (pad #1-5)
joytrg:
.ds
5
; 'delta' pad values (new keys hit)
joyold:
.ds
5
; 'previous' pad values
.org
$2241
irq_cnt:
.ds
1
; VDC interrupt counter; increased 60 times per second
; reset to zero when vsync() function called
vdc_mwr:
.ds
1
vdc_dcr:
.ds
1
.endif
.org
$2244
scr_mode:
.ds
1
; screen mode and dimensions - set by <ex_scrmod>
scr_w:
.ds
1
scr_h:
.ds
1
.org
$2284
soft_reset:
.ds
2
; soft reset jump loc (run+select)
.if
 !(CDROM)
.include
"sound.inc"
.endif
.org
$2680
vsync_cnt:
.ds
1
; counter for 'wait_vsync' routine
joybuf:
.ds
5
; 'delta' pad values collector
joyhook:
.ds
2
; 'read_joypad' routine hook
joycallback:
.ds
6
; joypad enhanced callback support
disp_cr:
.ds
1
; display control (1 = on, 0 = off)
clock_hh
.ds
1
; system clock, hours since startup (0-255)
clock_mm
.ds
1
; system clock, minutes since startup (0-59)
clock_ss
.ds
1
; system clock, seconds since startup (0-59)
clock_tt
.ds
1
; system clock, ticks (1/60th sec) since startup (0-59)
joy6:
.ds
5
; second byte for 6-button joysticks
joytrg6:
.ds
5
joyold6:
.ds
5
joybuf6:
.ds
5
joytmp:
.ds
5
joytmp6:
.ds
5
.if
(CDROM)
ovl_running
.ds
1
; overlay # that is currently running
cd_super
.ds
1
; Major CDROM version #
irq_storea
.ds
1
; CDROM IRQ-specific handling stuff
irq_storeb
.ds
1
ram_vsync_hndl
.ds
25
ram_hsync_hndl
.ds
25
.endif
; (CDROM)
;±±±[ STARTUP CODE ]±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±
; Let's prepare this secondary libray bank first, for use later.
; The reason, as you will see, is because code for a given function
; which sits together in a file, may have things in zero-page,
; bss, LIB1_BANK (ie. START_BANK), and LIB2_BANK
.
;
; The assembler must know beforehand what address etc. to use as a basis
.
;
.data
.bank
LIB2_BANK,"Base Library 2/Font"
.org
$6000
.include
"font.inc"
.code
.bank
LIB2_BANK
.org
$A600
.data
.bank
CONST_BANK,"Constants"
.data
.bank
DATA_BANK,"User Program"
.org
$6000
;
; place overlay array here
; 50 entries, each containing
; 2 bytes for start sector,
; 2 bytes for # sectors
;
ovlarray:
.ds
200
.code
.bank
START_BANK,"Base Library 1"
; A little introduction to the boot sequence:
;
; A HuCard has its origin at bank 0, and is mapped at $E000
; It needs to grab the interrupt vectors at $FFF6 and implement
; implement handlers for them
;
; A CDROM will load at bank $80 ($68 for SCD), and the initial
; loader will be mapped at $4000. The current MagicKit sequence
; also maps $C000 to this same bank. However, the initial boot
; sequence will execute at $4070, proceeding to load additional
; code and data, and then jump to a post-boot section called
; 'init_go'. This is the point at which the loader explicitly
; relinquishes the $4000 segment. It should be noted that there
; are library subroutines loaded as part of this initial segment,
; and those routines are located in the $C000 range as well.
;
; Sectors are loaded, up to and including the first "DATA_BANK",
; where the overlay array is stored - so that the CDROM error
; overlay can be located and executed in the event of a CDROM
; system version mismatch (ie. playing SCD games on CDROM)
;
; A second entry point is defined for overlays that are not
; being booted (ie. they are loaded and executed from another
; overlay). This entry point is at $4000, after the segments
; have all found their natural loading spots (ie. segment $68
; for Super CDROMs). This entry point maps the necessary
; segments and resets the stack, without clearing memory or
; performing other setup chores, and then maps and executes
; _main() to run the module. The user has no choice regarding
; this function, although he can pass values through the global
; variables which main() can use to decide what to do next.
;
; An additional "Hook" area has now been defined at $4028,
; which is used at initial load time, in case a SCD overlay
; program is run on plain CDROM hardware, and the author
; wishes to override the default text error message by
; loading and executing a plain CDROM program instead
;
; ----
; interrupt vectors
.if
 !(CDROM)
.org
$FFF6
.dw
_irq2
.dw
_irq1
.dw
_timer
.dw
_nmi
.dw
_reset
.endif
; !(CDROM)
; ----
; develo startup code
.if
(DEVELO)
.org
$6000
sei
map _reset
jmp _reset
_restart:
cla
; map the CD-ROM system bank
tam #7
jmp $4000
; back to the Develo shell
.endif
; (DEVELO)
; ----
; reset
; ----
; things start here
; ----
; ----
; CDROM re-map library bank
;
;
; overlay entry point
;
; assume MMR0, MMR1, MMR6, MMR7 are set.
; set others & reset stack pointer
;
.if
(CDROM)
.org
$C000
; current overlay number that is running
; this is overwritten by the isolink prgram; the load
; statement must be the first in the block
;
ovlentry:
lda #1
sta ovl_running
lda #CONST_BANK+_bank_base
tam #2
lda #DATA_BANK+_bank_base
tam #3
lda #_call_bank
tam #4
stw #$4000,<__sp
ldx #$ff
txs
map _main
jsr _main
bra *
;
; CDROM error message alternate load entry point
;
.org
$4028
cderr_override:
.db
0
cderr_overlay_num:
.db
0
cdrom_err_load:
; since CDROM program will load into same area in RAM,
; this load routine must be executed from scratch RAM
; re-use the ram interrupt handler areas (not yet initialized)
tii
.load_cd_ovl,
ram_vsync_hndl, 64
jmp ram_vsync_hndl
.load_cd_ovl:
lda cderr_overlay_num
asl A
asl A
tay
lda #DATA_BANK+$80
tam #3
ldx ovlarray,Y++
lda ovlarray,Y++
stz <_cl
; sector (offset from base of track)
sta <_ch
stx <_dl
lda ovlarray,Y
sta <_al
; # sectors
lda #$80
sta <_bl
; bank #
lda #3
sta <_dh
; MPR #
jsr cd_read
cmp #0
bne
.error
lda #$80
tam #2
jmp _boot
.error:
jmp cd_boot
; Can't load - reboot CDROM system card
;
; Proper Boot-time entry point
;
.org
$4070
_boot:
stz $2680
; clear program RAM
tii $2680,$2681,$197F
;
; Note: All CDROM boot loaders will load into MMR $80 region
; regardless of whether they are CD or SCD.
; Here, we will move the information to occupy
; base memory at MMR $68 if appropriate
;
.if
(CDROM = SUPER_CD)
jsr ex_getver
; check if SCD program running
stx cd_super
; on SCD hardware
cpx #3
; don't copy to _bank_base if
bne
.nocopy
; memory doesn't exist there
lda #_bank_base+1
; copy bank 2 to proper location
tam #6
tii $6000,$C000,$2000
tam #3
; FONT_BANK now lives in SCD area ($69 exactly)
lda #_bank_base
; then copy bank 1
tam #6
tii $4000,$C000,$2000
; then load rest of program
.nocopy:
.endif
; (CDROM = SUPER_CD)
.else
; (ie
.
if HuCard...)
.org
$E010
_reset:
sei
; disable interrupts
csh
; select the 7
.16
MHz clock
cld
; clear the decimal flag
ldx #$FF
; initialize the stack pointer
txs
lda #$FF
; map the I/O bank in the first page
tam #0
lda #$F8
; and the RAM bank in the second page
tam #1
stz $2000
; clear all the RAM
tii $2000,$2001,$1FFF
.endif
; (CDROM)
; ----
; initialize the hardware
_init:
.if
(CDROM)
jsr ex_dspoff
jsr ex_rcroff
jsr ex_irqoff
jsr ad_reset
.else
stz timer_ctrl
; init timer
.endif
; (CDROM)
jsr init_psg
; init sound
jsr init_vdc
; init video
lda #$1F
; init joypad
sta joyena
; ----
; initialize interrupt vectors
.if
(CDROM)
jsr ex_dspon
jsr ex_rcron
jsr ex_irqon
.else
ldx #4
; user vector table
cly
.l2:
lda #LOW(_rti)
sta user_jmptbl,Y
iny
lda #HIGH(_rti)
sta user_jmptbl,Y
iny
dex
bne
.l2
stw #_reset,soft_reset
; soft reset
stw #_rts,vsync_hook
; user vsync routine
stw #_rts,hsync_hook
; user hsync routine
lda #$01
; enable interrupts
sta irq_disable
stz irq_status
cli
; ----
; enable display and VSYNC interrupt
vreg #5
lda #$C8
sta <vdc_crl
sta video_data_l
st2 #$00
lda #$01
sta disp_cr
.endif
; (CDROM)
; ----
; init TIA instruction in RAM (fast BLiTter to hardware)
lda #$E3
; TIA instruction opcode
sta _ram_hdwr_tia
lda #$60
; RTS instruction opcode
sta _ram_hdwr_tia_rts
; ----
; init random number generator
lda #1
jsr wait_vsync
; wait for one frame & randomize _rndseed
stw #$03E7,<_cx
; set random seed
stw _rndseed,<_dx
jsr srand
.if
(CDROM)
.if
(CDROM = SUPER_CD)
lda cd_super
; don't load the program if SCD
cmp #3
; program not running on SCD hrdware
beq loadprog
lda cderr_override
lbeq dontloadprog
jmp cdrom_err_load
.endif
; (SUPER_CD)
; ----
; load program
; ----
; CL/CH/DL = sector address
; DH = load mode - bank mode ($6000-$7FFF)
; BL = bank index
; AL = number of sectors
;
loadprog:
lda ovlentry+1
; current overlay (as written by ISOLINK)
cmp #1
; is it initial overlay ?
lbne _init_go
; if not initial overlay, somebody else already
; loaded us completely; do not try to load remainder
; (ie
.
executing CDROM error overlay)
stz <_cl
; initial boot doesn't load complete program;
stz <_ch
; prepare to load remainder
lda #10
; 10th sector (0-1 are boot;
; 2-9 are this library...)
sta <_dl
lda #3
; load mode (consecutive banks; use MPR 3)
sta <_dh
stw #(_bank_base+2),<_bx
; 2 banks are boot/base library
stw #(_nb_bank-2)*4,<_ax
jsr cd_read
cmp #$00
lbeq _init_go
; ----
jmp cd_boot
; reset
; This is the point in the CDROM loader where the code no longer
; executes in the $4000 segment, in favour of using the $C000
; segment (also used for the library subroutines)
.org
$C130
; These routines will be run from RAM @ $2000 so we
; need to count bytes to determine how much to xfer
; (The total is 24 bytes, but we copy 25)
.bank
LIB2_BANK
vsync_irq_ramhndlr:
php
; 1 byte
pha
; 1
tma #6
; 2
sta irq_storea
; 3
lda #BANK(_vsync_hndl)
; 2
tam #6
; 2
pla
; 1
pha
; 1
jsr _vsync_hndl
; 3
lda irq_storea
; 3
tam #6
; 2
pla
; 1
plp
; 1
rts
; 1 = 24 bytes
hsync_irq_ramhndlr:
php
; 1 byte
pha
; 1
tma #6
; 2
sta irq_storeb
; 3
lda #BANK(_hsync_hndl)
; 2
tam #6
; 2
pla
; 1
pha
; 1
jsr _hsync_hndl
; 3
lda irq_storeb
; 3
tam #6
; 2
pla
; 1
plp
; 1
rts
; 1 = 24 bytes
.bank
LIB1_BANK
_init_go:
.if
(CDROM = SUPER_CD)
dontloadprog:
.endif
.endif
; (CDROM)
; ----
; jump to main routine
; ----
; load font
.ifdef
HUC
stw #$4000,<__sp
; init stack ptr first
stw #FONT_VADDR,<_di
; Load Font @ VRAM addr
;
; this section of font loading was stolen
; from _load_default_font because the default
; FONT segment number is not yet guaranteed
; if the SCD is being run on a plain CDROM system
; so we need to trick the segment pointer
; with a reliable one
;
__ldw <_di
; stolen from _load_default_font
; because segment# default not reliable
jsr _set_font_addr
; set VRAM
.if
(CDROM)
stb #FONT_BANK+$80,<_bl
; guarantee FONT_BANK even if
; SCD on regular CDROM system
.else
stb #FONT_BANK+_bank_base,<_bl
.endif
stb #96,<_cl
stb _font_color+1,<_ah
lda _font_color
bne
.fntld
inc A
.fntld:
sta <_al
clx
lda font_table,X
sta <_si
inx
lda font_table,X
sta <_si+1
; Now, load the font
;
; Note for CDROM/Super CDROM:
;
; The 'REAL' mapping for the lib2_load_font function
; maybe doesn't exist yet (we are executing from bank $80,
; not from $68 if it's a Super CDROM)
;
; So we must map the version at bank ($80 + LIB2_BANK)
; before executing it
.
We remap the bank after completion,
; 'just in case'
.if
(CDROM)
tma #page(lib2_load_font)
pha
lda #LIB2_BANK+$80
tam #page(lib2_load_font)
jsr lib2_load_font
pla
tam #page(lib2_load_font)
.else
jsr load_font
.endif
;
; END stolen font-load
;
jsr _cls
stz color_reg
; set color #0 = 0/0/0 rgb
stz color_reg+1
stz color_data
stz color_data+1
lda #1
; set color #1 = 7/7/7 rgb
sta color_reg
stz color_reg+1
ldx #$ff
stx color_data
sta color_data+1
; ----
; Super CDROM error message
; ----
.if
(CDROM)
.if
(CDROM = SUPER_CD)
lda cd_super
cmp #3
lbeq
.ok
; SCD running on Super system
lda #FONT_BANK+$80
; guarantee FONT_BANK even if
; SCD on regular CDROM system
tam #PAGE(scdmsg1)
__ldwi scdmsg1
__phw 2,2
__ldwi $0180
call _put_string
.2
__ldwi scdmsg2
__phw 2,2
__ldwi $0200
call _put_string
.2
__ldwi scdmsg3
__phw 2,2
__ldwi $0383
call _put_string
.2
__ldwi scdmsg4
__phw 2,2
__ldwi $0403
call _put_string
.2
bra *
; otherwise loop on blank screen
.bank
LIB2_BANK
scdmsg1:
.db
"This game was written for the"
.db
0
scdmsg2:
.db
"PC Engine Super CDROM System"
.db
0
scdmsg3:
.db
"Please use a PC Engine"
.db
0
scdmsg4:
.db
"Super CDROM System card"
.db
0
.bank
LIB1_BANK
.ok:
.endif
; (CDROM = SUPER_CD)
.endif
; (CDROM)
.endif
; (HUC)
.ifdef
SUPPORT_MOUSE
jsr mousinit
; check existence of mouse
.endif
; SUPPORT_MOUSE
.if
(CDROM)
; Now, install the RAM-based version of the
; interrupt-handlers and activate them
tma #page(vsync_irq_ramhndlr)
pha
lda #bank(vsync_irq_ramhndlr)
tam #page(vsync_irq_ramhndlr)
tii vsync_irq_ramhndlr,ram_vsync_hndl,25
tii hsync_irq_ramhndlr,ram_hsync_hndl,25
pla
tam #page(vsync_irq_ramhndlr)
stw #ram_vsync_hndl,vsync_hook
; set VSYNC handler
smb #4,<irq_m
; enable new code
smb #5,<irq_m
; disable system card code
stw #ram_hsync_hndl,hsync_hook
; set HSYNC handler
smb #6,<irq_m
; enable new code
smb #7,<irq_m
; disable system card code
.endif
; (CDROM)
.ifdef
HUC
; ----
; Map the final stuff before executing main()
; ----
lda #CONST_BANK+_bank_base
; map string constants bank
tam #2
; (ie
.
$4000-$5FFF)
lda #_call_bank
; map call bank
tam #4
; (ie
.
$8000-$9FFF)
; ---
.if
(CDROM)
lda #1
; first overlay to run at boot time
sta ovl_running
; store for later use
.endif
; ---
stz clock_hh
; clear clock
stz clock_mm
stz clock_ss
stz clock_tt
map _main
jsr _main
; go!
bra *
.else
map main
jmp main
.endif
; HUC
; ----
; system
; ----
; give back control to the Develo system
; ----
.if
(DEVELO)
_system:
sei
csh
cld
ldx #$FF
; stack
txs
lda #$FF
; I/O bank
tam #0
lda #$F8
; RAM bank
tam #1
lda #$80
; Develo Bank
tam #2
tma #7
; startup code bank
tam #3
; ----
; re-initialize the machine
;
stz $2000
; clear RAM
tii $2000,$2001,$1FFF
stz timer_ctrl
; init timer
jsr init_psg
; init sound
jsr init_vdc
; init video
lda #$1F
; init joypad
sta joyena
lda #$07
; set interrupt mask
sta irq_disable
stz irq_status
; reset timer interrupt
lda #$80
; disable sound driver
sta <$20E7
st0 #5
; enable display and vsync interrupt
lda #$C8
sta <vdc_crl
sta video_data_l
jmp _restart
; restart
.endif
; (DEVELO)
;±±±[ INTERRUPT CODE ]±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±
_rts:
rts
_rti:
rti
; ----
; irq2
; ----
; IRQ2 interrupt handler
; ----
.if
 !(CDROM)
_irq2:
bbs0 <irq_m,
.user
rti
.user:
jmp [irq2_jmp]
.endif
; !(CDROM)
; ----
; irq1
; ----
; VDC interrupt handler
; ----
.if
 !(CDROM)
_irq1:
bbs1 <irq_m,user_irq1
; jump to the user irq1 vector if bit set
; --
pha
; save registers
phx
phy
; --
lda video_reg
; get VDC status register
sta <vdc_sr
; save a copy
; ----
; vsync interrupt
;
.vsync:
bbr5 <vdc_sr,
.hsync
; --
inc irq_cnt
; increment IRQ counter
; --
st0 #5
; update display control (bg/sp)
lda <vdc_crl
sta video_data_l
; --
bbs5 <irq_m,
.l3
; --
jsr _vsync_hndl
; --
.l3:
bbr4 <irq_m,
.l4
jsr user_vsync
; call user vsync routine
.l4:
; ----
; hsync interrupt
;
.hsync:
bbr2 <vdc_sr,
.exit
bbs7 <irq_m,
.l5
; --
jsr _hsync_hndl
; --
.l5:
bbr6 <irq_m,
.exit
jsr user_hsync
; call user handler
; ----
; exit interrupt
;
.exit:
lda <vdc_reg
; restore VDC register index
sta video_reg
; --
ply
plx
pla
rti
; ----
; user routine hooks
;
user_irq1:
jmp [irq1_jmp]
user_hsync:
jmp [hsync_hook]
user_vsync:
jmp [vsync_hook]
.endif
; !(CDROM)
; ----
; _vsync_hndl
; ----
; Handle VSYNC interrupts
; ----
_vsync_hndl:
.if
 !(CDROM)
ldx disp_cr
; check display state (on/off)
bne
.l1
and #$3F
; disable display
st0 #5
; update display control (bg/sp)
sta video_data_l
bra
.l2
; --
.endif
.l1:
jsr rcr_init
; init display list
.l2:
st0 #7
; scrolling
stw bg_x1,video_data
st0 #8
stw bg_y1,video_data
; --
lda clock_tt
; keep track of time
inc A
cmp #60
bne
.lcltt
lda clock_ss
inc A
cmp #60
bne
.lclss
lda clock_mm
inc A
cmp #60
bne
.lclmm
inc clock_hh
cla
.lclmm:
sta clock_mm
cla
.lclss:
sta clock_ss
cla
.lcltt:
sta clock_tt
; --
.if
(CDROM)
jsr ex_colorcmd
inc rndseed
jsr randomize
lda <$e7
cmp #$01
bne
.skip_psg
jsr psg_driver
.skip_psg:
.endif
.ifdef
SUPPORT_MOUSE
lda msflag
; if mouse supported, and exists
beq
.l3
; then read mouse instead of pad
jsr mousread
bra
.out
.endif
; SUPPORT_MOUSE
.l3:
jsr read_joypad
; else read joypad
.out:
rts
; ----
; _hsync_hndl
; ----
; Handle HSYNC interrupts
; ----
; ----
; hsync scrolling handler
;
_hsync_hndl:
ldy s_idx
bpl
.r1
; --
lda <vdc_crl
and #$3F
sta <vdc_crl
stz s_idx
ldx s_list
lda s_top,X
jsr rcr5
rts
; --
.r1:
ldx s_list,Y
lda <vdc_crl
and #$3F
ora s_cr,X
sta <vdc_crl
; --
jsr rcr_set
; --
lda s_top,X
cmp #$FF
beq
.out
; --
st0 #7
lda s_xl,X
ldy s_xh,X
sta video_data_l
sty video_data_h
st0 #8
lda s_yl,X
ldy s_yh,X
sub #1
bcs
.r2
dey
.r2:
sta video_data_l
sty video_data_h
.out:
rts
; ----
; init display list
;
rcr_init:
maplibfunc build_disp_list
bcs
.r3
rts
; --
.r3:
smb #7,<vdc_crl
lda #$FF
sta s_idx
ldx s_list
ldy s_top,X
cpy #$FF
bne rcr5
; --
ldy s_xl,X
sty bg_x1
ldy s_xh,X
sty bg_x1+1
ldy s_yl,X
sty bg_y1
ldy s_yh,X
sty bg_y1+1
stz s_idx
bra rcr5
; ----
; program scanline interrupt
;
rcr_set:
iny
sty s_idx
lda s_list,Y
tay
lda s_top,Y
cmp scr_height
bhs rcr6
cmp s_bottom,X
blo rcr5
; --
lda s_bottom,X
rcr4: dec A
pha
lda #$F0
sta s_bottom,X
stz s_cr,X
dec s_idx
pla
; --
rcr5:
st0 #6
; set scanline counter
add #64
sta video_data_l
cla
adc #0
sta video_data_h
bra __rcr_on
;--
rcr6: lda s_bottom,X
cmp scr_height
blo rcr4
bra __rcr_off
; ----
; rcr_on
; ----
; enable scanline interrupt
; ----
rcr_on:
_rcr_on:
lda #5
sta <vdc_reg
__rcr_on:
st0 #5
lda <vdc_crl
ora #$04
sta <vdc_crl
sta video_data_l
rts
; ----
; rcr_off
; ----
; disable scanline interrupt
; ----
rcr_off:
_rcr_off:
lda #5
sta <vdc_reg
__rcr_off:
st0 #5
lda <vdc_crl
and #$FB
sta <vdc_crl
sta video_data_l
rts
; ----
; timer
; ----
; timer interrupt handler
; ----
.if
 !(CDROM)
_timer_user:
jmp [timer_jmp]
_timer:
bbs2 <irq_m,_timer_user
pha
phx
phy
sta irq_status
; acknowledge interrupt
lda <psg_irqflag
; is IRQ being serviced ?
bne
.exit
inc <psg_irqflag
; IRQ being serviced
cli
; but allow other interrupts to be processed
lda <psg_inhibit
; if sound off, don't bother
bne
.exit2
bsr psg_driver
; do all sound-related stuff
.exit2:
stz <psg_irqflag
; allow IRQ processing again
.exit:
ply
plx
pla
rti
psg_driver:
tma #page(psg_drive)
; map out the code segment
pha
lda #bank(psg_drive)
tam #page(psg_drive)
tma #4
; save data banks
pha
tma #3
pha
lda psg_bank1
; map PSG data banks
tam #3
lda psg_bank2
tam #4
jsr psg_drive
lda psg_tempo
bmi
.noreset
sta timer_cnt
ora #$80
sta psg_tempo
.noreset:
pla
; restore data banks
tam #3
pla
tam #4
pla
tam #page(psg_drive)
; restore code bank
rts
.endif
; !(CDROM)
; ----
; nmi
; ----
; NMI interrupt handler
; ----
.if
 !(CDROM)
_nmi:
bbs3 <irq_m,
.user
rti
.user:
jmp [nmi_jmp]
.endif
; !(CDROM)
;±±[ DATA ]±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±
; ----
; font
; ----
.ifdef
HUC
font_table:
.dw
font_1
.dw
font_2
.dw
font_1
.dw
font_1
.endif
; HUC
;±±[ LIBRARY ]±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±
; ----
; standard library
; ----
.include
"library
.asm"
.include
"scroll
.asm"
.include
"math
.asm"
.ifdef
HUC
.include
"huc
.asm"
.include
"huc_gfx
.asm"
.include
"huc_math
.asm"
.include
"huc_bram
.asm"
.include
"huc_misc
.asm"
.endif
; HUC
.ifdef
SUPPORT_MOUSE
.include
"mouse
.asm"
.endif
; SUPPORT_MOUSE
.if
(CDROM)
.include
"cdrom
.asm"
.else
.include
"sound
.asm"
.endif
; CDROM
; ----
; disp_on
; ----
; enable display
; ----
.ifdef
HUC
_disp_on:
ldx disp_cr
lda #1
sta disp_cr
cla
rts
.else
disp_on:
lda #1
sta disp_cr
rts
.endif
; HUC
; ----
; disp_off
; ----
; disable display
; ----
.ifdef
HUC
_disp_off:
ldx disp_cr
stz disp_cr
cla
rts
.else
disp_off:
stz disp_cr
rts
.endif
; HUC
; ----
; set_intvec
; ----
; set interrupt vector
; ----
; IN : A = vector number
; 0 IRQ2
; 1 IRQ1 (VDC)
; 2 TIMER
; 3 NMI
; 4 VSYNC
; 5 HSYNC
; 6 SOFT RESET (RUN + SELECT)
; X = vector address low byte
; Y = " " high byte
; ----
.if
 !(CDROM)
set_intvec:
php
sei
cmp #6
blo
.vector
bne
.exit
.reset:
stx soft_reset
sty soft_reset+1
bra
.exit
.vector:
pha
asl A
sax
sta user_jmptbl,X
inx
tya
sta user_jmptbl,X
pla
.exit:
plp
rts
.endif
; !(CDROM)
; ----
; wait_vsync
; ----
; wait the next vsync
; ----
; IN : A = number of frames to be sync'ed on
; ----
; OUT: A = number of elapsed frames since last call
; ----
wait_vsync:
bbr1 <irq_m,
.l1
cla
; return immediately if IRQ1 is redirected
.ifdef
HUC
clx
.endif
rts
.l1:
sei
; disable interrupts
cmp irq_cnt
; calculate how many frames to wait
beq
.l2
bhs
.l3
lda irq_cnt
.l2:
inc A
.l3:
sub irq_cnt
sta vsync_cnt
cli
; re-enable interrupts
.l4:
lda irq_cnt
; wait loop
.l5:
incw _rndseed
cmp irq_cnt
beq
.l5
dec vsync_cnt
bne
.l4
stz irq_cnt
; reset system interrupt counter
inc A
; return number of elapsed frames
.ifndef
HUC
rts
.else
; ----
; callback support
pha
lda joycallback
; callback valid?
bpl
.t3
bit #$01
bne
.t3
lda joycallback+1
; get events for all the
beq
.t3
; selected joypads
sta <_al
cly
cla
.t1:
lsr <_al
bcc
.t2
ora joybuf,Y
.t2:
iny
cpy #5
blo
.t1
and joycallback+2
; compare with requested state
beq
.t3
inc joycallback
; lock callback feature
tax
; call user routine
tma #5
pha
lda joycallback+3
tam #5
cla
jsr
.callback
pla
tam #5
dec joycallback
; unlock
; --
.t3:
plx
cla
rts
; ----
; user routine callback
;
.callback:
jmp [joycallback+4]
.endif
; ndef HUC
.include
"joypad.asm"
; read joypad values
;±±[ USER PROGRAM ]±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±
; .nomlist
; .list
;...
; .endif
Retrieved from "http://www.archaicpixels.com/index.php/PCEAS_Startup_File"
Personal tools