Tag - STOS

Variables and Dimensions are a way of storing information in STOS to use in your program. The two main pieces of information are words and numbers. Your program would make a decision if one of these equaled something and act upon it. Here’s a simple example of a variable being used.

VARIABLES

10 print “Please type in a number”
20 input A
30 print “You choose the number”;A

What happens here is that the computer labels a little box as ‘A’ and inserts the number you typed in at the input prompt into it. The number you typed is now stored in the computer’s memory in a little box called ‘A’. Line 30 looks in the box and prints its contents to the screen, which of course is the number you entered. ‘A’ is the name we have chosen for the variable and the input command is one way of putting information into it. Another way to put information into a variable is like this.

10 let NUMBER=100
20 print NUMBER

Line 10 tells the computer to get one of its boxes and stick a label on it and call it NUMBER, then puts the value ‘100’ inside it. Note, the use of the command ‘let’ is optional and can be removed so your routine would be.

10 NUMBER=100
20 print NUMBER

Variables can be called anything you wish, using letters, words and symbols, but you must make sure that there are no STOS commands in the name or else you get something like this……

10 sin GLE=10

If you used the word ‘SINGLE’ then STOS finds the command ‘sin’ and gets confused. Try different names until you find one that appears in capitals.

Not only numbers can be used in variables, so can words or letters. If you wanted to put a word into a variable then you must add a ‘$’ to the variable’s name and the word must be put in between two quotes. For example.

10 NAME$=”DEANO”
20 print “MY NAME IS “;NAME$

10 input “What is your name”;NAME$
20 print “Hello There “;NAME$

You can also add variable values together which can be used in a game to add points to your score, for example.

10 SC=100
20 print “Your score is “;SC
30 print “Press a Key”
40 SC=SC+10 : goto 20

Line 40 tells the variable SC to equal the value of itself which is ‘100’ and the add ’10’ to itself. The same applies to letters, usually known as strings of characters. For example.

10 input “What is your first name”;NAME$
20 input “What is your second name”;SURNAME$
30 A$=NAME$+” “+SURNAMES
40 print “Hello “;A$

DIMENSIONS

As you know, a variable is a little box inside the computers memory. A dimension is a large box full of little boxes. Think of a cassette box, it’s one big box with so many slots for your cassettes. A dimension allows you to store so many pieces of information inside one variable. Here’s an example of how one could be used.

10 dim A(2) : rem Set up one variable box with two slots
20 A(1)=100 : A(2)=200
30 print A(1),A(2)

The same method can be used with strings.

10 dim NAME$(2)
20 NAME$(1)=”ST” : NAME$(2)=”PLUS”
30 print NAME$(1),NAME$(2)

Dimensions can be used exactly the same way as variables, the only difference is that with dimensions you use the variable name plus the number of slots in the variable box….IE: dim SC(10).

Another type of dimension is the two way dimension. This is setting up so many boxes with so many slots. Try this example.

10 dim NUMBER(5,10) : rem Set up five boxes each with ten slots.
20 NUMBER(1,1)=100 : rem Put ‘100’ in box one, slot one
30 NUMBER(2,1)=500 : rem Put ‘500’ in box two, slot one.
40 print NUMBER(1,1)
50 print NUMBER(2,1)

This is useful for directions in adventure games. For example this routine sets up a dimension with five locations and four exits.

10 dim D$(5,4)
20 for X=1 to 5 : For Y=1 to 4
30 read D$(X,Y)
40 next Y : next X
50 data 2,3,4,5
60 data 1,2,3,4
70 data 5,2,4,3
80 data 7,6,2,1
90 data 2,4,1,2

I recommend you use clear variable names and plenty of REM statements in your program so you can keep track on what each variable and dimension does.

As you know, there are only fifteen memory banks that you can use in STOS. Yet some games have more than fifteen pictures or music files overcoming the fifteen bank limit. This is done by simply sticking all the files into one bank on top of each other. This is called Stacking a Bank.

