Run Forever! Jumpfinity! Postmortem

Introduction

 Run  Forever! Jumpfinity! is a randomly generated platformer. It was released on April 7th for the iPhone. It had a strange development cycle, where Matt Fister wrote a prototype in Python using Pygame, and later Mark Cerritelli ported it to the iPhone for distribution.

Design and Prototype Development

Matt:  Run Forever! Jumpfinity! was strangely inspired by a technique for random level generation that came to me while I was falling asleep. It was one of those ideas that seem like a eureka moment. I wrote a blog post on it so I wouldn't forget about it.

The prototype development came from the excitement from trying to implement this idea. I took some shortcuts from the original algorithm, but the result turned out pretty good anyway. The levels still surprise me, as much as they can anyway.

One major regret that I have at the development level is not writing a tool to speed up the creation of level templates - the building blocks used to generate the levels. Using just windows explorer and emacs to write templates became a drag on creating lots of diverse levels. 

Another reason for creating the game was to learn how to write a real-time game using Python and Pygame. Before I wrote Run Forever! Jumpfinity! all the games I had written in Python were turn based.

I found Python and Pygame made creating the game really easy though. I highly suggest them for prototyping any game, and I even think they are appropriate for releasing cross platform computer games as long as performance isn't an issue.

Other useful tools in my toolchain were GraphicsGale, which I'm still convinced is the best program for pixel art, and sfxr, which is great for rapid generation of sound effects.

Porting to iPhone and Release

Mark: For me, this project was about learning.  I wanted to learn about developing and selling an iPhone game.  What I started with was a codebase written in python, that I didn’t really know in detail, using libraries with which I was mostly unfamiliar.

 I started doing the graphics with Quartz, but quickly realized didn’t know how to use it efficiently, and decided it was more worthwhile to put time into learning about OpenGL ES.  Certainly that would make porting to other mobile platforms easier.

       Matt’s code was quite good, so it was easy to port the logic.  I recreated the object oriented skeleton, and then fleshed out the game.  However, I ran into quite a few challenges.  One, obviously, is that the iPhone is a touch interface, so I had to figure out how I wanted to have the player walk, run, and jump.  

Originally, I did not want a HUD, but at the very end of development, after seeing a few people play, I realized that even with the tutorial people were initially have trouble with the sliding interface.  Another challenge was that the coordinate systems and timing between my implementation and the original source were not the same, so I had to rediscover the physical constants to make the game fun.  

Finally, I had to work with the constraints of a mobile platform.  While Jumpfinity! is not a computationally taxing program, I did have to be aware of the iPhone’s limits so not to do anything stupid.

       If I were to go back in time and do this again, I can imagine a few things that might have sped up development.  I could have created a Mac OS X version for the assistance of a keyboard. I could have tried to get the original source to compile.  I could have had people play around with it as I worked on it, getting feedback over time.  I also did not realize until way too late that I could compile an Ad Hoc version for Matt to play and test.