;I am releasing this source code on 1 condition: PLEASE DO NOT
;DISTRIBUTE MODIFIED COPIES OF THIS GAME!!!! THANKS!!!!



;                       Mutiny 85  (ZShell game)

;                      (c) Tim FitzRandolph, 1996


;Side scrolling shooter.  Blast the bad-guys until you win.

;controls:
;       UP      =       up arrow
;       DOWN    =       down arrow
;       LEFT    =       left arrow
;       RIGHT   =       right arrow
;       MISSILE =       2nd
;       MEGABOMB=       Alpha
;       QUIT    =       EXIT

;       thats all.



#INCLUDE "TI-85.H"

.org 0
.db "Mutiny85 1.3 (ZShell)",0



;---------------------------------------------------------------;
;                       V A R I A B L E S                       ;
;---------------------------------------------------------------;
;define all of the variables for use in the game

shipx           = $80DF                 ;ships x position
shipy           = $80E0                 ;ships y position

b1x             = $80E1                 ;1st bad guys x position
b1y             = $80E2                 ;1st bad guys y position

b2x             = $80E3                 ;2nd bad guys x position
b2y             = $80E4                 ;2nd bad guys y position

b3x             = $80E5                 ;you get the idea...
b3y             = $80E6

b4x             = $80E7
b4y             = $80E8



m1x             = $80E9                 ;missile positions--
m1y             = $80EA                 ;there can be 3 missiles
m2x             = $80EB                 ;on screen at once.
m2y             = $80EC
m3x             = $80ED
m3y             = $80EE

lives           = $80F2                 ;number of lives the player curently
                                        ;has...
score           = $80F3                 ;current score (fills $80F4)

shooting        = $80F5                 ;variable for tracking missiles

encounter       = $80F6                 ;decides if its time to deploy
                                        ;the enemies

dispscore       = $80F8                 ;memory for displaying score


en1a            = $8100                 ;enemy 1: alive=1 dead=2
en2a            = $8101                 ;enemy 2: alive=1 dead=2
en3a            = $8102                 ;notice a pattern?
en4a            = $8103
en5a            = $8104

m1s             = $8105                 ;missile alive?
m2s             = $8106                 ;this one?
m3s             = $8107                 ;and this one?

numbermega      = $8108                 ;number of MEGAMISSILES!!!


CONT            = $810A                 ;contrast for MEGAMISSILE


count1          = $810C                 ;counters for enemy positions
count2          = $810E
count3          = $8111
count4          = $8113
count5          = $8115

gameloops       = $8117                 ;counter for enemy deployment


b5x             = $8119
b5y             = $811A

high            = $811C         ;high score

disphigh        = $811E         ;for displaying high score

temporary       = $8201

star1x          = $8203         ;x position of first set of stars
star2x          = $8204         ;x position of second set of stars

counter         = $8206         ;counter for starfield

;---------------------------------------------------------------;
;                           I N I T                             ;
;---------------------------------------------------------------;
;set up the games variables initial values, and other stuff

Init:


        ld a,(ZS_BITS)          ;set Zshell to re-checksum
        set 0,a

        ld a,3                  ;start out with 3 lives
        ld (lives),a

        ld a,0                  ;set this stuff to 0
        ld (encounter),a
        ld (shooting),a
        ld (en1a),a
        ld (en2a),a
        ld (en3a),a
        ld (en4a),a
        ld (en5a),a
        ld (m1s),a
        ld (m2s),a
        ld (m3s),a
        ld (count1),a
        ld (count2),a
        ld (count3),a
        ld (count4),a
        ld (count5),a

        ld a,2
        ld (numbermega),a


        ld a,4                  ;set the 85 to graphics mode
        out (5),a

        ld a,127
        ld (b1x),a
        ld (b2x),a
        ld (b3x),a
        ld (b4x),a
        ld (b5x),a

        ld hl,$0000
        ld (score),hl

        ld a,64
        ld (b3y),a

        ld a,20
        ld (b5y),a

        ld a,2                  ;set stars x positions to 2
        ld (star1x),a
        ld (star2x),a

        ROM_CALL(CLEARLCD)      ;clear the screen



;---------------------------------------------------------------;
;                  T I T L E     S C R E E N                    ;
;---------------------------------------------------------------;
;show the neat title screen, and well, thats all.

TitleScreen:
        set 3,(IY+05)           ;set text to White on Black

        ld hl, $0001            ;x=0,y=1
        ld ($800C),hl
        ld hl, (PROGRAM_ADDR)
        ld de, Title2           ;show title1 text
        add hl,de
        ROM_CALL(D_ZT_STR)
        
        ld hl, $0002            ;x=0,y=1
        ld ($800C),hl
        ld hl, (PROGRAM_ADDR)
        ld de, Title1           ;show title1 text
        add hl,de
        ROM_CALL(D_ZT_STR)

        ld hl, $0003            ;x=0,y=1
        ld ($800C),hl
        ld hl, (PROGRAM_ADDR)
        ld de, Title3           ;show title1 text
        add hl,de
        ROM_CALL(D_ZT_STR)

        res 3,(IY+05)           ;set text back to Black on White
       

     ;--NOW DRAW THE REST OF THE TEXT (MENU STYLE)--;

        ld hl,$2B25                     ;display "by: Tim FitzRandolph"
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,AuthorStr
        add hl,de
        ROM_CALL(D_ZM_STR)

        ld hl,$3A4F                     ;display "press [ENTER]"
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,PressEnterStr
        add hl,de
        ROM_CALL(D_ZM_STR)



        ld a,1
        ld (shipx),a
        ld a,23
        ld (shipy),a

TitleWait:                              ;wait for pressing of the Enter Key
        CALL_(AnimateShip)
        call GET_KEY
        cp $9                           ;is ENTER pressed?
        JUMP_Z(GameInit)                ;yep, so goto the GAME
        cp $37                          ;is EXIT pressed?
        ret z                           ;yes, so QUIT
        JUMP_(TitleWait)                ;enter not pressed, so try again.


