Tag - STOS

The STOS compiler is a very useful program to have because it does the following things.

It speeds STOS programs up to three times their normal speed.

It saves the program as a single PRG file so there’s no need to copy the STOS folder onto the copy disk.

Compiled STOS programs are smaller than normal ones, saving disk space.

There’s no way a PRG file can be changed back into a BAS file so no-one can hack into it.

Even though the compiler seems like a great piece of software, it does have its issues. For example, when you compile a program to disk and then load it, the Function Key window flashes twice before the program starts. The way around this problem is to remove these commands from the program before you compile it.

key off
mode 0
hide on
curs off

From the Compiler’s main screen, go to the option menu and set the MODE option to LOW. Next, turn off the other commands by clicking on the OFF boxes. Compile the program and the screen appears blank when the program is loaded. Works better when the compiler sets the commands.

If you are pressed for space, then reduce the Sprite Buffer to 500 bytes. If the mouse pointer is not used in your game then select the NONE option in the option menu, but if your program just uses low res pointers then turn off the LOAD MED/HI option instead.

The Compiler has a couple of problems on the STE, first, trying to set it to change to Medium Rez results in the compiled program to run in the rez it was loaded in. Change the mode option to medium.

The second problem is with the STOS Tracker. On the STE the compiler always tells you that the last line of your program has an error, no matter what it is. To fix this you need to update the Compiler with the program on the Tracker disk called COMP207.PRG which updates the Compiler to v2.07 so the tracker commands will compile okay.

The compiler will sometimes list a line in your program and report an error, even though the line is okay. The reason it does this is because it is having trouble compiling it. This can happen on long lines of code and the FOR/NEXT loops. Look at this example.

10 pen 6: for x=1 to 10 : print”Hello” : next x

The compiler doesn’t like this line because of the “pen” command, why is a mystery, but remove the “pen” command and everything is fine. When using the FOR command, make sure it’s the first command on the line, like so…

10 for x=1 to 10 : pen 6 : print”Hello” : next x

See how I have put the “pen” command inside the loop? This lead to another problem I found. Look at this example.

10 box 10,10 to 100,20

When this line is found in a compiled program, the box is drawn in the current paper colour. The solution is to add an “ink” command at the start of the line.

10 ink 1 : box 10,10 to 100,20

The compilers main problems lie in the basic listing, it will report any lines it doesn’t understand. Normal errors would be spelling mistakes or the wrong use of a command. But sometimes it just has trouble compiling it in this case just play about with the listing and re-word it a bit, then try again.

In the COMMANDS.BAS file, there is a list of words that cannot be used in a compiled program. Most of them are Direct Commands so they can’t be put on a line anyway. The “run” command can’t be used so if your program requires a BAS file to load and run later in the program then you’ll just have to add it to the end of the program and call it using the ‘goto’ command.

Also, if your program has LOAD”name.var” in it, it will not work when compiled. The compiler will compile it but prints an error in the compiled program when it comes across this command. The solution is to save your variables as SEQ or RANDOM ACCESS file. For example:

10 open #1,”R”,”varible.dat”
20 put #1,N$
30 close #1

You can then load the contents of N$ like this.

10 open #1,”R”,varible.dat”
20 get #1,N$
30 close #1

Despite these issues most programs should compile fine. One other important thing to remember is that extensions have a compiler version with the extension .ECA. Make sure you have that installed.

STOS Code to Amos Code

December 30, 2018

As STOS and Amos are similar languages it was easier to port the STOS code of some of my games to Amos rather than rewrite it. In this article I will show you how to port your code over to Amos.

Converting STOS source code to Amos is easy. Simply save it as an ASCII file with the command save”game.asc”. Then port it over to your Amiga by formatting a MSDOS disk with Fastcopy 3, making sure you turn the fast format option off. Then it’s a simple case of reading the disk in your Amiga’s drive using the Crossdos driver which you’ll find in the Devs drawer on your workbench disk. Simply double click on the icon to activate it. Once it’s on disk then you can simply load the ascii file into Amos with the Load Ascii option.

