Recently I participated in the first “Depth Jam“, organized by Jonathan Blow and Chris Hecker, along with Marc Ten Bosch.

The goal of Depth Jams is to come up with solutions for hard design problems on games that are already working.

While regular game jams are about solving a bunch of relatively easy problems until there’s a working game, trying to solve hard problems is hard work. Also because you are challenging somebody’s main project, it’s an emotionally tense interaction all along. Depth jams are definitely not about having fun!

Having other talented game designers think hard and exclusively about your game plus the cycle of implementing solutions and discussing them felt very different from what you get from casual brainstorming or playtesting sessions. It was the first time I could have this depth of discussion about my game with other designers.

My chosen problem for this depth jam was the dilemma of where to go next with Storyteller’s gameplay. After the jam I decided to explore a slightly different core mechanic that seems to be working better in the kind of space Storyteller wants to be in. Time will tell how well it works (will write about this soon!).

Thoughts on the format

• We had 4 games to work on, but all the game switching during the day prevented me from following a train of thought for very long until it was time to change again. Maybe 3 games works better?
• Since the jam is so exhausting and discipline-trying, making it a retreat in a place that is not familiar to anyone feels critical to me. Jon and Chris hired a catering service to keep distraction away and cut down on variables that could affect the performance of the jam, but I can say that it would have been totally fine (maybe even better) if we cooked our own meals, provided we made all groceries once before starting. Advice: avoid abundant and heavy meals!
• There must be some contract where everybody agrees to give the others freedom to talk openly about the games even if it’s hurtful to the maker. We had a couple of emotionally charged moments during the jam, but without the possibility of expressing openly it would have degenerated into tiptoeing around egos. Mutual respect as game makers is something we had in abundance, so it might be important!
• It would have been better if we spent even more time playing the games before the jam.
• A pre-meeting was necessary to propose the “question” for each game. We figured that each of us should really care about the subject, be specific enough to have a few answers instead of hundreds, and it must be possible to hack the solutions during the jam. We didn’t want to use jam time to figure them out, but we did change some of them during it. As a bonus, discussing the questions beforehand allowed us to start thinking ahead of time.
• We chose to add 1 day to the jam per game, and 4 slots of 2 hours for each day. Each game got one first-morning slot because it’s when everybody is at their most productive, but we were flexible with the rest according to how we were feeling. We shuffled shifts often. Breaks were crucial to keep productivity and sanity! Frisbee is proven to work. After dinner it was programming time, where we implemented the solutions discussed.
• Each slot was about discussing the problem until interesting solutions emerged, but I feel it was still too brainstormy. I would try this setup instead: 1) Discuss problem during slot 2) Stop talking and walk away to think during slot 3) Come back, talk and pick solutions before the slot is over. Slots would need to be longer though (that’s why I suggest 3 games per day instead of four).

Storyteller uses String IDs heavily, and I want to store them in collections but don’t want to risk duplicates, which is what the Set data structure is for.

Unfortunately, Actionscript 3 does not feature a set collection. So far, I was using the Dictionary class, but since it is not exactly a set, I tripped up several times because of its odd interface: myset["id1"] to ask for containment, delete myset["id"] for deletion and there’s no built in way to ask for its amount of elements.

I searched Google for collection libraries like AS3Commons and Polygonal, but they had a few shortcomings: the former does not implement builtin iteration (using the nefarious Proxy class) and the second does not support a set of String out of the box nor builtin iteration.

Since I don’t want to worry about sets in my game, I made my own StringSet class that has several features:

• It is pretty type safe because it uses the String type explicitly everywhere (unlike AS collections, in which the push method traded safety for versatility).
• Is implemented using Dictionary, which is pretty fast when asking for containment.
• Can be iterated using for..in and for each…in, and can ask for containment using the in operator (ie if(“mydog” in dogset){}).
• Provides several convenience methods like joining, intersection, clone, toArray, toVector, etc.
• Caveat: it does NOT retain the order in which keys were added.
• Caveat: may have bugs. Report them on the comments so I can fix them!

Download StringSet.as

Storyteller might allow characters to lie.

Characters in Storyteller have perfect information about everything that happened in the story. While this allows plenty of interesting situations, I feel I need to take things a step further, and allow characters to have incomplete or downright false information. This means I will have to rewrite the solving algorithm again to have a global, true model of the story and individual models of the world for each character.

I am particularly interested in characters lying to each other, and acting upon false information. This would make some stories trickier as players will have to remember who knows what. Some Shakespeare stories would become possible, as in Othello:

Iago is Othello’s ambitious friend. Othello promotes Michael Cassio and Iago is deadly jealous. Othello elopes with Desdemona but Iago starts to plot against them. Othello becomes jealous and suspicious of Desdemona. Othello returns to the castle to kill his innocent wife. Emilia tells Othello the truth about the scheming Iago. Othello wounds Iago, then kills himself. Iago kills Emilia.

Another kind of deception is “impostoring“, where one character poses as another, surprising the victim with the eventual revelation. The Crying Game comes to mind.

The goal of this feature is for players to be able to play not only with external events like murder and theft, but also with what each character believes:

Shocked and surprised, I stumbled to get the Nuovo award at this year’s IGF and gave an unusual, improvised acceptance speech.

This means that the game might be able to get more credibility with the press and increase the chances of being published by Steam and Apple. Since I started attending GDC I sort of fantasized with getting an award at some time; and finally achieving it, I have more mindshare to spend on the game itself and in some ways, being more honest with myself.

The other news is that I am staying here at San Francisco for three months at Chris Hecker’s house working solely on Storyteller in a forced march, hanging out with other very smart people like Jonathan Blow and Marc Ten Bosch, so I am extremely happy.

So my main goal now: make a great game out of Storyteller!

Disclaimer: all this might change before release! It has happened before…

Storyteller has a simple interface: you drag actors into panels to give form to a story, but you don’t directly control how each character behaves. Each actor reacts according to his nature, of which there are several: villain, lover, hero, amnesiac, etc. All living characters have a common behavior: they all suffer when someone they care about dies or dumps them, and other common-sense rules.

The challenge of each “story” (or level) is to figure out how to make actors do what you want, how to fit that in 3 or 4 panels AND somehow match what the story goals.

In example above, Tim is missing Lucy because he fell in love with her the first frame. Lucy, however, is playing a villain so she is not only uninterested in Tim but also annoyed at his crush on her. What happens between the first and second panel is that Lucy left for some reason and Tim is still in love with her, thus him missing her. This is called closure, the core of what makes Storyteller work. Another, simpler example:

Adam here dies because the game concludes that since there’s a tomb in the second panel and only Adam is missing, he must have died. That’s the nature of the tomb in Storyteller.

Each one of the stories check if its conditions are met, but often they are not very specific, so you can find multiple solutions to the same story:

Some stories actually detect some interesting variants and hints you of their existence!

Right now, I am trying some new submechanics like flashbacks, that allow out-of-order story arranging: