The Art of Rewriting Old Games
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.
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.
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.
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.
|Updates from LinuxCon and ContainerCon, Toronto, August 2016||Aug 23, 2016|
|NVMe over Fabrics Support Coming to the Linux 4.8 Kernel||Aug 22, 2016|
|What I Wish I’d Known When I Was an Embedded Linux Newbie||Aug 18, 2016|
|Pandas||Aug 17, 2016|
|Juniper Systems' Geode||Aug 16, 2016|
|Analyzing Data||Aug 15, 2016|
- Updates from LinuxCon and ContainerCon, Toronto, August 2016
- What I Wish I’d Known When I Was an Embedded Linux Newbie
- NVMe over Fabrics Support Coming to the Linux 4.8 Kernel
- Download "Linux Management with Red Hat Satellite: Measuring Business Impact and ROI"
- New Version of GParted
- All about printf
- Tor 0.2.8.6 Is Released
- Returning Values from Bash Functions
- Tech Tip: Really Simple HTTP Server with Python
With all the industry talk about the benefits of Linux on Power and all the performance advantages offered by its open architecture, you may be considering a move in that direction. If you are thinking about analytics, big data and cloud computing, you would be right to evaluate Power. The idea of using commodity x86 hardware and replacing it every three years is an outdated cost model. It doesn’t consider the total cost of ownership, and it doesn’t consider the advantage of real processing power, high-availability and multithreading like a demon.
This ebook takes a look at some of the practical applications of the Linux on Power platform and ways you might bring all the performance power of this open architecture to bear for your organization. There are no smoke and mirrors here—just hard, cold, empirical evidence provided by independent sources. I also consider some innovative ways Linux on Power will be used in the future.Get the Guide