Roger M. Wilcox's old TRS-80 adventure games

Rewritten as modern Windows apps

Misadventure is the very first adventure
game I ever wrote, and it shows. Originally written for the TRS-80 in
1980, I finally got around to rewriting the game as a WPF .NET application in
2012 as part of my "remember my past" endeavor. NOTE: This is a
.NET 4.0 application, and requires that you have installed either the
full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual
C# source code for Misadventure.

Star Cruiser is the second adventure game I
ever wrote. Originally written for the TRS-80 in 1980, I finally got
around to rewriting the game as a WPF .NET application in 2012 as part of my
"remember my past" endeavor. NOTE: This is a .NET 4.0 application,
and requires that you have installed either the full .NET 4.0 framework
or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual
C# source code for Star Cruiser.

Jailbreak is the third adventure game I
ever wrote, and is also probably the smallest. Originally written for the
TRS-80 in 1980, I finally got around to rewriting the game as a WPF .NET
application in 2012 as part of my "remember my past" endeavor.
NOTE: This is a .NET 4.0 application, and requires that you have
installed either the full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual
C# source code for Jailbreak.

Space Traveller is the fourth adventure
game I wrote for the TRS-80, originally in 1980. I managed to recover the
program from cassette tape in 2013, and rewrote it as a WPF .NET application as
part of my "remember my past" endeavor. I drew a little bit of my
inspiration from Scott Adams' Ghost Town adventure, and a tiny bit from
his Strange Odyssey. NOTE: This is a .NET 4.0
application, and requires that you have installed either the full .NET
4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for Space Traveller.

Nuclear Submarine is the fifth adventure
game I wrote for the TRS-80, originally in 1980. I managed to recover the
program from cassette tape in 2013, and rewrote it as a WPF .NET application as
part of my "remember my past" endeavor. NOTE: This is a .NET 4.0
application, and requires that you have installed either the full .NET
4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for Nuclear Submarine.

India Palace is the sixth adventure game I
wrote for the TRS-80, originally in 1980. I managed to recover the
program from cassette tape in 2013, and rewrote it as a WPF .NET application as
part of my "remember my past" endeavor. NOTE: This is a .NET 4.0
application, and requires that you have installed either the full .NET
4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for India Palace.

The Vial of Doom is an adventure game I wrote for
the TRS-80 in 1980, which was based on a
25-page typewritten short story
I'd written a year earlier (which in turn was influenced just a teensy weensy
bit by Michael Moorcock's multiverse). In many ways, this game was a
watershed in my adventure-game-authoring career, as I originally thought the
story was way too complicated to make an adventure game out of ...
until I read an article about Greg Hassett's "World's Edge" adventure
and turned green with envy and grim with determination. I considered it
my first "good" TRS-80 adventure game; it was the 7th I'd written, and 14 more
would follow it (15, if you count that Star Trek adventure where you
can't even pick things up). When the IBM PC became available to me in
1983, I ported this game to GWBASIC. (At some point afterward, I posted
the source code to Usenet; it's now archived
here.) I finally got around to
rewriting the game as a WPF .NET application in 2012, as part of my "remember
my past" endeavor. NOTE: This is a .NET 4.0 application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual C# source
code for The Vial of Doom. For an "authentic" adventuring
experience while playing this game, play the theme song for the Bill Bixby
Incredible Hulk TV series in the background, and sing along with lyrics:
"The Vial of Doom / An epic storyyyyy / About destroying / Chaos's gloryyyyy /
Although it may / Seem mildly goryyyyyy ..."

The Poseidon Adventure is the eighth adventure
game I wrote for the TRS-80, originally in 1980. At one point, I renamed
it The Upsidedown Adventure out of fear that 20th Century Fox might sue
me for trademark infringement; but frankly, if I can write a game named
Another Star-Trek Game and not get sued, I'm probably safe. (Then
again, Scott Adams did get in trouble for naming one of his adventures
Mission Impossible.) I managed to recover the program from
cassette tape in 2013, and rewrote it as a WPF .NET application as part of my
"remember my past" endeavor. NOTE: This is a .NET 4.0 application,
and requires that you have installed either the full .NET 4.0 framework
or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual C#
source code for The Poseidon Adventure.

Interstellar War is the ninth adventure
game I wrote for the TRS-80, originally in 1981. Just as The Vial of
Doom was an adventurized version of a short story I wrote with the same
name, so Interstellar War was based (very loosely) on my original
40-page draft of The Pentagon War. I finally
got around to rewriting Interstellar War as a WPF .NET application in
2012 as part of my "remember my past" endeavor.
NOTE: This is a .NET 4.0 application, and requires that you have
installed either the full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for Interstellar War.

In the Universe Beyond is the tenth
adventure game I wrote for the TRS-80, originally in 1981. I managed to
recover the program from cassette tape in 2013, and rewrote it as a WPF .NET
application as part of my "remember my past" endeavor. NOTE: This
is a .NET 4.0 application, and requires that you have installed either
the full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for In the Universe Beyond.

The Staff "Slake" is the twelfth adventure
game I wrote for the TRS-80, originally in 1981. I finally got around to
rewriting it as a WPF .NET application in 2012 as part of my "remember my past"
endeavor. NOTE: This is a .NET 4.0 application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for The Staff "Slake".

Tanker Train is the thirteenth adventure game
I wrote for the TRS-80, originally in 1981. I managed to recover the
program from cassette tape in 2013, and rewrote it as a WPF .NET application as
part of my "remember my past" endeavor. Those of you who've played Scott
Adams' Mission Impossible adventure will probably notice whence I got a
little bit of my inspiration. NOTE: This is a .NET 4.0
application, and requires that you have installed either the full .NET
4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual C#
source code for Tanker Train.

Medieval Space Warrior is the fourteenth
adventure game I wrote for the TRS-80, originally in 1981. It was
inspired, to a small degree, by Arthur C. Clarke's The City and the
Stars. I consider it one of the three best TRS-80 adventure games I
wrote, alongside The Vial of Doom and The Last City. I
ported it to GWBASIC in 1983 or 1984 or thereabouts, and finally got around to
rewriting it as a WPF .NET application in 2012 as part of my "remember my past"
endeavor. NOTE: This is a .NET 4.0 application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for Medieval Space Warrior.

King of the Jungle is the fifteenth
adventure game I wrote for the TRS-80, originally in 1981. I finally got
around to rewriting it as a WPF .NET application in 2012 as part of my
"remember my past" endeavor. NOTE: This is a .NET 4.0 application,
and requires that you have installed either the full .NET 4.0 framework
or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for King of the Jungle.

Trash Island is a combination of the sixteenth and
seventeenth adventure games I wrote for the TRS-80, originally in 1981.
They were once billed as Parts I and II of the Trash Island trilogy, titled
"In Search of Trash Island" and "The Hidden City of Trash Island", before I
combined them into a single adventure game in GWBASIC. (And, yes, I got
the idea for a multi-part adventure with "Island" in its name from a certain
famous Scott Adams two-parter.) I finally got around to rewriting it as a
WPF .NET application in 2012 as part of my "remember my past" endeavor.
NOTE: This is a .NET 4.0 application, and requires that you have
installed either the full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual C#
source code for Trash Island.

Escape from Trash Island is the
eighteenth adventure game I wrote for the TRS-80, originally in 1981.
It was once billed as Part III of the Trash Island trilogy, before I combined
parts 1 and 2 of the trilogy into a single adventure game in GWBASIC.
You're expected to have completed the previous adventure game, which gave you
a password you need in order to be able to play Escape from Trash Island
at all. (Those of you wondering where I got that particularly oddball
password from, go watch an old Bugs Bunny cartoon titled "Bushy Hare.") I
finally got around to rewriting Escape from Trash Island as a WPF .NET
application in 2012 as part of my "remember my past" endeavor.
NOTE: This is a .NET 4.0 application, and requires that you have
installed either the full .NET 4.0 framework or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete
Visual C# source code for Escape from Trash Island. (And, yes,
doing so will allow you to find the password for the game without having to
complete the previous adventure first. Cheater.)

Followers Adventure is the nineteenth adventure
game I wrote for the TRS-80, originally in 1982. It was a rather
sarcastic adventure game set in Palestine about two millennia ago, if you catch
my drift. I finally got around to porting to 32-bit Windows in September
2002. If you have way too much time on your hands, you'll also want to
see the complete Visual C++ source code for
Followers Adventure.

Derelict 2147 is the twentieth adventure game I
wrote for the TRS-80, originally in 1982. I finally got around to
rewriting it as a WPF .NET application in 2012 as part of my "remember my past"
endeavor. NOTE: This is a .NET 4.0 application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual C#
source code for Derelict 2147.

