328 lines
7.0 KiB
ArmAsm
328 lines
7.0 KiB
ArmAsm
*= $6000
|
|
|
|
; conditional compilation flags
|
|
|
|
DEBUG_BOUNDS = 1
|
|
|
|
|
|
.include "macros.s"
|
|
.include "constants.s"
|
|
|
|
; Zero page locations. Using the whole thing because we aren't using any
|
|
; ROM routines
|
|
|
|
*= $0006
|
|
; parameters: these should not be changed by child subroutines
|
|
param_x .ds 1
|
|
param_y .ds 1
|
|
param_col .ds 1
|
|
param_row .ds 1
|
|
param_index .ds 1
|
|
param_count .ds 1
|
|
param_save .ds 1
|
|
|
|
*= $0080
|
|
; scratch areas: these may be modified by child subroutines
|
|
scratch_addr .ds 2
|
|
scratch_ptr .ds 2
|
|
scratch_0 .ds 1
|
|
scratch_1 .ds 1
|
|
scratch_2 .ds 1
|
|
scratch_index .ds 1
|
|
scratch_count .ds 1
|
|
scratch_col .ds 1
|
|
scratch_row .ds 1
|
|
|
|
*= $0090
|
|
; required variables for HiSprite/asmgen
|
|
damageindex .ds 1
|
|
damageindex1 .ds 1
|
|
damageindex2 .ds 1
|
|
bgstore .ds 2
|
|
damage_w .ds 1
|
|
damage_h .ds 1
|
|
damageptr .ds 2
|
|
damageptr1 .ds 2
|
|
damageptr2 .ds 2
|
|
|
|
*= $00a0
|
|
tdamageindex .ds 1
|
|
tdamageindex1 .ds 1
|
|
tdamageindex2 .ds 1
|
|
damagestart .ds 1
|
|
src .ds 2 ; decompression usage
|
|
dst .ds 2
|
|
end .ds 2
|
|
count .ds 2
|
|
delta .ds 2
|
|
|
|
*= $00b0
|
|
; global variables for this program
|
|
rendercount .ds 1
|
|
drawpage .ds 1 ; pos = page1, neg = page2
|
|
hgrhi .ds 1 ; either $20 or $40, the base of each hgr screen
|
|
hgrselect .ds 1 ; either $00 or $60, used as xor mask for HGRROWS_H1
|
|
tempaddr .ds 2
|
|
counter1 .ds 1
|
|
textptr .ds 2
|
|
hgrptr .ds 2
|
|
temprow .ds 1
|
|
tempcol .ds 1
|
|
tempcheck .ds 1
|
|
|
|
*= $00c0
|
|
mazeaddr .ds 2
|
|
next_level_box .ds 1
|
|
box_row_save .ds 1
|
|
box_col_save .ds 1
|
|
maze_gen_col .ds 1
|
|
config_num_players .ds 1
|
|
config_quit .ds 1
|
|
frame_count .ds 2
|
|
countdown_time .ds 1
|
|
still_alive .ds 1
|
|
|
|
*= $00d0
|
|
current_actor .ds 1
|
|
current .ds 1 ; current direction
|
|
last_dir .ds 1
|
|
allowed .ds 1 ; allowed directions
|
|
allowed_horz .ds 1
|
|
allowed_vert .ds 1
|
|
updown .ds 1 ; up or down for amidar
|
|
d .ds 1 ; actor input dir
|
|
r .ds 1
|
|
r1 .ds 1
|
|
r2 .ds 1
|
|
c .ds 1
|
|
c1 .ds 1
|
|
c2 .ds 1
|
|
size .ds 1
|
|
dot .ds 1
|
|
|
|
* = $00e0
|
|
before .ds 1
|
|
crossed .ds 1
|
|
round_robin_index .ds 2
|
|
level .ds 1
|
|
last_enemy .ds 1
|
|
|
|
*= $f0
|
|
debug_a .ds 1
|
|
debug_x .ds 1
|
|
debug_y .ds 1
|
|
debug_last_key .ds 1
|
|
frame_count .ds 2
|
|
|
|
; other declare storage vars
|
|
.include "vars.s"
|
|
|
|
*= $6000
|
|
|
|
start jsr set_hires ; start with HGR page 1, full screen
|
|
|
|
lda #<TITLE_START
|
|
sta src
|
|
lda #>TITLE_START
|
|
sta src+1
|
|
lda #<TITLE_END
|
|
sta end
|
|
lda #>TITLE_END
|
|
sta end+1
|
|
lda #0
|
|
sta dst
|
|
lda #$40
|
|
sta dst+1
|
|
jsr unpack_lz4
|
|
|
|
restart jsr init_once
|
|
jsr title_screen
|
|
jsr init_game
|
|
jsr game_loop
|
|
|
|
check_restart ldx #34 ; x coord on screen for "GAME"
|
|
ldy player_score_row
|
|
lda #<game_text
|
|
sta scratch_ptr
|
|
lda #>game_text
|
|
sta scratch_ptr+1
|
|
jsr printstr
|
|
ldx #35 ; x coordinate for "OVER"
|
|
ldy player_lives_row
|
|
lda #<over_text
|
|
sta scratch_ptr
|
|
lda #>over_text
|
|
sta scratch_ptr+1
|
|
jsr printstr ; prints to back page, so have to flip pages to show
|
|
jsr pageflip
|
|
|
|
jsr any_key
|
|
jmp restart
|
|
|
|
game_text .byte "GAME ",0
|
|
over_text .byte "OVER",0
|
|
|
|
forever
|
|
jmp forever
|
|
|
|
init_once jsr init_vars
|
|
jsr init_damage
|
|
jsr init_screen_once
|
|
jsr init_actors_once
|
|
rts
|
|
|
|
title_screen nop
|
|
lda #1
|
|
sta config_num_players
|
|
lda #0
|
|
sta config_quit
|
|
lda #1
|
|
sta level
|
|
rts
|
|
|
|
init_game jsr init_level
|
|
jsr init_actors
|
|
jsr initbackground
|
|
lda #0
|
|
sta frame_count
|
|
sta frame_count+1
|
|
sta countdown_time
|
|
sta config_quit
|
|
rts
|
|
|
|
initbackground jsr init_damage
|
|
jsr show_page1
|
|
jsr init_maze
|
|
jsr init_panel
|
|
jsr titlepage
|
|
jsr copytexthgr ; page2 becomes the source
|
|
jsr fastwipe
|
|
jsr copy2to1
|
|
rts
|
|
|
|
; main game loop. Rather than optimize things and unroll all this stuff into
|
|
; a single big function, I'm calling a bunch of subroutines in hopes that
|
|
; it is easier to follow.
|
|
;
|
|
; The "actor" is either a player or an enemy, and the actor number is placed
|
|
; in the X register. Subroutines must save the X register and restore it
|
|
; upon return if they modify it.
|
|
;
|
|
; All of the game logic routines expect the player/enemy number in X as they
|
|
; use it as an index into whatever specific data they need, like position or
|
|
; direction.
|
|
game_loop nop
|
|
inc frame_count ; frame count isn't used for anything other than debugging
|
|
bne ?1
|
|
inc frame_count+1
|
|
?1 jsr userinput
|
|
|
|
lda config_quit
|
|
beq ?2
|
|
rts
|
|
|
|
; loop through enemies first so we can check collisions with the
|
|
; players as the players are moved
|
|
?2 lda #FIRST_AMIDAR-1
|
|
sta current_actor
|
|
?enemy inc current_actor
|
|
ldx current_actor
|
|
lda actor_active,x
|
|
bmi ?player ; negative = end
|
|
beq ?enemy ; zero = skip
|
|
jsr clear_actor_flag
|
|
jsr move_enemy
|
|
jsr set_actor_flag
|
|
jmp ?enemy
|
|
|
|
?player lda #0
|
|
sta still_alive
|
|
lda #$ff
|
|
sta current_actor
|
|
?p1 inc current_actor
|
|
ldx current_actor
|
|
lda actor_type,x
|
|
cmp #PLAYER_TYPE
|
|
bne ?alive
|
|
lda actor_active,x
|
|
beq ?p1 ; zero = skip
|
|
jsr handle_player
|
|
jmp ?p1
|
|
|
|
; if any player is still alive, the game continues. Once the last player
|
|
; dies, the countdown timer allows the enemies to continue to move a
|
|
; little while before the game ends. Returning from the game loop means
|
|
; that the game is over.
|
|
?alive lda still_alive
|
|
bne ?draw
|
|
dec countdown_time
|
|
bne ?draw
|
|
rts
|
|
|
|
; main draw loop. Restoring background will overwrite the softsprites
|
|
; so there's no need to erase the sprites some other way. Text damage
|
|
; is also restored before any changes for the upcoming frame are drawn.
|
|
?draw jsr restorebg_driver
|
|
jsr restoretext
|
|
jsr paint_boxes
|
|
jsr renderstart
|
|
jsr pageflip
|
|
jsr debug_player
|
|
;jsr wait
|
|
jmp game_loop
|
|
|
|
|
|
; updates the game state based on player status changes
|
|
handle_player nop
|
|
; if actor_status[zp.current_actor] == PLAYER_REGENERATING:
|
|
; # If regenerating, change to alive if the player starts to move
|
|
; if actor_input_dir[zp.current_actor] > 0:
|
|
; actor_status[zp.current_actor] = PLAYER_ALIVE
|
|
lda actor_status,x
|
|
cmp #PLAYER_REGENERATING
|
|
bne ?alive
|
|
lda actor_input_dir,x
|
|
beq ?final
|
|
lda #PLAYER_ALIVE
|
|
sta actor_status,x
|
|
|
|
; if actor_status[zp.current_actor] == PLAYER_ALIVE:
|
|
; # only move and check collisions if alive
|
|
; move_player()
|
|
; check_collisions()
|
|
?alive lda actor_status,x
|
|
cmp #PLAYER_ALIVE
|
|
bne ?dots
|
|
jsr move_player
|
|
jsr check_collisions
|
|
|
|
; if actor_status[zp.current_actor] == PLAYER_ALIVE:
|
|
; # only check for points if still alive
|
|
; check_dots()
|
|
; check_boxes()
|
|
?dots lda actor_status,x
|
|
cmp #PLAYER_ALIVE
|
|
bne ?final
|
|
jsr check_dots
|
|
jsr check_boxes
|
|
|
|
; if actor_status[zp.current_actor] != GAME_OVER:
|
|
; still_alive += 1
|
|
; zp.current_actor += 1
|
|
?final lda actor_status,x
|
|
cmp #GAME_OVER
|
|
beq ?end
|
|
inc still_alive
|
|
?end rts
|
|
|
|
|
|
|
|
|
|
.include "rand.s"
|
|
.include "maze.s"
|
|
.include "actors.s"
|
|
.include "logic.s"
|
|
.include "background.s"
|
|
.include "debug.s"
|
|
.include "lz4.s"
|