Just about every beginner at interactive storytelling tries to build a tree structure. This never works, as I explained so many years ago in this essay. To put it in simple mathematical terms, a branching tree with just two options at each node and no foldback will require 2**N - 1 nodes, where N is the number of steps or choices in the story. Thus, a story only ten steps long will need 1023 nodes. That’s a huge number of nodes to create for a very short story. Trees don’t work for interactive storytelling, as so many beginners have learned the hard way. Most give up when the realization sinks in, but some continue plugging on, trying many ploys to evade the mathematical inevitability. They always fail.
Here is a schematic depiction of the structure of an encounter-based storyworld:
It consists of three basic components:
First, the main storyline. This constitutes a major violation of most notions of interactive storytelling. People expect a tree. But we have long since established that properly bushy trees cannot be made to work. Even so, most people would still expect more than one main storyline. This architecture is in fact a single storyline with three endings.
The objection raised to this architecture is that it appears to make the player’s decisions meaningless. After all, if you’re going to go through the same basic story regardless of what decisions you make, what’s the point?
The trick lies in the processes associated with each option available to the player. Whenever the player chooses an option, their choice triggers algorithms that alter the global variables crucial to the outcome of the story. The player’s choices really do make a difference, but that difference does not appear in the form of different events in direct response to each choice. The behavioral consequence of the player’s choice appears at the end of the story.
Here’s another way to think about the difference between the branching tree and the architecture I use: the branching tree gives you instant feedback on each of your decisions; my architecture gives you feedback on the cumulative effect of all your decisions. The branching tree is the videogamer’s version of interactive storytelling; my architecture is for adults who think in terms of the big picture.
The second component is the occasional small branching tree. I found that these small intermediate trees can be useful in presenting the player with different kinds of challenges. But do not forget the fact that these trees can quickly grow into unweildy monsters.
The third component is the final multiple ending. This closely parallels traditional tree structures. The key difference is that traditional tree structures are path-dependent, whereas there is no path dependency in this architecture. This raises an important point regarding tree architectures. Since these architectures rely on the path taken to specify the final outcome, there should be exactly as many paths as there are outcomes. That is, each path taken should yield its own outcome. But this imposes a problem that is the inverse of the geometric explosion discussed at the outset of this essay. That is, if your storyworld has eight possible endings, there should be eight paths leading to those endings. Eight paths are selected by exactly three binary choices. In other words, path dependency pushes you right back into the geometric explosion problem. Authors typically solve this problem with extensive use of foldback, but that in turn robs the player’s decisions of meaning.
I wish to emphasize the fundamental difference between this architecture and that of the conventional tree. Games people have gotten those little circles burned into their brains and just can’t see anything but little circles. Remember, it’s the PROCESSES — the algorithms that change the global variables — that matter, not the states (represented by circles).
Part Four: How to Design an Encounter-Based Storyworld