# Curating Simulated Storyworlds — Chapter 5: Refining Emergent Narrative

> NOTE: THIS IS A MARKDOWN CONVERSION INTENDED FOR LLM CONSUMPTION.
> IF YOU ARE A HUMAN BEING, READ THE PDF INSTEAD:
> https://jamesryan.computer/papers/2018_ryan_curating_simulated_storyworlds.pdf
>
> The PDF is the canonical document, typeset with every figure and table. This file
> is a plain-text conversion of the LaTeX source, published HERE so that software agents
> can read the thesis without parsing a PDF. It is lossy and is not meant for humans.
>
> This file is chapter 5 of 14 only: Refining Emergent Narrative (~11,000 words).
> See below for links to markdown conversions of the individual chapters.
>
> **Structure.** Sections are `##`/`###`/`####` headings. Cross-references are resolved to
> their numbers ("Section 3.1.1", "Chapter 5"), so a heading can be searched for directly.
> Citations are inline bracketed keys such as `[ryan2017grimes]`; every key used in the text
> has an entry in the bibliography, formatted as `- **[key]** Author. Title. Venue, Year.`
> Footnotes appear inline as `[Note: ...]`.
>
> **Conversion limits.** Figures and most complex tables appear as `[Figure omitted]` or
> `[Table omitted]`. Code fences carry no language tag. A few diacritics in author names
> were simplified from the Latin-1 source.
>
> **All files.**
>
> Index (this list, plus the abstract; small): https://jamesryan.computer/thesis/index.md
> Whole thesis in one file (large, ~1.6 MB): https://jamesryan.computer/thesis/full.md
>
> By chapter:
> - 01. Introduction (~4,600 words, ~30 KB) — https://jamesryan.computer/thesis/01-introduction.md
> - 02. Defining Emergent Narrative (~6,900 words, ~47 KB) — https://jamesryan.computer/thesis/02-defining-emergent-narrative.md
> - 03. The Pleasure of Emergent Narrative (~21,000 words, ~135 KB) — https://jamesryan.computer/thesis/03-the-pleasure-of-emergent-narrative.md
> - 04. The Pain of Emergent Narrative (~41,000 words, ~268 KB) — https://jamesryan.computer/thesis/04-the-pain-of-emergent-narrative.md
> - 05. Refining Emergent Narrative (~11,000 words, ~73 KB) — https://jamesryan.computer/thesis/05-refining-emergent-narrative.md
> - 06. James Ryan Generator (~2,800 words, ~16 KB) — https://jamesryan.computer/thesis/06-james-ryan-generator.md
> - 07. World (~20,000 words, ~129 KB) — https://jamesryan.computer/thesis/07-world.md
> - 08. Case Study: Diol/Diel/Dial (~9,300 words, ~59 KB) — https://jamesryan.computer/thesis/08-case-study-diol-diel-dial.md
> - 09. Talk of the Town (~25,000 words, ~162 KB) — https://jamesryan.computer/thesis/09-talk-of-the-town.md
> - 10. Case Study: Bad News (~22,000 words, ~132 KB) — https://jamesryan.computer/thesis/10-case-study-bad-news.md
> - 11. Hennepin (~32,000 words, ~209 KB) — https://jamesryan.computer/thesis/11-hennepin.md
> - 12. Looking Ahead: Sheldon County (~11,000 words, ~75 KB) — https://jamesryan.computer/thesis/12-looking-ahead-sheldon-county.md
> - 13. Conclusion (~2,700 words, ~17 KB) — https://jamesryan.computer/thesis/13-conclusion.md
> - 14. Bibliography (~29,000 words, ~233 KB) — https://jamesryan.computer/thesis/14-bibliography.md

I will now present the crux of this dissertation, my framework for *curationist emergent narrative*. My aim in developing this framework has been simple: maintain the pleasure of emergent narrative (see Chapter 3) while simultaneously alleviating the pain (see Chapter 4). In meeting this goal, the framework takes an intellectual position, advocates for a particular technical approach, suggests a general architecture, and produces a series of additional concepts. In this chapter, I will discuss these concerns in turn before proceeding to situate the framework against the intellectual contexts in which it was developed. Because many of the pertinent concepts and arguments have been discussed at length in the preceding chapters, in this chapter I will be relatively concise.

## Intellectual Position

If we were to bifurcate the design space of procedural narrative, for our purposes here a convenient (though admittedly reductionist) policy would be to distinguish works that explicitly model a storyworld from ones that do not. [Note: I use the term ‘procedural narrative' as a catch-all for story generation, interactive storytelling, videogame narrative, and any other modality in which narrative obtains through the mechanism of automatic procedure (potentially, but not necessarily, incorporating interactivity). Note that this term is more general than ‘computational narrative', since it admits mechanical devices for story generation that precede the electronic digital computer.] In this way, one sector of the bifurcated space hosts early physical devices like *Movie-Writer* [blanchard1916movie] and *The Uranium Shipment and the Space Pirates* [moriarty2015sing], both of which were discussed in Section 4.1.2, as well as story grammars that operate only at the level of a story's surface text. Additionally, we would find here more technically involved efforts in story generation that focus specifically on language, such as *Pauline* [hovy1987thesis], *StoryBook* [callaway2002narrative], *Say Anything* [swanson2012say], and *Fabula Tales* [lukin2017generating]. These projects live in the first sector because they do not explicitly model a storyworld, even though the surface material generated by each system will suggest the presence of a storyworld in the same way that the words of print fiction suggest the backdrop of a larger world.

Residing on the other side of this divide, then, are the projects in procedural narrative that explicitly model storyworlds. Here, we find simulationist story generators like Sheldon Klein's murder-mystery generator [klein1971program,klein1973automatic] and *Tale-Spin* [meehan1976metanovel], as well as nearly all videogames that produce narrative, including examples like *The Sims* [maxis2000sims] and *Dwarf Fortress* [dwarf], but also *The Elder Scrolls V: Skyrim* [skyrim,murnane2018emergent], titles in the *Football Manager* series [reed2017changeful, pp. 218–219], and countless other examples. We also encounter in this sector a number of narrative games that have been produced in academic research contexts, including *Facade* [mateas2003faccade], *Prom Week* [mccoy2013prom], *Best Laid Plans* [ware2016intentionality], *Nothing For Dinner* [habonneau2012simulated,szilas2014nothing], *Emma's Journey* [summerville2017mechanics,summerville2018gemini], and *Bad News*, the subject of Chapter 10. All of these projects explicitly model a storyworld, and as such, this portion of the bifurcated design space coincides with the purview of this dissertation.

#### Emergentism versus Interventionism

Within the sector containing works of procedural narrative that explicitly model storyworlds, we might carry out another convenient bifurcation, this time corresponding to fundamentally distinct intellectual approaches to the relationship between storyworld and story: *emergentism* versus *interventionism*. More precisely, we should say that this delineation is not binary, but rather works according to a continuum whose dimension captures the degree of interventionist mechanism that is employed in a work. To explain, let us consider the distinction in terms of a classic design challenge in this genre of procedural narrative (again, projects in which a storyworld is explicitly modeled).

The emergentist approach works bottom-up by modeling storyworlds from which stories may *emerge*, through the happenstance of simulation. This method characterizes some of the earliest works in computational narrative—*Saga II* [morse1960saga], Sheldon Klein's murder-mystery generator [klein1973automatic], *Tale-Spin* [meehan1976metanovel]—and it is of course the hallmark of emergent narrative. As I argued at length in Chapter 3, the *pleasure* of emergent narrative is rooted primarily in its correspondences to the genre of nonfiction: when events emerge out of simulations, they feel like they really happen, and this unlocks the set of aesthetics that I outlined in Section 3.2. In turn, however, we experience a tandem *pain*: the commodity of storyworld simulation (raw emergent material) tends to lack story structure.

