Adventure Trail


Programmer ANTHONY BAILEY finds adventure-writing made easy in the utilities GAC and PAW — which produce those good, cheap home-grown games

On the Spectrum adventure scene, 1987 was a lean year with few major releases. Games costing more than £3 were rare, and even the ubiquitous budget range was outnumbered by a mass of mail-order home-grown software. The commercial releases were distinguishable only by their packaging and sometimes their graphics, but the quality of ideas and writing to be found in the best home-grown adventures was of a very high standard.

The reason for this preponderance of good software is that adventure utilities have at last come of age, allowing many amateurs to produce a professional-looking adventure. Of course, if you want to write something worth playing, you’ll still need a flair for atmospheric prose and a good imagination!

This article compares the two major adventure-writing utilities, those awkward-sounding acronyms GAC and PAW (Incentive’s Graphic Adventure Creator and Gilsoft’s Professional Adventure Writer).


If you’ve used any of the so-called ‘arcade-game generators’ you’ll no doubt have noticed that all they really let you do is alter movement patterns, graphics and the map of a game rather than allow you to design anything really innovative or different. But there’s much more freedom in what you can do with an adventure creator. Though Gilsoft’s The Quill tends to produce adventures with a rather cloned appearance, GAC and PAW offer the user more opportunity to change the look and style of the game.

Most adventures can be divided into three main segments. There is a database which contains such things as all the text describing locations and objects, and the messages and vocabulary. There’s a parser which allows the player to type in a command and then decodes the input. And there’s an interpreter: this is the heart of the adventure, where the computer examines the player’s input and works out what messages or location descriptions should be output. Essentially, the interpreter is the part which handles the exchange of information between the player and the computer.

When a programmer writes an adventure from scratch, he has to write the parser and interpreter in machine code. Now with an adventure-creator there is no need to write any code — the utility supplies the parser, provides the bare bones of the interpreter and then allows you to describe the rest of it in terms of English words and expressions. For example, with PAW if you want something to happen only when the player is carrying a certain object you use the word CARRIED. In effect you are using a very simple and user-friendy programming language.

PAW and GAC are both rather good adventure creators and deserved the Smashes they received when reviewed in CRASH (in Issues 40 and 32 respectively). And they cost the sane: £22.95 on cassette, £27.95 on microdrive (there’s now a +3 disk version of PAW as well).

But which utility is more useful?


The packages are similar. Their presentation tries hard to justify the apparently high price tag; a single cassette wallows in a huge plastic case. The cassette contains the main program and a ‘quick start’ database with some basic vocabulary command, along with short but impressive demonstration games, and in PAW’s case some alternative character sets.

GAC has a well-written, informative, detailed manual; the two PAW manuals are excellently written, with straightforward, chatty prose in the introduction and further detail and a reference section in the technical guide. So the new user should have no problem getting to grips with the utilities straight away.

PAW allows 16K of program to be written straight off, and from then on it will overwrite parts of itself which are automatically reloaded from tape if they are required again. This technique allows another 11K of space to be used (giving a total of 27K per game). And if you have a 128K Spectrum PAW takes full advantage of the extra memory and lets you write a massive 117K adventure!

But GAC games sit complete in memory, giving you about 23K of free memory to write in. But Incentive doesn’t plan to release a 128K version of GAC in the near future.

There’s a simple menu at GACs front end; selecting an option from this takes you through a series of question-and-answer inputs. Pressing BREAK takes you back to the main menu again.

The PAW system of menus and submenus will be familiar to users of The Quill. Both systems are user-friendly, though PAW scores by allowing the author to view a scrolling list of all the entries made; GAC will only display them individually.


Both utilities have advanced parsers which allow sentences with up to two nouns, a verb, an adverb and a preposition. These sentences can he chained with conjunctions or punctuation to create really complex commands.

And both programs will recognise IT, so GET RING AND WEAR IT is catered for. PAW allows you to qualify a noun with an adjective, so the finished game can differentiate between OPEN RED DOOR WITH SMALL KEY and OPEN GREEN DOOR WITH LARGE KEY.

GAC splits vocabulary into three categories: verbs, nouns and adverbs/prepositions. Up to 255 words are allowed in each category, and as many as you desire can be synonyms (for example, GET and TAKE can be treated by the parser as the same word).

PAW is similar, but subdivides the vocabulary into seven categories: verbs, nouns, adjectives, adverbs, prepositions, conjunctions and pronouns. Again 255 of each type are possible. And PAW treats the first 20 nouns in its vocabulary as ‘conversion nouns’: in other words, NORTH (noun 4) is treated as a noun in the command LOOK NORTH, but is converted to a verb if entered on its own. Nouns 1-50 are not recognised by IT — so as long as the author plans the vocabulary correctly, when the player types GET SWORD AND ATTACK GOBLIN WITH IT PAW will spot that IT refers to the sword and not the goblin.


GAC can cope with up to 9,999 locations but PAW can only manage 252; still, this should be sufficient even for a 128K creation. GAC offers 255 messages for the author’s use; PAW allows these messages, too, and also has another 255 system messages. Some of these are used by the interpreter and can be altered, but most are free for the use of the programmer.

User-friendly adventures require a lot of messages and the writer of a large adventure may well find himself pushed for space.

Up to 255 objects can be implemented with both utilities. Commendably, both GAC and PAW let you define the weight of each object — thus a chest of treasure can take up more space than an apple does in the player’s inventory.

And to ease the creation of automatic get/drop/wear/remove commands, PAW asks the author which vocabulary noun and adjective correspond to each object, and also inquires whether it is wearable, a container, or both.


Your adventure can be text-only, or use graphics; GAC has a fixed picture size, but PAW is more flexible and allows pictures of any size. And in PAW some text can be kept onscreen while other text scrolls beneath it. If you feel ambitious, and you have memory to burn, you could use pictures created with art utilities in PAW by calling an outside routine with the EXTERN command!

Anyway, reasonably good graphic scan be simply produced with both systems. They employ the ‘drawstring’ technique: all illustrations are stored as a list of the commands that were used to create them.

The pictures are basically formed by drawing and filling shapes. Both packages offer ‘elastic’ lines, and GAC goes one better with a facility for elastic rectangles and ellipses. But GAC has only two fill patterns; PAW offers 15 user-definable shades and the ability to create extra character sets, definable on the utility’s character-generator (it’s rather cumbersome and art utilities are easier to use).

Pictures can be called as subroutines (which can be scaled, in the case of PAW) so that repetitive illustrations take up very little of that precious memory.


When it comes to testing out the adventure, both GAC and PAW have useful options which allow the user to examine the status of the various flags and program counters during play. This is great for debugging.

PAW allows experienced users to manually change the values of these flags in the middle of a test. GAC has 256 on/off switches and 128 variables that can hold values ranging from 0 to 255; PAW just has 256 such variables. Naturally, all the normal facilities such as saving and loading the database and checking on the amount of memory left, are available on both programs. PAW also has a superb text-compressor which replaces common combinations of letters with single bytes in memory and effectively gives you 40% extra text space — great for writing 48K games.


The meat of the finished adventure is the set of tables of instructions and commands which deal with all the inputs and actions of the player. GAC offers three types of table: high-priority, low-priority and local conditions.

The high-priority table is checked first of all; in play, that’s where the program checks whether the player is in darkness, for example. Low-priority conditions include such things as responses for GETting an object, and local conditions apply only to specific locations; OPENing a DOOR would be covered in the local-conditions table, for instance.

Each table consists of a sequence of lines with a format of IF (conditions) (actions) END so a typical line might read: ‘IF (VERB (18) AND ( NOUN (50) OR NOUN (51))) MESS (20) WAIT END’ which gives the conditions the look of a simple programming language.

It’s a shame that syntax errors within a line are not highlighted, and that only one line can be viewed at a time — once programs get complex this makes debugging rather awkward. But GAC is flexible in that all numbers can be replaced with arguments such as the contents of a certain flag or a random number; this allows you to implement such things as random messages. The CONN condition (equivalent to MOVE in PAW) is especially useful.


PAW’s approach has some differences. Two types of table are used, response and process, and each entry consists of a verb and a noun (which can be set to nulls) followed by a series of ‘condacts’ — Gilsoft’s jargon for a mixture of conditions and actions.

In a response table, PAW looks for a match between the player’s input and the verb and noun and then carries out those entries. Unlike GAC, PAW caters for entries for GETting, DROPping, WEARing and REMOVing objects as well as for GET ALL, DROP ALL, WEAR ALL and REMOVE ALL.

The condacts are rather more varied than their GAC counterparts, with commands such as EXTERN (which allows you to call BASIC and machine-code routines from within PAW), RESET (which helps in the creation of multipart games), PARSE (which decodes anything within quotes in terms of a new command), TIMEOUT (allows the computer to animate graphics or move around game characters whilst the player is thinking), PUTIN and TAKEOUT (for dealing with putting objects within one another; PAW calculates the true weight of a container), and a very powerful DOALL command (which allows the author to implement his own ALL and ALL EXCEPT commands). Some of these facilities can be simulated with GAC, but PAW makes everything elegantly simple.

The process tables operate in the same way, but the verb and noun are used simply as a label for the author’s own reference. Process 1 is called every time a location is described, and is the equivalent of the GAC high-priority table. Process 2 is called after every input or timeout, and this is where events beyond the player’s control take place. The best facility of all is PAW’s ability to create another 253 subprocesses, which can then be called as subroutines from response or process tables. Calls can be nested up to ten levels, and the processes can even call be recursive (call themselves). Sensibly used, this facility contributes to programs which are beautifully structured and hence easy to debug and alter.


GAC is an excellent utility. But if you haven’t got yourself an adventure creator (and if not why not? — they’re tremendous fun!) the flexible and friendly PAW is the one to go for. It’s probably the best utility ever written on a Spectrum and it should turn the adventuring world head over heels.