Now a thing to remember is although Amos has most normal STOS commands, there are still some differences. Let’s take this line.

10 key off : mode 0

In Amos there are no such commands. You should change this to…

10 Screen Open 1,320,200,16,Lowres

This does the same job as the command ‘mode 0’.

When you list your source code you will notice that Amos will show commands it doesn’t understand in capital letters. You just need to find the Amos versions of those commands and change them around.

Sometimes there are problems with loading in certain files with long lines and you will get a “Line too Long” message. All you have to do is load the ASCII file into a word processor and make the lines shorter. For example:

10 for X=1 to 20 : XB(1,X)=FRNE+39*20/200 : next X

This can be set out as…

10 for X=1 to 20
20 XB(1,X)=FRNE+39*20/200
30 next X

If you have a lot of conditions in an If Then statement then you can use an Amos feature which allows you to have as many conditions as you want. This following routine will show you what I mean.

10 If CHOICE=1
20 Screen Copy 5 To 3
30 Music 1
40 FE=FE+100
50 Endif

Once the source is converted then it’s time to port over and convert your program’s data. Random Access files and Seq files can still be read within Amos but the commands are slightly different. Chip music will not play on the Amiga but you can play mods in your game instead. Sample banks I have not found a way to convert but you can simply load single samples into Protracker then save the lot as a mod, then save them out when you port the mod over.

Pictures can be loaded into STpaint and saved as IFF files for the Amiga. Sprite banks can be converted to pictures using the Put Sprite command to fill a picture screen with sprites.

Final note: Amos uses both line numbers and labels so there is no need to change that unless you want to.

First STOS Game for Newbies

December 29, 2018

Well you’ve opened the STOS manual. You’ve read it and seen all the clever commands and accessories you can use. You’ve read and heard that all this can enable you to write your very own masterpiece. But how do you start, what do you do, how do you tell STOS to do this? These are the questions the beginner asks. In this article I will show you how to get started and even write a simple game.

How do we start? Well first we need to learn some commands. A program is just a group of commands that tell STOS what to do. We start off with simple commands and we type out the examples in the STOS manual. This helps to give us a good idea of commanding STOS and telling it what to do.

Lets say we wanted STOS to print something on the screen over and over again. We can use the PRINT and GOTO commands like this…

10 print”STOSSER”
20 goto 10

Here we have a simple program. First it prints the word STOSSER onto the screen, and then it goes onto the next line that tells STOS to go back to line 10 and print STOSSER on the screen again.

So as you can see, we have grouped two commands together to make a small program, actually a small program like this is better known as a routine. A program such as a game is just a large group of routines. Let’s try a routine that counts up to ten.

10 for X=1 to 10
20 home:print X:wait 5
30 next X

What we have here is a loop that adds one to the variable X, prints it on the screen, then stops when X reaches 10. The HOME command is used to tell STOS to keep the count printing on the same part of the screen, and the WAIT command stops STOS from printing too fast.

So once we have learned the commands we can easily group them together. Once you’ve been learning them, typing out examples and looking at other routines, you’ll find it all comes clearer.

Lets program a small game. First we have to decide what the program is going to be, and what it does. The game in question is a Guess the Number game where STOS will first choose a random number then ask the player to guess it. If the players guess is wrong then STOS will tell him so. First…let’s set up the screen.

10 key off : hide : mode 0
Rem Now to start printing the information we need on screen.
20 locate 0,1 : centre”NUMBER GUESSER”
Rem Now we need to tell STOS to choose a random number, like this.
30 RN=rnd(10) : if RN=0 then goto 30

This line will choose a different number from 1 to 10 every time STOS comes across it. With programming we are sometimes faced with problems, in this case, the RND command will sometimes choose nought as a random number. The problem is that we only want numbers from 1 to 10. So therefore we add an IF THEN statement to tell STOS that if it chooses nought…then go back and try again.