Given such a predicament, a potential remedy leaps out: *intervene* in the simulated storyworld to modulate the ongoing action such that it fits a model of story structure. This more top-down strategy characterizes several technical methods—author-centric story generation, drama management, plot-level narrative planning, and more—but I call the general scheme *interventionism*. Since Natalie Dehn's 1981 critique of *Tale-Spin*'s character-centric approach to story generation [dehn1981story], the interventionist scheme has predominated in the field. In the area of interactive storytelling, it has been in place at least since Brenda Laurel's 1986 dissertation proposed a “playwright” module that could drive experiences toward dramatically pleasing outcomes [laurel1986toward]. [Note: Even earlier, when she was working at the Atari Sunnyvale Research Lab in the early 1980s, Laurel wrote a series of company memos that represent early articulations of her ideas for “interactive fantasy” [laurel1982first,laurel1983interactivity,laurel1983notes]. A few years later, she compiled some of these papers in a form that she has made publicly available [laurel1989atari]. In one memo, Laurel and Eric A. Hulteen describe a planned experiment centered on a system called *Play-Right*, which was to adapt “portions of the design (if not the actual code)” of *Tale-Spin* [laurel1983media, p. 2]. Later, Laurel published an extensive report laying out details of the proposed system, which would apparently operate in a *CAVE*-like [cruz1992cave] media room at Atari [laurel1983toward].] The idea, again, is to intervene in (or just rig) the storyworld simulation so that story structure reliably obtains.

#### Killing the Pleasure with the Pain

While this remedy alleviates the pain of emergent narrative, it in turn kills the pleasure: when a simulated storyworld is modulated through the intervention of an external system—a model of creative writing, a drama manager, a plot-level narrative planner—it no longer works like nonfiction. By the interventionist pattern, events *spawn* according to the policies of a modulating system, which means they do not *emerge* out of the happenstance of simulation. They do not actually happen, and they do not feel like they actually happen. Thus, while interventionist outputs and experiences may be dramatically well-formed, they lack the distinctive aesthetics of emergent narrative that I outlined in Section 3.2. This does not mean that the interventionist approach is flawed, but rather that it is something altogether different from emergent narrative—it is not a remedy, since it kills the pleasure with the pain.

#### Desiderata for an Actual Remedy

An actual remedy for emergent narrative should maintain the pleasure while simultaneously alleviating the pain. It would remain fiercely emergentist, eschewing intervention, since the pleasure of emergent narrative depends on such inclinations. At the same time, however, it would produce story structure, since this alleviates the pain. As such, a remedy must follow a specific pattern: story structure emerges bottom-up, without intervention, in each simulation instance. If this were achieved, we could have our cake and eat it too.

This is the intellectual position that anchors my framework for curationist emergent narrative. It is fiercely emergentist, and thus strictly non-interventionist, because the aim is to have one's cake and eat it too. It is about maintaining the pleasure of emergent narrative while simultaneously alleviating the pain. It demands bottom-up story structure in every simulated storyworld. In the next section, I describe the technical approach, centered on a procedure of  *curation*, makes this position tenable.

#### To Be Clear

An earlier version of this thesis demarcated emergentism and interventionism in binary terms, to which my committee members rightly took umbrage. Clearly there is something more like a continuum at work, where the degree of intervention increases as emergentism gradually gives way to interventionism. Even this is misleading, however, or at least imprecise.

For one, it is probably not possible for a simulated storyworld to come to exist *except* through a kind of human artifice—such worlds are created and evolved by rules and other modeling details that result from human authoring. As such, it does not make sense to consider a complete lack of intervention—where a storyworld comes to exist and evolve on its own—and so a pure emergentism does not seem feasible. Furthermore, there are projects that are surprisingly difficult to place on this continuum. For example, when we discussed this issue, my coadvisor Michael Mateas raised the case of *Facade* [mateas2003faccade], which he co-created with Andrew Stern. While this project utilizes a well-known example of *drama management* [roberts2008survey], and while drama management is a clear example of storyworld intervention, Michael explained to me that the project's drama manager actually works in quite bottom-up fashion—so much so that ‘drama manager' might not be the most intuitive descriptor. [Note: Personal communication, July 26, 2018.]

In his feedback on my initial thesis draft, my other coadvisor Noah Wardrip-Fruin wrote, “it's ridiculous to think of the procedural script of Facade as an intervention in a simulation that would otherwise go on without it, or to think of the script as some kind of emergent simulation”. [Note: Personal communication, August 10, 2018.] To be clear, I am not suggesting that the simulated world would go on by itself, but rather I mean to argue that such reliance on external mechanism expresses an interventionist inclination: if a system's simulation breaks down without intervention, the project is probably not emergentist. Nonetheless, I understand and agree with the broader point that my reading committee expressed to me, which is that my emergentist–interventionist delineation suffers under consideration of technical specifics.

As such, some clarification is necessary. Like I noted at the beginning of this dissertation, what you are reading is at its heart an art manifesto. It promulgates a fiercely emergentist approach to procedural narrative as an expression of an aesthetic orientation, as opposed to a line of technical or even intellectual argumentation. As we move into Part II, I will begin reporting on a series of projects that were developed in the context of my technical and media practice. This practice and the curationist framework that underpins it make sense to me because of the way I look at the design space: for me, the degree of storyworld intervention *is* the central consideration in procedural narrative. While it may not be possible to build a purely emergentist system (because intervention is inevitable), I am still interested in developing projects that express an emergentist orientation and that target the peculiar aesthetics of emergent narrative that I outlined in Section 3.2. So, to be clear, my argument in this section is driven by an artistic inclination, more so than a technical or even intellectual stance. Even if no one else shares this inclination, I think it is important for me to explain it here, because it frames the various projects that are the core contributions of the second half of this dissertation.

## Technical Approach

Let us return to the design challenge that I raised in the previous section: how can we can ensure that story structure reliably emerges across all the generable storyworlds of a simulation engine? [Note: Readers who have read the earlier chapters of thesis will already have a sense as to how I answer this question. Nonetheless, I will reiterate the core ideas again here, since this chapter is intended to serve as a kernel for this dissertation.]

#### *Dwarf Fortress 's Narrative Cornucopias*
For a clue, let us look to an example of successful emergent narrative: *Dwarf Fortress* [dwarf]. Tarn Adams is an emergentist—he eschews interventionist measures—but nonetheless we know from examples like *Oilfurnace*, the case study of Section 3.1.1, that story structure can still obtain in his storyworlds. Moreover, the abundance of published accounts of emergent stories [dfstories] suggest that story structure *tends* to emerge in *Dwarf Fortress*. Why does story structure tend to emerge here, but not in, say, *Tale-Spin*? [Note: Of course, story structure can emerge in *Tale-Spin*, but typically this is the result of a human author rigging the system in a particular way, as Jim Meehan explains in his dissertation: “we may or may not get a story by simply watching the simulator run. How do you make it interesting? You fix it in advance. You rig the world so that if people behave rationally, they'll do some interesting things” [meehan1976metanovel, p. 108]. As such, Meehan's approach positions him toward the interventionist side of things, though his system is sometimes viewed as an example of the failure of emergent narrative. In any event, when I claim that story structure tends not to emerge in *Tale-Spin*, I mean so with regard to the space of possible storyworlds that it can generate: while authors may rig initial conditions to select a more narratively interesting world from this space, most instances lack such intrigue. This is not the case with *Dwarf Fortress*.] The answer is simple: the *Dwarf Fortress* simulation is far more complex—several orders of magnitude more complex. As such, the narrative potential of a *Dwarf Fortress* storyworld is much higher than that of a typical *Tale-Spin* world. Moreover, its simulation is so complex, and its narrative potential so immense, that it would actually be surprising if story structure did *not* emerge in a given simulation instance.

Thus, we might characterize Tarn Adams's method for ensuring the emergence of story structure as following a broad technical strategy: generate such an abundance of fertile simulated material that story structure is essentially *guaranteed* to be supplied in the accumulation. This strategy entails the simulation of massive storyworlds that have many characters doing many things over extended periods of story time. As such, this *cornucopian* approach to simulation differs fundamentally from *Tale-Spin*'s: *Tale-Spin* simulates a story, while *Dwarf Fortress* simulates a world, in all its overabundance. While Meehan crosses his fingers in the hopes that a simulation trace will itself constitute a well-formed story, Adams rests assured that many good stories are lodged in his system's material. [Note: This critique is unfair to Meehan, since the hardware limitations of his day would have precluded this massively simulationist approach, even had he been so inclined.] Indeed, the myriad goings-on of a *Dwarf Fortress* storyworld are not intended as a story, but instead as an *accumulation containing many stories*. As such, stories are repositioned as the *byproduct* of simulation, rather than its sole manufacture.

#### But Now Curation Is Necessary

While Tarn Adams's cornucopian approach to simulation may ensure (without resorting to interventionism) that interesting stories always emerge, it raises a major challenge concomitantly: how can such stories be discerned amid the backdrop of boring simulated material? Indeed, if the plenitude is not a story, but rather an accumulation that contains many stories, then an additional step is required for humans to encounter or experience the stories: *curation*. By ‘curation', I mean a process by which some entity sifts through the accumulation to identify narratively interesting material, which that entity then assembles into the shape of a story. In the case of *Dwarf Fortress*, humans are clearly encountering emergent stories, which begs the question: who is doing the curation? The answer, in this case, is humans. Human players are curating *Dwarf Fortress*'s simulated storyworlds, either through a basic mode of mental narrativization, where the ongoing experience of gameplay is understood as a kind of story, or through a more elaborate construction of second-order media artifacts that are meant for consumption by others—this is what *Oilfurnace* is.

[Figure omitted]

#### Automatic Curation

What if a computer program could curate? This would enable a simulation to sift through its own material to excavate stories for human encounter, or even to discern partial stories that are in the process of emerging. Such a capacity would constitute a kind of computationalization of the mental processes that enable human players to recognize stories that emerge during gameplay. In turn, we may consider a prospect that is potentially more powerful: systems that computationalize the kind of curation procedure that Tim Denee carried out to create *Oilfurnace*; Figure 5.1 suggests this prospect in relation to an existing project. This would enable the automatic construction of full-fledged media experiences that recount the emergent happenings of simulated storyworlds. [Note: It would be an interesting challenge to attempt to specifically operationalize Tim Denee's curationist practice. There is a growing body of work on generating comics and other *sequential art* [eisner1985comics], which could provide a head start in terms of technical approach [perezyperez2007computer,alvarez2007grammar,lee2011exploiting,perezyperez2012illustrating,martens2016generating,martens2016discourse,cardona2016plotshot,olsen2017narrative,radiano2018story].]

#### Overgenerate and Curate

This is my vision for curationist emergent narrative, and in describing it I have suggested the essentials of the technical approach that underpins it, which I capture in a tagline: *overgenerate and curate*. In natural language processing, the phrase ‘overgenerate and rank' is associated with a technique whereby many candidate outputs (or parses) are generated and ranked, before a top-scoring one is ultimately selected. [Note: The technique seems to be attributed to three roughly contemporaneous papers: a 1998 paper on generation by Irene Langkilde and Kevin Knight, a 2000 paper on parsing by Michael Collins [collins2000discriminative], and a 2001 paper on generation by Marilyn Walker and collaborators [walker2001spot]. In linguistics, the notion of overgeneration refers to cases where a grammar (such as the rules for word formation in a natural language [halle1973prolegomena]) is capable of producing unattested constructions—such a grammar *overgenerates*. As a basic concept in generative grammar, the concept dates at least to Paini's ancient model [katre1989astadhyayi]. To my knowledge, the notion in linguistics of ranking candidate constructions is most associated with *Optimality Theory* [prince1993optimality], which is a model of linguistic production as a procedure that optimizes over competing constraints.] In the case of the kind of cornucopian emergent narrative that is employed in *Dwarf Fortress*, a simulation overgenerates causal sequences, nearly all of which will be non-stories or boring stories, but through a process of curation the interesting causal sequences may be identified. Critically, the curation process is not simply one of ranking, hence my modification to the ‘overgenerate and rank' tagline. That is, by ‘curation' I do not mean the mere *selection* of a subset of the material generated by a simulation, but instead I intend to imply a more constructive procedure of which selection is only one phase. To illustrate the distinction, I will rely on two analogous procedures: curation in cultural institutions and Hayden White's model of historiography.

The canonical sense of ‘curation' is the work done by a curator at a cultural institution—say, an art gallery—in preparing a collection for exhibition. Certainly there is a critical step in this process that entails the selection of a subset of the works in the collection that will actually be exhibited, but this alone is not curation. The result of this process is a set of items, not an exhibit. To build an exhibit, the curator must also reason about *presentation*, with all its considerations of spacing, timing, framing, priming, aesthetic details, and so forth. Furthermore, because the art exhibition is itself a cultural form [alberro2009institutional], the curator engages in the established practices of that form: she builds her exhibit so that it looks and works like an exhibit—her design considerations are informed by the history of that cultural form and perhaps current trends too. If she decides to innovate, that innovation is *relative* to the established practice and its history. It is this highly constructive sense of curation that I seek to harness for my purposes here. As such, this technique does not entail the mere selection of a subset of simulated material, but the curation of that material by a procedure that results in a considered narrative artifact, which it itself mounted into a full-fledged media experience.

By now I have alluded several times to Hayden White's model of historiography, which I first introduced in Section 3.1.1. In pursuit of a *strange loop* [hofstadter1980godel], I will quote my earlier explanation and make this dissertation cite itself: [Note: I recently encountered this device in a 1995 paper: “[Elliott and Melchior, 1995] Clark Elliott and Ernst Melchior. Getting to the point: Emotion as a necessary and sufficient element of story construction. In AAAI Technical Report for the Spring Symposium on Interactive Story Systems, Stanford University, March 1995. AAAI, American Association for Artificial Intelligence. THIS PAPER.” [elliott1995getting, p. 4].]

> First, the subject phenomena are captured, as they are transpiring, in a *chronicle* that records them by some method of inscription. While the chronicle itself is the result of a kind of curation, since it will never perfectly capture the subject phenomena (inscription is lossy), it is, for the historian's purposes, the raw historical record. That is, because it is the only documentation of the subject phenomena, it contains the only material that the historian may use to construct her account of that phenomena (though she of course may augment this, or adulterate it, with extraneous material). The chronicle is open-ended, with no narrative beginning (but rather the unceremonious onset of a process of recording that produced the record) and no narrative end (but instead an unceremonious termination of that recording process). From this chronicle, the historian crafts a *story*. This process entails the selection of a subset of the chronicled events, which may then be used to construct a discernible narrative structure in which some of selected events actuate *motifs*: *inaugural motifs* cue meaningful causal sequences that will culminate eventually with *terminating motifs*, and along the way *transitional motifs* signal abeyance in the causal sequence. Finally, the story is embedded in a particular *emplotment*—e.g., tragedy or comedy—which unlocks a set of rhetorical effects that support a targeted ideological stance. [ryan2018curating, p. ]

