Ed Riddle

Game Credits


Racing Pak (1982)   (Indy 500 by)
Indy 500 (1977)   (Programmer)

Quality Assurance

Star Command (1988)   (Playtesters)

Developer Biography

Ed was mainly a hardware designer before joining Atari in 1977. The first thing he worked on there was a demonstration of 3D, a research project to test the viability of 3D video games. He did the whole thing in hardware since he didn't know how to program. He recounted, "I went to the Stanford University library and studied visual perception and came up with a demo. It used red and blue filter glasses. It was interesting, but it made your eyes feel funny so we dropped it."

Ed volunteered to do a game project for the new 2600, thinking that it would be fun way to learn programming. It says it was the first computer program he ever wrote. He wrote it on a teletype connected to a timeshare system. He says, "It was a bit tedious because compiles were done overnight. During the day, I had to write in machine language and manually load code into memory to test the program. It was like the dark ages of programming!"

One day the boss called him in and showed him a bill for $50,000.00" for compile time on his program. It turned out that he specified something wrong in a data field and, because of a bug in the compiler, it went into a loop and compiled all night. He recalls that they eventually had to pay it. Atari was gracious, though, and there were no ramifications, except, perhaps, a little embarrassment on Ed's part.

As for Indy 500, the basic structure of the program, was written by a coworker, Larry Wagner, which helped move the program forward at the beginning. By the time Ed finished the program, however, very little of Wagner's original code remained.

One big project was to develop the controller for the game. Ed did a lot of experiments with the basic paddle controller (that uses a potentiometer). The engineering team did some pretty deep analysis and finally concluded that you can't use a pot to control a car that goes around a track like the ones in the Indy game. Atari didn't want to make a separate controller, but there didn't seem to be any other choice. To solve the problem, they made a clever little digital encoding gadget, based on a small PC board, that would indicate the rate and direction of turning. Atari wanted to develop more games based on the new controller, but Ed left the company before he could start a new project, and nobody else picked up the ball.

Ed says he invented the Tag and Crash 'N Score game variations in about 15 minutes of musing about what to write. They seemed almost too obvious and he wished he could think of really clever games, but the system was limited to 2K of ROM, so he went with the very simplest games. On reflection, Ed says that they turned out much better than he expected.

Ice Race came later. One of the hardware engineers encouraged Ed to implement a skid factor, to make the games more interesting. He recounts that he went to bed with it on his mind, visualizing over and over how a car skids. In the morning, he had a flash on how it could be done. It was a lot of trouble to implement because he had to re-code almost all the motion logic, but it actually only added about 50 bytes to the program.

Wanna know how it works? (Skip this if you aren't interested in the technical details.) There are 16 car directions possible, like compass points. This is stored in a 4-bit number, the direction index. There is a picture of the car for each direction. (Some cars look like random garbage, but what can you do with an 8 x 8 sprite?)

When you turn the code wheel, it increments or decrements the direction index which is passed to the car picture and motion subroutines. Thus, when the index is 2, you select picture 2, which is a car pointing up and to the right, and you send a 2 to the motion subroutine, which selects from a trig table the ratio of how many pixels to move to the right and how many to move up the screen. To make the car go faster, you just multiply the pixel numbers from the table by the speed index.) That's it in a nutshell.

To make it skid, Ed separated the direction index into two indexes, one for the car's motion and one that selects the displayed picture. The displayed picture index is tightly coupled to the controller. Turn the controller and the car swivels. However, the motion index (the thing that says which way the car travels on the screen) was limited by a rate-of-change governor. It could only increment or decrement at a limited rate. When you turn the wheel fast, the car immediately points to its new heading, but the direction of travel has to shift step-by-step until it "catches up" with the new heading. This gives a great impression of a skid.

Ed set it up so that there were a number of variables he could specify for the behavior of the skid effect (at what speed it kicked in and how fast it resolved). These are set to different values for different games and for the different levels of play. For Ice Race, the skid is maximized to give the impression of driving on ice.

There is an interesting bug in the program. For crashes, Ed did a simple "jitter" to the direction index while making a crash sound. It looked pretty good for just a few bytes of code. Sometimes the index jittered the wrong way and the car would go completely around. Ed says he never found the bug, but decided to leave it in because it was fun to see.

After developing Indy 500, Ed hacked the Indy game into what he called "Roach Wars" in which cockroaches ran around on the kitchen floor shooting poop bombs at each other, but when the game was reviewed by management, they decided that maybe it would be too controversial, so it never was produced. Ed says it was much more fun to play than Indy, though. The engineers played it and loved it. Unfortunately, no copy remains of this program.

Ed left Atari after about one year to join a startup, so that was the last of his game career. Later, in 1980, he joined the original Macintosh development team at Apple as it was first starting. He designed the original Mac keyboard and its associated peripheral bus. Over the years he did a lot of designs for other companies, mostly industrial computers and peripherals, nothing as flashy as is work in the game and Apple markets.

In 1992 Ed retired from electronic design and did technical writing for about 10 years, and then retired at 59 from his technical career. He moved to Oregon to "follow his muse."

Ed played in a band for about 8 years. His band did blues, R&B, and Brazilian jazz. Currently, he is active in running and promoting meditation workshops called "Enlightenment Intensives" and teaches a form of deep meditation called "Dogzen." (See his website for details.)

Last updated: Nov 17, 2006