From: galley@think.com (Stu Galley)
Newsgroups: alt.folklore.computers,rec.games.int-fiction
Subject: Re: Zork/Dungeon (LONG)
Date: 2 Oct 1992 21:45:40 GMT
Organization: Thinking Machines Corp., Cambridge, Mass., USA
NNTP-Posting-Host: django.think.com
Keywords: history Zork Infocom

from THE NEW ZORK TIMES Vol. 4 Nr. 1 - WINTER 1985
Copyright (c) Infocom, Inc. --- transcribed without permission


The History of Zork -- First in a Series

by Tim Anderson

In the beginning, back in the 1960's, DEC (Digital Equipment
Corporation) created the PDP-10, a medium-sized computer.  The "10",
as it was called, became popular at many research installations, and a
great deal of software was written for it, some of which is still far
in advance of systems on more modern machines.  At MIT's Artificial
Intelligence Lab, an operating system called ITS (Incompatible
Time-sharing System) was written for the 10.  ITS was designed to make
software development easy.  The designers of the system assumed that
it would have a small, knowledgeable, friendly group of users, so they
did not include any security features.

Around 1970, the ARPAnet was invented.  ARPAnet made it possible for
researchers all over the country (indeed, all over the world) to
communicate with each other, and to use each other's machines.  In
those halcyon days, access was unrestricted; you could get on from any
machine connected to the net, or by knowing an appropriate phone
number.  Budding hackers from around the country soon discovered that
this made a wonderful playground.  They also discovered that there
were some computers at MIT with some neat stuff on them and no
security -- anyone who could connect to the machines could log in.

Also around 1970, a language called MUDDLE (later renamed MDL) was
developed as a successor to LISP.  It never succeeded in fully
replacing LISP, but it developed a loyal user community of its own,
primarily at MIT's Project MAC (now called the Laboratory for Computer
Science) and especially in the Dynamic Modelling Group (later the
Programming Technology Division).  The Dynamic Modelling Group (DM),
in addition to its other accomplishments, was responsible for some
famous games.  The first of these was a multi-player graphics game
called Maze, in which players wandered around a maze shooting each
other.  Each user's screen showed the view of the maze that his or her
computerized alter-ego saw, updated in real time.  Dave Lebling was
among those chiefly responsible (to blame?) for the existence of the
game.

The next game of note was Trivia (who says research labs aren't ahead
of their time?), an ongoing "can you top this" contest for the truly
crazed.  Trivia, unlike Maze, could be played by network users, and
achieved wide popularity on the ARPAnet.  Marc Blank wrote the second
version, and I maintained/hacked it; it was actually a legitimate test
of a database system the group used for a research project.

ln early 1977, Adventure swept the ARPAnet.  Willie Crowther was the
original author, but Don Woods greatly expanded the game and unleashed
it on an unsuspecting network.  When Adventure arrived at MIT, the
reaction was typical: after everybody spent a lot of time doing
nothing but solving the game (it's estimated that Adventure set the
entire computer industry back two weeks), the true lunatics began to
think about how they could do it better.  Adventure was written in
FORTRAN, after all, so it couldn't be very smart.  It accepted only
two-word commands, it was obviously hard to change, and the problems
were sometimes not everything one could desire.  (I was present when
Bruce Daniels, one of the DM'ers, figured out how to get the last
point in Adventure by examining the game with a machine-language
debugger.  There was no other way to do it.)

