An Attribute describes a trait, quality, or property of an Actor, Prop, or Stage. You can create as many Attributes as you want, but we advise you to be careful and not run hog-wild here, lest you create a confusing mess of Attributes. Our experience has been that authors create too many Attributes at first, and then have to pare down their list, which can be very tedious and time-consuming.

You can create
Attributes to represent anything that you think is important to your dramatic needs. For example, if you want to build a storyworld about romance, you'll certainly want to have an Attributes for how attractive an Actor is. If it's a macho storyworld for guys, you'll probably want an Attribute for how strong each male Actor is. If it's a Western-type storyworld, then maybe you'll want an Attribute for how quick on the draw an Actor is. You don't want Attributes for everything and anythingyou want Attributes that will directly influence the decisions that Actors make.

Attributes are created in the appropriate Editor depending on whether you're describing an Actor, Prop, or Stage.  We have a convention that we have found is very helpful when it comes to naming an Attribute: we give it two names connected by an underscore, with the two names representing the meanings of the two opposite senses of the Attribute.

For example, if we have an
Attribute for how attractive an Actor is, we don't call it "Attractive"we call it "Ugly_Attractive." If we want an Attribute for how strong an Actor is, we don't call it "Strong"&#mdash;we call it "Weak_Strong." Years of experience have taught us that this bipolar labeling convention makes it easier to work with Attributes. In fact, we've built this convention into the Storyteller, so that it's easier for the player to understand. The Storyteller takes advantage of the labeling convention to make its presentation to the player a bit easier to understand. But you don't have to follow this convention. If you want to give your Attributes other labels, be our guest. (In fact, there are a few special situations in which it's best not to follow the convention—but recognizing those special situations is an advanced topic.)

Attribute has a different value for each Actor (or Prop or Stage). You set the different values of the Attribute using the sliders for that Attribute.

But the weirdest, most confusing thing about
Attributes is the number system we use for them. Attributes are always measured with a strange kind of number that we call a Bounded Number.

Bounded Numbers

Storytronics is a kind of simulation: it models dramatic behavior with numbers. Designing such models is always a tricky business, and one of the trickiest, nastiest, dirtiest problems in modeling comes from dealing with the numbers themselves. What, exactly, do we mean when we try to put a number on a dramatic personality trait?

For example, suppose we want to take into account how gullible
Actors are. We want gullible Actors to have Inclinations that incline them towards trusting-type Options, while we want other Actors to have Inclinations that incline them away from trusting-type Options. Obviously, we'll want to create an Attribute called "Suspicious_Gullible." But what would any such numbers mean? Does a Suspicious_Gullible value of 100 mean that an Actor is really gullible? Does 5 mean that he's really suspicious? What does 3,157,287 mean? Or -37.2?

We all recognize that there are degrees of gullibility and suspiciousness. We can readily understand that
Actor X is more gullible than Actor Y, or that Actor Z is just slightly suspicious. So we already know instinctively that gullibility and suspiciousness are concepts that, at least theoretically, could be measured with numbers. But what numbers are right for the job?

We have invented, just for Storytron, our very own kind of number that is designed especially for this problem. We call it a
Bounded Number, or BNumber.  We've designed it from the inside out to make perfect sense and to be easy to use.

Whenever you use a
BNumber, you think in terms of the average, not the absolute. You don't think "How many units of gullibility should I assign to Fred?" Instead, you think in terms of a bell curve of suspiciousness and gullibility, like this:

Most people are close to the average in overall suspiciousness versus gullibility. Some people are more suspicious and some are more gullible. And very few are extremely suspicious or extremely gullible. So you use a value of 0.0 to indicate average or normal values, a value of 1.0 to indicate the maximum possible degree of gullibility, and -1.0 to indicate the maximum possible degree of suspiciousness. (In practice, we never use the values of +1.0 or -1.0, because they're supposed to represent "the impossible extreme." So we normally just use +0.99 to mean "really really really big one way" and -0.99 to mean "really really really big the other way.")

This reliance on thinking in terms of bell curves makes a lot of problems go away, because now you don't have to worry about the units of measurement. Suppose you want an
Attribute for how short or tall an Actor is. You don't have to worry about whether an Actor is 5 foot 4 inches tall or 162 cm tall. You just decide that average height is, say, 5 foot 6 inches, and really really really short is 4 feet 0 inches and really really really tall is 7 feet 6 inches. Then you can estimate that 5 feet 4 inches corresponds to a BNumber of about -0.05.

Nor do you have to worry about weird scaling problems, like multiplying 6,487,265 "Joy thingies" by 0.125 "Honest thingies."
Sad_Joyful runs from -1.0 to +1.0, and so does False_Honest. Everything is always measured on the same scaleno matter what you're using!

BNumber Arithmetic, everything always works out right. You can add, subtract, and do whatever you want with BNumbers, and they never go outside of their legal range from -1.0 to +1.0. No matter what you do to them, they always stay legal. (More about Bounded Numbers in BNumbers, Unumbers, and Numbers)

Let's use an
Attribute in our growing storyworld. Go to the Prop Editor and use the green "+" box in the top center to add a new Attribute under "Core Prop Traits."  Call that Attribute "Harmless_Lethal." This will represent how injurious a Prop is when used in a fight. Now add three more Props: pillow, cane, and club. Be sure to set their locations to "Joe's Bar."  Use the sliders to assign Harmless_Lethal values to the Props as follows:

pillow - leftmost tick (low)
        cane - next tick to right (medium-low)
        whiskey bottle - center tick (average)
        chair - next tick to right (medium-high)
        club - rightmost tick (high)

Let's use this new
Attribute to make the decision-making for the Option "hit with" more interesting. Let's say that, when you hit somebody with something, you choose the least lethal weapon that's still more lethal than the one you were hit with. In other words, if somebody hits you with something, you up the ante, but you don't immediately jump all the way to the most lethal weapon. So let's change the Acceptable and Desirable scripts for the 4Prop WordSocket for the Option "hit with" for the Role "hittee" for the Verb "hit with."

But first, a little digression: did you notice how clumsy the previous sentence is? We had to use a long string of prepositional phrases to specify exactly what script we're talking about. After having written too many of these long, tedious sentences, we came up with a shorthand that's much easier to use and understand. The form is as follows:

Verb: Role: Option: WordSocket: {Acceptable or Desirable}

So in this case, that entire sentence could have been reduced to:

hit with: hittee: hit with: 4Prop: Acceptable

Back to work. We need to write an Acceptable Script and a
Desirable Script. Go to the Verb Editor and make sure the Verb selected is hit with.  The Role should be hittee and the Option should be hit with, just as in the shorthand sentence above. 

Do you recall that the
Inclination Script never affects the player? The computer uses the Inclination Script to make decisions for the other Actors, but the human player always gets the full choice of Options. Well, the same principle applies to Acceptable and Desirable. We want the human player to be able to choose from any of the possible Props, but we want the computer-controlled Actors to choose based on the escalatory algorithm we described above.

4Prop Acceptable Script determines what choices the human player sees on the menu, while the Desirable Script decides which of those menu items the computer Actor will choose. This, it turns out, makes some of our Scripting work easierand some harder.

The Acceptable Script is ridiculously easy. We want the human player to be able to choose whatever
Prop he wants. Hence, the Acceptable Script looks like this:


This means that, whenever the Engine asks, "Is this
Prop acceptable?" the answer is always "Yes." Every Prop will be Acceptable! So the human player can choose any Prop he wants.

Click on Acceptable under
4Prop and erase the old Acceptable Script by clicking on the highest Operator ("OR") and hitting the delete key. Then press on the "true" button just above the Scripting box.  Done.

For the computer
Actors, we need to use the Desirable Script to implement the escalatory idea sketched above. We want the Desirability to be negative when the Prop in question has lethality lower than the lethality of the Prop that was just used on the Actor, and maximum for the Prop that has the lowest lethality of the remaining Props. Here's a Script that does this:

PickUpperIf of:
      TopGreaterThanBottom(BNumber) of:
Harmless_Lethal of:
         Harmless_Lethal of:
      BInverse of:
         Harmless_Lethal of:


The TopGreaterThanBottom(BNumber) Operator is in the "Logical" menu; and the Harmless_Lethal Operator is in the "Prop" menu. This4Prop is in the "ThisEvent" menu.

Let's take this Script apart and explain it piece by piece. The
PickUpperIf Operator will pick the upper term (the BInverse term) if the condition is true; if the condition is false, then it will return the lower value: -0.99. Obviously, a Desirable of -0.99 is very undesirable and the CandidateProp with that value won't be selected.

Let's suppose that the logical condition turns out to be true. Then the upper term (the
BInverse one) will be chosen. What does that mean? BInverse is a really simple Operator: it simply reverses the sign of its argument. Thus, BInverse of -0.5 is +0.5; BInverse of +0.25 is -0.25, and so forth. So the CandidateProp with the highest value of Harmless_Lethal will have the lowest BInverse result, and the CandidateProp with the lowest value of Harmless_Lethal will end up with the highest BInverse result.

But now we have to consider the biggest term in this Script, the logical term TopGreaterThanBottom(BNumber). This yields true if the top number of its two arguments is bigger than the bottom number, and false otherwise. In other words, it asks, Is the
Harmless_Lethal of the CandidateProp bigger than the Harmless_Lethal of This4Prop, the Prop that I was hit with? If so, then we pick the BInverse term. If not, we pick the -0.99 term.

Let's suppose that
Joe has just hit Fred with the cane, and Fred is running the Desirable Script for the Prop he's going to "hit with" back.  The CandidateProp with the highest Desirable value is the whiskey bottle, which is exactly what we wanted.
Let's try it in Storyteller Lizard to watch the algorithm at work. There's one more thing we need to adjust first:  we changed the
4Prop Acceptable script to "true" in the hit with Option under hit with, but the old script (the one that forces Fred to use the chair and Tom to use the whiskey bottle) is still in the hit with Option under punch.  If we don't change it, the first time the player (Tom) has the choice of using hit with, the only Prop he can use is the whiskey bottle.

Welcome to the nit-picky world of scripting.

If you want to see this problem happening, try it out in Storyteller Lizard.  To fix it, use the
Verb Editor to edit punch, and in the hit with Option, change the 4Prop Acceptable script to "true." Now the first time Tom has the choice of using hit with, he has all the Props to choose from.

hitting Fred with various Props, and watch how he responds.  The escalation algorithm guides his choices of what Prop to hit with.  Have fun!

Previous tutorial:  Enriching the Storyworld                                                      Next tutorial:  Emotional Reactions

Home     SiteMap     Feedback     FAQ     Press Room     Privacy Policy     Login