Chris Crawford on Interactive Storytelling (52 page)

Of course, eventually everybody knows, and when the Secret’s owner discovers this, there’s hell to pay. But what are the accounting details required to pay hell? How can the Secret’s owner respond to the betrayal?

What prevents people from telling every lie and divulging every secret? Answer: the likelihood of sanctions if discovered. The key issue here is discovery; people lie and blab secrets because they believe they won’t be caught, but sometimes they
are
caught. Therefore, you need a mechanism that permits improper gossip to be discovered—but only sometimes. In other words, there must be a chance of getting caught, but not so high as to make it overly risky. My solution to this is the
Grapevine
(as in “I heard it through the grapevine”).

The basic idea is to keep track of who told what to whom. For each item of Gossip, you have to maintain a record of every transmission of that item. In other words, if Larry concocts the lie that John slept with Margaret and then tells that lie to Dave, and Dave tells Fred, who in turn tells both Mary and Sam, and Mary tells Jane while Sam tells Agnes and Tabitha, and Tabitha asks Margaret why she slept with John, then Margaret has to be able to deny the lie and demand that Tabitha reveal her source for the lie.
Figure 14.2
makes this complicated mess easier to understand.

Assembling the data structure required to keep track of this tree isn’t difficult. Its value is that Margaret, upon learning of the lie being told about her, can demand “Who told you that?” Tabitha can then choose to spill the beans about Sam or lie, depending on how her attachment to Sam compares to her attachment to Margaret. If she does reveal that Sam was her source, Margaret can go to Sam and make the same demand. In this fashion, Margaret could trace the lie all the way back to its source. This is cumbersome, of course, but the existence of this possibility is the best deterrent to lying.

FIGURE
14.2:
A typical grapevine.

One possible objection is that this system would quickly spawn an impossibly large pile of meaningless data. Most events aren’t worthy of this treatment; why waste computer resource on such a low-priority task?

The trick is that the Grapevine system doesn’t consume much RAM. It keeps track of the tree for every Event, but after every Actor has learned of the Event and carried out his or her reaction to it—if any—the storytelling engine dismisses the information. If everybody has heard the news and nobody has anything left to do about it, there’s no longer any point in storing the information.

A more serious objection is that successfully tracking the falsehood all the way back to its source is most unlikely. For Margaret to nail Larry, she needs the cooperation of Tabitha, Sam, Fred, and Dave. Should even one of those people decide to protect Larry, Margaret will be stumped. But the real value of this situation lies in the element of suspicion. Suppose, for example, she traces the lie as far back as Sam, who insists that he can’t recall who told him (or maintains that he didn’t tell Tabitha). This adds grist for the dramatic mill, creating tension between Sam and Tabitha: “Why did you tell Margaret that I told you about her? Now Margaret’s on my case!” It also reduces Margaret’s trust in Sam. Moreover, she can try to guess Sam’s possible informants based on her third-person trust
relationships, thereby getting a step or two closer to the source. Thus, Margaret is able to develop suspicions she can then act on—and the plot thickens.

Despite these possibilities, the clinching argument for the Grapevine system is the need for some fair and workable deterrent to lying. Accountability, which the Grapevine system makes possible, is that deterrent.

Rare is the protagonist who doesn’t stumble at some point in the story over a lack of information, some misinformation, or an unfortunately revealed secret. Information transfer among members of the cast is always an important component of most narrative. Accordingly, any storytelling engine must include provisions for recording information and for Actors manipulating that information.

I LEARNED A HARD LESSON
in my early work with interactive storytelling. I was building my engine around an Arthurian storyworld that included Arthur, Guinevere, and Lancelot. In keeping with the conventions of the basic story, I provided for the possibility of Lancelot falling in love with Guinevere. While I was running one of numerous tests on the storyworld, Lancelot did indeed fall for Guinevere, and the two of them consummated their love in the forest.

Now, this verb
MakeLoveTo
had a high
Import
value, and of course the Gossip section of the engine calculated that, because Lancelot was Arthur’s best friend and Guinevere his wife, Arthur would have high interest in any event involving both of them. Accordingly, when Lancelot next encountered Arthur, he searched through his headlines and found the one that would most interest Arthur: “Arthur, did you hear? I had sex with your wife!”

The factor I had left out was anticipation: Lancelot should have anticipated Arthur’s likely reaction to the news that he had slept with Guinevere and, accordingly, held his tongue. But the algorithm for anticipation, it turns out, was far more difficult to design than most other algorithms in the engine.

There are two fundamental problems. First, to anticipate another’s reaction to something, you must put yourself in that person’s place. Lancelot must, in effect, pretend he’s Arthur, and then imagine how he would feel in Arthur’s shoes. This task requires a considerable amount of computational legerdemain. The second problem is that you’re attempting to determine Arthur’s reaction in a subjunctive sense:
If
Arthur knew of the event, how would he react?

