Category Archives: Quest

15 years of Quest, part 2: 1999-2000

This is part 2 of a look back at 15 years of Quest – part 1 is here.

Immediately after releasing Quest 1.0, in November 1998, I got started working on Quest 2.0 – the first alpha version was released only a month later, in December 1998. This version incorporated the early feedback I’d received from v1.0 – making room descriptions more customisable, adding functions, numeric variables and “for” loops, improving the in-game debugging information, and fixing various bugs.

It seems surprising to me now that I didn’t ever do a bug-fix release of v1.0 – I guess that so few people were actively using it, and there were so many rough edges anyway, it must have made more sense just to plough on and pour everything into v2.0. And this was before I’d ever heard of source control anyway – in fact, I doubt I’d have even had any kind of backup copy of the Quest code at the time. (It was a time when I was constantly running out of hard disk space, when floppy disks were too small, before I had a CD writer, and before any significant amount of online storage space was easily available).

Over the following months I added more features – more text formatting options, allowing objects to moved and hidden, and libraries to allow Quest functions to be re-used between games.

It was all a nice break from working on my A-levels and filling in my UCAS form.

Quest 2.0 was released in August 1999, and for the first time included a beta version of a new visual Quest game editor called “QDK” – meaning finally you no longer had to code games using a text editor. (I would have called the editor “QED” but there was already a Quake editor of that name).

QDK 1.0

Editing a room in QDK 1.0

Editing an object in QDK 1.0

The script editor was very basic:

Editing a script in QDK 1.0

The main player interface for Quest 2.0 still looked pretty much exactly the same as v1.0 – which is to say, hideous. This was finally rectified in November 1999 with the release of Quest 2.1, which has a layout which is awfully similar even to the current version of Quest:

Quest 2.1

Quest 2.0 is the first version for which at least one actual game was made – and it’s still on, and it still works today, whether you download it or use the web-based player – The Adventures of Koww the Magician.

There are a total of 28 games on which were written for Quest 2.x – see if you can find them… (the column to the right of the game listing will tell you the version of Quest used to build the game).

The “libraries” feature got some early use, with Alan Bampton creating a “Standard” library to add some features, including containers – which Quest was still years away from supporting natively. This library was included with Quest itself as of v2.11. (10 years later, when redesigning Quest for v5.0, libraries became the way to add all functionality to Quest – without its Core library, Quest 5 does very little at all).

By early 2000 my thoughts were turning to Quest 3.0, which would be a huge update – I was getting lots of suggestions from users, and there were various aspects of Quest I wanted to tidy up – things which didn’t make sense to me at all any more, such as: why was “an object in a room” a separate concept to “an item you can carry”? It was time for the first of many overhauls of Quest. In the mean-time I carried on releasing bug-fixed versions of v2.1 up until Quest 2.19, which was released in January 2001.

Next time I’ll carry on with a look back at version 3.0 and beyond. If you want to peruse some archive material, the forums from 1998-2000 are still online.

Building Moquette – Simulating the London Underground and Doing Pretty Things With Text

Following on from the previous blog post (Moquette Post-Mortem and Review Roundup), here’s a look at how some of it was implemented.

Moquette was entered into the IFComp not under the Quest category, but as a web-based game only. Why? Because I used my latest development version – Quest 5.5, which is currently available only as an unsupported pre-beta “nightly” build. A downloadable .quest file was submitted to the IFComp for archive purposes, and will be made available from the Moquette page on when a beta version of Quest 5.5 is ready – which should be in the next month or two.

Some reviewers supposed that the text effects in Moquette might be a preview of new features in v5.5, but actually they’re not – you can do them in Quest 5.4 using the same JavaScript, which I’ll go into later in this blog post.

The changes in v5.5 as far as they apply to Moquette are cosmetic – I needed the ability to completely hide the location bar and game border, and to set a custom screen width. I also needed the ability to disable a command link after it’s clicked, and I implemented some changes to how scrolling works so there is a nice smooth transition when new game text is added.

Simulating the Tube

Moquette is full of contradictions. It’s a game, but it’s not a game. It has many choices, yet no choices. And on a technical level, it has many locations (a full tube map) and yet it really only has two locations – the train and the platform.

Everything else is just labelling of scenery. Get off one train, change to another line, get on a different train – as far is Quest is concerned, you’re just right back where you started.

The train has attributes to represent the line it’s travelling on and the station it’s at (or, if it’s in a tunnel, the station it was most recently at). It also counts turns – there is an overall turn counter, used to trigger plot events, and there is a rolling counter – every three turns, it triggers the next station on the line.

The platform has attributes to represent the lines that stop there, the direction trains go in for each line, and its location (station). At many stations, there is one platform in each direction for each line – but that’s not true for e.g. the Circle and District lines which share platforms.

There are objects for each tube line, and objects for each tube station. Tube station objects may contain hand-crafted data for platforms (if any platforms are for multiple lines), but otherwise the platform data is generated simply using data about which lines stop at that station. The format is simple – one attribute for each line which stops at that station. For example, Bank station is stored like this:

Bank XML

I started in the top-left of the tube map, at Paddington, giving the station an index of 100 for each line that stops there. Then I went along each line counting up or down. So, Bank ends up at index 110 on the Central line, 105 on the Bank branch of the Northern line, and 101 on the Waterloo & City line.

(I should really have added some code for the special case of Bank being linked to Monument, but I didn’t get round to it – few people noticed. Almost as if that was completely irrelevant to the plot…)

