Tag Archives: The Oregon Trail

The Oregon Trail is all about resource management. You start the game with $700, which will have to serve as your non-renewable bankroll for the entire trip. From this you must buy your oxen team as well as food, ammunition, clothing, and “miscellaneous supplies” (which basically comes down to medical supplies). Play then proceeds through a series of up to 18 turns, each representing two weeks on the trail. At the beginning of each you can choose whether to hunt or simply press onward. In addition, you pass by a fort every other turn, where you can purchase additional supplies if you like. And you have to decide if you want to eat poorly, moderately, or well during that period, balancing your food supplies with the risk of illness that comes from a poor diet and hard work. During the body of each turn, you are usually subjected to a randomly chosen event of some kind. Most of these are of the unfavorable variety. This series of misfortunes and disasters is what most people remember best about the game:

“WAGON BREAKS DOWN — LOSE TIME AND SUPPLIES FIXING IT.”
“OX INJURES LEG — SLOWS YOU DOWN REST OF TRIP.”
“BAD LUCK — YOUR DAUGHTER BROKE HER ARM. YOU HAD TO STOP AND USE SUPPLIES TO MAKE A SLING.”
“WILD ANIMALS ATTACK!”

According to the City Pages article, these last were hostile Indians in the original version, which would certainly have been more exciting to imagine if less politically correct. Telltale signs of code modifications around line 2885 bear this out. (Interestingly, the immortal “YOUR WAGON BROKE AN AXLE!,” source of a long-running Internet meme, is not yet in this version.) This tragic litany is occasionally broken by “HELPFUL INDIANS SHOW YOU WHERE TO FIND MORE FOOD,” but most of the time it’s a hard life indeed on the trail — which I suppose is accurate enough.

Rawitsch strove mightily to make the program accurate in its simulation of the trip, even constrained as he was by the limitations of his computing hardware and HP BASIC. The likelihood of the various randomized events are based as much as possible upon historical reality. The terrain changes; the going gets slower and harder later in the trip, when you begin to pass through the Rocky Mountains. Even the weather changes, requiring more clothing. In fact, there is more going on below the surface than you might realize. A peculiarity that The Oregon Trail shares with many other BASIC games of this era is that it seems to expect — even to depend upon — the player having a look at the code in order to fully understand what’s going on in the game. For instance, I didn’t realize that stopping at a fort for supplies dramatically reduces the miles you can cover in a single turn until I read that in the code. Likewise, it is easy to miss the terrain changes and the effect they have on the game if you haven’t at least skimmed through the code.

As a narrative experience, The Oregon Trail is more compelling than it perhaps has any right to be. Its communications are terse indeed, but one really does get the sense of embarking upon a long and dangerous journey. As I limped ever close to my destination of Oregon City, with one of my oxen injured, low on food and supplies, with winter fast closing in, I felt real tension and concern for my little family. The “you are there” feeling is further enhanced by the occasional “action” sequences in which you are given a limited amount of time to type the word “BANG” in the hopes of success at hunting or at defending yourself from bandits or animals. The game is relentlessly unforgiving; failing to stockpile enough food for the coming turn, or enough medicine or bullets, leads to instant death. Unlike in more typical early adventures games, where instadeaths are rather comical in their unexpectedness and cruelty, these feel believable. It was a hardscrabble existence indeed on the trail, and I’m sure plenty of real would-be settlers died for exactly these reasons. There’s actually a consonance between gameplay and narrative that’s rather rare to find even in modern storygames.

My personal strategy is to buy little if any food, reserving my precious money for other things. I then hunt about every other turn, taking advantage of the fact that I know my way around a keyboard pretty well. I also try very hard not to carry too much stuff at any time, as I always seem to end up losing it for nothing in some disaster or other. Traveling light, however, means more stops at forts; my biggest problem is usually running out of time, being trapped on a mountain trail when winter arrives. If you develop a favorite strategy of your own, maybe one that works better than mine, feel free to tell about it in the comments.

