Classic Basic Games Page

For a budding computer hobbyist, it was the thing to have after you got your first computer. It had a keyboard, a printer that served for all output, and even a means of input and storage, a paper tape reader.

If you got one, for the steep price of about $1000, and then put it together, not a small feat, what you got was a big blue box with lights on the front. If you did your homework correctly, those lights did the right things, and after carefully reading the manual, and inputting several byte instructions, painstakingly flipping each bit of the byte, 8 bits, then hitting enter for each byte, you could actually get the machine to do something sensible with the lights on the front.

The beast was commanded to count on the lights. In binary of course. Next, a lit bit was walked across each of the front panel lights in turn, marquee style. Finally, the game "shoot the duck" was entered, which rotated a light across the row of lights. The object was to hit the switch under it at just the right time, and turn the light off. Miss and you just created another light. Get all the lights out, and, well, you ran out of interesting things to do rapidly.

Now, with an ASR-33 clanking away next to the blue box, and that Basic tape, probably borrowed from a friend, you were ready to sign on.

The teletype stops.

The end of the tape falls on the floor.

The machine hammers out a sign-on. Microsoft Basic 1.2. Ready. Ready ! The machine talks ! Those who were there know. It was time for a beer, to show the wife, to cheer. That goddam box spoke to me in english. Now I understand.....

Many programs were passed back and forth then, typed in from magazines, punched in from paper tape, read in from cassette tapes, or from a new, odd device called a "floppy disk". Passed from hand to hand, copied without a care, even from the writers of the programs themselves.

And most of them were games.

Original Basic programs from this time are hard to find now, even on the Internet. The media on which they were kept was either lost, destroyed, or more likely, simply belonged to an obsolete computer or media type that was thrown out at the end of its life. The magazines that published them are gone, interest in them has waned.
Perhaps most destructive of all, when advanced graphics began to become common on computers such as the Apple, a lot of them were "converted" to run specifically on those computers. This made the game more interesting by adding graphics, but was the death warrant to the source, as when that computer died, so did the specially modified source for it.

Many of the games were reinvented over and over. Lunar lander had several versions, later becoming a full graphical game. Artillery was also a popular graphics game. Many early programs were inspiration for later, more complex games. The gaming empire that became Quake started as a humble Apple computer game named "Castle Wolfenstein". And of course, the ultimate irony is that the Microsoft Basic that ran many of these games started an empire of unimaginable wealth.

The collections

Some of these are fairly similar or completely different versions of programs that also exist in the Creative Computing collection. They are here because they have significantly added features or are written in a substantially different way.

Some of the programs here are from the "More Basic Computer Games" book from Creative Computing, and will stay here until (if) we create a collection of those games.

Now since these are way out of print, this might not have helped me a couple years back. However, we live in Internet time, and the internet has enabled me to find books that I would never have been able to find formerly. Within days I had a copy of it.

The intent was to scan it in and OCR it (convert it automatically to computer readable text). Unfortunately, the programs in the book had been reproduced from listings made on a cheap dot matrix printer, and attempts to OCR it yielded nothing but garbage. Once again, you guys came to the rescue, and Ed mailed me a copy of a .zip library that proported to be the complete contents of the first book. In this collection I found most every file accounted for. I also found that the games have been modified from the original book form. Some of the modifications were useful, such as printing out instructions for how to play the game, that only appeared in the original book. Some were not so useful, such as printing control characters here and there.

Acting as a computer historian, I "unmodified" the games to create the original games as they appeared in the book. To be fair about it, you now have your choice of flavors. The original book form, or the modified form.

The Creative computing library serves several important goals for the purposes of the Classic Basic Games page. First, I can verify that these games were original from 1978, the time the collection was published. Second, the original author, David H. Ahl, did research back then as to "who wrote what" program, research that would be hard to reproduce today. Thus, hopefully, the programs are titled with the proper authors.

Readers will note that the "More Basic Computer Games", the sequel to the collection, does not appear here. I have the book, but I have not found more than a very few of the programs in computer source form. I am still looking.

The Creative Computing collection was received from helpful people on the net, and those sources restored to original condition as referenced to the original book. Because the collection was restored from modified sources, it is still possible to find errors or differences from the original program. These are being corrected as I find them.