When STOS has chosen a number between 1 and 10, it needs to ask the player to guess the number.

40 locate 2,4 : print”I am thinking of a number between 1 and 10?
50 locate 2,5 : print”Can you guess what it is?”

Next we need a way of letting the player enter his guess.

60 input A

This command waits for the player to enter a number and press return. Now so far we have the RN variable which holds the random number chosen by the game, and the A variable which holds the number chosen by the player. But what if the player has typed in a number which is out of range? We can check for this with these two lines.

70 if A<1 then print”Your guess is too low, try again” : goto 60 80 if A>10 then print”Your guess is too high, try again” : goto 60

So if the number in the A variable is out of range then the game informs the player to try again then goes back to the input at line 60. Now we need a line to check if the player has guessed the right number.

90 if A<>RN then print”That’s not it, try again” : goto 60

This line checks if the A variable contains the same number as the variable chosen by the game. Here we are telling the game that if the players guess is other than the number the game has chosen then to give them a chance to try again.

Finally we need to check if the player has guessed the right number.

100 if A=RN then print”Well done, you’ve guessed the number” : stop

So there we have it. A small game produced by just a group of routines. We can easily improve it, such as getting the game to loop back to the start after the player wins. We could also add extras such as a score by simply adding points to a variable and printing it on the screen like this.

110 SC=SC+10 : print”Your score is now:”;SC
120 wait 50 : cls : goto 20

I recommend you download The Beginner Guide to STOS Basic by MT Software as this is much more detailed.

Programming an Art Package

December 29, 2018

Ever fancied writing your own art package? Well in this tutorial I am going to show you how to program a few options that you would normally find in an art package. I have written a full art package called Grafix Art and the routines printed here are taken straight from it.

First off all, this is the routine for the normal freehand draw tool.

4410 rem DRAW
4420 hide on : off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : show on : K=1
4430 set mark 1,1
4440 wait 10 : repeat
4450 X=x mouse : Y=y mouse
4460 if hardkey=97 then hide : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : fastcopy logic,back : show
4470 until mouse key=1 or mouse key=2
4480 hide on : SCR$(SC)=screen$(logic,0,0 to 330,200)
4490 if mouse key=2 then hide on : wait 10 : goto 230
4500 if mouse key=1 then polymark X,Y
4520 repeat
4540 X=x mouse : Y=y mouse
4550 if mouse key=1 then polyline to X,Y
4560 until mouse key=0
4570 fastcopy logic,back
4580 show on : goto 4440

In other STOS art packages people have tried using the PLOT command for this routine. However this causes the line to draw broken. What happens here is we use polymarks to make the lines. The opaque command is from the EXTRA extension and what it does is places an image in a string put there using SCREEN$ onto the screen as a normal screen copy and not merged. In an art package we have workscreens to place our picture in so we can design so many different pictures at a time and flick through them. The routine starts by waiting for the user to click the left mouse button before it will draw a polymark. The right mouse button allows you to abort the operation.

This next routine will draw a continuous line.

4590 rem LINE
4600 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : K=1 : set line val(LTYPE$),L_SIZE,0,0 : show on
4610 clear key : wait 10 : repeat
4620 X=x mouse : Y=y mouse : M=mouse key : K$=inkey$
4630 if asc(K$)=0 and scancode=97 then hide : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back : show
4640 wait vbl : until M
4650 if M=2 then hide on : wait 10 : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : cls : goto 200
4660 Y1=Y : X1=X : hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200)
4670 logic=back : wait 10 : repeat
4680 opaque screen back,0,0,SCR$(SC) : polyline X,Y to X1,Y1
4690 X1=x mouse : Y1=y mouse
4700 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
4710 screen swap : wait vbl
4720 until mouse key=1
4730 logic=physic
4740 show on : goto 4610