By late May, Adventure had been solved, and various DM'ers were
looking for ways to have fun.  Marc Blank was enjoying a respite from
medical school; I had just finished my master's degree; Bruce Daniels
was getting bored with his Ph.D. topic; and Dave Lebling was heartily
sick of Morse code.  Dave wrote (in MUDDLE) a command parser that was
almost as smart as Adventure's; Marc and I, who were both in the habit
of hacking all night, took advantage of this to write a prototype
four-room game.  It has long since vanished.  There was a band, a
bandbox, a peanut room (the band was outside the door, playing "Hail
to the Chief"), and a "chamber filled with deadlines."  Dave played and
tested the game, saw that it was pretty awful, and left, to spend two
weeks basking in the sun.

Marc, Bruce, and I sat down to write a real game.  We began by drawing
some maps, inventing some problems, and arguing a lot about how to
make things work.  Bruce still had some thoughts of graduating, thus
preferring design to implementation, so Marc and I spent the rest of
Dave's vacation in the terminal room implementing the first version of
Zork.  Zork, by the way, was never really named.  "Zork" was a nonsense
word floating around; it was usually a verb, as in "zork the fweep,"
and may have been derived from "zorch."  ("Zorch" is another nonsense
word implying total destruction.)  We tended to name our programs with
the word "zork" until they were ready to be installed on the system.

By the time Dave got back, there was a (more-or-less) working game.  It
probably wasn't as big as Adventure, and was certainly less than half
the size of the final version, but it had the thief, the cyclops, the
troll, the reservoir and dam, the house, part of the forest, the
glacier, the maze, and a bunch of other stuff.  The problems were not
as interesting as those that came later: it took time for people to
learn how to write good problems, and the early parsers wouldn't
support complicated solutions anyway.  What we had done right was all
in the "substratum."  There was a well-defined (and easily-changed)
theory governing interactions among objects, verbs, and rooms.  It was
easy to drop in new parsers, which happened frequently, since everyone
and his uncle tried his hand at writing a parser (Marc finally became
obsessed with it, and wrote the last 40 or 50 of them himself).  And it
was easy to add new rooms, objects, and creatures (I won't discuss the
difficulty of adding new concepts yet).

Zork, like Adventure, survived only because it was played by people
outside the small community that developed it.  In the case of
Adventure, this was possible because it was written in FORTRAN and
could run on practically any machine.  Zork was written in MUDDLE,
which ran on only some PDP-10s.  Its user community was the group of
"net randoms" that infested the MIT systems; remember that we had no
security at all at this time.  DM had developed an active community
largely because of Trivia.  Since Trivia was pretty dead by the time
Zork came along, there weren't many other things for the randoms to
do, so they hung around waiting for the next game.  Early players of
Zork ranged from John McCarthy, the inventor of LISP (we actually have
a copy of the connectivity matrix that McCarthy used instead of a
map), to twelve-year-olds from Northern Virginia.  No one ever
officially announced Zork: people would log in to DM, see that someone
was running a program named Zork, and get interested.  They would then
"snoop" on the console of the person running Zork, and see that it was
an Adventure-like game.  From there, it only took a little more effort
to find out how to start it up.  For a long time, the magic incantation
was ":MARC;ZORK"; people who had never heard of ITS, DM, or PDP-10s
somehow heard that if they got to something called "host 70" on the
ARPAnet, logged in, and typed the magic word, they could play a game.

Although Zork in June 1977 was infinitely more primitive than, say,
Zork I, it still had pretty much the same flavor.  The Flathead family
was represented, in the person of Lord Dimwit Flathead the Excessive,
ruler of the Great Underground Empire; and the official currency was
the zorkmid.  Bruce was responsible for the purplish prose where these
were first mentioned.

Many of the details of the GUE were whimsical (if not silly), but we
weren't completely immune to reality.  In those days, if one wandered
around in the dark area of the dungeon, one fell into a bottomless
pit.  Many users pointed out that a bottomless pit in an attic should
be noticeable from the ground floor of the house.  Dave came up with
the notion of grues, and he wrote their description.  From the
beginning (or almost the beginning, anyway), the living room had a
copy of "US News & Dungeon Report," describing recent changes in the
game.  All changes were credited to some group of implementers, but
not necessarily to those actually responsible: one of the issues
describe Bruce working for weeks to fill in all the bottomless pits
in the dungeon, thus forcing packs of grues to roam around.

The first major addition to the game, done in June 1977, was the river
section, designed and implemented by Marc.  It survives largely
unchanged in Zork I, but illustrates very well the problems of
building reality.  There were minor problems of consistency -- some
parts of the river were sunlit (and even reachable from outside), but
others were dark.  The major problem resulted from the new concept
Marc introduced: vehicles.  In the original game, there were rooms,
objects, and a player; the player always existed in some room.
Vehicles were objects that became, in effect, mobile rooms.  This
required changes in the (always delicate) interactions among verbs,
objects, and rooms (we had to have some way of making "walk" do
something reasonable when the player was in the boat).  In addition,
ever-resourceful Zorkers tried to use the boat anywhere they thought
they could.  The code for the boat itself was not designed to function
outside the river section, but nothing kept the player from carrying
the deflated boat to the reservoir and trying to sail across.
Eventually the boat was allowed in the reservoir, but the general
problem always remained: anything that changes the world you're
modelling changes practically everything in the world you're
modelling.

Although Zork was only a month old, it could already surprise its
authors.  The boat, due to the details of its implementation, turned
into a "bag of holding": players could put practically anything into
it and carry it around, even if the weight of the contents far
exceeded what a player was allowed to carry.  The boat was two
separate objects: the "inflated boat" object contained the objects,
but the player carried the "deflated boat" object around.  We knew
nothing about this: someone finally reported it to us as a bug.  As
far as I know, the bug is still there.



from THE NEW ZORK TIMES Vol. 4 Nr. 2 - SPRING 1985
Copyright (c) Infocom, Inc. --- transcribed without permission


The History of Zork -- SECOND IN A SERIES

by Tim Anderson

When last seen, Zork(R) was a small game (probably slightly more than
half the size of the final mainframe version) that ran on one
computer.  Although it was only six weeks old, and had never been
advertised, it had a relatively large user community from all over the
country.  In some ways it was better than the classic Adventure at this
time, but mostly it was the next game to come along, and it wasn't
even the only contender.

The characters: MIT-DM, a PDP-10 running ITS; MDL (aka Muddle), a
language that ran only on PDP-10s; Marc Blank, Bruce Daniels, Dave
Lebling, and Tim Anderson, intrepid implementers; and assorted net
randoms.

July 1977 saw two major additions to the game, the last for several
months (we weren't exactly hired to write the thing, after all).  The
first of these was another BKD special: Bruce didn't write much code,
but he was willing to design problems.  We went to him, and asked for
a particularly nasty section; the result was the coal mine.  His design
was originally nastier than the final implementation, since the maze
was just about as horrible as the original one in the game; it got
simplified due to popular demand.  The problems were improving in
quality, and the coal mine maze was a late example of making things
hard by making them tedious.

The volcano section was Marc's second vehicle implementation, but is
perhaps more noteworthy for the loving portraits of Lord Dimwit
Flathead the Excessive that decorated the coin and stamp found in the
section.  The river (see Part I) and volcano sections, in addition to
vehicles, required a better concept of time: both the boat and the
balloon moved more or less on their own, and the volcano required the
use of explosives and fuses.  Marc added a clock daemon, which
processed a queue of events that would happen some fixed number of
moves later.  This handled, in addition to the movement of the
vehicles, the fuse, the lantern burning out, and the mysterious gnomes
that occasionally appear.  The first of these was in the volcano: if
the player got trapped in the upper reaches of the volcano by losing
his balloon, after a few moves a volcano gnome would appear and offer
freedom in exchange for a treasure.  We were just being nice; most
players weren't allowed to save their games, so they had no way of
backing out if they made such a mistake.  The gnome allowed them to
keep playing, albeit with no chance of getting all the points.

Even before the volcano section, we'd talked about a problem that
involved flying; Dave had a preference for something with an eagle,
and its aerie, but we could never figure out how to restrict things
enough -- it wouldn't do to have a parallel map of the game viewed
from the air.  Once again, we worried about restraining a new concept,
so the balloon had no way of leaving the volcano.  And once again we
were bitten by a new concept.  When the player used the explosives in
the wrong place, and didn't get out of the way, he'd end up with
20,000 pounds (or was it tons?) of rock on his head.  This made a
certain amount of sense in the underground section, but not out in the
forest.

No more sections were added to the game for several months after July,
but it continued to improve.  In addition it finally moved to machines
other than DM, thus greatly expanding the number of players.

Although Muddle ran primarily on DM, a version for TENEX (the most
popular PDP-10 operating system on the Arpanet) had existed for some
time; the TENEX version could, with some minor modifications, run on
TOPS-20 as well.  We finally succumbed to one of the requests for a
copy of Zork when we were given an account on a TOPS-20 machine on the
net.  After we made the necessary software modifications, of course,
many copies could be made; a mailing list of Zork owners developed, so
They could get whatever updates appeared.

Although people could get runnable Zorks, they couldn't get sources.
We tried two approaches to protecting the sources (remember, there was
no protection of any sort on DM): they were normally kept encrypted;
and we patched the system to protect the directory where we kept the
sources (named CFS, for either "Charles F. Stanley" or "Computer
Fantasy and Simulation").  This worked pretty well, but was finally
beaten by a system hacker from Digital: using some archaic ITS
documentation (there's never been any other kind), he was able to
figure out how to modify the running operating system.  Being clever,
he was also able to figure out how our patch to protect the source
directory worked.  Then it was just a matter of decrypting the sources,
but that was soon reduced to figuring out the key we'd used.  Ted had
no trouble getting machine time; he just found a new TOPS-20 machine
that was undergoing final testing, and started a program that tried
every key until it got something that looked like text.  After less
than a day of crunching, he had a readable copy of the source.  We had
to concede that anyone who'd go to that much trouble deserved it.  This
led to some other things later on.

Players hadn't been able to save their Zorks because the method we
used at first took several hundred thousand bytes for each save, and
even on a time-shared system that was excessive.  Marc, around this
time, invented a new way of saving that cut the size down to
something more reasonable, with the slight disadvantages that any new
rooms or objects added to the old game would break existing save
files, and that it never quite worked right anyway.  However, it did
make it easier to play the game, and we still had the silly notion of
being nice to our users.

Fall '77 saw two major additions to the game, as Marc took another
break from medical school (yes, fans, he did graduate on time), and
Dave got into coding in a big way.  The Alice in Wonderland section,
complete with its magic bucket and robot, was installed.  The robot was
the first "actor," an object that could perform some of the same tasks
the player could.  The style of address was familiar: "ROBOT, TAKE THE
CAKE."  The implementation of this required another change in the
game's flow of control, and changes to anything else that one could
reasonably talk to.

The first version of fighting was added about the same time.  Dave, an
old Dungeons and Dragons player, didn't like the completely
predictable ways of killing creatures off.  In the original game, for
example, one killed a troll by throwing a knife at him; he would catch
the knife and gleefully eat it (like anything else you threw at him),
but hemorrhage as a result.  Dave added basically the full complexity
of DD-style fighting, with different strengths for different weapons,
wounds, unconsciousness, and death.  Each creature had its own set of
messages, so a fight with the thief (who uses a stiletto) would be
very different from a fight with the troll and his axe.

As a result of the purloined sources at DEC, a lunatic there decided
to translate Zork into FORTRAN.  We had always assumed this would be
impossible: Muddle is very (oops, *very*) different from FORTRAN, and
much more complicated, and we'd used most of its features in designing
Zork.  The guy who did it was mostly a hardware person, so perhaps he
didn't know what he was up against.  At any rate, shortly after the
Great Blizzard of '78 he had a working version, initially for PDP-11s.
Since it was in FORTRAN, it could run on practically anything, and by
now it has.

Unfortunately, at some point in the preceding year we (no one will now
admit to suggesting the idea) had decided to change the name of the
game.  Zork was too much of a nonsense word, not descriptive of the
game, etc., etc., etc.  Silly as it sounds, we eventually started
calling it Dungeon.  (Dave admits to suggesting the new name, but
that's only a minor sin.) When Bob the lunatic released his FORTRAN
version to the DEC users' group, that was the name he used.  I'm sure
many people have noticed a curious similarity between the Dungeon game
they played on their friendly IBM 4341 and the Zork I they played on
their equally friendly IBM PC; now you know why.

Fortunately for us, a certain company (which shall remain nameless)
decided to claim that it had trademark rights to the name Dungeon, as
a result of certain games that it sold.  We didn't agree (and MIT had
some very expensive lawyers on retainer who agreed with us), but it
encouraged us to do the right thing, and not hide our "Zorks" under a
bushel.

The next section that was added was intended to be the last: after a
player had accumulated all the points in the game, he could play the
End Game, designed largely by Dave.  This became the section of Zork II
with the Dungeon Master, and at the time was certainly the most
involved, and hardest (as it should have been) thing in the game.  The
implementation was, if anything, more involved than the problem.  Less
than two months later, though, Marc had come up with something worse,
probably during a boring anatomy lecture.  The bank section has
probably been fully deciphered by fewer people than anything else in
the game; even those who solve it on their own don't usually
understand what was going on.  I can only say that it makes sense if
you understand it.

For some time, we'd been getting bug reports, fan mail, and
suggestions for new problems from all sorts of people.  We were
beginning to run a little short on ideas anyway, and one of the ideas
we got was very good.  During a lengthy dinner at Roy's, our favorite
Chinese restaurant, we worked out the details of the jewel-encrusted
egg, purple prose courtesy of Dave.  Many people on the net had long
since solved the game, but went back in and did any new problems that
came along; one of them had played DD with Dave, and called him up
about a day after the egg was announced.  "I've gotten the egg opened,
but I assume you losers have some nonsense where you do something with
the canary and the songbird.  Dave, no fool, said "Cough, cough, ahem,
of course," and immediately went off and added the brass bauble.

The remaining puzzles, the Royal Zork Puzzle Museum and the palantirs,
were added in the late summer and fall of 1978.  The puzzle was
designed (several times) primarily by Bruce, who in theory was back
trying to finish his dissertation.  Finding the minimum number of moves
required to solve it was a popular pastime among dedicated Zorkers for
a while.

The last (lousy) point was a tribute to the final point in the
original Adventure, which involved leaving a particular object in a
particular room for no particular reason.  When we first solved
Adventure in 1977, Bruce finally figured this out by using a
machine-language debugger on the running game (since Adventure was not
written in machine language, this was not easy).  The major difference
between that and our version (a stamp worth One Lousy point) is that
it would be harder to find ours without the source of the game.

The last puzzle was added in February of '79.  We (mainly I, at this
point) kept fixing bugs for almost two more years -- the last
mainframe update was created in January of '81.  No new puzzles were
added because none of the implementers had time or inclination, and
because we had no more space available: at the time, we were limited
to a megabyte of memory, and we had used it all up.  The first article
about Zork appeared in April of '79, and attracted a great deal of
interest; some of this may have been because we offered to give people
the game (if they didn't already have it), and gave them parts of the
sacred sources as well.

Infocom was incorporated in 1979 by various people from the DM group,
including Marc, Dave, and me.  It was not founded to sell Zork; rather,
it was founded to give group members somewhere to go from MIT.  Marc
and Joel Berez (both exiled to Pittsburgh) determined that it would be
possible to make Zork run on something cheaper than the $400,000
PDP-10, and the company eventually went along.  See the next NZT for
further details.

In the meantime, we still get requests for hints on the mainframe Zork
(sometimes it's called Dungeon, and often it's on something other than
a PDP-10).  The most recent request for a copy came in on April 1, but
I think it was serious.

[end]
Newsgroups: alt.folklore.computers,rec.games.int-fiction