;*; Updated on 04-May-90 at 2:37 PM by Matt Badger; edit time: 0:00:44
;SPACE.M68 - Game of Space Invaders
;Copyright (C) 1986 by UltraSoft (ULTR/AM)
;
;Written by: David Pallmann
;
;Edit History:
;1.0 24-Feb-86 created. /DFP
;
;The game performs best when run on a terminal at 19200 baud. Running at a
;slower baud rate will make Space Invaders less challenging and the quality
;of the graphics illusions will suffer.
;
;This program was designed so that it should run on just about any kind of
;terminal, no matter how smart of dumb. The only calls required are Clear
;Screen and Position Cursor. Cursor On and Cursor Off are used if supported
;by the terminal driver.
;
;Space Invaders requires 3K of memory.
;
;Space Invaders is FreeWare. Like the program? Send me a few complements
;and I will continue to write more games like this.
; Address: David Pallmann
; UltraSoft
; 367 Wildwood Rd
; Ronkonkoma, NY 11779
;
;SPACE.M68 is complete and requires no external files (other than those
;included with AMOS/L). To assemble: .M68 SPACE To run: .SPACE
;Program version number
VMAJOR=1
VMINOR=0
;Universal (.UNV) files referenced - all included with AMOS/L
SEARCH SYS
SEARCH SYSSYM
SEARCH TRM
;Registers
;'MEM' (same as A5) - used to point to work memory (variable space)
MEM=A5
;Game definition parameters
;ROWS is set to the number of rows of aliens
;COLS is set to the number of columns of aliens
;WIDTH is set to the screen width
ROWS=4
COLS=8.
WIDTH=80.
;The following defines an alien record as consisting of:
; a row (if this is zero then the alien no longer exists) - one byte
; a column - one byte
; a type code (different types draw different aliens) - also one byte
;There is one alien record for each alien-- the total number is ROWS*COLS
.OFINI
.OFDEF AROW,1 ; cursor row
.OFDEF ACOL,1 ; cursor column
.OFDEF ATYPE,1 ; alien type
.OFSIZ ASIZE
;The following defines variable space used in this program:
.OFINI
.OFDEF ADATA,ASIZE*ROWS*COLS ; alien data - one record for each alien
.OFDEF SCORE,4 ; player's score - one longword
.OFDEF SAUCNT,2 ; saucer appearance timer - one word
.OFDEF SAUVAL,2 ; point value of next saucer - one word
.OFDEF SAUCER,1 ; position (column) of saucer (0=no saucer)
.OFDEF SAUDIR,1 ; direction of saucer movement (0=left,-1=right)
.OFDEF ROW,1 ; row - used by some subroutines - one byte
.OFDEF COL,1 ; column - used by some subroutines - one byte
.OFDEF TYPE,1 ; type - used by some subroutines - one byte
.OFDEF ACOUNT,1 ; number of aliens left
.OFDEF POS,1 ; position (column) of laser base
.OFDEF MROW,1 ; row of user's missile (0=no missile)
.OFDEF MCOL,1 ; column of user's missile
.OFDEF XROW,1 ; row of alien's missile (0=no missile)
.OFDEF XCOL,1 ; column of alien's missile
.OFDEF LIVES,1 ; number of spare lives left
.OFDEF ATTCNT,1 ; cycles between attacks
.OFSIZ MEMSIZ
;Macro CURSOR {row},{column} addresses the cursor
;{row} and {column} arguments must be BYTES
DEFINE CURSOR ROW,COL
CLRW D1
MOVB ROW,D1
ROLW D1,#8.
ADDB COL,D1
TCRT
ENDM
;Macro TCALL is used to define TAB(-1,x) codes (see below)
DEFINE TCALL CODE
MOVW #-1_8.+CODE'.,D1
TCRT
ENDM
;Terminal Special Functions:
;CLS = TAB(-1,0); clear screen
;ON = TAB(-1,28); cursor on
;OFF = TAB(-1,29); cursor off
DEFINE CLS=TCALL 0
DEFINE ON=TCALL 28
DEFINE OFF=TCALL 29
;Start of Code
;Program header defines program as reentrant and reusable (can be LOADed into
;system or user memory safely), and stores version number.
;GETIMP call allocates memory variable space and points register MEM to it.
START: PHDR -1,0,PH$REE!PH$REU ; program header
GETIMP MEMSIZ,MEM ; allocate local memory
;The memory allocated by GETIMP is cleared to zeroes, which is generally
;what the programmer wants. Here, though, we need to pre-load some values:
SETUP: MOVB #4,LIVES(MEM) ; user starts out w/4 extra lives
MOVW #1000.,SAUVAL(MEM) ; value of next saucer is 1000 points
MOVB #5,ATTCNT(MEM) ; set 5 cycles between alien attacks
;Set Terminal
;Set image (single character) mode and turn off terminal echo
;If terminal supports it, turn off cursor
TERM: JOBIDX A0 ; index Job Control Block
MOV JOBTRM(A0),A1 ; get terminal definition area addr
ORW #T$IMI!T$ECS,T.STS(A1) ; set image mode & turn off echo
OFF ; turn off cursor
;Intro Screen
INTRO: CLS ; clear screen
MOVB #12.,ROW(MEM) ; set row to 12
MOVB #10.,COL(MEM) ; and column to 10
CLRB TYPE(MEM) ; set alien type to 0
LEA A1,MESSAG ; index display message
10$: CALL DRAW ; draw alien
MOVB COL(MEM),D2 ; get column
SUBB #3,D2 ; subtract 3 from it
CURSOR ROW(MEM),D2 ; re-address cursor
MOVB (A1)+,D1 ; get next char of message
BEQ 40$ ; branch if end-of-message
CMPB D1,#'~ ; delay command?
BNE 20$ ; no
SLEEP #3000. ; yes - sleep 1/3 second
BR 30$ ; branch
20$: TTY ; display char on screen
30$: INCB COL(MEM) ; increment alien column
BR 10$ ; loop back
40$:
;First or New Screen of Aliens
;Automatically give user a new life as a reward for finishing previous screen
;Clear the screen;
;Retype name 'SPACE INVADERS' at the top of the screen, and display spare
;laser bases (lives) at the bottom of the screen.
NEWSET: CMMB LIVES(MEM),#19. ; does user have 19 spare lives?
BGE 10$ ; yes - can't fit any more on line 24
INCB LIVES(MEM) ; give user another life
10$: CLRB SAUCER(MEM) ; no saucer
MOVW #1000.,SAUCNT(MEM) ; 1000 cycles till next saucer appears
CLRB MROW(MEM) ; no player missile
CLRB XROW(MEM) ; no alien missile
CLS ; clear the screen
TYPE Space Invaders ; name of the game
CURSOR #24.,#1 ; address cursor
CLR D0 ; get number
MOVB LIVES(MEM),D0 ; of addition lives
20$: TYPESP _A_ ; print laser base
SOB D0,20$ ; loop till done
CALL DISCOR ; display score
;Adjust attack frequency based on score
ADJUST: CMM SCORE(MEM),#10000. ; score < 10000?
BLT BASE ; yes - branch
MOVB #4,ATTCNT(MEM) ; no - attack 1 out of 5 times
CMM SCORE(MEM),#25000. ; score < 25000?
BLT BASE ; yes - branch
MOVB #3,ATTCNT(MEM) ; no - attack 1 out of 4 times
CMM SCORE(MEM),#50000. ; score < 50000?
BLT BASE ; yes - branch
MOVB #2,ATTCNT(MEM) ; no - attack 1 out of 3 times
CMM SCORE(MEM),#75000. ; score < 75000?
BLT BASE ; yes - branch
MOVB #1,ATTCNT(MEM) ; no - attack every other time
CMM SCORE(MEM),#100000. ; score < 100000?
BLT BASE ; yes - branch
CLRB ATTCNT(MEM) ; no - attack every change we get
; (this guy is good!)
;Set laser base to center of horizon (column 41) and draw laser base
BASE: MOVB #41.,POS(MEM) ; set laser base position
CALL DRWLSR ; draw laser base
;Initialize alien data array
;Loop through matrix assigning rows, columns, and types
;Top row becomes type 0 aliens, next row is type 1, and so on
;Different type aliens get displayed differently by DRAW subroutine
;Plot all aliens on the screen
;Set ACOUNT (alien count) to total number of aliens
INIT: MOVB #ROWS*COLS,ACOUNT(MEM) ; set alien count
LEA A0,ADATA(MEM) ; index alien data area
MOVB #2,COL(MEM) ; set current column to 2
MOV #COLS,D3 ; set up outer loop
10$: MOV #ROWS,D2 ; set up inner loop
MOVB #4,ROW(MEM) ; set row to 4
CLRB TYPE(MEM) ; set type to 0
20$: MOVB ROW(MEM),AROW(A0) ; set alien row
MOVB COL(MEM),ACOL(A0) ; set alien column
MOVB TYPE(MEM),ATYPE(A0) ; set alien type
CALL DRAW ; draw alien
ADD #ASIZE,A0 ; advance to next data record
ADDB #3,ROW(MEM) ; add 3 to next row
INCB TYPE(MEM) ; add 1 to next type
SOB D2,20$ ; loop till row of aliens defined
ADDB #8.,COL(MEM) ; add 8 to next column
SOB D3,10$ ; loop till all columns of aliens defined
;This is the main body of code. MOVER and MOVEL are nearly identical pieces
;of code. The difference is that MOVER processes the aliens in a different
;order (column-by-column, starting at the right) from MOVEL (column-by-column,
;starting at the left). When MOVER cannot move the aliens any further right,
;it calls the local subroutine NXTROW (which moves all the aliens down a row),
;and branches to MOVEL. MOVEL then moves the aliens left. When MOVEL can't
;go any further left, it too calls the NXTROW routine. Finally, control loops
;right back to MOVER.
;Both MOVEL and MOVER operate in terms of "cycles". In a cycle, the following
;occurs: 1. the next alien is moved left or right
; 2. the saucer (if present) is moved (or possibly created)
; 3. the keyboard is scanned and any commands are acted upon
; 4. if a missile has been fired by the user, or by an alien,
; it is advanced.
;
;Processing for right-moving aliens
MOVER: LEA A0,<ADATA+<ROWS*COLS*ASIZE>-ASIZE>(MEM) ; index last alien record
MOV #ROWS*COLS,D0 ; set up loop to process every alien
CLRB D5 ; clear flag
10$: CTRLC FINISH ; branch on ^C
TSTB AROW(A0) ; is this alien still alive?
BEQ 20$ ; no - branch
CALL CHKCMD ; check and act on player commands
CALL MOVSAU ; move or create flying saucer
CALL MISSIL ; move player missile
TSTB ACOUNT(MEM) ; time for a new screen?
JEQ NEWSET ; yes - branch
CALL ATTACK ; move or create alien missile
TSTB AROW(A0) ; has this alien been destroyed?
BEQ 20$ ; yes
INCB ACOL(A0) ; move alien right
MOVB AROW(A0),ROW(MEM) ; copy row,
MOVB ACOL(A0),COL(MEM) ; column, and
MOVB ATYPE(A0),TYPE(MEM) ; type
CALL DRAW ; re-draw alien
CMPB ACOL(A0),#WIDTH-5 ; is alien at far-right of screen?
BLE 20$ ; no
SETB D5 ; yes - set flag
20$: SUB #ASIZE,A0 ; advance backwards to previous record
SOB D0,10$ ; loop till all aliens moved
TSTB D5 ; is it time to move left?
BEQ MOVER ; no - branch
BCALL NXTROW ; yes - move all aliens down a row
;Processing for left moving aliens
MOVEL: LEA A0,ADATA(MEM) ; index first alien data record
MOV #ROWS*COLS,D0 ; set up loop to process every alien
CLRB D5 ; clear flag
10$: CTRLC FINISH ; branch on ^C
TSTB AROW(A0) ; is this alien still alive?
BEQ 20$ ; no - branch
CALL CHKCMD ; check and act on player commands
CALL MOVSAU ; move or create flying saucer
CALL MISSIL ; move player missile
TSTB ACOUNT(MEM) ; time for a new screen?
JEQ NEWSET ; yes - branch
CALL ATTACK ; move or create alien missile
TSTB AROW(A0) ; has this alien been destroyed?
BEQ 20$ ; yes - branch
DECB ACOL(A0) ; move alien left
MOVB AROW(A0),ROW(MEM) ; copy row,
MOVB ACOL(A0),COL(MEM) ; column, and
MOVB ATYPE(A0),TYPE(MEM) ; type
CALL DRAW ; re-draw alien
CMPB ACOL(A0),#3 ; is alien at far-left of screen?
BGE 20$ ; no - branch
SETB D5 ; yes - set flag
20$: ADD #ASIZE,A0 ; advance to next data record
SOB D0,10$ ; loop till all aliens moved
TSTB D5 ; is it time to move right?
BEQ MOVEL ; no - branch
BCALL NXTROW ; yes - move all aliens down a row
JMP MOVER ; loop back to right-moving routine
;Local Subroutine - increments rows of all aliens
;This routine is called when the array of aliens moves to the far left or
;right of the screen. If any aliens make it line 24 of the screen, the game
;is over and control is passed to GAMOVR.
NXTROW: LEA A0,ADATA(MEM) ; index alien data area
MOV #ROWS*COLS,D0 ; set up loop to process each alien
10$: TSTB AROW(A0) ; is alien alive?
BEQ 20$ ; no - branch
INCB AROW(A0) ; increment row
CMMB AROW(A0),#23. ; have we exceeded row 23?
JGE GAMOVR ; yes - game is over
20$: ADD #ASIZE,A0 ; no - advance to next alien
SOB D0,10$ ; loop till done
RTN ; return
;Move Saucer Routine - called every cycle
;If no saucer is currently on the screen, a counter is decremented. When the
;counter finally reaches zero, a saucer is created. The decision to create
;the saucer on the left or right hand side of the screen is determined by
;whether there are an odd or even number of aliens left on the screen.
;If a saucer is already on the screen, it is advanced.
MOVSAU: TSTB SAUCER(MEM) ; is there a saucer on the screen?
BNE ADVSAU ; yes
DECW SAUCNT(MEM) ; decrement saucer count
BEQ 10$ ; branch if time for a new saucer
RTN ; else return
10$: CLR D7 ; get number
MOVB ACOUNT(MEM),D7 ; of aliens left?
BTST #0,D7 ; even?
BEQ 20$ ; yes
MOVB #WIDTH-7,SAUCER(MEM) ; set column to 75
CLRB SAUDIR(MEM) ; set direction to left
CALL DRWSAU ; draw saucer
RTN ; return
20$: MOVB #2,SAUCER(MEM) ; set column to 2
SETB SAUDIR(MEM) ; set direction to right
CALL DRWSAU ; draw saucer
RTN ; return
ADVSAU: TTYI ; ring
BYTE 7,0 ; bell
TSTB SAUDIR(MEM) ; are moving left or right?
BEQ ADVLFT ; left
ADVRHT: INCB SAUCER(MEM) ; advance to next column
CMMB SAUCER(MEM),#WIDTH-7 ; end of screen?
BGT 10$ ; yes - branch
CALL DRWSAU ; no - re-draw saucer
RTN ; return
10$: CALL CLRSAU ; erase saucer from screen
RTN ; return
ADVLFT: DECB SAUCER(MEM) ; move saucer left
CMMB SAUCER(MEM),#3 ; end of screen?
BLT 10$ ; yes - branch
CALL DRWSAU ; no - re-draw saucer
RTN ; return
10$: CALL CLRSAU ; erase saucer from screen
RTN ; return
;Check Command - called every cycle
;Left-arrow (^H) moves laser base to the left
;Right-arrow (^L) moves laser base to the right
;Space Bar fires a missile
;Control-C exits game
CHKCMD: TCKI ; has a key been pressed?
BEQ 10$ ; yes - branch
RTN ; nope - return
10$: KBD FINISH ; get char into D1 (branch on ^C)
CMPB D1,#'H-'@ ; is it... ^H (left-arrow)?
BEQ MOVLFT ; yes - branch
CMPB D1,#'L-'@ ; is it... ^L (right-arrow)
BEQ MOVRHT ; yes - branch
CMPB D1,#40 ; is it... a space
JEQ FIRE ; yes - branch
RTN ; ignore char and return
;Move laser base left
MOVLFT: CMPB POS(MEM),#5 ; is laser base at extreme left?
BLE 10$ ; yes - branch
SUBB #2,POS(MEM) ; move laser base two columns left
CALL DRWLSR ; re-draw laser base
10$: RTN ; return
;Move laser base right
MOVRHT: CMPB POS(MEM),#WIDTH-5 ; is laser base at extreme right?
BGE 10$ ; yes - branch
ADDB #2,POS(MEM) ; move laser base two columns right
CALL DRWLSR ; re-draw laser base
10$: RTN ; return
;Fire missile (from player)
;This code is run when the user presses the space bar
;If a missile is already on the screen, nothing happens
;Otherwise, a missile is created and plotted using the DRWMSL routine
;Ensuing cycles will automatically advance the missile in the MISSIL routine
FIRE: TSTB MROW(MEM) ; missile in the air?
BEQ 10$ ; no
RTN ; yes
10$: MOVB #22.,MROW(MEM) ; locate missile at column 22
MOVB POS(MEM),MCOL(MEM) ; set missile column to laser base column
CALL DRWMSL ; draw the missile
RTN ; return
;Missile Processing - called every cycle
;This routine advances a missile if there is one on the screen
;The missile will cease to exist if (1) it reaches the top of the screen,
;(2) it collides with an alien (which destroys it and increases the player's
;score, or (3) it collides with a saucer (which also destroys it and increases
;the player's score).
MISSIL: SAVE A0,D0-D3 ; save registers
TSTB MROW(MEM) ; is a player missile on the screen?
BEQ MSLRTN ; no - branch
CALL CLRMSL ; erase missile from screen
DECB MROW(MEM) ; move missile one row up
CMMB MROW(MEM),#2 ; is missile at top of screen?
BEQ MSLSAU ; yes - branch
CALL DRWMSL ; re-draw missile
CMMB MROW(MEM),XROW(MEM) ; collision with alien missile?
BNE 10$ ; no
CMMB MCOL(MEM),XCOL(MEM) ; collision with alien missile?
BNE 10$ ; no
CALL COLLID ; handle collision
BR MSLRTN ; all done
10$: LEA A0,ADATA(MEM) ; index alien data array
MOV #ROWS*COLS,D0 ; prepare to process all records
MSLCHK: CLR D2 ; clear D2
MOVB AROW(A0),D2 ; D2 := upper row
MOV D2,D3 ; copy D2 to D3
INCB D3 ; D3 := lower row
CMMB MROW(MEM),D2 ; is missile above this alien?
BLT MSLNXT ; yes - branch
CMMB MROW(MEM),D3 ; is missile below this alien?
BGT MSLNXT ; yes - branch
MOVB ACOL(A0),D2 ; D2 := alien column position (left)
MOV D2,D3 ; c
opy D2 to D3
ADDB #3,D3 ; D3 := alien column position (right)
CMMB MCOL(MEM),D2 ; is missile to left of alien?
BLT MSLNXT ; yes - branch
CMMB MCOL(MEM),D3 ; is missile to right of alien?
BGT MSLNXT ; yes - branch
CALL CLEAR ; clear alien from screen and memory
BR MSLRTN ; branch
MSLNXT: ADD #ASIZE,A0 ; advance to next alien data record
SOB D0,MSLCHK ; loop till all aliens checked
MSLRTN: REST A0,D0-D3 ; restore registers
RTN ; return
MSLSAU: CLR D2 ; clear D2
MOVB SAUCER(MEM),D2 ; D2 := saucer column (left)
BEQ 10$ ; branch if not active
MOV D2,D3 ; copy D3 to D2
ADDB #6,D3 ; D3 := saucer column (right)
TSTB MROW(MEM) ; is player missile active?
BEQ 10$ ; no - branch
CMMB MCOL(MEM),D2 ; is player missile to left of saucer?
BLT 10$ ; yes - branch
CMMB MCOL(MEM),D3 ; is player missile to right of saucer?
BGT 10$ ; yes - branch
CURSOR #2,SAUCER(MEM) ; erase saucer
TYPESP ; by print a space,
CLR D1 ; the point
MOVW SAUVAL(MEM),D1 ; value of
DCVT 4,OT$TRM!OT$ZER ; the saucer,
TYPE < > ; and another space
SLEEP #2500. ; wait 1/4 second
CURSOR #2,SAUCER(MEM) ; and then
TYPE < > ; type space to complete erase saucer
CLRB SAUCER(MEM) ; mark saucer as inactive
MOVW #1000.,SAUCNT(MEM) ; reset saucer cycle count
CLR D7 ; load
MOVW SAUVAL(MEM),D7 ; value of saucer
ADD D7,SCORE(MEM) ; and add to score
ADDW #500.,SAUVAL(MEM) ; add 500 to value of next saucer
CALL DISCOR ; re-display score
10$: CLRB MROW(MEM) ; mark player missile inactive
REST A0,D0-D3 ; restore registers
RTN ; return
;Alien Attack Routine - called once every cycle
;This routine is responsible for (1) generating alien missile attacks on the
;player every so often and (2) advancing said missile down the screen.
ATTACK: TSTB AROW(A0) ; is this alien alive?
BEQ 10$ ; no - branch
TSTB XROW(MEM) ; is an alien missile active?
JNE ATTMOV ; yes - branch
MOVB ACOL(A0),D1 ; add one to
INCB D1 ; alien column
CMPB D1,POS(MEM) ; is laser base within range of an attack?
BEQ ATTCHK ; yes - branch
INCB D1 ; add one more to alien column
CMPB D1,POS(MEM) ; is laser base withing range now?
BEQ ATTCHK ; yes - branch
10$: RTN ; return
;Player is in a position where he/she can be attacked by the current alien.
;Now scan to see if there are any aliens blocking the way
ATTCHK: LEA A1,ADATA(MEM) ; index alien data array
MOV #ROWS*COLS,D1 ; prepare to process all records
10$: CMP A0,A1 ; is this the current alien?
BEQ 20$ ; yes - no checking required
CMMB ACOL(A1),ACOL(A0) ; are aliens at the same column?
BNE 20$ ; no - branch
CMMB AROW(A1),AROW(A0) ; is check-alien below curr. alien?
BLE 20$ ; no - branch
RTN ; return
20$: ADD #ASIZE,A1 ; advance to next record
SOB D1,10$ ; loop till all aliens checked
INCB D4 ; increment attack counter
CMPB D4,ATTCNT(MEM) ; can we attack?
BLT 30$ ; no - branch
MOVB AROW(A0),XROW(MEM) ; set missile
ADDB #3,XROW(MEM) ; row
MOVB ACOL(A0),XCOL(MEM) ; and
INCB XCOL(MEM) ; column
CALL DRWATK ; draw missile
CLRB D4 ; clear attack count
30$: RTN ; return
;move attacking alien missile down screen
;to keep the missile from moving too rapidly, bit 0 of D3 is set and reset;
;only when bit 0 of D3 is one is the missile advanced
ATTMOV: BTST #0,D3 ; is bit 0 = 0?
BEQ 10$ ; yes - branch
BCLR #0,D3 ; no - set bit zero on
BR 20$ ; branch
10$: BSET #0,D3 ; set bit 0 on
RTN ; return
20$: CALL CLRATK ; clear attack missile from screen
INCB XROW(MEM) ; increment row
CMMB XROW(MEM),#22. ; at bottom of screen?
BGE ATTEND ; yes - branch
CMMB XROW(MEM),MROW(MEM) ; collision with player missile?
BNE 30$ ; no
CMMB XCOL(MEM),MCOL(MEM) ; collision with player missile?
BNE 30$ ; no
CALL COLLID ; handle collision
RTN ; return
30$: CALL DRWATK ; no - re-draw missile
RTN ; return
ATTEND: SAVE D2-D3 ; save registers
MOVB POS(MEM),D2 ; load position of laser base
MOV D2,D3 ; set D2 to left column
DECB D2 ; of laser base
INCB D3 ; set D3 to right column of laser base
CMMB XCOL(MEM),D2 ; is alien missile to left of laser base?
JLT KILMSL ; yes - branch
CMMB XCOL(MEM),D3 ; is alien missile to right of laser base?
JGT KILMSL ; yes - branch
TTYI ; ring
BYTE 7,0 ; bell
SUBB #3,POS(MEM) ; subtract 3 from position
CURSOR #23.,POS(MEM) ; re-position cursor
TYPE < *ARG* > ; print Aaargh!! message
SLEEP #2500. ; wait 1/4 second
CURSOR #23.,POS(MEM) ; re-position cursor
TYPE < ..... > ; type rubble
SLEEP #2500. ; wait 1/4 second
CURSOR #23.,POS(MEM) ; re-position cursor
TYPE < > ; wipe out laser base
SLEEP #2500. ; wait 1/4 second
TSTB LIVES(MEM) ; any lives left?
BEQ GAMOVR ; nope - game over - branch
SAVE D0 ; save D0
CLR D0 ; load D0
MOVB LIVES(MEM),D0 ; w/number of lives
DECB D0 ; subtract by one
MUL D0,#4 ; multiply by 4 to get column
INCB D0 ; and add one
CURSOR #24.,D0 ; position cursor
TYPE < > ; and type spaces
REST D0 ; restore D0
DECB LIVES(MEM) ; decrement spare live count
MOVB #41.,POS(MEM) ; re-set position to middle
CALL DRWLSR ; re-draw laser base
CLRB XROW(MEM) ; erase alien attack missile
REST D2-D3 ; restore registers
RTN ; return
;Missile collision
;erase player and alien missile from screen
COLLID: CALL CLRATK
CLRB XROW(MEM)
CALL CLRMSL
CLRB MROW(MEM)
RTN
;Game over
GAMOVR: CURSOR #1,#36.
TYPE Game Over
JMP FINISH
;mark alien missile as destroyed
KILMSL: CLRB XROW(MEM)
CLRB XCOL(MEM)
REST D2-D3
RTN
;Finish
;This routine cleans up a few things before exiting the program
;Control-C flag is cleared so display doesn't get messed up
;Cursor is turned back on
FINISH: JOBIDX A0 ; index Job Control Block
ANDW #^C<J.CCC>,JOBSTS(A0) ; clear ^C flag if set
CURSOR #23.,#1 ; address cursor
ON ; turn on cursor
CRLF ; print newline
EXIT ; exit
;Draw Missile routine
;Draws player's missile on the screen
DRWMSL: CURSOR MROW(MEM),MCOL(MEM)
TYPE !
RTN
;Clear Missile routine
;Clears player's missile off the screen
CLRMSL: CURSOR MROW(MEM),MCOL(MEM)
TYPE < >
RTN
;Draw Laser base routine
;Draws player's laser base on the screen
DRWLSR: MOVB POS(MEM),D7
SUBB #3,D7
CURSOR #23.,D7
TYPE < _A_ >
RTN
;Clear alien missile routine
;Clears alien missile from the screen
CLRATK: CURSOR XROW(MEM),XCOL(MEM)
TYPE < >
RTN
;Draw alien missile routine
;Draws alien missile on the screen
DRWATK: CURSOR XROW(MEM),XCOL(MEM)
TYPE |
RTN
;Clear saucer
CLRSAU: SAVE D0 ; save registers
MOVB SAUCER(MEM),D0
DECB D0
CURSOR #2,D0
TYPE < >
CLRB SAUCER(MEM) ; mark saucer as gone
MOVW #1000.,SAUCNT(MEM) ; set 1000 cycles till next saucer
REST D0 ; restore registers
RTN
;Draw saucer
DRWSAU: SAVE D0
MOVB SAUCER(MEM),D0
DECB D0
CURSOR #2,D0
TTYI
ASCIZ " <***> "
EVEN
REST D0
RTN
;Clear alien from display. The display space previously occupied by the
;alien is cleared to blanks and the alien's value is displayed for 1/10th
;of a second and then cleared as well. A0 is expected to point to the
;alien data record in ADATA(MEM).
CLEAR: SAVE D2-D5 ; save registers
MOVB AROW(A0),D2 ; copy alien row
MOVB ACOL(A0),D3 ; copy alien column
DECB D2 ; subtract one
DECB D3 ; from each
TTYI ; ring
BYTE 7,0 ; bell
CURSOR D2,D3 ; address cursor
TYPE < > ; print blank line
INCB D2 ; next row
CURSOR D2,D3 ; address cursor again
TYPE < > ; print blank line again
INCB D2 ; next row
CURSOR D2,D3 ; address cursor once more
MOV #4,D5 ; load D5 w/4
SUBB ATYPE(A0),D5 ; subtract alien type from D5
MUL D5,#100. ; multiply by 100 to get points
MOV D5,D1 ; copy to D1 for output
DCVT 5,OT$TRM!OT$ZER ; print number of points
TYPESP ; print a space
SLEEP #1000. ; wait 1/10 second
CURSOR D2,D3 ; next row
TYPE < > ; print more spaces (alien now gone)
ADD D5,SCORE(MEM) ; update score
CALL DISCOR ; display score
CLRB MROW(MEM) ; cancel
CLRB MCOL(MEM) ; player missile
CLRB AROW(A0) ; mark alien
CLRB ACOL(A0) ; as destroyed
DECB ACOUNT(MEM) ; decrement live alien count
REST D2-D5 ; restore registers
RTN
;Draw alien. ROW(MEM), COL(MEM), and TYPE(MEM) are expected to contain
;values for the currently selected alien. ROW(MEM) and COL(MEM) are the
;coordinates of the upper left-hand part of the alien. TYPE(MEM) determines
;the type of alien drawn.
DRAW: SAVE A0,D0-D3 ; save registers
LEA A0,PIX ; point A0 to picture data
CLR D0 ; load D0
MOVB TYPE(MEM),D0 ; with alien type
MUL D0,#24. ; multiply alien type by 2x6
ADD D0,A0 ; A0 now points to proper alien
MOVB ROW(MEM),D2 ; copy row
MOVB COL(MEM),D3 ; copy column
DECB D2 ; subtract one
DECB D3 ; from both
CURSOR D2,D3 ; address cursor
TYPE < > ; print blank line above alien
INCB D2 ; point D2 to next row
BTST #0,D3 ; is this an even number column?
BEQ 10$ ; yes - use version A of alien
ADD #12.,A0 ; no - use version B of alien
10$: CURSOR D2,D3 ; address cursor
BCALL PIXLIN ; print 1st line of alien picture
INCB D2 ; advance to
CURSOR D2,D3 ; next row
BCALL PIXLIN ; print 2nd line of alien picture
REST A0,D0-D3 ; restore registers
RTN ; return
;Display 6 characters of data @A0
PIXLIN: MOV #6.,D0 ; prepare for 6 iterations
10$: MOVB (A0)+,D1 ; get char, increment pointer
TTY ; print char in D1
SOB D0,10$ ; loop 6 times
RTN ; return
;Display score at top right hand of screen
DISCOR: CURSOR #1,#WIDTH-10. ; address cursor
MOV SCORE(MEM),D1 ; load D1 w/score
DCVT 9.,OT$TRM!OT$ZER ; print score, right justified
RTN ; return
;Alien pictures. Each alien is 2x4 characters in size, plus spaces on the
;and right. The spaces are there in case the alien has moved.
;There are two versions of each alien-- the picture changes slightly as the
;alien slides across the screen. The type of alien drawn (there are four)
;depends on ATYPE(alien).
PIX: ASCII " (oo) " ; type 0 alien
ASCII " -^^- "
ASCII " (oo) "
ASCII " _/\_ "
ASCII " v__v " ; type 1 alien
ASCII " (oo) "
ASCII " v__v "
ASCII " (..) "
ASCII " #oo# " ; type 2 alien
ASCII " <()> "
ASCII " #oo# "
ASCII " (<>) "
ASCII " o!!o " ; type 3 alien
ASCII " <==> "
ASCII " o!!o "
ASCII " >==< "
;Message displayed on introduction screen - must be terminated w/NUL byte
;(ASCIZ does this). A tilde character (~) is not displayed but instead
;causes a 1/3 second delay.
MESSAG: ASCIZ /S P A C E ~ I N V A D E R S ~ b y U L T R A S O F T ~~~~/
EVEN
END
