A Short History of My Adventure Games

26th April 2001

From my earliest programming days, I've been writing Adventure games. In the decade from 1980 to 1990, I started more than twenty, although I have done much less since then - I guess this is a downside to programming for a living. This document is a more or less exhaustive list of all the Adventure games I've written, in chronological order.

1. Early TRS-80 stuff (1980?)
2. Derivative VIC-20 stuff
3. Early VIC-20 stuff
4. The unnamed Dracula Adventure
5. Zonk aka. Anaujiram aka. Sarg (1981-1983ish)
6. Quest (1982?)
7. Adventureland
8. Magic Mirror (1982)
9. Nosferatu (1982)
10. Heaven and Hell (1982?)
11. Stairway to the Stars (1982?)
12. The Final Challenge aka. Cornucopia (1983?)
13. Unnamed, unwritten, half-formed design
14. Nemesis aka. Causes of Chaos (1985)
15. Camelot (around 1985)
16. Lamp-post (1985ish)
17. A Quilled SciFi Thing
18. Crystal of Chaos
19. Zonk again
20. The Rabid Wombat Strikes Again
21. adv (1987)
22. MU aka. MUNDI (1988)
23. Herring (1990 to the present day)
24. sac, the Scott Adams Compiler (2001)

1. Early TRS-80 stuff (1980?)

Around 1980, my friend Myles Kelvin was lucky enough to get access to a computer - his dad bought it to do accounts on. We played Scott Adams' Adventureland, and were impressed enough to want to do something similar ourselves. So we wrote a bunch of DATA statements in TRS-80 level 2 BASIC. They contained text to describe dragons, castles etc., though we didn't have any clear idea of what we would do with them. The answer eventually turned out to be: nothing.

2. Derivative VIC-20 stuff

Some time shortly after that, the wonderful Practical Computing magazine brought out an issue that was all about adventure games (March 1982, apparently). It had wonderful artwork on the cover: an archaelogist crouching down and brushing debris away from an oddly regular-shaped rock, to discover that it's a key on the keyboard of a gigantic stone computer. Very evocative! I would love to find a copy of that ancient magazine, but all attempts so far have met with failure. [Update: As of August 2006, I have a copy of the magazine thanks to Diana MacKay who read this page and kindly sent it to me. I scanned the cover.]

Anyway, in among all the articles that seemed to be from another world - describing mainframe adventure games with hundreds of locations! - was one that was more at the level I could work at: an infinite 3D maze program for the Commodore Pet (easy to adapt for a VIC-20), which generated the maze from a random-number generator seeded by the player's co-ordinates. Very elegant. (I wrote a very simple reimplementation in Perl a while back, which you're welcome to if you'd like to see it.)

I extended this in small ways - for example, by explicitly placing a small number of ``treasures'' in difficult-to-reach places.

3. Early VIC-20 stuff

Three or four more or less identical games arranged in a solid 3D grid (3x3x4, as I remember), with very primitive navigation facilities and perhaps no other verbs at all. In retrospect, the 3D layout was obviously a blind alley - I think I had been led there by the clear physical framework of the infinite maze.

4. The unnamed Dracula Adventure

This was my first ``real'' adventure game, co-written with Myles on his dad's 48k Video Genie (a TRS-80 clone). The Dracula theme was probably inspired by the knowledge of Scott Adams' game The Count, though neither of us had actually played it at the time.

It used an ``parallel linear array'' data structure, (what we now call ``a FORTRAN array of structures''), which survived essentially unchanged right through to the Commodore 64 Zonk. There were two sets of arrays representing locations and objects:

5. Zonk aka. Anaujiram aka. Sarg (1981-1983ish)

Also co-written with Myles, this much larger game was inspired by adverts for Zork: we'd never seen the game, or ever read a review, just a full-page advert for Zork as resold by Molimerx software! We were so impressed with details of the huge size (as it then was) and such novel concepts as storing part of the game on disk, that we decided to try to emulate it.

Zonk, as it was originally called, read location data and bitmapped graphics from fixed-length records in a random access disk file. The fixed length was marginally over 1k, and the bitmaps were able to fit comfortably in this space, since they were monchrome 128x48! (Actually, the TRS-80 had a 64x16 screen, and among the characters in its 8-bit-wide set are the 64 possible combinations of six on/off blocks packed into a character space, two across and three down. This means that the bitmaps contained text and pictures built from puncuation characters as well as the bitmap stuff).

As far as I remember Zonk eventually grew to about 120 locations with six or seven full-screen graphics - by which time, its name has changed to Anaujiram, and eventually to Sarg. (Yes, both of these names are rather peurile backward spellings of drugs. And we thought we were so clever.)

It being the early 80s when floppy disks were a dangerously exciting novelty, we had to write a bespoke program for creating the disk-file with the locations. And of course we needed a bespoke image-editing program too.

In addition to the ``real'' loctions, Sarg included a 125-location 3D maze (5x5x5), implemented as a basically separate program embedded in the main one. It was called ``The Maze of Arnold F. W.'', a very cryptic bow in the direction of Pink Floyd's Final Cut album which we were listening to a lot at the time - this gives a rough dating of the game.

At the time, we were very proud of Zonk. This just shows what you can get away with by means of never having played the real Zork.

6. Quest (1982?)

This was a substantially enhanced re-working of the Practical Computing infinite maze for an unexpanded VIC-20, with monsters to fight, treasure to find, etc. It's mostly interesting because it was the first program to earn me any money - thirty pounds or so for publication as a listing in the back of Your Computer. There's a good chance that I still have the pages with the listing on, somewhere, but I can't imagine where. If I ever find it, I'll put it up on this web site.

The guys at the magazine hadn't told me they were going to use my program, so when I saw it in the magazine, I didn't immediately recognise it as mine - I thought to myself, ``this seems like a good game, I think I'll type it in''! Ah, the thrill of sudden realisation!

7. Adventureland

This was a partial reimplementation of Scott Adams' Adventureland, which I did to check that my system was sufficiently powerful to express all the sorts of things I needed to be able to say for my own games. I don't think I bothered finishing it.

8. Magic Mirror (1982)

This was the first ``real'' Adventure that I had published. It's described in much more detail in its own section.

9. Nosferatu (1982)

My follow-up to Magic Mirror, described in much more detail in its own section.

10. Heaven and Hell (1982?)

This was intended to be number three in the Magic Mirror series, but although I finished it, it never got published somehow. Probably named after the Black Sabbath song (this is the sort of stuff I was into in those days), it was intended to be the most difficult of the sequence, with one innocent mistake early on preventing completion at a much later stage.

The idea was to start on the Earth, get yourself killed and thus progress to Hell, and eventually find Jacob's Ladder, which could be climbed into Heaven. (Er, my theology has moved on a bit since then! :-)

11. Stairway to the Stars (1982?)

Number four in the series, and named after another Blue Oyster Cult song, this was all about getting as high up as possible, climbing beanstalks, ladders and all sorts. I can't remember much more about it now, and it too was never published.

The four games in the Magic Mirror series were all written very close together, in a matter of a few months. I had my game mechanics all worked out, and I was on a roll with the plotting. I wish I could remember now why they didn't make it out there into the hands of the public - the way I remember it, it just sort of never happened, which I think is a real loss. Apart from anything else, it means that I've lost whatever chance I might once have had of playing these lost games again.

12. The Final Challenge aka. Cornucopia (1983?)

This was the last complete ``straight'' adventure game I wrote, and I guess I probably had this in mind when I called it The Final Challenge. It was very much in the mould of Magic Mirror et al., and was intended to cap the series, though as far as I remember, Terminal Software never even got to see it.

Unlike the other games in this series, it required a VIC-20 with not 8k but 16k expansion - and since I didn't own a 16k board, I had to borrow one from a school-friend, Richard Monk, in order to write it. Seems strange in these days when 4M of memory is considered woefully inadequate. [Meta-note: I wrote that last sentence in 1997 or '98. As I write now, in 2001, 4M is truly laughable - most people now consider 64M unusable. No doubt by the time you read this, people will look sniffily on any computer whose memory is so tiny as to be measured in something as piddly as megabytes. Plus ca change.]

Of all my games that have been lost to posterity, this is the one that I would most like a chance to play again. I remember it somehow being invested with a strong sense of atmosphere, and having more-interesting-than-average puzzles. I have often tried to recapture elements of the plot to Cornucopia, as it rather bizzarrely ended up being called, but I have never succeeded to my own satisfaction. I particularly remember a tricky initial portion, necessary to get into the caves where the game took place, and a huge underground cavern with trees growing in it.

13. Unnamed, unwritten, half-formed design

About this stage, I invented Lords of Midnight - in particular, the technique known as ``landscaping'', whereby graphics illustrating the various locations are generated on the fly, on the basis of a semantic notion of the sourrounding objects. Unfortunately, Mike Singleton rushed out his version while mine was still at the chemist's, and made four million pounds more than me - just like Alfred Hitchcock's remake of Mr. L. F. Dibley's film, Rear Window.

The ``design'', to dignify it with a more complete name that it deserves, was sort of inspired by the Ravenloft AD&D module, which was unusual in that the main bad-guy - a vampire, in this case - was interesting in his own right, was a man with a mission rather than mere combat-fodder. At the time, that was unusual enough in AD&D, and absolutely unheard-of in computer adventures. (Of course, it was only unheard of because I'd only read Zork adverts, never played the game - and therefore, I'd never met the thief.)

14. Nemesis aka. Causes of Chaos (1985)

This was the biggest thing I did commercially. I believe it was the first (only?) multi-player adventure for the Commodore 64, though this had to be achieved by the players taking turns. In all honesty, I doubt anyone really played it like that, but it was a good single-player adventure anyway.

There's much, much more about CoC on the Causes of Chaos section of this site.

15. Camelot (around 1985)

This was to have been the follow-up to Causes of Chaos - a multi-user adventure game based on the Arthurian mythos, with a whole bunch of new features over and above CoC. In particular, a range of characters were available: Arthur, Lancelot, Galahad, etc.; and they each had their own particular abilities: Arthur's leadership, Lancelot's strength, Galahad's purity, etc. Players could assume the role of any character not already being used by another player, so that even a single player could dispatch the various characters to different tasks simultaneously. In retrospect, this is a somewhat Lords of Midnight-ish notion, though I didn't have that in mind at the time.

Technically, this was a small step forwards from Causes of Chaos, in that I started to formalise the separate notions of players and characters, and consequently to think in more abstract terms. Only a small step, though.

I also wrote a lot of stuff to do a limited form of graphical combat (based primarily on reaction speed), and got as far as coding up the first twenty or so locations of the game, with their objects and some puzzles. The game foundered not for technical reasons, but simply because I lost momentum on designing the game's plot: the ideas just wouldn't come, probably because of the limitations of Arthurian Britain. This is a shame because (A) I would have made a lot of money, and (B) I had some good ``grand scheme'' ideas for the plot - in particular, that it would not be possible to win the final battle: Arthur always loses, in the manner of a Grand Tragedy.

The Camelot introductory screen was a lot prettier than the Causes of Chaos one: in particular, I was able to design separate Olde English sprites for each of the letters of the word CAMELOT, and slide them on to the screen one at a time, which was a very nice effect. There were vague plans to make a loading screen by videoing the members of the church I was then a member of, dressed up as knights, and digitising the result - this gives a rough date for the game, since I must have been seventeen or so.

16. Lamp-post (1985ish)

At about this time, I took some time out from my more ``serious'' adventure programming; and I hadn't had so much fun in ages. Ian ``Zobbo'' Cottee and I wrote this game together, at his house, using Gilsoft's Quill, as a sort of a ``B-side'' to his altogether more serious, though still rather silly, Zob. Borrowing thematically from Graham Chapman's colonel character (``Silly, silly, far too silly!''), packed with wardrobes, custard and Van der Waals forces, the entire game was so linear that it was virtually impossible to fail to solve it. But what fun. After all these years, wardrobes survive as a major thematic force in my game design.

17. A Quilled SciFi Thing

I wrote this at home - don't know why I bothered really, I guess I just enjoyed the ease of Quilling rather than programming for a change. It was set in the far future in a devastated post-holocaust earth, and involved time travel, done by means of a time machine in a museum: a strange coincidence, since I had never played Zork III at that stage. Since this involved no programming, and I never finished plotting, this didn't really add much to my portfolio.

18. Crystal of Chaos

That was enough with the Quill already! I went back to the more flexible and powerful system I'd used for Magic Mirror as suchlike, to write Crystal of Chaos. This was interesting only from a plotting point of view. While it did nothing new technically - indeed, it was a backwards step from Causes of Chaos and Camelot - it added new elements such as magic (in a book of spells), and had more than one possible solution to most of the puzzles. This meant that it would be possible to get quite a long way into the game, only to find a puzzle that couldn't be solved because the necessary objects had been ``used up'' in solving earlier puzzles in a non-optimal way. Interesting that here, as in other games, I unwittingly paralleled work done by Infocom: the spell book and multiple solutions were both to be found in the Enchanter/Sorcerer/Spellbreaker series. I guess all good ideas are obvious ideas in the end.

