Jounce Brings Music and Puzzles to the iPhone

We've seen an explosion of music games hit store shelves recently (Beatles Rock Band, anyone?). And ever since Dance Dance Revolution's 1998 Japanese release, we have come to associate rhythm with music-based video games. A music game can't be made with rhythm gameplay, right?

A brief spin of Jounce might just change your mind. Instead of relying on a player's rhythm, Jounce creates the music for you. Your job is to place enough Bouncers around the screen to reach your goal in the greatest amount of moves possible, earning one point per ball per bounce. Each Bouncer in the puzzle scene is assigned a different tone in a rising scale, creating generative musical pleasing to the ear. This is perhaps one of the few music games I have ever seen that you can still enjoy even if you don't have rhythm (like Fozzie Bear).




Matt Mitman - chief designer, programmer, artist, and well, all-around creator of Jounce - explains how he created Jounce as a 1.5-man team. Enjoy!

What inspired you to create Jounce?

Boredom was the prime motivator. I had nothing going on one Sunday, but didn’t really feel like working on any existing projects, so I just started hammering out this new one. The idea was vaguely inspired by another iPhone game we’d been doing some prototype work on at Max Gaming Technologies, but with the core idea extremely simplified, and then subsequently expanded upon as I saw what was working.

I viewed Jounce as something of an experiment for the App Store: a small quick game to test the waters and see if something really basic still stood a chance. So far, it's not going to make me rich, but it's doing well enough to keep tinkering with it.

How are the levels created on Jounce?

Jounce uses a deterministic procedural generator to create all of its levels. Since the levels take around two minutes each and the GUI is currently set to 32001 levels, if someone were to play every level once, they’d be looking at a bit more than 1000 hours of play time – not bad for a little puzzle game!



Matt Mitman did pretty much everything on Jounce - art, script, and sound effects - with help from Tim Newell for Mac porting and building.

What was your development process like?

Jounce was completed extremely fast. All told (not counting playing the game), I put in around 20 hours of work into v1.0, and Tim spent a couple hours packaging up builds for testing and finally submitting to the iTunes App store. I created all of the gameplay related parts myself, and then Tim did the Mac port/submission side of things, so just two guys on the dev team.

The bulk of the work was done on one Sunday, starting in the morning. By later that night, I had a fairly solid game. There were still a few bugs and it lacked a high score system, but pretty much the core of the game was done at that point. I then spent a bit of time here and there over the following week polishing things up, adding some particle effects, and generally just making sure things were stable and looked good. Overall Jounce sailed along remarkably smoothly.

The look of Jounce was originally intended to just be some quick prototype art; some really basic shapes in grayscale just for testing as I tossed the initial build together. It grew on me over time though, so rather than switching to something bright and cheerful like many iPhone games seem to be using currently, I decided to keep it and be a bit unique there. It's somewhat ironic I suppose that the first game created on my own has almost zero time spent on the art, given I generally identify myself as an artist, rather than a coder.

QA was informal, basically by playing the Windows build of the game a ton and fixing anything I saw break. I sometimes made notes on whatever scrap of paper was sitting on my desk, but that’s the extent of my bug tracker for this project.

After the PC build seemed to be solid, Tim made a build for iPhone that we tested. A few gameplay tweaks came out of this, such as making the Bouncers a little larger, and drawing a line from the center of the Bouncer to your finger, but I can’t recall any new bugs showing up on the iPhone version.

Then it was off to write a description, gather some screenshots, and submit to the App Store.

What development tools did you use to create the game?

Nothing unusual here: Photoshop for the art, Visual Studio simply because it’s the default app to open .cs files on my system for C# work, and of course, Torque 2D for iPhone.

Torque’s biggest benefit for me is that I can build an entire iPhone game on my Windows desktop and then pass it off for the port. I didn’t have to go out and spend a couple hundred bucks on a Mac Mini, figure out how to make room for it on my desk, and learn my way around a new OS. I’ll probably buy a Mac eventually, but I wasn’t inclined to make that investment before I saw if I was likely to make that investment back.



"Torque’s biggest benefit for me is that I can build an entire iPhone game on my Windows desktop and then pass it off for the port." - Matt Mitman, Designer of Jounce

Describe your biggest technical hurdles and how you overcame them.

Being a small game, there weren’t really a whole lot of hurdles to jump; the main one I suppose would be the level generator. I figured with Jounce being a puzzle game, it needed to have plenty of levels to keep people playing it, but since this was to be a quick experiment I didn’t want to spend a bunch of time laying out a hundred levels by hand.

After I had a basic playable build going an hour or two after I started, it seemed like random levels would most likely work fine, so I decided to go with a deterministic generator for the levels. I wanted to be a little more hands on than just using getRandom(), and I had to make sure that levels would look the same for everyone, so I ended up using a whole bunch of weird equations I made up as I went along based on Sine and Cosine. The generator ended up being driven by equations like:

%blockCount = mRound(2*mSin(%level + 2*mCos(%level)) + 3*mCos(%level) * mSin(%level*%level) + (%level / $maxLevelCount) * ($maxBlocks-5)) + 5;

That worked fairly well, but levels often ended up being overly filled, making it impossible to reach the goal, so after it fills the level with the main blocks, it goes through and removes anything that overlaps or is too close for the ball to pass through. This guaranteed playable levels, but all the walls were rectangles, so for the final touch, it does one last pass to add a handful of smaller blocks back in to give it some more interesting shapes. So I suppose the generator came together by constantly moving forward, rather than restarting and trying a different method when things weren’t quite working. I’ve checked over 700 of the levels without any being unplayable now, so it appears to be stable.

The benefit of this is Jounce supports way more levels than anyone is likely to ever play. The UI currently caps it to levels 0 through 32000, but I could easily raise it to just about any other number in moments. And of course, it meant I didn’t have to spend hours if not days laying out levels, so I could concentrate on making the whole game more solid with that time saved.

There’s one issue in the current build that will be fixed when the next update goes live. During our testing, performance seemed to be fine - I’d have a number of balls bouncing around without any trouble, so I left some onCollision callbacks in script. Turns out, though, that several of our players aren’t just better than us, they are a lot better and found ways to have nearly all the balls bouncing around in order to rack up some really impressive scores, which unfortunately caused FPS to bottom out. I thought it had something to do with physics, but after running the profiler, it turned out to be the onCollision callbacks. I don’t do a whole lot with these, basically just spawn a particle and increment the score value of each ball. When you’ve got 40 to 60 balls bouncing around, each one colliding several times in a second, those brief little callback scripts add up fast.

The solution is of course to just move those callbacks into the C++ side of things, which has turned out to be quite easy and resulted in a pretty massive boost when all the balls are bouncing around at once. Checking FPS on the PC, moving less than 2 dozen lines of script into C++ gave nearly 10x the performance in worst case scenarios.

How successful has Jounce been so far?

I wouldn't call Jounce a huge success just yet, but it looks to be on the right track for that to occur. It was posted about on the Touch Arcade forums within about a day of release (before we’d even started doing any press work) and received a bunch of extremely positive responses and great feedback that’s going to help shape the next couple updates. The best sign so far, though, is Apple put it up in the New and Noteworthy section of the games page on the App Store less than a week after release. I probably won’t be paying off my mortgage next month, but sales have been good enough so far to warrant a few update releases.

Speaking of, Jounce 1.1 and Jounce Lite should be showing up in the App Store any day now. Jounce 1.1 adds OpenFeint support, customization of color and backgrounds, multiple sound sets, and vastly improved performance when making more complex layouts (dang players were just too good, found some slowdowns with layouts I hadn't even considered making :) ). Sales have slid down the past few weeks, but we're hopeful that this update and the lite version will cause a nice big spike to drive it back up the charts.



The next version of Jounce will have customization of color and backgrounds, among other features.

Thanks, Matt, for taking the time to talk with me and good luck to Max Gaming Technologies from all of us at TorquePowered!

For more stories like this, check out the Torque Developer Interview series.