White's model is the blueprint for curationist emergent narrative—by analogy to the former, we may conceptualize the latter. First, what I call (in that quotation) the ‘subject phenomena', White more specifically calls the *historical field*. In curationist emergent narrative, the external reality of White's model becomes the simulated storyworld, and his historical field becomes the narratable phenomena that transpire in the course of a simulation instance. Just as a chronicle serves as a record of the historical field, a system may record data about what has happened in the simulation so far. This inscription will likely be lossy in both cases, since memory constraints make it infeasible to maintain a perfect record of a simulation. Because anything that is not recorded disappears, as in the real world, this data store contains all the material that may be used in the construction of a story, which brings us to the next step.

As White explains, creating a story entails the selection of material recorded in the chronicle, particularly such that a set of narrational motifs may be actuated—this is a Whitean notion of story structure, but of course any narratological formalism could be operationalized in this step. The point is that the data itself is a not story, but rather a structured accumulation of material that may be used to construct an actual story. [Note: Here, perhaps surprisingly or perhaps not, we find in White's ideas an essential critique of *Tale-Spin*'s approach: it calls a raw simulation trace, with no actuated motifs, a story. Just as a chronicle is not an historical account, a simulation trace is not a story.] Finally, since the rhetorical considerations of emergent narrative are not as charged as those of historical writing, White's notion of emplotment does not connect so strongly. Nonetheless, it is important to acknowledge that there is an additional phase in story crafting beyond the assembly of selected content into a narrative structure—thus, we might view ‘emplotment' as referring in a general way to this phase. Moreover, as I discussed at length in Section 4.2.5, in curationist emergent narrative constructing a narrative artifact is not enough. Practitioners of procedural narrative do not aim merely to build artifacts, but moreover to produce experiences. I believe that curated stories should be *mounted* in full-fledged media experiences, and in the next section I discuss some possible mounting configurations.

And so we have found our remedy: by producing massive storyworlds that constitute narrative cornucopias, emergent story structure can be guaranteed, but it is only through a procedure of curation that such structure may actually be identified—or more precisely, constituted. Thus, unsurprisingly, curationist emergent narrative does not circumvent the hard truth of interventionism: it takes work to maintain story structure. Critically, however, this framework provides a way to do this work without actually intervening in the storyworld, and as such it maintains the pleasure of emergent narrative while simultaneously alleviating the pain. This was my criterion for a remedy.

#### Appropriating Interventionist Methods for Curation

Intriguingly, all the knowledge engineering (about what makes a good story) that drives the interventionist scheme may be adapted to this emergentist approach. For example, a policy by which a drama manager fits ongoing action to a targeted dramatic arc may be converted into a *curation* policy that enables a system to assemble simulated material into the desired arc. In each case, the system reasons about how story units (e.g., quantized beats or simulated events) may be sequenced to compose dramatic arcs, but in curation the task of deciding what comes next is recast as search in a space of *observed* sequences. Likewise, the machinery of narrative planning could be utilized, but instead of planning operators that may be executed to *invent* actions, the planner reasons over operators that match against observed actions (ones that actually occurred in the storyworld). Even author-centric story generation could be employed: the task of story invention would be recast as one of story recounting, with the automatic storyteller utilizing a model of creative writing to tell stories about what has actually happened in a simulated storyworld.

Indeed, by recasting intervention policies as curation policies, *all* of the craft of interventionist procedural narrative may be appropriated for curationist emergent narrative. A corollary here is that automatic curation will require human creators to inscribe just as much story knowledge as before, but critically these authored story patterns do not modulate the storyworld itself, but rather the recounting of that world. This is the only difference between interventionist procedural narrative and curationist emergent narrative, and it is thus the hallmark of the latter. Thus, while foregoing intervention does not make the work any easier, it does afford an approach that stays true to the emergentist artistic orientation. As I have noted several times by now, developing such an approach is the core aim of this thesis.

#### How It Worked All Along

Lastly, I contend that this framework is actually an account of how successful examples of emergent narrative have worked all along: a simulation guarantees narrative intrigue in each of its generable storyworlds, and in turn humans willingly do the curation that is required to make emergent stories experienceable. In addition to explicitly identifying this pattern (about which more soon), a contribution of this dissertation is to postulate its computationalization, whereby curation happens automatically.

## Curationist Architecture

The technical approach that I have outlined in the previous section suggests a general architecture for curationist emergent narrative, with two essential variants: in a *feedforward* curation architecture, constructed stories are mounted in second-order media experiences, while in a *feedback* architecture, they are mounted back into the simulated storyworld itself; Figure 5.2 illustrates both of these variants. I call this a ‘general architecture' because individual implementations may vary considerably, and moreover because these modules do not necessarily have to be disentangled computer programs (or even computer programs at all)—instead, I mean to demarcate conceptually distinct bundles of functionality.

[Figure omitted]

#### Human Components

Before introducing the discrete components that work together to constitute this architecture, I would like to note that it does not necessarily have to take the form of a purely computational system. Indeed, as I have noted above, I maintain that this architecture actually explains how successful works of emergent narrative, such as *The Sims* and *Dwarf Fortress*, have worked all along: humans do the curation. As such, each module in this architecture may be human-powered, purely computational, or driven by a hybrid combination somewhere in the middle.

