http://storyteller-game.com

It has nice pictures like this one:

I decided Storyteller deserved its own website instead of being here on my personal blog.

Also, since explaining the game through text is kind of hard, I decided to record a very short gameplay video. It is kind of rough on purpose, since I want to make it clear that the game will change quite a bit before release!

New Storyteller Website

NOTE: apparently all DNSes have not updated yet, so if you see a parking page, try again later!

Update your subscriptions to the new site, since I won’t be updating this blog anymore…

And remember to follow development through facebook, twitter and the dev blog on the new site!

Last week I was invited to show Storyteller at the Penny Arcade Expo as a guest of Spy Party‘s booth.  It was the first time the game is playtested publicly and it surpassed all of our expectations: people enjoyed the game and most of them played it through.

All the recent changes to the core mechanic of the game succeeded in making it way easier to understand and more interesting to play. I collected a lot of feedback and observations and ideas this trip and will spend the next weeks working on them. Now I feel way more confident that I have a solid game and it just needs work to get there.

Storyteller was also selected to be part of this year’s “official selections” at IndieCade, which means that the game will be part of the event without competing with juried games. I will not be able to attend in person this year, but the game will be playable!

Next week I am traveling to Seattle to attend PAX as a guest for the Spy Party Booth, where Storyteller will be publicly playable.

It will be the first time the game is shown in an environment with gamers instead of developers, which is a bit scary!

There are 25 stories to play in the current build and my TO-DO list still has 30 small items I want to work on before PAX. I think this is going to be the best and most playable version of Storyteller that ever existed.

Big thanks to my PR advisor, Chris Hecker!

There are just too many rules.

The first stories are simple and most people have no problem going through them, but as more and more characters are introduced, it becomes harder to predict what is going to happen when you place the lover next to the angry villain that just secretly killed his wife out of jealousy.

Examples of Rules

I fall in love with the closest character if:

• I am compatible (nobles like rich people, heterosexuals need opposite sex, etc.)
• I don’t feel remorse about something I did to him (lovers don’t care)
• I don’t hate or dislike her (lovers don’t care)
• I am not already in love and as far as I know my partner didn’t die (lovers don’t care)
• I am not envious of this person (lovers don’t care)

I spent the past two months rewriting, debugging and adjusting the rules that govern character behavior, hoping that it would fix the problem, but I got stuck going back and forth without making significant progress. Some designer friends suggested I should proceed to make the whole game with the current mechanics, hoping the process of producing the actual game would reveal the proper mechanics to use.

The build I am preparing for PAX has 25 stories in it and I started noticing a structure underlying the whole mess of character-defining rules. When placing characters in frames, you are trying to create scenes (i.e. theft, murder, crush, abandonment, etc.) that satisfy what the story is asking of you. Could I implement a higher-level mechanic that deals with whole frames instead of individual characters?

I will consider this when I come back from Seattle.

Interesting changes I made to the game:

• Each character only has one nature, making things simpler than the old version
• Max three characters are allowed per frame, this is easier both for players and the code
• Some things can only happen in quiet frames: you used to be able to fall in love during a bloody murder. Not anymore.
• Introduced the Gift and Mina the Vampire

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!

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: