I’d like to begin with a couple of observations.

• When I remember myself in past years, I’m often impressed with
  how much I’ve changed. And when I go back and look at things I
  wrote or built or created in past years, I’m often impressed with
  with how little I’ve changed.

• It pays to be anal-retentive.

In the winter of 1992, I spent a week in Fort Leavenworth, Kansas,
supporting a military training simulation for which I was one of the
programmers. Actually, I only spent the days there; I spent the
nights at a Comfort Inn in Platte City,
Missouri. (No one on the project actually wanted to stay in
Leavenworth.) It was the first week of the 1992 Winter Olympics,
and I spent my evenings sitting on the bed in my hotel room, watching
the Olympics and working on a little game called Quest on a DOS laptop
I’d borrowed from my dad.

The laptop was a simple little thing, nearly obsolete even then; it
was a Radio Shack model with not a lot of memory and a tiny hard drive
and no graphics, and a battery that didn’t hold a charge well, and it
ran DOS. I loved it–it was a computer I could take on the road.

Quest was my first attempt at writing a tile-based game, along the
lines of the Ultima series. It was written in a mixture of C++
and a Forth-like language for which I’d written an interpreter; the
basic game engine was in C++, but all of the creatures and objects and
regions to explore were defined in Forth. I’d never heard of Tcl at
that point, but I’m sure the Tcl programmers reading this are nodding
their heads–I was ripe to embrace Tcl when I discovered it.

The output was to the DOS screen, but by way of a hack. DOS allowed
you to redefine the screen’s character set temporarily. So Quest used
character graphics, but with special graphical characters I defined
for the various monsters, objects, and terrain features, along with
all of the lovely characters in the PC’s extended ASCII character
set.

It was a thing of beauty, and I had a lot of fun working on it. In
the end, though, it was a failure, for a host of reasons.

• As a DOS program it was retro at a time when retro was no
  longer in. Microsoft Windows was already the next big thing.

• There was no World Wide Web on which to distribute it. I could
  have uploaded it to a PC Bulletin Board, and it might have
  garnered some minimal attention, but (given that it was retro)
  probably not a whole lot.

• It was trying to be Ultima rather than Angband,
  and consequently it was never finished.

That last point requires some explanation. Ultima was a game
written for other people to play; it held few surprises for the its
developer. The world map, the towns, the castles, and so forth were
predetermined. Angband development has always been done by folks
who want to play the game themselves, and want it to unpredictable and
surprising, and so as much as possible of the game is randomized in
one way or another.

So basically, Quest was a game I was writing for other people to
play. The joy I got out of it was implementing the basic
infrastructure to make the game work; designing new levels and quests
was, on-the-whole, rather boring. Testing my new features was one;
playing the levels I’d already designed was dull, because I knew
exactly what I had to do.

This might not have been fatal had Quest had an audience; but in fact
it didn’t.

I like the Ultima model, and I want to bring some of that to
Ramble; but I also want a game I’ll enjoy playing, which is why much
of my initial work on Ramble has focussed on creating interesting
random levels.

Anyway, I needed a combat model for Quest, and I didn’t really feel
like making one up from scratch. So I went out and got a copy of the
Advance Dungeons & Dragons (2nd Ed.) Player’s Handbook and
cribbed from that. I didn’t use the AD&D rules verbatim, as they
weren’t written with computer games in mind, but I used them as a
starting point and an inspiration.

Being about ready to start some simple combat modeling for Ramble,
I cast about my hard drive and found the Quest source code, which,
astoundingly, I hadn’t thrown away in the intervening 13 years. I found
the combat code easily enough, but I was lacking context–why had I
done things the way I did? What, of all things, was a “THAC0”?

I put the computer away, and went to dig up that self-same Player’s
Handbook which, miraculously, I hadn’t thrown away in the
intervening 13 years–and struck gold.

Inside the front cover of the handbook was a hard copy of some of
the Quest source code–and a print-out of something called
(obscurely) the Analyst’s Guide to VF. What it is, is a
document that talks about how things are done in
AD&D, with page references to the Player’s Handbook, and
then explains how I modified them to use them in Quest. More than
that–it documents the basic player, creature, object, and combat
models used in quest, and explains why they are the way they are.

Who would have thought, 13 years ago, that I’d be able to put my hand
on all of these resources in a matter of moments?

As I said, it pays to be anal-retentive.