Storylets Play Together

Storylets encourage narrative designers to think in terms of systems, and allow story arcs to affect one another in memorable ways.

In my previous post on storylets, I showed how storylets can replicate standard interactive narrative structures that are familiar from video games or CYOA.

This post gets into the other things storylets can do for your narrative structure that would be harder to achieve with a conventional method. Specifically, storylets let you build a system where

  • episodic stories can feed into a larger narrative arc, and it’s easy to add new episodic content without ripping out all the existing stuff
  • the player is guided within, but not constrained to, a story they’re currently playing
  • different episodes interact with each other in fictionally and mechanically interesting ways

To take those one at a time:

Large and small narrative arcs

A big storylet-based story might have a long narrative arc and then a bunch of smaller internal stories inside it.

Bee was written for the Varytale platform, which is, alas, no longer available.

My game Bee, for instance, takes place over several years of the protagonist’s life. There’s an overall arc about her growing up until she’s no longer eligible for any more spelling bees, and the changes in her life that go alongside that. Within each year of her life, she experiences traditional holidays, trains, does chores, and develops relationships with the members of her family.

To track where the player is in this story, I tracked several different progress stats:

  • How many years have passed?
  • What month is it?
  • How far has she progressed with character relationships and their associated story arcs?

“How many years have passed?” controls high level progress through the story. When it reaches a high enough number, we’ll get to the endgame, a story about her last spelling bee ever.

“What month is it?” makes seasonal content available, and of course advances the year count. This means that

  • A storylet about Christmas has “month=December” as a prerequisite
  • Every storylet advances the month after it’s played, as an effect
  • If the month is December, the new month becomes January and the year stat is also advanced by 1

The character relationships, meanwhile, are mostly detached from those temporal measures. A player might progress rapidly through all the stages of a character story during the first “year” of the main narrative.

To generalize from that a bit, we can have episodic progress stats that track where we are in a small story (like the character relationships) and other stats that rise more slowly, or have much larger values, that track our progress through the main narrative arc:

In some games, completing an episode is what drives the main arc forward. Neo Cab works a bit along these lines: you can pick up 3-4 passengers a night, and it’s up to you which ones you want to drive.

But when you’ve ended your shift, the day ends and your overall progress ratchets forward, opening up new elements in the main storyline.


Guided but not constrained

A branching narrative struggles to tell the player more than one story at a time. Typically, the player has a tightly defined set of options at any given moment.

Conversely, parser-based text adventures and a lot of open world games can confront the player with a bewildering amount of freedom, leaving them unsure what they ought to do.

A storylet system can offer a happy medium here: contextually relevant options from all the stories you’re currently in the middle of, plus any “always available” elements. Making this comfortable for the player depends on some good UI design, as well, but the underlying system supports it.


Stories that interlock

Month, year, and character story progress are not the only stats in Bee. The game also tracks spelling skill, motivation, and family poverty.

These other stats aren’t progress stats, though. Motivation and spelling skill are resources. The protagonist needs motivation to be able to play certain storylets that improve spelling skill. And she needs spelling skill at a certain level to be able to pass the end of year spelling bee.

Meanwhile, poverty is a menace — something the player doesn’t want to increase, but which may rise as a result of events in the story. When poverty is too great, certain storylet options become unavailable, and others open up.

Seasonal events in Fallen London introduce new happenings in existing game locations, and unlock new elements within existing storylines.

This is still a fairly systems-light representation — other storylet games have lots of resources and menaces in play. In Sunless Skies, for instance, gaining too much terror unlocks Nightmare storylets that plague the protagonist with unspeakable visions.

Thanks to these abstractions, one story can meaningfully affect what happens in another.

Here’s the branch and bottleneck storylet diagram from last post, except this time we’re including the idea that the player will sometimes need to go outside the episodic story she’s in if she wants to get the means to unlock the next episode. And conversely, sometimes she might need to do some other, unrelated activity to prevent a menace stat from going too high:

Some lovely storytelling dynamics can arise from systems like this, dynamics that echo the effects you find in long-running series television.

Suppose this episode is about tracking down a family of werewolves, but in order to unlock a midgame storylet, Mulder needs clues from an informant. That’s his source stat. Fortunately, he already has an informant available, unlocked through earlier play. He does have to go back through a familiar action or two of putting a signal in his apartment window in order to get his informant to show up — but that’s the kind of content reuse that feels fictionally justified.

Now suppose that in the midgame, one storylet has Mulder insist on sitting out in the woods in a convertible to watch the full moon. But nothing happens all night long except they get a lot of mosquito bites, and in the morning the menace stat “Agent Scully’s Exasperation” ticks upward a little. Or a lot.

Now Scully’s exasperation score unlocks a whole new episode when this one is over, a Mulder-and-Scully-fight episode. Alternatively, Mulder realizes he’s gotten himself into trouble and engages in a menace-reducing activity of buying her an apology gift, as a beat between the plot beats of continuing to hunt werewolves.

All of those are elements that someone could bake into a traditional branching narrative as options at the critical points. But building the system of storylets means that there’s a whole reusable economy of menaces and resources.

It means that I could have holiday seasonal events where Mulder has extra options for cheering Scully up on her birthday, or where she’ll read his intentions differently if it’s around Valentine’s Day.

Or maybe the identity of Mulder’s informant changes depending on what has happened in the top-level narrative progression. Maybe any informant will do for getting the Information resource commodity, but the costs of doing so and the fictional tonality of the interaction shift a lot.

In fact, we might have a scenario where there are multiple sources available for information, and the player has to decide how long Mulder will spend investigating each of the sources before trying to move on from this point — the more intel-gathering storylets he plays, the better the outcome he can unlock:

…but other things might be happening at the same time. Menaces might be climbing; a time stat might be counting down.


At its core, this is standard game systems design advice: make sure your systems affect each other.

It’s possible to design with this kind of systems thinking in mind for (say) a branching narrative system, but storylets make it particularly natural to do so because they foreground the stats — what are you tracking? Which storylets become available, and which are locked, as a result?

This presentation by Tadhg Kelly, and this post on his blog, talk about four kinds of numbers in games — currencies, metrics, tools, and territory. Some of his definitions feel a little alien to me — I wouldn’t think of a tennis ball as a currency in the game of tennis. But using these broad categories and thinking about how they apply to stats in narrative design, we might divide them like this:

Progress stats, menaces, reputation, and relationship stats are metrics, advancing the storyline and opening up optional events.

Money, inventory items, consumable “favors owed” by other characters, and subtler items like energy are all currencies. Currencies are most fun if they have a backstory: the currency of Hell might not be acceptable to churchgoers. Creating fungible, convertible rewards allows different storylines to affect each other in fun and fictionally surprising ways.

Most of the storylet-based games I’ve played have at least some metrics and some currencies.

Some, but not all, also have a sense of territory — a stat representing the player’s location in the game universe, for instance. Territory works well with investigation or exploration gameplay where the player needs to figure out where to look next for something.

Tools, we might understand as things that open up new affordances and actions that wouldn’t otherwise be there.

Some storylet games use personality traits or skills this way, for instance by letting the player learn lockpicking in order to defeat any forthcoming locks. The challenge is that, to pay off properly, this really requires the content creators to be disciplined and make sure that there are regular opportunities to show off a particular skill or trait throughout the rest of the content. (There are procedural ways to help make sure that’s the case; that’s a more advanced design solution, though.)

Another interesting but less common way to design “tools” in a storylet system is to have something that affects how other options play out.

  • Reduce risk. Fallen London gives the player a supply of “second chances”, a resource the player can spend to guarantee herself a second roll of the dice on a risky attempt where she wants to increase her chance of succeeding.
  • Modify core metric stats. Inventory items and outfits might increase the player’s stats in particular areas, temporarily making certain storylets accessible.
  • Multiply / divide consequences. Make a storylet produce double the currency that it otherwise would! Make a compliment twice as effective on your relationship stats with the Countess! Etc.

Storylets: You Want Them

Storylet systems are a way of organizing narrative content with more flexibility than the typical branching narrative.

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:

Continue reading “Storylets: You Want Them”

Survey of Storylets-based Design

Sketching a Map of the Storylets Design Space” is a paper by Max Kreminski prepared for ICIDS 2018, an academic survey of the storylet design space. I wanted to point my blog readers towards it, as it covers a lot of interesting territory in the quality-based narrative/salience-based narrative area (and in fact references my post on structures beyond branching narrative). Those of you interested in ways of structuring IF with more procedural complexity than a branching narrative may find it interesting.

The paper offers an overview of major storylet-based tools and works from both indie and academic experiments new and old, including StoryAssembler, StoryNexus, The King of Chicago, Reigns, and Ice-bound Compendium. It does not discuss Varytale, but then Varytale has been unavailable to play with for some years now, so there may not have been an accessible version for Kreminiski to look at since beginning their research.

Kreminski identifies four dimensions for looking at storylet-based systems: how preconditions for storylets are defined; whether individual storylets can ever be repeated; what sort of content is contained within a storylet (linear text? replacement grammars? branching content?); and finally, the “content selection architecture”, or how storylets are chosen as eligible for display.

Screen Shot 2018-08-29 at 11.10.31 AM.png

Kreminski also built a storylet system and a small prototype game of their own, a piece called Starfreighter. (It’s available on itch, if you want to look at it yourself.) The scenario is a fairly standard space-trading story, in which you accumulate crew and cargo and travel through a procedurally generated graph of solar systems. There are several cool presentational aspects here, including the way that you can select place names in your storylet and get extra information and see the location highlighted on the map. The actual content is not very deeply developed — there’s enough here that you can travel from port to port, do some trading, and have your hull damaged repeatedly by space debris, but it doesn’t dramatically develop very much more than that.

The structurally interesting bit about Starfreighter as a storylet system is that it looks not just for specific qualities (like Fallen London‘s “if your Connected: the Duchess is greater than 10”) but for resources that fit particular qualities, and subsequently binds those identified resources to the storylet for purposes of producing the narration. So for instance you might have a storylet “sell [cargo] on [planet]”, which would become available if you had any cargo (say, a crate of exotic matter) and were on any planet (say, Uinox), so that the storylet text would then be realized as “sell crate of exotic matter on Uinox.”

Continue reading “Survey of Storylets-based Design”

Reigns: Her Majesty (Leigh Alexander / Nerial)

Screen Shot 2017-12-27 at 12.03.06 PM

Reigns is a piece of interactive narrative with a Tinder-style mechanic (swipe left or right to accept the requests of your various friends, advisors, and enemies) and story snippets unlocked by where your stats are so far. At all times you need to keep your stats from reaching maximum or minimum, or your current incarnation will die — so trying to keep your current character going requires sometimes making individual choices that wouldn’t be what you want; and sometimes there’s a narrative-progressing move you could make… but you can’t afford to do it right now without dying in the process. Meanwhile, choices give you a clue what they’re likely to affect, but it’s not complete information — you can sometimes guess wrong about whether an option will raise or lower a particular stat, and thus kill yourself by accident.

The story experience that emerges thus feels a bit capricious but often entertaining. It’s not roleplaying of the kind where you can choose a protagonist personality and pursue it consistently, because consistently heading in any direction will get you killed.

There’s also a long-term way to win, but I never figured it out, in part because I wasn’t enough into the story to keep messing with it.

Reigns: Her Majesty takes that same simple concept, re-centers it on a queen protagonist, and makes it much much funnier.

Continue reading “Reigns: Her Majesty (Leigh Alexander / Nerial)”

Mailbag: QBN System Variants

Hello Emily,

I was reading through your blog and, in your post dated May 25, 2017 you describe several narrative systems, and the last one you write about you name it “System with Dynamic Requirements”

I’ve been working for a couple years now (on my free time) on a system that is very similar to what you describe: A tool to create narrative very similar to the way QBN does but with dynamic requirements for actors and locations.

The main difference is that it is a system to run over a real time game and the choices are done by gameplay inputs instead of selecting or letting the game select.

The tool provides a visual-node interface to create attributes and rules. The player actions trigger events on the system (i.e. looting a body trigger and event and we can create a rule on the tool that say “when loot event is triggered add attribute looter to the player”) and the attributes are evaluated continuously by the rules and giving results (i.e. If player have looter attribute with a value higher than 5 add world attribute “looter missions activated”)

Of course, there are the dynamic requirements that I’m using as I think the player’s engagement will be higher if the characters used on the story are people they “choose” to met in the game instead of previously designed so I can check if at one point they helped someone to escape or to acquire some item or whatever and later check the list of actors and use that one to be part of the story, or I can check between the locations in the world and create a mission that use a location with a certain attributes instead of always the same location for the same mission.

My question is: Do you know about other projects working on the same line?

Sort of, depending on how precisely you define “the same line”.

I know of projects that make use of Node-RED to visually define rules for various purposes other than interactive narrative rules.

I know of IF games, including my own, that allow the player to unlock new gameplay and story sections with any item that matches some general requirement; and sometimes a puzzle will have multiple solutions, but the specific solution the player picks turns out to be important or expressive in some way, or is used to judge the protagonist’s character.

I know of experiments with dynamically-gated story elements — most (but not all) of these tools in the academic space rather than among hobbyist IF tools or (for that matter) commercial video game tools. You may be interested in Ian Horswill’s Dear Leader’s Happy Story Time, described here in an academic paper with references and mentions of other related academic projects, or here in a video talk. (The references here provide a lot of potential further searches, with context.)

I know of realtime games that serve up specific beats depending on what tags are currently matched about world state. See Elan Ruskin’s work for Left4Dead, covered in this excellent talk. This is salience-based matching for various world states, which then in turn influenced the design of the dialogue-fitting in Firewatch. Not the same as constraint solving, but relevant to some of your other points about wanting to unlock specific story beats if the player has the right background.

I do not know of an existing tool with all the features you describe: a visual interface to create the rules for a dynamic-conditions interactive narrative system, applied to a realtime experience. (That’s not to say no one’s building one. I just haven’t seen it.)

That said, I’d like to suggest that you’re opening not just a technical space but a challenging design space, and you’ll want to test your assumptions about the player experience. There are some finished, public examples of games that do play a little in this space. For instance, games in the Fable series assigned story importance to figures the player had spent time with. I would suggest, based on my experience with that, that your initial assumption (“the player’s engagement will be higher if the characters used on the story are people they “choose” to met in the game instead of previously designed”) may not be true in all cases.

 

Montage, Narrative Deckbuilding and Other Effects in StoryNexus

empressshadow_smallIn a previous post, I wrote about design considerations for quality-based narrative systems, and mentioned that there was probably room for a standalone article about frequently-used patterns here. (This article in many ways mirrors one I wrote years ago about scene types in parser IF.)

When I write for Fallen London, I find myself using and reusing a couple of standard structures.

Straight choices tied to a progression quality: the storylet is available as step 1 (or 4, or 10, or X) of the story; there are two or more things you can do within that storylet; when you’re done, the narrative advances to step X+1. Maybe some of the things you can do in the storylet depend on secondary qualities, but this is basically recapitulating a fairly tight branch-and-bottleneck CYOA structure.

Continue reading “Montage, Narrative Deckbuilding and Other Effects in StoryNexus”