▶ Skip to the index of episodes.
About this Project
In 1961 Martin Graetz, Stephen Russell, and Wayne Wiitanen conceived Spacewar!, the first digtal realtime video game, as a showpiece application for MIT's new DEC PDP-1, proudly presented to a stunned public in May 1962 at the annual Sience Open House.
Ten years later, in 1971, Nolan Bushnell, presented the very first coin operated arcade video game, Computer Space.
(Note: Galaxy Game by Bill Pitts and Hugh Tuck, essentially Spacewar! running on a PDP-11, was second by just a month, but was available at the Tresidder student union building at Stanford University only.)
Computer Space was heavily influenced by Spacewar!, but Bushnell, who couldn't afford a pricy computer for a machine that was to return the investment by quarters (a cheap minicomputer, like the Data General Nova, was still about $4,000 for just the basic unit), rather teamed up with Ted Dabney (thus Syzygy Engineering) to construct his game in solid state logic (mainly 74xx-chips) and eventually partnered with Nutting Associates to produce the machines. So, Computer Space isn't a program, but a machine (if we want, a very specialized computer), and it is a simpler game than the original Spacewar!. On the other hand, it's entertaining as well, and, most importantly, it's a single-player game. (Spacewar! is for two human players only.)
By an ironic twist in history we'll try to bring Computer Space to the early-1960s machine that served as the platform for the original Spacewar! and started it all, the DEC PDP-1 (Digital Equipment Corporation Programmed Data Processor 1), which may be some fun. The PDP-1 provides one of the most straight-forward instruction sets, and should be fun to program. Still, in the absence of a processor stack and a realtime clock, there are some challenges to be met, especially for realtime programming.
Finally, we may ask, "Why, at all?" — Well, having investigated PDP-1 source code for some time, I'm eager to do some of my own, maybe a game. While the PDP-1 is quite a decent machine, its display is rather slow by modern standards — 50 microseconds to complete the display process for any of the dots on its 1024 × 1024 X/Y-display — and, since it's a point-plotting device without any memory, we'll have to refresh every dot/blip/pixel each frame. This is just good for two lines across the screen at a reasonable frame rate, but not for more, spending allmost all of the time in the display routine. Therefor our choice must be based on the graphics of the games, i.e., the number of dots to be displayed at any given time — a restriction, which leaves us just a few video games to chose from. Computer Space is one of them, and probably as much fun as implementations are rare.
For this project, we'll use
- PDP-1 assembler code;
- macro1.c, a modern C-version of the Macro 2-pass assembler for the PDP-1, based on the PAL assembler by Douglas Jones and Rich Coon;
- a web-based emulation of the PDP-1 and its Type 30 Visual CRT Display, importing a binary image of a paper tape via a JSON-type definition file;
- a text editor of choice, we'll use the proven swiss army knife of Mac software, BBEdit, (also used for writing this blog, which might qualify for a retro-challenge as well);
- some glue-logic in Perl to connect this Rube Goldberg machine of a tool chain and hook it to the editor;
- all sorts of documentation.
Experience the program live, running in an in-browser emulation of the DEC PDP-1 and its Type 30 CRT display:
Update: As of Nov. 2016, the emulation optionally adds sound effects of the original arcade machine, which are not available on the
Usage note: Chrome may not be able to keep up with the frame rate of the emulated program and may lag and skip frames. Please try Safari (on Mac) or Firefox.
Episode #1: Platform Considerations
We're entering the challenge late, however, before we begin to program, we'll have to consider any platform related issues in order to inform ourselves what we we're meaning to do.
Episode #2: Stars & Sync
Where we actually do some code for some shiny results. By the way, we learn some about the PDP-1 and how to write code for it. At the end of the episode, we actually run some virtual paper tape in our web-based emulator.
Episode #3: Rocketry
Or, Fly Me to the
Where we put a rocket onto the (emulated) screen. Involves figuring out the outline of the ship (not as easy as you would suppose), parsing inputs, processing rotations, and more. ▶ Read it …
Episode #4: “A Rocket Ship That You Control”
It's time to add controls to its, because, of course, this is one of the most compelling promises made by Computer Space. Also, some refinements…
Episode #5: Yet Another Progress Update
We're still tinkering with the movement algorithm of the rocketship in an epic endeavor towards esthetically pleasing paths and viable configurability.
Episode #6: Saucers!
We cellebrate the halftime of our humble project by putting some saucers on the screen, complete with animations and computer controlled movements. Also, yet another rocket outline.
Episode #7: Skeet in Space!
Eventually, we arrive at the first indications of an already playable game. While rather sort of a skeet shooting game or a duck hunt, we're sufficiently satisfied by our progress that we even skip a version number.
Episode #8: The Saucers Strike Back
Where we add enemy torpedoes and saucer A.I..
In the end, we've the basic game ready.
Also, a lame joke on version 0.3 and frames rendering on a computer.
Episode #9: Scores, Just in Time
Where we go figuring how to do figures. Eventually, we have a working score display, thanks to a JIT compiler for rendering character outlines. While we are, of course, geniuses, not everything is always as round as the tube of the Type 30 scope…
Episode #10: AI and the Problem of Missing Accurately
Where we ponder about time and space, regarding the aiming process of our saucers' AI. Also, appropriately for Halloween, the apparition of four ghosts …
Episode #11: It Lives!
Just in time for Halloween our Frankenmonster of gaming history is raising its head. We're finished and a bit «au bout de souffle» …
Episode #12: Wrap-Up
Where we wrap-up the project and see what may be learned from it. Also the final episode of this blog and the (successful) end of our humble project.
Addendum: All New Pyrotechnics
Where we return to implement an all new explosion effect. And this time, it will be our own. And it will be, of course, in true 1960s spirit.
Addendum II: Final Trim (Version 1.0)
Our mission: Final trim and polishing. Hence we return for another session of Computer Space footage so that we may mirror the original machine appropriately. Also, the final release of our code.
— finis —
… but there might be still more to come, think paper tape @CHM …
Update: +++ Paper tape punched +++ First run on real hardware Dec 12, 2016 (see below) +++
+++ Breaking news: Our humble project was actually picked as one of the winners! :-) +++
Thanks for dropping by, congrats to all winners and mentions, and cheers to all co-participants in Retrochallenge 2016/10!Norbert Landsteiner
October 2016, Vienna, Austria
www.masswerk.at – contact me.
— This series is part of Retrochallenge 2016/10. —