I have tried to stay as close to the original, as determined by the book, as possible. In some cases, this results in errors that were in the original program being left in. Occasionally, it was necessary to fix errors in the source because the programs would not even load, such as missing quotes, which my Basic will not allow. Some of these might have been printing errors, some may have been original program errors.

Changes made to library from book form

There were a small number of changes made to the programs in order to make them runnable. These were as follows:

1. Sine Wave

The statement:

40 REMARKABLE ....

Uses a trick that worked with many Basic interpreters that recognize keywords wherever they appear, even in the middle of other words. In more advanced basics, this is not possible, because if variables like:

MYSTRING$

Are allowed, you would go crazy trying to chase down imbedded keywords. See also the comments on IP Basic below.

2. Spacing.

As in example (1), it is not possible to have the statement:

10IFC$="BARK"THENGOTO20

The keywords must not be run together with other keywords and variable names:

10 IF C$="BARK" THEN GOTO 20

3. Special characters.

Occasionally, a special character (control character) appears in the programs. This was REMed out. Special characters in ASCII are characters less than 32 in value (space).

4. "RUN" statement.

The "RUN" statement in 3d Tic Tac Toe was changed to STOP.

5. "LPRINT" statement.

The "LPRINT" statement in 3d Tic Tac Toe was changed to "PRINT".

6. "END" in program middle.

In the program "weekday", the statement:

1240 END

Appears in the middle of the program. The original Basic meaning of "END" is to stop reading/compiling the program, so this is a misused statement. Was replaced by:

1240 STOP

7. Space in tolken.

In the program "23 matches":

410 IF N < = 1 THEN 470

The space between the "<" and "=" does not allow this to be a valid less than or equal. Space removed.

8. Function use before define.

In the program "hexapawn", the function fns appears before its definition, which causes a problem with Qbasic. The lines 20 and 25 were swapped.

9. Bad REM statement.

In the program "hexapawn", line 511 uses an unterminated REM statement. Space added.

Special problems

The following special notes apply to the collection, these are known bugs and limitations. Remember that these programs were written by anyone from longtime programmers to high school students, so some problems are to be expected !

1. "hexapawn" does not run on Qbasic. Hexapawn has an interesting board output routine that executes tab(10) (line 1030) multiple times. Apparently, on the original MS Basic (and other basics) tabbing to a position that is behind or at the current position is a no-op. Qbasic actually throws another line and tabs to the position. Why that is a good idea is beyond me. Easily fixed.

2. "hilo" makes the unwarranted assumption in line 180 that 100*rnd(1) will be a number from 1 to 100. Actually, the number will be between 0 and 99, since exact 0 and exact 1 will never be the result of rnd, and the fraction is removed. You can fix it with:

180 Y=INT(100*RND(1)+1)

3. In "horserace", there is a really bazzare bit of code in lines 570 to 780 where the value of N is used after a for n=..next loop, and apparently it expects the value to be 8. In both IP Basic and Qbasic it isn't, but is instead 9, and this results in acess to the uninitalized variable d(i) and a zero divide. Fix this by adding the line:

721 n = 8

4. In "mastermind", line 8010, the quotes are left off string data. This causes IP Basic to choke, as probally others. Qbasic likes it. I considered it, but its a lot of work just to kludge up the language so lazy programmers can leave quotes off. The solution is to put the quotes back.

5. In "salvo", line 1270, DEF FNA is executed twice, because the code loops back to that point. Both IP Basic and Qbasic were unanimous that this was not a nice trick, although the original Microsoft Basic probally tolerated it. The solution is to move the defines upwards toward the top.

6. In "salvo", the program runs out of its data list after a few games. It needs a restore at the start of each run. Left as an excersize for you.

A final parting note. If you have the original book, there is a small inside joke on page 88, the hockey game, where it lists the different teams playing as the big computer manufacturers verses the home computer makers of that day.

The real joke is that all of them besides IBM are now long gone, closed or aquired by other companies! Microsoft was around, but perhaps the author did not think of them as much in the way of competition :~)

The "menu" program