The Oregon Trail story after 1978 has been much better documented than has its early years, so I won’t devote much space to that. By 1980 MECC had purchased 500 Apple IIs and installed them in classrooms all over Minnesota, where children used them to (among other things) play the freshly ported Apple II version of The Oregon Trail. There followed a version with accompanying full-color illustrations (1985), a CD-ROM extravaganza version (1996), and, eventually, that Facebook version (2011), just to hit some of the highlights. When you strip away all of the multimedia that encrusts them, it’s really quite surprising how closely these later versions hew to the model that Rawitsch designed back in 1971. It’s not the most sophisticated storygame in the world, but it really is better than it ought to be. I’m glad I took the time to get to know it better, and, again, happy to be able to offer the code to anyone else who’d like to dive in. I’d go so far as to place it alongside Eliza and Hunt the Wumpus as one of the three pre-Adventure computer games that anyone interested in the history of interactive narrative really ought to know.

It’s been a while since I’ve written on this subject. That hasn’t been because I’ve lost interest; rather the contrary actually. I’ve been doing some digital archeology with my new friends Michael Gemeny and Bob Brown of the HP 2000 Yahoo Group, and we’ve been able to turn up something very cool indeed.

On an old tape image from the school district of York County, Pennsylvania, Michael found a program with the very promising name of “Oregon.” Sure enough, when we loaded it onto the system we found a version of The Oregon Trail dated March 27, 1975, more than three years older than the earliest previously known version. I’ve uploaded the program listing to this site, if you’d like to have a look. Looking at said listing has already proven to be very interesting for us.

First of all, it appears that the little history lesson I gave in part 3 of this series was not entirely correct. When Rawitsch came to MECC in 1974, he evidently did not port the game — or at least not immediately — to run on MECC’s centralized UNIVAC mainframe. He rather typed it out once again on another HP-2100 system. That makes a great deal of sense when one considers that these little systems were quite common in Minnesota schools and, indeed, in schools all over the country. By early 1975 MECC was obviously already giving the program away to school districts in other states.

It’s also evident that Rawitsch, or MECC, or at any rate someone, continued to improve and refine the game for years before it made its way to the Apple II. The 1978 version found in Creative Computing has some features not present in the 1975 version. In both versions, the player must enter a word quickly into the terminal at certain points: when hunting, when attacked by bandits, etc. The 1978 version, however, has a difficulty setting; when the program starts, the player is asked how good a shot she is, from “ace marksman” through to “shaky knees.” This determines how much time the player is given to type the word. And unlike in the 1975 version, in 1978 that word is chosen randomly from four possibilities — “BANG,” “BLAM,” “POW,” and “WHAM” to be specific. In 1975 it’s just good old “BANG” all the time. For those interested in looking at the differences, you can also download the 1978 version. This one isn’t quite as authentic as the 1975 one. I spent quite a lot of time fixing problems in the code that resulted from the OCR, and in the process also ported it back to HP-BASIC from CDC Cyber BASIC. I believe the problems have all been sorted out, however, and it should look and play just as it would have on an HP system back in 1978.

So, if we take the liberty of calling these major version numbers 2 and 3, it sure would be nice to have version 1, wouldn’t it? Unfortunately, that doesn’t look likely to happen. Since this version apparently never made it beyond the system on which Rawitsch, Heinemann, and Dillenberger wrote it, and since Rawitsch deleted it off of that system in 1972, the only hope seemed to lie with that famous yellowing printout Rawitsch carried over to MECC. This picture from an Oregon Trail anniversary event at the Mall of America gave us hope, as Rawitsch is holding something that looks suspiciously like exactly what we were seeking.

I was able to contact Rawitsch about that, but the news was disappointing: he no longer has the printout. Barring a miraculous find, it appears that the 1975 version is the best we’re likely to do. Still, that’s a heck of a lot better than 1978. I feel lucky indeed to have found it.