Like most of the games I wrote in this period, it was never what you could call ``finished'' - I think my mind was going too fast for my typing fingers to keep up! But There was enough of it that it would be interesting to play again (in particular, I'd love to know the details of the puzzles.)

19. Zonk again

By this point, I'd realised that the whole multi-player thing was a red herring while I was working on single-user computers (how did it take me so long?!), so I shelved that whole line of work until such time as I had access to multi-user computers.

In the mean time, I decided with Zonk to concentrate on using the C64's capabilities more fully, and on playability. This meant that in programming terms, there were more new ideas here than in most of my games. One detail was that I built infrastructure that allowed me to use all 64k of the 64's RAM, by storing text in the 16k that's ``hidden'' behind the kernal and BASIC ROMs, swapping the necessary blocks in and out as necessary with little machine code routines.

A more significant change was that I finally broke away from the old two-word ``VERB NOUN'' input format, allowing multiple-word noun clauses; and there was a certain amount of intelligence in understanding what the player intended. For example, the game included (among other things) a stone key, a bronze key, and a bronze statue. If you said ``GET KEY'' when both were present, the game would ask which you meant, so that you had to say ``GET BRONZE KEY'' - or just ``GET BRONZE'' for short, although of course that would also be ambiguous if the bronze statue was also present. But if you were carrying one key and the other was present, then ``GET KEY'' would do the right thing. And ``DROP KEY'' would do the opposite, but also right, thing. Cool.

One other innovation (for me - good games had been doing it for years) was the introduction of what I termed ``abstract objects'' - things like ``self'', ``air'', ``ground'', etc., which are always there.

Zonk re-used some of the old Cornucopia puzzles (though lots didn't make it in, and thus were lost, most likely forever.) But there were a lot of new and very complex puzzles in there too - I particularly remember one insanely involved sequence involving an electrified floor, a negative gravity generator, a steel rope, a chasm and some rubber gloves (though, OK, I admit it, the details elude me!)

20. The Rabid Wombat Strikes Again

This hardly got started at all, but what did exist was driven by what little I'd read of a single inspirational piece of technology: text compression. I did the compression ``by hand'', using a set of infrequently-used characters to represent frequently-used words. (So far as I recall, there was no escape mechanism to represent those infrequent characters.)

21. adv (1987)

By 1987, I'd written about twenty adventure games in BASIC, all of them limited to varying degrees by the linearity of my data structures, which were basically parallel arrays. By then, I was at Warwick University, and I'd finally learned another programming language - C. Armed with C, and a bit of understanding of data structures other than arrays - and inspired by having read Richard Bartle's columns about MUD in Micro Adventurer magazine - I set out to build a much more ambitious game that anything I'd done before.

The big advances in what I was trying to achieve here were twofold. Firstly, I wanted to represent hierarchies of objects: for example, the herring is in the glass case, which is in the wooden box, which is at the forest clearing. And secondly, I wanted to build a ``real'' parser for the English language, using a formal BNF grammar expressed in yacc.

Neither of these goals was fully realised. The first one worked so far as it went, although it achieved containment using linear data structures and trickery with negative indexes and suchlike. In this, it pointed the way for what I was shortly to do with MUNDI, and then revisit with more suitable data structures in Herring. The second goal, I think, was a chimera: English is just not suited to formal parsing, in part because it's not possible for a lexical analyser to reliably identify words as being particular parts of speech. (For example, consider how to lex and parse the old chestnut PLANT THE POT PLANT IN THE PLANT POT.)

So I didn't get very far with adv (about two thousand lines of code) before I threw it all away and started again on what would become MUNDI. Fortunately for my own sense of history, I had the sense to archive what I'd done up to that point, and this distribution is essentially that archive.

(Also at around this time - in October 1987 - I wrote a short article, ``adv1.ms'' about how to write adventure games in BASIC. This was commissioned for a magazine that was edited by Ian Cottee's sister.)

22. MU aka. MUNDI (1988)

When I started thinking about how I could re-jig adv to work with multiple users, I quickly realised that the source was totally unsuitable, and that I'd do better to start again. What emerged was a new program, initially called simply MU (for ``Multi-User'') but quickly renamed MUNDI which has all sorts of meanings.

For much, much more about MUNDI, see the MUNDI section of my site.

23. Herring (1990 to the present day)

### - write this up!

I have an embronic Herring section.

24. sac, the Scott Adams Compiler (2001)

This is a very simple system for writing simple adventure games in the Scott Adams TRS-80 format, which can be run using ScottFree and similar interpreters.

Download links and documentation are in the sac section.


At the last count, that's more than 20 adventure games I have been involved in. Most of them I have designed and written myself, one or two have been co-written, and a few have never reached the degree of completion that merits the word ``written''. Still. It's plenty, isn't it?

Feedback to <mike@miketaylor.org.uk> is welcome!