This is my first post/review/analysis of a computational artifact, rather than some sort of purely written thing. Storytron is Chris Crawford’s magnum opus, the fruit of his labor toward the great endeavor of Interactive Storytelling. The project was originally called Erasmatron, after the medieval scholar Erasmus. Crawford has received a lot of challenge toward his project, and this comes from several factors. The first is his outright rejection of games, the second is the sheer time it took him to develop it (13 years, albeit working alone), and the unusual nature of the project itself. I was originally expecting to be much more critical of Storytron, but after examining it closely, I believe that it has a rather sound architecture. The chief challenge to the project is the base unit for the dramatic system, which is the Sentence. This is worthy of criticism not because sentences are low level grammatical structures, but because the textual interaction is problematic. Storytron builds directly from Crawford’s book on Interactive Storytelling, but having experimented with both the authoring tool and the first demo game, I can discuss some of the key differences and interesting conclusions.

It will be useful to juxtapose Storytron against other existing systems, notably Facade and The Sims.

Architecture

I want to describe the architecture of Storytron first, and examine how it relates to the systems described in Crawford’s book. One of the first things that I noticed is that Storytron uses a planning model for agent behavior. The system includes a drama manager, in the form of a special Actor called Fate. It is difficult to tell whether the flaws with the model of planning emerge strongly in this system, but I suspect that these are held back by the strong personality system. Actors’ personalities have a great influence on their behavior, allowing factors such as mood, emotion, predispositions and the like to affect the Actor’s decisions. Actors do form plans, but these are directed towards the establishment of certain events.

The core elements (and hence data structures) in Storytron are: Actors, Relationships, Props, Sentences, Stages, and Verbs.

Actors

Structure is very similar to the form described in Interactive Storytelling, but has some notable differences. The structure however is open for extension, meaning that authors can create their own traits for new storyworlds. The ones given are Quiet_Chatty and Cool_Volatile. Accordance variables may be rendered unnecessary by making some variables hidden versus visible. Characters have “Weight Traits” which represent the core traits that the actor wishes to find in other characters. This involves self perception as well as a sort of desire in others. This is an interesting concept, but I am not sure how it might come into play.

Additionally, there are several state traits which reflect important states to consider when simulating the characters:

• Active
• Unconscious
• DontMoveMe
• Location
• SpyingOn
• OccupiedUntil

Relationships

The perceived traits described in the Interactive Storytelling book are included here, under relationships. These operate on the hidden traits for actors, props, and stages. Additionally, these have confidence values for each of these, reflecting how accurate the actor considers its perception value.

Storytron contains additional relationship values reflecting scales which were not described in the book. These address some of the points I thought was missing in the book. These particular traits are things that I would originally apply to situations, with more procedural representations, but here they are framed simply as numeric values. The net of these appears to be reasonably effective, however. The organization of actors, props, stages, and events seems very sound.

• Debt_Grace (Actor to Actor)
• Stranger_Kin (Actor to Actor)
• Familiarity (Actor to Actor)
• Unwelcoming_Homey (Actor to Stage)
• KnowsMe (Prop to Actor, Stage to Actor)
• WhoKnows (Event to Actor)

Relationship variables are held by both holders of the relationship. So, actors will have each of these, but the Stage or Prop will also share them as well.

Props

Like actors, these are dynamic elements in stages, and partly form the content of Interactive Storytelling. Props have several attributes, but not very many. I like the concept of props, and I intend on using a model very similar to this one. The model proposed relies heavily on authors creating their own variables denoting the qualities of objects as scalar values– Benign_Harmful, etc.

• InPlay
• Owner
• Carried
• Visible
• PropLocation

Stages

These represent the core elements that describe places. These are discussed in light detail in the Interactive Storytelling book. Like Props, Stages should have author-defined values denoting the qualities of the stages- Radiated_Clean, for instance. The other parameters listed are:

• DoorOpen (indicating whether Actors may enter or exit the Stage)
• DoorLocked
• Position
• StageOwner

The Drama Cycle

