RSS Feed IDS on YouTube IDS on Facebook IDS on YouTube

Several months ago, Steve and I attended the launch party of the Experience Music Project’s Indie Game Revolution expo, a year long project to display how independent game development has shaped and formed a medium that so many of us grew up with.  Among many titles which we hadn’t yet heard of were some now household names of the indie world, like Nidhogg.  Nintendo co-sponsoring an event showcasing independent developers and having their own booth displaying no less than a dozen titles was an idea almost as alien to the industry a year ago as virtual reality was three years ago.  Yet, here we are and the community is better for it.

One particular title caught my eye as we explored the different works on display.  I love the idea of interactive media that bends the barrier of what we consider a “game” to be, and I think Panoramical in particular is a great example of what can be done when we ask, “What if, instead of making a ‘game’ with a win condition, we just try to enable a user to build an experience in our world?”  Instead of giving the player a controller or touchscreen, Panoramical enables players to experience the game with a soundboard.  Sliders, volume knobs, etc. were all functional in their own ways.  What a great idea!  A diverse group of crowd seemed to be enjoying it, and, just as importantly, they seemed to be enjoying the creations of each other.


Panoramical by Fernando Ramallo & David Kanaga. Go check it out.

Steve and I have had numerous discussions of what makes a game qualify as a by-the-book game.  The only conclusion we’ve come to is that a real game must have a success and fail condition.  By that definition, Panoramical and other works like it don’t fall under the “game” category, but that doesn’t diminish their worth nor gratitude to have them included in our medium.  Panoramical falls in this grey area between a film and a video game, like Dear Esther and others.  They tell a story or allow us to explore a world, and to take on the burden of allowing users to visually explore a soundscape is no small task.

Exploring what it is to be a “game” vs. another medium is a topic for another post.  This is about how we interact with games.  Controls have always been interesting to me.  I loved using a joystick to play Descent growing up.  A first person flight shooter in a zero-G environment was perfect for that method.  However, remove a dimension, and it becomes unwieldy.  In Doom or Counter-Strike, a joystick is about as useful as a Guitar Hero/Rock Band drum set.  Yet, they both have their target applications and are very effective at it.  Otherwise, people wouldn’t pay hundreds for a joystick or thousands to build a multi-monitor flight simulation station.

Controls are evolving right before our very eyes right now.  Valve has their new Steam controller with some very interesting ideas.  Nintendo pushed the envelope with the Wii stick and nunchuck to limited success.  Microsoft removed the physical piece alltogether with the Kinect and now seems to be taking it a step further with Hololens.  However, we need to be asking ourselves why.  To what end do these new interactions allow us to convey feelings to our users?

Kinect Harry Potter

Kinect Harry Potter. A useful control metaphor? I think not.

Controls are merely a method of indirection.  They enable a player to interact with the game.  Good controls should be transparent and make the game feel like an extension of the player’s will.  This is very difficult to achieve in a medium where dragons, spaceships, 4D geometry, and altering the space-time continuum are par for the course.  A good controller for a particular game or genre does not and most likely should not be exactly what you would use to perform the tasks in game.  For example, electronic boxing gloves for Street Fighter are a terrible idea.  No one wants to actually get on a skateboard in front of their TV to play Tony Hawk.  It’s not practical.

This leads us to understand why controllers are the way they are.  It’s because games enable us to feel like we’re doing the impossible.  The Marine in Doom can run at over 90mph.  Ryu in Street Fighter can jump over three times his own height.  When the assumptions of reality are broken, so must our assumptions of how to interact in reality.  So, we have a keyboard and mouse to navigate treacherous corridors at 90mph with lightning reflexes.  We have a joystick and 6 buttons to allow us to input complex commands in tens to hundreds of milliseconds instead of seconds and with extreme precision.

Controllers and our controls have evolved to meet the needs of the game itself, and this is a lesson we must not forget moving forward.  The metaphor of the game must not be broken to meet a contrived control metaphor.  This is where Kinect ultimately failed.  You can’t simulate a sword fight if users aren’t holding swords or feel the impact.  It feels less realistic than if they were doing it via controller.  This is such an important point that I’m going to repeat it in another way.  Controls that attempt to parallel reality and can’t convey the subtlety are immeasurably worse than those that ignore reality and focus on making the game an extension of the player’s mind.  Button layout doesn’t matter if players aren’t thinking “what button do I press?” and are thinking “how can I get over there?” or “how can I solve this problem?”


