Having a driving question helps me find interesting, less-mainstream content that can help shape my thinking. One question I am exploring is how game-design can drive app-design (not via gamification). The presentation, Building a Princess Saving App, describes it perfectly.

This talk is about building learning and fun into your applications. If you’ve ever wondered how games work and how they can help you build better apps, this is the talk for you. Along the way, we’ll discuss a new philosophy of interaction design that is already creating a major competitive advantage for innovative application developers.

The slides describe how typical enterprise and Web 2.0 application designers might approach the problem of saving a princess vs. how Super Mario Brothers does it.

Along the way you learn the language of game-design and the STARS model. Well worth a read if you are interested in this topic.

A few days ago, I wondered about soundtracks for books. I had an aside where I mentioned that game soundtracks are synchronized with the player’s actions (like a book’s would have to be).

That is also true of a non-game app. If an app had a soundtrack, then it would also be synchronized with behavior, state, situations, etc.

Apps often use system sounds. So, if you do something that isn’t allowed, you could get an error beep. Alerts similarly come with a sound. That’s been around probably since the first GUIs. Those aren’t soundtracks.

But, I’ve been trying to think about all apps as potentially games, or having game design drive the app design. So, that means sound design has to be part of it. In fact, I think it’s a tell that not being able to conceive of sound design for an app means that it isn’t using game-driven design. What’s the soundtrack to MS Word?

In Pokémon Go vs. Apple Workouts, I said that game-design doesn’t drive the Workouts app—it’s slapped on. And even though I play music while doing a workout, that’s not a soundtrack either.

But every workout app could have a sound layer to let you know what is going on. in Sprint-o-Mat, I give you a ding when it’s time to start sprinting. Apple workouts have pace alerts.

But, what more could you do? In AR opens up playability, I said that even mundane apps could become games with AR (e.g. Grocery List vs. Zombies). We have a kind of AR right now with just headphones, so maybe the right sound-design (more than music or system sounds) could make a workout more like a game.

So, if the game in Sprint-o-Mat is a race, here are some ideas for a game-design driven soundtrack:.

1. Crowd sound
2. Have the crowd yell out your name
3. Give a sense of the location of the pace-setter
   1. Footsteps
   2. Heavy breaths
   3. Friendly banter: “C’mon keep up, don’t let me pass”
4. Add in band music that you pass (is at a physical location that you approach and leave)
5. Have an announcer yell out your name and final time at the end

From the beginning of Sprint-o-Mat, I always internally represented distances as an enum with an associated value:

public enum Distance {
  case mile(distance: Double)
  case km(distance: Double)
 
  static let kmPerMile = 1.60934
}

So, adding kilometer support in Sprint-o-Mat was mostly about adding in some UI.

I added a button to flip the units, but I didn’t want a straight conversion. I wanted it to round to the closest tenth.

public func flipUnitsAndRound() -> Distance {
  switch self {
  case .mile(let d):
    return .km(distance: round(d * Distance.kmPerMile * 10) / 10)
  case .km(let d):
    return .mile(distance: round(d / Distance.kmPerMile * 10) / 10)
  }
}

I do the same for paces, and round them to the nearest 15 seconds.

With this done, it was mostly hunting down all of the places I was lazy—mostly inside of my HealthKit code that is getting running distance from the Watch in miles.

I left that as is, but made all of the mathematical operators for Distance work for mixed miles and kilometers, so I could could construct a .km Distance and then += .mile distances onto it, and the conversion would be automatic, keeping the units of the left-hand side.

public func + (left: Distance, right: Distance) -> Distance {
  switch (left, right) {
    case (.mile(let ld), .mile(let rd)):
      return .mile(distance: ld + rd)
    case (.km(let ld), .km(let rd)):
      return .km(distance: ld + rd)
    case (.km(let ld), .mile(let rd)):
      return .km(distance: ld + rd * Distance.kmPerMile)
    case (.mile(let ld), .km(let rd)):
         return .mile(distance: ld + rd / Distance.kmPerMile)
     }
}

func += (left: inout Distance, right: Distance) {
  left = left + right
}

If you run in kilometers, check out the new version.

I’ve been exploring the intersection of games and things that aren’t really games, and using playability to make books and apps better. In past articles, I’ve talked about how this is not gamification, which I view as a tacked-on layer. I gave the example of Pokémon Go vs. Apple Workouts to illustrate the difference.

I recently made a major update to Sprint-o-Mat that made the UI more of a visualization. My goal was to make it easier to get the most important information at a glance.

But, running with it today, I realized that it’s also now a game. Instead of showing this:

I show this:

The white dots are pace-setters, and so now it’s a game—a race. It’s a rudimentary one, but racing is fun, and I think this now is a fruitful direction for making it more and more like a race.

In a real race, one of the most fun parts (to me) is when you are close to another runner and have to compete. This is where I think I can add some functionality in the next version.

I could do even better if Apple Glasses are real.