In a recent paper, Ben Samuel, Adam Summerville, and I explored this idea in the context of *computationally assisted performance* [samuel2016computatrum]. Our process was to identify a series of roles underpinning both computational and noncomputational experiences (e.g., a *Hamlet* actor, a *Dungeons & Dragons* dungeon master, *Facade*'s drama manager) and then characterize each according to the degree to which it is: a performer of the experience, a consumer of the experience, computationally assisted, and endowed with agency. In positioning roles according to these four dimensions, we identified a series of tropes and some unexplored areas of design space, such as the development of games for AI consumption. For our purposes here, I would like to emphasize that the modules in this architecture may be human-powered, purely computational, or hybrid. Further, as I have stated above, in this dissertation I intend not only to characterize existing works of curationist emergent narrative according to this architecture, but to raise the challenge of building experiences in which conventionally human-powered modules are computationalized. [Note: That being said, I am very curious about the prospect of doing the inverse: turning conventionally computational modules into human-powered (or hybrid) ones. I will discuss some ideas for this later on.]

### Components

Without further ado, what follows are the individual components that make up the general architecture for curationist emergent narrative. Again, this architecture is illustrated in Figure 5.2.

#### Experiencer

An *experiencer* is an entity who encounters, and optionally provides inputs to, a media experience. As I explain below, this experience may be a first-order one, meaning the simulated storyworld is itself encountered, or a second-order one in which simulated happenings are curated as narrative artifacts that are then mounted in an experience that is decoupled from the simulation. This component is the one most likely to be human-powered, though recent proposals have advanced the notion of developing media experiences for AI consumption—for instance, a role-playing game that a human develops for an AI to play [samuel2016computatrum,osborn2017rpg]. In the case of curationist emergent narrative, I could imagine a human who is experiencing a simulation as a situated player character telling stories about simulated events to non-player characters who also live in the simulation.

#### Simulated Storyworld

A *simulated storyworld* contains the characters and events that an emergent narrative may recount. Conceptually, this module works like Hayden White's ‘historical field': it is the world itself, not a record of that world. Architecturally, it is a simulation engine, though that may be entangled in the larger software ecosystem of an interactive experience. This module may seem the least amenable to human control, but there is a classical example: in tabletop roleplaying games, the storyworld is driven by a hybrid entity constituted in a human operator who administers the game's systems by which the world may be constituted.

#### Chronicler

The *chronicler* is a module that is tasked with recording the emergent phenomena that transpires over the course of a simulation instance. In Hayden White's model, it is implied to be a human who maintains a physical annal or chronicle, though in the real world there are also natural mechanisms that do this—for example, tree rings are a kind of chronicle. In a curationist architecture, this module may be human-powered, purely computational, or hybrid.

#### Chronicle

A *chronicle* is not a module, but rather a bundle of data. In a computational context, this may be constituted in data stored in memory or in a disk file, while in the case of human operation, the chronicle may obtain nebulously in a person's mind (about which more soon) or it may be recorded using analogue inscription technologies (e.g., written notes). As such, the chronicle is not necessarily contained in a single discrete record, but may be distributed across multiple records stored via multiple modalities. [Note: To be clear, by ‘record' I do not mean ‘database record' or anything else so specific, or so specifically digital, but rather an instance of any kind of storage medium, physical or otherwise.]

#### Story Sifter

The *story sifter* is a module that sifts through the accumulated simulated material captured in a chronicle to excavate raw narrative material out of which an actual story may be constructed. This component is the heart of the architecture, and the disregard for it in most works of emergent narrative to date is the impetus for this dissertation. In nearly all cases, this module has been human-powered—typically, its duties are carried out through a player's unconscious narrativization of an ongoing simulated experience—but I am calling for *automatic* story sifting.

To sift, this module must make use of policies that encode knowledge about what material makes for narratively potent material. Here, I differentiate between *sifting patterns* and *sifting heuristics*: the former pattern-match against the material recorded in a chronicle, while the latter encode abstract policies that may guide the sifting process. An example of a sifting pattern is a regular expression (encoding an abstraction of a type of storyline) that may be used to retrieve matching event sequences recorded in a chronicle. As for sifting heuristics, I could imagine a system that utilizes them working like Doug Lenat's system *AM* [lenat1976artificial], which carries out heuristic exploration to automatically discover interesting or aesthetically pleasing mathematical concepts. In Chapter 11 I provide a detailed example of how these policies might be formulated.

Per my discussion in the last section, these methods may adapt all of the authored knowledge that is typically encoded in policies for story intervention or techniques for story invention. Indeed, story sifting is a full-fledged application area for which a multitude of methodologies could be developed. As I note below, in previous work I have referred to this module as the ‘story recognizer' [antoun2015generating,ryan2015open], but under the influence of Hayden White (who showed that stories are not already constituted in a chronicle) I now prefer the term ‘story sifter'.

#### Material

The *material* excavated by the story sifter is another bundle of data, but critically it is a subset of the data included in the chronicle. It is the *stuff* of an emergent story, but it may also encompass material that will ultimately be extraneous (with regard to what is actually recounted in the constructed story). As I discussed in Section 4.2.3, this material may be highly structured—for example, a system's story sifter could build *story intention graphs* [elson2012modeling] that encode rich metadata about the relation between simulated events and other narratological concerns. The ultimate purpose of this material is to make it feasible for the narrativizer to build an interesting story.

#### Narrativizer

The *narrativizer* module constructs an actual narrative artifact out of the material produced by the story sifter. This task is as broad as it sounds, since it entails all of the work that is carried out in the application area of story generation. The difference between the narrativizer and a conventional story generator is that the latter *invents* stories, while a narrativizer *recounts* stories. Though it is currently obscure, the term ‘narrativization' has a fairly long history in the humanities [white1981narrativization,paul1985narrativization] and a technical sense of the term (building stories that recount data) is emerging in computational narrative [barot2017bardic,zampolli2017verb,zampolli2017grammar].

#### Story

The narrativizer produces a *story*, by which I broadly mean a completed narrative artifact. Here, I use such a general term in an effort to be ecumenical—the story could take the form of prose, speech audio, a comic, or even something that is itself highly procedural, such as a videogame quest or a work of choice-based interactive fiction. Just as the narrativizer appropriates all of the methodology of story generation, and thereby all the craft of storytelling, the notion of ‘story' in the curationist architecture encompasses all possible narrative forms. [Note: To be clear, I do not mean to abscond from the duty of explicitly defining a specific notion of ‘story'. As Hartmut Koenitz has argued, projects in computational narrative have tended to suffer from such vagueness [koenitz2017interactive]. Rather, I am being vague here (ecumenical, really), since I think it is critical to pin down such definitions at the project level, rather than at the level of a general scheme for procedural narrative, which is what I am articulating here. As such, I advocate setting such definitions as part of the act of grounding out this general architecture in a specific project-level implementation.]

#### Media Experience

A *media experience* is a full-fledged media work that may be experienced by an experiencer. As I have now stated several times, and particularly in Section 4.2.5, it is not enough to generate a narrative artifact—for curation to culminate, that artifact must be mounted in a media experience.