AnimateShip:                    ;animate the ship acros the screen :)
        CALL_(EraseShip)
        ld a,(shipx)
        inc a
        inc a
        ld (shipx),a
        CALL_(DrawShip)
        CALL_(Delay)
        ret


        
;---------------------------------------------------------------;
;                      G A M E    I N I T                       ;
;---------------------------------------------------------------;
;initialize some more variables and clear the screen.

GameInit:
                CALL_(en1done)
                CALL_(en2done)
                CALL_(en3done)
                CALL_(en4done)
                CALL_(en5done)

                ld a,15                 ;reset the ships position.
                ld (shipx),a
                ld a,35
                ld (shipy),a

                ROM_CALL(CLEARLCD)      ;clear the screen

                CALL_(DrawBottomBars)   ;draw bars on bottom of screen
                                        ;for the score and stuff

                JUMP_(GameLoop)


DrawBottomBars:
        ld b,1
        ld c,8
barloop1:
        CALL_(PlotPixel)
        inc B
        ld a,b
        cp 128
        JUMP_Z(bar2)

        JUMP_(barloop1)

bar2:
        ld b,1
        ld c,9
barloop2:
        CALL_(PlotPixel)
        inc B
        ld a,b
        cp 128
        ret z

        JUMP_(barloop2)


;---------------------------------------------------------------;
;                      G A M E    L O O P                       ;
;---------------------------------------------------------------;
;oh boy.  the actual game loop.  whooh-hoo!

GameLoop:
        CALL_(EraseShip)                ;Erase the Ship

        CALL_(KeyTest)                  ;Check for keypresses
        JUMP_(CheckQuit)
afterquit:

        JUMP_(deathcheck)               ;player dead?
afterdeath:
        CALL_(DrawShip)                 ;Draw the Ship
        CALL_(Enemies)                  ;handle those enemies!
        CALL_(Missiles)                 ;mess with the missiles!
        CALL_(DrawInfo)                 ;draw the score, # of megabombs.
        CALL_(EraseStars)               ;erase starfield
        CALL_(MoveStars)                ;move starfield
        CALL_(DrawStars)                ;draw starfield

        JUMP_(GameLoop)                 ;loop back to the top





;--------------------------------------------------------------
DrawInfo:
        CALL_(DrawScore)
        CALL_(DrawMEGA)
        ret

DrawScore:
        ld hl,$3805
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,ScoreStr
        add hl,de
        ROM_CALL(D_ZM_STR)

        ld hl, (score)
        ld de, dispscore+4
	ld b, 5
SCORELOOP:
	call UNPACK_HL
	add a, '0'                      
	ld (de), a                      
	dec de
	djnz SCORELOOP
	
        ld hl, $3823
	ld ($8333), hl
        ld hl, dispscore
	ld b, 5
	ROM_CALL(D_LM_STR)
	ret



DrawMEGA:
        ld hl,$3841
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,MEGAStr
        add hl,de
        ROM_CALL(D_ZM_STR)


        ld hl,$3872
        ld ($8333),hl
        ld a,(numbermega)
        add a,'0'
        ROM_CALL(M_CHARPUT)
        ret
;---------------------------------------------------------------;
;                        K E Y   T E S T                        ;
;---------------------------------------------------------------;
;Check to see if the player actually wants to interact with
;the game!!

KeyTest:
        ld a,0
        out (1),a
        in a,(1)
        bit 3,a
        push af
        CALL_Z(moveup)
        pop af
        bit 0,a
        push af
        CALL_Z(movedown)
        pop af
        bit 1,a
        push af
        CALL_Z(moveleft)
        pop af
        bit 2,a
        push af
        CALL_Z(moveright)
        pop af
        bit 7,a
        push af
        CALL_Z(MEGABOMB)
        pop af
        bit 4,a
        push af
        CALL_Z(PauseLoop)
        pop af
        bit 5,a
        push af
        JUMP_Z(FireMissile)
        
aftermissile:
        pop af
        ret                               


PauseLoop:
        ld hl,$FC00
        ld de,GRAPH_MEM
        ld bc,1024
        ldir
PauseLoop2:
        call GET_KEY
        cp $37
        ret z

        JUMP_(PauseLoop2)

moveup:
        ld a,(shipy)
        inc a
        inc a
        cp 59
        CALL_Z(uptomuch)
        cp 60
        CALL_Z(uptomuch)
        ld (shipy),a
        ret

movedown:
        ld a,(shipy)
        dec a
        dec a
        cp 9
        CALL_Z(downtomuch)
        cp 8
        CALL_Z(downtomuch)
        ld (shipy),a
        ret

uptomuch:
        ld a,58
        ret

downtomuch:
        ld a,10
        ret



moveleft:
        ld a,(shipx)
        dec a
        dec a
        cp 1
        CALL_Z(lefttomuch)
        cp 2
        CALL_Z(lefttomuch)
        ld (shipx),a
        ret

moveright:
        ld a,(shipx)
        inc a
        inc a
        cp 62
        CALL_Z(righttomuch)
        cp 63
        CALL_Z(righttomuch)
        ld (shipx),a
        ret

lefttomuch:
        ld a,3
        ret

righttomuch:
        ld a,61
        ret



MEGABOMB:

        CALL_(DrawShip)

        ld a,(numbermega)               ;any MEGABOMBS left?
        cp 0                            ;no???
        ret z                           ;too bad!

        ld a,(CONTRAST)
        ld (CONT),a                     ;save current contrast

        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark
        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark
        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark
        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark
        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark
        ld a,$1D
        out (2),a
        CALL_(longDelay)                ;flash light
        ld a,$01
        out (2),a
        CALL_(longDelay)                ;flash dark

        ld a,(CONT)
        out (2),a                       ;reset contrast

        ld a,(numbermega)
        dec a
        ld (numbermega),a

        CALL_(en1done)
        CALL_(en2done)
        CALL_(en3done)
        CALL_(en4done)
        CALL_(en5done)

        ld hl,(score)
        ld de,500
        add hl,de
        ld (score),hl

        CALL_(EraseShip)

        ret