Looking at the code of the 1975 version does tell some very interesting stories in itself. Michael knows much more about HP BASIC than I do, so I’m going to quote him here:

“The line numbers of this code tell an important part of the story which matches the historical accounts. From the looks of it, I would have said that it was being maintained by an accomplished programmer with a sense of pride and dedication. Then it seems to have been maintained by a less experienced programmer, or a programmer lacking the sense of pride, or the time, or perhaps the skill to maintain the appearance of the code.”

This latter programmer would of course be Rawitsch, who re-keyed and modified the program at MECC, initially at least on his own, and who, unlike Heinemann and Dillenberger, was not a trained programmer.

While most of the program is numbered in steps of 5, this pattern is occasionally broken. This is somewhat odd, as Michael informs me that HP-BASIC has a very powerful renumbering facility that Rawitsch perhaps didn’t know to take advantage of. Michael has assembled a list of lines which break the numbering pattern, and which therefore probably indicate places where Rawitsch made changes or additions at MECC. At the risk of belaboring the point, I’ll just paste that in here for the passionately interested.

Line 8- 11 Added MECC name, maintainer, and version
Line 262-263 Caution user against using a dollar sign
Line xx99 added section names in remarks
Line 1332 require user answer to be an integer
Line 1537 added caution about spending
Line 1752 discovered that ‘7 was a bell, added note to that
effect
Line 1902 made question two lines
Line 2392 fixed bug when riders don’t attack
Line 2672 added ammunition losses to heavy rains losses
Line 2792 added ammunition losses to fire losses
Line 2891 may have changed Indians to wolves and cause death
Line 3147 added ammunition losses to wagon damage
Line 3317 added ammunition losses to blizzard damage
Line 3650-3658 added next of kin and aunt Nellie
Line 4012 added another note about ‘7 bells
Line 4279 changed congratulatory message

Working from these clues and the historical record, it might be possible to reconstruct an “original” Oregon Trail. I’ve thought about it quite a lot, but I’m not really certain if it’s a good idea. The end result would inevitably be the product of a lot of conjecture. And, while we can learn much from the line numbers, we can’t know what modifications Rawitsch might have made within certain lines.

But perhaps you’d like to play this thing? If so, here’s how you can experience it in all its 1975 glory in HP Time-Shared BASIC.

1. Telnet to mickey.publicvm.com. (Telnet, mind you. None of that newfangled SSH!)
2. Slowly alternate CTL-J and CTL-M until you see a “PLEASE LOG IN” message.
3. Enter “HEL-T001,HP2000,1”. Without the quotes, of course — and note that those are zeroes. Oh, and the system isn’t case-sensitive, but for the authentic experience you might want to have your caps lock on.
4. Enter “GET-OREGON” to load the 1975 version, “GET-ORE2” to load the 1978 version.
5. “LIST” the program if you like, or just “RUN” it.

Bob Brown has graciously made this system available for all of us interested in this corner of computer history. Poke around as you like — there’s a lot of other interesting programs on there in addition to The Oregon Trail. But do please be polite and respectful if you decide to rummage.

As for our subject today… damned if the thing isn’t kind of fun. More on that when I wrap all of this up very soon now.

Update, October 25, 2018: Mickey appears to be down for good. Sorry, folks, it was nice while it lasted. If anyone should put up a similar system, by all means, contact me.

Update, January 2, 2019: And now it’s up again. Get in there while you still can, folks.

My search for the original Oregon Trail code as first written at Carleton College having turned up nothing, I set out to find the earliest version I could. That turned out to be the one posted by one Deserthat in his blog. This version appeared in the May-June 1978 issue of Creative Computing. But before I get to that let me talk just a bit about the seven years that elapsed between the game’s creation and its appearance in Creative Computing.