The Last City is the twenty-first — and
the last — adventure game I wrote for the TRS-80. In 1983, I could
feel my interest in the TRS-80 waning as the new IBM PC started to take over my
computing life. The previous TRS-80 adventure game I'd written,
Derelict 2147, was a ho-hum treasure hunt adventure that could never
compare with my two previous masterpieces, The Vial of Doom and
Medieval Space Warrior. It would have been a dull, bland note to
go out on, and I wanted to leave with a bang. So, bringing
together all the elements that made those two previous masterpieces so good,
I decided to write one last TRS-80 adventure game. To this day, I
consider The Last City to be the pinnacle of my adventure-game-writing
oevre — so much so that I ported it to GWBASIC on the PC and posted the
source code on Usenet (which is still archived
here). Later, in 1989, I ported
it to Turbo C as a full-screen MS-DOS console application, and then finally in
2001 I turned it into a real honest-to-goodness 32-bit Windows app. If
you have way too much time on your hands, you'll also want to see the
complete Visual C++ source code for The Last
City.

In 1983, as a kind of footnote to my TRS-80 adventure game oevre, I wrote a
brief adventure game based on Star Trek. I don't remember the name
I gave to this adventure, only that it wasn't Star Trek Adventure.
You didn't even have the ability to pick up or put down objects in this
game. The goal involved wiping out some Klingons and scoring with a
beautiful female alien. Sadly, I can't find the Level II BASIC source
code for this adventure on any of the TRS-80 cassettes in my collection;
there's a chance that, since I considered this game to be so much more
simplistic than my other adventures, I wrote over it when a more "important"
piece of TRS-80 software came along.

... and one by Roger M. Wilcox's dad:

Darkpit was my dad's Magnum Opus of TRS-80
adventuredom. Somewhere in another adventure, you fell into a dark pit and were
left for dead. Any light source you may have had was either lost or broken.
You awaken lying on a stone floor in pitch darkness, and must feel your way
along if you're to have any hope of escape. Sadly, he never finished this game
... but in 2013, I rewrote it for .NET 4.0, and in so doing brought the game to
completion. Like most of the adventures above, it's a .NET 4.0 application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. You can also view the
complete Visual C# source code for
Darkpit, and if you're really interested, here's the
original TRS-80 Level II BASIC version of Darkpit as
my dad last left it, viewable as a virtual cassette in a TRS-80
emulator.

Roger M. Wilcox's old TRS-80 non-adventure games which require
a TRS-80 emulator to run

NOTE: The links below are .cas files, which are binary images
of data stored on cassette (as used by TRS-32 and other TRS-80 emulators). If
these links don't work for you, I've bundled all the .cas files that appear on
this page in a single .zip file that you can download with this link:
RMW_TRS-80.zip.

Armor Battle - A small game I wrote
early on, not very sophisticated. Your tank's cannon could only shoot something
if you got right next to it.

Interception - Based on the arcade video
game called Intercept, where you tried to run into score boxes while
avoiding your own ever-growing tail.

