BATTLE OF THE BASICS

Laser BASIC, £14.95 from Ocean IQ/Oasis Software, 12 Walliscote Road, Weston Super Mare, Avon BS23 1UG.

Mega BASIC, £9.95 form Sportscene Specialist Press (Your Sinclair Spectrum). 14 Rathbone Place, London W1P 1DE.

Beta BASIC, £9.95 from Betasoft, 92 Oxford Road, Moseley, Birmingham B13 9SQ.

This month's TECH TIPS looks at extensions to ZX BASIC. Ocean, Betasoft and Your Spectrum (RIP) battle it out in the contest to find the ultimate set of BASIC extensions. Laser BASIC, Beta BASIC, and Mega BASIC are the contenders - as it turns out there's no clear winner, since each utility has it's own unique advantages.

ZX BASIC, built into the Spectrum ROM, is a good language for those who want to learn about programming fairly painlessly. Most of the simplest keywords can be entered at a single key press lines are checked for syntax as they are entered and the editor is easy to use. String and graphics commands are unusually simply used. Most of the error messages are in something approaching English and you can continue after making changes to a program.

When it comes to serious use, ZX BASIC doesn't fare so well. It is very slow, especially when large programs are being run, and editing is laborious. The less common symbols and keywords are hidden in the obscure corners of the keyboard.

The best way to speed up ZX BASIC is to use a compiler - we looked at those in a previous TECH NICHE. This month's packages build on the existing language, rather than enhance what's already there. Laser BASIC, Beta BASIC and Mega BASIC add extra facilities and utilities. Facilities include on screen sprites (animated graphic symbols), extra commands, functions and control statements. Utilities make program editing and debugging easier. I'll start by comparing their presentation.

LASER BASIC - WHAT YOU GET

Laser BASIC is supplied in a plastic box, like a VHS video box but even bigger. The code was written by Oasis Software who produced the Forth-based graphics package White Lightning some time ago. The program is the flagship of Ocean's new IQ range billed as 'The secret of advanced games programming'. Look out Matthew Smith, Sandy White, and all, your secret is out! - well not quite.

For £14.95 you get two cassettes and a 90 page A5 manual printed on hideous but trendy green paper, to discourage pirates with old fashioned photocopiers. The cassettes contain the Laser BASIC program, two libraries of sprites, a sprite designer, a 'shop window' demonstration program and a game of three dimensional noughts and crosses which shows off the features of the system.

The manual is wrapped in a black card cover, with a useful 'bookmark' flap extended from the back cover. Something is needed to help you keep your place, since the presentation is not good - the manual is typeset, but only one size type is used throughout, and the layout makes the whole volume look like a ninety page technical appendix. The style is dull and verbose, but you do get a five page alphabetic command summary and two pages of contents list, including a useful 'tape map'. 21 pages are taken up with a commentary on the demonstration program, routine by routine.

BETA BASIC- WHAT YOU GET

Beta BASIC is also supplied in a video box, which holds another 90 page A5 manual and a single cassette. The cassette contains the Beta BASIC extensions and an unspectacular 'turtle graphics' demonstration.

This time the manual is printed on bright red paper - using this and Laser BASIC alternately is like taking part in a psychological experiment! Again the type is all a single size but this time it has been produced on a good quality daisywheel printer. Apparently, a modified version of Tasword II was used, but it is none the worse for all that. The layout is better than that of Laser BASIC, but still rather dull.

The style of the manual is straightforward and readable though not as good as the original Spectrum manual, mainly because of the lack of graphics. The text is divided into a summary and a reference section, with appendices to cover errors, printers, keys and special variables. There's a tow page list of contents.

Examples and observations are sprinkled through the text, and these help dilute the more technical explanations. The front cover contains a keyboard chart, showing the positions of the new commands - no overlay is provided. The back cover contains a concise syntax summary.

MEGA BASIC - WHAT YOU GET

Mega BASIC has the smallest but most readable manual of all: 30 A6 (double cassette sized) pages printed on white paper - hurrah! The single cassette contains two copies of the Mega BASIC system and a sprite designer. Unfortunately some one forgot to record the sprite designer onto either side of our tape, purchased (with £7.95 of real money!) at the ZX Microfair. We got a complete recording later.

The layout of the manual is good and the style is informal. It is very readable, much as it's parent magazine used to be before the Megawow Geewhizz Supaspeccy style took root. There's a five page list of commands, an (incomplete) table of error messages and a single, well organised contents page. Examples are far and few between - this manual is, sadly, better to look at than it it is to use.

USING LASER BASIC

Beta BASIC and Laser BASIC have a lot in common, so they are reviewed together, later in this article. Laser BASIC is the odd one out, so I'll discuss its unique features individually.

Laser BASIC offers no new editing facilities - it just modifies the syntax checker to allow a hundred or so new commands and functions, which must be typed in full (letter by letter) in capitals. The commands are all four letters long and start with a full stop. From .ADJM to .WRBV, they are almost all totally unmemorable and unpronouncable. Commands expect up to seven numeric parameters.

Functions are three letters long, similarly unpronouncable and start with a question mark. Functions can only be used in assignments - not in expressions - so you have to copy them into a normal variable with LET before you can PRINT them for example.

Most of the commands are concerned with sprite graphics. As in White Lightning you can propel sprites of almost any size, from one character to several times larger than the screen - useful for moving backdrops in games like Zaxxon or Defender. You can do all sorts of tricks if you can remember the right command - moving, scrolling, panning, recolouring, masking, rotating, animating, enlarging, shrinking, inverting and detecting collisions - in other words, you can fiddle about with patterns on the screen in almost every conceivable way.

The rest of the system is a bit of a disappointment, There are very few new commands apart form those that deal with sprites. You can renumber programs, 'trace' the current line number, read groups of keys and PEEK and POKE two-byte values. That's all. There are no new commands for editing, sound effects or 3D perspective.

You can use procedures - routines called by name rather than line number - but the names must only contain one letter, again making programs hard to understand. Values can be passed to a procedure and changes thereafter don't affect the original variables - in Technospeak: the values of the variables are local.

The Laser BASIC demonstration shows that you can produce varied and attractive flicker-free graphics with the package, but the demo is not exactly 'state of the art' - it looks like a collection of snippets from simple games of a couple of years ago.

The free game is flashy, but 3D noughts and crosses is not exactly pulse-quickening stuff. The slow speed of ZX BASIC slugs the Laser system, making it hard to keep more than one thing moving at a time. The game is played well, using an algorithm that first appeared, as far as I know, in Practical Computing in January 1981 (page 102), though the author does not acknowledge this.