The actual execution cycle is reasonably sound. There are three phases to a turn. These are described as the “Action Cycle” the “Reaction Cycle” and the “Travel Cycle”. These are executed consecutively, and during each, every actor acts, reacts, and may travel, respectively. The action phase involves planning and execution, so the actor will think and then act. Reaction is performed when actors learn of events. In the reaction phase, each actor will assume a role according to the event’s verb structure, (this is somewhat difficult to understand, I suspect it involves whether the reacting actor is an object, witness, etc of the event). Actors may wish to form plans in response to reactions.

The understanding of role here is somewhat different than the approach that I am used to, but it appears to be an effective way of looking at integrating roles and plans. This may be an approach from which I might like to build.

Gameplay

The actual interaction with the Storytron system is robust, but somewhat difficult. The central issue is that the core mechanic of playing a storyworld is composing sentences. There is a visual builder to construct these sentences, but the representative capacity of the events is diminished. Like all projects that use natural language, (story generators, interactive fiction, Facade) Storytron suffers from the difficulty that the computer has with human language. The space of possible interactions available to the player is extensive, but is still contained by the model of the story world written by the author. When the medium is text, it seems that it should be possible to compose nearly any sentence, and perform any action that would be reasonable, but some of these simply cannot be handled by the logic of the story world. This is a necessity with developing any model, that simplifications must be made. The flaw is that using a textual medium with many possibilities creates an expectation of being able to do much more.

The representative capacity of the interaction is also diminished by sentence based representation, especially in the sense that the story world is complex and updates regularly. This critique comes from playing Balance of Power 21st Century, which is a sequel to a previous Chris Crawford game, but is also a beta and clearly a public policy game. The fact that a public policy story world lacks representative capacity is not necessarily a problem with the technology itself so much as the genre. Nonetheless, flaws do emerge, and it is interesting to compare the visualization of policy in this with, for instance, Civilization. From the perspective of the player, it becomes necessary to navigate through tables describing relationships and attributes in order to deduce the context of possible actions. This is tremendously counter to the sense of the storytelling aesthetic being heralded in the work. The scope of computational representation is very rich, in the sense that nations have a complex balance of power and influence over each other, but these elements are not well presented to the user. In keeping with the metaphor of theatrical drama, it is like going to an opera in a foreign language, and needing to read the history behind everything in order to understand the show.

One feature which is very important is the presence of faces. Story moves and sentence construction come with visual feedback in terms of faces denoting the visible moods of either the player or the NPCs with whom the player is interacting.

Another element to interacting with Storytron that is very difficult is the use of sliders. The point is that numeric and comparative values must enter into the system in order for changes to make sense. Having grown up with games, I am used to slider systems representing variables such as mood and reputation. However, these have a variety of deliberate feedback mechanisms. In Balance of Power, feedback (especially in terms of falling clout) tends to come after it is too late. Part of this is again indicative of the genre of political strategy. However it also is an indication that the numbers are not supported intuitively or tangibly in the system. The values of numbers range from “Extra Huge”, to “Huge”, to “Very Large”, to “Large”, to “Medium Large”, to “Medium”, and so on. The problem with these is that they are not reflected in terms of the language of the story world. It is unclear to the player what it means for a nation to find something desirable at a rate of “Medium Small”, or what it would mean to ask someone to do something with that much emphasis. The reason why other games that use sliding systems are effective is that the reference of the number is strongly supported within the language of the game.

Authoring

The greatest challenge to Storytron is the authoring environment, SWAT. The application is very complex and requires a great deal of time to learn. This is hardly surprising since other projects (Facade especially) have been extremely intricate, and require a great deal of content to be authored. The authoring tool centrally allows the author to create and modify the building blocks of the system.

Part of the reason for the difficulty in the editor, which is otherwise a really good editor, comes from the reliance on grammatical metaphors, and the exclusion of a programmatic language. The editor provides a tree based structure for composing boolean and other typed expressions. The ability to manipulate these is useful, but the tree based interface forms an obstacle between the author and the actual expressions that they need to write. The interface includes elements that allow the author to have complete access to the available expressions. A good example for comparison is with Facade, which has a scripting language, which is used to author many many events, and also Inform, which has a format for scripting very similar to natural language composition.

The main issue at stake with authoring is ease of use. It must be possible and as easy for authors to add onto a story world the same way that someone might be able to add a paragraph to an existing story. It must be possible to understand a story world, in whatever form, relatively quickly. This area is one of the major challenges with Storytron, but what I choose to do is yet to be determined.