I have created a new program, "menu", to replace the "menu" program in the modified sources given me for Creative Computing. A menu program lets you pick out a program to run from a list of programs. This can be an important addition to a system that beginners will use, because they don't want to learn to execute arcane shell commands to get these programs running.

The original menu program used the "run" command to transfer control to and from the program. Thats an ok technique, except that it requires each program to be modified so that it will execute another "run" command to get back to the menu program. Instead, I wrote a completely different version that uses the "exec" command in IP Basic:

exec "file"

In IP basic works just like a "run" command with file parameter, except that when the target program terminates, it will return back to the original program. The advantage here is that there is no special modification required to the programs that run under menu. The system is completely compilable as well, because a shell command of the form "basic file" is generated at runtime.

The program is written in minimal Basic, and should run in all respects if you find your local equivalent to the "exec" command. And yes, I do realize that many Basics don't have that command. For those, you would have to return to the original "run" modified programs.

Submissions

All submissions should be sent to:
 

Thank you.

What is a classic basic program ?

• Dates from the first days of the microprocessor. This is pretty flexible, since most Classic Basic programs actually were created in the 1960s and early 1970s on minicomputers. However, a program that dates from the 1980s is very likely extremely dependent on one particular computer (i.e., the PC) and would be impossible to "back convert" to its Classic Basic origins, if it ever had any. Brand new program submissions are actually encouraged provided they obey the rules of Classic Basic as defined here, and are marked as such.
• Contains no special graphical, sound or other computer specific instructions. I can tolerate a small amount of adulteration by repairing the damage to get back the original program. But a program that has been extensively doctored is not useable. Actually, most of the programs I use must be repaired in some fashion.
• Contains no special character outputs. Most of these can be found by the chr$() function appearing in the source, which means that a special character is being created from a number. These were used for various proprietary console controls. Fixable if there are not too many. Note that char$(7) was almost universal for "ring bell", and works even on a teletype.
• Contains mainstream basic commands. Actually, very odd basic commands were common to find early on, because the minicomputer Basics used them. Later, the more advanced Basics such as Basic on the PC began to use them.

Basic used

The most widespread Basic from the first days of the Microcomputer is Microsoft Basic, all of the games here are compatible with that. However, none of the odd statements of Microsoft Basic are used, nor its quirks relied on (such as the fact that true = -1).

The Basic I use to run the programs is IP Basic, which stands for "Intellectual Property Basic". I wrote it, and it is a full feature Basic that is compatible with the original Microcomputer Basics, runs under windows and is fully graphical. Its compatible with the Creative Computing collection by definition. That collection was used to test it, and where non-compatibilities were found, they were corrected. In many cases this caused IP Basic to inherit a few quirks of Microsoft Basic, but that is to be expected.

The one exception to this is the behavior of the dim statement for strings. In IP Basic, the rightmost number in the dim is the size of the string, in characters. This causes the program above "hangman" not to run, but only a simple change is required. I have left the program in the Microsoft form, as it was originally.

IP Basic is a compiler oriented Basic, that is, it is meant both to be compiled as interpreted. It may use line numbers, but does not need them, and can use symbolic labels instead, or any mix thereof. IP Basic also implements arbitrary symbol names such as "MYVAR$". As such (like most other similar Basics), it cannot use sources where the keywords and symbols are run together like:

10FORC=1TO10:NEXTC

Nor can it use calculated gotos (thankfully rare) such as:

10 GOTO 100+(A*10)

It is also possible to have "convoluted" programs that cannot be compiled because they cannot be parsed sequentially:

10 FOR I = 1 TO 10
20 IF I < 10 THEN 40
30 RETURN
40 NEXT I

If you want to use a Microsoft compatible Basic to run these programs, I recommend Qbasic, which is the last Microsoft product to be compatible with original Microsoft Microcomputer Basic. Visual Basic is not compatible with the programs here, and VB completely changed the I/O paradymes. "print" and "input" no longer function there.

Other Basics that implement the standard Basic commands are likely to work. They need not be Microsoft compatible, because, as said above, the programs don't get very adventurous in their use of Microsoft Basic. The following is a list of oddities I have seen, that you may have to fix in your programs:

Example:

"Z" appears right after the string without the customary ";" or ",". This works because (and only because) expressions are complete syntactic units. In lay speak, that means the interpreter/compiler knows when one expression is done, and the other one begins. You might need to change this to:

PRINT "THE NUMBER IS";Z

Example:

"ONE", "TWO" and "THREE" are strings, and you are allowed to leave the quotes off. You might need to change this to:

DATA "ONE", "TWO", "THREE"

Example:

Would print:

MY NUMBER 5 IS BIGGER THAN YOURS

Notice that no spaces are provided before or after A, but the Basic inserts them. If your Basic does not automatically insert spaces before and after numbers, you might need to change it to something like:

PRINT "MY NUMBER ";A;" IS BIGGER THAN YOURS"

Tiny basic rules

In case you were curious about the Basic language processed by the Tiny Basic above (basic-s), this is a short description. Tiny basic is a stripped down version of Basic, somewhat, but only somewhat, like the early Tiny Basics that appeared on the first home computers. It processes integers only, no floats or strings. As such, this is not a Basic that can run most, or even any, of the Classic Basic programs, and, especially, cannot run itself.

Tiny Basic started out as a way to get a Basic running in the minimum amount of ram, because ram used to be very expensive. After that no longer had much point (although it is still useful in embedded processors), it became sort of an interesting game to see if you could implement a Tiny Basic in any given language you were handed. I personally have done one in Basic itself, Pascal, and C. Although it sounds like a personal oddity of mine, I know that others enjoy the game, because I see Tiny Basics showing up in Java, on Palm computers and other interesting places.

Of course, everyone is going to disagree on what language Tiny Basic should have, by the sheer definition of the task. However, the name of the game in Tiny Basic is to implement the minimum statement set that is possible to get any useful program running, so the statements picked usually are similar. All my Tiny Basic dialects are similar, and all based originally (loosely) on the 8080 Tiny Basic written by Li Chen Wang and appearing in Doctor Dobbs in the 1970's, a program I had great fun modifying.

Statements

if <cond>
input <var>
print <var>/<string>
goto <line>
rem <any>
stop
list
new
bye
run
let <var> = <expr>
<var> = <expr>

The variables allowed in Tiny basic are represented by the letters "a"-"z", each representing an integer (no floats or strings). Expressions consist of the four calculator operations "+", "-", "*" and "/", with "/" and "*" having the highest priority. ( and ) may be used to group expressions.

Any number of statements can appear on a line, separated by ":".

If a line is entered without a number in front, it is executed immediately. If a nonzero number appears at the start of the line, then the line is placed into program storage in the order of that line number. If there is already a line by that number, it is replaced by the new line. If the line entered has nothing after the number (line number is alone on the line), then the indicated line will be deleted. The stored program is listed with "list", and the "run" statement causes all variables to be reset to 0 and the first line of the program is executed.

A print statement consists of any number of expressions, or strings separated by "," or ";". Although strings cannot be stored in variables, a string, consisting of any number of characters appearing between quote marks, can be printed.

Want to play with Tiny Basic ? Here are some excersizes for you:

1. How much more work would it be to add string variables to Tiny Basic ?

2. Tiny Basic can be written in other Basics (called "nesting" the language). Most languages can do this. Is it possible to write a Tiny language, then write a more complex language processor in that for a "non-tiny" language (its called bootstrapping) ?

3. Is it possible to design a minimum language that would nest to any level ? What would be the minimum feature set required to nest to N levels ? What would be the advantage of having such a Tiny Basic ?

4. Is writing Basic in Basic just a way to slow down computers, or does it have a purpose ?

A word to the wise: writing Basic games

Basic games are often written by computer beginners, young people, or both. I started programming with writing a few games, but found myself rapidly caught up in more complex programs that performed useful work.

Games are a excellent introduction to programming, and in this simple text oriented form, you may find that you learn more about programming than attempting frustrating graphics before you have learned the basics.

Here are some suggestions that might help.