Rawitsch, Heinemann, and Dillenberger were roommates enrolled in the student teaching program at Carleton College in 1971; Heinemann and Dillenberger taught math, Rawitsch taught history. It was Rawitsch who first conceived of and designed The Oregon Trail as a board game, and Heinemann and Dillenberger who suggested that it be computerized and then programmed it in Time-Shared BASIC. The first outside of this trio to play it were the students in Rawitsch’s history class, on a teletype machine which Rawitsch wheeled into his classroom on December 3, 1971. According to Rawitsch, they “loved it.” Rawitsch and many other teachers in the Minneapolis school district used it frequently for the remainder of the term. When Rawitsch left the district in 1972, however, he deleted The Oregon Trail from the system and took it with him as a long roll of printed paper which he ended up tossing into a drawer somewhere and forgetting about.

As it happens, Minnesota was something of a center of computer innovation in these days. In 1973 the state’s legislature founded an organization called The Minnesota Educational Computing Consortium (MECC), with a mandate to seek out and implement new applications for computers in education. A UNIVAC 1100 mainframe was installed at MECC’s Minneapolis headquarters, and some 1500 terminals were connected to it from schools throughout the state. In 1974, MECC hired Rawitsch to work as “a liason between MECC and a group of community colleges.”

Encouraged to think about new applications for computers in education, Rawitsch recalled that yellowing printout of The Oregon Trail. He punched it into a teletype connected to MECC’s UNIVAC over a “long Thanksgiving weekend” in 1974. The UNIVAC was a mainframe rather than a minicomputer like the HP-2100 — a very different proposition altogether. Luckily, it did have a version of BASIC available. [Actually, this is not quite correct. I learned after writing this that Rawitsch initially keyed the program into another HP-2100 system. See Part 4 of this series for more about that.] In addition to presumably being modified by Rawitsch or someone else at MECC to suit the UNIVAC’s implementation of BASIC, The Oregon Trail was also enhanced by Rawitsch himself to be more historically accurate, consistent, and entertaining. That version was played by thousands of schoolchildren all over the state during the next several years.

In 1977, MECC replaced its aging UNIVAC with a top-of-the-line CDC Cyber-73 system, and The Oregon Trail was modified once again to run on that system. This was the version that appeared in Creative Computing in 1978, and the version I back-ported to HP Time-Shared BASIC in order to experience The Oregon Trail in something close to its original form.

Now, as for Creative Computing… well, there’s one hell of an interesting story there as well.

Founded in 1974 by David Ahl, Creative Computing was the first mass-market magazine devoted to computers, predating even Byte by a full year. In keeping with its name, Creative Computing approached its subject not as an exercise in business and engineering, but as an artistic and cultural phenomenon. Its pages have plenty of technical advice and program listings, but also plenty of speculation on what the impending computer revolution really means. These “soft” articles are perhaps not surprising when one considers that many of the people who read the magazine could only dream of and speculate about access to a real computer of their own. There is much enthusiasm, but also some trepidation, most prominently in repeatedly expressed concerns about civil liberties in the new world to come. Both its idealism and its anti-authoritarian bent seem anchored in the by then fading counterculture of the late 1960s. I’m always reminded when I read it of the atmosphere around Berkeley’s Community Memory project, as described so well by Stephen Levy in Hackers.

Before founding Creative Computing Ahl was Education Marketing Manager for DEC. In keeping with this background and with its humanistic focus, Creative Computing was always very interested in the use of computers for education, devoting many pages to the subject in almost every issue. It’s thus not a big surprise that The Oregon Trail ended up there; if anything, the surprise is that it didn’t appear sooner.

By the time it did, MECC, which shows every sign of having been quite the visionary organization, was already getting involved with the new generation of “microcomputers,” as they were called in those days. MECC began installing Apple IIs into many Minnesota classrooms that year. And, yes, The Oregon Trail was ported yet again to run on them.

And so, with that history dispensed with, I’ll finally have a close look at the game itself next time around, which is after all where I’ve been trying to go with this shaggy-dog story all along.