Solar Nova - Space aliens are trying to blow up
the sun! Your space ship must manufacture what it needs to survive each attack
wave and shoot down the Hydron missiles, either with your own missiles or with
your one-shot space lasers. But beware, the enemy has fighters, too. (Inspired
by Stewart Eastman's Slag.)

Empire Wars - Imperial Stormdrains are
attacking! You must clear a path through them with your blaster and your
photon sword, then face down the dreaded Darth Badguy. If the odds are stacked
too highly against you, you can try to Use the Farce. Graphics are eerily
reminiscent of Leo Christopherson's Android Nim. Audio is eerily
reminiscent of Leo Christopherson's Duel-N-Droids. There is also an
earlier, text-only version of Empire
Wars.

Another Star-Trek Game (yes, with the
hypen between the "Star" and the "Trek") is perhaps the one game I spent more
time perfecting on the TRS-80 than any other. Inspired by Simutek's
Graphictrek 2000, for which I had complete source code since it was
written entirely in Level II BASIC, I embarked on writing my own Star Trek text
game in 1981 or so. My take on this classic here is, perhaps, the only
TRS-80 Star Trek game wherein you'll do better if you fight the Klingons
while your engines are running.

Roger M. Wilcox's dad's old TRS-80 adventure games which require a
TRS-80 emulator to run

Dungeon 1 – Small enough to fit in 4K.
Fight your way through a dungeon filled with wandering monsters, including the
dreaded Arcing TRS-80.

Darkpit – My dad's Magnum Opus of TRS-80
adventuredom. Somewhere in another adventure, you fell into a dark pit and were
left for dead. Any light source you may have had was either lost or broken.
You awaken lying on a stone floor in pitch darkness, and must feel your way
along if you're to have any hope of escape. Sadly, he never finished this game.
If you have way too much time on your hands, you might also want to see the
Level II BASIC source code for Darkpit in
human-readable ASCII format. I eventually rewrote it for .NET 4.0, and in so
doing brought the game to completion. Here's the
completed .NET 4.0 version of Darkpit, with
complete Visual C# source code.

Old TRS-80 adventure games which require a TRS-80 emulator to run
and which were written neither by Roger M. Wilcox nor his dad

Star Trek Adventure – by Randy
Hawkins. I typed this in from an article titled "Save Our Ship" in 80
Microcomputing's annual games issue (August 1982). This particular game
avoided giving away spoilers to a casual reader of the program listing by
storing all its text in substitution-cipher strings. It also features the
planet "Teiras 80." Get it? 'Cause it's on a TRS-80? ... <crickets>
(Geez, tough room.)

Roger M. Wilcox's old non-adventure games

Another Star-Trek Game (a modern
port of the same-named TRS-80 game above). I ported this game to GWBASIC
for the IBM PC in 1983, then to Turbo Pascal for MS-DOS in 1988, and finally
got around to rewriting it as a WPF .NET application in 2012 as part of my
"remember my past" endeavor. NOTE: This is a .NET 4.0 application,
and requires that you have installed either the full .NET 4.0 framework
or at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands,
you'll also want to see the complete Visual
C# source code for Another Star-Trek Game.

Hack Up the Monster, Steal its Treasure, and
Proceed On to the Next Room. Helpfully abbreviated
HUtMSiTaPOttNR, or just HUtMSiTa because it was originally
written back when filenames were limited to 8 characters. This was
originally written in GWBASIC in the 1980s, then rewritten in Modula II in
around 1990 or so, and finally ported to Visual C# in 2012. Basically,
this is a text-based "dungeon run" game based around the 1st Edition AD&D
Unearthed Arcana rules — except that you can never gain a
level. NOTE: This is a .NET 4.0 console application, and
requires that you have installed either the full .NET 4.0 framework or
at the very least the
.NET
4.0 Client Profile. If you have way too much time on your hands
you'll also want to see the complete
Visual C# source code for HUtMSiTaPOttNR; which, due to originating
in a language which lacked local variables, has all sorts of weird short
variable name reuse throughout it.

Hexagonal Minesweeper: I released this game
as shareware in 1993, and made a grand total of $90 off of it because I set the
price way too high. Since it's been over a decade, I thought I'd
release a Win32 build of the Registered Copy Version of this game to the world,
which is what the link above points to. (For authenticity, I even
included the original, self-righteous README file that I distributed with the
six Registered copies I actually sold.) And since this app is now so old
there's zero business potential in it any more, here is the
complete VC++ source code for the Registered Copy
version of Hexagonal Minesweeper updated for 32-bit compilation,
including a compiled 32-bit version of the .exe. Note: The sound API I
was using in the old 16-bit registered copy version doesn't exist in Win32.

Hack Up the Monster, Steal its Treasure, and
Proceed On to the Next Room, version 2.0. Helpfully abbreviated
HUtMSiTaPOttNR 2. This is a major revision of the above C# .NET
port of HUtMSiTaPOttNR. Think of it as 1st Edition AD&D with the
Unearthed Arcana supplement, the command-line text game. It's
pretty extensive; the only things from 1st Edition AD&D with Unearthed
Arcana that aren't (yet) included in HUtMSiTaPOttNR 2.0 are:

Most magic items

All but one artifact

Monster spell casting

Missile weapons

Spiked bucklers. I hate spiked bucklers.

Psionics

Holy water/flaming oil

Player characters surprising monsters

Companions that stick around after a combat is over

Weight allowances

Weapon proficiencies

Spell material components

Unidentified magic items

Ranged combat (all combat is assumed to take place at melee range, with
each team conveniently lined up on opposite sides of the room)