The Art of Rewriting Old Games

Take some of the 8-bit games you enjoyed as a kid and update them for the new generation.

The opening lines of Nellan Is Thirsty (Figure
1), an old text adventure game for 8-bit home computers, say
“You are in a room called the Bank. A giant carpet on the floor says
Welcome....The BANKER, Mr. Klinkoyn, looks sleepy.” If you don't
recognize those words, you're not alone. It is one among thousands of
open-source programs written during the 1970s and 1980s that have gone out
of popular play.

Figure 1. The Original Text Adventure

During the reign of the 8-bit computer, many independent hobby
programmers produced a wide assortment of quality, open-source
software. There was no such thing as the GNU General Public License
(GPL) in those days, so programmers offered to release their works
to the public domain (PD). In fact, the GPL was created
specifically to overcome some of the deficiencies of the PD licensing model (see
Resources). These programs were distributed through the media of the day:
electronic billboards, local users groups, magazines and mail-order
software collections.

Unfortunately, most of this groundbreaking software has faded into digital
oblivion as the aging disks and tapes upon which it is encoded slowly
canker away in dusty closets and attics. For certain types of programs,
this is no great loss. Old word processors and spreadsheets, for example,
are grossly primitive compared to their modern counterparts and are of
limited usefulness today. The gravest tragedy posed by the disintegration
of old diskettes, however, is the loss of old games.

Old games? Such a claim is not as ludicrous as it first may seem. In
contrast to most practical software—which may undergo many revisions
during its lifetime to stay current—entertainment software
generally does not receive regular updates. A game may spawn a sequel
or two, but these sequels usually are separate games in their own right,
not revisions of the original. Without an update every few years, old
games eventually dwindle into disuse. Some people, motivated by a desire
to prolong the life of these digital relics, zealously promote the use
of emulators, which allow users to simulate a different platform on a
modern PC. However, this only delays the imminent demise of old software,
it doesn't prevent it. Emulators are useful only to those with both
knowledge of and sufficient interest in the original platform. And
their numbers are going to decrease as time goes on.

What to do, then? Many of these old PD games are every bit as clever,
innovative and enjoyable to use today as they were 20 or 30
years ago. Although their graphics, if any, are crude compared to
modern games, they possess a certain charm that is uniquely theirs. As early
examples of open-source software, they represent a vital link to our past.
Emulators, impressive as they are, present only a partial answer. The
ideal solution would be to transform the original games into a format
palatable to modern audiences. Indeed, the best way to preserve old
software is to rewrite it.

Figure 2. The Rewritten Opening Screen

The Remaking of a Classic

For example, let us consider Nellan Is Thirsty, the game I mentioned at
the beginning of this article. It was written as sample code by Dr Furman
H. Smith and published in the July/August 1980 issue of the now-defunct magazine
Recreational Computing. From there, the code was released to the public domain. From this
humble beginning, the game circulated around various users groups
throughout the world. Its plot was typical of other PD adventure games
of the era: explore your surroundings, collect a series of treasures
and return them to a central location. As with most children's games,
there are no mistakes that cannot be undone and all the characters
are friendly. Unlike many other children's games, however, Nellan
Is Thirsty offers a high level of challenge and interest even for
experienced adventurers. Even after I had solved the game, I would play
it over and over again on my Commodore 64 simply for the fun of it.

As time passed, my platform of choice moved to MS-DOS and then to
Linux. Yet I would frequently turn back to Nellan Is
Thirsty with
a measure of poignant nostalgia, knowing that my children would
never likely see the game. Besides, the Commodore 64 being a dead platform,
modern gamers rarely have the patience for text
adventures. It occurred to me that the only way to preserve this
classic game for today's children would be to completely rewrite it as
a graphics-based game for modern computers. So, that's what I did.

The remake of Nellan Is Thirsty (I've given it the shortened
title of Thirsty Nellan) replaces the command-line parser interface
of the original game with a point-and-click GUI environment. The player
controls navigation of the on-screen avatar by using either the mouse or
the arrow keys. Items can be picked up and manipulated by clicking on
them. The player's inventory, showing the objects collected thus far
in the game, is displayed in a panel running along the bottom of the
window. The game's characters communicate to the player using digitized
speech. I designed the background scenery using the proprietary
Maya software from Alias|Wavefront. The 3-D models were then rendered as
2-D perspective images, giving a 3-D look-and-feel to the game without the
computational overhead of real-time 3-D rendering. This allows Thirsty
Nellan to run at acceptable speeds even on low-end PCs.

Figure 3. Discovering the Milk Room in the Original

Figure 4. In the new version, inventory appears in the bottom bar.

Such modernizations come at a cost. For example, increasing the
simplicity of the interface has the unfortunate side effect of decreasing
its precision. In the original game, the player had a fairly expressive
vocabulary for interactions with the virtual environment, using
typed commands such as TAKE, DEPOSIT, CONSULT and LOOK. In the
GUI, however, all forms of expression are reduced to one
command: click. For most games, this limitation is outweighed
by the benefits. Players no longer need to guess which combination of
nouns and verbs the parser accepts; rather,
they are free to explore their virtual environment in a graphical setting.

Nellan Is Thirsty had the historic distinction of being the first text
adventure written specifically for children. Now it marks yet another
milestone in computer gaming history as the first text adventure to
be rewritten completely with a GUI. Although the new
game's story line is almost identical to its predecessor, not one line of
code was borrowed from it. The original BASIC code base, which centered
around parsing typed commands, simply was incompatible with my design for
a modern GUI-based game. Thus, Thirsty Nellan is
implemented in C++;
I used the familiar Qt API to build the user interface. Qt is best known
for being the framework of the K Desktop Environment, so players
may notice a similar look and feel between Thirsty
Nellan and
KDE. Although the game's development was completed almost entirely in
Linux, I've also compiled a version for Microsoft Windows.
Using Qt permitted me to maintain a single code base
for both the Linux and Windows versions of the game.

In keeping with the open-source goals of the original, Thirsty
Nellan
is released under the GPL. Curious players may notice one or two symbolic
tributes to other modern open-source games. Most noticeably, the animated
penguin who acts as the game's protagonist was borrowed directly from
Sam Hart's popular educational game Tux Typing. Especially observant
players also may recognize the red-colored jewel from Anders Widell's
ubiquitous KSokoban, which here serves as one of the treasures the player
must find to win Thirsty Nellan.

When I was first introduced to Linux four years ago, I really learned to appreciate text-based games. I really enjoyed this article, and I now have a fresh copy of 'Thirsty Nellan' running on both my wifes W2K machine and my Linux box.