REM ><Invaders$Dir>.Src.Invaders
REM Taito Space Invaders (Circa 1978) Clone
REM (c) DynaByte Software 2008
REM LibASH Extended heap manager (c)2008 DynaByte Software.
REM Derived from ASH by Steve Revill (c)2004 7th Software.
REM Keys | Title | In-Game
REM ======+===============+=============
REM SPACE | Start Game |
REM S | Screenshot | Screenshot
REM Z | | Left.
REM X | | Right.
REM Enter | | Fire.
REM M | Music On/Off | Music On/Off
REM + | Volume Up | Volume Up
REM - | Volume Down | Volume Down
REM P | | Pause/Resume Game.
REM Q | Quit Program | Suicide.
REM *************************************************************
REM Initialisation Part 1... (Files & Environment.)
REM *************************************************************
REM Setup error trapping and announce ourselves...
ON ERROR PROCtrap_error:END
MODE28:OFF :REM 800*600 (256 Colours)
string$="Acorn Invaders. (c)2008 DynaByte Software"
PRINT string$:PRINT STRING$(LEN(string$),"-"):PRINT
REM Check we have all our essential files...
REM Our Hiscore table is a special case as it can be either
REM generated if one doesn't exist, or we can carry on regardless
REM if we can't create it.
REM Set Directory pointers...
app_dir$="<Invaders$Dir>.Resources." :REM Root resources.
gfx_dir$=app_dir$+"Graphics." :REM Graphics.
dat_dir$=app_dir$+"Data." :REM Data, Lookups etc.
snd_dir$=app_dir$+"Sound." :REM Sound.
REM Locate files... (Mission critical...)
bail%=FALSE
PRINT"Checking files..."
IF NOT FNfind(gfx_dir$+"Gfx0","Sprites") THEN bail%=TRUE
IF NOT FNfind(gfx_dir$+"Gfx1","Charset") THEN bail%=TRUE
IF NOT FNfind(snd_dir$+"Intro","Music") THEN bail%=TRUE
IF NOT FNfind(dat_dir$+"Creds","Credits") THEN bail%=TRUE
IF NOT FNfind(dat_dir$+"Msg","Messages") THEN bail%=TRUE
IF NOT FNfind(dat_dir$+"ImgLUT","Lookups") THEN bail%=TRUE
IF NOT FNfind(dat_dir$+"SWIs","Lookups") THEN bail%=TRUE
IF bail% THEN ERROR 255,"File Missing!!"
PRINT
REM Load strings & Lookup Tables...
REM We do these here as they share the same code, except they
REM setup different global variables...
PRINT"Loading Messages..."; :REM Text strings.
string_max%=FNstring_enumprocessed(dat_dir$+"Msg","SGSM")
DIM string_num%(string_max%),string_msg$(string_max%)
PROCstring_load(dat_dir$+"Msg","SGSM",string_num%(),string_msg$())
PRINTFNstring_get(14)
PRINTFNstring_get(9)+" "+FNstring_get(3); :REM Sprite names.
ilut_max%=FNstring_enumprocessed(dat_dir$+"ImgLUT","TULI")
DIM ilut_num%(ilut_max%),ilut_msg$(ilut_max%)
PROCstring_load(dat_dir$+"ImgLUT","TULI",ilut_num%(),ilut_msg$())
PRINTFNstring_get(14)
PRINTFNstring_get(9)+" "+FNstring_get(13); :REM SWI names.
slut_max%=FNstring_enumprocessed(dat_dir$+"SWIs","TULS")
DIM slut_num%(slut_max%),slut_msg$(slut_max%)
PROCstring_load(dat_dir$+"SWIs","TULS",slut_num%(),slut_msg$())
PRINTFNstring_get(14)
REM Setup our variables. (These are used all over...)
REM A lot of misc values like timing stores are now held in the
REM gamestate% object. Values held here are listed below. Music
REM stuff was previously stored in it's own object, but didn't
REM really warrant the extra overhead. A lot of the other values
REM were bundled into the player% object, but didn't really
REM belong there. This new object pulls all this stuff together
REM in one place. We also kick the ASH Heap Manager at this point
REM and get it going.
REM gamestate% object contents...
REM Offs.| Usage Offs.| Usage
REM -----+-------------------------+-----+-----------------------
REM 0 : Sound Status | 32 : HUD Pause game status.
REM 4 : Music Handle (TimPlayer)| 36 : HUD Pause game timer.
REM 8 : Volume change delay | 40 : Screenshot counter.
REM 12 : Last extra life score | 44 : Media writeable flag.
REM 16 : Extra life HUD counter | 48 : Not used...
REM 20 : Extra life frame toggle | 52 : Number of inv. missiles
REM 24 : Extra life frame timer | 56 : Number of bunkers.
REM 28 : Pause Game toggle. | 60 : <End of allocation>
REM -----+-------------------------+-----+-----------------------
REM Number of invader missiles (Offset 52)...
REM This value represents the maximum number of missiles currently
REM allowed on screen. This increases up to a maximum of 10 as the
REM player gets further down the line. For ASH allocation and
REM freeing purposes, this number is ALWAYS 10 (The size of the
REM array.) Slots higher than the number in this offset are masked
REM off when it comes to the operation of the handler.
REM Timers (Offsets 8, 24 & 36)...
REM All timers are snapshots of OS_ReadMonotonicTime used for
REM delay or animation events.
PRINT:PRINTFNstring_get(12)
PRINTFNstring_get(8)+" "+FNstring_get(2)
PROCash_init :REM Kick the Heap Manager.
gamestate%=FNash_claimfilled(60,0) :REM Claim for state info.
gamestate%!0=1:gamestate%!4=-1
gamestate%!40=FNinit_setdumpcounter(0) :REM Screendump counter.
IF gamestate%!40=-1 THEN ERROR255,FNstring_get(109)
PRINTFNstring_get(15)+STR$(gamestate%!40)
bail%=FALSE :REM TRUE to quit game.
gamestate%!44=TRUE :REM TRUE to save HiTable.
gamestate%!52=5 :REM Invader missiles.
gamestate%!56=5 :REM Number of bunkers.
cred_size%=0 :REM Credit screen stuff.
DIM scores_name$(10),scores_value%(10) :REM HiScore table.
DIM scores_rack%(10)
REM Objects... Each object (Base, saucer, missile etc.) is
REM given a block of memory up to 68 bytes long to hold all
REM relevant data for that object. This, apart from being
REM quicker, is far easier to code and saves memory (See
REM tutorial). These are tokens to address offsets in each
REM of those blocks of memory. (See tutorial for how this
REM works...) Contents for offsets 32-64 (flags1% - flags9%) will
REM be different, depending on the nature of the object. Not all
REM objects will have all 9 option flags available. I'll define
REM LOCAL variables with more meaningful names and point them to
REM these in the object's handler routines.
PRINTFNstring_get(8)+" "+FNstring_get(22)
REM Object offsets...
xpos%=0:ypos%=4:xsize%=8:ysize%=12 :REM Position & Size.
dir%=16:speed%=20 :REM Movement.
active%=24:beenhit%=28 :REM Object Status.
flags1%=32:flags2%=36:flags3%=40 :REM Misc flags.
flags4%=44:flags5%=48:flags6%=52
flags7%=56:flags8%=60:flags9%=64
REM Define offsets for screen and rail objects.
x_eig%=16:y_eig%=20:setmode%=24 :REM Offsets in screen obj.
xfont%=28:yfont%=32
toprail%=16:baserail%=20 :REM Offsets in rail obj.
REM Initialise Sound Sub-system and load music...
PRINT:PRINTFNstring_get(8)+" "+FNstring_get(1)+" ";
ver%=0:SYS FNswi_get(30) TO ver%
PRINTFNstring_get(21)+" "+STR$(ver%/100)
gamestate%!4=FNtp_loadsong(snd_dir$+"Intro")
REM Initialise Graphics Sub-system...
REM The variables we're interested in here will be...
REM gfx_spriteop% -> The OS Call we'll use to draw graphics.
REM gfx_spritepool% -> Block of RAM where our sprites reside.
REM gfx_fontpool% -> Block of RAM where our charset resides.
REM gfx_area% -> Pointer to our current graphics pool.
PRINT:PRINTFNstring_get(17)+" "+FNstring_get(16)
SYS FNswi_get(1),, FNswi_get(2) TO gfx_spriteop%
PRINTFNstring_get(9)+" "+FNstring_get(4);
gfx_spritepool%=FNgfx_load(gfx_dir$+"Gfx0")
PRINTFNstring_get(14)
PRINTFNstring_get(9)+" "+FNstring_get(5);
gfx_fontpool%=FNgfx_load(gfx_dir$+"Gfx1")
PRINTFNstring_get(14)
gfx_area%=gfx_spritepool%
REM Load Credit screen data...
REM This was originally as strings in the listing, but
REM implementing this in a loop reading data from an array takes
REM less space and tidies up the listing somewhat.
PRINT:PRINTFNstring_get(9)+" "+FNstring_get(6);
hdl%=OPENIN(dat_dir$+"Creds")
INPUT#hdl%,magic$ :REM Read magic and verify.
IF magic$<>"DERC" THEN
CLOSE#hdl%:ERROR 255,FNstring_get(101):END
ENDIF
INPUT#hdl%,cred_size% :REM Number of lines...
DIM cred_str$(cred_size%),cred_spc%(cred_size%)
FOR i%=1 TO cred_size%
INPUT#hdl%,cred_spc%(i%),cred_str$(i%)
NEXT i%
CLOSE#hdl%
PRINTFNstring_get(14)
REM HiScore Table...
REM Here, we look for and load, if it exists, our Hiscores file.
REM If we can't find one, we check whether we can write to the
REM location before we attempt to create one. If we can't
REM do that, then we can still run, but the user's scores will
REM not be retained on exit.
PRINT:PRINTFNstring_get(7)
hifile$=dat_dir$+"HiTable" :REM Location of file.
IF FNfs_find(hifile$)<>1 THEN
IF NOT FNfs_writeable(0,app_dir$) THEN
gamestate%!44=FALSE :REM HiTable save flag.
PRINTFNstring_get(19)+" "+FNstring_get(10)+" "+FNstring_get(20)
ELSE
PRINTFNstring_get(19)+" "+FNstring_get(11)+" "+FNstring_get(20)
ENDIF
PROChitable_create(gamestate%!44) :REM HiTable save flag.
ELSE
IF NOT FNfs_writeable(1,hifile$) THEN
gamestate%!44=FALSE :REM HiTable save flag.
PRINTFNstring_get(18)+" "+FNstring_get(10)+" "+FNstring_get(20)
ELSE
PRINTFNstring_get(18)+" "+FNstring_get(11)+" "+FNstring_get(20)
ENDIF
PROChitable_load
ENDIF
PRINT:PRINTFNstring_get(12):PROCwait(150)
REM *************************************************************
REM Initialisation Part 2... (Global objects and variables.)
REM *************************************************************
REM Reserve memory for global object blocks...
screen%=FNash_claim(36):rail%=FNash_claim(24) :REM Global objects.
box%=FNash_claim(16)
REM Get the video display into a VGA 256 colour mode. This is
REM also the same MODE as our sprites. Call to PROCget_screeninfo
REM calls the OS to get some values and sets up our screen object
REM for us.
CLS:PROCget_screeninfo :REM Setup screen object.
screen%!xfont%=FNconv_units(8,1)
screen%!yfont%=FNconv_units(8,2)+7
REM Define property values for other global objects.
rail%!xsize%=FNconv_units(6,1) :REM Rail properties.
rail%!ysize%=FNconv_units(6,2)
rail%!toprail%=screen%!ysize%-50
rail%!baserail%=30
REM *************************************************************
REM Main Loop... (Title>Game>Title.)
REM *************************************************************
REM Start music playing...
REM Offs. | Purpose | Value
REM ------+---------+------
REM 0 | Status | 0=Mute, 1=Music & SFX, 2=SFX Only.
REM 4 | Handle | TimPlayer reference handle.
REM 8 | Delay | n=0 - Do it now, n>0 Wait n counts.
SYS FNswi_get(33) ,gamestate%!4 :REM Start playing.
SYS FNswi_get(36) ,gamestate%!4,128 :REM Set current volume.
REM Cycle attract mode and play game...
WHILE NOT FNtitle_loop
CLS:PROCmain
ENDWHILE
REM Enclose our goodbyes in a border...
REM Setup our border size and position. Centre this on the screen
REM and then drop it down by 3px. (Raising the text by 3px would
REM break too many things!) Call PROCdraw_box() to produce our
REM border and then display our text. Once we've done all that, we
REM start to fade our music and bail back to the desktop.
CLS:box%!xsize%=220:box%!ysize%=40
box%=FNcentre_sprite_xy(box%,screen%):box%!ypos%-=3
PROCdraw_box(box%):PROCcentre_text_xy(FNstring_get(31),10)
IF gamestate%!0=1 THEN
SYSFNswi_get(36),gamestate%!4,-1 TO ,cvol%
FOR i%=cvol% TO 0 STEP-2
SYSFNswi_get(36),gamestate%!4,i%:PROCwait(4)
NEXT i%
SYSFNswi_get(35),gamestate%!4 :REM Stop music playing.
SYSFNswi_get(32),gamestate%!4 :REM Unload music.
gamestate%!4=-1 :REM Clear handle.
ENDIF
PROCash_destroy :REM Tear down ASH Subsystem...
END
REM *************************************************************
REM Title Loop... (Display our title sequence.)
REM *************************************************************
REM Animate in our initial screen layout and then perform a cycle
REM between Credits, Score Advance, Keyboard Controls & HiScore
REM Table screens. Do a keyboard scan for each screen and check
REM for hotkeys and return from function accordingly... Object
REM hwind% points to the area of the screen where where the
REM current screen in the sequence gets placed in the attract
REM mode. Although not a window in the true sense, in that it has
REM no focus, it's easier to think of it that way. This is the
REM area below "Invaders" and above "PRESS SPACE TO PLAY" text.
REM Objects inv1% - inv3% are identical copies of each other,
REM except for values of ypos%. Likewise, the key-% objects are
REM copies, apart from the co-ordinates. Our saucer% object here,
REM is only large enough to hold screen co-ordinates. It is made
REM LOCAL to this function so we can re-define it for the main
REM game loop.
DEFFNtitle_loop
LOCAL i%,space%,invt%,hwind%,str%,saucer%,inv1%,inv2%,inv3%
LOCAL base%,keyz%,keyx%,keye%,keyq%,keym%,keys%,keyu%,keyd%
LOCAL x%,y%,rc%,scores_save%,s$,string$
scores_save%=44 :REM gamestate% object offsets.
REM Allocate & initialise title sequence objects using ASH...
REM Space is allocated for keyx%, keye%, keyq%, keym%, keys%,
REM keyu%, keyd%, inv2% and inv3% by FNash_blockcopy() all we
REM need to do is remember to release it afterwards.
space% =FNash_claimfilled(16,0)
invt% =FNash_claimfilled(16,0)
hwind% =FNash_claimfilled(16,0)
saucer% =FNash_claimfilled(16,0)
inv1% =FNash_claimfilled(16,0)
keyz% =FNash_claimfilled(16,0)
base% =FNash_claimfilled(16,0)
REM Initialise LOCAL (title sequence) variables.
space%!xsize%=FNconv_units(100,1) :REM Space text properties.
space%!ysize%=FNconv_units(40,2)
space%!xpos%=FNcentre_sprite(space%,screen%)
space%!ypos%=800
invt%!xsize%=FNconv_units(150,1) :REM Invaders text properties.
invt%!ysize%=FNconv_units(40,2)
invt%!xpos%=FNcentre_sprite(invt%,screen%)
invt%!ypos%=space%!ypos%-invt%!ysize%
hwind%!xsize%=720:hwind%!ysize%=500:REM Window properties.
hwind%!xpos%=FNcentre_sprite(hwind%,screen%)
hwind%!ypos%=200
saucer%!xsize%=FNconv_units(40,1) :REM Saucer properties.
saucer%!ysize%=FNconv_units(20,2)
saucer%!xpos%=(hwind%!xpos%+hwind%!xsize%/2)-150
saucer%!ypos%=(hwind%!ypos%+hwind%!ysize%)-125
base%!xsize%=FNconv_units(30,1) :REM Base properties.
base%!ysize%=FNconv_units(15,2)
inv1%!xsize%=FNconv_units(20,1) :REM Common invader props.
inv1%!ysize%=FNconv_units(20,2)
inv1%!xpos%=(hwind%!xpos%+hwind%!xsize%/2)-150
inv1%!xpos%+=FNcentre_sprite(inv1%,saucer%)
inv2%=FNash_blockcopy(inv1%) :REM Create two copies.
inv3%=FNash_blockcopy(inv1%)
:REM Unique invader props.
inv3%!ypos%=saucer%!ypos%-40-inv3%!ysize%
inv2%!ypos%=inv3%!ypos%-40-inv2%!ysize%
inv1%!ypos%=inv2%!ypos%-40-inv1%!ysize%
keyz%!xsize%=FNconv_units(20,1) :REM KB Controls "keys".
keyz%!ysize%=FNconv_units(20,2)
keyz%!xpos%=(hwind%!xpos%+hwind%!xsize%/2)-120
keyx%=FNash_blockcopy(keyz%) :REM Clone three.
keye%=FNash_blockcopy(keyz%):keyq%=FNash_blockcopy(keyz%)
keyq%!xpos%=hwind%!xpos% :REM Tweak & clone three.
keyp%=FNash_blockcopy(keyq%):keys%=FNash_blockcopy(keyq%)
keym%=FNash_blockcopy(keyz%)
keym%!xpos%=hwind%!xpos% :REM Tweak & clone two.
keym%!xpos%+=(hwind%!xsize%/2)+10
keyu%=FNash_blockcopy(keym%):keyd%=FNash_blockcopy(keym%)
:REM Unique "keys" props.
keyz%!ypos%=(hwind%!ypos%+hwind%!ysize%)-120
keyx%!ypos%=keyz%!ypos%-60:keye%!ypos%=keyx%!ypos%-60
keys%!ypos%=keye%!ypos%-90:keyp%!ypos%=keys%!ypos%-60
keyq%!ypos%=keyp%!ypos%-60:keym%!ypos%=keye%!ypos%-90
keyu%!ypos%=keym%!ypos%-60:keyd%!ypos%=keyu%!ypos%-60
REM Animate the initial screen title "Space Invaders" & "PRESS
REM SPACE TO PLAY" messages.
CLS:PROCdraw_rail(rail%!toprail%):PROCdraw_rail(rail%!baserail%)
PROChud_soundstate
FOR i%=0-space%!xsize% TO space%!xpos% STEP 5
WAIT:PROCplot(FNsprite_get(100),i%,space%!ypos%)
PROCwait(1)
NEXT i%
FOR i%=screen%!xsize% TO invt%!xpos% STEP -5
WAIT:PROCplot(FNsprite_get(101),i%,invt%!ypos%)
PROCwait(1)
NEXT i%
string$=FNstring_get(32):str%=LEN(string$)*screen%!xfont%:y%=170
PROCprint(FNcentre_text(str%,screen%!xsize%),y%,string$,11)
string$=FNstring_get(33)
str%=LEN(string$)*screen%!xfont%:y%-=screen%!yfont%
PROCprint(FNcentre_text(str%,screen%!xsize%),y%,string$,11)
REM Cycle the remainder of the attract mode.
WHILE NOT INKEY(-99) AND NOT INKEY(-17) AND NOT INKEY(-82)
REM Display Credits Screen...
REM Text strings are held in cred_str$() in encrypted form.
REM Line spacing info is held in the matching element of
REM cred_spc%(). Negative values have special meanings...
REM Value | Line spacing is...
REM --------+---------------------
REM -1 | 1 * screen%!yfont% (Next line.)
REM -2 | 2 * screen%!yfont% (Leave a blank line.)
REM <+n> | Leave a gap of <n> OS Units...
y%=hwind%!ypos%+hwind%!ysize%
FOR i%=1 TO cred_size%
string$=FNencode_string(cred_str$(i%))
x%=FNtitle_stringcentre(string$)
CASE cred_spc%(i%) OF
WHEN -1 : y%-=screen%!yfont%
WHEN -2 : y%-=(2*screen%!yfont%)
OTHERWISE : y%-=cred_spc%(i%)
ENDCASE
PROCprint(x%,y%,string$,0)
NEXT i%
REM Wait for 750 counts or until SPACE or Q pressed...
rc%=FNtitle_wait
IF rc%=1 THEN =TRUE
IF rc%=2 THEN =FALSE
PROCwipe_sprite(hwind%)
REM Display Score Advance table...
string$=FNstring_get(57)+" "+FNstring_get(34)
x%=FNtitle_stringcentre(string$)
y%=hwind%!ypos%+hwind%!ysize%-20:PROCprint(x%,y%,string$,0)
string$=FNstring_get(35):y%-=screen%!yfont%
x%=FNtitle_stringcentre(string$):PROCprint(x%,y%,string$,0)
x%=saucer%!xpos%+saucer%!xsize%+10
PROCplot(FNsprite_get(11),saucer%!xpos%,saucer%!ypos%)
string$=FNstring_get(36)+" "+FNstring_get(40)
PROCprint(x%,saucer%!ypos%+10,string$,0)
PROCplot(FNsprite_get(24),inv3%!xpos%,inv3%!ypos%)
string$=FNstring_get(37)+" "+FNstring_get(40)
PROCprint(x%,inv3%!ypos%+12,string$,0)
PROCplot(FNsprite_get(22),inv2%!xpos%,inv2%!ypos%)
string$=FNstring_get(38)+" "+FNstring_get(40)
PROCprint(x%,inv2%!ypos%+12,string$,0)
PROCplot(FNsprite_get(20),inv1%!xpos%,inv1%!ypos%)
string$=FNstring_get(39)+" "+FNstring_get(40)
PROCprint(x%,inv1%!ypos%+12,string$,0)
str%=base%!xsize%/screen%!xfont%+2:s$=FNstring_get(66)
string$=s$+STRING$(str%," ")+FNstring_get(67)
x%=FNtitle_stringcentre(string$)
y%=inv1%!ypos%-(3*screen%!yfont%)
PROCprint(x%,y%,string$,0)
base%!xpos%=x%+7+(LEN(s$)*screen%!xfont%):base%!ypos%=y%
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%)
REM Wait for 750 counts or until SPACE or Q pressed...
rc%=FNtitle_wait
IF rc%=1 THEN =TRUE
IF rc%=2 THEN =FALSE
PROCwipe_sprite(hwind%)
REM Display Keyboard controls screen...
string$=FNstring_get(41):x%=FNtitle_stringcentre(string$)
y%=hwind%!ypos%+hwind%!ysize%-20:PROCprint(x%,y%,string$,0)
REM Left, Right & Fire...
x%=keyz%!xpos%+keyz%!xsize%+10
PROCplot(FNsprite_get(102),keyz%!xpos%,keyz%!ypos%) :REM (Z)
string$=FNstring_get(42)+" "+FNstring_get(43)
PROCprint(x%,keyz%!ypos%+12,string$,0)
PROCplot(FNsprite_get(103),keyx%!xpos%,keyx%!ypos%) :REM (X)
string$=FNstring_get(42)+" "+FNstring_get(44)
PROCprint(x%,keyx%!ypos%+12,string$,0)
PROCplot(FNsprite_get(104),keye%!xpos%,keye%!ypos%) :REM (Enter)
PROCprint(x%,keye%!ypos%+12,FNstring_get(45),0)
REM Extra control keys (Left column)...
x%=keyq%!xpos%+keyq%!xsize%+10
PROCplot(FNsprite_get(105),keyp%!xpos%,keyp%!ypos%) :REM (P)
string$=FNstring_get(46)+" "+FNstring_get(49)
PROCprint(x%,keyp%!ypos%+12,string$,0)
PROCplot(FNsprite_get(117),keys%!xpos%,keys%!ypos%) :REM (S)
PROCprint(x%,keys%!ypos%+12,FNstring_get(76),0)
PROCplot(FNsprite_get(107),keyq%!xpos%,keyq%!ypos%) :REM (Q)
string$=FNstring_get(48)+" "+FNstring_get(49)
PROCprint(x%,keyq%!ypos%+12,string$,0)
REM Extra control keys (Right column)...
x%=keym%!xpos%+keym%!xsize%+10
PROCplot(FNsprite_get(106),keym%!xpos%,keym%!ypos%) :REM (M)
string$=FNstring_get(47)+" "+FNstring_get(73)
PROCprint(x%,keym%!ypos%+12,string$,0)
PROCplot(FNsprite_get(115),keyu%!xpos%,keyu%!ypos%) :REM (+)
string$=FNstring_get(47)+" "+FNstring_get(77)+" "
string$+=FNstring_get(74)
PROCprint(x%,keyu%!ypos%+12,string$,0)
PROCplot(FNsprite_get(116),keyd%!xpos%,keyd%!ypos%) :REM (-)
string$=FNstring_get(47)+" "+FNstring_get(77)+" "
string$+=FNstring_get(75)
PROCprint(x%,keyd%!ypos%+12,string$,0)
REM Wait for 750 counts or until SPACE or Q pressed...
rc%=FNtitle_wait
IF rc%=1 THEN =TRUE
IF rc%=2 THEN =FALSE
PROCwipe_sprite(hwind%)
REM Display HiScore table...
REM First line... (This is conditional on scores_save%)
string$=FNstring_get(50)
IF gamestate%!scores_save% THEN string$=FNstring_get(51)
x%=FNtitle_stringcentre(string$)
y%=hwind%!ypos%+hwind%!ysize%-20
PROCprint(x%,y%,string$,0)
REM Second line...
string$=FNstring_get(58)+" "+FNstring_get(52)
x%=FNtitle_stringcentre(string$):y%-=screen%!yfont%
PROCprint(x%,y%,string$,0)
REM Table header...
y%=(hwind%!ypos%+hwind%!ysize%)-100
string$=" "+FNstring_get(68)+" "+FNstring_get(69)
string$+=STRING$(12," ")+FNstring_get(57)+"."
string$+=STRING$(3," ")+FNstring_get(60)+"."
x%=FNtitle_stringcentre(string$)
PROCprint(x%,y%,string$,0)
y%-=2*screen%!yfont%
REM Loop through the HiScore table arrays displaying names and
REM scores...
FOR i%=1 TO 10
IF i%<10 THEN
string$=" "+STR$(i%)+". "
ELSE
string$=" "+STR$(i%)+". "
ENDIF
s$=FNencode_string(scores_name$(i%))
string$+=FNstr_pad(s$,8," ",FALSE):string$+=" .... "
string$+=FNstr_rightalign(STR$(scores_value%(i%)),10)
string$+=" ... "+FNstr_rightalign(STR$(scores_rack%(i%)),3)
x%=FNtitle_stringcentre(string$)
PROCprint(x%,y%-(i%*(screen%!yfont%+5)),string$,0)
NEXT i%
REM Wait for 750 counts or until SPACE or Q pressed...
rc%=FNtitle_wait
IF rc%=1 THEN =TRUE
IF rc%=2 THEN =FALSE
PROCwipe_sprite(hwind%)
ENDWHILE
REM This should never get executed...
ERROR 255,FNstring_get(102)
=FALSE
REM Wait for 750 counts or SPACE or Q to be pressed. Returns one
REM of three values in rc%
REM 0 -> Timeout period expired... (750 counts up.)
REM 1 -> "Q" to Quit...
REM 2 -> SPACE to Play...
DEFFNtitle_wait
LOCAL t%,rc%
t%=TIME+750:rc%=FALSE
REPEAT
IF INKEY(-82) THEN PROCevnt_kb_screendump
IF INKEY(-102) THEN PROCevnt_kb_togglemusic
IF INKEY(-59) THEN PROCevnt_kb_volume(4)
IF INKEY(-60) THEN PROCevnt_kb_volume(-4)
UNTIL TIME>=t% OR INKEY(-17) OR INKEY(-99)
IF INKEY(-17) THEN rc%=1 :REM Get outta here (Q)...
IF INKEY(-99) THEN rc%=2 :REM Play a game...
REM If rc% is TRUE (non zero value) then we either start a game
REM or quit. Either way, we need to release the memory claimed
REM by our objects.
IF rc% THEN
PROCash_free(space%):PROCash_free(invt%):PROCash_free(hwind%)
PROCash_free(saucer%):PROCash_free(inv1%):PROCash_free(inv2%)
PROCash_free(inv3%):PROCash_free(keyz%):PROCash_free(keyx%)
PROCash_free(keye%):PROCash_free(keyq%):PROCash_free(keym%)
PROCash_free(keyp%):PROCash_free(keys%):PROCash_free(keyu%)
PROCash_free(keyd%):PROCash_free(base%)
ENDIF
=rc%
REM Prepare a string for display...
REM Centering a string requires a number of parameters to be setup
REM before calling PROCprint(). The process is largely repetative
REM All we do is change a few values.
DEFFNtitle_stringcentre(string$)
LOCAL str%
str%=LEN(string$)*screen%!xfont%
=hwind%!xpos%+FNcentre_text(str%,hwind%!xsize%)
REM *************************************************************
REM Game Loop... (Play one instance of the game.)
REM *************************************************************
REM Loop through one instance of the game. This basically means...
REM Setup in-game stuff. -> Play until out of bases. -> Manage
REM hiscore entry. -> Return.
DEFPROCmain
LOCAL base%,shell%,saucer%,rack%,player% :REM Objects.
LOCAL inv%
LOCAL invstat%(),invfire%() :REM Invader status.
LOCAL bunker%(),bunknum% :REM Bunker status.
LOCAL lives%,score%,racknum%,suicide% :REM Player properties.
LOCAL paused%,pstatus%,ptime% :REM Game state (Paused)
LOCAL elcount% :REM Game state (Extra)
LOCAL colgap%,xnum%,ynum%,rownum%,frcap% :REM Rack properties.
LOCAL evnt_kb%,str%,string$,x%,y%,i%,j% :REM Misc.
REM Claim memory for local objects using ASH...
base%=FNash_claim(32):shell%=FNash_claim(28)
saucer%=FNash_claim(48):rack%=FNash_claim(68)
inv%=FNash_claim(16):player%=FNash_claimfilled(16,0)
REM Setup arrays and object pointers...
lives%=0:score%=4:racknum%=8:suicide%=12 :REM Player offsets.
elcount%=16:paused%=28:bunknum%=56 :REM Game state offs.
colgap%=flags2%:xnum%=flags3%:ynum%=flags4% :REM Rack offsets.
rownum%=flags7%:frcap%=flags8%
DIM invstat%(10,6),invfire%(10),bunker%(gamestate%!bunknum%)
REM Initialise LOCAL (in-game) variables.
base%!xsize%=FNconv_units(30,1) :REM Base properties.
base%!ysize%=FNconv_units(15,2)
base%!xpos%=FNcentre_sprite(base%,screen%)
base%!ypos%=50:base%!speed%=6:base%!dir%=base%!speed%
inv%!xsize%=FNconv_units(20,1) :REM Invader properties.
inv%!ysize%=FNconv_units(20,2)
saucer%!xsize%=FNconv_units(40,1) :REM Saucer properties.
saucer%!ysize%=FNconv_units(20,2)
saucer%!ypos%=rail%!toprail%-(10+saucer%!ysize%)
saucer%!speed%=5:saucer%!active%=FALSE
saucer%!flags3%=1
shell%!xsize%=FNconv_units(5,1) :REM Shell properties.
shell%!ysize%=FNconv_units(20,2)
shell%!active%=FALSE:shell%!speed%=10
player%!racknum%=1:player%!lives%=3 :REM Player properties.
player%!suicide%=FALSE
gamestate%!elcount%=-1 :REM Initial game state.
rack%!colgap%=FNconv_units(20,1) :REM Rack properties.
rack%!xnum%=10:rack%!ynum%=6
rack%!active%=TRUE:rack%!frcap%=4
SYS FNswi_get(6) TO rack%!flags9%
PROCinvfire_init:PROCbunk_init :REM Object arrays.
REM Initialise game screen...
REM Draw the top and bottom rails, prepare and display the HUD &
REM sort out the first rack of invaders. Finally... Display the
REM player's base.
PROCdraw_rail(rail%!toprail%):PROCdraw_rail(rail%!baserail%)
PROChud_init(0,scores_value%(1),player%!lives%,player%!racknum%)
PROCrack_gameinit :REM Invaders.
PROCbunk_redraw :REM Bunkers.
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%) :REM Base.
REM Our event generator...
REM This is the main polling loop. The program sits tight in this
REM loop firing off events until the player runs out of lives.
WHILE player%!lives%>0
REM Keyboard poll...
REM We only check the top four if we haven't paused the game.
REM The rest we always need to check.
evnt_kb%=FALSE
IF gamestate%!paused%=0 THEN
IF INKEY(-74) THENPROCevnt_kb_basefire(base%!xpos%,base%!ypos%)
IF INKEY(-98) THENPROCevnt_kb_baseleft:evnt_kb%=TRUE
IF INKEY(-67) THENPROCevnt_kb_baseright:evnt_kb%=TRUE
IF INKEY(-17) THENPROCevnt_kb_suicide :REM(Q)Suicide...
REMIF INKEY(-36) THENPROCevnt_kb_saucertest :REM(T)Test only...
REMIF INKEY(-87) THENPROCevnt_kb_eltest :REM(L)Test only...
REMIF INKEY(-35) THENPROCrack_endgame :REM(E)Test only...
ENDIF
IF INKEY(-102)THENPROCevnt_kb_togglemusic :REM(M)Music On/Off
IF INKEY(-82) THENPROCevnt_kb_screendump :REM(S)Screenshot...
IF INKEY(-56) THENPROCevnt_kb_togglepause :REM(P)Pause Game...
IF INKEY(-59) THENPROCevnt_kb_volume(4) :REM(+)Volume Up...
IF INKEY(-60) THENPROCevnt_kb_volume(-4) :REM(-)Volume Down...
REM Update screen...
REM This is our equivalent of an arcade game's VBlank interrupt.
REM We've polled the input device (our keyboard) and we're
REM idling whilst processing events (evnt_kb%=FALSE). Either
REM way, something's going on, usually AI/Collision detection
REM related.
REM Post-process evnt_kb event updates. (Keyboard.)
REM The only two that require action here are left & right as
REM we need to display the base at the new position.
IF gamestate%!paused%=0 THEN
IF evnt_kb% THEN
base%!xpos%+=base%!dir%
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%)
ENDIF
ENDIF
REM Process evnt_fr events. (Frame Refresh.)
IF gamestate%!paused%=0 THEN
PROCevnt_fr_basefire :REM Animate player's shots.
PROCevnt_fr_saucer :REM Saucer handling & AI.
PROCevnt_fr_rackmove :REM Move rack & Collision detect.
PROCevnt_fr_rackfire :REM Rack missile fire control.
PROCevnt_fr_bunkers :REM Defense bunker collision stuff.
PROCevnt_fr_extralife :REM "Extra Life" text control.
ELSE
PROCevnt_fr_pausegame :REM "Game Paused" text control.
ENDIF
REM Wait for next VBlank
WAIT
ENDWHILE
REM Display GAME OVER!!! in a bordered rectangle in the middle
REM of the screen.
box%!xsize%=240:box%!ysize%=40
box%=FNcentre_sprite_xy(box%,screen%):box%!ypos%-=3
PROCwipe_sprite(box%):PROCdraw_box(box%)
string$=FNstring_get(49)+" "+FNstring_get(53)
PROCcentre_text_xy(string$,11):PROCwait(750)
REM Check & Handle HiTable entry...
IF NOT player%!suicide% THEN
IF player%!score%>=scores_value%(10) THEN
PROChitable_entry(player%)
ENDIF
ENDIF
REM Free memory used for objects...
PROCash_free(base%):PROCash_free(rack%):PROCash_free(saucer%)
PROCash_free(shell%):PROCash_free(player%):PROCash_free(inv%)
FOR i%=1 TO 10:PROCash_free(invfire%(i%)):NEXT i%
FOR i%=1 TO gamestate%!bunknum%:PROCash_free(bunker%(i%)):NEXT i%
ENDPROC
REM *************************************************************
REM Proceedures (Keyboard events.)
REM *************************************************************
REM Move base left. If we're already at left edge then bail...
DEFPROCevnt_kb_baseleft
REM Collision detection. (Base & Playfield.)
IF base%!xpos%<=0 THEN
base%!xpos%=0 :REM Don't move.
ELSE
base%!dir%=0-base%!speed% :REM Change direction.
ENDIF
ENDPROC
REM Move base right. If we're already at the right edge, bail...
DEFPROCevnt_kb_baseright
REM Collision detection. (Base & Playfield.)
IF base%!xpos%>=screen%!xsize%-base%!xsize% THEN
base%!xpos%=screen%!xsize%-base%!xsize% :REM Don't move.
ELSE
base%!dir%=0+base%!speed% :REM Change direction.
ENDIF
ENDPROC
REM Fire a shell. If we're already firing a shell bail. (We can
REM only fire one shell at a time or else the animation gets
REM confused.) shell%!active% is a property of the shell% object
REM that is set boolean TRUE when player fires a shell and is
REM cleared when either the shell scrolls off the top of the
REM screen or hits something.
DEFPROCevnt_kb_basefire(x%,y%)
REM Bail if shell already active.
IF NOT shell%!active% THEN
shell%!active%=TRUE :REM Set active.
shell%!xpos%=x%+(base%!xsize%/2) :REM Initial position.
shell%!ypos%=y%+base%!ysize%
PROCsfx_play(4)
ENDIF
ENDPROC
REM Dump a screen to disc as "<Invaders$Dir>.Screens.Dump<nnn>"
REM Where <nnn> is a number from 0 to 999. FNinit_setdumpcounter()
REM when given the current value, returns the next free slot.
REM When the "Screens" directory is empty, we start from 0.
DEFPROCevnt_kb_screendump
LOCAL num%,mflag%,name$
num%=40:mflag%=44 :REM Object offsets.
IF gamestate%!mflag% THEN
REPEAT:UNTIL NOT INKEY(-82) :REM De-bounce key.
gamestate%!num%=FNinit_setdumpcounter(gamestate%!num%)
IF gamestate%!num%=-1 THEN ERROR255,FNstring_get(109)
name$="<Invaders$Dir>.Screens.Dump"+STR$(gamestate%!num%)
OSCLI"ScreenSave "+name$
ENDIF
ENDPROC
REM Player has chickened out. (Committed suicide. 'Q' in-game.)
REM Set lives to zero and flag it up as a suicide event in the
REM player object. (Skip Hiscore entry if suicide set.)
DEFPROCevnt_kb_suicide
LOCAL i%
FOR i%=1 TO 7:invfire%(i%)!active%=FALSE:NEXT i%
player%!lives%=0:player%!suicide%=TRUE
ENDPROC
REM Toggle Music on & off...
REM Added music% object data to new gamestate% object, which now
REM also includes some of the values we used to store with the
REM player% object that were never really specific to the player,
REM but didn't belong anywhere else either. (04/07/08)
REM Offs. | Purpose | Value
REM -------+----------+------
REM 0 | Status | 0=Mute, 1=Music & SFX, 2=SFX Only.
REM 4 | Handle | TimPlayer internal handle.
REM 8 | Delay | Snapshot of OS_ReadMonotonicTime last done
DEFPROCevnt_kb_togglemusic
LOCAL mstatus%,mhandle%
mstatus%=0:mhandle%=4
REPEAT:UNTIL NOT INKEY(-102) :REM De-bounce key.
gamestate%!mstatus%+=1
IF gamestate%!mstatus%>2 THEN gamestate%!mstatus%=0
IF gamestate%!mstatus%=1 THEN
SYSFNswi_get(33),gamestate%!mhandle%
ELSE
SYSFNswi_get(34),gamestate%!mhandle%
ENDIF
PROChud_soundstate
ENDPROC
REM Turn Music volume up/down...
REM We only need to do this if music is actually playing... Don't
REM change anything otherwise. We don't de-bounce the keys here
REM as we don't exactly want a one-shot event. We do however, need
REM to introduce a delay, otherwise we would get an on/off switch
REM situation on fast hardware.
DEFPROCevnt_kb_volume(vol%)
LOCAL mstatus%,mhandle%,mdelay%,mt%,cvol%,nvol%
mstatus%=0:mhandle%=4:mdelay%=8 :REM Object offsets.
IF gamestate%!mstatus%=1 THEN
SYSFNswi_get(6) TO mt% :REM OS_ReadMonotonicTime
IF mt%-gamestate%!mdelay%>=10 THEN
SYSFNswi_get(36),gamestate%!mhandle%,-1 TO ,cvol%
nvol%=cvol%+vol%
IF nvol%>=0 AND nvol%<=128 THEN
SYSFNswi_get(36),gamestate%!mhandle%,nvol%
gamestate%!mdelay%=mt%
ENDIF
ENDIF
ENDIF
ENDPROC
REM Pause & Resume game...
REM Toggle between pause and resume. The actual logic is done
REM elsewhere.
DEFPROCevnt_kb_togglepause
LOCAL paused%,pstatus%,string$
paused%=28:pstatus%=32
REPEAT UNTIL NOT INKEY(-56) :REM De-bounce.
string$=FNstring_get(49)+" "+FNstring_get(61)
gamestate%!paused%=FNtoggle(gamestate%!paused%) :REM Toggle.
gamestate%!pstatus%=gamestate%!paused% :REM Set visible.
IF gamestate%!paused%=0 THEN
string$=STRING$(LEN(string$)," ")
PROChud_bannertext(string$)
ENDIF
ENDPROC
REM *************************************************************
REM Proceedures (VBlank/Frame Events)
REM *************************************************************
REM Continue animation of a player's shell... If one hasn't been
REM created then we bail back to event loop.
DEFPROCevnt_fr_basefire
IF shell%!active% THEN
REM Have we hit the top??
IF shell%!ypos%>=rail%!toprail%-shell%!ysize% THEN
shell%!active%=FALSE :REM Clear event.
shell%!ypos%-=2:PROCwipe_sprite(shell%) :REM Remove shell.
ELSE
REM Display shell at current position.
PROCplot(FNsprite_get(5),shell%!xpos%,shell%!ypos%)
ENDIF
shell%!ypos%+=shell%!speed% :REM Advance frame.
ENDIF
ENDPROC
REM Process saucer animation & generation events. A saucer can be
REM randomely activated n% of the time, but not if one is
REM currently on the screen. When activated, there is a 50% chance
REM of it starting on the left hand side of the screen, likewise
REM we have a 50% chance of it starting on the right.
DEFPROCevnt_fr_saucer
LOCAL hit%,toggle%,spr%,mt%,hittime%,fr$
hit%=flags1%:toggle%=flags2%:spr%=flags3% :REM Object tokens.
IF NOT saucer%!active% THEN
IF FNpct(4) AND FNpct(5) THEN
saucer%!active%=TRUE:saucer%!beenhit%=FALSE
saucer%!toggle%=0
REM Decide which side of the screen to start from.
IF FNpct(50) THEN
saucer%!dir%=0-saucer%!speed% :REM Right edge. (50%)
saucer%!xpos%=screen%!xsize%
ELSE
saucer%!dir%=0+saucer%!speed% :REM Left edge. (50%)
saucer%!xpos%=0-saucer%!xsize%
ENDIF
ENDIF
ELSE
REM Has saucer gone off screen??
IF saucer%!xpos%<=0-saucer%!xsize%ANDSGN(saucer%!dir%)=-1 THEN
saucer%!hit%=FALSE:saucer%!active%=FALSE
ENDPROC
ENDIF
IF saucer%!xpos%>screen%!xsize%ANDSGN(saucer%!dir%)=1 THEN
saucer%!hit%=FALSE:saucer%!active%=FALSE
ENDPROC
ENDIF
REM Has saucer been hit by player shot??
IF NOT saucer%!beenhit% THEN
IF FNhit(shell%,saucer%) THEN
PROCwipe_sprite(shell%)
PROCplot(FNsprite_get(12),saucer%!xpos%,saucer%!ypos%)
SYS FNswi_get(6) TO saucer%!hit%:saucer%!beenhit%=TRUE
shell%!active%=FALSE:PROChud_scorehit(500)
ENDIF
ELSE
IF FNhit(shell%,saucer%) THEN
PROCwipe_sprite(shell%):shell%!active%=FALSE
ENDIF
ENDIF
REM Animate saucer...
IF NOT saucer%!beenhit% THEN
REM Change image every 40 centi-seconds.
SYS FNswi_get(6) TO mt% :REM OS_ReadMonotonicTime
IF mt%-saucer%!spr%>=40 THEN
saucer%!spr%=mt%
saucer%!toggle%=FNtoggle(saucer%!toggle%)
ENDIF
REM Display one of two images.
fr$=FNsprite_get(10)+STR$(saucer%!toggle%)
PROCplot(fr$,saucer%!xpos%,saucer%!ypos%)
saucer%!xpos%+=saucer%!dir%
ELSE
REM Animate/Remove explosion...
SYS FNswi_get(6) TO mt%
hittime%=mt%-saucer%!hit%
IF hittime%>=300 THEN
saucer%!active%=FALSE:saucer%!toggle%=1
PROCwipe_sprite(saucer%)
ELSE
IF hittime%>=250 THEN
PROCplot(FNsprite_get(15),saucer%!xpos%,saucer%!ypos%)
ELSE
IF hittime%>=200 THEN
PROCplot(FNsprite_get(14),saucer%!xpos%,saucer%!ypos%)
ELSE
IF hittime%>=100 THEN
PROCplot(FNsprite_get(13),saucer%!xpos%,saucer%!ypos%)
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
ENDPROC
REM Check out the rack of invaders. Move left, right & down. Deal
REM with collision detection between player missiles and invaders.
DEFPROCevnt_fr_rackmove
LOCAL rack_ext%,z%,col%,row%,eclr%,sclr%,rclr%,offset%
LOCAL frame%,scol%,ecol%,mt%,timer%,pcsinv%,pcsbnk%
REM Setup meaningful pointers to our object flags...
REM Vars colgap%, xnum%, ynum%, rownum% & frcap% have already
REM been tied to flags2%, flags3%, flags4%, flags7% & flags8%
REM respectively.
frame%=flags1%:scol%=flags5%:ecol%=flags6%:timer%=flags9%
pcsinv%=52:pcsbnk%=56
REM Alternate our animation frame...
SYS FNswi_get(6) TO mt% :REM OS_ReadMonotonicTime
IF mt%-rack%!timer%>=50 THEN
rack%!timer%=mt%:rack%!frame%=FNtoggle(rack%!frame%)
ENDIF
REM Deal with rack movement...
REM Move rack left, right & down. Check each time we move down
REM to make sure that the rack hasn't invaded the base. If it has
REM then end the game.
rack_ext%=rack%!xpos%+rack%!xsize%
offset%=0-((rack%!scol%-1)*(inv%!xsize%+rack%!colgap%))
IF rack_ext%>=screen%!xsize% THEN
rack%!dir%=0-rack%!speed%:PROCrack_advance
ENDIF
IF rack%!xpos%<=offset% THEN
rack%!dir%=0+rack%!speed%:PROCrack_advance
ENDIF
REM Have we reached the base?
offset%=rack%!ypos%+((rack%!rownum%-1)*inv%!ysize%)
IF offset%<=base%!ypos%+base%!ysize% THEN
PROCrack_endgame:ENDPROC
ENDIF
REM Deal with collision detection...
REM Firstly we check to see if the player's shell lays somewhere
REM inside the rack of invaders. If this is not the case then we
REM bail and take no further action this time. However, if we
REM are inside the rack (FNhit(shell%,rack%)=TRUE) then we need
REM to see what, if anything, we've actually hit.
IF FNhit(shell%,rack%) THEN
z%=inv%!xsize%+rack%!colgap%
IF (shell%!xpos%-rack%!xpos%) MOD z% <= inv%!xsize% THEN
REM We've hit something... Find out what.
col%=((shell%!ypos%-rack%!ypos%) DIV inv%!ysize%)+1
row%=((shell%!xpos%-rack%!xpos%) DIV z%)+1
REM Act on it...
REM Vars col% & row% now contain the index of the invader that
REM the player hit. We now check the status of that invader
REM and act accordingly. A value of zero indicates that it's
REM already dead and buried, whilst a negative value is used
REM as a countdown timer for the explosion sprite. We are only
REM interested in positive non-zero values. Anything else, we
REM take no action.
IF SGN(invstat%(row%,col%))=1 THEN
invstat%(row%,col%)=-5 :REM Set explosion timer.
PROCwipe_sprite(shell%) :REM Remove shell.
shell%!active%=FALSE :REM De-activate shell.
rack%!beenhit%+=1 :REM Another one down.
PROCsfx_play(1)
REM Scoring...
CASE col% OF
WHEN 1,2 : PROChud_scorehit(50) :REM Bottom two rows.
WHEN 3,4 : PROChud_scorehit(75) :REM Middle two rows.
WHEN 5,6 : PROChud_scorehit(100) :REM Top two rows.
ENDCASE
ENDIF
ENDIF
ENDIF
REM Have we destroyed the last invader in the current rack?
REM If so, clear the play area and create and display the next
REM wave. In the process of clearing the play area, we seem to
REM wipe part of the HUD too. This happens when the cleared rows
REM drop below the position of the rail marking the bottom of the
REM play area. For the moment, I am just re-drawing this as and
REM when it happens, but really it needs fixing.
IF rack%!beenhit%>=rack%!xnum%*rack%!ynum% THEN
player%!racknum%+=1 :REM Advance rack counter.
PROCwipe_sprite(rack%) :REM Clear the last invader.
PROCdraw_rail(rail%!baserail%) :REM Re-draw bottom rail.
PROChud_lives(player%!lives%) :REM Update HUD.
PROChud_rack(player%!racknum%)
PROChud_soundstate
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%)
PROCbunk_reset:PROCbunk_redraw :REM Reset & redraw bunkers.
PROCrack_init :REM Create new rack.
REM Increase difficulty by allowing more invader missiles as
REM number of racks destroyed increases.
IF player%!racknum%>5 THEN gamestate%!pcsinv%=7
IF player%!racknum%>10 THEN gamestate%!pcsinv%=10
ENDIF
REM Do we need to resize the rack? The rack is defined as a block
REM of a fixed size. We display the invaders in this block. Each
REM time we clear the left or rightmost column or the bottom row,
REM we need to update the size of this block to keep the display
REM accurate.
eclr%=TRUE:sclr%=TRUE
FOR col%=1 TO rack%!ynum%
IF invstat%(rack%!ecol%,col%)<>0 THEN eclr%=FALSE
IF invstat%(rack%!scol%,col%)<>0 THEN sclr%=FALSE
NEXT col%
rclr%=TRUE
FOR row%=1 TO rack%!xnum%
IF invstat%(row%,rack%!rownum%)<>0 THEN rclr%=FALSE
NEXT row%
IF sclr% THEN rack%!scol%+=1
IF eclr% THEN
rack%!xsize%-=(inv%!xsize%+rack%!colgap%):rack%!ecol%-=1
ENDIF
IF rclr% THEN rack%!rownum%+=1
REM Finally... Redraw the rack...
rack%!xpos%+=rack%!dir%:PROCrack_redraw
ENDPROC
REM Invader missile fire logic...
REM This... Like all the rest of these animation routines is
REM timer based. We call this event handler once every
REM repetition of the game loop. All invader missile information
REM is held in our invfire%() array. This array is just an array
REM of object pointers. Data can be accessed using offsets just
REM like all the others. Every call to this event advances the
REM animation by one frame and then handles display & collision
REM detection for that frame before returning.
DEFPROCevnt_fr_rackfire
LOCAL i%,j%,mt%,pcsinv%,pcsbnk%
REM Assign meaningful names to object specific flags.
pcsinv%=52:pcsbnk%=56
REM Loop through all invader missile slots...
FOR i%=1 TO gamestate%!pcsinv%
IF NOT invfire%(i%)!active% THEN
PROCinvfire_create(i%) :REM Create a missile.
ELSE
PROCinvfire_animate(i%) :REM Animate and move down.
REM Collision Detection...
REM One of three events can happen here. Either we hit the
REM bottom of the playfield, the player's base, or a shell
REM hits us on the way up.
REM Have we reached the bottom??
IF invfire%(i%)!ypos%<=rail%!baserail%+(rail%!ysize%+5) THEN
invfire%(i%)!active%=FALSE:PROCwipe_sprite(invfire%(i%))
ENDIF
REM Have we hit the player's base??
IF FNhit(invfire%(i%),base%) AND invfire%(i%)!active% THEN
PROCinvfire_hitbase(i%)
ENDIF
REM Have we hit a bunker??
REM Currently just remove the missile. Replace this bit when
REM we've worked out how to do a proper collision detection on
REM it.
FOR j%=1 TO gamestate%!pcsbnk%
IF FNhit(invfire%(i%),bunker%(j%)) THEN
PROCbunk_beenhit(j%,FALSE)
PROCwipe_sprite(invfire%(i%)):invfire%(i%)!active%=FALSE
ENDIF
NEXT j%
REM Has a shell hit us??
IF FNhit(shell%,invfire%(i%)) THEN
PROCinvfire_beenhit(i%)
ENDIF
REM Explosion frame...
IF invfire%(i%)!beenhit% THEN
PROCinvfire_explode(i%)
ENDIF
ENDIF
NEXT i%
ENDPROC
REM Handle the pause status and update the HUD...
REM Text display is carried out by a HUD routine. We need to check
REM and fire it here only...
DEFPROCevnt_fr_pausegame
LOCAL paused%,pstatus%,ptime%,mt%,string$
paused%=28:pstatus%=32:ptime%=36 :REM Object offsets.
SYS FNswi_get(6) TO mt%
IF mt%-gamestate%!ptime%>=50 THEN
gamestate%!pstatus%=FNtoggle(gamestate%!pstatus%)
gamestate%!ptime%=mt%
ENDIF
string$=FNstring_get(49)+" "+FNstring_get(61) :REM "GAME PAUSED"
IF gamestate%!pstatus%=0 OR gamestate%!paused%=0 THEN
string$=STRING$(LEN(string$)," ")
ENDIF
PROChud_bannertext(string$)
ENDPROC
REM Handle the extra life text status and update the HUD...
REM This routine is fired if player%!elcount% is zero or greater.
REM When our count (player%!elcount%) gets above 5, we set it to
REM -1... It is then triggered in the scoring routine when an
REM extra life condition occurs by setting our count to 0. Our
REM current state (either blink on, or blink off) is held as 1 or
REM 0 in player%!elframe%.
DEFPROCevnt_fr_extralife
LOCAL elcount%,elframe%,eltime%,mt%,string$
elcount%=16:elframe%=20:eltime%=24 :REM Object offsets.
IF gamestate%!elcount%>=0 THEN
SYS FNswi_get(6) TO mt%
string$=FNstring_get(66)+" "+FNstring_get(72) :REM "EXTRA LIFE"
IF mt%-gamestate%!eltime%>=50 THEN
gamestate%!eltime%=mt%
gamestate%!elframe%=FNtoggle(gamestate%!elframe%)
IF gamestate%!elframe%=1 THEN gamestate%!elcount%+=1
ENDIF
REM Are we in blink off state??
IF gamestate%!elframe%=0 THEN
string$=STRING$(LEN(string$)," ") :REM Clear the line...
ENDIF
REM Have we blinked 5 times??
IF gamestate%!elcount%>5 THEN
string$=STRING$(LEN(string$)," ") :REM Clear the line...
gamestate%!elcount%=-1 :REM Disable event...
ENDIF
PROChud_bannertext(string$) :REM Update the HUD...
ENDIF
ENDPROC
REM Deal with the bunkers...
REM Currently we destroy the bunker after a combination of 10
REM hits by either the player or the invaders. Each time a bunker
REM is hit, we bump it up or down by an offset of 5px accordingly.
REM this is a temporary nudge like effect which returns the
REM bunker to it's rightful place shortly afterwards.
DEFPROCevnt_fr_bunkers
LOCAL i%,mt%,pcs%,timer%,blk%
pcs%=56:timer%=flags2% :REM Object offsets.
blk%=FNash_claim(16) :REM Temp bunker object.
FOR i%=1 TO gamestate%!pcs% :REM Loop through each bunker.
IF FNhit(shell%,bunker%(i%)) THEN
PROCwipe_sprite(shell%):shell%!active%=FALSE
PROCbunk_beenhit(i%,TRUE)
ENDIF
IF bunker%(i%)!beenhit% THEN
SYSFNswi_get(6) TO mt%
IF mt%-bunker%(i%)!timer%>=5 THEN
blk%!xpos%=bunker%(i%)!xpos%:blk%!xsize%=bunker%(i%)!xsize%
blk%!ypos%=bunker%(i%)!ypos%-5
blk%!ysize%=bunker%(i%)!ysize%+10:PROCwipe_sprite(blk%)
PROCplot(FNsprite_get(16),bunker%(i%)!xpos%,bunker%(i%)!ypos%)
bunker%(i%)!beenhit%=FALSE
ENDIF
ENDIF
NEXT i%
PROCash_free(blk%)
ENDPROC
REM *************************************************************
REM Functions & Proceedures. (HiScore Table/HiScore Entry.)
REM *************************************************************
REM Create a clean HiScore table. The value passed to us in save%
REM determines whether we can save the table to disc or not. If
REM we can (save%=TRUE) then we call PROChitable_save to write the
REM file back.
DEFPROChitable_create(save%)
LOCAL i%,n$
FOR i%=1 TO 10
IF i% MOD 2=0 THEN n$=FNstring_get(71) ELSE n$=FNstring_get(70)
scores_name$(i%)=FNencode_string(n$)
scores_value%(i%)=(11-i%)*1000:scores_rack%(i%)=0
NEXT i%
IF save% THEN PROChitable_save
ENDPROC
REM Load our HiTable from disc. The names are stored in RAM in
REM encoded form and are only decoded for display.
DEFPROChitable_load
LOCAL i%,hdl%
hdl%=OPENIN(dat_dir$+"HiTable")
FOR i%=1 TO 10
INPUT#hdl%,scores_name$(i%),scores_value%(i%),scores_rack%(i%)
NEXT i%
CLOSE#hdl%
ENDPROC
REM Save our HiTable back to disc. The names are stored in RAM in
REM encoded form and are only decoded for display.
DEFPROChitable_save
LOCAL i%,hdl%
hdl%=OPENOUT(dat_dir$+"HiTable")
FOR i%=1 TO 10
PRINT#hdl%,scores_name$(i%),scores_value%(i%),scores_rack%(i%)
NEXT i%
CLOSE#hdl%
ENDPROC
REM HiScore name entry...
REM Sort through our hiscore array and find out where the player
REM is. (We already know he is worthy.) Allow to enter their name
REM and save the HiTable back to disk (Only if scores_save%=TRUE).
REM then return...
DEFPROChitable_entry(player%)
LOCAL invt%,space%,done%,g%,i%,pos%,str%,x%,y%,string$
LOCAL scores_save%
space%=FNash_claim(16) :REM Space for objects.
invt%=FNash_claim(16)
scores_save%=44 :REM gamestate% object offs.
REM Setup graphical objects for later on...
space%!xsize%=FNconv_units(100,1) :REM Space text properties.
space%!ysize%=FNconv_units(40,2)
space%!xpos%=FNcentre_sprite(space%,screen%)
space%!ypos%=800
invt%!xsize%=FNconv_units(150,1) :REM Invaders text properties.
invt%!ysize%=FNconv_units(40,2)
invt%!xpos%=FNcentre_sprite(invt%,screen%)
invt%!ypos%=space%!ypos%-invt%!ysize%
REM Find out where we are and stick it in pos%
pos%=0
FOR i%=10 TO 1 STEP -1
IF player%!score%>=scores_value%(i%) THEN pos%=i%
NEXT i%
REM Insert a new entry into the table and drop everything below
REM us by one place... (We are 5th, so old 5th becomes 6th... 9th
REM becomes 10th and 10th gets dropped.) We need to do this to
REM all three arrays...
FOR i%=9 TO pos% STEP -1
scores_name$(i%+1)=scores_name$(i%)
scores_value%(i%+1)=scores_value%(i%)
scores_rack%(i%+1)=scores_rack%(i%)
NEXT i%
REM Insert Player's achieved score & rack into the table...
scores_value%(pos%)=player%!score%
scores_rack%(pos%)=player%!racknum%
REM Now deal with the graphics...
REM Produce our basic Space Invaders layout a la title sequence.
CLS:PROCdraw_rail(rail%!toprail%):PROCdraw_rail(rail%!baserail%)
PROCplot(FNsprite_get(100),space%!xpos%,space%!ypos%)
PROCplot(FNsprite_get(101),invt%!xpos%,invt%!ypos%)
REM Build and display the text.
string$=FNstring_get(54)+" "+STR$(player%!score%)
string$+=" "+FNstring_get(55)+" "+STR$(pos%)+FNsuffix(pos%)
str%=LEN(string$)*screen%!xfont%
x%=FNcentre_text(str%,screen%!xsize%):y%=invt%!ypos%-170
PROCprint(x%,y%,string$,0)
REM Free memory used by objects.
PROCash_free(space%):PROCash_free(invt%)
REM Create and display a box...
box%!xsize%=165:box%!ysize%=40
box%=FNcentre_sprite_xy(box%,screen%):PROCdraw_box(box%)
REM Handle player input...
REM Code 13 is Return/Enter. Code 8 is BackSpace. All other codes
REM are filtered with FNvalid() before being added to string$
REM to prevent the program breaking when we can't find a graphic.
x%=box%!xpos%+20:y%=box%!ypos%+12:string$="":i%=1:done%=FALSE
OSCLI"FX 21,0" :REM Flush Keyboard buffer...
REPEAT
g%=GET :REM Get a char from Keyboard.
REM Validate input...
REM Only allow character input if our string length is less
REM than 8 characters. Only accept Enter or Backspace for the
REM 9th character.
CASE g% OF
WHEN 13 :done%=TRUE
WHEN 8 :i%-=1:string$=LEFT$(string$,i%-1)
OTHERWISE :IF i%<9 AND FNvalid(g%) THEN i%+=1:string$+=CHR$(g%)
ENDCASE
REM Update Display...
REM Var i% will be less than 1 if the first character pressed
REM was backspace. We need to trap that and make it 1. We also
REM clear the input field before we re-display string$... This
REM is so that when Backspace is pressed, the character is
REM actually removed from the screen as well as from the input.
REM (string$)
REM We also need to check if we are trying to display an empty
REM string, as our PROCprint() will fall over. This occurs if
REM the first key typed was BackSpace or a character we can't
REM display. (In the case of the latter, it is not added to
REM string$, but we still come down here to update the display.)
IF i%<1 THEN i%=1
PROCprint(x%,y%,STRING$(8," "),0)
IF string$<>"" THEN PROCprint(x%,y%,string$,0)
UNTIL done%
REM Add player's name to entry already prepared earlier and save
REM if we can... (scores_save%=TRUE)
IF string$="" OR string$=" " THEN string$=FNstring_get(56)
scores_name$(pos%)=FNencode_string(string$)
IF gamestate%!scores_save% THEN PROChitable_save
ENDPROC
REM Have we got the ability to display this character?
REM Return TRUE if we can or FALSE if we can't
DEFFNvalid(chr%)
LOCAL out%
out%=FALSE
IF chr%>=32 AND chr%<=126 THEN out%=TRUE
=out%
REM *************************************************************
REM Functions & Proceedures (HUD & Scoring)
REM *************************************************************
REM Initialise the HUD display...
DEFPROChud_init(sc%,hi%,l%,r%)
LOCAL x%,string$
string$=FNstring_get(57)+" "+FNstring_get(59)
string$+=FNstr_pad(STR$(sc%),10," ",TRUE)
PROCprint(0,screen%!ysize%-screen%!yfont%,string$,0)
string$=FNstring_get(58)+" "+FNstring_get(57)
string$+=" "+FNstring_get(59)+FNstr_pad(STR$(hi%),10," ",TRUE)
x%=screen%!xsize%-LEN(string$)*screen%!xfont%
PROCprint(x%,screen%!ysize%-screen%!yfont%,string$,0)
PROChud_lives(l%):PROChud_rack(r%):PROChud_soundstate
ENDPROC
REM Update HUD lives display...
DEFPROChud_lives(num%)
LOCAL string$
PROCplot(FNsprite_get(1),0,0):string$=" = "+STR$(num%)
PROCprint(base%!xsize%,0,string$,0)
ENDPROC
REM Update HUD rack display...
DEFPROChud_rack(num%)
LOCAL x%,string$
string$=FNstring_get(60)+" "+FNstring_get(59)
string$+=FNstr_pad(STR$(num%),3,"0",TRUE)
x%=screen%!xsize%-LEN(string$)*screen%!xfont%
PROCprint(x%,0,string$,0)
ENDPROC
REM HUD banner text display routine...
REM This is called by the Pause Game & Extra Life event refresh
REM handlers at the moment and possibly others in the future.
DEFPROChud_bannertext(string$)
LOCAL x%,y%,str%
str%=LEN(string$)*screen%!xfont%
x%=FNcentre_text(str%,screen%!xsize%)
y%=screen%!ysize%-screen%!yfont%
PROCprint(x%,y%,string$,0)
ENDPROC
REM Score a hit...
REM The first part updates the score display on the top left
REM corner of the HUD. If the player's current score is greater
REM than that of the top spot, this value is also reflected in the
REM Hi Score display in the top right. For every 5k points the
REM player scores, he/she gains an extra base. We check this and
REM increment here too.
DEFPROChud_scorehit(value%)
LOCAL elscore%,elcount%,x%,string$
elscore%=12:elcount%=16 :REM Object offsets.
player%!score%+=value%
string$=FNstring_get(57)+" "+FNstring_get(59)
string$+=FNstr_pad(STR$(player%!score%),10," ",TRUE)
PROCprint(0,screen%!ysize%-screen%!yfont%,string$,0)
IF player%!score%-gamestate%!elscore%>=5000 THEN
player%!lives%+=1:PROChud_lives(player%!lives%)
gamestate%!elscore%=player%!score%:gamestate%!elcount%=0
ENDIF
IF player%!score%>scores_value%(1) THEN
string$=FNstring_get(58)+" "+FNstring_get(57)+" "
string$+=FNstring_get(59)
string$+=FNstr_pad(STR$(player%!score%),10," ",TRUE)
x%=screen%!xsize%-LEN(string$)*screen%!xfont%
PROCprint(x%,screen%!ysize%-screen%!yfont%,string$,0)
ENDIF
ENDPROC
REM Display sound status...
REM Displays one of three icons in the HUD area depending on the
REM current sound status. The placement of this needs to make
REM sense during both game and attract modes.
DEFPROChud_soundstate
LOCAL status%,snd%,fr$
snd%=FNash_claim(16) :REM Claim space for image block.
status%=0 :REM Object offsets. (gamestate%)
snd%!xsize%=FNconv_units(20,1):snd%!ysize%=FNconv_units(10,2)
snd%!xpos%=FNcentre_sprite(snd%,screen%):snd%!ypos%=0
REM Trap invalid sound state.
REM by the time this is called, our status flag should be setup
REM to something meaningful. Just in case it isn't, we sanity
REM check it here.
IF gamestate%!status%<0 OR gamestate%!status%>2 THEN
ERROR255,FNstring_get(111)+" "+STR$(gamestate%!status%)
ENDIF
REM Update display and free ASH block.
fr$=FNsprite_get(120+gamestate%!status%)
PROCplot(fr$,snd%!xpos%,snd%!ypos%):PROCash_free(snd%)
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Rack & Invaders)
REM *************************************************************
REM Cold initialisation...
REM Called directly by PROCmain once at the beginning of each
REM game to initialise the first wave...
DEFPROCrack_gameinit
LOCAL frame%,scol%,ecol%,rownum%
frame%=flags1%:scol%=flags5%:ecol%=flags6%:rownum%=flags7%
PROCrack_init:PROCrack_redraw
ENDPROC
REM Initialise a rack of invaders...
REM This is called at the beginning of the game and whenever
REM rack%!beenhit%=rack%!xnum%*rack%!ynum% (All invaders hit.)
REM to produce the next wave of the invasion force... We hold the
REM status of each invader in the invstat%() array...
REM Value Significance
REM ========================
REM -n Just been hit.
REM 0 Dead and buried.
REM >0 Current graphic.
DEFPROCrack_init
LOCAL col%,row%,s%
REM Rack properties...
REM These are set here as they have to be reset at the beginning
REM of each wave.
rack%!xpos%=50:rack%!ypos%=550:rack%!frame%=0:rack%!beenhit%=0
rack%!speed%=3:rack%!dir%=rack%!speed%:rack%!scol%=1
rack%!ecol%=rack%!xnum%:rack%!rownum%=1
REM Use s% as a temporary to avoid problems with line length in
REM !Zap edit window.
s%=(rack%!xnum%*inv%!xsize%)+((rack%!xnum%-1)*rack%!colgap%)
rack%!xsize%=s%:rack%!ysize%=rack%!ynum%*inv%!ysize%
REM Initialise invaders status.
FOR row%=1 TO rack%!xnum%
FOR col%=1 TO rack%!ynum%
invstat%(row%,col%)=((col%+1)/2)+(rack%!frame%*10)
NEXT col%
NEXT row%
ENDPROC
REM Redraw the whole rack of invaders at once.
DEFPROCrack_redraw
LOCAL col%,row%,x%,y%,blk%:blk%=FNash_claim(16)
FOR row%=rack%!scol% TO rack%!ecol%
x%=rack%!xpos%+((row%-1)*(inv%!xsize%+rack%!colgap%))
FOR col%=rack%!rownum% TO rack%!ynum%
y%=rack%!ypos%+((col%-1)*inv%!ysize%)
IF invstat%(row%,col%)>0 THEN
invstat%(row%,col%)=((col%+1)/2)+(rack%!frame%*10)
ENDIF
IF invstat%(row%,col%)<>0 THEN
CASE SGN(invstat%(row%,col%)) OF
WHEN -1 : PROCrack_checkinv(x%,y%,row%,col%)
WHEN 1 : PROCplot(FNsprite_get(27)+STR$(invstat%(row%,col%)),x%,y%)
ENDCASE
ELSE
blk%!xpos%=x%:blk%!ypos%=y%:blk%!xsize%=inv%!xsize%
blk%!ysize%=inv%!ysize%:PROCwipe_sprite(blk%)
ENDIF
NEXT col%
NEXT row%
PROCash_free(blk%)
ENDPROC
REM We start our explosion at -5. Every time we redraw an invader
REM we add to the count until zero is reached. When this happens
REM we wipe the sprite by creating a temporary object and passing
REM it to PROCwipe_sprite() in the normal way.
REM +----+--------------------------+
REM | x% | Physical X co-ordinate. |
REM | y% | Physical Y co-ordinate. |
REM | r% | Row index into array. |
REM | c% | Column index into array. |
REM +----+--------------------------+
DEFPROCrack_checkinv(x%,y%,r%,c%)
LOCAL blk%
invstat%(r%,c%)+=1:PROCplot(FNsprite_get(26),x%,y%)
IF invstat%(r%,c%)=0 THEN
blk%=FNash_claim(16):blk%!xpos%=x%:blk%!ypos%=y%
blk%!xsize%=inv%!xsize%:blk%!ysize%=inv%!ysize%
PROCwipe_sprite(blk%):PROCash_free(blk%)
ENDIF
ENDPROC
REM Advance rack down by one row...
REM Object blk% hovers above the top row of invaders to allow me a
REM quick use of PROCwipe_sprite() to remove the old top row. We
REM drop a row by dropping 1/3 of a row three times to lessen the
REM "jump". The original used to do something like this, but I'm
REM guessing this was down to the lack of CPU power rather than by
REM design.
DEFPROCrack_advance
LOCAL blk%,i%:blk%=FNash_claim(16)
FOR i%=1 TO 3
rack%!ypos%-=inv%!ysize%/3:PROCrack_redraw
NEXT i%
blk%!xpos%=rack%!xpos%
blk%!ypos%=rack%!ypos%+rack%!ysize%
blk%!xsize%=rack%!xsize%:blk%!ysize%=inv%!ysize%
PROCwipe_sprite(blk%):PROCash_free(blk%)
ENDPROC
REM End game...
REM We are called when the rack of invaders has reached the
REM player's base. Do a little animation before we return to the
REM Hiscore entry etc...
DEFPROCrack_endgame
LOCAL inv_left%,inv_right%,mt%,frtime%,alt%,speed%,i%,img$
speed%=1:inv_ext%=24
REM Reserve space...
inv_left%=FNash_claim(28):inv_right%=FNash_claim(28)
REM Clear any in-game debris from the screen. (Invaders, saucers
REM and other junk.)
PROCwipe_sprite(rack%):PROCwipe_sprite(base%)
IF shell%!active% THEN
PROCwipe_sprite(shell%):shell%!active%=FALSE
ENDIF
IF saucer%!active% THEN
PROCwipe_sprite(saucer%):saucer%!active%=FALSE
ENDIF
PROCinvfire_clearall:PROCbunk_clearall
REM Setup initial values.
base%!xpos%=FNcentre_sprite(base%,screen%)
inv_left%!xpos%=0-inv%!xsize% :REM Left invader properties.
inv_left%!ypos%=base%!ypos%
inv_left%!dir%=speed%
inv_right%!xpos%=screen%!xsize% :REM Right invader properties.
inv_right%!ypos%=base%!ypos%
inv_right%!dir%=0-speed%
REM Zero any remaining lives & update bottom of HUD...
player%!lives%=0:PROCdraw_rail(rail%!baserail%)
PROChud_lives(player%!lives%):PROChud_rack(player%!racknum%)
REM Hit it!!
REM Two invaders, one from each side, approach the base and blow
REM it up...
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%)
REM The approach...
frame%=0:alt%=FALSE
REPEAT
inv_left%!xpos%+=inv_left%!dir%
inv_left%!inv_ext%=inv_left%!xpos%+inv%!xsize%
inv_right%!xpos%+=inv_right%!dir%
SYS FNswi_get(6) TO mt% :REM OS_ReadMonotonicTime
IF mt%-frtime%>=50 THEN alt%=FNtoggle(alt%):frtime%=mt%
IF alt% THEN img$=FNsprite_get(21) ELSE img$=FNsprite_get(20)
PROCplot(img$,inv_left%!xpos%,inv_left%!ypos%)
PROCplot(img$,inv_right%!xpos%,inv_right%!ypos%)
PROCwait(2):WAIT
UNTIL inv_left%!inv_ext%>=base%!xpos%
REM The cheer...
FOR i%=1 TO 10
PROCplot(FNsprite_get(20),inv_left%!xpos%,inv_left%!ypos%)
PROCplot(FNsprite_get(20),inv_right%!xpos%,inv_right%!ypos%)
PROCwait(20)
PROCplot(FNsprite_get(21),inv_left%!xpos%,inv_left%!ypos%)
PROCplot(FNsprite_get(21),inv_right%!xpos%,inv_right%!ypos%)
PROCwait(20):WAIT
NEXT i%
REM The end...
PROCsfx_play(2)
FOR i%=1 TO 3
PROCplot(FNsprite_get(2)+STR$(i%),base%!xpos%,base%!ypos%)
PROCwait(20):WAIT
NEXT i%
PROCwait(20):PROCwipe_sprite(base%)
PROCash_free(inv_left%):PROCash_free(inv_right%)
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Invader Fire)
REM *************************************************************
REM Setup our array of invader missile objects...
REM Like everything else, sizes are supplied in pixels. These are
REM passed to FNconv_units() which converts them to OS Units. All
REM system calls expect these values as OS Units.
DEFPROCinvfire_init
LOCAL i%,hittime%,frtime%
hittime%=flags3%:frtime%=flags4% :REM Offsets.
FOR i%=1 TO 10
invfire%(i%)=FNash_claimfilled(48,0) :REM Claim memory.
invfire%(i%)!xsize%=FNconv_units(5,1) :REM Width (In px.)
invfire%(i%)!ysize%=FNconv_units(20,2) :REM Height (In px.)
SYS FNswi_get(6) TO invfire%(i%)!hittime% :REM Timer stores.
SYS FNswi_get(6) TO invfire%(i%)!frtime%
invfire%(i%)!active%=FALSE :REM Set inactive.
NEXT i%
ENDPROC
REM If we haven't already got an active missile in this slot
REM then we create one. The likelyhood of this happening is
REM a percentage chance based on the player's current level +5.
REM This is capped by a second call to FNpct(), the value of
REM which is initially 4. This value is incremented by 1 for
REM every 10 racks the player destroys.
REM Prop.. | Value | Comments.
REM -------+---------+--------------
REM type% | 1 or 2 | Missile type. (Type 1 can be hit.)
REM frame% | 0,1,2,3 | Current frame. (2 & 3 For type 2 only.)
REM Missile types are defined 75/25. Having a 75% chance of
REM being type 1. Speed for type 1 is 4 OS Units per frame, for
REM type 2, we half that.
DEFPROCinvfire_create(slot%)
LOCAL fpos%,firepos%,frate%,spd%,x%,y%
LOCAL frame%,type%
frame%=flags1%:type%=flags2% :REM Object properties.
fpos%=RND(10):frate%=player%!racknum%+5 :REM Other constants.
IF frate%>100 THEN
frate%=100
IF player%!racknum% MOD 10=0 THEN rack%!frcap%+=1
ENDIF
IF FNpct(frate%) AND FNpct(rack%!frcap%) THEN
IF invstat%(fpos%,rack%!rownum%)>0 THEN
x%=rack%!xpos%+(fpos%-1)*(inv%!xsize%+rack%!colgap%)
y%=rack%!ypos%+((rack%!rownum%-1)*inv%!ysize%)-inv%!ysize%
firepos%=(inv%!xsize%/2)-(invfire%(slot%)!xsize%/2)
invfire%(slot%)!xpos%=x%+firepos%
invfire%(slot%)!ypos%=y%
invfire%(slot%)!active%=TRUE:invfire%(slot%)!beenhit%=FALSE
invfire%(slot%)!type%=1:invfire%(slot%)!frame%=0:spd%=4
IF FNpct(25) THEN invfire%(slot%)!type%=2:spd%=spd%/2
invfire%(slot%)!speed%=spd%
invfire%(slot%)!dir%=invfire%(slot%)!speed%
PROCsfx_play(3)
ENDIF
ENDIF
ENDPROC
REM Continue animating down the screen...
REM Handle the image swapping (for the animation) and the
REM position of the currently selected invader missile.
DEFPROCinvfire_animate(slot%)
LOCAL mt%,frame%,frtime%,type%,fr$,fr2$
REM Assign meaningful names to object specific flags.
frame%=flags1%:type%=flags2%:frtime%=flags4%
SYS FNswi_get(6) TO mt% :REM Handle the timer...
IF mt%-invfire%(slot%)!frtime%>=40 THEN
invfire%(slot%)!frtime%=mt%
invfire%(slot%)!frame%+=1
ENDIF
:REM Limit frame counter...
IF invfire%(slot%)!type%=1 AND invfire%(slot%)!frame%>1 THEN
invfire%(i%)!frame%=0
ENDIF
IF invfire%(slot%)!type%=2 AND invfire%(slot%)!frame%>3 THEN
invfire%(slot%)!frame%=0
ENDIF
fr2$=STR$(invfire%(slot%)!frame%) :REM Prepare frame...
IF invfire%(slot%)!type%=2 AND invfire%(slot%)!frame%=3 THEN
fr2$="1"
ENDIF
fr$=FNsprite_get(30)+STR$(invfire%(slot%)!type%)+fr2$
REM Display frame...
REM Only advance and display prepared frame if we haven't
REM already been hit, otherwise we just display the explosion.
IF NOT invfire%(slot%)!beenhit% THEN
invfire%(slot%)!ypos%-=invfire%(slot%)!dir%
PROCplot(fr$,invfire%(slot%)!xpos%,invfire%(slot%)!ypos%)
ELSE
fr$=FNsprite_get(30)+"3"
PROCplot(fr$,invfire%(slot%)!xpos%,invfire%(slot%)!ypos%)
ENDIF
ENDPROC
REM Missile has hit the player's base...
DEFPROCinvfire_hitbase(slot%)
LOCAL i%
PROCsfx_play(2)
FOR i%=1 TO 3
PROCplot(FNsprite_get(2)+STR$(i%),base%!xpos%,base%!ypos%)
PROCwait(20):WAIT
NEXT i%
PROCwipe_sprite(base%)
IF shell%!active% THEN
PROCwipe_sprite(shell%):shell%!active%=FALSE
ENDIF
base%!xpos%=FNcentre_sprite(base%,screen%)
player%!lives%-=1:PROChud_lives(player%!lives%)
PROCwipe_sprite(invfire%(slot%)):invfire%(slot%)!active%=FALSE
PROCplot(FNsprite_get(1),base%!xpos%,base%!ypos%)
ENDPROC
REM We've been hit by a player's shell...
DEFPROCinvfire_beenhit(slot%)
LOCAL type%,hittime%
type%=flags2%:hittime%=flags3% :REM Object offsets.
IF invfire%(slot%)!type%=1 THEN
IF NOT invfire%(slot%)!beenhit% THEN
invfire%(slot%)!beenhit%=TRUE:PROChud_scorehit(5)
fr$=FNsprite_get(30)+"3"
PROCplot(fr$,invfire%(slot%)!xpos%,invfire%(slot%)!ypos%)
SYS FNswi_get(6) TO invfire%(slot%)!hittime%
ENDIF
ENDIF
PROCwipe_sprite(shell%):shell%!active%=FALSE
ENDPROC
REM We have been destroyed...
DEFPROCinvfire_explode(slot%)
LOCAL hittime%,mt%
hittime%=flags3% :REM Object offsets.
SYS FNswi_get(6) TO mt%
IF mt%-invfire%(slot%)!hittime%>=40 THEN
PROCwipe_sprite(invfire%(slot%))
invfire%(slot%)!active%=FALSE
ENDIF
ENDPROC
REM Clear all invader missiles off the screen...
REM Used by PROCrack_endgame in preparation for the animation.
DEFPROCinvfire_clearall
LOCAL i%,items%:items%=52
FOR i%=1 TO gamestate%!items%
IF invfire%(i%)!active% THEN
PROCwipe_sprite(invfire%(i%)):invfire%(i%)!active%=FALSE
ENDIF
NEXT i%
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Bunkers)
REM *************************************************************
REM Setup an arbitary number of bunkers...
REM This allocates memory and performs the calculations required
REM to convert from pixels to OS Units to give us the correct
REM sizes for all further display & collision detection etc...
REM Bunker positions are calculated using the following formula...
REM x=(s/n)+((c-1)*(s/n)) -> Gives us the position of the current
REM bunker. Where x = X Co-ordinate.
REM s = Screen width.
REM n = Number of bunkers.
REM c = Current bunker.
DEFPROCbunk_init
LOCAL i%,x%,gap%,hitcount%,num%
num%=gamestate%!56 :REM Number of bunkers.
hitcount%=flags1% :REM Object offsets.
gap%=screen%!xsize%/num% :REM Gap between bunkers.
x%=gap%-150 :REM Left bunker pos.
FOR i%=1 TO num%
bunker%(i%)=FNash_claimfilled(48,0) :REM Claim memory.
bunker%(i%)!xsize%=FNconv_units(30,1) :REM Width (In px.)
bunker%(i%)!ysize%=FNconv_units(15,2) :REM Height (In px.)
bunker%(i%)!xpos%=x%+((i%-1)*gap%) :REM Position (X)
bunker%(i%)!ypos%=base%!ypos%+100 :REM Position (Y)
bunker%(i%)!active%=TRUE :REM Set active.
bunker%(i%)!hitcount%=0 :REM Hit counter.
NEXT i%
ENDPROC
REM Reset all bunkers to active state...
REM Perform a quick init. We already know where everything goes,
REM we just need to get them all in a known condition.
DEFPROCbunk_reset
LOCAL i%,hitcount%,num%
num%=gamestate%!56 :REM Number of bunkers.
hitcount%=flags1% :REM Object offsets.
FOR i%=1 TO num%
bunker%(i%)!active%=TRUE :REM Set active.
bunker%(i%)!hitcount%=0 :REM Reset hit counter.
NEXT i%
ENDPROC
REM Redraw all active bunkers...
REM Does much the same as PROCbunk_init, but without all the setup
REM as we already know where everything is.
DEFPROCbunk_redraw
LOCAL i%,num%
num%=gamestate%!56 :REM Number of bunkers.
FOR i%=1 TO num%
IF bunker%(i%)!active% THEN
PROCplot(FNsprite_get(16),bunker%(i%)!xpos%,bunker%(i%)!ypos%)
ENDIF
NEXT i%
ENDPROC
REM Bunker collision detection...
REM Both invader fire and player fire handlers call this routine
REM if they detect a collision with a bunker. Bunkers can be hit
REM 10 times by either invader fire or player's shots before they
REM disappear until the beginning of the next rack. Var by% is
REM TRUE if hit by player or FALSE otherwise.
DEFPROCbunk_beenhit(slot%,by%)
LOCAL y%,hitcount%
hitcount%=flags1%:timer%=flags2% :REM Object offsets.
bunker%(slot%)!hitcount%+=1 :REM Increment hit counter.
IF bunker%(slot%)!hitcount%>=10 THEN
PROCwipe_sprite(bunker%(slot%)):bunker%(slot%)!active%=FALSE
ELSE
y%=bunker%(slot%)!ypos%
IF by% THEN y%+=5 ELSE y%-=5 :REM Move up or down on hit.
PROCwipe_sprite(bunker%(slot%))
PROCplot(FNsprite_get(16),bunker%(slot%)!xpos%,y%)
bunker%(slot%)!beenhit%=TRUE
SYSFNswi_get(6) TO bunker%(slot%)!timer%
ENDIF
ENDPROC
REM Clear all bunkers off the screen...
REM Used by PROCrack_endgame in preparation for the animation.
DEFPROCbunk_clearall
LOCAL i%,blk%,num%
num%=gamestate%!56
FOR i%=1 TO num%:bunker%(i%)!active%=FALSE:NEXT i%
blk%=FNash_claim(16):blk%!xpos%=0:blk%!ypos%=bunker%(1)!xpos%
blk%!xsize%=screen%!xsize%:blk%!ysize%=bunker%(1)!ysize%
PROCwipe_sprite(blk%):PROCash_free(blk%)
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Core Graphics Routines)
REM *************************************************************
REM Load a gfx file...
REM Doing it this way allows us to use two different buffers, one
REM for the sprites and the other for the charset.
DEFFNgfx_load(filespec$)
LOCAL area%,size%
size%=FNfs_filesize(filespec$)+256 :REM Find filesize.
area%=FNash_claim(size%) :REM Reserve space.
!area%=size%:area%!4=0:area%!8=16:area%!12=16 :REM Set pointers.
REM Load Graphics into our reserved space...
SYS gfx_spriteop%, 256+10, area%, filespec$ :REM Load file.
SYS gfx_spriteop%, 256+17, area% :REM Verify data.
=area%
REM Display a string character by character with a delay between
REM each one. Each character is indexed to the 8*8 character set
REM sprites using ASCII codes.
DEFPROCprint(x%,y%,string$,char_delay%)
LOCAL i%,chsize%
gfx_area%=gfx_fontpool% :REM Switch to our charset.
chsize%=screen%!xfont%
FOR i%=1 TO LEN(string$)
PROCplot(STR$(ASC(MID$(string$,i%,1))),x%+((i%-1)*chsize%),y%)
IF char_delay%>0 THEN PROCwait(char_delay%)
NEXT i%
gfx_area%=gfx_spritepool% :REM Switch back...
ENDPROC
REM Display a given image. Modified to use a local sprite area &
REM system calls to speed things up dramatically. (02/01/08)
REM sprite$ = Name of image to display.
REM x% = X Co-ordinate.
REM y% = Y Co-ordinate.
DEFPROCplot(sprite$,x%,y%)
LOCAL address%
SYS gfx_spriteop%, 256+24, gfx_area%, sprite$ TO ,, address%
SYS gfx_spriteop%, 512+34, gfx_area%, address%, x%, y%, 0
ENDPROC
REM Clear a sprite from the screen. (New method.)
REM Before we created an identical bitmap in the sprite file
REM and displayed this over our image. This should be faster, and
REM result in a smaller sprite file.
DEFPROCwipe_sprite(obj%)
GCOL0,0 TINT0
RECTANGLE FILLobj%!xpos%,obj%!ypos%,obj%!xsize%,obj%!ysize%
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Text & Graphics Alignment.)
REM *************************************************************
REM Centre text horizontally...
REM Where string_length% is the length of the string in multiples
REM of OS Units, where each multiple is the width of a character.
REM Var screen% is the screen width.
REM width...
DEFFNcentre_text(string_length%,screen%)
=(screen%/2)-(string_length%/2)
REM Centre text horizontally & vertically.
DEFPROCcentre_text_xy(string$,delay%)
LOCAL str%,y%
str%=LEN(string$)*screen%!xfont%
y%=(screen%!ysize%/2)-(screen%!yfont%/2)
PROCprint(FNcentre_text(str%,screen%!xsize%),y%,string$,delay%)
ENDPROC
REM Centre sprite horizontally...
REM Takes the two "object" blocks as parameters and extracts the
REM required values from them. Then returns the centre position.
DEFFNcentre_sprite(object%,relative%)
=(relative%!xsize%/2)-(object%!xsize%/2)
REM Centre sprite horizontally & vertically.
REM Returns the new position at offsets xpos% & ypos% in object%.
DEFFNcentre_sprite_xy(object%,relative%)
LOCAL x%,y%
object%!xpos%=(relative%!xsize%/2)-(object%!xsize%/2)
object%!ypos%=(relative%!ysize%/2)-(object%!ysize%/2)
=object%
REM *************************************************************
REM Functions & Proceedures (Graphical Boxes & Lines.)
REM *************************************************************
REM Repeat a 6*6 image across the screen to produce a "rail" like
REM effect at position y%.
DEFPROCdraw_rail(ypos%)
LOCAL i%,reps%
reps%=screen%!xsize%/rail%!xsize%
FOR i%=1 TO reps%+1
PROCplot(FNsprite_get(108),(i%-1)*rail%!xsize%,ypos%)
NEXT i%
ENDPROC
REM Produce a box to surround text in GAME OVER!!! & GOODBYE!!!
REM texts. (Among others.)
DEFPROCdraw_box(obj%)
LOCAL x%,y%,cxsize%,cysize%,rxsize%,rysize%,i%
REM Setup...
cxsize%=FNconv_units(3,1):cysize%=FNconv_units(3,2)
rxsize%=1:rysize%=3
REM The top & bottom...
FOR i%=1 TO obj%!xsize%
x%=obj%!xpos%+((i%-1)*rxsize%)
PROCplot(FNsprite_get(113),x%,obj%!ypos%)
PROCplot(FNsprite_get(113),x%,obj%!ypos%+(obj%!ysize%-(2*rysize%)))
NEXT i%
REM The two sides...
x%=obj%!xpos%+(obj%!xsize%-cxsize%)
FOR i%=1 TO obj%!ysize%-1
PROCplot(FNsprite_get(114),obj%!xpos%,obj%!ypos%+((i%-1)*rxsize%))
PROCplot(FNsprite_get(114),x%,obj%!ypos%+((i%-1)*rxsize%))
NEXT i%
REM The four corners...
PROCplot(FNsprite_get(111),obj%!xpos%,obj%!ypos%)
PROCplot(FNsprite_get(109),obj%!xpos%,(obj%!ypos%+obj%!ysize%)-cysize%)
PROCplot(FNsprite_get(112),obj%!xpos%+(obj%!xsize%-cxsize%),obj%!ypos%)
x%=(obj%!xpos%+obj%!xsize%)-cxsize%
y%=(obj%!ypos%+obj%!ysize%)-cysize%
PROCplot(FNsprite_get(110),x%,y%)
ENDPROC
REM *************************************************************
REM Functions & Proceedures (String & Text De-coding)
REM *************************************************************
REM These routines deal with our garbled strings. This is done
REM this way for a couple of reasons...
REM # BasCrunch output is smaller.
REM # BasCrunch ouptut is harder to reverse engineer.
REM Get number of messages in a processed file...
DEFFNstring_enumprocessed(filespec$,magic$)
LOCAL in_hdl%,count%,maggot$
in_hdl%=OPENIN(filespec$)
INPUT#in_hdl%,maggot$
IF maggot$<>magic$ THEN CLOSE#in_hdl%:ERROR 255,"Bad Magic!"
INPUT#in_hdl%,count%
CLOSE#in_hdl%
=count%
REM Load a file off disc and return messages setup in arrays.
DEFPROCstring_load(filespec$,magic$,RETURN nums%(),RETURN strs$())
LOCAL in_hdl%,i%,count%,maggot$
in_hdl%=OPENIN(filespec$)
INPUT#in_hdl%,maggot$
IF maggot$<>magic$ THEN CLOSE#in_hdl%:ERROR 255,"Bad Magic!"
INPUT#in_hdl%,count%
FOR i%=1 TO count%
INPUT#in_hdl%,nums%(i%),strs$(i%)
NEXT i%
CLOSE#in_hdl%
ENDPROC
REM The following functions are all identical, other than what is
REM actually searched. (The arrays are different.) So... To avoid
REM duplicating code, I've written a generic search routine with
REM three wrappers passing the correct values to the generic code.
REM Retrieve an encoded message for display... (Wrapper...)
DEFFNstring_get(msg%)
=FNcore_get(msg%,string_max%,string_num%(),string_msg$(),106)
REM Retrieve an encoded Sprite name... (Wrapper...)
DEFFNsprite_get(msg%)
=FNcore_get(msg%,ilut_max%,ilut_num%(),ilut_msg$(),107)
REM Retrieve an encoded SWI name... (Wrapper...)
DEFFNswi_get(msg%)
=FNcore_get(msg%,slut_max%,slut_num%(),slut_msg$(),108)
REM Generic core code for above get functions...
DEFFNcore_get(msg%,max%,num%(),str$(),msg_err%)
LOCAL i%,found%:found%=0
FOR i%=1 TO max%
IF num%(i%)=msg% THEN found%=i%:i%=max%
NEXT i%
IF found%=0 THEN
IF msg%>=106 AND msg%<=108 THEN
ERROR 255,"Missing message!!!"
ELSE
ERROR 255,FNstring_get(msg_err%)+" "+STR$(msg%)
ENDIF
ENDIF
=FNencode_string(str$(found%))
REM *************************************************************
REM Functions & Proceedures (Sound Sub-system OS call wrappers.)
REM *************************************************************
REM Load a song into memory and return a handle...
DEFFNtp_loadsong(filespec$)
LOCAL hdl%:hdl%=0
SYSFNswi_get(31),,filespec$ TO hdl%
=hdl%
REM Trigger one of a number of loaded sound effects...
REM The number passed in what% is the number of the sample to
REM play. We currently only have 4 sound effects numbered 1-4.
DEFPROCsfx_play(what%)
LOCAL status%,err$
status%=0:err$=FNstring_get(110)+" "+STR$(what%)
IF gamestate%!status%>0 THEN
IF what%<1 AND what%>4 THEN ERROR255,err$
OSCLI"SPlay_fire0"+STR$(what%)+"mhh"
ENDIF
ENDPROC
REM *************************************************************
REM Functions & Proceedures (Misc. Game Specific.)
REM *************************************************************
REM Get various information about screen resolution. This includes
REM viewing area and conversion factors. We cannot rely on fixed
REM values because they change from mode to mode. So grab the
REM current values from the OS and bung 'em into some variables.
DEFPROCget_screeninfo
LOCAL blk%
blk%=FNash_claim(20) :REM Reserve space for parameter block.
REM Setup parameter block...
blk%!0=4 :REM XEigFactor (Convert.)
blk%!4=5 :REM YEigFactor (Convert.)
blk%!8=11 :REM XWindLimit (Width.)
blk%!12=12 :REM YWindLimit (Height.)
blk%!16=-1 :REM Termination byte.
SYS FNswi_get(5), blk%, blk%:REM Call OS.
REM Setup our screen% object...
screen%!x_eig%=blk%!0 :REM X & Y EigFactor.
screen%!y_eig%=blk%!4
screen%!xsize%=(blk%!8)+1<<blk%!0 :REM Screen size.
screen%!ysize%=(blk%!12)+1<<blk%!4
screen%!setmode%=MODE
PROCash_free(blk%)
ENDPROC
REM Convert between pixels & OS Units. Our screen object has been
REM setup already using PROCget_screeninfo. However, if the
REM current value of MODE is different to that in screen%!setmode%
REM then the screen mode has changed, so call PROCget_screeninfo
REM again.
REM size% = Value to convert.
REM op% = What to do. 1 = Width (Pixels > OS Units)
REM 2 = Height (Pixels > OS Units)
REM 3 = Width (OS Units > Pixels)
REM 4 = Height (OS Units > Pixels)
REM Returns
REM conv% = Converted value.
DEFFNconv_units(size%,op%)
LOCAL conv%,mode%
REM Check to see if the screen mode has changed. If so, then
REM call PROCget_screeninfo to update the values. This is
REM probably overkill and can be omitted, but still good practice
REM for debugging.
mode%=MODE
IF mode%<>screen%!setmode% THEN PROCget_screeninfo
REM Do the conversion.
CASE op% OF
WHEN 1 : conv%=size%<<screen%!x_eig%
WHEN 2 : conv%=size%<<screen%!y_eig%
WHEN 3 : conv%=size%>>screen%!x_eig%
WHEN 4 : conv%=size%>>screen%!y_eig%
OTHERWISE
ERROR 255,FNstring_get(103)+" "+STR$(op%)
ENDCASE
=conv%
REM Collision detection. Takes two objects and returns TRUE if
REM one is inside or has hit the other, else returns FALSE. Vars
REM tx_ext% & ty_ext% hold the two far edges of the sprite. We
REM calculate these by adding the target object's size to it's
REM position each time we're called. We then use these values to
REM perform a bounds check, one for x (ix% is TRUE if in.) and
REM one for y (iy% is TRUE if in.). Finally... We return an
REM evaluation of ix% AND iy%.
DEFFNhit(obj%,targ%)
LOCAL tx_ext%,ty_ext%,ix%,iy%
ix%=FALSE:iy%=FALSE
IF obj%!active% AND targ%!active% THEN
tx_ext%=targ%!xpos%+targ%!xsize% :REM Right hand edge.
ty_ext%=targ%!ypos%+targ%!ysize% :REM Top edge.
IF obj%!xpos%>=targ%!xpos% AND obj%!xpos%<tx_ext% THEN ix%=TRUE
IF obj%!ypos%>=targ%!ypos% AND obj%!ypos%<ty_ext% THEN iy%=TRUE
ENDIF
=ix% AND iy%
REM Bail gracefully on error.
DEFPROCtrap_error
LOCAL m$
ON ERROR OFF
m$=" Panic!!!"
CASE ERR OF
WHEN 17 : m$="Program Terminated."
WHEN 254 : m$="ASH"+m$
WHEN 255 : m$="Game"+m$
OTHERWISE : m$="System"+m$
ENDCASE
PRINT:PRINT:PRINTm$:PRINT STRING$(LEN(m$),"=")
PRINT:REPORT:PRINT" at line : ";ERL
REM Tear down Sound Sub-system & Release memory.
IF gamestate%!4<>-1 THEN
SYS"TimPlayer_SongStop",gamestate%!4
SYS"TimPlayer_SongUnload",gamestate%!4
ENDIF
REM Tear down ASH Sub-system.
PROCash_destroy
ENDPROC
REM Display file info as we go... (Initialisation.)
DEFFNfind(fspec$,msg$)
LOCAL disp$,rc%,found%:found%=FALSE
disp$=STRING$(10," "):RIGHT$(disp$,3)=" : "
LEFT$(disp$,LEN(msg$))=msg$:rc%=FNfs_find(fspec$)
IF rc%=1 THEN
disp$+="OK.":found%=TRUE
ELSE
disp$+="Missing!!"
ENDIF
PRINTdisp$
=found%
REM Run through a counter checking names of files in the "Screens"
REM directory inside the application until we have a file not
REM found condition. Set the counter to this. This routine starts
REM from count% and stops at the first gap in a chain.
REM Because we fire it from PROCevnt_kb_screendump we effectively
REM handle any possible breakage in a chain of existing numbers
REM because it'll always find the next free slot. We continue to
REM count up until "Dump" and the number of digits in our count
REM exceed the ADFS file name limit (10 Chars.), at that point we
REM flag up an error by returning -1. This gives us a max count
REM of 999999. Chances are we'd exceed the max number of files
REM allowed in a directory before we'd ever hit this limit!!
DEFFNinit_setdumpcounter(count%)
LOCAL dump_name$,loc$
loc$="<Invaders$Dir>.Screens.":dump_name$="Dump"+STR$(count%)
IF FNfs_find(loc$+dump_name$)<>0 THEN
REPEAT
count%+=1
dump_name$="Dump"+STR$(count%)
UNTIL FNfs_find(loc$+dump_name$)=0 OR LEN(dump_name$)>10
IF LEN(dump_name$)>10 THEN count%=-1
ENDIF
=count%
REM *************************************************************
REM Functions & Proceedures (Generic & Portable Code)
REM *************************************************************
REM Returns TRUE n% percent of the time...
REM This is used all over the place, usually dictating the chances
REM of a particular event occuring, or as a bias for properties.
DEFFNpct(n%)
LOCAL rnd%
rnd%=RND(100)
=rnd%<=n%
REM Encode or decode a string using a simple XOR algo... This
REM prevents hackers from peeking at and modifying strings in
REM files. Strings are in reverse order in BASIC datafiles, but
REM are still in plaintext format.
REM string$ = String to mash up.
REM Returns
REM mashed$ = Mashed up string.
DEFFNencode_string(string$)
LOCAL i%,mashed$
FOR i%=1 TO LEN(string$)
mashed$+=CHR$(ASC(MID$(string$,i%,1)) EOR 131)
NEXT i%
=mashed$
REM Introduce a delay of n% hundredths of a second.
DEFPROCwait(n%)
LOCAL t%
t%=TIME+n%
REPEAT:UNTIL TIME>=t%
ENDPROC
REM Toggle a flag between 0 & 1.
DEFFNtoggle(n%)
=n% EOR 1
REM Returns a suffix (st, nd, rd etc...) when given a number. This
REM number can be any number of digits long, we just deal with the
REM last digit.
DEFFNsuffix(n%)
LOCAL out$,u%
u%=VAL(RIGHT$(STR$(n%),1))
out$=FNstring_get(65)
IF u%>=1 AND u%<=3 THEN out$=FNstring_get(u%+61)
=out$
REM ************************************************************
REM Functions & Proceedures (LibSTR)
REM ************************************************************
REM I've imported the following two routines from my string utils
REM library. Normally I'd just include them using the LIBRARY
REM command, but that would kill the cruncher, so I've dumped them
REM here...
REM Pad a string to len% characters by adding multiple copies of
REM char$ to it. If start% is set TRUE then we will add padding to
REM the start of the string, else we add it at the end. If longer
REM than len% characters, then chop it to len% characters.
DEFFNstr_pad(string$,len%,char$,start%)
LOCAL diff%,out$
diff%=len%-LEN(string$) :REM How many to add.
IF diff%<=0 THEN
out$=LEFT$(string$,len%)
ELSE
IF start% THEN
out$=STRING$(len%,char$):RIGHT$(out$,LEN(string$))=string$
ELSE
out$=string$+STRING$(diff%,char$)
ENDIF
ENDIF
=out$
REM Fix a string's length to len% characters and return it right
REM aligned...
DEFFNstr_rightalign(string$,len%)
LOCAL out$
out$=STRING$(len%," ")
RIGHT$(out$,LEN(string$))=string$
=out$
REM ************************************************************
REM Functions & Proceedures (LibFS)
REM ************************************************************
REM I've imported the following two routines from my fs utils
REM library. Normally I'd just include them using the LIBRARY
REM command, but that would kill the cruncher, so I've dumped them
REM here...
REM Check for the prescence of a filing system object at a given
REM location. I say object, as this can check for the existance of
REM directories as well as files.
REM Parameter block...
REM file$ = Filespec to check for in current directory.
REM ...On Exit.
REM found% = 0 Object not found.
REM = 1 Object is a file.
REM = 2 Object is a directory.
DEFFNfs_find(file$)
LOCAL found%
SYS"XOS_File",17,file$ TO found%
=found%
REM Return the size of a file. (In bytes.)
DEFFNfs_filesize(file$)
LOCAL size%
SYS FNswi_get(3),5,file$ TO ,,,,size%
=size%
REM Can we write to this file? Return TRUE or FALSE...
REM I really need to find a better way of doing this. The logic is
REM screwy and doesn't pick up on a write protected floppy. I'm
REM not sure if this is down to this part of the check, or the
REM logic further up which deals with the result from this code.
REM op%=0 -> File doesn't exist. Var file$ contains location.
REM op%=1 -> File exists. Can we write/replace it?
DEFFNfs_writeable(op%,file$)
LOCAL hdl%,flg%,flags%,result%
result%=FALSE
REM Attempt to open or create a file depending on our opcode.
CASE op% OF
WHEN 0 : hdl%=OPENUP(file$+"chkfile")
WHEN 1 : hdl%=OPENUP(file$)
OTHERWISE : ERROR 255,FNstring_get(104)+" "+STR$(op%)
ENDCASE
REM If we get this far and we still haven't got a valid file
REM handle then it's fairly safe to say that we're never gonna
REM get one, so skip the next bit and return FALSE.
IF hdl%<>0 THEN
SYS FNswi_get(4),254,hdl% TO flags%;flg%
IF (flg% AND 1) THEN CLOSE#hdl%:ERROR 255,FNstring_get(105)
IF ((flags% AND (1<<7))<>0) THEN result%=TRUE
CLOSE#hdl%
ENDIF
=result%
REM ************************************************************
REM Functions & Proceedures (Ash Heap manager for BASIC)
REM Copyright (c)2004 7th Software.
REM ************************************************************
REM Initialise ASH Subsystem...
DEFPROCash_init
LOCAL err%
ash_heap%=0:ash_total%=0
SYS FNswi_get(10), -1, -1 TO ash_slot%
SYS FNswi_get(11) TO ash_page% ; err%
IF err% AND 1 THEN ash_page%=16384
PROCash_create(ash_page%)
ENDPROC
REM Release the memory used for our heap
DEFPROCash_destroy
IF ash_heap% THEN
SYS FNswi_get(10), ash_heap%-&8000,-1 TO ash_slot%
ash_heap%=0:ash_total%=0
ENDIF
ENDPROC
REM Claim a block from the heap - generate an error if claim fails
REM Our block's size is now the requested size + 3 extra locations
REM @ 4 bytes per location + 3 extra bytes.
REM Offs | Significance.
REM --------+---------------
REM 0 | Low guard-word.
REM 4 | Block user area size in bytes.
REM 8 | User area base address. (This is what is returned.)
REM <bytes> | High guard-word.
DEFFNash_claim(bytes%)
LOCAL block%,size%
size%=(bytes%+15) AND &FFFFFFFC
block%=FNash_alloc(size%)
IF block% ELSE ERROR 254,FNstring_get(211)
block%!0=&DEADDEAD :REM Store low guard-word...
block%!4=bytes% :REM Store user area size...
!(block%-8+(block%!-4))=&DEADDEAD :REM Store high guard-word...
=block%+8
REM Claim a block of memory, as above, but fill it with a
REM specified value before returning.
DEFFNash_claimfilled(bytes%,value%)
LOCAL block%
block%=FNash_claim(bytes%) :REM Claim requested space...
PROCash_blockfill(block%,value%) :REM Fill with spec'd value...
=block%
REM Free a block into the heap
DEFPROCash_free(RETURN block%)
IF FNash_blockchecklow(block%) THEN ERROR 254,FNstring_get(212)
IF FNash_blockcheckhigh(block%) THEN ERROR 254,FNstring_get(213)
block%-=8:ash_total%-=block%!-4
SYS FNswi_get(12), 3, ash_heap%, block%
block% = 0
ENDPROC
REM Return the size (in bytes) of a specified block.
DEFFNash_blocksize(block%)
LOCAL blk%
blk%=block%-4
=blk%!0
REM Fill a block of memory with a specified value...
DEFPROCash_blockfill(block%,value%)
LOCAL offset%,size%
size%=FNash_blocksize(block%)
FOR offset%=0 TO size%-4 STEP 4
block%!offset%=value%
NEXT offset%
ENDPROC
REM Create a block with identical contents to the original.
DEFFNash_blockcopy(block%)
LOCAL copy%,offset%,size%
size%=FNash_blocksize(block%)
copy%=FNash_claim(size%)
FOR offset%=0 TO size%-4 STEP 4
copy%!offset%=block%!offset%
NEXT offset%
=copy%
REM Returns TRUE if the low guardword has been garbaged.
DEFFNash_blockchecklow(block%)
block%-=8
IF block%!0<>&DEADDEAD THEN =TRUE
=FALSE
REM Returns TRUE if the high guardword has been garbaged.
DEFFNash_blockcheckhigh(block%)
block%-=8
IF !(block%-8+(block%!-4))<>&DEADDEAD THEN =TRUE
=FALSE
REM *** LibASH Internals ***
REM Create a heap in the memory above HIMEM
DEFPROCash_create(size%)
IF ash_heap% THEN ERROR 254,FNstring_get(215)
size%=(size%+ash_page%-1) AND NOT (ash_page%-1)
ash_heap%=HIMEM
SYS FNswi_get(10), ash_slot% + size%, -1 TO ash_slot%
size%=ash_slot%+&8000-ash_heap%
IF size%<1 THEN
ash_heap%=0
ERROR 254,FNstring_get(216)
ELSE
SYS FNswi_get(12), 0, ash_heap%,, size%
ENDIF
ash_total%=0
ENDPROC
REM Attempt to add some more memory into the end of our heap
DEFPROCash_grow(bytes%)
LOCAL prev%
prev%=ash_slot%
SYS FNswi_get(10), ash_slot%+bytes%, -1 TO ash_slot%
bytes%=ash_slot%-prev%
IF bytes% THEN SYS FNswi_get(12),5,ash_heap%,,bytes% TO ,,,bytes%
ENDPROC
REM Claim a block from the heap (grow it if need be) - return
REM zero if claim fails.
DEFFNash_alloc(bytes%)
LOCAL block%, err%
SYS FNswi_get(13), 2, ash_heap%,, bytes% TO ,, block% ; err%
IF err% AND 1 THEN
PROCash_grow((bytes%+ash_page%) AND NOT (ash_page%-1))
SYS FNswi_get(13), 2, ash_heap%,, bytes% TO ,, block% ; err%
IF err% AND 1 THEN =0
ENDIF
ash_total% += block%!-4
=block%