Pong Returns : Postmortem For The Atari Pong Indie Developer Challenge

Atari announced the finalists for their Pong Developer Challenge on June 26th, and we were not included on this.   Thus, our time as part of the Atari Pong Indie Developer Challenge comes to a close.   In this post-mortem we look back at what we think we did wrong, what we think we did right, and how we move on…


When Atari announced the Pong Developer Challenge a few months ago, I was initially excited.  Atari contacted us to promote the contest, and we gladly did so, as always.    However, when I read the news I had a feeling that I wanted to take part myself.    I talked it over with the other guys at Producto, and they were mildly interested.

However, the next day, when Gamasutra ran a negative story about the terms of the contest (“Why Atari’s Pong Indie Developer Challenge is bad for developers” by Brian Robbins), visions of the Flash game portal days of yore came flooding back.   Flash game contests were, may times,  notoriously lopsided in favor of the portal putting on the contest.  Most of the time they gave the portals a lot of free content, and the developers lost the tight to their own work.

However, I saw this Atari contest as something different.  Atari would own all the submissions but they would essentially be Pong, so they owned the rights anyway.    It seemed that no matter what I came up with, there was no way I could use it myself, so why not submit it to Atari and see what happened?

The Name

The name of the submission came to me almost as soon as I heard about the contest.  “Pong Returns” had an obvious double meaning.  “Pong” was coming back as game, and in the game itself your job is to “return” balls coming from the right side of the screen.

Design Doc submission

When the dead line for the contest was approaching on April 15th, I only had a very slight idea about what our Pong game would be,  I wanted to create a game that paid homage to all the Atari coin-op that came between Pong and Asteroids in the 1970’s.  I wanted the game to  for a single player, and I wanted it to look as retro as possible, but with a retro-evolved bent.  My modern gaming touch points were bit.trip.beat and Furu Furu Park.  I spent the entire weekend before Aprial 15th pouring all of my Pong aspirations into a 26 page design document.    Here is how I described the game in the introduction.

Tag Line: A mashed-up, fast paced, hypnotic journey through the history of Atari’s earliest coin-Ops

Introduction:  As life-long Atari fans, one thing that frustrates us is how little credit Atari gets for pioneering video games in the 1970’s.   Atari is recognized for Pong, Breakout and Asteroids as if those were the only video games made in the decade.    In reality, Atari pioneered maze games, space games, racing games, shooting games, and everything in between.    However, since most of the games were created with discrete logic chip designs without a microprocessor, they cannot be “emulated” on modern systems.  This means that few people have played the games, and thus, they don’t really understand the impact that Atari’s coin-ops had on the video game industry.

The aim of Pong Returns is to “right” this “wrong” by morphing the game of Pong into a journey through the history of Atari’s “lost” coin-op games from the 70’s.    The game starts on a familiar Pong playfield, but as the levels progress, elements are added from classic Atari coin-op games to increase the challenge and vary the game play.   At its’ heart, Pong Returns is still Pong, but by mashing-up the gameplay of Pong with elements from Atari’s coin-op history we aim to create an addictive, engrossing, and transcendental experience that plays homage to and respects Atari’s amazing history.

Inspiration: Pong Returns is inspired by the many versions of Pong that Atari released in the 70’s, and by the wealth of other coin-op games Atari created in the same time period.    At the same time, the game is inspired by such modern classics as Bit.Trip.Beat (for the single player Pong style action) and games like Furu Furu Park that mash-up elements of classic games with modern game play.

Description:  In Pong Returns the player’s job is to “hit back” or “return” 11 balls per level through the from the left side to the opposite side of the screen.  On some levels, the area to get the ball “through” on the right side of the screen is limited.  Each successive level introduces new elements or obstacles that must be overcome to continue in the game.  The new elements and obstacles introduced are pulled from the history of Atari Games from the 1970’s, culminating in a battle with the seminal rocks and UFOs from Atari’s Asteroids.

Number of Players:  Pong Returns is a single player game played against computer opponents. 

Opponents: The computer “opponents” move in rhythmic patterns, and while they simulate A.I. they are not necessarily A.I. players.   Instead, players will be rewarded and encouraged to recognize the patterns of play so they can advance to higher levels.   On some levels it will be necessary to simulate A.I. to ramp the difficulty level, and this will occur on an as needed basis,

Visuals: The visuals of the game will be decidedly retro and 8-bit.  Characters designs and animations are inspired by Atari’s coin-op output from the 1970’s and stay as close to that aesthetic as possible.  However, to add variety, visuals tricks that Atari pioneered like color cycled images and audio visualizations like the ones created for Atari Video Music (see example here: http://www.youtube.com/watch?v=-NWwtZCpC2M)  will be incorporated into the backgrounds.  Also, art work from the Atari coin-op that inspires each level will be superimposed in the background of the display.

So far so good.  I described exactly the type of game I would want to play.  If Atari did not like the idea, they could stop right there and not bother with the rest.  What followed was 20 or so pages that described, in detail all of the Atari Coin-Ops that would be mashed-up with Pong for the levels in the game.  Some of them were classic Pong games by Atari, others were Atari coin ops hardly any one remembers (Shark Jaws, Jet fighter) and still others were well known classics (Asteroids).



The Pong mash-up would include class Pong game play invaded by the art and characters from Atari coin-ops through the 70’s  It would be like a journey culminating with a battle against Asteroids.

You can see the entire design document here:  Pong Returns Design Document First Draft


I turned in our design document, and and figured we had no chance of getting any further.   This was my dream idea.   The opportunity to recreate and play with Atari coin-op images and game-play from the classic age was a goal unreachable, wasn’t it?   I laughed it off.  It was fun to come-up with an outlandish idea.    In fact, for some of the mash-ups I had devised (i.e.  the ones for Tank and Stunt Cycle) it was not clear how I could even to pull them off:


Still, I wanted Atari to like the idea.

Mistake #1: Scope : 

Designing something that would take too much time to create.  While the mash-up idea might have been a good one, the contest deadline was short (just 4 weeks to make demo, 3 weeks to fnish the whole game).  With 20 coin-ups to mash-up, scope was just too large

The Demo

On the morning of May 1, I was very surprised to see the name “Producto Studios” listed as one of the semi-finalists in the contest.   The next round required us to create a demo and a “video”.  We had about 4 weeks to complete both, and I had no idea hope I was going to get both done.  We were working on a couple in-house projects, and I was writing the content for a class on HTML5 that was due the same day as the contest entries.

Still, how hard would it be to create a demo for Pong Returns?  It was a one-player games of Pong with multiple levels.  Easy right? Well, some times things that appear easy get all tangled up when you think about them too much.

Mistake #2: Focusing On Nuances And Not Optimization

I desperately wanted to replicate the audio visualization from the Atari Video Music appliance from the 70’s into the game.  Atari Video Music hooked-up to a stereo and used the wave-form of the music to display hypnotic images on the screen.

I knew that Flash had a very easy way to access the wave-form data of songs, so I made the decision to build the demo in Flash and export it to iOS.   I tested a simple version of this with some shapes moving to music on an iPad, and it appeared to work pretty well.    This was an encouraging start for the project, but it colored everything else.

The next step was to build a particle effects engine.   I wanted everything to explode in glorious particles.    I had this vision of the video music visualizations moving to the beat of some chip-tune style techno music, with particle exploding all over the place.  I still liked the idea, and in my head I wanted it to look cool, and be part of a cool game.  However, focusing on those nuances instead of game play was a huge mistake.

At the same time, while you can make some good iOS apps with Flash, the code needs to be heavily optimized for performance.   I simply did not have the time to fully optimize the game, and demo suffered because of it.  Because of this, most of the visualization and particle effects needed to be removed in the demo for performance.

Mistake #3 : I Made Pong

By the time I started to work on the actual game play, there was only about 7 days left until the contest entry was due.  Again, I was writing class materials at the same time (and in fact, flew to San Francisco to teach class the same day the contest entry was due).   I should have budgeting my time more wisely, but since this was just supposed to be a “demo”, I worked feverishly to incorporate as many of the early Atari com-op games as I could with my remaining time, and did not really consider what the “final” game would be.    The idea was to hint at the game play that would be in the final game, and figure out the rest once the demo was complete. It turned out,  I was able to get Pong, Pong Doubles (two paddles), Super Pong (3 paddles) and Coupe De Monde (soccer with a goal) done with a reasonable level of accuracy, but ran out of time for much else.

When I played the game, it was okay, but it was still just Pong.    Four successive version of Pong, but still just Pong.   With my few remaining days, I  started to panic because, well,  that I had essentially made Pong.   I went back to the drawing board an worked out a concept that each “game” (Pong, Pong Doubles, etc.) would encompass four levels in the games.  The 1st level would use a computer player that moved in a repeatable pattern.  The 2nd level would be like the original game, with computer A.I., the 3rd level would be a “frenzy” where balls shot out at a regular intervals, and the 4th level would be “battle”, where the walls closed-up, and the played had to destroy enemies on the screen.   At the last minute, I threw in a quick set of levels based on “Asteroids” (but used the AI ad movement from the Pong levels) just to show what that might look like in the game.   In the end, the demo had 20 levels with the promise of about 60 more once the final game was complete.

Here is a video of the actual game play.  I’ve restored the audio visualizations to the game screen, but other than that, it’s identical to the submitted demo.

Final Thoughts

If I had the chance to start over, I don’t think I would make a different game.  I would focus less on the nuances,  and more on optimization, but in the end, I was working towards making a game that I wanted to play…and one I still want to play.   I wish had had the opportunity to explore how Pong could have been mashed-up with more old Atari coin-op games, because to me it still seems like a fun idea .  Unfortunately, even though I still want to play Pong Returns  in it’s final, finished form, but I will never get the chance.    I learned a lot through the process, some things that I’m already using to make new games right now.

-Steve Fulton

Leave a Reply