Let’s say we have five pieces of chip music that we want to save along with the program in one bank and call each piece when we need it. Well first to get them all in the bank we need to add up the total length of the files and reserve a bank to this length. If you put your five selected tunes on a disk then type ‘dir’ you should get a list like this.

Drive A:

MADMAX.MUS 4200
KILLING.MUS 2100
CIRCUS.MUS 8244
ALEC.MUS 4774
STOMP.MUS 8000

Here we have first the filenames followed by the file length, the file lengths need to be added up and then a bank reserved…..

4200+2100+8244+4774+8000=27318

10 reserve as work 5,27320+100

Note how the value in line 10 is slightly higher than the calculated figure. This is because we must always reserve a round figure for the length, we then add 100 bytes just to make a bit more space in the bank. Now we can add more lines to this routine to load the music files into the bank.

20 bload “MADMAX.MUS”,start(5)
30 bload “KILLING.MUS”,start(5)+4200
40 bload “CIRCUS.MUS”,start(5)+4200+2100
50 bload “ALEC.MUS”,start(5)+4200+2100+8250
60 bload “STOMP.MUS”,start(5)+4200+2100+8250+4780
70 rem SAVE BANK
80 bsave “M_BANK.DAT”,start(5) to start(5)+length(5)

The first file has loaded into the large bank starting from the start of the bank so it has taken up 4200 bytes of the bank which is the length of the first file (MADMAX.MUS). To load the second file in we have to make sure it slots in after the first one so we load in into the bank starting at the position where the first file ends. The next file has to load in and slot in the bank after the first two so we add the values of the first two files to give us the starting position where to load the third file.

So basically, we are loading in each file after the other adding up the values of the previous files to find the start position of the present file in the large reserved bank. Rather than have all this value+value bit we can add up the values into one length like so.

20 bload “MADMAX.MUS”,start(5)
30 bload “KILLING.MUS”,start(5)+4200 : rem Length of first file
40 bload “CIRCUS.MUS”,start(5)+6300 : rem Length of files 1 and 2
50 bload “ALEC.MUS”,start(5)+14550 : rem Length of files 1,2 and 3
60 bload “STOMP.MUS”,start(5)+19330 : rem Length of files 1,2,3 and 4

Note its also important that file lengths that are not even must be rounded up to the nearest even figure for the bank to stack properly.

In order to use the stacked bank in our program we just reserve a bank to the full length and bload it in. Now the easiest and quickest way to play the music is like this. First we need two arrays which will hold the start address of each file, and the length of each file. The music can easily be played by one line, saving a load of IF statements.

10 reserve as work 5,27320+100
20 bload “M_BANK.DAT”,5
30 dim MUS_ST(5) : rem Reserve array for start addresses
40 dim MUS_LE(5): rem Reserve array for file lengths
50 MUS_ST(1)=0 : MUS_ST(2)=4200 : MUS_ST(3)=6300 : MUS_ST(4)=14550 :
MUS_ST(5)=19330
60 MUS_LE(1)=4200 : MUS_LE(2)=2100 : MUS_LE(3)=8250 : MUS_LE(4)=4780 :
MUS_LE(5)=8000
70 input “Choose tune to play (1 to 5)”;PL
80 if PL=0 or PL>5 then goto 70
90 rem Play chosen music file
100 A=musauto(start(5)+MUS_ST(PL),1,MUS_LE(PL))
110 wait key
120 A=musauto(0,0,0) : goto 70

You can use the same method with packed pictures. In your game you just load in the bank of stacked binary packed pictures and call them up in the same way……for example.

10 reserve as work 10,50000
20 bload “PICS.PAC”,10
30 dim SCR_ST(4)
40 SCR_ST(1)=4000 : SCR_ST(2)=3200 : SCR_ST(3)=6500 : SCR_ST(4)=9000
50 for X=1 to 5
60 unpack start(5)+SCR_ST(X) : wait 50
70 next X

So there you have it. With this method you can have as many binary files in a bank as memory permits, and put an end to the bank limit.

