“Changeful Tales” is a blog series where I rework my dissertation into more bite-sized, readable, and visible ideas.
While narrative mechanics represent the ways a player can interact with a game’s story, let’s consider as well what the system can do with those interactions: the internal processes that act on player input, perform operations on it (simple or complex), and return new bits of story (or lexia). As a result of this loop, the player interprets their actions as operating a story machine, even if it’s one as simple as if I scroll down, I’ll get the next piece of story. The narrative logics of a storygame comprise this holistic story machine, existing across multiple dimensions: deep in the game’s code, in the hardware of the screen and input devices, and within the user’s mind.
Traditional media does not really have narrative logics, or perhaps they’re so simple they’re rarely worth mentioning. We could say a digital version of a book or film has a narrative logic of next(): upon interaction display the next page, or at regular intervals show the next frame. Story content in linear media is conceptually a linked list, one-dimensional, with progression from the initial lexia through to the final lexia. Through this lens we might interpret a rewind button as an action that changes the narrative logic to display the story in reverse order and more quickly.
Some games have equally simple narrative logics, such as display the next cutscene when the correct conditions are met. But others might be more complex. A Twine game features logics of navigating a node-based story space, with rich interpretive possibilities based on how the author chooses to interconnect lexia. A text adventure features a more elaborate story machine that might feature concepts of containment, illumination, weight, countdowns, and grammar: it trades the more streamlined and abstracted logics of navigation in a Twine for heavier logics of immersion in a simulated space. Other games might experiment with less familiar narrative logics: Her Story offers a radically interconnected way of accessing a set of lexia (in the form of video clips), while The Ice-Bound Concordance, by myself and Jacob Garbe, centers logics of reconfiguration: constantly adjusting a story’s initial condition until you find one that leads to an ending you like.
Much as we identified common narrative mechanics in the previous post, we can also identify some of the most common narrative logics: the most established kinds of operable story machine.
- Story as Coin-Op Reward — do the right action, get a piece of story. The action might be as simple as bumping into an NPC, or as complex as completing a sequence of boss fights.
- Story as Navigable Graph — as in a Twine, an adventure game’s map of connected rooms, or a dialogue tree; a space the user can move through (freely or with restrictions) where each node has story content as well as connections to more story content.
- Story as Fleeting Opportunities — chances to get new story content come and go based on the changing game state (characters coming and going on a schedule; actions becoming available when a flag or stat reaches a certain value).
- Story as Recurring Variations—repeatedly getting a variant on one or more recurring stories, as with procedurally generated or templated quests.
Innovation in interactive narrative can be read as successfully realizing a new kind of narrative logic, or extending an existing one in a novel way. Shadow of Mordor, for instance, was noteworthy in part for extending the familiar logic of Story as Recurring Variation (a series of boss enemies) so that those variations became responsive to a previously underutilized channel of narrative input: the player’s decisions and strategies during combat. A large library of custom visual content and story lexia (voice-acted enemy audio) combined to create the impression of a story machine that made unique, custom nemeses based not on your choices from a dialogue tree, but on the way you’d been fighting orcs. Crucially, this change was not purely within the combat logics (as in games that adapt enemy difficulty to your play style) but in the narrative logics as well — in the player’s perception of a story adapting to their choices.
For a novel approach to succeed as a narrative logic, however, it needs to operate both in the system’s code and the player’s understanding. Dialogue trees, for all their limitations and simplicity, are a well-established narrative logic. They’re easy to implement in code, and easy for players to understand. More elaborate systems risk confusing or frustrating players who can’t build a mental model of how they work. Games of social simulation (like Prom Week, Redshirt, or Blood & Laurels) strive toward the ambitious goal of a narrative logic that feels like interacting with a person, such that common-sense ideas like treat this person poorly and they’ll get mad at me become as actionable as click next to continue. But players aren’t familiar with logics this complex, and designers have neither established patterns of system-building nor conventions of UI to fall back on. These games can risk feeling unsatisfying, frustrating, or even broken, despite their revolutionary technology.
Much of the rest of this blog series will be devoted to identifying and tackling this problem: how we can both design more complex and interesting narrative logics, but also, crucially, make them understandable and operable for players.
First, though, it’s worth looking back a bit at where we’ve got to. With the framework of narrative logics, we’ve arrived at a goal we’ve been aiming for across this series so far: a language for discussing how a player and system collaborate to create the impression of a story responsive to the player’s actions. With this lens we can compare storygames with very different genres or UI conventions to talk about how they actually function as interactive narratives, both as abstract machines and instantiated code. We also have a productive way to troubleshoot how and why story machines can fail. Is a particular storygame failing because the player’s mental model does not match its actual inner workings? Is it because of a mismatch in the player’s understanding of how their inputs are translated into actions? Is it because the player’s expressiveness does not match the capability of the story system to respond to it?
In an upcoming book on adventure games I’m writing with Anastasia Salter and John Murray, we argue that this last kind of breakdown is behind the genre’s commercial decline in the late 1990s and its reputation for being difficult and unfair. These games offered expressive input, suggesting narrative logics of experimentation and creative problem-solving, but in many cases failed to connect those inputs to a system that could respond to them. Poorly designed adventure games were narrative logics of next() pretending to be simulations. This vast disconnect became a frequent source of frustration and anger.
In the posts to come (and in my dissertation, which this series adapts) I’ll consider three emerging narrative logics in depth, discussing how they work, what kinds of stories each is good at telling, and how to make them operable by players. Before we get there, though, it’s worth pausing for a moment on a familiar narrative logic to get comfortable with how this kind of lens is useful and revealing. I’ll tackle that challenge in the next post.