Here, *Saga II* [morse1960saga], which I discussed in Section 4.1.2, provides an illustrative example (see Figure 5.3). In this project, a raw script that is printed out by the TX-0 computer is what I am calling a chronicle, but critically the creators do not stop there and call that a final product. Instead, they use this raw printout to construct a shooting script—this is an act of curation that produces what I am calling a story. Still, however, the job is not done. As a final phase of curation, the creators produce a television program from the shooting script, thereby *mounting* the story into a full-fledged media experience. While this emphasis on curation is rooted in the peculiar impetus for the project—a collaboration between CBS-TV and MIT—it is remarkable nonetheless. I view *Saga II* as a shining example of curationist emergent narrative, though it would of course be even more impressive if the television program were itself automatically generated. [Note: It would be an interesting experiment to computationalize the entire *Saga II* curation pipeline—this would likely require *generative choreography* [birringer2006saira,antunes2012generative,crnkovic2016generative] and *generative machinima* [elson2007lightweight,munilla2009zuzen,jhala2011intelligent]. Liza Daly's *Saga III* [daly2018saga], a playful reimplementation of *Saga II*, could serve as a starting point.]

[Figure omitted]

As I will explain in more detail momentarily, the simulated storyworld may itself be a media experience—whether it is a full-fledged one depends simply on whether or not it may be experienced by an experiencer. In the context of curationist emergent narrative, the simulated storyworld (if it can be experienced) is a *first-order media experience*. If the generated narrative artifact is then mounted into an experience that is decoupled from the simulated storyworld, it has been mounted into a *second-order media experience*. As the project's sole technical memorandum [morse1960saga] explains, the *Saga II* simulation did in fact have an interface that would allow an experiencer to modify the simulation rules. Given this, I would call the interactive simulation program a first-order media experience and the produced television scenes second-order ones. In that case, the experience in which curated narrative artifacts are mounted is not interactive, but of course it as also possible to mount into interactive experiences. This distinction is expressed by the optional arrows on the experiencer nodes shown in Figure 5.2.

### Variants

Now that I have introduced these components, in this section I will explain how the two variants of this architecture are distinguished. Additionally, I will argue that an additional variant of the architecture accounts for how successful projects in emergent narrative have worked all along.

#### Feedforward Curation

By *feedforward curation*, a generated narrative artifact is mounted into a *second-order media experience*. In this way, the procedure feeds forward, curating material that is generated by a simulated storyworld for eventual presentation in a media experience that is decoupled from that simulation framework. An example of this is *Saga II*'s curation procedure, whereby events that emerged in a simulated storyworld (the modeled wild-west hideout) are recounted in an altogether separate media experience (a live-action television program).

#### Feedback Curation

By *feedback curation*, a generated narrative artifact is mounted back into the simulated storyworld itself. To my knowledge, there has been little exploration of this mode of curation, but one prospective example has been identified by scholar Marcus Carter in terms of what he calls ‘emitext' (portmanteau of ‘emergent' and ‘paratext'): “a form of paratext that emerges from within the game as part of play, rather than a peripheral industry that surrounds it” [carter2015emitexts, p. 311]. In curationist terms, this notion corresponds nicely to curated stories that are mounted in second-order experiences—for instance, the previously discussed *Oilfurnace*—but there is also another prospect that matches the feedback pattern. In his paper, Carter specifically identifies player-constructed propaganda in *EVE Online* [carter2016internet], and such emitext can of course be presented to players during gameplay itself. When the propaganda is fed back into the storyworld in this way (to influence future emergence), feedback curation is at work.

Another example of this would be a videogame in which non-player characters automatically process the ongoing simulation to construct stories about what has happened so far. One interesting prospect for feedback curation is the emergence of stories about emergent stories—for example, a character's act of telling a story recounting emergent events could itself function as a critical event in a subsequent (higher-order) emergent story. This might termed *meta-emergent narrative*. [Note: Arthur Danto has evocatively suggested that historiography might be a necessarily cybernetic task: “the historian must make some more history before he can write some history, a distressingly sisyphian labor” [danto1962narrative, p. 153].]

I would like to clear up one potential concern. In Section 4.2.1, I identified a ubiquitous misconception by which the mere transpiring of simulation is believed to constitute emergent narrative, but now I am articulating a mode of curation whereby generated narrative artifacts are mounted back into a simulated storyworld. Is this the same phenomenon? No, these are not equivalent phenomena, for a simple reason: when the mere transpiring of simulation is treated as emergent narrative, the procedure of curation is circumvented, while in the case of feedback curation it is in fact the central concern.

[Figure omitted]

#### Mental Curation

The curationist architecture can also account for how successful examples of emergent narrative have tended to work all along. By the pattern of *mental curation*, illustrated in Figure 5.4, the curated story obtains in the mind of a human experiencer. [Note: In his comments on an earlier draft of this thesis, Noah Wardrip-Fruin asked, “In the mental curation diagram, shouldn't a bunch of those boxes move inside the experiencer box?” (personal communication, July 9, 2018). The answer is yes, that would be more precise, but the result would probably be hard to decipher and would not match the visual pattern of the earlier curationist architectural diagrams. In the later chapters, I will provide diagrams for each of my reported media experiences that show which architectural variant is instantiated in the project. In the case of *Diol/Diel/Dial*, mental curation is at work, and so I adapt this diagram (as Figure 8.5) to make it clear that, in that project, the experiencer is doing the work of the story sifter and narrativizer. Hopefully, if only in that case, the diagram is clear enough.] As such, the various curation operations that are associated with the chronicler, story sifter, and narrativizer modules are carried out by that human experiencer, likely as unconscious mental processes—that is, the experiencer cannot help but mentally narrate the events of a simulation as they are transpiring, or afterwards through reflection, and this narration procedure is an act of mental curation. [Note: In his recent dissertation on player-curated accounts of *The Elder Scrolls V: Skyrim* [skyrim] gameplay, Eric Murnane argues that emergent narrative can *only* obtain through a distanced postmortem reflection: “There is a narrative that occurs only when we are not playing the game. [...] There is the story that the game is telling and the blow by blow of what the player does. However, when the player has a bit of time to reflect, they start to make connections. The beginning of emergent narrative is the surprise. Something happens in the game that reminds them that it is a game. The player's suspension of disbelief is just shaken enough that the immersion is broken. Players can either reject the narrative outright when this happens, or (more interestingly), they can reflect on the event and contextualize it. If they take the latter route, suddenly all manner of things fall into place” [murnane2018emergent, pp. 180–181]. I personally think that narration can occur in the moment, though certainly there is some latency, and in any event the most coherent stories will obtain through a more prolonged process of curation. Moreover, storytelling is typically predicated on its recounted events having already culminated (in an actual world or in an author's mind), and this requires a postmortem vantage; Arthur Danto's *narrative sentences* [danto1962narrative], discussed above, exemplify this idea. In finishing his thought, Murnane aptly identifies the cocreative nature of what I would call human-powered curationist emergent narrative: “I posit that the reason players do this is because they recognize that this surprise event is special. It is not what the developers intended; they are off the beaten path. When they make sense of the events in the game, they are becoming the coauthor. They are no longer receivers of media, they are cocreators” [murnane2018emergent, p. 181]. Such cocreation is the crux of Ben Samuel's notion of *shared authorship*, which is the subject of his recent dissertation [samuel2016crafting].] As such, mental curation may be viewed as a kind of degenerate variant of the curationist architecture. [Note: Here, I mean to use the technical sense of the word ‘degenerate', which is to say that the curationist architecture is not fully instantiated in experiences that follow the pattern of mental curation. To be clear, I am not contending that such experiences are inferior in any objective sense, but rather that they do not demonstrate the particular architecture that I am promulgating with this dissertation.]

To be clear, I am not equating human curation with mental curation—the latter specifically occurs when a curated story obtains only in the mind of a human experiencer. It is also possible for a human to curate an external narrative artifact that may be mounted in an actual media experience, whereas it is probably not worth considering mental life to be a kind of media experience. When mounting is carried out, either feedforward or feedback curation is instantiated. For example, *Oilfurnace* was produced by feedforward curation, whereas human-powered feedback curation characterizes the phenomenon of *EVE Online* propaganda being mounted in the game's storyworld itself. Indeed, the prospects for human-powered curation are exciting, though so too are those of automatic curation. I advocate both, but in the context of a thesis in computational media, I will tend to emphasize the latter.

## Additional Concepts

In this section, I will outline a few additional concepts that are pertinent to the curationist approach. Most of these have already been introduced and discussed in earlier parts of this dissertation, but I am including them here in an effort to develop a handy glossary of sorts. Readers may wish to consult this section if any of these concepts become hazy by the time they are discussed again later on.

#### Cornucopian Simulation

A *cornucopian simulation* is one that reliably produces storyworlds that teem with narrative potential. While the failure of emergent narrative to date has largely been rooted in a lack of story structure, this pain dissipates when every simulation instance generates narrative intrigue. In this regard, *Dwarf Fortress* is a paragon—each of its storyworlds is a narrative cornucopia, and this is because Tarn Adams is the consummate simulation author.

#### Bad Runs

In curationist emergent narrative, *bad runs*—simulation instances that do not produce narrative intrigue—are recast as authoring errors. This is a corollary of the emphasis on cornucopian simulation. While bad runs have conventionally been viewed as an essentially unavoidable pitfall of emergent narrative, in this framework it is the responsibility of an author to craft a simulation whose every instance bursts with narrative potential.  If a simulation struggles to generate narrative potential, its author should consider adding more breadth (characters, entities, story time) and depth (complexity, richness, intrigue) to its modeling.

#### Contingent Unlocking

As I explained in Section 4.1.6, *contingent unlocking* is a technical approach to character simulation whereby emergent events may contingently unlock subsequent events. For example, in Sheldon Klein's murder-mystery generator [klein1971program,klein1973automatic], two characters who emergently flirt unlock the affordance of a subsequent emergent tryst, which in turn unlocks pockets of the action space that pertain to the emergent murder scene. More typically, character simulations make events dependent on aspects of the world state, but this can lead to an overly realistic notion of causality (where an event's causality is distributed across essentially everything that has happened so far). Stories tend to cue clear causal relations between events, and when contingent unlocking is utilized, event structures may emerge that resemble the causal structures that are actually found in stories. I call the former *emergent contingency structures*, and contingent unlocking may be used to generate them and also to facilitate their identification later on, by enabling a task that I call *causal bookkeeping*. (These related concepts are reintroduced below.)

To be clear, contingent unlocking is not the only way to produce this kind of causal structure. I write about it in this thesis because it is a method that I have found to be useful in my own simulation practice (as I recount in Part II), and one that I find to be particularly compatible with the emergentist inclination, since it can guarantee that narratable event sequences will exist in a possibility space without enforcing their generation at any time. Moreover, while I will discuss a particular method of contingent unlocking that is employed in *Hennepin*, there are many possible implementations.

#### Causal Bookkeeping

{Discussed at length in Section 4.1.6, *causal bookkeeping* is a technique whereby causal relations among emergent events are tracked by the system as they occur. This task is facilitated by contingent unlocking: whenever an event emerges by virtue of being contingently unlocked by an earlier event, the system records a causal relation between the two events. While a story is more than a sequence of temporally and causally related events, the tasks of story sifting and narrativization are greatly facilitated when this kind of information can be known upfront, rather than inferred later on. To be clear, here I mean to refer to a particular kind of causality (which features heavily in narrative): the *contingency* event relation, as identified by narratologist Mark Alan Powell [powell1990narrative, p. 40], whereby an event is caused by one or a few earlier events (and the connection is explicit and legible). As the following chapters will show, the evolution of my simulation practice over three engines has been marked by the development of increasingly better mechanisms for causal bookkeeping. Due to the nature of simulation, I view temporal bookkeeping as a trivial task, but it is of course just as important to keep track of when events occurred relative to one another.}

#### Emergent Contingency Structure

An *emergent contingency structure* is an event sequence that emerges out of a simulation and exhibits the kind of explicit and narrow causal structures that one finds in narrative, as opposed to the massively branching structures that characterize how causality actually works in the real world and in simulations. This concept was discussed at length in Section 4.1.6.

Critically, an emergent contingency structure is built only according to *contingency* relations between events, which I have just mentioned. With causal bookkeeping in place, the identification of an emergent contingency structure is a simple matter of retrieval that works by operating over recorded causal relations between events. To be clear, an edge in such a sequence does not represent an event contingently unlocking another kind of event, but moreover a case of an instance of the latter event actually emerging by virtue of the unlocking. That is, contingent unlocking enables the emergence of a subsequent event, but does not guarantee that happening.

Rather than a linear sequence, an emergent contingency structure will likely be a directed acyclic graph with a small branching factor—this is because an event may contingently cause multiple later events or be contingently caused by multiple earlier events (working in tandem). [Note: These graphs are acyclic because an event cannot cause itself, but in certain cases a cycle might actually obtain. For example, in a plot featuring time travel, an event could paradoxically cause itself, and this would be represented by a cycle in the graph.] Briefly, I would like to emphasize that the bottom-up generation of emergent contingency structures does not work like the top-down authoring of branching plot graphs, even though both kinds of structures may take a similar shape. When an emergent contingency structure obtains, it is due to the component events actually emerging in a simulation. Antithetically to this, the branching structure of an authored plot graph obtains through human invention. As such, the former phenomenon works like nonfiction, while the latter works like fiction.

Finally, I would like to emphasize that the emergence of (semi)linear event structure does not preclude the designator ‘emergent narrative'. Emergentism is not dependent on a lack of recognizable structure, but rather such lacking has been a symptom of deficient simulation methods that have unfortunately come to characterize the approach of emergent narrative. All stories have discernible causal structure—that thing we call ‘plot'—the production of which should be the aim for *all* approaches to procedural narrative, including emergentist ones. [Note: To be clear, not all *literary works* have discernible causal structure, but I think it is fair to say that all *stories* do. I love William S. Burroughs more than the next person, but this predilection does not lead me to view any old emergentist welter as compelling experimental literature. One *could* attempt to construct a Burroughsian simulation whose traces might be imbued with a Burroughsian quality, but this would be a monumental design challenge that would require deep consideration and conscious effort extending far beyond the mere crafting of an emergent possibility space. In fact, my friend Joe Krall and I planned to take on such a project—more specifically, a *cut-up* [burroughs1961cut] massively multiplayer online game—but tragically he was killed in an accident.]

#### Sifting Pattern

A *sifting pattern* specifies an abstract protonarrative pattern that a story sifter may use to excavate material in a chronicle that matches the pattern. For instance, one could author regular expressions that do this. In a 2015 paper [osborn2015playspecs], Joe Osborn and collaborators applied his *Playspecs* tool [osborn2018operationalizing, pp. 201–218]—which supports regular expressions for playtrace data—to *Prom Week* playtraces to excavate examples of observed event sequences matching a specific pattern (e.g., two characters date, break up, and then get back together). While Osborn and his collaborators were particularly interested in using such patterns for authoring support, *Playspecs* could also be utilized to specify curationist sifting patterns. [Note: Joe Osborn is my labmate, and through our mutual coadvisor Michael Mateas, we descend academically from Stephen Cole Kleene, who actually introduced the concept of regular expressions in a 1951 technical report titled “Representation of Events in Nerve Nets and Finite Automata” [kleene1951representation]. In his original formulation, the concept was associated with a notation for defining what he called “regular events” [kleene1951representation, pp. 46–75]. Kleene advised a student named Robert Constable, who advised a student named Joe Bates, who coadvised a student named Michael Mateas, who coadvised students named Joe Osborn and James Ryan.]

A sifting pattern could even contain nested sifting patterns, thereby taking the form of a full-fledged *story grammar* [rumelhart1975notes]. While story grammars have been devised to capture patterns attested in corpora or to generate stories, this would be a novel application of them to the task of *retrieving* potential story material. To me, a sifting pattern suggests the image of a *sieve* whose mesh pattern instantiates a particular protonarrative archetype—the story sifter pours the chronicle through the sieve and emergent examples that match the pattern are caught in the mesh.

#### Sifting Heuristic

A *sifting heuristic* specifies a policy for sifting, rather than an explicit pattern that may be matched against the chronicle. Here, I imagine a story sifter that works similarly to Doug Lenat's system *AM* [lenat1976artificial], which attempts to discover mathematical concepts by utilizing heuristics about what makes such a concept interesting or aesthetically pleasing. This variant evokes the idea of an inspired story sifter that explores a chronicle improvisationally with ideas about what makes for interesting or aesthetically pleasing material. As such, to connect back to Hayden White's work, a story sifter that works heuristically more closely resembles an historian than a sifter that uses patterns. An example sifting heuristic might specify that statistically improbable event sequences are interesting. As I noted above, Morteza Behrooz and collaborators have explored this idea in the context of logs from a rummy videogame with chat interaction [behrooz2015remember].

## Intellectual Development

In the interest of providing intellectual context, I will conclude this chapter with a brief account of the development of this curationistist framework. As I explain more in the next few chapters, toward the end of my work on *World*, my first simulation engine, I became interested in the idea of automatically discerning stories that emerge from simulations. In February of 2014, I wrote about the prospect of doing this for *World* storyworlds in an email to Reid Swanson in advance of a scheduled meeting:

> Among other things, I'm interested in brainstorming about how to sift out the more interesting stories in the sim, and how to generate short biographies for people in the world without just using a template. [Note: Personal communication, February 6, 2018.]

 My primary challenge at that time was rooted in my system's lack of causal bookkeeping (discussed in the previous section), which meant that causal relations among events needed to be inferred as a first step. I recall also having conversations about this technical challenge with Peter Mawhorter, a labmate in the Expressive Intelligence Studio, around this time.

#### *Dwarf Grandpa *
In the spring of 2014, Jacob Garbe, another labmate, was carrying out a likeminded project under the moniker *Dwarf Grandpa*. Jacob's aim was to produce a system, called *LegendsWriter*, that could sift through material produced over the course of a *Dwarf Fortress* simulation instance to generate stories recounting emergent events that had occurred in that storyworld. [Note: Just as grandfathers are known to tell stories about the real world, the system would be like a dwarf grandpa who tells stories about *Dwarf Fortress* storyworlds—hence the moniker.] As he explains in an unpublished class report [garbe2014games] and a recent blog post [garbe2018simulation], Jacob hoped to build a fully automatic system that would be driven by the data contained in a *Legends mode* [dflegendsmode] export file. [Note: Legends mode provides an interface to the history of a *Dwarf Fortress* simulated storyworld. It allows a player to view maps and explore data representing emergent phenomena pertaining to characters, locales, events, and more, and much of this data may be exported as well.] In curationist terms, the Legends data is a chronicle of a storyworld, and the *LegendsWriter* would do story sifting using sifting patterns that Jacob calls *story scaffolds*. As he explains in a recent blog post recounting the project, these are like regular expressions for event sequences (and with nesting, they become full-fledged story grammars):

> I made a small library of scaffolds. In this implementation, a scaffold was a grouping of sub-events that were ordered in time, but not in strict increments (i.e. I wouldn't care if “Eat” came 2 or 3 or 50 timesteps after “Hunt”, I just cared if “Eat” came after “Hunt”). These scaffolds [...] could read simple data from state (like which characters were involved, etc). Once I had a library, I ran pattern matching over the events for each character in the exported Dwarf Fortress history, checking to see if I could apply a scaffold to it. [garbe2018simulation, n.p.]

After sifting out raw story material through the employment of story scaffolds, *LegendsWriter* performs narrativization by using a grammar-based text generator that can produce story prose given the raw material associated with a given scaffold. According to Jacob's ultimate vision for the project, generated stories would be mounted in some kind of media experience (perhaps one in which an elderly dwarf character recounts the stories). In this way, the *LegendsWriter* would curate a chronicle to produce actual narrative artifacts that would be mounted in a second-order media experience. While Jacob ended up abandoning the project—he was extremely busy with *The Ice-Bound Concordance* [reed2014ice,garbe2014ice,garbe2014author] at the time—it contributed greatly to my growing interest in the prospect of curating simulated storyworlds. [Note: Jacob is now adapting the notion of story scaffolds to his own dissertation project, *Delve* [garbe2018delve], which itself utilizes world generation prior to gameplay [garbe2018simulation]. However, instead of using scaffolds to do curation, he is using them to drive world generation itself, somewhat in the style of traditional story grammars [rumelhart1975notes].]

#### *Mexica x *
Later in 2014, Rafael Perez y Perez visited UC Santa Cruz to give a presentation on his famous story generator *Mexica* [perez1999mexica,perez2001mexica,perez2004three,perez2017mexica]. In what was my first one-on-one meeting with a visiting scholar, I showed off *World* (the subject of Chapter 7) and was delighted when Rafael responded with enthusiasm about the system and its emphasis on simulation. Before the meeting ended, we brainstormed about a potential collaboration that would bridge *World* and *Mexica*.

Though the latter is an author-centric story generator that models the process of human creative writing [perezyperezs2015mexica]—and thus not at all a work of emergent narrative—Rafael came up with the interesting idea of having *Mexica* recount the emergent events of *World* storyworlds. We figured that doing this would require exporting *World* data in the format used by *Mexica*'s knowledgebase, which it uses to tell its stories. [Note: Rafael had recently carried out a collaboration by which *Mexica* was integrated with multiple other story generators in an interesting blackboard architecture called *Slant* [montfort2013slant].] A few weeks later, Rafael emailed me a paper on the treatment of story events as operators that modulate character emotions [y2007employing], and we planned to go from there, presumably by thinking about *World*'s emergent actions in these terms. Unfortunately, at this time I was very busy doing work on a much different topic—*videogame discovery* [ryan2015what,ryan2015people,ryan2015large]—and I dropped the ball on this prospective collaboration.

Looking back on this missed opportunity now, I realize that it would have represented a novel approach to curationist emergent narrative: use an existing story generator to curate storyworlds that are generated by an existing simulation engine. Such a configuration would have exemplified my argument (in Section 5.2) that the policies of interventionist systems can be appropriated as curation policies. In this case, the total operation of an interventionist system would have been appropriated for the task of automatic curation.

#### Generating *Prom Week Character Diaries*
My first personal foray into curationist emergent narrative was in the form of a 2015 collaboration with Chris and Matt Antoun (and several mentors), which I discussed briefly in Section 4.1.6. Our goal in this project was to automatically generate narrative summarizations of *Prom Week* [mccoy2011prom] gameplay. Specifically, we planned to create a modified version of the game that would generate a postmortem after gameplay (or after each campaign) in the form of a first-person diary entry written from the perspective of a character who had been central to the events that had transpired.

This would require curation, and by now I had identified a central curationist challenge, which I called ‘story recognition'. [Note: As I will explain momentarily, this was a precursor term for what I now call ‘story sifting'.] Here is how we introduced that challenge in our workshop paper on this project:

> Games whose narratives emerge from simulations currently have no way of understanding the very narratives they support. Stories arise in many simulationist games only incidentally; they are remarkable streams of an otherwise overwhelming profusion of events. But while
humans who play games are capable of recognizing which event sequences are storylike, the systems themselves are not. So as story generation in simulationist games works by
a sort of event combinatorics, a major issue becomes *story recognition*. How does one make a system that can discern stories embedded in the morass of data that its simulation produces? [antoun2015generating, pp. 1–2]

 As we reported in that paper, we never got to the point of automatically generating diary entries, primarily because we could not come up with an effective method for doing causal bookkeeping in *Comme il Faut* [mccoy2014social], as I explained in Section 4.1.6. Nevertheless, by now I was extremely interested in the prospect of curating simulated storyworlds, and this intrigue was reinforced by the failures of *Diol/Diel/Dial*—a contemporaneous project, and the subject of Chapter 8—which I identified as being rooted in a lack of curation.

#### Dissertation Seed

Later in 2015, with Michael Mateas and Noah Wardrip-Fruin, I wrote a paper that would become the seed for this dissertation: “Open Design Challenges for Interactive Emergent Narrative” [ryan2015open], which was published in the proceedings of the International Conference on Interactive Digital Storytelling. [Note: In an otherwise negative appraisal of the submission, Reviewer #2 (really) remarked, “The paper reads like the first chapter of an ambitious and much needed doctoral thesis”. I hope both descriptors still apply!] The crux of this paper was a more extensive articulation of the technical challenge of ‘story recognition', to which a section was devoted. Here is an excerpt:

> There is typically no explicit narratological modeling whereby narratives in simulationist systems get composed; this would constitute a top-down approach to story generation, but simulations work bottom-up. As in other emergent narrative systems with sufficiently complex underlying simulations, stories happen in *Dwarf Fortress* only incidentally; they are remarkable event sequences among a huge boiling stew of *things happening*. While humans who play experiences like *Dwarf Fortress* are capable of recognizing which event streams are storylike, the system itself is not. We call this challenge *story recognition*: how does one make a system that can discern stories embedded in the morass of data that its simulation produces? [ryan2015open, pp. 19–20]

#### ‘Story Recognition' $$ ‘Story Sifting'

As noted in a footnote in that paper, the term ‘story recognition' was adapted from ‘object recognition': “We have adapted this term from that of an analogous task in computer vision, *object recognition*, in which discrete objects are identified in image data” [ryan2015open, p. 20]. In the course of writing this dissertation, I have come to favor an alternative term, the aforementioned ‘story sifting'. This progression has been due to the influence of Hayden White: whereas initially I had conceived of the task as one of recognizing stories that are already constituted (but obscured by other material), White makes it clear that stories are never fully formed in a record, but instead a record contains the *raw material* out of which an actual story may be constructed. As such, the analogy to object recognition was misguided. Instead, the task is to sift through a record to excavate the material that may be used to build a story through a procedure of constructive narrativization.

#### Onward

By the end of 2015, my ideas about curation had been developing for nearly two years, and my framework for curationist emergent narrative, as presented in this chapter, was in the process of coevolving with my changing simulation practice. In the remaining chapters of this dissertation—those that compose Part II—I will recount this coevolution in the context of three simulation engines and three coupled second-order media experiences that, taken in total, demonstrate my increasing emphasis on curation.