How I Spent My Summer of 1982
Life is strange.
In the summer of 1982, I spent about three months creating a list of 4,096 numbers, meticulously ensuring that every single number was the right value, and in the correct place in the list. When I finished, the only tangible evidence of my work was that long list of numbers.
When the list was complete, after nearly 1,000 hours of work, the former Connecticut Leather Company¹ put the numbers (in order) into a computer memory chip and plastic case and sold it at stores throughout the country. And people actually bought it.
The list of numbers that I created was known to the public as the Atari 2600 version of the hit coin-op video game Donkey Kong. To create the list, I wrote a computer program in 6502 assembly language in about 3 months, with little sleep. With enormous pressure to submit final code in time for holiday sales, I finished the game with a push of 72 straight hours at my desk, after which I was told that I looked like a zombie.
This is the story of how that list was created.
For background, Nintendo’s Donkey Kong (the arcade game) was a breakthrough in video game design, and one of the most successful coin-operated games of the early 1980's. To be clear, I did not invent Donkey Kong. The game was designed by the legendary Shigeru Miyamoto, who has gone on to be possibly the most successful video game designer in history. It was the first video game to feature Mario, who went on to fame and fortune in the Super Mario Bros series of games (though in Donkey Kong he was referred to only as Jumpman). Donkey Kong was one of the first video games to use cartoon-quality animation and storytelling to draw the player into the action. My role was limited to creating an Atari 2600 version of Miyamoto’s masterpiece.
Donkey Kong takes place in a construction site.¹ Pauline, the damsel in distress, and Mario’s girlfriend, has been abducted by a stubborn² ape. As Mario, the intrepid hero, your job is to save the princess from the impertinent primate. The arcade game is shown below.
In the first stage of the game, the object is to run and climb up the girders of the under-construction building to reach Pauline (note said damsel-in-distress at the top of the screen, yelling “help!”). The player controls Mario with a joystick and button. The joystick moves Mario up, down, left and right, while the button allows him to jump. To stop Mario from reaching Pauline, the ape launches a steady stream of barrels down the slanted girders to impede his progress up the building.
If Mario successfully avoids the barrels and reaches the top of the building, he sweeps up Pauline, and climbs off the top of the screen to Stage 2. The arcade game has four Stages (levels) in all, featuring similar escapades and gameplay challenges in different areas of the construction site.
In 1982, Donkey Kong was one of the biggest things in the arcade, sucking down quarters at a record pace. Even if you didn’t play video games, you likely had heard about Donkey Kong.
At the same time, the home video game market was in the midst of a growth spurt. In the early 1970’s, your standard home video game gadget connected to the TV and played one or more PONG-like ball and paddle games.
Every game selection was pretty much the same, but they had clever names like tennis, ping pong, and hockey, to make you think you were playing something besides PONG. When you got bored with ball and paddle games, the system went in the closet (or the garbage).
In 1977, the Atari Video Computer System (the VCS, or 2600), was launched. The 2600 made inroads into the home video game market for its first couple of years despite a much higher price than its predecessors, thanks in part to its removable game cartridges. Being able to buy additional games in cartridge form greatly extended the life of the machine, allowing the family to try something new when they got bored of the games they had played to death.
However, the event that propelled the Atari 2600 into the stratosphere was the release of the Space Invaders cartridge in 1980. Space Invaders, a huge arcade hit designed by Tomohiro Nishikado of the Japanese game company Taito, was the first significant license of an arcade megahit to the home video game market. When it arrived on the Atari, not only did the cartridge sell like crazy, but the Atari 2600 machine quadrupled in sales overnight as the crowd of enthusiasts needed the game console to play the cartridge.
The industry had learned a valuable lesson. Licensing a hit arcade game and bringing it to a home console had the potential to be pure gold.
Now back to my part of the story. In the mid 1970’s, as a college student in New Jersey, I was very fortunate to get a part-time job at a four-person electronics company, in the business of designing and engineering gadgets such as calculators, digital clocks, and eventually electronic toys. As low man on the totem pole, my initial responsibilities included getting lunch for the engineers.
Over time, in a company with brilliant people, but limited resources and a habit of over-promising, I was fast-tracked into learning on the job, mainly by being thrown into the fire time and time again. While it wasn’t easy, it was incredibly rewarding, and was instrumental in defining the future path of my career.
By 1979/1980, even though I had still not completed my college degree, I was a full-fledged, self-taught engineer. By that time, the company I had joined as the fourth employee had grown in size, and focused most of its efforts on handheld electronic toys (a story for another post). I loved working on electronic toys, but I was also fascinated by the market successes of the Atari video game system. With support from management, I bought an Atari machine, ripped it open, and figured out how it worked, a process called reverse-engineering. Soon after, I designed and programmed my first Atari 2600 game (in fact, my first video game), Space Jockey, which released in 1982.
After that, I decided to move on from that first job in engineering. My career was flourishing, and it was time to find something more rewarding for me.
In May of 1982, now independent and self-employed, I was offered a contract to develop an Atari 2600-compatible version of Donkey Kong. Coleco (the aforementioned Connecticut Leather Company), after seeing the commercial success of the home version of Space Invaders on the Atari, went to Nintendo and acquired exclusive home rights to the biggest arcade game in the world at the time. While the Donkey Kong deal was primarily focused on Coleco’s soon-to-be launched Colecovision game console, a competitor system to the Atari 2600, it would have been crazy for Coleco not to market a version for the Atari system, with the largest audience of players in the home market.
Fortunately for me, there were very few independent engineers who had the knowhow necessary to write an Atari game. There were the Atari employees (who were plenty busy, and not available), the game designers at Activision (an Atari spinoff, also fully occupied and not available), and not too many others. As for me, I was recently unemployed, and willing and able, so I took the project.
It would not be an easy undertaking, as I explain below. I was very familiar with the arcade game and its groundbreaking graphics, animation and gameplay. The task at hand was to create a commercially-viable version of a $3,000 coin-op game which would run on a $30 Atari cartridge.
The challenges were many, including:
- I had about 3 months to write it. I could have used a year.
- I had 4,096 bytes of memory in which to store all of the code, graphics and sound effects. In addition, I had 128 bytes of RAM memory to keep track of everything (NOTE: not kilobytes, bytes). The game would be programmed to run on a 1 MHZ, 8-bit microprocessor. Those numbers are almost guaranteed to bring knowledgeable programmers to their knees.
- In addition to the above constraints, the game console I was programming on, the Atari 2600, was severely (I mean SEVERELY) limited from a technical standpoint (which is an entirely separate discussion), especially when compared to a $3,000 arcade machine. The Atari 2600 system was originally designed to play 2 games — PONG and COMBAT. Consequently, the graphic capabilities of the 2600 were limited to displaying two (2) sprites (animating, moving characters), plus one (1) ball and two (2) missiles. The ball and missiles were simple square/rectangle projectile objects while the two sprites were 8-bits wide, with the ability to display rudimentary animation frames.
PONG had a left paddle, right paddle, and a ball. COMBAT had Player 1’s tank, Player 2’s tank, and two missiles, one for each player. Atari’s assumption in designing the Atari 2600 was that all future games would have two moving sprites and up to three projectile objects. This was in contrast to the Donkey Kong arcade machine, which was capable of displaying “128 foreground sprites at 16x16 pixels each.”
In addition to the limitation on the number of objects on the screen, due to memory constraints, the Atari 2600 was limited to displaying unique background graphics for only 1/2 of the screen. In other words, the right side of the screen could only display a copy or a reflection of the left side of the screen. Since the iconic slanted ramps of Donkey Kong are non-symmetrical in nature (not a copy or reflection when comparing left to right), I had to come up with a way to “work around” the hardware to achieve the slanted ramps.
To write the game, I composed a computer program in a language called 6502 assembly language. The written program was processed by a computer-based tool called an assembler, which ran on my Apple II personal computer. The output of the assembler was a list of 4,096 numbers, with each number having a value of between 0 and 255 (owing to the mystery of the binary number system, which I may explain at some point in a future post).
In addition to writing the program, I also had to create the computer graphics which would be displayed on the screen of the television. At the time, there were no tools to create such graphics, so I colored in squares on a piece of graph paper to create the background, each of the characters, such as Mario, and other items, such as the hammer, and the individual digits which displayed the score. The image on the left shows Mario in his standing position, comprised of 8 pixels (i.e. pixel=picture element) on each line, and 18 lines of graphics. The image on the right is a closer view of Mario’s head, showing how each pixel is filled in in color on graphic paper of 8 cells wide. As the Atari system was limited to one color per line (per character), notice that Mario is made up of 18 single color lines.
Once the graphics were drawn on graph paper, I had to convert them into numbers (yes, we’re back to that list of 4,096 numbers), with each line of Mario’s graphic taking up one number for the pattern of dots, and a second number for the color. So Mario’s standing image, as shown above, took up about 36 (18 x 2) of my available 4,096 bytes of data.
While I did most of my work on the Apple II, at some point, I had to get the 4,096 bytes into the Atari machine to see if the program I was writing did what I had designed it to do (which programs rarely do). When writing a game program, you will write code for an hour or so, assemble what you’ve written, and then try the program out to see if it works. One way to do that would be to take the list of numbers, referred to as the binary, and put it into a computer chip in a cartridge, to plug into the Atari. That method, unfortunately, takes a lot of time, and is not something you’d want to do 20 times a day.
Consequently, I designed a custom electronic board that connected the Atari system directly to the Apple II computer. Once the assembly of the program was complete, the board allowed the Atari to instantly run the program (as if a cartridge was plugged into the game console). My custom Atari interface board is shown below.
When I had the game in pretty good shape (from a play standpoint), I was about 1,200 bytes over my allotment of 4,096. At that point, I had no choice but to begin the process of code optimization, or as we used to call it, cutting bytes. To cut bytes, I had to look at the program, routine by routine, and figure out how to accomplish the same task in less code (without breaking the functionality). It sounds gruesome, but it was actually one of my favorite things to do.
Finally, I had a finished version of the game.
The image below shows the first Stage screen of the Atari 2600 version of Donkey Kong. Referring to the image, I had to create graphics and write computer code to generate the non-symmetrical slanted ramps (in purple), 4 rolling barrels (only one shown here), Mario, Donkey Kong, Pauline, the hammer, a “lives” display (the block in the upper right corner), and six (in total) digits of score. All of the objects I have listed above count against the Atari machine’s limit of “two (2) sprites plus one (1) ball and two (2) missiles.” Complex, intricately-timed assembly language code was used to trick the hardware into displaying many unique copies of the limited objects available (certainly a discussion for another time).
While I feel that I did the best job possible on an almost impossible task, the port was not perfect. Due to memory constraints, I could only include two of the four arcade game Stages (as mentioned above, there were four distinct gameplay screens in the original coin-op machine). I’ve gotten a lot of grief over the years about that decision but it was technically impossible to add anything else to the cartridge, unless the publisher, Coleco, agreed to go to a larger cartridge memory, which would have given me 8,192 bytes to work with. Given the added cost of manufacturing, they declined. With that reality, I focused on making the most playable and graphically-pleasing version of the game that could be done given the numerous constraints.
The Donkey Kong 2600 game cartridge was a huge commercial success for Coleco. I read an analyst report years ago that stated that, while the Atari 2600 version of Donkey Kong was one of 550 products that Coleco put out that year, it represented 25% of their total revenue. A conservative estimate of the retail revenue of the game in 1982 alone was $100 million dollars, equivalent to about $269 million dollars in 2020, or about $65,670 per each number in that list of 4,096 numbers.
I’m thankful that I was in the right place at the right time to work on such an iconic game. It was certainly a back-breaking effort, but I wouldn’t have traded the experience for anything.
Hope you enjoyed the story.
1: The Connecticut Leather Company? Before going on to fame and fortune with Cabbage Patch Dolls, and video games, Coleco was known as the Connecticut Leather Company.
1: Why a construction site, you ask? Great question. The answer is simply that it worked for gameplay. You see many strange things in video games for that reason, with the standard game designer retort of “it’s a video game, I don’t need a reason.” Ever ask yourself why in Angry Birds you are using a slingshot to fling birds at structures built by pigs? Same answer.
2: Stubborn Ape The game’s designer, Shigeru Miyamoto, initially referred to the ape as the stubborn ape. When translated from Japanese to English, the word stubborn was translated as “donkey,” for obvious reasons. Thus the unique name “Donkey Kong.”