Writing for storylets in StoryAssembler

This page provides a series of design steps to follow when designing a narrative experience using StoryAssembler and storylets. If you are unfamiliar with storylets, Emily Short has a helpful article explaining what they are and how they can be used in games. Currently, it is the defacto introduction to storylets.

StoryAssembler is a framework that allows users to generate choice-based stories at runtime using a library of story chunks called, fragments. StoryAssmbler aims to generate stories by piecing together fragments that satisfy a list of story goals representing what state we want the story to be in by the end. Each fragment represents a piece of dialogue and may present users with choices that link to other fragments.

Determining how exactly to approach authoring in StoryAssembler can be daunting. We often don't think of telling stories out of order and prefer a chronological series of events. This page is meant to help guide users through designing a narrative experience that takes full advantage of StoryAssembler's dynamism.

What goes into a storylet?

The short answer to this question is, "Whatever you want". Storylets can be as large or small as you want them to be. What matters is that you consider what is required for a player to be eligible to experience a storylet and what effects that storylet has on the rest of the narrative.

Initial design

1. Determine your story goals

It's best to start by thinking about the goals of your story. These will guide your later writing and StoryAssembler's algorithm when selecting story fragments as the game runs. What do you want the player to experience? What should they see/read? What should they learn?

2. Decide what order goals should be accomplished

Think about what order story goals should be pursued and accomplished. Are there things that the player should experience before others?

3. Divide goals among scenes

StoryAssembler divides the entire narrative experience into one or more scenes (similar to movie or play scenes). Each scene has its own goals. Writers should consider whether story goals should be divided among multiple scenes and what goals should correspond to each. StoryAssembler plays scenes in a set order. So, writers do not need to worry about dynamism at this phase.

4. Start fleshing out your scenes

Ask yourself the following fundamental narrative setting design questions:

• What characters are present?
• What key objects/items are present?
• What are the characters doing and why?
• What are the relationships of the characters toward each other? Is there conflict?

5. Start with a linear narrative

For each scene, start with a linear plot structure with little or no player choices available. Ensure that this starting narrative touches on all the story goals. You may need to break this linear narrative into multiple fragments (depending on the StoryAssembler runtime implementation).

6. Look for parts that can happen out of order

Review the linear narrative you designed. Are there parts that could happen in a different order than what you have now? Are there certain parts that depend on the player first experiencing another part of the story? Start subdividing the linear narrative into fragments and consider what prerequisites must be satisfied for the player to reach that part of the story. These fragments will be the storylets that allow players to experience a non-linear narrative.

7. Add choice points to move between storylets

Add choice points to the narrative that allow players to move between the fragments.

8. Add additional choices to flavor

Not all choices need to move players between portions of the plot. Sprinkle in some additional choices that might not change the current plot trajectory but might modify a player's progression through other systems or give them the feeling that they have more freedom than they might actually have to influence the plot.

9. Add duplicate/alternative storylets

Sometimes, you might need to add duplicate storylets presenting the same piece of the story world but slightly differently. For example, you might have a storylet where the player converses with a classmate. If your game tracks characters' current emotions, One instance of this storylet might feature a joyful conversation between friends. In contrast, another version might be more contentious if the player had previously done something to slight the character.

Adding these alternative storylets allows you to create a world that feels more alive and reactive to player choice.

Other things to remember

1. Keep interaction loops tight

Over multiple interactions with an NPC, the dialogue should reflect a changing relationship dynamic. This could be as simple as adding alternative dialogue lines to existing conversation threads that show a character reacting differently to the player. For instance, a character that is not as friendly with the player might give short responses without much engagement. However, as their relationship grows, those terse responses should be replaced with longer, more friendly replies. Ideally, players should be in a form of interaction loop with characters, where they regularly interact. This allows us to show the player a dynamic story world without them playing the story multiple times.

Putting it together in StoryAssembler

TBD.