The Laser Sprite Generator is written in BASIC. The program is a bit slow and long winded to use, but good results can be obtained if the sprite libraries supplied are anything to go by (I can't draw). The display is rather lurid and it is a shame that you can't edit sprites with a Kempston joystick.

CAN A MEGA BEAT A BETA?

Beta BASIC is the oldest utility reviewed here, although the latest version - 3.0 - was only published this summer. In many ways it seems to have been produced in direct response to Mega BASIC, which rather shook up the world of Spectrum BASIC extensions when it was launched a year ago. Already Mega BASIC has outpaced Beta BASIC on the version number front - I looked at version 4.0.

Beta BASIC looks just like ZX BASIC when you first load it - even the copyright message looks like the Sinclair one which we have all come to know and love or hate... depending on what we were doing before it appeared.

The Mega BASIC start up screen is much more impressive. The program name, version and author appear on the top of the screen. The ink is yellow on black. The bottom line contains an indication of the mode (the cursor is now a solid block) and whether or not CAPS LOCK is enabled.

TYPING PRACTICE

Both systems let you dispense with the Spectrum's keyword entry scheme, which is great if you've got a proper keyboard - I used a Fuller FDS. In Mega BASIC you have to type all the commands letter by letter although they can be abbreviated to their first few letters followed by a full-stop.

Beta BASIC lets you select normal keyword entry (the extra keywords are accessed from graphics mode) or letter-by-letter typing, or an ingenious mixture of both which I used most of the time. In the mixed mode, keywords at the start of a statement can be typed as normal, or type letter by letter if preceded by a space - a natural action for a touch typist, The mixed mode is convenient since it means that common commands - LET, PRINT, GO TO and so on - can be typed with one press, and the rest can be typed out with no need to look down and search for the required keyword.

Both BASICs provide user defined keys - so a group of characters can be produced when the appropriate 'key' is pressed. In Beta BASIC you must press symbol shift and space, then a letter or digit. Mega BASIC expects you to select extended mode then type a shifted digit.

Both BASICs improve the performance of the line editor. They allow you to edit lines by number - you don't have to LIST them first. They also let you move quickly through a line with the up and down keys as well as left and right, and provide a short-cut to the start or end of a line.

In Beta BASIC you have to press Enter before changing the current line, whereas you change it by typing the AND and OR symbols in Mega BASIC. Mega BASIC also gives you a second 'copy' cursor - like the BBC Micro - which can be moved independently with a rather strange group of keys; characters can be copied from the position of this cursor to the other with a shifted keypress. Beta BASIC won't do this, but it does let you join and split lines at will.

Beta BASIC tokenises lines rather slowly, but you soon get used to the slight pause after you hit Enter. It lets you put premature line-feeds into a listing (so that lines don't just run from one margin to another) but this can cause confusion when editing as the 'extra' text is not always cleared from the display.

I think that BBC Micro enthusiasts will probably prefer the Mega BASIC editor, but I preferred the Beta BASIC one be cause of the facility to join lines and the neat listings - Beta BASIC indents loops and tests for you automatically if asked to do so - this time Beta BASIC collects a BBC Micro feature. One big snag with Mega BASIC is the fact that that you can't always re-edit an incorrect line- sometimes you just get a 'Bad Line' message and have to type the lot again. Ugh!

The Mega BASIC keywords are not easily mastered since they almost all end with underscores - Symbol Shift Zero, if you've never needed one before - for no obvious reason. This is taking QL emulation too far. Mega BASIC is also needlessly fussy about the space character in instructions such as OPEN # and GO TO.

BLOCK STRUCTURE

Both BASICs provide some facilities for writing block structured, modular programs, but Mega BASIC features are not very substantial. You can define procedures (which must have names starting with an AT sign) but these can't be typed as commands and local variables aren't allowed. Simple REPEAT UNTIL loops are the only new control structure.

Beta BASIC provides a range of facilities that would satisfy even an ALGOL 86 programmer (ALGOL 86 is a language so comprehensive that no one has implemented it fully yet, and they've been trying for 18 years!). It's a computer scientist's dream: you get named procedures, local or reference parameters with default values if they're not supplied you can pass lists of parameters for sequential processing. There's multi line IF THEN ELSE, a general purpose looping construct which allows exit from any point, and these structures can be nested arbitrarily.

Beta BASIC even speeds up a few ZX BASIC commands. Some aspects of ZX BASIC slow up alarmingly as program size increases, Beta BASIC avoids this, so that FOR loops, GO TOs, GO SUBs and RETURNS can be increased in speed by a factor of up to twenty times in long programs. This effect is, of course, largely swamped by the execution time for other statements, but it is still a nice feature.

You get long and short (single statement) forms of ON GO TO and ON GO SUB, which brings me to the only missing feature I could think of: Beta BASIC has no SELECT or CASE statement.

UNIQUE FEATURES - BETA BASIC

It would take a whole CRASH Christmas Special to list all the unique features of Beta BASIC, but they include commands to sort and shuffle rows from string and numeric arrays. There are new integer functions and operators such as MOD and bitwise OR. and there are some fast but low precision trigonometric functions. It is a shame that the new function are typed in as DEFined FNs since this reduces the number of user defined functions you can use.

Clever print-formatting is allowed for neat tables of figures. There's an optional clock display, with an alarm, and a command which passes characters to the command line as though they were typed in - the ultimate in self-writing software. The contents of memory can be treated like an enormous string array, allowing all sorts of neat tricks.

The Beta BASIC toolkit lets you list lines, groups of lines, variables, key definitions and procedures. You can search out and replace information in a program, renumber, save and delete groups of lines. You can delete groups in Mega BASIC but the rest of these tricks are beyond it.

Beta BASIC graphics commands include a FILL, function which colours bounded areas of the screen for you. Filling is fairly fast and you even get a count of the number of points filled. Graphics can be shifted and scaled within a window and you can use absolute co-ordinates rather than offsets, when drawing lines on the screen.

What Mega BASIC excels at is multi-tasking. The Spectrum's interrupt facility is used all over the place. You can produce intricate non-stop sound effects while a program runs, or make two programs run at once - or all three at the same time! The software multi-tasks rather crudely, executing lines from two parts of a program alternately.

Mega BASIC has simple, four-character-size animated sprite graphics. The eight sprites can move, changing shape automatically, while the program controlling them does something else. It amazes me that Laser BASIC did not include this feature - in fact it DOES appear in the Amstrad and Commodore versions of Laser BASIC.

The Mega BASIC Sprite Designer was a bit of a disappointment since it wasn't recorded on my cassette. We got a replacement at the next Microfair, and found it to be a competent but unimaginatively-written program - not as good as the Horizons cassette, for instance. It is written in Mega BASIC, which makes it rather sluggish but decent results can be obtained with a bit of effort.

Machine code support is noticably absent from Beta BASIC, presumably because it is considered unnecessary. Mega BASIC gives you a small but useful 'front panel' to control machine code and an extended CALL statement which allows parameters to be passed to machine code but not returned.

User defined graphics can be designed in a single Mega BASIC statement; as far as I know this is a neat trick from the Memotech repertoire. Strings can be printed down, rather than across the page and large characters can be printed in fuzzy, 'stippled' colours. Screen output can be redirected to machine code or a printer; in fact it's very easy to do this in ZX BASIC if you know the right command.

The main Mega BASIC system includes a tape header reader which prints the details of tape files. There's also a rather dangerous cassette file copier that destroys your current program and crashes the machine if the file concerned is more than 20K long!

Mega BASIC is generally frustrating to use if you make a mistake. The commands don't check their parameters properly, so silly mistakes can cause weird results or even crash the machine. The manual pleads lack of memory but my verdict is lack of effort and poor software design.

SHARED FEATURES

Both systems let you divert execution to a subroutine when each end of line is reached by in the main program. This can be very useful when debugging. They both have a facility to trap errors and disable break-ins from the keyboard but Mega BASIC can't trap Interface 1 errors or - more mysteriously - the error codes it generates itself! Both offer two-byte PEEK and POKE instructions, and can provide automatic line numbers.

Both BASICs are associated with magazines. The glossy monthly Your Sinclair is owned by the publishers of Mega BASIC and has contained several articles based around the system in Your Spectrum days. The Beta BASIC magazine is less pretty but more substantial. It consists of fourteen typed pages crammed with neat routines and tips for Beta BASIC users. A six issue subscription costs £5.50.

Windows have definitely arrived - Beta BASIC and Mega BASIC allow you to restrict display output to a limited area of the screen and dial up a range of character sizes, including a Tasword-style 64 characters per line. Areas of the screen can be scrolled smoothly in all directions, or saved for later re-display in various sizes. The attribute grid can be blasted in various ways, for special effects. Printing can be offset from the grid so you can position text with pixel accuracy.

Only Mega BASIC lets you select between three possible typefaces - Spectrum, BBC and Amstrad character shapes. Of course you can redefine the characters in Beta BASIC or normal, boring ZX BASIC with just a few POKEs, but this superficial Mega BASIC advantage haunts the machine. A system running Mega BASIC just doesn't seem like a Spectrum when you use it. Beta BASIC is more subtle, and doesn't immediately appear to have changed the nature of the machine. Some people will choose Mega BASIC on the basis of this feature alone - it all depends how much you like the Sinclair style.

Both systems take up a lot of memory - about 20K - which is inconvenient for business users. It's a shame the publishers don't let you choose a subset of the commands, as you used to be able to do on the venerable ZXED toolkit from Dk'tronics.

WINDING UP

Mega BASIC and Beta BASIC are both recommended to those who want to inject new life, and perhaps a little excitement, into their ZX BASIC programming. Both systems are very powerfull and usable, though the publishers of Mega BASIC really ought to tidy up its error-handling.

I preferred Beta BASIC, mainly because of its elegance and comprehensive support for software engineering: the Spectrum was designed, oddly enough, as a programmer's machine rather than a games one (hence no joystick port, poor sound, friendly BASIC, microdrives, limited colour etc). Beta BASIC takes the Spectrum a long way onward as a programmer's machine. Others may be drawn by the multi-tasking, the machine code support and graphical gloss of Mega BASIC.

If you want to push pixels around the screen then Laser BASIC is great, but the code needed is hard to read and hard to debug. At present you can't use Laser BASIC in commercial games without infringing Ocean's copyright, but a run time system, misleadingly called the Laser BASIC Compiler should be available for £9.95 by the time you read this. I don't expect that there will be many takers.

Laser Basic
Publisher: Ocean IQ
Price: £14.95
Memory: 48K

Laser Compiler
Publisher: Ocean IQ
Price: £9.95
Memory: 48K

Laser Basic is all about sprites.

What is a sprite? Well, it's an object which can move across the screen - a monster or a bus or a space invader - independently of other objects or the background. The dream command in Basic would be something like LET SPRITE(1) = LEFT+1 which would move sprite number one a square to the left.

Alas, you can't do that sort of thing on the Spectrum without writing a lot of routines which make the whole operation extremely slow, especially if you've got lots of sprites on the screen at a time. Laser Basic is designed to provide a comprehensive set of extra commands which you can use to manipulate sprites.

What you get is a set of programs, including a demonstration game of 3D Noughts and Crosses, which, between them, provide the various necessary facilities. Laser Basic itself occupies about 8K of memory at the top end of the RAM, but the amount of extra space used to store the sprite data obviously depends on how many sprites you define for use. Two sets of sprites - 109 in all, ranging from small spacecraft to large steam trains - are thoughtfully provided.

There are 138 commands added to Basic, which fall into various categories. The toolkit provides a renumber facility and a monitor command, which runs a program line by line so you can follow it through. A set of graphics variables contains information about the position and nature of different sprites.

A set of commands puts the contents of a graphics variable into an ordinary Basic variable where it can then be changed under normal functions.

Further sets of commands scroll the screen, or attributes, a number of pixels left or right, up or down. You can choose whether to have your sprites wrap around the edges of the screen or simply disappear. Another group of commands is concerned with dropping sprites into the screen or taking data from the screen and turning it into a sprite. A final set gives inverse, mirror and rotate functions on pre-defined sprites and their attributes.

If you are beginning to get confused by all this technical stuff, be warned - Laser Basic is immensely powerful but does not welcome the novice. That is not because the program is badly implemented - far from it - but because the very nature of the programming is complicated. If you don't understand how ordinary Basic Spectrum graphics work, you will be completely at sea with Laser Basic.

For those who do understand the ins and outs of graphics programming, however, it's excellent utility. The separate sprite designer program allows you to create all the sprites you need by using methods similar to those of UDG generators - except in this case you are not limited to a single character square but can work on a grid of up to 15x15 squares - larger if you tailor the size to your needs first. The resulting data is then saved as a sprites file to be used with Laser Basic itself.

The one drawback to the whole thing is that you can't run your program without Laser Basic present in the memory - obviously the Spectrum can't interpret those new commands by itself. Ocean IQ has therefore produced the Laser Compiler, which allows you to compile your programs into machine code which will then run on its own. It's simple enough to use, runs very fast, and occupies less memory than the Laser Basic program, thus ensuring that anything you write will be short enough to compile.

The booklet suggests that the Compiler can improve ordinary Basic by a speed factor of two, whereas it's much better with Laser Basic programs. We found virtually no difference at all on test programs in Basic involving arithmetic, looping, and graphics. Nor was there a marked improvement on the speed of Laser Basic, though scrolling functions were definitely smoother.

This is not surprising - the compiler is very small, only makes one pass and clearly does not optimise the code in the way programs like Blast! attempt to do. You should not buy the compiler on its own if you expect major savings in the speed of your programs - it's simply not worth it. As a tool for persuading your Laser Basic efforts to run on their own, it is essential.

Also essential are microdrives, if you want to get anywhere without winding up knee deep in cassette tape.

While the 75-page manual is daunting, it's full of example programs and routines to illustrate all the commands. The sprite selections provided are well-drawn and cover most of the usual objects and monsters.

The programmers were responsible for White Lightning, the classic games writing utility, and have kept up the standard with Laser Basic. While it is likely to have a rather limited market, it is certainly a highly satisfactory package for the budding games programmer.

MACHINE: Amstrad CPC 464/664/6128; Commodore 64/128; Spectrum 48K/Plus
SUPPLIER: Ocean
PRICE: Spectrum (£9.95), C64/128 (£19.95 tape, £24.95 disc); Amstrad (£19.95 tape, £24.95 disc)

The advertising literature for Ocean's Laser Basic claims to "turn your computer into a professional games writing machine for fun and profit." Quite a bold statement to make especially when you consider the number of games on the market for the machines it is written for; namely the Amstrad (464/664/6128), Commodore (64/128) and Spectrum *48K/plus).

The program does come with a proven pedigree though, having been released through Ocean by the people who brought you the much acclaimed utility White Lightning.

The package looks like an oversized video cassette case which contains the manual (which is an attempt to stop piracy has been published black on coloured paper, blue for the Amstrad, red for the Commodore and green for the Spectrum), the cassettes which contain the Laser Basic Extension program, sprite generator, demo program, and some already pre-defined sprites. The Amstrad and Commodore versions also have a Sound Generator and sound sprites which are sadly lacking on the Spectrum.

The manuals are concise and have lots of small worked examples to follow. Mind you, in the Amstrad version you get over 200 new commands, over 250 on the Commodore and 100 on the Spectrum.

But don't be put off. It's like any new language, you will find that some of the commands will be used often and for others you will need to refer to the manual.

After all that, what can Laser Basic actually do!!? I'll take the Amstrad and Spectrum versions first. Laser Basic gives these two machines full sprite manipulation capabilities only dreamed of by the manufacturers. It is possible, of course, using machine code, to program and control sprites but, unless you are fully conversant with Z80 mnemonics, this is not an easy task, especially if you wish to control a number of sprites such as those found in programs like Jet Set Willy and Manic Miner.

After loading the Laser Basic Extension the user can then do a multitude of things with sprites, these include moving them in any direction on the screen, up, down, forwards, backwards, behind or in front of other sprites, and you can move them along pre-determined paths. You can also detect collisions, expand, shrink, rotate, inverse and duplicate sprites without corrupting any other data. Other commands enable you to window or change the colours of the sprite of your choice, using up to 255 sprites at any one time.

Mindboggling!

Not only that, the program has its very own interrupt facility for even smoother graphics.

The sound capability of the Amstrad is fairly well known but even here the capabilities of the machine are enhanced by the addition of commands not only to make the beeps and hoops normally associated with games but the complex tunes you may have had difficulty with previously. You can even assign a particular sound to a particular sprite character.

The Commodore version is a little different to the other two reviewed because of two main reasons - Commodore's poor basic and it already has a hardware sprite facility.

So Laser Basic for the machine contains not just extended interpreter for sprite manipulation but an extended Basic as well which gives the 64 some of the capabilities of other machines.

The program not only allows the user to control software sprites in a similar manner to those of the other two machines but also includes a variety of commands for manipulating the hardware sprites as well. When you consider the amount of time, space and effort needed using the poke statement, the package is nearly worth while for that alone. Again, the sound capabilities are dealt with in a similar vein to those of the Amstrad.

The only real criticism of Laser Basic is the fact that it needs to be resident in the machine to run any programs written using it, although Ocean have released a Laser Basic Compiler for the Commodore and Spectrum (the Amstrad version is not completed yet) which allows you to compile your Laser Basic programs and run them without the main program. This is of course an extra program, but you can market any game without paying any royalties to Ocean. Nice idea.

When you consider the cost of present day games for the above machines, Laser Basic must be real value for money. I've had as much, if not more, fun with it than many of the games I've come across lately. If you have any doubts about buying the package ask the shop to load the Demo program for you then stand back and enjoy the show, I'm sure you will be as impressed as I was.

ZAPPING YOUR GRAPHICS

ZX looks at some utilities that can help put some life into your graphics displays.

Marketed by Ocean but written by Oasis, this is a very comprehensive package intended to 'enhance the ease, and particularly the speed, with which complex animated graphics can be produced'. Over 100 extra commands and functions are provided to this end and all operate from within BASIC. The program has a lot in common with Oasis' White Lightning, but concentrating purely on graphics means that you do not have to learn Spectra Forth, as essentially the same commands are used as with their ideal language.

There are a few changes, mostly names of commands to aid clarity, but basically this appears to be a stripped down, but still very powerful, version of White Lightning.

If you already have White Lightning then you will not get a great deal from this program, but, if you do not have WL and want a slightly simpler program which is essentially for graphics work then LASER BASIC is ideal. But be prepared to spend time learning to use it.

Ocean IQ, £14.95.

THE LASER GENERATION

Ocean's utilities label, Ocean IQ, kicks off with the first of their Laser series of programs.

Don't be misled by the titles of these programs, Laser Basic will not give you QL-style BASIC on your Spectrum, and the Compiler is not a rival for BLAST. Laser is an advanced games designing package, for programming top quality screen movement in BASIC. Although Laser Basic supplies four 'toolkit' commands - renumber, remkill, trace and procedure - the other 110 extra new BASIC commands relate to sprite handling, animation, screen window creation, scrolling, attribute handling and the like.

With so many new commands, this is not an easy program to master. It is essential to go through the (excellent) handbook trying out the examples, and you will still need the book beside you while you create your own games. This has enabled Ocean to use an ingenious anti-piracy device.

They have produced the handbook in a form which cannot be photocopied and under no circumstances will they supply new copies. Since it is useless without the handbook, they have not built anti-piracy devices into the program. There is a menu option for making Microdrive backups, and I had no difficulty in breaking into it to change the commands to use Wafadrive.

ZAP!

Any doubts about the quality of BASIC-driven movement were dispelled by the demonstration program supplied. One particularly impressive screen has cubes, one with a little man jumping up and down on it, moving across the screen at varying speeds and passing behind and in front of pillars, while at the same time a spaceship antenna whirls and a clock pendulum swings. The movement is smooth and flicker-free. The demo program listing in the handbook shows that all this activity is generated by a 19-line BASIC subroutine!

Movement can be created by scrolling all or part of the screen - the user can define as many windows as required - by moving, animating or scrolling sprites, or by a combination of these. You can even define a window within a sprite Sprites can be moved about the screen without affecting the background, spun, mirrored, inverted, enlarged or scrolled. Scrolling of sprites, screen or windows may be vertical or horizontal, with or without wrap, and the number of pixels to scroll may be specified. Up to 16 SETS of parameters may be used to define windows, to hold sprite numbers and position information, or to hold key codes for keyboard scanning. Using the SETS speeds up the program running, but parameters can also be programmed directly in BASIC.

Up to 255 sprites may be held in memory at once, depending on their size, and there is a separate generator program for designing them. The designer has two screens. One, an 8x8 grid, is used for designing one character square of your sprite. You then place this, using cursors to specify the position, on the larger screen which is 15x15 character squares in normal size. If you need larger than 15 squares in any direction, you must design two sprites and use them side by side in your game.

I found that the 8x8 grid made it difficult to design a large sprite on screen. One character square is too small a window to judge the finished effect and I found it easier to design the sprite on graph paper first. However, this might not be a problem to someone with a surer artistic touch than mine. You can also enter decimal or hex data, which generates your sprite on the larger screen. When the sprite is complete you specify its height, length and file number and save it in memory. The sprite file may be saved on tape or microdrive in two ways. Option 1 allows reloading to the generator for modification, whilst Option 2 enables you to load in Laser Basic to design your game. I found that you must save them twice using both options. I designed 25 related sprites to animate a galloping horse, loaded them into the Basic, and the horse galloped across the screen leaving a trail of disembodied tails and rear legs because I had forgotten to give the sprites a trailing blank square to wipe out the previous position. Because I had not made an option 1 save I couldn't modify them and had to start all over again. (You don't normally use so many sprites in animation - I was experimenting with hi-res movement, which the programme handled impressively).

Designing related sprites is easy. You can rotate, invert, mirror your sprite, move it across its background or make alterations to a small area and save the altered design as a new sprite

D.I.Y. GAMES

When your game is complete, you may wish to market it, in which case it must run independently of Laser Basic. This is where the Compiler comes in. You use it to compile your Laser Basic to machine code which, when SAVEd with a running code from the Compiler, your sprite file and a loading program, will allow your game to run without Laser Basic being present. While the compiling is going on, the program gives an alarming imitation of a machine code crash, with colours and lines flashing on the screen. This is normal, because the display file is used as a workspace. You can use the Compiler to compile ordinary BASIC programs, but there is little point in it. The time saving is only a factor of two or less, and space saved is lost again to the running code. Also there are limitations on the BASIC program structure that the Compiler can handle.

Ocean place no restrictions on the marketing of programs produced using Laser, and they require no royalties. Laser is expensive, but the games designer or anyone interested in graphics and animation will find it worth every penny.