Sprites are the little graphical images that move about on screen such as ships, aliens, bullets, little men, etc. Let’s look at how we can do this.

THE SPRITE COMMAND

Before you can use the sprite command you will need some sprites in memory. For example, try loading the animals1.mbk sprite bank from the STOS disk.

EG: load”animals1.mbk”

As it’s a sprite bank, STOS automatically loads them into bank one. Now let’s put it on screen.

10 sprite 1,100,100,14

This put a monkey sprite on screen. Now lets take a closer look at the sprite command.

sprite NUMBER,X,Y,IMAGE

NUMBER is the number of the sprite which ranges from 1 to 15. You can only place 15 sprites on screen at any one time.

X AND Y are the X and Y co-ordinates where you want to put the sprite. So in the above example, the sprite is placed 100 pixels across the screen and 100 pixels down the screen.

IMAGE is the number of the sprite from the sprite bank you want to place on
screen. In the above example its image 14 which is the monkey.

Let’s try two sprites on the screen.

10 sprite 1,100,100,14
20 sprite 2,160,100,14

So we now have two copies of the monkey on screen. Try changing the image number and the second sprite will be another one from the bank. Sprites can be designed using the sprite editor accessory. Refer to the STOS manual on how to create sprites.

MOVING A SPRITE:

The sprite can be moved across the screen by using the MOVE command. It goes like this.

move X 1,(1,2,300) or move Y 1,(1,2,300)

Let’s look at the command in more detail.

move DIRECTION,NUMBER,(SPEED,STEPS,PIXELS)

DIRECTION can be X or Y, it tells STOS to move the sprite either X (across the screen) or Y (up or down the screen).

NUMBER is the number of the sprite to move.

SPEED is the speed to move the sprite which ranges from 1 (fast) to 4 (slow).

STEPS tells STOS how many pixels to move the sprite at a time.

PIXELS tells STOS how many pixels to move the sprite.

Look at this example

10 sprite 1,10,10,14
20 move x 1,(1,2,100)
30 move on

So the sprite is moving across the screen at a speed of 1, in steps of 2 pixels at a time, and 100 pixels across the screen. The move on command tells STOS to start the movement. Note that sprites work on interrupt so your program can be doing over things while the sprite is working.

We can add extra letters to the move command to make it do other things like L and E. Normally the sprite will move and stop at the PIXELS parameter you choose but you can fix STOS to keep moving the sprite along its set strings by adding the letter L at the end of the move command. Using the E command allows you to stop the movement at a certain point.

EG:

10 sprite 1,10,10,14
20 move x 1,”(1,2,100)(1,-2,100)L” :rem keep moving sprite
30 sprite 2,10,50,14
40 move Y 1,”(1,2,100)E50″:rem stop sprite at Y co-ordinate 50
50 move on

ANIMATING THE SPRITE

We can step through the images of a sprite by using the ANIM command. The format goes like this…

anim NUMBER,(IMAGE1,DELAY),(IMAGE2,DELAY) etc

NUMBER is the number of sprite to animate.

IMAGE is the image number to show.

DELAY is the time to pause between each image.

Lets animate the monkey.

10 sprite 1,100,100,14
20 anim 1,”(14,5)(15,5)(16,5)(17,5)L” : anim on

So this command flicks the sprite between images 14 to 17 and then loops back to the start. We now have a walking monkey.

OTHER COMMANDS

MOVON(NUMBER)

This command checks to see if the sprite is still moving. It returns 0 if it isn’t and 1 if it is.

UPDATE, UPDATE ON, UPDATE OFF

STOS updates sprites every 50th of a second. This can be arkward when you want to do other things and STOS is using processor time for its updating. STOS is always checking a sprite and updating its position and you can turn the feature off by using the Update Off command, and Update On can return things back to normal. You can then update the sprite when you want freeing some processor time like so…

10 update off
20 for X=10 to 100
30 sprite 1,X,10,1 : update
40 next X

Try removing the update command from this example and the sprite will not be displayed on screen. It’s still there but just not being copied to the screen.