FireMissile:
        ld a,(m1s)
        cp 0                    ;missile 1 on?
        JUMP_Z(deploym1)                ;deploy missile 1!
        ld a,(m2s)
        cp 0                    ;missile 2 on?
        JUMP_Z(deploym2)                ;deploy missile 2!
        ld a,(m3s)
        cp 0                    ;missile 3 on?
        JUMP_Z(deploym3)                ;deploy missile 3!

        JUMP_(aftermissile)     ;all missiles on screen, so do NOTHING!


deploym1:                       ;deploy missile 1
        ld a,1
        ld (m1s),a              ;announce missile is alive

        ld a,(shipx)
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        ld (m1x),a              ;set x position of missile

        ld a,(shipy)
        inc a
        inc a
        inc a
        ld (m1y),a              ;set y position of missile


        JUMP_(aftermissile)


deploym2:                       ;deploy missile 2
        ld a,1
        ld (m2s),a              ;announce missile is alive

        ld a,(shipx)
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        ld (m2x),a              ;set x position of missile

        ld a,(shipy)
        inc a
        inc a
        inc a
        ld (m2y),a              ;set y position of missile


        JUMP_(aftermissile)


deploym3:                       ;deploy missile 3
        ld a,1
        ld (m3s),a              ;announce missile is alive

        ld a,(shipx)
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        inc a
        ld (m3x),a              ;set x position of missile

        ld a,(shipy)
        inc a
        inc a
        inc a
        ld (m3y),a              ;set y position of missile


        JUMP_(aftermissile)



CheckQuit:
        call GET_KEY
        cp $37
        JUMP_Z(endofgame)

        JUMP_(afterquit)





;---------------------------------------------------------------;
;                        M I S S I L E S                        ;
;---------------------------------------------------------------;
;do we need to animate the missiles? lets see!

Missiles:               

        ld a,(m1s)              ;load missile 1's state
        cp 1                    ;alive?
        CALL_Z(handle1)         ;okay, do missile 1.
        CALL_Z(handle1)         ;okay, do missile 1.
        CALL_Z(handle1)         ;okay, do missile 1.

        ld a,(m2s)
        cp 1                    ;missile 2 alive?
        CALL_Z(handle2)
        CALL_Z(handle2)
        CALL_Z(handle2)

        ld a,(m3s)
        cp 1                    ;what about missile 3?
        CALL_Z(handle3)
        CALL_Z(handle3)
        CALL_Z(handle3)

        ret                     ;done!


handle1:

        ld a,(m1s)
        cp 1
        ret nz

        CALL_(EraseMissile1)     ;erase it.
        ld a,(m1x)
        inc a
        inc a
        cp 127
        JUMP_Z(killms1)         ;missile is done.
        cp 128
        JUMP_Z(killms1)         ;missile is done.

        ld (m1x),a              ;it has been moved...

        CALL_(checkms1)

        CALL_(DrawMissile1)      ;draw it.
        ret                     ;done.


handle2:

        ld a,(m2s)
        cp 1
        ret nz

        CALL_(EraseMissile2)     ;erase it.
        ld a,(m2x)
        inc a
        inc a
        cp 127
        JUMP_Z(killms2)         ;missile is done.
        cp 128
        JUMP_Z(killms2)         ;missile is done.

        ld (m2x),a              ;it has been moved...

        CALL_(checkms2)

        CALL_(DrawMissile2)      ;draw it.

        ret                     ;done.

handle3:

        ld a,(m3s)
        cp 1
        ret nz

        CALL_(EraseMissile3)     ;erase it.
        ld a,(m3x)
        inc a
        inc a
        cp 127
        JUMP_Z(killms3)         ;missile is done.
        cp 128
        JUMP_Z(killms3)         ;missile is done.

        ld (m3x),a              ;it has been moved...

        CALL_(checkms3)

        CALL_(DrawMissile3)      ;draw it.

        ret                     ;done.


killms1:
        CALL_(EraseMissile1)
        ld a,0
        ld (m1s),a              ;missile dead.


        ret                     ;done.

killms2:
        CALL_(EraseMissile2)
        ld a,0
        ld (m2s),a              ;missile dead.


        ret                     ;done.

killms3:
        CALL_(EraseMissile3)
        ld a,0
        ld (m3s),a              ;missile dead.


        ret                     ;done.



checkms1:
        ld a,(m1x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b1x)
        cp B
        CALL_Z(en1hit)
        inc a
        cp B
        CALL_Z(en1hit)

        ld a,(m1x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b2x)
        cp B
        CALL_Z(en2hit)
        inc a
        cp B
        CALL_Z(en2hit)

        ld a,(m1x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b3x)
        cp B
        CALL_Z(en3hit)
        inc a
        cp B
        CALL_Z(en3hit)


        ld a,(m1x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b4x)
        cp B
        CALL_Z(en4hit)
        inc a
        cp B
        CALL_Z(en4hit)

        ld a,(m1x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b5x)
        cp B
        CALL_Z(en5hit)
        inc a
        cp B
        CALL_Z(en5hit)

        ret

checkms2:
        ld a,(m2x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b1x)
        cp B
        CALL_Z(en1hit)
        inc a
        cp B
        CALL_Z(en1hit)


        ld a,(m2x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b2x)
        cp B
        CALL_Z(en2hit)
        inc a
        cp B
        CALL_Z(en2hit)

        ld a,(m2x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b3x)
        cp B
        CALL_Z(en3hit)
        inc a
        cp B
        CALL_Z(en3hit)

        ld a,(m2x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b4x)
        cp B
        CALL_Z(en4hit)
        inc a
        cp B
        CALL_Z(en4hit)

        ld a,(m2x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b5x)
        cp B
        CALL_Z(en5hit)
        inc a
        cp B
        CALL_Z(en5hit)


        ret

checkms3:
        ld a,(m3x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b1x)
        cp B
        CALL_Z(en1hit)
        inc a
        cp B
        CALL_Z(en1hit)


        ld a,(m3x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b2x)
        cp B
        CALL_Z(en2hit)
        inc a
        cp B
        CALL_Z(en2hit)


        ld a,(m3x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b3x)
        cp B
        CALL_Z(en3hit)
        inc a
        cp B
        CALL_Z(en3hit)

        ld a,(m3x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b4x)
        cp B
        CALL_Z(en4hit)
        inc a
        cp B
        CALL_Z(en4hit)

        ld a,(m3x)
        inc a
        inc a
        inc a
        ld b,a

        ld a,(b5x)
        cp B
        CALL_Z(en5hit)
        inc a
        cp B
        CALL_Z(en5hit)

        ret

en1hit:
        ld a,(m1y)
        ld b,a
        ld a,(b1y)
        cp B
        JUMP_Z(killenemy11)
        dec a
        cp B
        JUMP_Z(killenemy11)
        dec a
        cp B
        JUMP_Z(killenemy11)

        ld a,(m2y)
        ld b,a
        ld a,(b1y)
        cp B
        JUMP_Z(killenemy12)
        dec a
        cp B
        JUMP_Z(killenemy12)
        dec a
        cp B
        JUMP_Z(killenemy12)

        ld a,(m3y)
        ld b,a
        ld a,(b1y)
        cp B
        JUMP_Z(killenemy13)
        dec a
        cp B
        JUMP_Z(killenemy13)
        dec a
        cp B
        JUMP_Z(killenemy13)

afterenemy1:

        ret


killenemy11:
        CALL_(killms1)
        CALL_(en1done)

        ld hl,(score)
        ld de,100
        add hl,de
        ld (score),hl

        JUMP_(afterenemy1)

killenemy12:
        CALL_(killms2)
        CALL_(en1done)

        ld hl,(score)
        ld de,100
        add hl,de
        ld (score),hl

        JUMP_(afterenemy1)

killenemy13:
        CALL_(killms3)
        CALL_(en1done)

        ld hl,(score)
        ld de,100
        add hl,de
        ld (score),hl

        JUMP_(afterenemy1)

en2hit:
        ld a,(m1y)
        ld b,a
        ld a,(b2y)
        cp B
        JUMP_Z(killenemy21)
        dec a
        cp B
        JUMP_Z(killenemy21)
        dec a
        cp B
        JUMP_Z(killenemy21)

        ld a,(m2y)
        ld b,a
        ld a,(b2y)
        cp B
        JUMP_Z(killenemy22)
        dec a
        cp B
        JUMP_Z(killenemy22)
        dec a
        cp B
        JUMP_Z(killenemy22)

        ld a,(m3y)
        ld b,a
        ld a,(b2y)
        cp B
        JUMP_Z(killenemy23)
        dec a
        cp B
        JUMP_Z(killenemy23)
        dec a
        cp B
        JUMP_Z(killenemy23)

afterenemy2:

        ret


killenemy21:
        CALL_(killms1)
        CALL_(en2done)

        ld hl,(score)
        ld de,125
        add hl,de
        ld (score),hl

        JUMP_(afterenemy2)

killenemy22:
        CALL_(killms2)
        CALL_(en2done)

        ld hl,(score)
        ld de,125
        add hl,de
        ld (score),hl

        JUMP_(afterenemy2)

killenemy23:
        CALL_(killms3)
        CALL_(en2done)

        ld hl,(score)
        ld de,125
        add hl,de
        ld (score),hl

        JUMP_(afterenemy2)


en3hit:
        ld a,(m1y)
        ld b,a
        ld a,(b3y)
        cp B
        JUMP_Z(killenemy31)
        dec a
        cp B
        JUMP_Z(killenemy31)
        dec a
        cp B
        JUMP_Z(killenemy31)

        ld a,(m2y)
        ld b,a
        ld a,(b3y)
        cp B
        JUMP_Z(killenemy32)
        dec a
        cp B
        JUMP_Z(killenemy32)
        dec a
        cp B
        JUMP_Z(killenemy32)

        ld a,(m3y)
        ld b,a
        ld a,(b3y)
        cp B
        JUMP_Z(killenemy33)
        dec a
        cp B
        JUMP_Z(killenemy33)
        dec a
        cp B
        JUMP_Z(killenemy33)

afterenemy3:

        ret


killenemy31:
        CALL_(killms1)
        CALL_(en3done)

        ld hl,(score)
        ld de,150
        add hl,de
        ld (score),hl

        JUMP_(afterenemy3)

killenemy32:
        CALL_(killms2)
        CALL_(en3done)

        ld hl,(score)
        ld de,150
        add hl,de
        ld (score),hl

        JUMP_(afterenemy3)


killenemy33:
        CALL_(killms3)
        CALL_(en3done)

        ld hl,(score)
        ld de,150
        add hl,de
        ld (score),hl

        JUMP_(afterenemy3)


en4hit:
        ld a,(m1y)
        ld b,a
        ld a,(b4y)
        cp B
        JUMP_Z(killenemy41)
        dec a
        cp B
        JUMP_Z(killenemy41)
        dec a
        cp B
        JUMP_Z(killenemy41)

        ld a,(m2y)
        ld b,a
        ld a,(b4y)
        cp B
        JUMP_Z(killenemy42)
        dec a
        cp B
        JUMP_Z(killenemy42)
        dec a
        cp B
        JUMP_Z(killenemy42)

        ld a,(m3y)
        ld b,a
        ld a,(b4y)
        cp B
        JUMP_Z(killenemy43)
        dec a
        cp B
        JUMP_Z(killenemy43)
        dec a
        cp B
        JUMP_Z(killenemy43)

afterenemy4:

        ret


killenemy41:
        CALL_(killms1)
        CALL_(en4done)

        ld hl,(score)
        ld de,225
        add hl,de
        ld (score),hl

        JUMP_(afterenemy4)

killenemy42:
        CALL_(killms2)
        CALL_(en4done)

        ld hl,(score)
        ld de,2255
        add hl,de
        ld (score),hl

        JUMP_(afterenemy4)

killenemy43:
        CALL_(killms3)
        CALL_(en4done)

        ld hl,(score)
        ld de,225
        add hl,de
        ld (score),hl

        JUMP_(afterenemy4)


en5hit:
        ld a,(m1y)
        ld b,a
        ld a,(b5y)
        cp B
        JUMP_Z(killenemy51)
        inc a
        cp B
        JUMP_Z(killenemy51)
        inc a
        cp B
        JUMP_Z(killenemy51)
        inc a
        cp B
        JUMP_Z(killenemy51)
        inc a
        cp B
        JUMP_Z(killenemy51)

        ld a,(m2y)
        ld b,a
        ld a,(b5y)
        cp B
        JUMP_Z(killenemy52)
        inc a
        cp B
        JUMP_Z(killenemy52)
        inc a
        cp B
        JUMP_Z(killenemy52)
        inc a
        cp B
        JUMP_Z(killenemy52)
        inc a
        cp B
        JUMP_Z(killenemy52)

        ld a,(m3y)
        ld b,a
        ld a,(b5y)
        cp B
        JUMP_Z(killenemy53)
        inc a
        cp B
        JUMP_Z(killenemy53)
        inc a
        cp B
        JUMP_Z(killenemy53)
        inc a
        cp B
        JUMP_Z(killenemy53)
        inc a
        cp B
        JUMP_Z(killenemy53)

afterenemy5:

        ret


killenemy51:
        CALL_(killms1)
        CALL_(en5done)

        ld hl,(score)
        ld de,104
        add hl,de
        ld (score),hl

        JUMP_(afterenemy5)

killenemy52:
        CALL_(killms2)
        CALL_(en5done)

        ld hl,(score)
        ld de,104
        add hl,de
        ld (score),hl

        JUMP_(afterenemy5)

killenemy53:
        CALL_(killms3)
        CALL_(en5done)

        ld hl,(score)
        ld de,104
        add hl,de
        ld (score),hl

        JUMP_(afterenemy5)




deathcheck:
        ld a,(shipx)
        dec a
        ld b,a
        ld a,(shipy)
        ld c,a
        CALL_(GetPixel)
        or 0
        JUMP_NZ(died)

        inc C
        inc C
        CALL_(GetPixel)
        or 0
        JUMP_NZ(died)

        inc C
        inc C
        inc C
        dec B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(died)

        inc B
        inc B
        inc B
        inc B
        inc B
        inc B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(died)
        dec C
        dec C
        dec C
        inc B
        inc B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(died)

        JUMP_(afterdeath)


died:

        ld a,(shipx)
        dec a
        dec a
        ld b,a
        ld a,(shipy)
        ld c,a
        CALL_(GetPixel)
        or 0
        JUMP_NZ(reallydied)

        inc C
        inc C
        CALL_(GetPixel)
        or 0
        JUMP_NZ(reallydied)

        inc C
        inc C
        inc C
        dec B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(reallydied)

        inc B
        inc B
        inc B
        inc B
        inc B
        inc B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(reallydied)
        dec C
        dec C
        dec C
        inc B
        inc B
        CALL_(GetPixel)
        or 0
        JUMP_NZ(reallydied)

        JUMP_(afterdeath)

reallydied:
        ld a,(lives)
        dec a
        cp 0
        JUMP_Z(endofgame)
        ld (lives),a

        ROM_CALL(CLEARLCD)
        ld hl,$1815
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,LivesStr
        add hl,de
        ROM_CALL(D_ZM_STR)

        ld hl,$1862
        ld ($8333),hl
        ld a,(lives)
        add a,'0'
        ROM_CALL(M_CHARPUT)

diedwait:
        call GET_KEY
        cp $9
        JUMP_Z(goback)
        cp $36
        JUMP_Z(goback)

        JUMP_(diedwait)

goback:
        ROM_CALL(CLEARLCD)
        JUMP_(GameInit)

;---DRAW A MISSILE--;
DrawMissile1:
        ld a,(m1x)
        ld b,a
        ld a,(m1y)
        ld c,a
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        ret

DrawMissile2:
        ld a,(m2x)
        ld b,a
        ld a,(m2y)
        ld c,a
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        ret


DrawMissile3:
        ld a,(m3x)
        ld b,a
        ld a,(m3y)
        ld c,a
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        ret


;----ERASE A MISSILE---;
EraseMissile1:
        ld a,(m1x)
        ld b,a
        ld a,(m1y)
        ld c,a
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        ret


EraseMissile2:
        ld a,(m2x)
        ld b,a
        ld a,(m2y)
        ld c,a
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        ret

EraseMissile3:
        ld a,(m3x)
        ld b,a
        ld a,(m3y)
        ld c,a
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        ret


;----DRAW THE SHIP----;
DrawShip:
        ld a,(shipx)
        ld b,a
        ld a,(shipy)
        ld c,a

        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec B
        dec B
        dec B
        inc C
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc C
        dec B
        dec B
        dec B
        dec B
        dec B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec B
        dec B
        dec B
        inc C
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        dec B
        dec B
        dec B
        dec B
        dec B
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        ret




;----ERASE THE SHIP----;
EraseShip:
        ld a,(shipx)
        ld b,a
        ld a,(shipy)
        ld c,a

        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec B
        dec B
        dec B
        inc C
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc C
        dec B
        dec B
        dec B
        dec B
        dec B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec B
        dec B
        dec B
        inc C
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        dec B
        dec B
        dec B
        dec B
        dec B
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        ret




Delay:
        push af
        push bc
        ld a,$10
        ld b,$10
        
delayloop:
        dec a
        jr nz,delayloop
        dec b
        jr nz,delayloop
        pop af
        pop bc
        ret


longDelay:
        push af
        push bc
        ld a,$AA
        ld b,$AA
ldelayloop:
        dec a
        jr nz,ldelayloop
        dec b
        jr nz,ldelayloop
        pop af
        pop bc
        ret


Enemies:                        ;handle the enemies

        ld a,(gameloops)                ;increment the game loops
        inc a
        cp 1000                         ;once couter=1000, resets to 1
        CALL_Z(resetloops)
        ld (gameloops),a

  ;////////check for enemies already alive////////
        ld a,(en1a)                     ;is enemy1 alive? 
        cp 1
        CALL_Z(doenemy1)                ;ANIMATE HIM!

        ld a,(en2a)                     ;enemy 2 alive?
        cp 1
        CALL_Z(doenemy2)                ;ANIMATE HIM!      

        ld a,(en3a)                     ;3 alive?
        cp 1
        CALL_Z(doenemy3)                ;animate!

        ld a,(en4a)                     ;4 alive?
        cp 1
        CALL_Z(doenemy4)                ;good!

        ld a,(en5a)                     ;5 alive?
        cp 1
        CALL_Z(doenemy5)               ;yay!
  ;///////see if its time to deploy the enemies///////
        ld a,(gameloops)
        cp 100                          ;counter at 100?
        CALL_Z(doenemy1)                ;deploy ENEMY1!
        cp 200                          ;conter at 200?
        CALL_Z(doenemy1)                ;deploy ENEMY1!
        cp 300
        CALL_Z(doenemy1)
        cp 400
        CALL_Z(doenemy1)
        cp 500
        CALL_Z(doenemy1)
        cp 600
        CALL_Z(doenemy1)
        cp 700
        CALL_Z(doenemy1)
        cp 800
        CALL_Z(doenemy1)
        cp 900
        CALL_Z(doenemy1)


        cp 125
        CALL_Z(doenemy2)
        cp  250
        CALL_Z(doenemy2)
        cp 375
        CALL_Z(doenemy2)
        cp 500
        CALL_Z(doenemy2)
        cp 625
        CALL_Z(doenemy2)
        cp 750
        CALL_Z(doenemy2)
        cp 875
        CALL_Z(doenemy2)

        cp 235
        CALL_Z(doenemy3)
        cp 450
        CALL_Z(doenemy3)
        cp 756
        CALL_Z(doenemy3)


        cp 260
        CALL_Z(doenemy4)

        cp 2
        CALL_Z(doenemy5)
  ;//////////the enemies are done!!!////////////
          ret

resetloops:

        ld a,0
        
        ret



doenemy1:
        ld a,1
        ld (en1a),a

        ld a,(count1)
        cp 128                   ;done animating?
        JUMP_Z(en1done)         ;yep.
        

      ;//GET CURRENT EMENY POSITION//;

        ld hl,Enemy1Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count1)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b1y),a             ;load into variable


    ;//ERASE ENEMY//;

        CALL_(EraseE1)

    ;;//MOVE ENEMY//;;

        ld a,(count1)
        inc a
        ld (count1),a


        ld a,(b1x)
        dec a
        ld (b1x),a


        ld hl,Enemy1Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count1)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b1y),a             ;load into variable

   ;;//DRAW ENEMY//;;

        CALL_(DrawE1)

   ;done.
        ret




doenemy2:
        ld a,1
        ld (en2a),a

        ld a,(count2)
        cp 128                   ;done animating?
        JUMP_Z(en2done)         ;yep.
        

      ;//GET CURRENT EMENY POSITION//;

        ld hl,Enemy2Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count2)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b2y),a             ;load into variable


    ;//ERASE ENEMY//;

        CALL_(EraseE2)

    ;;//MOVE ENEMY//;;

        ld a,(count2)
        inc a
        ld (count2),a


        ld a,(b2x)
        dec a
        ld (b2x),a


        ld hl,Enemy2Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count2)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b2y),a             ;load into variable

   ;;//DRAW ENEMY//;;

        CALL_(DrawE2)

   ;done.
        ret



doenemy3:
        ld a,1
        ld (en3a),a

        ld a,(b3x)
        cp 1                   ;done animating?
        JUMP_Z(en3done)         ;yep.
        cp 2
        JUMP_Z(en3done)
        cp 3
        JUMP_Z(en3done)

      ;//GET CURRENT EMENY POSITION//;
         
        CALL_(EraseE3)

    ;;//MOVE ENEMY//;;


        ld a,(b3y)
        dec a
        ld (b3y),a

        ld a,(b3x)
        dec a
        dec a
        dec a
        ld (b3x),a
         

   ;;//DRAW ENEMY//;;

        CALL_(DrawE3)

   ;done.
        ret




doenemy4:
        ld a,1
        ld (en4a),a

        ld a,(count4)
        cp 70                   ;done animating?
        JUMP_Z(en4done)         ;yep.
        

      ;//GET CURRENT EMENY POSITION//;

        ld hl,Enemy4X-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count4)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b4x),a             ;load into variable


        ld hl,Enemy4Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count4)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b4y),a             ;load into variable


    ;//ERASE ENEMY//;

        CALL_(EraseE4)

    ;;//MOVE ENEMY//;;

        ld a,(count4)
        inc a
        ld (count4),a


        ld hl,Enemy4X-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count4)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b4x),a             ;load into variable


        ld hl,Enemy4Y-1       ;storage - 1
        ld de,(PROGRAM_ADDR)
        add hl,de               ;now have location of data
        ld a,(count4)
        ld e,a                  ;load in offset
        ld d,0
        add hl,de               ;new location

        ld a,(HL)               ;load into a
        ld (b4y),a             ;load into variable

   ;;//DRAW ENEMY//;;

        CALL_(DrawE4)

   ;done.
        ret


doenemy5:
        ld a,1
        ld (en5a),a


        ld a,(b5x)
        cp 1
        JUMP_Z(en5done)

        CALL_(EraseE5)

        ld a,(b5x)
        dec a
        ld (b5x),a

        CALL_(DrawE5)

        ret





en1done:                ;kill enemy 1!

        CALL_(EraseE1)
        ld a,0
        ld (en1a),a
        ld (count1),a

        ld a,128
        ld (b1x),a

        ret

en2done:                ;kill enemy 1!

        CALL_(EraseE2)
        ld a,0
        ld (en2a),a
        ld (count2),a

        ld a,128
        ld (b2x),a

        ret


        
en3done:                ;kill enemy 1!

        CALL_(EraseE3)
        ld a,0
        ld (en3a),a
        ld (count3),a

        ld a,128
        ld (b3x),a

        ld a,64
        ld (b3y),a
        ret

en4done:                ;kill enemy 1!

        CALL_(EraseE4)
        ld a,0
        ld (en4a),a
        ld (count4),a


        ret

en5done:

        CALL_(EraseE5)
        ld a,0
        ld (en5a),a

        ld a,128
        ld (b5x),a

        ret

DrawE1:
        ld a,(b1x)
        ld b,a
        ld a,(b1y)
        ld c,a

        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec b
        inc c
        CALL_(PlotPixel)
        inc b
        CALL_(PlotPixel)
        inc b
        inc b
        inc b
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc C
        dec B
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        ret


EraseE1:
        ld a,(b1x)
        ld b,a
        ld a,(b1y)
        ld c,a

        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec b
        inc c
        CALL_(ErasePixel)
        inc b
        CALL_(ErasePixel)
        inc b
        inc b
        inc b
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc C
        dec B
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        ret


DrawE2:
        ld a,(b2x)
        ld b,a
        ld a,(b2y)
        ld c,a
        CALL_(PlotPixel)
        inc B
        dec C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc c
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        dec C
        CALL_(PlotPixel)
        inc B
        inc B
        inc B
        CALL_(PlotPixel)
        inc B
        dec C
        CALL_(PlotPixel)
        inc B
        inc C
        CALL_(PlotPixel)
        inc B
        inc C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        dec B
        CALL_(PlotPixel)
        ret


EraseE2:
        ld a,(b2x)
        ld b,a
        ld a,(b2y)
        ld c,a
        CALL_(ErasePixel)
        inc B
        dec C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc c
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        dec C
        CALL_(ErasePixel)
        inc B
        inc B
        inc B
        CALL_(ErasePixel)
        inc B
        dec C
        CALL_(ErasePixel)
        inc B
        inc C
        CALL_(ErasePixel)
        inc B
        inc C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        dec B
        CALL_(ErasePixel)
        ret


DrawE3:
        ld a,(b3x)
        ld b,a
        ld a,(b3y)
        ld c,a
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        dec C
        inc B
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        dec C
        inc B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        dec B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc B
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        ret



EraseE3:
        ld a,(b3x)
        ld b,a
        ld a,(b3y)
        ld c,a
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        dec C
        inc B
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        dec C
        inc B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        dec B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc B
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        ret


DrawE4:
        ld a,(b4x)
        ld b,a
        ld a,(b4y)
        ld c,a
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        dec B
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec C
        dec C
        inc B
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        dec C
        dec C
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        inc B
        dec C
        dec C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        ret


EraseE4:
        ld a,(b4x)
        ld b,a
        ld a,(b4y)
        ld c,a
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        dec B
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec C
        dec C
        inc B
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        dec C
        dec C
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        inc B
        dec C
        dec C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        ret


DrawE5:
        ld a,(b5x)
        ld b,a
        ld a,(b5y)
        ld c,a
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        inc C
        inc C
        CALL_(PlotPixel)
        inc C
        inc B
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        CALL_(PlotPixel)
        inc C
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec B
        CALL_(PlotPixel)
        dec C
        dec B
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        CALL_(PlotPixel)
        dec C
        inc B
        CALL_(PlotPixel)
        inc C
        inc C
        inc C
        CALL_(PlotPixel)
        inc B
        inc B
        inc B
        CALL_(PlotPixel)
        dec B
        dec C
        CALL_(PlotPixel)
        ret


EraseE5:
        ld a,(b5x)
        ld b,a
        ld a,(b5y)
        ld c,a
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        inc C
        inc C
        CALL_(ErasePixel)
        inc C
        inc B
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        CALL_(ErasePixel)
        inc C
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec B
        CALL_(ErasePixel)
        dec C
        dec B
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        CALL_(ErasePixel)
        dec C
        inc B
        CALL_(ErasePixel)
        inc C
        inc C
        inc C
        CALL_(ErasePixel)
        inc B
        inc B
        inc B
        CALL_(ErasePixel)
        dec B
        dec C
        CALL_(ErasePixel)
        ret


;---------------------------------------------------------------;
;                       MOVE THE STARS!!                        ;
;---------------------------------------------------------------;
MoveStars:
        ld a,(star1x)           ;load current fast stars x position
        dec a
        dec a
        dec a
        ld (star1x),a           ;update the memory

        ld a,(star2x)           ;load current slow stars x position
        dec a
        ld (star2x),a           ;update the memory


        ret                     ;done!!!



;---------------------------------------------------------------;
;                       DRAW THE STARS!!                        ;
;---------------------------------------------------------------;
DrawStars:
        ld a,(star1x)
        ld b,a
        ld a,62
        ld c,a
        ld a,1
        ld (counter),a

        CALL_(DrawLoop1)

        ld a,(star2x)
        ld b,a
        ld a,62
        ld c,a
        ld a,1
        ld (counter),a

        CALL_(DrawLoop2)

        ret

DrawLoop1:
        CALL_(PlotPixel)
        dec C
        ld a,35
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        dec C
        ld a,18
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,23
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        dec C
        ld a,5
        add a,b
        ld b,a
        CALL_(PlotPixel)

        ld a,(counter)
        inc a
        cp 7
        ret z

        ld (counter),a

        JUMP_(DrawLoop1)