• Start simple. Write a simple game and improve it. If you try to make a single part too complex, the entire program will be difficult and frustrating because you won't see it actually doing anything until the end.
• Patience with the user. Beginning programmers often put wisecracks in programs, chide users for mistakes, quit the program for "impossible" users, etc. Think about it. This is an attempt to make the program seem more human, right ? Does it make a good game if the worst attributes of people are put into the program ? Instead, how about a program that shows off the best characteristics of the computer, its infinite patience and neutrality. This is especially important for children as users.
• Imagination beats graphics. Think its impossible to have 2 and 3 dimensional games without graphics ? There are plenty of shallow graphics games. The first chess programs simply output chess notation (QKXKB7). The Apollo LEM module computer worked  with numerical displays only, even though it had full 3d understanding of its environment, and communicated that to the pilots.
• Be a stupid user. When its time to finish your game, pretend you are stupid. Enter answers with extra blanks before and after the number. Enter nothing, just hit return. Enter obviously wrong and outrageously large or negative values. The mark of a real programmer is to make programs that are not "fragile".
• Comment your programs. Put the instructions for the game into the program. Put REM statements telling how the program works, show off your knowledge. Ideally, the program should be interesting enough that a printout would make good bedtime reading. Put the program away, and come back and read it a month or more later (or show it to a friend). Is it understandable, or does it just look like arcane scribbling ? If you were run over by a bus, would someone want that program, or would they throw it away ?
• Work on someone else's' programs. Make it bigger and better. Does that program you got look odd ? Study it ! Its doing things you might want to know about. If someone gave you a pile of bricks, that would not help you understand how to build a building. But taking a building apart back to a pile of bricks just might.

How this page got started

How did I get started collecting these programs ? Well......

I write programming language interpreters and compilers for fun. The first language processors I wrote, a compiler and an interpreter, were written for Basic, back when most of my code was written in assembly language. Because of the simplicity of Basic, it is usually possible to write a "tiny Basic", a stripped down version of Basic, in a day or so. Writing such a Basic in various languages has been a pastime for me, and is an important benchmark of a new language for me (perhaps the subject of another web page).

Because the machines that ran my earlier Basics became obsolete, I decided that I wished to have a Basic implementation written in my chosen high level language, Pascal, and slowly grew a Basic implementation in my spare time from a tiny basic in the 1980s to the very not-so-tiny IP Basic today.

I needed some test material to verify that it worked correctly. Well, Basics vary a lot, especially in the details of graphics and sound, so what I needed were some very simple programs that did not do any advanced I/O. It occurred to me that the old basic programs I used to play with when I first started using a computer 20 odd years ago were perfect for that purpose, and so I set out to find some.

After having a great difficulty finding more than a sparse few, it occurred to me that finding these programs would be a lot easier if I placed the results of my search up for general viewing and download, sort of a "stone soup" idea that would get programs to come to me. In typical Internet fashion, this has worked pretty well.

You guys helped me build this collection, and all I ask is that you enjoy it.

The "real" Sam the computer man

So did I in fact start programming in the garage with an 8800 and a teletype ? Weeeellllllll........

The famous article in Popular Electronics about the Mits 8800 appeared just before I graduated high school in Los Angeles. I read it backwards and forwards, it did not have a lot of information. I later realized that some of the information was wrong, and still later it came out that the computer in the article was a fake, a mockup, even though the 8800 was later a real product.

The truth is that in 1975, getting into computers was a several thousand dollar proposition, and I simply could not afford it. Instead, I learned the basics (pun intended) of computers at the disk drive maker Micropolis. I liked it so much, and still could not afford a "real" computer, that I did what a few hardy (or perhaps insane) people did, and cobbled up an S-100 system from a combination of kits, my own designed boards, scrounged parts and jury rigs. In fact, until 1987, I never owned a computer that was not a collection of parts that I designed or made, including the operating system.

Later, I did in fact get an 8800 and an ASR-33 teletype, in the early 1980's. By then they were being sold cheap. I finally had the system everyone started the whole thing with. The ASR-33 was a little to big to keep around, but I still have the 8800. I hear they are valuable now, but to me, having one sitting up there on the shelf is priceless.

In 1987 I got tired of being incompatible with everyone else, and put together a PC, yes, again from parts. In fact, aside from the two notebook computers I own, I have never purchased a preassembled computer, because all I do is upgrade parts of my existing ones. I have three computers in various parts of the house used by various members of the family, making five in total, with an 8 address TCP/IP lan running the whole show.