Storylets: You Want Them

Very frequently, when I’m called in to suggest a narrative delivery system that will work for a particular game, I find myself sketching out some form of storylet-based solution. Storylets are simple, atomic, robust, and recombinable.

Here’s my basic definition of a storylet (though many systems may call them other things: events, snippets, etc):

• there is a piece of content. It might be a line or a whole section of dialogue, it might be narration, it might be an animation or scrap of film
• there are prerequisites that determine when the content can play
• there are effects on the world state that result after the content has played

I’ve written some before about how this structure lets one get beyond standard branching narrative, with quality-based and salience-based structures. It is the concept underlying StoryNexus. It also underlies Threaded Conversation, the conversation library I wrote for Inform (eventually released, and now maintained, by Chris Conley).

You could even understand conversation elements in Versu and in Character Engine as a type of storylet. In those cases, there is quite a lot of other procedural work determining what content should be presented next and how it should vary. Quite a few procedural narrative systems work by defining some kind of model for stringing storylets together — so this can be an approach that will support an ambitious AI-driven concept.

At the same time, this design method isn’t only for the procedurally ambitious. You can make and explore the affordances of a rudimentary storylet system by writing your storylet content and quality rules on a set of index cards. And in fact I do sometimes do exactly that as a paper prototyping exercise.

This definition leaves a lot else out. It doesn’t say how much content is inside a given storylet, how that content is structured, or how it’s selected. Max Kreminski’s overview work explores a lot of the nuances here.

But for the present article, I’m looking chiefly at how many standard ways of structuring game narrative content can be rendered in storylets.

Common Branching Structures and Storylets

Storylets can be used to replicate a lot of classic structures from branching, Twine, or Choose Your Own Adventure contexts, if you give yourself a progress stat or quality to count how far you are through the story, and perhaps also allow for a menace stat to represent how much trouble the player is in.

For instance, here’s a gauntlet storyline, linear except where the player makes a mistake, as it might be represented in Twine and then as it might be represented in storylets:

And here’s a branch-and-bottleneck, where the player is allowed some variation and then channeled back for critical moments:

Or a sorting hat, where a key choice at the beginning determines which of several linear narratives the player will experience:

Or a loop-and-grow structure where the player goes through the same seasons over and over again, but with some growth and difference over time — the structure I used for Bee.

Time caves are possibly the most annoying type of work to build with storylets, because they make every piece of content access dependent on the exact route you took to get there:

So to represent this in storylets, you’d have to attach to each piece of content a unique identifier that you used as the flag to unlock the next piece. At this point, you’re not getting most of the value of using storylets — the robust ability to add things later, the possibility of making stories interlock in interesting ways, the design discipline of generalizing about how your narrative space works.

As a practical matter, though, most games of any size aren’t time caves. It’s way too much work and too much combinatorial explosion, making a story that branches and branches without ever recombining. The more common case is to have small time-cave-like segments embedded in a larger structure. And in that case, it’s possible to enable that kind of branching with some tooling finesses — Versu and Character Engine use tooling to make it easier to author explicit branching elements embedded in a larger procedural flow — or by embedding branching narrative content within a storylet, as Varytale did.

Common Video Game Structures and Storylets

Storylets can be unlocked by levels of gameplay, levels of resource gathering, or by repetitive grinds where they have to be played over and over again until the player gains enough skill to pass. (The latter was a common structure in the early days of Fallen London, though the system has largely moved on from that.)

Storylets can be interspersed with progress in a casual game like Lily’s Garden, letting the player open new sections of story by playing some match-3 or time-management or similar gameplay:

And if the gameplay between levels is something where the player can express any kind of choice — playing the level well or badly, with one strategy or another — a storylet structure will let you pay off the narrative consequences there:

Storylets can be used to imitate the progression of a geography-based level design, if we break that design down into accessible areas:

• 

• 

• 

In short, many of the other options for assembling an interactive story can be replicated using a storylet structure.

But there’s more. Storylets can also be assembled into unusual solutions, like narrative deckbuilding and crafting concepts. Storylet-based stories can be extended after they’ve been written. And they can be designed to interlock with other narrative circumstances in the same storyworld.

Taken together, those features mean that storylet-based systems are often a good bet for a game that’s meant to last for years, to include DLC, to mesh with other gameplay systems, or to allow interesting player mods.

I’ll get into more detail about some of those points in a future article, if there’s interest.

Resources:

• Beyond Branching — a big long post introducing the background of this idea
• Survey of Storylet Design — summarizing academic work in this space by Max Kreminski
• Mailbag post on building storylet based systems for yourself — this piece is largely about implementation of these ideas