I mentioned last time around that the original Oregon Trail was written on an HP-2100 series minicomputer. That’s a pretty interesting topic in itself.

HP’s first computer line, the 2100 series could be equipped with a number of possible operating systems. One of the most common, and the one under which The Oregon Trail was written, was called HP Time-Shared BASIC. This system was unique in its time, and perhaps even visionary. Rather than placing the user in the command-line driven environment typical of virtually all other OSs of the period, Time-Shared BASIC, true to its name, dropped the user after login into an interactive BASIC environment. Not only could she write programs here using BASIC, but all of her other immediate interactions with the system — loading and saving files, etc. — were also done using BASIC statements.

This was the design concept later used by many of the 8-bit generation of personal computers, as anyone who ever typed “LOAD ‘*’,8,1” to start a game on a Commodore 64 can attest. Following the norms of the time, even the original IBM PC dumped the user into a little used and seldom remembered BASIC environment if it didn’t find a DOS disk to boot at power-on. I’d been curious for years how we got from the command-line driven environments typical of most institutional computing to the interactive BASICs of these machines; now I think I have an idea.

Time-Shared BASIC represented a more welcoming environment for working and programming than was typical of the time, and this fact combined with the relatively low cost and easy maintainability of the HP-2100 line made these machines favorites of universities and even high schools. HP seems to have put considerable effort into designing and marketing the HP-2100 as a more user-friendly, accessible sort of machine. This manual is particularly interesting, being an introduction to BASIC programming pitched to the complete novice. It’s actually really well done, managing to walk the fine line of being friendly and accessible without falling into condescension. In light of all this, then, it’s not at all surprising that an HP-2100 would have found its way to Carleton College.

There were quite a lot of games and educational programs written in Time-Shared BASIC, and some of these have ended up on the Internet in the form of an unorganized dump to a huge tape image. So, I decided to try to bring up an emulated version of Time-Shared BASIC on my computer and to look through this mass to see if there might be a copy of the original The Oregon Trail in there somewhere. Well, it sounded like a good idea at the time, anyway…

You see, while there is an HP-2100 emulator available thanks to the amazing efforts of The Computer History Simulation Project, Time-Shared BASIC was a pretty complicated configuration. It was in fact TWO HP-2100s, one serving as a sort of gateway to users who connected via remote terminals and the other hosting the core of the OS itself. So, emulating the thing means running two separate HP-2100 emulators, loading the appropriate software onto each, and linking them together via sockets. Finally, one opens a THIRD window on one’s PC to telnet into the system via the loopback address. I never would have gotten anywhere close to a working setup if it hadn’t been for a Yahoo group dedicated to the platform, who host in their files section an emulator setup that almost worked right out of the box. I won’t bore you with the details of my struggles to get from almost to completely working; suffice to say that I finally got my own little Time-Shared BASIC system up and running.

And so I started going through the tape dump. This was almost 6MB of data, a large quantity indeed for a collection of BASIC programs often only a few kilobytes in length. Alas, though, no joy on The Oregon Trail.

But what I did find was pretty darn interesting, and more than justified the time it took to get to this point. Here were literally hundreds of BASIC programs: games, educational programs dealing with every subject, practical scientific and mathematical tools, etc. I even found what appears to be the original version of the old Star Trek game. There was obviously quite a thriving culture of program development and trading on this system from the late 1960s to the late 1970s. That’s perhaps not so remarkable in itself. What is, though, is that these programs were being written and used not by a priesthood of professionals as in the world of the IBM mainframe or a collection of focused hackers and researchers as in the world of the DEC PDP line, but rather by everyday students and educators. This gives their work a very different character. And if this sampling of their work is anything to go by, these people were very, very interested in games.

This mother lode deserves more attention, and I’m going to try to give it some and perhaps post a bit more about it in the future. (In particular, I want to see if I can find a version of the Hamurabi game Jason Dyer mentioned in a comment to the first post in this series.) But before I do that I’ll get back to The Oregon Trail proper next time around.