You’ll notice in these routines that we have implanted an UNDO feature. This means that if you are not happy with the last thing you have done you can erase it from screen before you carry on. Note that the routine will put the current picture into a screen with SCREEN$. This is your present workscreen.

Drawing a box is easy as well, here is the routine.

4750 rem BOX
4760 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : K=1 : set line val(LTYPE$),L_SIZE,0,0 : show on
4770 wait 10 : repeat
4780 X=x mouse : Y=y mouse : wait vbl
4790 if hardkey=97 then hide : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back : show
4800 M=mouse key : until M
4810 Y1=Y : X1=X : hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200)
4820 if M=2 then hide on : wait 10 : cls : goto 200
4830 logic=back : repeat
4840 opaque screen back,0,0,SCR$(SC) : box X,Y to X1,Y1
4850 X1=x mouse : Y1=y mouse
4860 screen swap : wait vbl
4870 until mouse key
4880 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
4890 logic=physic : fastcopy logic,back
4900 show on : goto 4770

You can also alter the routine to draw a rounded box just by changing the command BOX to RBOX.

Something a little more interesting……a triangle.

4910 rem TRIANGLE SHAPE
4920 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : K=1 : set line val(LTYPE$),L_SIZE,0,0 : show on
4930 repeat
4940 X=x mouse : Y=y mouse
4950 if hardkey=97 then hide : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back : show
4960 wait vbl : M=mouse key : until mouse key : hide on
4970 X1=X : Y1=Y : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : logic=back : wait 10
4980 if M=2 then logic=physic : wait 10 : cls : goto 200
4990 repeat
5000 opaque screen logic,0,0,SCR$(SC) : X1=x mouse : Y1=y mouse
5010 polyline X,Y to X1,Y1 to X,Y to X,Y
5020 screen swap : wait vbl
5030 until mouse key
5040 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
5050 wait 10 : repeat
5060 opaque screen logic,0,0,SCR$(SC) : X2=x mouse : Y2=y mouse
5070 polyline X,Y to X1,Y1 to X2,Y2 to X,Y
5080 screen swap : wait vbl
5090 until mouse key
5100 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
5110 wait 10 : logic=physic : fastcopy logic,back : show on : goto 4930

The first part of the routine draws the first angle of the triangle and the second part draws the rest of it.

And now, an eclipse type circle.

5120 rem CIRCLE
5130 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : show on : K=1
5140 repeat
5150 X=x mouse : Y=y mouse
5160 if hardkey=97 then hide : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back : show
5170 wait vbl : M=mouse key : until M
5180 if M=2 then hide on : wait 10 : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : cls : goto 200
5190 hide on : logic=back : wait 10
5200 SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200)
5210 repeat
5220 opaque screen logic,0,0,SCR$(SC) : X1=x mouse : Y1=y mouse
5230 earc X,Y,abs(X1-X),abs(Y1-Y),0,3600
5240 screen swap : wait vbl
5250 until mouse key
5260 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
5270 logic=physic : fastcopy logic,back : show on : wait 10 : goto 5140

The ABS command stops the circle from drawing inwards.

No picture is complete without a bit of colour. This routine will fill a area of screen with the current ink and pattern number, which can be altered with the SET PAINT and INK commands.

5280 rem FILL SHAPE
5290 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : show on : set paint 2,PSTYLE,1 : K=1
5300 repeat
5310 if mouse key=1 then hide : paint x mouse,y mouse : show
5320 if hardkey=97 then hide : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back : show
5330 wait vbl : until mouse key=2
5340 hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : wait 10 : cls : goto 200

Another interesting tool is the RAYS effect.

