Concurrent Storytelling

This post outlines one way of understanding what my thesis is about: a tool for concurrent storytelling. For this post, I'll speak mainly in terms of narrative structure & system design rather than PL & logic. My goal is that an audience more oriented in interactive fiction than in programming languages can follow along. Please feel free to send me feedback about the accessibility of this writing from that perspective!

Previously, I've described my thesis programming language as a tool for designing game mechanics. But the term "game mechanics" is fairly broad, and in my proposal, I gave examples ranging from 2d puzzle games to parser interactive fiction. While I'm still excited about designing a core language that can express that entire range of mechanics, I've also narrowed my focus somewhat to examples that are especially illuminating to design this way.

In my INT 7 paper presented in June, I wrote about what I identified as the first solid successful experiment: narrative generation through a social simulation mechanic. In other words: describe general rules for character interaction; throw a bunch of characters into the pot; stir, and observe the (highly nondeterministic) sequence of actions that arises. Tweak the action rules until this process is likely to create something recognizably "story-like."

What I just referred to as a "sequence of actions" is actually better understood as a DAG of actions: a directed edge between actions A1 and A2 only exists if A2 depends on some resource(s) created by A1. "Resources" in the narrative setup include things like the presence/availability of characters required for a scene, but also pieces of state like "Romeo has a crush on Juliet" or "Tybalt carries a weapon."

Such a DAG is represented in CLF's notion of trace terms, and can be visualized with my coauthor's tool:

(This example interprets the story as a general directed graph (potentially with cycles), not a DAG, because it collapses the specific action instantiations into a single node. But the relevant structure of causal dependencies between actions can still be seen.)

What was interesting about this work to me was the way the concurrent structure of the trace term directly corresponded to the concurrent structure of the story. Even as a non interactive artifact, there is still an underlying intensional model of independent action among characters. This structure would be interesting to observe even for completely deterministic stories (i.e. those where characters always do the same thing and don't make choices). There is something like a choreography of character action that makes independent actions give rise to the global story.

To make this observation more concrete, consider the experimental theater piece Tamara. The play is set in the mansion of the Italian poet & historical figure Gabriele D'Annunzio, and the cast incorporates other artists and aristocrats as well as the servants of the household. The show is also performed in a mansion-shaped space, containing many and varied rooms. At the start of the show, audience members are instructed to pick a cast member to follow, and the cast disperses to different areas of the mansion to perform independent, concurrent scenes. When a character exits a room, each audience member may either follow them to the next scene they enter, or, if the room has any remaining characters, may stay and watch them perform the rest of the scene.

I have not managed to get my hands on a copy of the script (if anyone has any pointers for how to find or buy it, please let me know!), but if I were to reconstruct it myself, I would draw something looking very much like a CLF trace: each node is a scene; edges in are character entrances; edges out are character departures. (To be more precise, the scene node would need to be duplicated for every non-simultaneous entrance or departure.) The mechanics of actually synchronizing such an object so that the timing of scenes fits together is a separate issue, but one that could be analyzed atop the DAG abstraction.

So the next research question I have is: can one take the CLF trace corresponding to the Tamara script (or other "concurrent story") and have a computer "perform" it in a way that would give the player a (structurally) similar experience to an attendee of a live performance? In other words, permit the same interactions/choices afforded to the participants in Tamara?

My hypothesis is that the straightforward/na├»ve compilation of a CLF trace into Twine -- where the program DAG is literally interpreted as a passage graph -- would give such a reading. If the tuple of resources emitted by a rule application correspond to choices out of a passage, and those resources correspond to characters, then each potential choice will correspond to "following" (or remaining with) a character.

I'm hoping to test this hypothesis soon by writing such a compiler as part of #PROCJAM 2014!

Meanwhile, I have submitted a kind of related "concurrent storytelling" experiment (in collaboration with Vincent Zeng) to the 2014 IFComp.


Popular posts from this blog

Reading academic papers while having ADHD

Using Twine for Games Research (Part II)

Using Twine for Games Research (Part III)