As in Robots, in SRobots you do not directly control the actions of your ship. Instead you write a program that controls the robot controling the ship. This game is a lot more complex than Robots, instead of the simple physics of Robots, SRobots is basically the old game of Thrust, with 'real world' physics. Instead of a top-down view, it is now side on. Six robots can fight, thrusting, expending fuel, shooting. unlike in Robots, the ships do not have any shields, and one hit will kill them. They do have 5 lives now though, and thankfully the Assembly for SRobots is much nicer than Robots'.
This is what it looks like. The bottom of the screen holds the status of the ships - name, the stars are lives, the little ships drawn below are kills. The amount of light colouring on each of the landing pads indicates the amount of fuel the ship has left. Above the ground you can see the ships flying around, trying to shoot each other. Cathy has killed loads of people, but is about to crash into another ship. Wiggler just fired a burst at LookKill, so it will get another kill to it's tally.
The game itself is pretty much complete. There is a bug in the scanner somewhere (I know cause I set up a Wiggler against a Shooter, and occasionaly the Wiggler fired, even though it only fires when it detects something and it couldn't possibly have detected anything). Had a brief look for it, but couldn't find it anywhere (didn't look for long).
My main goal (The Big Idea) is to convert SRobots to a Java applet, then put it on the web. Robots may then be placed on your web sites, and since a Java applet can access any URL in the world, everyone will be able to visit this web page, and fight their robots off against anyone else. If I get round to doing this, then there will be a list put up here of URL's for people's robots, and possibly a scoreboard of the robots to beat. Right now there are not many people writing robots (I'm not), in fact, I know of one (and a couple of 'soon, I promise').
For more information, here are the docs for SRobots:
SRobots - the sequel!
Version 1.03
By Iain King
40,000 AD - The future of warfare.
War is silly - people die and nobody want's too. To remedy this, the
nations of the different worlds decide that they'll settle their differences
in a way other than sending out half there population to get slaughtered.
To this end, they build small robots. They give them a sense of self
just so they don't want to die (hey - war is no good if *nobody* suffers), get
their top programmers to write there OS, and put them in little ships to 'get
the bits blasted out of' them.
Guess who they hired to code them? :)
-------------------------------------------------------------
Space Robots Docs!
1) The universe
The universe as seen by the robot -
how does the game work?
2) Notes on how to write the programs.
The layout of your source, and what the source
looks like.
3) The commands
A list of the commands and their functions.
4) The programs with the game.
Appendix A - list of commands with their opcodes
Appendix B - version list
-------------------------------------------------------------
1) The Universe.
The SRobots universe is quite simple. Honest.
To get a quick look at the universe type at the DOS prompt :
srobots spinner flyer
This will run srobots with two robots - one spinner, and one
flyer. The screen will pop up, giving stats on the robots.
Lines is the number of lines of code the robot has, and registers is
the number of registers used. Played, Won and Kills are pretty obvious. A
robot Wins if it is the last robot left alive. Deadliest is the robot in a
game that scores the most kills. %Wins and %Deadliest is the percentage of
games Played that that robot has won/been deadliest. The (Kills) is the average
number of kills per game. Hit a key and the game will switch to the game screen.
Hit a key again and they will take of and start buzzing about. The
spinner start lobbing volley's of shots into the air. As time goes by, either
the spinner will kill the flyer, or it will kill itself.
And that's what the game looks like. The screen wraps to the left
and right, but has a 'ground' (which is composed of landing pads), and a
'ceiling' (in the sense of a jet fighter's ceiling).
There is a gravity, and the ships move by thrusting and spinning.
In fact, this game is really the old game of thrust, but you don't get to
take an active roll in the game. Instead, you program the robots, who in
turn fly the ships.
The ships have no armour, or what you might call energy. Any sort of
hit on the ship will kill it. Each robot starts with five ships, or lives.
The ship's also have a finite (though reasonably large) supply of fuel. This
goes down as you thrust, but the ships get refueled whenever they land. To
land, the ship must fall relatively gently to the ground and be facing
straight up. If they do not face straight up then they will crash and die.
If a ship dies it restarts at a random location on its pad. The robots
program is rerun from the begining. (Note that you can detect how many lives
you have left, and so write your robots to take a different strategy depending
on how stocked up they are).
All but the last ship have emergency evac teleporters. Your robot
will teleport to safety when the ship blows up. If the last ship blow's up
though...
The pad's themselves show you your robots information. The coloured
line that makes up the pad is divided into two part, light and dark. This
is a fuel guage - the more light, the more fuel. The ships name is below
this, and to the right of the name is the ships current number of lives.
Below this a string of small ships will appear (hopefully),
indicating your robot's kills. (NB suicides do NOT count toward kill total)
As indicated, if a ship hits the ground too hard, or at the wrong
angle then it will explode.
If a ship hits the 'ceiling' then the lack of air at that altitude
will cause the ships turbines to stall. This basically means that your
engines are switched off and your y coordinate does not travel outside the screen.
Your ships can, of course, shoot. They can fire up to five shots on
screen at once, with no reload time. Shot travel until they hit the ground.
(NOTE - although your ships stall at their ceiling, the shots are not
propelled, and can travel above the limit)
Your robots have several means of gaining information about the
surrounding area. The first is that the robot can see out the front of his
ship in an arc up to 60 degrees straight ahead, to a limited range.
This yields the most info, as the robots can assimilate a lot of data quickly.
Next is the ships targeting scanner, which can scan any direction to a
limited range, and provides good info, but not quite as good as looking.
Finally, the radar can be used, which has an unlimited range, but can only
find the range of the objects found.
The robots may also talk to each other. This is done by using
the ship's radios. Team games can therefor be played, but the robots will
have to be programmed to know this! And remember - there can be only one!
If your team wins, then all but one will have to kill themselves so that
someone wins.
Coordinates:
The altitude is given in pixels and is in the range 0-379 (I think)
Angles are given in degrees, and 0 degrees is straight up. The angle
moves anti-clockwise, so 45 degrees points to the top-left.
User control:
It is possible to use the mouse to fly a ship in-game. This is
mainly for testing out your robots (as it should be quite simple to
beat them). Moving the mouse left and right spins your ship, left
button shoots, right button thrusts.
-------------------------------------------------------------
2) Writing your robot's programs
The assembler for Robots was incredibly bad. Srobot's assembler is
much nicer. Here are the basic rules:
a) No line can be blank - every line must contain an
instruction. (This is so the PC given in the game's
debug mode matches your source)
b) The commands are all three letters long. Sorry.
c) Commands can (and most do) have arguments.
d) A space or a comma can be used as a seperator.
All these are legal:
jeq start 0 0
jeq start 0,0
jeq start,0,0
jeq start, 0, 0
jeq,start,0,,,,,,,,,0
Obviously some are better than others.
e) Comments are denoted by a '//' (ignoring the quotes)
example:
jeq start 0,0 // Go back to start.
f) From (a) above : No line can be solely a comment.
g) Arguments can be one of four things:
A constant i.e. 1 5 1203 etc..
A label i.e. start main here there etc..
A register i.e. $1 $5 $128
A named register i.e. $shots $mode $freq etc..
A constant is any number (within a set range
obviously, but its big). They are all 'real' - in
srobots there is no 'typing' involved.
A register is refered to by placing a $ (dollar)
before a number. There are in all 128 registers,
ranging $1-$128. You may also refer to a register
$0. Register 0 refers to the top of the stack, and
lets you peek at the value held there. Refering to
a register out of this set will result in an error.
A named register enhances code readability. To
create one simply type a dollar '$' followed by the
name you wish to use. The name can be the same as a
label, but this would be a bad idea. When the
assembler assembles your code, it works out which
registers you have not called specifically (i.e. by
there index 1-128), and assigns the named registers
the free indexes. When you assemble your robot, Skatr
will tell you what index it has assigned to each named
register - it is a good idea to write these down during
debugging (in-game listings will refer only to register
indexes).
If operand is a 'destination' register, then the
dollar sign is optional, but strongly recommended.
i.e.
alt 1
is perfectly legal, but will be confusing when
editting. Also, you can't assign values to the
stack by using $0 as the destination of an operation.
The command will go ahead, but the value will be lost.
The dollar sign on a named variable is always compulsory.
If you omit it, then the assembler will take the name
as a label name.
A label is any string THAT MUST start with a letter.
Labels are used with jumps, and are defined in a
program like this:
thr 1 1 <-start // this is the label
jeq start 1,1 // this jumps to label
The label points to the line it is on (the line it is
on is the one that is jumped too).
Here is an example program to show (allegedly) good formating, in two
different styles. Note how we create a comment block at the top of the
program. The waste of the very first tick of the game (by the jump) is
practically as efficient as a commentless program - the game is geared to
allow a lot of ticks between movement - thrust and gravity are set at 0.00025
and 0.00002 of a pixel/tick/tick respectively.
----------------------------------------------------------------------------
jmp start // Hover by Iain King
sht
sht // Tries to hover in mid air
sht // Thrusts up, then waits until it
sht // starts falling.
sht // Once it starts falling, it thrusts up slightly
sht //
sht // Version 1.0
sht
thr 1000 1 <-start
thg $1
beq 1 $1 1 // Wait till we've stopped thrusting
dvy $vy <-main
ble 1 0 $vy // Wait till were falling
thr 1 .6
dvy $vy
ble 2 $vy 0 // Thrust till were not falling
jmp main // Back to top of main loop
----------------------------------------------------------------------------
jmp start // Hover by Iain King
sht
sht // Tries to hover in mid air
sht // Thrusts up, then waits until it
sht // starts falling.
sht // Once it starts falling, it thrusts up slightly
sht //
sht // Version 1.0
sht
thr 1000, 1 <-start
thg $1
beq 1 $1, 1 // Wait till we've stopped thrusting
dvy $vy <-main
ble 1 0, $vy // Wait till were falling
thr 1, .6
dvy $vy
ble 2 $vy, 0 // Thrust till were not falling
jmp main // Back to top of main loop
-----------------------------------------------------------
3) The commands
Here are all the commands available in srobots.
In all cases, A = operand 1, B = operand 2, etc..
Jumps and branches:
(A brief word - having just taken a class in RISC architecture's,
this is what I have modeled this version of SKA (this assembly)
on. Because of this, there is no JMP, or direct jump.
To perform a JMP, simply use a JEQ with the last 2 operands set at
0. Simple. Also note that greater than is the same as less than
or equal too with the arguments the other way around. Similarly,
>= is the same as less than with the args back to front.* However, the
effects of the class are wearing off now, so the assembler will convert
the commands : set, jmp, jgt, jge, sbr, sge, sgt, fwd, fge, fgt, bwd, bge,
bgt (like a macro) into the relevant add/equal/less than/less than or equal)
There are two types of jumps. Immediate jumps and relative
jumps. The two forms of immediate jumps are the 'jump'
set and the 'subroutine' set. The two forms of relative
commands are the 'forward' set and the 'back' set.
The immediate jumps can take a constant, a register or
a label for the destination. The relative jumps can only
take a constant or a register for their destinations.
In all jumps, the operands are divided as follows:
A, the first operand, is the destination.
Immediate:
If it is a constant, then that line number is
jumped to.
If it is a register, then the
jump will take you to the line number held in
the register (N.B. if your program jumps to
hyperspace then your ship will self destruct)
If it is a label, then the line number pointed
to by the label will be jumped to.
Relative:
If it is a constant, then the program counter
moves that many lines in the given direction.
If it is a register then the program counter
moves the register's value worth of lines in
the given direction.
B and C, the second and third operands are always compared
with each other. Depending on their values, and the jump
used, the program counter will or will not be changed to the
destination line number.
(For lines marked * see notes above)
The 'jump' set :
jmp A // will jump to A *
jeq A B C // will jump to A if B equals C (B==C)
jne A B C // will jump to A if B does *not* equal C (B!=C)
jle A B C // will jump to A if B is less than or equal to C (B<=C)
jlt A B C // will jump to A if B is less than C (B<C)
jge A B C // will jump to A if B is greater than or equals C (B>=C) *
jgt A B C // will jump to A if B is greater than C (B>C) *
The 'subroutine' set :
sbr A // subroutine jump to A *
seq A B C // subroutine jump to A if (B==C)
sne A B C // subroutine jump to A if (B!=C)
sle A B C // subroutine jump to A if (B<=C)
slt A B C // subroutine jump to A if (B<C)
sge A B C // subroutine jump to A if (B>=C) *
sgt A B C // subroutine jump to A if (B>C) *
rtn // return from subroutine
When a subroutine jump occurs, the current position of the program is
pushed onto a stack (Which can hold 128 subroutine jumps). When an
'rtn' is hit, the program flow jumps back to the point when the
subroutine jump was hit. (Basically gives you a GOSUB, or
an argumentless PROC)
The 'forward' and 'back' sets :
fwd A // jump forward A lines *
feq A B C // jump forward A lines if (B==C)
fne A B C // jump forward A lines if (B!=C)
fle A B C // jump forward A lines if (B<=C)
flt A B C // jump forward A lines if (B<C)
fge A B C // jump forward A lines if (B>=C)
fgt A B C // jump forward A lines if (B>C)
bwd A // jump backward A lines
beq A B C // jump backward A lines if (B==C)
bne A B C // jump backward A lines if (B!=C)
ble A B C // jump backward A lines if (B<=C)
blt A B C // jump backward A lines if (B<C)
ble A B C // jump backward A lines if (B>=C)
blt A B C // jump backward A lines if (B>C)
Notes :
Jumping forward or back zero lines will hang the program -
the jump jumps to itself.
Jump forward one line is what would happen if the jump never
occured.
Reseting:
Your robot can be told to reset his memory, which will cause
the program to clear all values and rerun from the start.
rst // reset and rerun from start
The Stack:
Two commands are available for manipulating the stack. The stack can
hold 128 entries, and if you overflow it, then the newest data will
simply not be stored. The value held in register 0 is the value at the
top of the stack. For example, to thrust for a number of ticks stored
on the stack at 100% power, use this:
thr $0 1
If the stack is empty then 0 will be returned on reference to $0.
psh A // Pushes A onto the top of the stack. Any reference to
// $0 will now refer to A
pop // Pops the stack - i.e. removes the top element.
i.e. psh 1
psh 2
psh 3
psh 4
psh 5
pop
pop
set $1 $0
would set register 1 to the value 3.
Basic arithmetic:
n.b. You may have noticed that you cannot assign a register a value.
To do this, you add the value to zero and store the result in the
register (as I said above, just did a class on risc programming * also
see notes above on why the assembler converts:
set A B
into
add A B 0
)
set A B // A=B * see above
add A B C // A=B+C
sub A B C // A=B-C
mlt A B C // A=B*C
div A B C // A=B/C
sin A B // A=sin(B)
asn A B // A=arc sin(B)
cos A B // A=sin(B)
acs A B // A=arc cos(B)
tan A B // A=tan(B)
atn A B // A=arc tan(B)
int A B // A=int(B) (truncates)
mod A B C // A=B mod C (modulus)
pwr A B C // A=B^C
sqr A B // A=sqr(B) (square root)
rni A B C // A=random integer between B and C (inclusive)
rnd A // A=random real (0-1)
The radio:
Inter-ship communications. Use 'frq' to set the frequency to listen
to. Use 'msg' to have a look at next message (0 if no message). This
also erases that message, and a subsequent use of 'msg' will see the
next message.
Use 'snd' to send messages. A message is simply a number. You can
hold twenty messages in your message queue.
frq A // set radio to recieve on frequency A (range 0-99)
msg A // store next message in A (0 if no message)
snd A B // send message A on frequency B
Ship controls:
The ship is controled with these commands. Any 'time' operand (i.e. in
'thr') can be given -1, meaning forever
trl A // turn left (anti-clockwise) A degrees
trr A // turn right (clockwise) A degrees
fac A // store the angle you are currently facing in A
thr A B // thrust A ticks at B power (B in range 0-1 / none-full)
sth A // set thrust power to A
thg A // Am I thrusting? 0=No 1=Yes in A
trg A // Am I turning? 0=No 1=Yes in A
thp A // Store current thrust power in A
Ship info:
Information on the ship and the world.
fue A // Store current fuel (0-1 / empty-full) in A
alt A // Store current altitude in A
grv A // Store gravity force in A
mth A // Store maximum thrust power in A
sid A // Store ship ID in A
lan A // Am I landed 0=No 1=Yes in A
liv A // Store number of lives left in A
tim A // Store current game time in A (number of ticks)
dvx A // Store current x velocity in A
dvy A // Store current y velocity in A
dvr A // Store current speed in A
dva A // Store current direction of travel in A
Guns:
Shoot your pea shooters!
sht // Shoot
bul A // How many bullets left unshot? in A
Radar:
Finding out about the environment. Ships and bullets will be
picked up by radar.
All three radars work by first calling the appropriate one.
This adds all objects found to your robots internal list (max 35
objects). You can scan through them using 'nxt', and get indivual
data onthe current list element. A ship's ID ranges from 1-6, all
bullets have ID of 0, and a -1 for an ID means the list is empty.
lok A B // Look ahead. Ignore anything beyond range A (max 100)
// Ignore anything outside arc B (max 60)
// returns values usable by:
// tid, tgx, tgy, tga, tgr, tvx, tvy, tva, tvr
scn A B C // Scan. Same as 'lok', but scans in direction C.
// A has max 200, and B is unlimited.
// returns values usable by:
// tid, tga, tgr, tva, tvr
rad A // Radar. Include all objects within range A (unlimited)
// returns values usable by:
// tid, tgr
rel A // If A is 1 then any 'scn' will be performed relative to
// the direction in which the ship is facing. If 0 then
// the scans are at absolute directions.
fnd A // Store 1 in A if the last 'lok', 'scn' or 'rad' found
// something, else stores a 0
nxt // moves on to the next item in list of found objects.
fls // flushes (removes all objects from) the list of objects.
All the following return values from the current item in the list of
found objects.
tid A // Stores target ID in A (1-6 if ship, 0 if bullet,-1 if
// list empty)
tgx A // Stores target x distance away
tgy A // Stores target y distance away
tga A // Stores target angle (what direction he is in from you)
tgr A // Stores target distance from you
tvx A // Stores target x velocity
tvy A // Stores target y velocity
tva A // Stores target direction of travel
tvr A // Stores target speed
System :
The WRT write command allows you to write self-modifying code. This is
naturally an incredibly stupid thing to do, but I put it in for a laugh.
Can't see this leading to more optimal coding, but it will make your code
pretty much elligible.
wrt A B C D E // writes to the robots program
// Writes to line A, with opcode B
// C,D and E are operands for that opcode,
// but if you use registers, then it will be the
// actual register used rather than its contents
For example:
set $1 7
set $5 2
set $add 17
wrt 4 $add $5 $1 5
This will cause line 4 in the program to be changed to:
add $5 $1 5
NOT 'add 2 7 5' as you might expect.
Robot info :
You can find out the info on the robot - wins, played, kills,
times deadliest. (These are the total amounts over many games,
as reported on startup)
rbp A // Stores the robots # games played in A
rbw A // Stores the robots # games won in A
rbd A // Stores the robots # games been deadliest in A
rbk A // Stores the robots # kills in A
Pretty pointless stuff to know, but ould come in handy (in team
games, only one bot can win, so you could use these to find out
the bot that had the highest score and make it win (by making it's
team mates die))
Debugging :
The DBG command can be used for debugging your robots.
dbg A B // Displays info on your robot, and it's registers
// contents up to register A (starting at 1)
// If B is 0, then only activates if running in debug
// mode (press the 'D' key), else activates regardless
---------------------------------------------------------------
4) The programs with the game.
The game has five programs : srobots, skatr, view and makeska, as
well as a batch file fight.bat
srobots :
This is the game itself. The parameters you pass in are the
robots that are to fight, and the switched to be used.
i.e.
srobots [/PTIS] shooter hover lander
The files for these must be these names with a '.rbt'
extension. srobots looks for them in either the current
directory or a subdirectory off the current one named
'robots'.
The switches do the following
S No spinner - the spinner shown in text mode will
not be displayed - you may want to redirect output
to a log file, which is what this is for.
P No Pause - SRobots will never wait for a keypress.
I No Info - The stats of the robots is not displayed
at the start.
T Text only - No graphical output produced
If you enter a robot name as 'user' on the command line, then
you will be given control over a ship in-game. Moving the mouse
left and right will spin your ship, left button will fire, right
button will thrust.
In the game, certain keys have functions.
The keys 1,2,3,4,5,6,7,8,9,0,-,=
Control the frame update. 5 or 6 is good for me. If you want
to fight quicker games run it at 9 or 0.
'Space' toggles single frame stepping. In this mode hitting a key
will advance the game one tick
'd' puts the game into debug mode, which will display some
extra info for each robot below it's pad (its current line
number, the current op code, and the truncated contents of
register 1). Also displays current time (in ticks) and frame
rate in top left corner. Also, see the DBG command.
'x' puts the game in extra debug - this practically stops the game,
but you get to examine practically every part of the programs running.
In this mode, any key advances you, 'x' stops the extra debug, and the
keys 1-6 allow you to examine the relevant robot.
'r' refreshes the screen
'Esc' quits, and asks if you want to treat as a draw and save.
If you say yes, then the stats for the game are saved to the
robots as if the game were a draw (i.e. - it saves the kills)f
N.B. The game always displays a winner/deadliest message to the standard
output, which you can redirect to create a logfile
(I.E> fight /P cathy shooter >>logfile.txt)
skatr :
This is the assembler. If you have a source file robot.ska,
then to assemble it you would type:
skatr robot
or skatr robot.ska
Skatr has a few options, and it's command template looks like
this:
skatr [/dylprc=######] filename
The switches MUST go before the filename, and if a 'c' is present
, it must go AFTER any other switches.
The switches do the following:
'D' Does not display any information.
'P' Does not display the Program code.
'L' Does not display the Label information
'R' Does not display the named Register information.
'Y' Does not prompt for file overwrite - yes assumed
'C' Allows you to specify a view code. The 'c' must be
followed by an '=' then six digits.
Specifying a view code will enable you to view the code generated by
your ska. It's pretty pointless for anyone but me (I need it for
debugging), but you can do it anyway. If no view code is specified,
then your code is secure and may not be viewed. (except by anyone with
a modicum of knowledge on viewing files).
(N.B. skatr is called skatr for hysterical raisins)
view :
VIEW <CODE> <ROBOT>
This allows you to view the .rbt files (dissassemble them).
You must specify a code, which if it doesnt match will stop
you viewing the source.
makeska :
This allows you to assemble multiple robots at once. It takes
one argument which is the filename of a list of ska files, for
example:
shooter.ska
wiggler.ska
spinner.ska
an easy way to make a makefile would be :
dir /b *.ska >makefile.txt
clear :
clears the stats in one rbt file - takes filename as
parameter. Useful if you want to collect stats on a match:
Clear all robots involved before the match, and the stats
will give you an accurate view on what robot is the best.
fight :
This is an NDOS batch file for running multiple games. It takes
arguments the same as SROBOTS (i.e. [/PTI] robot1 robot2 robot3...)
and then fights runs srobots until you exit it with 'Esc'.
---------------------------------------------------------------
Appendix A : The commands and their opcodes
Command Opcode
jeq 1
jne 2
jlt 3
jle 4
seq 5
sne 6
slt 7
sle 8
feq 9
fne 10
flt 11
fle 12
beq 13
bne 14
blt 15
ble 16
add 17
sub 18
mlt 19
div 20
sin 21
asn 22
cos 23
acs 24
tan 25
atn 26
int 27
mod 28
pwr 29
sqr 30
frq 31
msg 32
snd 33
trl 34
trr 35
fac 36
thr 37
fue 38
trg 39
thg 40
sht 41
bul 42
rtn 43
alt 44
thp 45
grv 46
dvx 47
dvy 48
dvr 49
dva 50
lok 51
scn 52
rad 53
nxt 54
fls 55
tgx 56
tgy 57
tga 58
tgr 59
tvx 60
tvy 61
tva 62
tvr 63
tid 64
sid 65
liv 66
tim 67
rni 68
rnd 69
sth 70
lan 71
fnd 72
rel 73
dbg 74
rbk 75
rbw 76
rbp 77
rbd 78
psh 79
pop 80
rst 81
mth 82
wrt 83
---------------------------------------------------------------
Appendix B - version list
Version 1.00
First release.
Version 1.01
New stuff added - Startup info, wins/kills/etc saved to
robots files. Speeded it up (about twice as fast -
some severe bumming, honest! It's not like I just told
the compiler to *use* the Math's Co-processor instead of
emulating it.) (Also added the commands that make use of
robot info - rbk, rbp, rbw, rbd)
When fighting with multiple instances of the same robot, that
robots stats are saved in this order:
If one of that robot type WON, then it will be saved.
Else, the instance of the robot with the most kills
will be saved.
Draw text bug fixed, along with draw bug (a ship winning with
one life left was classed as a draw before)
Added command line switches to srobots
(text only mode, no pause, no info).
Added command line switches to skatr (no prompt, no display,
enter view code)
Bug fix on landing - if you turned more than 360 degrees in one
direction, then you could not land (I forgot to MOD the ships
facing to 2*PI)
Shots now affected by gravity and no longer get destroyed if they
fly above the ceiling. Also changed fixed distance of travel
to travel time, then removed that - shots now stay alive until
they hit something (the ground, an enemy, you)
Fixed graphics glitch (ship never cleared properly if it died on
edge of screen)
Added DBG command.
Added ESC to quit (and possibly save results)
added extra debug mode
added refresh screen
added fight.bat
added the in built macros to assembler for jmp, jge, jgt, sbr, sge, sgt
, fwd, fge, fgt, bwd, bge, bgt, set. Looking back now, the whole
assembler could have been done a lot better : for example, the whole
command sets of the forward and backward jumps could have (and should have)
been done as macro's of the jump set. Instead they are coded as instructions
in the game.
new executables view and makeska. View is pretty pointless for anyone but
me, but if you REALLY can't work out what is wrong with your bot, check out
your .rbt file with it. If there is a bug in the assembler please report it
to me - address at top of page.
fuel now necessary for turning as well as thrusting.
fixed bug with messaging - all messages now synced to clock tick after send.
Before, depending on your robots position, it could recieve a message sent in
the tick it was sent OR the tick after.
added stack. Actually the code for the stack has been in there since the start.
I just forgot to implement the commands to make use of it. Oops.
Version 1.02
Added RST command.
Version 1.03
Added user control
Fixed docs
Rewrote View (now it works)
Added /plr options to Skatr
Added named registers
Skatr and Srobots now recognise standard parameter entry
(paramters now no longer need to be grouped under the one '/')
This involved all the effort of changing an IF statement into
a WHILE, one in each program.
Added MTH command.
Added WRT command.