DrawLoop2:
        CALL_(PlotPixel)
        dec C
        ld a,15
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,25
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,5
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,8
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,13
        add a,b
        ld b,a
        CALL_(PlotPixel)
        dec C
        ld a,3
        add a,b
        ld b,a
        CALL_(PlotPixel)

        ld a,(counter)
        inc a
        cp 8
        ret z

        ld (counter),a

        JUMP_(DrawLoop2)

;---------------------------------------------------------------;
;                      ERASE THE STARS!!                        ;
;---------------------------------------------------------------;
EraseStars:
        ld a,(star1x)
        ld b,a
        ld a,62
        ld c,a
        ld a,1
        ld (counter),a

        CALL_(EraseLoop1)

        ld a,(star2x)
        ld b,a
        ld a,62
        ld c,a
        ld a,1
        ld (counter),a

        CALL_(EraseLoop2)

        ret

EraseLoop1:
        CALL_(ErasePixel)
        dec C
        ld a,35
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        dec C
        ld a,18
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,23
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        dec C
        ld a,5
        add a,b
        ld b,a
        CALL_(ErasePixel)

        ld a,(counter)
        inc a
        cp 7
        ret z

        ld (counter),a

        JUMP_(EraseLoop1)


EraseLoop2:
        CALL_(ErasePixel)
        dec C
        ld a,15
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,25
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,5
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,8
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,13
        add a,b
        ld b,a
        CALL_(ErasePixel)
        dec C
        ld a,3
        add a,b
        ld b,a
        CALL_(ErasePixel)

        ld a,(counter)
        inc a
        cp 8
        ret z

        ld (counter),a

        JUMP_(EraseLoop2)

endofgame:

        ld a,(ZS_BITS)          ;set Zshell to re-checksum
        set 0,a
        
        ROM_CALL(CLEARLCD)


        ld hl,$1815
        ld ($8333),hl
        ld hl,(PROGRAM_ADDR)
        ld de,FinalStr
        add hl,de
        ROM_CALL(D_ZM_STR)

        ld hl, (score)
        ld de, dispscore+4
	ld b, 5
SCORELOOP1:
	call UNPACK_HL
	add a, '0'                      
	ld (de), a                      
	dec de
        djnz SCORELOOP1
	
        ld hl, $1853
	ld ($8333), hl
        ld hl, dispscore
	ld b, 5
	ROM_CALL(D_LM_STR)

lastwait:
        call GET_KEY
        cp $9
        ret z
        cp $36
        ret z
        cp $37
        ret z

        JUMP_(lastwait)




PlotPixel:
        ROM_CALL(FIND_PIXEL)
        ld de,$FC00
        add hl,de
        or (HL)
        ld (HL),a
        ret


ErasePixel:
        ROM_CALL(FIND_PIXEL)
        ld de,$FC00
        add hl,de
        xor 255
        and (hl)
        ld (HL),a
        ret



GetPixel:
        ROM_CALL(FIND_PIXEL)
        ld de,$FC00
        add hl,de
        and (hl)
        ret

Title2:                  .db "+-------------------+",0
Title1:                  .db "|   Mutiny85  1.3   |",0
Title3:                  .db "+-------------------+",0
AuthorStr:              .db "by: Tim FitzRandolph",0
PressEnterStr:          .db "(press ENTER)",0


ScoreStr:               .db "Score->",0
MEGAStr:                .db "MEGAbombs->",0

LivesStr:               .db "Remaining Lives:",0

FinalStr:               .db "Final Score:",0


Enemy1Y:        .db 30,31,32,33,34,35,36,37,38,39,40,39,38,37,36,35,34,33,32,31
                .db 30,29,28,27,26,25,24,23,22,21,20,21,22,23,24,25,26,27,28,29
                .db 30,31,32,33,34,35,36,37,38,39,40,39,38,37,36,35,34,34,32,31
                .db 30,29,28,27,26,25,24,23,22,21,20,21,22,23,24,25,26,27,28,29
                .db 30,31,32,33,34,35,36,37,38,39,40,39,38,37,36,35,34,34,32,31
                .db 30,29,28,27,26,25,24,23,22,21,20,21,22,23,24,25,26,27,28,29
                .db 30,31,32,33,34,35,36,37,38,39,40,39,38,37,36,35,34,34,32,31
                .db 30,31,30,29,30,31,30

Enemy2Y:        .db 64,57,53,49,44,37,29,23,19,16,14,12,11,11,11,11,11,11,11,11
                .db 12,14,16,19,23,29,37,43,46,47,48,48,48,49,49,52,56,59,60,61
                .db 64,57,53,49,44,37,29,23,19,16,14,12,11,11,11,11,11,11,11,11
                .db 12,14,16,19,23,29,37,43,46,47,48,48,48,49,49,52,56,59,60,61
                .db 64,57,53,49,44,37,29,23,19,16,14,12,11,11,11,11,11,11,11,11
                .db 12,14,16,19,23,29,37,43,46,47,48,48,48,49,49,52,56,59,60,61
                .db 64,57,53,49,44,37,29,23,19,16,14,12,11,11,11,11,11,11,11,11
                .db 15,16,18,20,23,25,32


Enemy4X:        .db 126,126,126,125,123,120,118,115,111,107,103,99,96,91,88,86,84
                .db 83,82,84,89,95,100,103,104,103,100,94,89,83,78,75,72,71,68,62
                .db 55,48,42,39,37,36,36,36,36,36,36,35,31,24,17,11,8,5,7,13,21,29
                .db 36,40,44,44,40,34,27,20,13,8,2,0

Enemy4Y:        .db 62,56,50,47,45,43,40,38,36,36,36,37,38,40,42,44,47,50,53,57
                .db 59,59,57,54,49,44,40,38,36,33,30,26,22,19,16,13,11,11,11,11
                .db 11,15,19,23,28,33,37,42,48,52,54,54,51,46,40,35,31,29,33,35
                .db 33,28,22,18,16,15,14,12,11,11,15

.end