I had already built into the engine the capability for Actors to have emotional reactions to Events, so I had code in place to ensure that if Arthur discovers Lancelot’s betrayal, he would become very angry. The problem was that this emotional reaction was part of the
real
reaction to the Event. In other words, the only way to figure out how Arthur would react was to have him actually react, in which case, he’d kill Lancelot. The whole point of anticipation is to see these things coming
before
they happen. I needed to create a virtual world
inside
the virtual world of the storyworld, a temporary imaginary world inside Lancelot’s head where Arthur could react to the news, and Lancelot could observe his reaction in safety and then act accordingly in his real world.

This example illustrates a general problem known in computer science as
recursion
. When a calculation must be carried out inside itself (Lancelot’s reaction anticipates Arthur’s reaction inside itself), you must use this exotic and confusing method. Unfortunately, recursive code places stringent requirements on program design, and those requirements would have forced me to completely rewrite most of the engine code, so I had to find another way.

There are two possible approaches you could use. In the first, you calculate the listening Actor’s likely reaction (that is, the Verb the listener will likely choose upon hearing the news), and then determine whether that reaction is desirable from the speaker’s point of view. I rejected that approach for my own engine because it simply defers consideration of the emotional reaction, which is the factor that really matters here. You could follow an endless logical tree of possible reactions, but the further you go down that tree, the hazier your calculations grow and the messier everything gets.

In the second approach—the one I settled on—you go directly to the emotional reaction. The engine calculates the listener’s emotional reaction and determines whether it’s desirable from the speaker’s point of view. This approach requires specifying an emotional reaction for every Verb. When Actors witness or learn of an Event, they must be able to calculate their emotional reaction. Moreover, Actors should react only to Subjects, not DirObjects of Events. The Subject is the Actor actually performing the action; the DirObject exercises no free will in being acted upon. This method saves storybuilders the trouble of specifying the target of the reaction.

For example, Lancelot’s problem would be tackled by presenting the Event “Lancelot sleeps with Guinevere” to the virtual Arthur and running him through the calculations of his emotional reaction to Lancelot. The engine obtains those emotional reaction values and feeds them back to Lancelot, who can then use them to determine whether he wants to tell Arthur.

Most Verbs give you no problem with this restriction on reactions, and those few Verbs that might cause trouble are easily dealt with. In the case of Lancelot sleeping with Guinevere, you need only precede that Event with an Event by which Guinevere explicitly agrees to sleep with Lancelot. Arthur can react to this first Event (Guinevere agreeing to sleep with Lancelot) in forming his reaction to Guinevere and react to the second Event (Lancelot sleeping with Guinevere) informing
his reaction to Lancelot. This strategy keeps reaction calculations simple: The Actor reacts to one person at a time. Of course, it requires that Gossip be communicated by Tales rather than by single Events.

For more information on Tales, refer back to
Chapter 14
, “HistoryBooks and Gossip.”

Therefore, when a speaker considers whether to reveal information to a listener, the speaker merely evaluates the listener’s emotional reaction to make his decision. The speaker adds up the changes in
PerVirtue
,
PerIntegrity
, and
PerPower
toward him. A positive sum means that the listener, upon hearing this news, will be more favorably inclined toward the speaker, so the speaker will reveal the Gossip.

However, this calculation applies only when the speaker is also the Subject of one or more Events in the Tale. When the Tale contains Events in which other Actors are the Subject, the speaker should take into account the listener’s emotional reaction toward those Actors. Even if Lancelot were, by some odd fluke, unconcerned with Arthur’s reaction toward him, he would still want to consider Arthur’s likely reaction toward Guinevere. The loss of
PerVirtue
,
PerIntegrity
, and
PerPower
that Arthur would feel toward Guinevere would be bad for Guinevere, and because Lancelot retains high
PerVirtue
for Guinevere, this outcome is undesirable from Lancelot’s point of view. Therefore, you must add a factor to the calculation for the desirability of revealing the Event to him; that factor includes the cost to Guinevere of telling Arthur about the tryst. It should be similar to the first factor: the sum of changes in Arthur’s
PerVirtue
,
PerIntegrity
, and
PerPower
for Guinevere upon learning of the tryst. However, this sum should be weighted in proportion to Lancelot’s
PerVirtue
for Guinevere. If his love for her is the maximum possible value, Arthur’s reaction toward Guinevere should be just as important to Lancelot as Arthur’s reaction to Lancelot himself. If his love for Guinevere is, say, only half the maximum, Arthur’s reaction to Guinevere should receive half-weight.

Moreover, these calculations have a negative side. Suppose Mordred is the one who possesses the information about Guinevere’s adultery. His calculation shows that Arthur will have a negative reaction toward both Lancelot and Guinevere. Because Mordred hates both Lancelot and Guinevere, he calculates that Arthur’s reaction to the news will be harmful to both of them, so he’s highly motivated to reveal the news.

This approach boasts high emotional acuity. Suppose, for example, Arthur beat Guinevere and is now considering telling Lancelot about the beating. Arthur knows that Lancelot likes Guinevere, so revealing that he hurt her could damage Lancelot’s relationship with him. Conversely, if Arthur thinks that Lancelot hates Guinevere, he’ll calculate that revealing this information will ingratiate him to Lancelot.