Programming the Monomyth

I’ve lately been watching a bunch of GDC (and other game conference) talks, specifically about how to do narrative when you have to worry about the player doing something stupid and unexpected. Some of this interest has been because I’ve been playing Wildermyth of late, and little things have been, if not bugging me, then getting my imagination going. (Note: this is one of those blog posts that I write in an hour to get an idea out of my head, I apologize if it’s less baked than it should be.)

How Wildermyth Handles Narrative

In Wildermyth, there are characters with Aspects and Hooks to them, and when it comes time to figure out what events are going to happen, it looks at the stable of available events, sees whether it has the right characters with those Hooks or Aspects, then casts them in those roles, saying dialogue that is written such that the writer knows nothing about those characters except that they meet some of the preconditions. The talk is here. It’s interesting, though I wish it went more in-depth on why they made some of the decisions they made.

In this way, it’s similar to how Naughty Dog handles the non-scripted dialogue in The Last of Us, or how Left 4 Dead handles character barks, or how Heaven’s Vault handles its whole plot, where the content is disconnected from all other content, put into a bucket, and then checked at runtime against preconditions. This is great for writers, since they can black box things and not have to worry about when or how the preconditions are met, nor about anything else that might get in the way of just immediately writing a story. Unfortunately, there are some problems with this approach, but they’re ones that I feel like I have a handle on how to address.

(Note: you can include a previous event as a precondition, which is how you can use a system like this to integrate in narrative events that end up looking like a graph, one of the traditional storytelling methods in games. The more you do this, the less power you get from the “events in a bucket” approach. I don’t want to entirely ignore this method of integrating different narrative structures, but it’s somewhat to the left of this particular post.)

Dan Harmon’s Story Circle

The basic story circle goes like this:

1. You — A character is in a zone of comfort,
2. Need — But they want something.
3. Go — They enter an unfamiliar situation,
4. Search — Adapt to it,
5. Find — Get what they wanted, 
6. Take — Pay a heavy price for it, 
7. Return — Then return to their familiar situation, 
8. Change — Having changed.

That’s about it. One important thing to note is that story circles are much worse if you think about them as rigid. Rather, they’re a structure that humans understand really well, which means that you can easily build things on top of them, and get power from subverting.

The best thing about this, from a writing perspective, and especially from a “procedural” writing perspective, is that the formula means that we have concrete keys to refer to.

What I Wish Wildermyth Did Differently

And here is one of the things that I wish Wildermyth did: story circles, or character development. What Wildermyth does instead is fake this sort of thing. Characters don’t really have wants, they have villains that they want to defeat, and “defeat the bad guy” is pretty boring as a motivation, especially when that’s really the only narrative that they have going. Characters have traits, but they don’t grow and change, with perhaps a few exceptions. Wildermyth “fakes” step 8 of the story circle by having a bit of history written to the character by an event, which is shown after the chapter is done … but this doesn’t actually represent growth, and I don’t think does a good enough job of faking character development enough that you can infer an arc.

So what would I do differently? Working within the framework that they already have, with content being atomic and gated by preconditions, I think that it wouldn’t actually be that much work to write a bunch of content that creates serviceable character arcs.

The minimum viable version of this would simply be eight “events” where each has the previous event as a precondition … but of course, even in normal storytelling, we don’t adhere all that closely to separating the eight steps out, so the “true” minimum is probably:

1. Everything is good, but then something isn’t right
2. The character goes and adapts
3. They get what they want and pay the price
4. They return, having changed

An example:

1. Sophia was set to marry her sweetheart, but he fell ill and was in need of medicine
2. She leaves the village and learns skills to survive in the wilds
3. She gets the medicine at the cost of a scar upon her face
4. She returns to the village and gives him the medicine, worried that he’ll love her less for her scar, but it’s fine, they get married

This is a very simple story, but because it’s broken into these parts, we can start writing out more of them, only worrying about the inputs and outputs of the black box (and not even those too much). For example:

2. She goes to the city and becomes a thief
2. She gets on a ship and becomes a fisherman
2. She communes with the spirits and becomes a warlock

All of these slot into that story very nicely, and without having to substantially change the other parts. In theory, if you write up a bunch of this content, then you can stitch it together at runtime, either behind the scenes, or with player input: if your story is coherent no matter what step 2 is, then why not allow the player to decide at least some of time?

My actual proposal for implementation is for events to query characters as part of their checking preconditions, specifically looking for a 1 through 8 number that will tell them where on the story circle the character is, then update that number as the event takes them through part of the story circle. In this way, you can get much more storylike outcomes without all that much more additional work and without having to fake it with things that can be inferred to be a story without actually being a story. An event might move a character from 3 to 7, or from 1 to 5, or anything else, and of course, there are events that don’t move the story circle at all.

Of course, to keep this consistent, there’s probably also some other programming you’d want to do, like tracking what the person is actually seeking, tracking their flaws and personality, etc. Part of the story circle is change, or at least the illusion of it, and one of my big problems with Wildermyth is that there is no change. Someone who is a Goofball never becomes less of a Goofball, never transitions to Snarky, never reveals that the reason they’re a Goofball is because of some tragic backstory, or insecurity, or apathy about the world, or … all the other stuff that I think makes writing good.

(I don’t mean to pick on Wildermyth, it’s a good game made by a tiny studio, but it’s the game that I’ve been playing lately, and I’ve been thinking about its systems, how they work, and how I think they could work better without having incredibly severe impacts on the budget. Most of this is not stuff that they could easily change now, but it is stuff that could be done if you were working on a game from the ground up.)

One of the other interesting things you can do with the story circle is change stories, and I would argue that many of the most popular stories do this. The hero starts off seeking something, but then it turns out that the thing they were seeking isn’t what they really needed all along. Perhaps Sophia leaves the house looking for a medicine for her ailing betrothed … but it turns out that she never really loved him, she was seeking her mother’s approval. All of this can be done with precondition-gated events as well, though I think you’d want to be a bit careful. The approach, I think, is to have multiple story circles going at once, and events that progress them independently or together, or can “bail” on one story circle in favor of another. In this way, you can have twists and turns added to the story. In proper narrative fiction, story circles can be twisted, corrupted, nested, overlapping, or aborted, and with this approach, you can get pretty much all of that while not having to have immense amounts of variable tracking.

I really am tempted to start writing my own interactive fiction, something like 80 days where the graphics are somewhat minimal and the focus is on having as much authored content as possible. I’ll keep playing Wildermyth, but my hope is that it’s a sign of things to come, and that procedural storytelling techniques that are about ten years old now will keep advancing in terms of how they approach the problems of wrangling a narrative out of player choices.

Addendum

The incomparable bacontime has written an example script that pulls from some simple tables, and I think it works well as a proof of concept. There are things that you’d want to add, if you were doing a full programmatic version, with tracking the MacGuffin being the most important of them, but it gives me some confidence that the formula really does work, especially if you’re writing around what you don’t know (which would be harder in a larger and more complicated narrative).