5350 rem RAYS
5360 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : K=1 : set line val(LTYPE$),L_SIZE,0,0 : show on : wait 10
5370 repeat
5380 X=x mouse : Y=y mouse : wait vbl
5390 M=mouse key : until M
5400 Y1=Y : X1=X : hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200)
5410 if M=2 then hide on : wait 10 : cls : goto 200
5420 logic=back : repeat
5430 X1=x mouse : Y1=y mouse
5440 opaque screen back,0,0,SCR$(SC) : polyline X,Y to X1,Y1
5450 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
5460 screen swap : wait vbl
5470 until mouse key=1
5480 logic=physic : polyline X,Y to X1,Y1 : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : wait 2 : goto 5420

A K line is like a normal line except that it does not stop drawing itself when you reclick the mouse button. Here is the routine……

5490 rem K-LINE
5500 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : K=1 : set line val(LTYPE$),L_SIZE,0,0 : show on
5510 repeat
5520 X=x mouse : Y=y mouse : wait vbl
5530 M=mouse key : until M : wait 10
5540 Y1=Y : X1=X : hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200)
5550 if M=2 then goto 200
5560 logic=back : repeat
5570 opaque screen back,0,0,SCR$(SC) : polyline X,Y to X1,Y1
5580 X1=x mouse : Y1=y mouse
5590 if mouse key=2 then logic=physic : wait 10 : cls : goto 200
5600 screen swap : wait vbl
5610 until mouse key=1
5620 logic=physic : polyline X,Y to X1,Y1 : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : wait 2 : X=X1 : Y=Y1 : goto 5560

Two more interesting tools are the SPRAY and BRUSH.

6010 rem SPRAY
6020 off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : show on : K=1 : wait 10
6030 repeat
6040 K$=inkey$ : X=x mouse+4 : Y=y mouse+4 : wait vbl
6050 if hardkey=97 then hide : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : show
6060 if mouse key=0 then show on
6070 M=mouse key : until M : hide on : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : wait vbl
6080 if M=1 and X>=SIZE and X<=319-SIZE and Y>=SIZE and Y<=199-SIZE then plot X+rnd(SIZE),Y+rnd(SIZE) : plot X-rnd(SIZE),Y-rnd(SIZE) : plot X+rnd(SIZE),Y-rnd(S IZE) : plot X-rnd(SIZE),Y+rnd(SIZE) 6090 if SPEED>0 and M=1 then wait SPEED
6100 if M=2 then SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : wait 10 : cls : goto 200
6110 if mouse key=0 then show on
6120 goto 6030

6180 rem BRUSH
6190 hide on : off : cls : ink PE-1 : opaque screen back,0,0,SCR$(SC) : fastcopy back,logic : wait vbl : wait 10 : K=1 : show on
6200 repeat
6210 XM=x mouse : YM=y mouse
6220 if hardkey=97 then off : opaque screen logic,0,0,SCR$(SC) : fastcopy logic,back
6230 if M=1 and XM+BRUSH<320 and YM+BRUSH<200 then hide on : bar XM,YM to XM+BRUSH,YM+BRUSH else show on
6240 M=mouse key : until M=2
6250 if M=2 then hide on : wait 10 : SCR$(SC)=”” : SCR$(SC)=screen$(logic,0,0 to 330,200) : cls : goto 200
6260 goto 6200

These are some of the more common tools used in an art package. There are more interesting features like MAGNIFY and RESIZE and all kinds of effects. But with these simple routines and a bit of imagination there is no reason why you can’t write your very own art package in STOS.

You can download Grafix Art and run it under an emulator.

Adventure Game Planning

December 29, 2018

Adventure games have been a popular source of amusement for years. This type of game puts you into a created fantasy world where you make the decisions. For example you could be a knight in shining armour attempting to rescue a princess from a tall tower guarded by a fire breathing dragon. In adventure games, the player would be told where he is and what’s going on around him, with people and creatures to communicate with, and puzzles to solve. A world where your dreams become reality. The first adventure games were ‘text based’, meaning that you communicated to the game by typing words and it answered back by printing a reply on the screen. For example, typing “get the lamp” will result in the computer replying “You take the lamp” – providing there was a lamp there in the first place. Playing an adventure game is like being a character in a film, what happens depends on your choice.

The only problem with these early adventure games was that they couldn’t understand everything the player typed in. So along came the graphic adventure games which hands control over to the mouse with little or no keyboard input. Commands would be clicked on instead of typed. These type of games include the early Monkey Island and Simon The Sorcerer series. These games really bring your adventure to life as you can actually see the world you are in rather than reading a text description.

PLANNING A GAME

Before we can start writing an adventure game we need to plan it out. First we need an idea then built the game around it. Let’s say our game takes place in a castle. This would be our fantasy game world which is broken down into a number of small locations. We would then make a list of the various locations you would find in a castle like this:

Throne location.
Main Hall.
Drawbridge.
Servants Quarters
Bed Chamber.
Tower.
Dungeon.
Castle Grounds.
Staircase.

The next thing to do is connect each location to the nearest one. For example the nearest location to the Drawbridge would be the Main Hall or the Castle Grounds. This is important because you don’t want the player to enter the castle and find himself stepping into the Dungeon. The list would now look like this.

Castle Grounds.
Drawbridge.
Main Hall.
Throne location.
Dungeon
Servant’s Quarters.
Staircase.
Bed Chamber.
Tower.

OBJECTS

An object is something the player can use in his quest. It could be: a coat, a lamp, some food, a bag or anything that can be picked up and moved. Each object has its own normal location number, it could also be in special locations which are known as Worn, Carried and Not Created. If the main character is a Barbarian we could give him a sword and put it in the carried location, so when the game starts the Barbarian is carrying the sword. We could also define a magic potion for him and put it in a normal location waiting for him to find it.

Sword. (Carried Location)
Potion. (Location Five)
Robe. (Worn Location)

If you’ve ever played an adventure game and actually found something which was hidden, then you’ve found a “Not Created” object. This is a normal object without a normal location number. When the player finds the object the object location variable will become the number of the location the player is in.

PUZZLES

In adventures games, puzzles are there to give the player a challenge and make solving his quest harder. For example: finding a way or opening a chest or getting past a guard dog. Lets note down some puzzles for the castle game.

Puzzle: The player has to get past the guard at the drawbridge.
Answer: The player must find a guards uniform and wear it.

Puzzle: The player can’t unlock the door of the Bed Chamber.
Answer: The player must break the lock with his sword.

Puzzle: The player can’t get past the guard dog in the Tower.
Answer: The player must find a bone and give it to the dog.

TRAPS

As with puzzles, traps are set up for the player to fall into. If he tried attacking the guard then the guard would kill him and the game would be over. Here’s some traps for our castle game.

1> If the player takes the Kings Robe the guards will kill him.
2> If the player drinks the green potion he will die.
3> If the player trys to walk past the dog it will bite him.

EVENTS

Events are the outcome of things that happen in the game. For example if the player had solved the puzzle of the dog then an event would be called to put the bone in the Not Created location and the player would be told that the dog ran off with the bone. The dog and bone would be removed from the game. Here is some more examples of events

1> When the player examines the vase, he finds the key.
(Note: put the key in the players present location).

2> When the player breaks the lock on the door, he can open it.
(Note: set the DOOR variable to one to indicate it’s open).

3> When the player drinks the potion, his strength will be restored.
(Note: Set STREN variable to full and put potion in Not Created location).

EXITS (CONNECTIONS)

The player needs a way of moving between locations so we have to define the exits from each location. Exits take on the form of North, South, East, West, Up, Down, etc.. We can also have false exits. This means that the player can’t move to another location just yet, in other words it’s blocked off. Let’s take our castle game. From the drawbridge we have two exits: one leads to the Main Hall (location 3) and the other leads to the Castle Grounds (location 1). We could make a note like this.

Drawbridge: (North goes to location 3, South goes to location 1)

So the drawbridge is location 2 and from there the player can go north to location 3 or South to location 1. A false exit could be noted down as an event, so when the player opens the door of the dungeon, he can enter it. (Note: Connect Main Hall to Dungeon). You can think of this as a Not Created location being created.

Before we can get these options working, we need to set up the game data. The best way of doing this is to type it all out as data statements and then read them into an array. So let’s put our location descriptions down as data statements first.

data”You are in a cave, an opening is east.”
data”You are outside a cave, the entrance lies west.”

In order to put and hold this in memory we need to define an array using the DIM command like so.

dim location$(2)

This array will hold two location descriptions, next we need a line to put the location descriptions in the array so we use the READ command.

for X=1 to 2 : read location$(X) : next x

You can check if the line has done its job by typing ‘print location$(1)’, the description for location one should appear.

Now let’s define the EXIT data. For this we need to use a two dimension array called MAP.

dim MAP(2,4)

Next we use a nested loop to read the data into the array.

for X=1 to 2 : for Y=1 to 4 : read MAP(X,Y) : next Y : next X

Finally the data lines for each location.

data 0,0,0,2
data 0,0,1,0

Here we have a two dimension array which holds all the exit data for each location. So in the above example the first number is the number of locations in the game and the second is the number of exits.

To use this example we have to give each exit a number for the game to refer to like this.

North………Exit one
South………Exit two
West………..Exit three
East…………Exit four

So if we wanted exit two (south) to lead to location 3 we would use the following line of data.

data 0,3,0,0

Here we have four numbers on a line. As south is exit two then we replace the second number on the line with the number three so we now have an exit leading south to location three. Let’s connect a north exit to location four from this location.

data 4,3,0,0

Each data statement must have four numbers on it. If you didn’t want to use a certain exit then you would set the exit number to nought.

We also need a routine to allow the player to move from location to location via the defined exits. Use this line.

if MAP(location,CH)<>0 then location=MAP(location,CH) else print”You can’t go that way.”

OBJECTS

We can use the same method to store the object examine messages.

dim OBJECT$(2)
for X=1 to 2 : read OBJECT$(X) : next X
data”a small lamp.”,”a sharp sword.”

OBJECT LOCATIONS

Each object has its own location number which could either be a normal or a special one. First we set up the array which hold the object location numbers.

dim OB_LOC(4)

Next we use READ to put it into the array.

for X=1 to 4 : read OB_LOC(X) : next X

And next, the data line containing the object location numbers.

data 1,5,10,15

So object 1 at location 1, object 2 at location 5, object 3 at location 10 and object 4 at location 15

for x=1 to 4
if OB_LOC(X)=location then print”You can see”;OBJECT$(X)
next X

Where the OBJECT$ array holds the description of the objects IE: a small lamp.

SPECIAL OBJECT LOCATIONS

Normal object locations would would be as many as the locations in the adventure game as they appear in the actual game. But there are special object locations such as these.

CARRIED…………….Object is carried by the player
WORN………………..Object is worn by the player
NOT CREATED……Object does not yet exist in the game

To keep them separate from normal objects we need to give them higher numbers than the total number of locations in the game.

CARRIED=1000 : WORN=2000 : NC=3000

Each variable can be used to specify which special location the object is in. So for example if we wanted the game to list our carried objects then it could be checked like this. First, using an array like OB_LOC, we can put our first object in the CARRIED special location like this..

OB_LOC(1)=CARRIED

We can then add some lines to our game to inform the player what objects he is carrying……

for X=1 to 10
if OB_LOC(X)=CARRIED then print”You are carrying…..”;OBJECT$(X)
if OB_LOC(X)=WORN then print”You are wearing….”;OBJECT$(X)
next X

I have only covered a few basics here. For full information why not try my STOS Adventure Creator and STOS Graphic Adventure Creator which you can download from my Atari ST Page. Most of the work is done for you so you can start knocking out many adventure games.

STOS Basic Routines

December 27, 2018