So, the code for moving around the tube network is pretty straightforward. But it wouldn’t be a journey on the London Underground with people. Lots and lots of people. Too many people.

Well, there are only 36 passengers in total in Moquette. Even if they were all on one tube carriage, you would still just about find a seat.

They are randomly assigned to each train when you get on. If you interact with them, that is recorded so that they won’t appear again. Every time the train enters a station, some of the passengers might get off and some new ones may get on – if you didn’t interact with them the first time, they may reappear later. This is why they tend to have fairly generic names such as “a man” or “a middle-aged woman”. I wanted you to get the impression that there were many more passengers than you were given the chance to properly look at.

In addition to the train and platform, there are locations for each of the plot events – the introductory part of the game is implemented as a sequence of rooms, as are the “visions” (the two smoking visions and the clay), the interaction with Heather and the interaction with Private Rod.

Text Effects

Quest has supported embedding JavaScript for a while now, and I wanted to show how this could be used for some effects to add a little bit of polish but without being too overblown.

A JavaScript effect is, in fact, the very first thing you see in the game. Quest’s function to initialise the user interface calls the following ASL:

JS.introScreen (GetFileURL("intro.jpg"))

This calls this JavaScript function:

function introScreen(url) {
     $("<div/>", {
         id: "introScreen"
         position: "fixed",
         top: 0,
         left: 0,
         width: "100%",
         height: "100%",
         overflow: "hidden",
         "text-align": "center",
         display: "none",
     .html("<img id=\"introScreenImg\" style=\"max-width:100%;max-height:100%;\" src=\"" + url + "\"/>");
     $("#introScreenImg").load(function() {
         setTimeout(function() {
         }, 7500);

function finishIntroScreen() {
     $("#introScreen").fadeOut(7000, function() {

The introScreen function hides Quest’s game output (which is entirely in the gameBorder div), then adds a new hidden div called introScreen containing the intro image. Once this has loaded, the function inside the call to jQuery’s .load() method is run – this ensures the image has always fully loaded before we show it. This fades the introScreen div into view over 4 seconds, and 7.5 seconds later calls finishIntroScreen to fade it out again.

finishIntroScreen first re-shows the gameBorder div containing the Quest output (which by now will contain the introductory game text), and then it fades out introScreen – to reveal the game text underneath.

Moquette Intro

The next effects occur in the first few turns – after Zoran gets on the first train, the text is nicely scrolled up and out of the screen, leaving it blank. The next effect occurs after the player makes the choice for Zoran to do something different than take his usual train today (or if Zoran makes that choice himself) – it’s the same effect again really, but this time the screen text is whisked off to the left.

Both of these make use of jQuery UI effects. These can be applied to any element, and the “drop” effect is the one used here. Quest calls:

JS.act0Clear ()

which simply calls this JavaScript:

function act0Clear() {
     $("#divOutput").effect("drop", {direction: "up"}, 1000);
     setTimeout(function() {
         EndOutputSection ("intro")
         HideOutputSection ("intro")
         HideOutputSection ("title")
         ASLEvent("FinishAct0Clear", "");
     }, 1500);

This calls the “drop” effect on divOutput, which contains the game output text (we could have used its parent, gameBorder, again I suppose as we’re not displaying an actual border around it). After this has run, the screen is empty, which means we can empty divOutput by hiding all the output sections on it (looking at this now with fresh eyes, that might be some old code as we clear the screen in a moment anyway).

We then call the FinishAct0Clear ASL function, which looks like this:

JS.reshowOutput ()
JS.StartOutputSection ("act01")
MoveObject (player, Act 0 Balham to Clapham South)

The reshowOutput JavaScript function is simply:


which gets us our Quest output back so we can start writing to it again. We start a new output section and move the player to the next location.

This is a pattern I use in most of the text effects – the ASL code triggers some JavaScript, the JavaScript does something pretty, then the JavaScript can call another ASL function when it’s done to continue the game.

The next effect is meeting Heather, which looks like this:

Meeting Heather

The JavaScript for this is:

var _heatherTextCount = 0;

function heatherText() {
    $("<div/>", {
        id: "heatherText"
        position: "fixed",
        top: 0,
        left: 0,
        width: "100%",
        height: "100%",
        overflow: "hidden"

function doHeatherText() {
    if (_heatherTextCount < 150) {
        setTimeout(function() {
        }, 20);
    else {
        $("#heatherText").fadeOut(2000, function() {
        setTimeout(function() {
            ASLEvent("JSFinish_HeatherText", "");
        }, 500);
    var minLeft = -100;
    var minTop = -100;
    var maxLeft = $(window).width();
    var maxTop = $(window).height();
    for (var i = 0; i < 3; i++) {
        $("<div/>", {
            text: "Heather"
            position: "absolute",
            left: getRandomInt(minLeft, maxLeft),
            top: getRandomInt(minTop, maxTop),
            "font-size": getRandomInt(8, 100) + "px",
            "font-family": "Georgia, serif",
            color: getRandomGrey(),
            opacity: Math.random(),

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;

function getRandomGrey() {
    var hex = Math.floor(Math.random() * 256).toString(16);
    return "#" + hex + hex + hex;

This places a new div over the game output, then calls a function at regular intervals to write the word “Heather” at a random location, size, greyness and opacity. After doing that a certain number of times, it triggers the ASL function JSFinish_HeatherText, which moves the player to the next location to start the conversation. Then it fades out the “Heather” div and removes it.

After meeting Heather, the “speckly” blackout works similarly – there are really two effects happening at once here. The blackout itself is simply a full-screen black div that fades in, fades out, then triggers the next part of the game. The speckles effect runs at the same time, and is similar to the previous “Heather” effect except with random letters – and they increase in size as the animation runs.

The final two animations are designed to evoke the feeling of sitting on a tube train while it enters and leaves a station. On the Underground, station names often appear on platforms above people’s heads, spaced quite close together. When you’re sat on a train looking out of the window as it pulls into a station, this gives something similar to the classic HTML “marquee” effect, but with the text scrolling past too rapidly to read at first, then slowing down and eventually coming to a stop.

For our final meeting with Heather, before she leads us to Private Rod, the text “HEATHER” appears in this way, using this JavaScript:

function heatherTube() {
     setTimeout(function () {
         $("body").css("overflow-x", "hidden");
         $("<div/>", {
             id: "heathertube",
             text: "HEATHER"
             position: "relative",
             left: "1200px",
             top: "0px",
             "font-size": "36pt",
             "font-family": "Georgia, serif"
     }, 2000);

 function animateHeatherTube(duration) {
     if (duration >= 2000) {
             left: "0px"
         }, duration, "swing", function () {
             $("body").css("overflow-x", "inherit");
             $("#heathertube").fadeOut(3000, function() {
                 ASLEvent("JSFinish_HeatherTube", "");
     else {
             left: "-1200px"
         }, duration, "linear", function () {
             $("#heathertube").css("left", "1200px");
             duration = duration * 1.5;

This temporarily sets overflow-x to “hidden”, which means we can have HTML elements off to either side of the screen without showing a horizontal scrollbar. Now all we need to do is animate a div containing the text “HEATHER” from off-screen on the right, to off-screen on the left. We do this with a duration that starts at 200ms and exponentially increases, to give the feeling of deceleration.

The final animation does the same thing, but with the whole of divOutput – so the entire game text. We do it the other way around, starting from a long duration and decreasing it each time (by dividing it by 1.3). Once duration reaches a value less than 500ms, we keep it constant and slowly fade out divOutput.

Hopefully I’ve shown you that these effects are reasonably simple to achieve, if you’re happy playing around with JavaScript and jQuery. Contrary to what some reviewers thought, these are not pointers to new Quest features at all – it just uses the same JavaScript integration features that have been there for a couple of years now, although not many people have exploited the full potential of these yet, which is why I wanted to play around with them in Moquette.

I’m not sure it would make too much sense for these kinds of effects to be more “built-in” to Quest – they would quickly become annoying through overuse. But if you need any advice on how to achieve a particular effect, post a message on the forums and I’ll be happy to advise – I can also do this kind of thing for you as part of the customisation service.

Text Adventure Games and Interactive History: Educational Questing

This is a guest blog post by Tara Fickle.

When I first started designing an online game based on the Japanese American internment, I must admit that I was a little apprehensive about how it would be received. Everybody that I talked to agreed that increasing awareness about this oft-overlooked historical injustice, especially among the younger generation, was an important and valuable venture. But my friends and colleagues seemed less enthusiastic about the whole game component; at best, they considered it a necessary evil, a caramel coating to conceal the good-for-you apple within from the suspicious minds of pleasure-seeking, learning-averse students. For some, too, the words “internment” and “game” were more than just uneasy bedfellows; the notion that I would even use them in the same sentence was offensive, trivializing, un-PC. I suppose I should have expected the latter reaction; if you look up “Drama in the Delta,” a 3D role-playing video game about the Jerome, Arkansas internment camp, you’ll find no shortage of outraged comments. One response, on an article in the Chronicle, pretty much sums it up: “[The internment] wasn’t summer camp, this was an illegal action taken by the US government that violated its own citizens Constitutional Rights, not a friggin game. My god, what an insulting travesty.”

So why did I end up creating Inside the Japanese Internment anyway? Well, because the real point I wanted to make is that it’s not about being forced to bring together game and history; when it comes to the internment, and, indeed, to Asian Americans as a whole, the fact is that you can’t separate the two. In the national imagination, Asians have always been stereotypically cast as game players; they scheme, they dissemble, they present their inscrutable poker faces to the world, faces whose intentions cannot be read, whose emotions cannot be detected. And after Pearl Harbor, that was precisely how supporters of the internment justified the relocation program: as a national strategy, a way of separating the loyals from the disloyals, the truth from the bluff. (This is an argument that I flesh out in detail in the first chapter of my dissertation, which you can read here). The internment was already a game – of the most serious sort. Inside is meant to make you realize that.

That’s why I don’t think of Inside as just an educational game – what Tom Cole aptly dubbed “a game with an educational skin” – but more like an interactive museum. It’s based almost exclusively in historical fact; I’ve changed most of the names, but the vast majority of the situations that players encounter – from cosmetic surgery to the Rescue of the Lost Battalion to the Tule Lake Uprising – are documented in historical accounts and court cases. Much of the game’s content is also adapted from novels written by internees like John Okada and Hiroshi Nakamura; in those cases, it’s not about whether the events really happened or not, but about understanding what and why those authors would choose to fictionalize – and about exposing their novel literary styles to the larger audience that they so greatly deserve.

And that’s really what I hope that Inside will accomplish in the broader sense: that it will expose individuals to different, radically new ways of thinking about the internment and about Asian American literature; about how history gets written, who writes it, and how technology has the potential to change it. In the immediate future, I’d love to expand the game and get it installed as part of the permanent exhibit on internment at the Japanese American National Museum, a Los Angeles-based institution which has George Takei on its board of trustees. I also hope that educators, at both the high school and undergraduate level, will consider adopting it as part of their units on World War 2.

But ultimately, I have a more wide-ranging goal: that Quest (the software which I used to design Inside, generously made available by the folks at will be integrated into all sorts of classrooms, especially in Literature and History courses. Because interactive text games have an incredible amount of potential as educational resources, a potential which has gone largely untapped. As an instructor of English at UCLA, one of the biggest difficulties I and my fellow teachers face is getting undergraduates to think about literature as something to be engaged with, not just passively read. When you are trying to get a group of 18 year olds to read Shakespeare or Chaucer, and especially when you’re asking them to write an essay about these canonical authors, you often immediately sense the trepidation and anxiety: “What do I, a lowly undergrad, have to say about a famous text that’s been written about five million times before? Everything’s already been said!”

But Quest gives students a voice, a sense of agency that they often feel they lack when faced with a mass of words on a page. What if, instead of asking students to write a paper on the theme of fate in Romeo & Juliet, we first asked them to choose a scene and recreate it as a short gamebook using Quest? Suddenly, they’re able to use their imaginations, their writing and critical thinking skills, their artistic sensibilities, to create something. Now they’ll have to ponder the same “what ifs” that Shakespeare himself contemplated when writing the play; what if Romeo hadn’t taken the poison? What if Juliet hadn’t confided in her nurse? In creating an interactive text adventure, students are now thinking about why these actions occurred in the first place – and deciding how to bring that thought process to life for the game player. Not only can this activity get students to read more closely, but more actively; and that’s the key to developing an essay which has a strong argument, not just plot summary. Plus, once they’ve created their games, they can be easily shared and made accessible as teaching modules for future classes.

In the coming months, I’m planning on offering some tutorial courses for my fellow teachers at UCLA (and hopefully finding some funding which will allow me to create an online teaching module to address a wider audience), to decrease the sense of intimidation that the older generation especially commonly feels when confronting unfamiliar technology. Quest is incredibly easy to use, and yet it’s versatile and sophisticated enough to let you do almost anything you can think of: author complex and customizable characters with diverse qualities, skills, and abilities; map out massive worlds that players can explore at will; add images, links, and even user-driven content. I’ve had absolutely no formal training in computer programming or game design (in the computer science course I ultimately dropped as an undergraduate, I got as far as creating a “Hello World” program before losing interest). Which is part of why Quest is so exciting: it has the potential to bridge the interdisciplinary chasm that currently exists between the humanities and other fields. It can bring the study of literature, history, and many other fields to the cutting-edge and give us humanists yet another strategy for articulating the relevance of our fields, allowing us to defend the university as a whole from the growing budget cuts that threaten to impoverish higher education for teachers and students alike. This is part of what burgeoning digital humanities initiatives like 4Humanities are all about; and I’m immensely grateful that Quest has allowed me to be a part of that movement.

Tara Fickle is a Ph.D. candidate in the English Department the University of California, Los Angeles (UCLA), specializing in 20th century American and ethnic fiction. She has recently completed her dissertation, Serious Play: Race, Game, Asian American Literature, and has published articles on Asian American cultural politics, contemporary literature, and game studies in various scholarly and popular journals. More information can be found at her academic website:

Quest is 15

Quest is 15 years old today! I posted the announcement of Quest 1.0 on the newsgroup on Saturday 7th November 1998. (And the original link in that post still gets you to the right place today, eventually)

Quest 1.0

So Quest is itself now almost as old as I was when I started writing it. But what got me started on it in the first place?

You’re probably expecting me to say something like this… I’d been interested in text adventure games since their heyday in the 1980s. On my family’s home computer, I got hooked by classic games like Zork, Hitchhiker’s Guide To The Galaxy and Planetfall. Such wonderful worlds of the imagination! Such crafty puzzles! I would spend hours drawing maps on squared paper and looking out for grues and giving myself eye strain and…

Well, no. That’s not how it happened. I never played any of those. In fact, I was never really into text adventures at all.

But then, they were before my time. I was just a bit too young. I first dabbled with a computer in, oh, about 1990 or so. We had an Acorn Electron in our house. We did have a couple of text adventures for that – we had a copy of Acornsoft‘s Sphinx Adventure (never really played it, couldn’t get anywhere, found it boring) and my dad had typed in the listing of a game called Necromancer from Electron User magazine. Which never quite worked properly, as something had been mis-typed somewhere along the line.


So I was just never that interested in text adventures. I was more into playing whatever shareware games had found their way onto my PC – Commander Keen, Wolfenstein, Doom and so on. But what I was much more interested in was creating my own. I probably spent more time in front of QBasic than any game. And that is where it all begins, really.

Schoolboy Humour

In 1994, at the age of 12 I started secondary school. The IT lab there was open at lunchtime for anybody to use. So instead of running around getting exercise, or loitering somewhere else, me and my friends played around with the computers. They were probably 486s, running MS-DOS 6 and Windows 3.1. They were connected to some kind of network but there was no internet access – we’d barely heard of this internet thing anyway back then. There wasn’t a whole lot to do other than write silly little programs using QBasic (or Visual Basic 3.0, which was also installed) so that’s what we did.

After my schoolfriend Martyn moved house and went to a different school, we kept in touch by writing letters to each other – this being a time before either of us had an email address. We would enclose 3.5″ floppy disks to share our latest programming efforts. It was in fact in Martyn’s first letter, around January 1995, that he sent me a game he’d written called “Sid Snibble and the Curse of the Curry Stain“.

I still have a copy, in a heavily nested folder full of archives of archives, and I can still run it today using QB64. It looks like this:

Sid Snibble and the Curse of the Curry Stain

It was a text adventure, but even this had a graphical element to it – you didn’t walk around the game by typing NORTH, SOUTH etc., you moved an ASCII face around with the arrow keys. When you entered a location, you could look at things, speak to characters, pick up items and so on – all in an attempt to solve the mystery of what happened the night before, and why you woke up in the middle of the road in a strange town with a large curry stain down your shirt.


This looked fun. I could write something like this. It would be hilarious! And so I set to work, doing what I’d always done – copying Martyn’s ideas, but doing them a lot worse.

So, in April 1995 I wrote my first text adventure game.

It was called… well, there’s no easy way to put this. I don’t want to rewrite history or tell a lie. I was young and the game was only for me and my friends. It was called “Where’s My Nob?!

How I wish that weren’t true. How I wish I could sit here and tell you the story of how I poured my soul into a creative work of genius, a work of art, a literary masterpiece. With a title like that, maybe I could claim that it was an earnest work exploring gender issues. But it wasn’t. I was 12. The game was an excuse for a load of the kind of sophisticated humour that 12 year olds are known for. Featuring locations such as Dracula’s castle, a teacher’s house, a corner shop, a dairy, a Skoda dealer and Potato World.

So, a throwaway game that should be played by nobody. But for me, a 12 year old boy who didn’t do any kind of creative writing, it was a fun thing to do that got some kind of creative juices flowing.

[Aside: Although it’s not a work that I would ever want anybody to see – indeed, I would be absolutely horrified – I think what it represents is something that still persists as I develop Quest today. Specifically, although I want Quest to be a useful tool for building very high quality works of interactive fiction, there is still a need for something that allows people to create their own Sid Snibbles (and, er, to find their own Nob? I think deep down my sense of humour remains the same). To give people a way to express themselves, to allow them to develop their artistic sense, to allow them to get started, and then to improve their craft. It’s easy to be snobbish about this kind of thing, and to moan about low-quality games, but if we didn’t have bad text adventures, it’s unlikely we would have very many good ones either.]

Anyway, back to my, er, game. I sent it to Martyn on a floppy disk together with a second one called “Make Mrs Booth Friendly!“, a game about my French teacher. Also on that disk, I included a terrible chatbot, “Dr Mad!” who would diagnose your illness, and a fortune teller called “Sadistic Smeg”.

Over the following months I wrote some more text adventure games, always full of in-jokes about school, only ever written for my friends, and never to be seen by anybody else ever, certainly not now. “It’s Mad!“, “Fantasy Land!“, “Park Parade Adventure!” and “The Town of Terror“. It seems the running theme was titles with exclamation marks.

Making Text Adventures for Windows 95

Fast forward a few years to 1998, when I’d started dabbling with Visual Basic 5.0 – which meant I was no longer stuck writing programs for DOS, I could create programs for Windows instead, featuring buttons and menus and message boxes and pictures and everything. I was rather stuck for ideas though. I’d spent some time working on a virtual pet, which were all the rage back then, but wanted to try something a bit meatier. I’d just finished my GCSE exams and was looking for something to keep me occupied over the summer break before I started sixth form. I thought back to the text adventures I’d written, and wondered – what would a text adventure game for Windows look like?

I decided to write myself a little engine before writing a game, so I wouldn’t have to hard-code everything like I’d done in QBasic. I started coding something that would take in a simple text file which would define all aspects of the game, and handle things such as allowing players to save their progress.

It turned out that I was actually far more interested in creating the engine than I was in writing a game anyway, and I was interested to see what other people might come up with if they used my system. At the time, I was fairly ignorant of any pre-existing systems which would do a similar thing to mine, until somebody suggested I take a look at the newsgroup. I started checking out the competition, and reading about Inform and TADS. It was clear to me that they were difficult for newcomers to use (this was before Inform had a natural language syntax – the syntax of Inform 6 still looks bizarre to me), so it looked like I should be able to get people interested in what I was doing.

I released Quest 1.0, and it looked like this:

Quest 1.0 Start Screen

(Those two globes were animated and bounced back and forth between the edges of the screen. For some reason.)

Quest 1.0 loaded text files which were in a simple format I’d devised, called ASL – Adventure Scripting Language. The syntax was simple, designed to be coded by hand using Notepad or similar – there was no visual editor yet (“QDK” appeared the following year).

Here’s the Quest 1.0 Readme file and ASL Reference if you’re interested in some historical detail. You would create games by using Notepad to edit the included template.asl file, which looked like this:

' Quest ASL Template
' All sections must exist in the game, though the text sections may be empty
' if desired.
define game <Enter name of game here...>
    asl-version <100>
    game version <1.0>
    game author <You>
    game copyright <© 1998...>
    game info <Enter game info here...>
    start <Enter name of place here...>
    possitems <Enter items separated by commas here...>
    startitems <Enter start items here...>
end define

define room <Enter name of place here...>
    look <Enter description here...>
end define

define text <intro>
Enter intro text here...
end define

define text <win>
Enter win text here...
end define

define text <lose>
Enter lose text here...
end define

This file format lasted a long time. It was used right up until Quest 4.x, the last version of which was released in 2011 – albeit heavily extended and changed in various ways over the years.

The empty template looks like this when loaded in Quest 1.0:

Quest 1.0 running a game

The user interface is still very similar to what Quest offers now – in fact, after it was rearranged in Quest 2.1 it has effectively remained an identical layout. There is the game text of course, a command box, a space to show what items you’re carrying, and a list of things you can see in the current location (which would show “Look at” and “Take” buttons if something was selected). There are also the compass buttons for easier navigation.

Quest 1.0 supported rooms, characters, objects, things you could pick up (“items”), quantities of things (“collectables”), string variables and some basic script commands. It could play WAV files, show images and display pop-up menus. It supported text formatting, and let you set up your own custom commands using a syntax like “eat #object#” – the same format that is still used in Quest 5 today.

There was a small sample game distributed with Quest 1.0, “A day in the life of a salesman“. It is of a very similar standard to my QBasic efforts – which is to say stupid, crude and borderline offensive in places. So no, you can’t have a copy, but yes, it does still run in Quest 5.4!

What happened next? We’ll pick up the story in the next blog post, where I’ll talk about how Quest grew, changed and even shrunk over the years to become what it is today.

QuestComp 2013 – the results

The winner of QuestComp 2013, and the £100 prize money, is Heal Butcher with Worship the Pig. Congratulations!

Very close runner up is Jonathan Estis with Pest.

For the full results, listing all the votes for each game, see the QuestComp 2013 Winner Announcement thread on the forums.

Many thanks to Evan Williams for organising the competition, and thanks to Phillip Zolla for donating the prize money. Thanks also to the entrants and everyone who voted.

If you missed out on entering a game for the QuestComp this year, you’ve got just over two months to enter your game for the IFComp!

QuestComp 2013 – the entries are in!

The entries for QuestComp 2013 are now in! They are:

Worship the Pig by Heal Butcher

Pest by Jonathan Estis

Over to organiser, Evan Williams:

Score as 1 – 10, mark any discussion threads in the forum appropriately so people aren’t led into spoilers accidentally, and I encourage you to post reviews on the game’s page.

Since things are already off-kilter, we’ll judge until we’re done judging, but no more than a month from now.

If anyone else pops in and says, “hey, I got my game finished!” I’ll leave it up to the judges whether they want to review the late entries.

Here are the rules for judges:

    • Judges are encouraged to play each game as long as they want and try to finish each one. However, they are not required to finish before voting (especially if the game takes more than about 1-1/2 to 2 hours). There is no minimum time length that must be spent on each game.
    • There is currently no minimum number of games which must be played to qualify the judges’ votes.
    • Anyone may judge.
    • Games should be scored on a 1 to 10 scale, 10 being best.
    • Judges may discuss the games during the judging period, but should clearly mark posts/topics, for the benefit of those who want to avoid spoilers.
    • Beta-testers are allowed to vote on the entries they beta-tested.

So, please play the games and submit your votes by emailing Evan Williams at

How am I doing? The Quest “Annual Review” 2012/13

In April 2012 I marked a year of working on Quest full-time by conducting my own “Annual Review” (Part 1, Part 2). Well, er, 13 months have elapsed since then, which makes it the perfect time to do it all again.

So, what have I been doing for the last 1.0833 years? What’s going well, what’s going badly, and where is all this going?

A quick recap of the last 13 months

Unlike last time, I’ve not actually been working on Quest 100% full-time. For the last 5 months I have, but between May and November 2012 it was relegated to spare time, and the occasional day off, as I took up some contract C# developer work to top up my bank balance.

Some numbers

Usage of the site has increased over the last 13 months:

  • Games played online averages to 480 per day – up from 400 per day, so a 20% increase
  • Game download count averages to 190 per day – up from 140 per day so a 35% increase

So, a nice bit of growth there but nothing explosive. What has truly gone up hugely though is the number of games on the website. 13 months ago, we had 380 games on the website, of which 76 had been added in the previous year. Now we have 980 games on the website in total – so 600 games have been added in the last 13 months. Pro-rated to a 12 month figure of 553, that’s an increase of 628% in game submissions.

Note that in April 2012, I added the ability to publish games privately, which means not all of these 600 games are public. In fact, 297 of these are private (“unlisted”). But even if we only count public games, that’s still a big increase – 303 public games in 13 months, which if pro-rated to a 12 month figure of 280 is still a 268% increase.

The web version of Quest is being well used, with 7300 games started since it was launched in March 2012. 331 of these have been published. This is slightly over half the total number of games published on this site in the time it has been available, so it shows that it’s about equally as popular as the desktop version.

What went well

I’ve really enjoyed running Quest workshops for the first time during the last year. It was amazing to see just how creative children are, and how quickly they can pick things up. Most of the attendees had never heard of text adventure games before my sessions, but within an hour or two they were creating their own games, setting their own puzzles, and sharing their creations with their friends.

It has given me a lot of confidence that Quest is a great way of getting kids into programming, getting them reading and getting them writing. They can get a lot out of it even over one session.

It’s also been really positive to see the site stats going up, loads of new games being created, and the forums getting busier. The new-look website which I launched a couple of weeks ago is doing well – it looks cleaner and more engaging to me, but more importantly the feedback is good and early indications from Google Analytics suggest people are staying longer on the site too.

Finally, adding Gamebook mode to Quest turned out to be a good idea – it has enabled significantly more people to create an interactive story, and is I think largely behind the big rise in submissions over the last year. It feels like this may well be the primary game type in the future, which is why I made significant enhancements to it a couple of months ago for Quest 5.4.

A mixed bag

For smartphone and tablet apps, there has been a mixture of good and bad results. It’s difficult to get publicity, so while there has been some good coverage – it was great to see First Times listed as one of the Guardian’s 30 best Android apps of that week …

If you, like me, pine (a bit) for the heyday of text adventures, you should definitely check out First Times. It’s a horror text adventure that kicks off with you waking up in a morgue, and without giving the game away, it’s genuinely creepy as you try to figure out what happened. If you’re young enough to be baffled by the term “text adventures”, ask your dad (but go north, open the door and hit the elf with the sword first).

… and it was also an IndieGames freeware pick, but after an initial flurry the “long tail” is indeed long, and shallow. On iOS, First Times went from 2,280 downloads in March down to 252 in April – which is actually slightly less than the older app, The Things That Go Bump In The Night, which had 313.

Even so this is much better than the sad tale of Aventura Pirata, a Spanish-language game which only had 27 downloads on iOS in April.

Interestingly, by far the most successful app I have released is the Windows Phone version of The Things That Go Bump In The Night – 1,168 downloads in the last month, and this is 9 months after its release. This is indicative of the decreased competition over on the Windows Phone Store, I think.

Room for improvement

It’s been great to add new translations for Quest into Italian, Portuguese and Romanian – bringing the total number of languages supported to 9. But very few games in these languages have been published yet – which is a huge shame as I know that text adventures would be a great resource for learning foreign languages. Clearly there is more work to be done here, both to make the Quest editor more usable by those who don’t speak English, and to set up the website to handle non-English games better – which may be as simple as adding language tags for easier searching and filtering.

I was excited to hear about the Nesta Digital Makers open call – here was a body offering funding for projects to get young people making things, “to become creators, not just consumers of digital technologies”. To my mind, Quest is absolutely perfect for that. So it was hugely disappointing not to be shortlisted – or even to receive any feedback. It’s understandable given the huge interest Nesta had in the scheme, but it makes me reluctant to pursue this approach for getting Quest to pay for itself, as it takes time to put together these kinds of funding applications.

Instead, selling products and services around Quest sounds far more sustainable and less risky to me. I know that there are schools out there using Quest, and offering services to them is one of my main focuses for the coming months. One of my current “areas for improvement” is simply identifying who these schools are. I can see from my web server log files that there are regularly groups of users from the same IP address using the web-based editor and playing games on the site – it would be great to know who you are, so please get in touch!

What people are saying

That’s what I think, then – what have other people been saying about Quest over the last year-and-a-bit?

Adrian Camm says:

Exploring Interactive Fiction (IF) design systems such as Inform7 and Adrift, I have found Quest to be probably the best for small projects ideally suited to K12 education.

Jon Bridgeman talks about using Quest with Year 7 and 8 students:

IF gets students writing.  A lot.  I can see cogs turning and imaginations sparking.  I get IF stories about zombies, Harry Potter, Area 51, London Zoo, zombies, Haunted Houses, and er..Manchester City…

Students HAVE to write descriptively, as they create a world from nothing and fill it with people, places, creatures and things from their own imaginings. …

It’s programming by stealth… It certainly sparked an interest in programming in a number of students… Try it yourself. Even better, get your kids to try it.

(It’s well worth your time reading his full blog post on getting students into writing interactive fiction)

Some tweets:

FreewareGenius says:

It’s pretty amazing what can be accomplished so easily now, with programs like Quest. Yes, I am in love with this program, and therefore, I could go on and on about it and how awesome all its features are and the like until I am blue in the face

IndieGames says:

Unlike Twine that can almost exclusively be used for choose-your-own-adventures and Inform 7 whose attempt at a natural language scripting environment can alienate, Quest uses a menu-driven system supported by a very simple scripting language. Truth be said, most basic stuff can be achieved via almost intuitive pointing-and-clicking, meaning you can have a simple first game ready in minutes.

Quest even helped out at a party:

Want to make your own text adventure game like Mr. Geek? You can use Quest, a free online program that makes it super easy!

Anybody got anything negative to say? To me, constructive criticism is more useful than a nice slap on the back. I’ve not actually seen much in the way of “bad press” this year, but one can always rely on forum member davidw for a choice quote. Over on the Adrift forum he writes:

Quest may attract the lion’s share of the IF market right now, but it still doesn’t produce much in the way of good games. “Quality over quantity” after all.

Personally, I am perfectly happy for most of the games on the website not to match up to davidw’s standards. Some poor quality games are, I think, the price to pay for giving people accessible tools with which to build things and express themselves. Many users are young and are trying out writing and programming for the first time – we’ve all got to start somewhere. This site relies on user-submitted reviews to highlight what’s good – and authors value feedback too. So whether you like a game or not, be sure to leave a review!

Being accessible is what allows a game like Go Rich Boy Go to exist in the first place. As the game’s author Jahanzaib Haque explains:

I found Quest – the text adventure creator that enabled me to just go ahead and create what was bubbling inside me. Six feverish days of writing later, my adventure game was born!

The game was been played by thousands of people over just a few days. As Global Voices covered it:

A timely online game and mobile app that packs humorous punches at Pakistan’s young and rich voters, some of whom say they will bravely dodge bombs to cast their vote next week, has been played by thousands of people.

Karachi-based journalist Jahanzaib Haque created the game “It’s election time in Pakistan: Go rich boy go!” ten days ago on April 21, 2013.

The months leading up to the 2013 elections have been rigged with violence, dozens of people have been killed in bombings targeting campaigns, rallies and crowded places. Last month the Pakistani Taliban warned voters and vowed to step up attacks against secular politicians.

Now this is the kind of thing that excites me – give people tools which are easy to use, and see what they come up with. People who would never have created any kind of computer game before now have the ability to do so. This could be the beginning of a very interesting journey.

Not just Quest that’s growing

Over the last year, it seems interactive fiction has started to take its first steps towards the mainstream. We have companies like Inkle releasing apps, and suddenly much talk about Twine. Playfic brought Inform into the browser and new platforms like Versu emerged. Crazy ideas are being tried out – like combining text games with something like Pinterest to create Dio. StoryNexus is powering a game from book publisher Random House which features in-app payments allowing you to do things like “expedite the narrative”. And check out the Choosatron. Stuff is happening here.

I think Quest occupies a unique position among all this. It encompasses both typing-based “old-school” text adventure games with a parser, and a newer style which is emerging based on hyperlinks that is closer to “Choose Your Own Adventure” than “Zork”. Will one style win over the other? Who knows – and I’m not going to be the one to prescribe exactly how people should interact with your game. We’re all still figuring this stuff out.

Perhaps more importantly, Quest is open source. Anybody can get involved in the project, contribute code or translations, or even fork the code if they don’t like where it’s heading – go ahead, build your own interactive fiction platform, even make it closed source and expensive if you want. You are allowed to do this by the licence, and you’ll save yourself a load of work.

The open source-ness also gives you security – Quest is not locked up inside one website, ready to disappear when a company runs out of money or their staff get acqui-hired. Even if disappears or I spontaneously combust, the source code for Quest is available to be run somewhere else, and the games are all downloadable.

Finally, even though Quest is free, it is actively supported and maintained, and it is continuing to grow and explore new directions. Need help, or got a mad idea for a project where something like Quest might be useful? Get in touch – or @alexwarren.

Where now?

I’m still funding Quest almost entirely out of my own pocket, and I have spent most of the last couple of years working on it, in preference to working on things that would actually earn me some money. I’m far happier alternating between Quest and contract developer work – and until I can make Quest pay for itself it’s the way things have to be, of course. But I would like to bring the two together, and work on projects where Quest forms a part. So do get in touch if you think there’s something we can work on together.

Another way I plan to fund Quest is by selling additional services, and right now I’m working on some extra functionality to help schools and groups using Quest – take a look at ActiveLit for more details, and expect to hear more about that soon.

My other project for the next few months is to finally build my own game. Yes, it’s been 15 years since I started working on Quest, so it’s probably about time. Although I’ve been collecting various thoughts about storytelling on this blog over the last year (see here, here and here), I’ve come to the realisation that it’s probably better to stop talking hypothetically about the kind of stuff you could do in Quest – I should show some of my ideas in an actual game instead.

I am especially looking forward to davidw’s review of it.

Quest 5.4.1 released

Quest 5.4.1 is now available. If you’re using the web version, you’re automatically up to date, and if you’re using the desktop version you can download the update.

This version is a bug-fix release – you can see all the closed tickets on CodePlex.

Thanks to Dick Aivia for updating the Dutch language template for this release.

One very minor enhancement in the desktop version – when running a game from the editor, you now have quicker access to the HTML Tools via the toolbar or by pressing F9.

Also one minor breaking change – if you have any exits that run scripts instead of automatically moving the player, you will need to tick a new checkbox on the exit editor “Run a script (instead of moving the player automatically)”.

As always, if you have any questions or problems, please let me know – you can email me or find me on Twitter @alexwarren.

Quest 5.4 released

Quest 5.4 has now been released, and you can download it now or use it in your browser.

The major new features in this version are the text processor, gamebook scripts and script editor code view. For a full list, see last month’s beta announcement.

Since the beta there have been a few minor enhancements, most notably to the gamebook scripts. There is a new “Text + Script” page type which lets you run a script before displaying the normal gamebook text and options, so you’re not forced to display text and options manually. There are new functions for moving the player between pages, and for adding and removing links.


  • In gamebook mode, when playing a sound there is a new option for the sound to continue playing after the player moves to a different page
  • You can now turn off the automatically generated display verbs list on a per-object basis (contributed by Pertex)
  • New {rndalt} text processor code displays a randomly chosen name from an object’s alt list (contributed by Ivor Levicki)
  • With the new-style menus, restored the option to force the player to make a choice from the menu before continuing. (Note this is a breaking change – previously compiled games for Quest 5.4 Beta will continue to work, but to compile against the new library you will need to set the value for the new parameter)
  • New function to output text without a line break at the end

As always, if you have any questions or problems, please let me know – you can email me and you can find me on Twitter @alexwarren.

QuestComp 2013


Update 18th March – now with prize money!

It’s officially the first unofficial Quest competition!

Over on the forums, various people have got together to organise QuestComp 2013 – a competition to use Quest to create a text adventure game around the theme of “Plague”.

Evan Williams a.k.a TriangleGames is organising the competition, and there are no prizes except for the glory of winning thanks to Phillip Zolla for sponsoring a first prize of £100.

If you intend to enter, please email Evan by March 31st – full details on the rules, competition timetable and how to enter are at the QuestComp 2013 page.

Thanks also to Scott Greig for the interesting logo, which I hope I’ve got the right way up.