Options are the verbs that the author judges to be dramatically reasonable responses to an event. If Black Bart punches Little Willie, then Little Willie will have some options he can select from by way of response. Let’s suppose that the storyworld author has decided that Little Willie has three options: he can punch Black Bart back, he can escalate by hitting him over the head with a chair, or he can run away. These options are assigned to the particular role that Little Willie plays — in this case, he’s playing the role of Direct Object. The primary decision that Little Willie must make is the choice between the three options. That choice requires the application of our concepts of Acceptable and Desirable. Little Willie will consider each of the three options, asking two questions of each:
Is this option acceptable? — requiring a boolean (yes/no) answer
How desirable is this option? — requiring a numeric answer.
The acceptability of an option is based on any special constraints for that verb. The first option, punching Black Bart, requires nothing special, so it is automatically acceptable. We could make the second option, hitting him over the head with a chair, dependent upon the availability of a chair. In other words, if a chair is at hand, then the second option is acceptable; if there’s no chair nearby, then the second option is not acceptable. Unless Little Willie lacks legs, then the option to run away is always acceptable.
Acceptability calculations for options are easy; desirability calculations are always difficult, because they must make the crucial decision for the actor: what’s he going to do? This is where the art rubber hits the algorithmic road. What factors would determine an actor’s decision? Remember, the algorithms we build here must apply to ANY actor in that role, not just Little Willie.
So let’s figure out the factors that would most affect this choice among the three options:
1. The most important factor, in my celestial artistic judgement, would be the temper of the Direct Object. The greater the temper of the Direct Object, the more likely he is to take a more violent option. My basic personality model does not include temper, although my engine did have provision for moods, one of which was Serene_Angry. Rather than expand the personality model with yet another ad hoc personality trait, I think it best to press Bad_Good into service here. Positive values of Bad_Good are indicative of controlling one’s temper. Negative values imply losing one’s tempe easily.
2. An actor's own size and strength relative to the Subject will be important in deciding among the options. However, in the basic personality model I recommend (Bad_Good, Faithless_Honest, Submissive_Dominant), there is no provision for physical strength. For purposes of this demonstration, however, I’ll add an intrinsic trait Weak_Strong to account for this consideration.
There are other factors that we could bring to bear on this decision, but it’s always prudent to keep things simple. Let’s build our desirability algorithms around these two factors: Bad_Good and Weak_Strong.
The three options (hit with chair, punch, and run away) represent a sequence of decreasingly violent reactions, so the fundamental basis of our choice between them will be something representing proclivity to violence. Let’s put it in plain English: a less violent person will choose a less violent option. We can express this predilection for violence as a combination of Bad_Good and Weak_Strong. Exactly what combination do we use?
If we were using conventional numbers instead of BNumbers, then we’d ask whether to add or multiply the two numbers together. Here we apply our simple rule: do you need BOTH Bad_Good AND Weak_Strong to take the nonviolent course, or do we need EITHER Bad_Good OR Weak_Strong to take the nonviolent course? Think through the four extreme combinations:
I’m Bad and Weak: I want to be violent, but I’ll lose, so I choose nonviolence.
I’m Bad and Strong: I want to be violent, and I can succeed, so I chose violence.
I’m Good and Weak: I want to be nonviolent, and I’ll lose, so I choose nonviolence.
I’m Good and Strong: I want to be nonviolent, but I could win, but I’ll choose nonviolence because I’m Good.
There’s only one combination that has me choosing violence: I’m Bad and Strong. Hence, I must be BOTH Bad AND Strong to choose violence; otherwise I choose nonviolence. Since this is an AND-relationship, I should multiply Bad_Good with Weak_Strong together to get the answer. (If this isn’t obvious, review the material in this lesson to refresh your memory.)
But we don’t want to use conventional numbers for this calculation; I digressed to explain the use of conventional numbers to demonstrate the style of reasoning. We must find the analogous calculation using BNumbers. Let’s use four BNumber lines corresponding to the four logical comparisons above:
Notice that I have used the negative of Weak_Strong here, because that lines up Weak_Strong in the same direction as Bad_Good. In other words, Weak works against Bad and Strong works against Good, so we use the negative value; this means that Weak works with Good, and Strong works with Bad. Here’s the same set of BNumber plots with Blend operators superimposed, presenting Blend(Bad_Good, -Weak_Strong, 0.0). This means that we are taking the simple average of Bad_Good and -Weak_Strong, using even weighting between them:
The first case covers a person who for whom Bad_Good < 0 and Weak_Strong > 0. In other words, this person is bad and strong. He will definitely end up in the negative range of the scale: that is, he’ll lean towards the more violent options.
The second case has a person who is a definitely Good, but a bit Strong. He is more Good than Strong, so he’ll lean towards a nonviolent option.
The third case is a person who is definitely Bad, but also a bit Weak. Nevertheless, his Badness exceeds his weakness, so he’s going to be a little violent.
The last case is a good person who is also Weak. This person will definitely want to avoid violence.
Ta-Da! We have our solution! It’s simple, too: Blend(Bad_Good, -Weak_Strong, 0.0). We could tweak it if we wanted by changing the weighting factor (0.0). If we decided that people are more calculating than virtuous, then we put more weight on Weak_Strong. If we decided that temper (badness) plays a larger role, then we put more weight on Bad_Good.
OK, so we can calculate a BNumber that tells us how violent the Direct Object’s reaction will be. But how do we make the jump from a BNumber to a choice between three options? If there were just two options, a violent option and a nonviolent option, then it would be easy. If the Blend yields a positive number, then we select the nonviolent option, and if it yields a negative number, we select the violent option. But we have THREE options! Oh, dear, alas and alack, what shall we do?
The standard solution is to use IF-statements. Sappho has an IF-statement called PickUpperIf. Here’s the Desirable script we would use to pick the least violent option (run away):
The BInverse operator just takes the negative of its parameter; it gives us -Weak_Strong of the Direct Object. The Blend operator yields a number that is proportional to how nonviolent the actors reaction should be. If the result of the Blend operator is greater than 0.25, then TopGreaterThanBottom(BNumber) is true, and PickUpperIf will pick 0.99. This means that the Desirable value for “run away” is 0.99, a very high value that guarantees that the actor will choose the “run away” option. If, however, the Blend operator returns a value less than 0.25, then TopGreaterThanBottom(BNumber) will be false, and PickUpperIf will return -0.99, a value so low that the option “run away” will certainly NOT be chosen.
A similar Desirable script for “hit with chair”, only using TopLessThanBottom(BNumber) and a value of, say, -0.25, will guarantee that “hit with chair” has a high Desirability only if the Blend operator produces a very negative value.
For the middle option, “punch”, we’d use coupled IF-statements, like this:
This means that the middle option, “punch”, will get the high value of 0.99 only if the Blend operator produces a value less than +0.25 and greater than -0.25.
There’s an even better way to deal with this kind of selection among multiple options, using a Sappho operator called “Suitability”, but I’ll keep that secret so that you'll never know! Bwa-ha-ha!