A counterpoint might be Guitar Hero.  A custom controller for a game had been attempted numerous times, but this one deserves special attention.  Next time you play (or go to your local thrift store and buy it for $10, because, trust me, it’s there), hold the controller up to the screen.  The buttons exactly match what’s on the screen and you strum every time they cross the bottom threshold.  It’s so simple that a 9 year old can figure it out, and thousands did.  Did you ever notice that the controller made a satisfying click when you strum it?  It’s because it was made with Cherry MX switches, the very same that have been in old IBM keyboards since the 80s.  Everything was calculated to make you feel like a rock star and, in that, Guitar Hero succeeds exactly where Kinect fails:  the controller is a perfect extension of the metaphor of the game itself.  In music, if you miss a note, just keep going.  Screw up too much and you’re booed off stage.  It’s an elegant solution because the controller was designed with the game.  Kinect was designed, then games were made to match the metaphor, and the disconnect shows.

As we evolve forward with new methods of indirection, we need to keep in mind that our games must be a projection of the player’s desires.  If we fail at this, then the game itself is a failure.  There is nothing worse than a player being removed from the experience because controller doesn’t allow them to quickly perform what they want within the rules of your constructed world.  Professional Starcraft players can control entire armies of dozens of units at over 400 actions per minute using a keyboard and mouse.  Don’t try to give those players a touch surface because it’s how actual military commanders coordinate squad movements in battle.  It will fail and the game, mechanics and story be damned, will be a waste of good ideas.  Afford the player the tools for success in an unrealistic world and allow them to exploit it and they will feel successful.  Now, I’m going to go play Super Meat Boy, because the controls are perfect.

More Reading:  Extra Credits:  Kinect Disconnect

Every developer seems to have that bug. You know, THAT bug. The elusive one that only seems to creep up during playtesting or while testing another feature? This isn’t specific to game development either. Web service developers or even operating system kernel developers have all seen, at least once in their careers, a bug that only seems to pop up when they aren’t looking for it. And it’s not just bad; it’s breaking. Debugging something you can’t figure out how to reproduce is an exercise in balancing sanity with sobriety.

With Minecart Madness, we had the Super Jump bug. We coined that name because the player would jump incredibly high for seemingly no reason. And it didn’t always happen. And we couldn’t figure out why. But it came up when we were debugging issues with track placement. It came up with we were debugging issues with obstacles on the track. It came up when we were figuring out how to handle tunneling. It kept happening. Why?

Filing a Good Bug

Super Jump Bug filing into IDS bug database

Super Jump Bug filing into our bug database

By profession, I’m a tester. My job is to break things and tell you why it’s broken. A really good bug filing should contain the following information:

  • First version where the bug was reproducible
  • Last version where the bug was not reproducible
  • Clear, concise reproduction steps with the minimum steps needed to cause bug
  • Any special machine settings (resolution dependence, high/low memory situation, specific phone, etc.)
  • Callstack if it’s a crash, but can also be useful if it’s not to show exactly where in code the bug is happening
  • Severity, i.e. how breaking of a bug it is
  • Extra manifestations, i.e. does this happen in all situations? For example, if your cross-platform Unity game is crashing on the iPhone, does it also crash in the same situation on Android?

With that in mind, let’s look back at this bug filing. Of the seven tenets listed above, this contains exactly zero. Each of these useful chunks of information rely on a single other event to occur: consistent reproduction. We couldn’t figure out how to make it happen. It just seemed to happen sometimes. Hence, the repro steps above.

What is “Breaking?”

As with all bugs, the Super Jump Bug had to go through a triage process where we decide if the bug is breaking enough to warrant fixing. These discussions usually involve expected amount of time to fix, expected degradation of the user experience, frequency of occurrences, and risk of fix. For the Super Jump Bug, we didn’t know the fix and we’d already attempted to reproduce it and fix it unsuccessfully. Through playtests, users would hit this bug as well.  When a user would hit the bug, he/she would notice immediately and ask what happened. We told those users that we were aware of it and not to worry. We were worried. The feeling of having to downplay a bug you know is breaking and can’t solve is crushing. With that in mind, we did not “Won’t Fix” this bug, if only to satisfy ourselves of knowing we solved it.

Procrastination as a Tool

Like most developers, we decided to just let this bug sit. And sit. And sit. Sometimes, as we’re all aware, one of two things can happen to bugs we let sit. First, the bug “magically” fixes itself. You change some specific values for core mechanics like jumping or movement, increase or decrease your net resolution, and suddenly, the bug isn’t there. It most likely is, but it is being masked or mitigated by your change. A bug that users can’t see, for an indie dev, is not a bug. We don’t have time to make things nice. We have to ship. The second thing that can happen while procrastinating is a revelation. A sudden moment of clarity. For a small moment in time, you become Neo. You can see the code and you realize the bug without ever thinking about it. That is how we solved the Super Jump Bug.

What is Jumping?

All mechanics in games need to feel like an extension to the players mind. Never has this been more true than in touch based mechanics. We touch the character and we want him to jump as we imagine in our minds, run as fast or slow as we picture, or target exactly where we point. Curiously, our minds don’t exactly imagine reality based physics. Not until high school physics classes do we realize that our assumptions about how things move are often wrong. But, this is a game, so we are expected to break with reality. Indeed, jumping should feel as the user would expect, not as it would be on Earth. Therefore, our jump algorithm doesn’t function as a NBA player leaping on the court does.

We break jumping into two parts. First, the initial hop. This happens with just a single touch and is the minimum jump height. This allows for targeted little jumps to cover the smallest of crevices. After that, for a specific amount of frames, we provide an additional upward velocity until either the user releases his/her finger from the screen or our acceptable amount of frames are exhausted. This provides the aforementioned feeling of the character on screen being an extension of the player’s finger, and therefore, mind. This creates a jumping experience that is fun and satisfying. More importantly, though, it makes the player feel liable for all successes and failures regarding hit and missed jumps.

What was the bug?

The code for the jump looked like this in revision 160:

velocity.Y -= _amountTouches == 1 ? HopHeight : fUpwardJumpAcceleration;

Revision 161, after the bug was fixed, contained the following instead:

velocity.Y = _amountTouches == 1 ? -HopHeight : _velocity.Y - fUpwardJumpAcceleration;

Of course, you see the changes, but do you see the bug? Hint: the bug is not on this line at all. To understand the bug, we need to know that, after landing, we reset _amountTouches to 0 in the Minecart’s update method. By doing this in the subsequent update, the Minecart is effectively running a frame behind on determining if it is in the air or on the ground. It goes to follow that a second HopHeight jump can occur.

Reproducing a Bug After Fixing It

Often, we determine a fix for a bug before the bug can be accurately reproduced. Only after conjuring a fix can we deduce a sequence of valid repro steps. For this bug, based on the fix in the earlier revision, the repro steps were as follows:

  1. Jump like any user would, but do not remove finger
  2. Land, keeping finger on screen
  3. Jump again by holding finger (we wait for touch events, never the absence)
  4. Repeat 3-4 times.

Step 3 is by design. We will never not let a user jump while on the ground. After 3-4 iterations of these steps, a large double jump would occur. Every. Time.

Learning and Moving Forward

The Super Jump Bug was a single bug with a single line fix affecting only certain users who happened to touch the screen for long enough in edge cases. However, it highlights that debugging may not be a scientific process. We can see that, because we are changing variables a full update behind, using the built-in debugger wouldn’t have gotten us closer. We tried. But, you can’t hold the screen AND hit break points in the emulator. In fact, reliance on the given tools was a hindrance to our progress for bug #107, the Super Jump Bug.

Brian Kernighan, one of the inventors of C, once wrote, “Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.” Intimate familiarity with each and every line of your code is paramount to shipping a quality product. Copy/paste is not a design pattern and will lead to bugs. We can confidently say that if we had borrowed another jump algorithm, this would have never gotten fixed. Code simply. Document thoroughly. Be patient. The product and your users will thank you.