Personality Modeling

Everybody’s talking about interactive storytelling these days, but we’ve seen little real progress in the field. One reason for this is the problem of creating good interactive characters. Sure, there’s a ton of non-interactive characters out there, characters who really don’t respond well to the player. But genuinely interactive characters are as common in our industry as humanoids in the Cretaceous era.

The first step in building interactive characters is to create a personality model. This is a set of attributes that define the personality of the character. One might think of the old attribute sets that one rolled up for characters in fantasy role-playing games: traits such as Charisma, Dexterity, Stamina, and so forth. But these traits don’t operate as a personality model. They don’t tell you anything about the personality of the character. All they tell you is how the character performs certain tasks.

What we want are attributes that describe how the character feels, how he reacts to the other characters. Where do we get those?

Personality modeling is an old field in psychology. Before psychology emerged as an academic field, there was phrenology, which attempted to divine personality traits from the bumps on one’s head. Later on, there was a simplistic model that recognized three poles, based on body type, which in turn was based on which of the three basic anatomical systems predominated during fetal development. Persons whose digestive systems dominated became mesomorphs, with round, flabby bodies. Those with pronounced musculo-skeletal systems became endomorphs, with strong athletic bodies; and those with exaggerated nervous systems were ectomorphs, skinny wimps. A whole range of personality traits were attributed to each of these somatypes. This simplistic personality model has long since been utterly discredited.

Over the years, personality models have come and gone with dizzying speed. Jungians introduced multipolar diagrams, Freudians had their own little systems, and the latest rage these days is a nine-pointed star. Along with this we’ve gotten a whole vocabulary of personality typing. Are you a Type A? Schizophrenic or even schizoid? Obsessive-compulsive? Are you a Martian or a Venusian, introverted or extroverted, task-oriented or social-oriented, analytic or intuitive? Gack!

In truth, these are not personality models, they are personality typing systems. They are coarse and primitive, meant only to provide simple, rule-of-thumb appreciation of human behavior. They are not used to define a personality, only to give better understanding of behavior.

There has been more serious work among psychologists on the problem of true personality modeling, but I must confess that this work goes over my head. Moreover, these people are trying to solve a problem we don’t need to solve: they want to model real human personanlity; we need only model characters. There’s a big difference between real human personality and a character the character is an idealized, simplified representation of a real human being. A character is to a real human being as a story is to life, or as a portrait is to a photograph. A story is a simplification and a clarification of life. It has a beginning, a middle, and an end, where life just bounces along endlessly. A story has a conflict and a resolution, where life has lots of boredom and few resolutions to the conflicts that do arise. So our task is not to create the perfect model of a real human personality; instead, our task is to create a usable model that permits us to create practical characters for interactive stories.

Personality models are highly subjective. There is no such thing as a "correct" personality model. This is all a black art, and if you and I produce different personality models, there is little basis for one to claim absolute superiority. For this reason, I suspect that designing personality models will be in the 90s what designing programming languages was in the 70s. Everybody will do it, we’ll have lots of religious wars over which model is best, and nobody can know what the outcome will be. Can you imagine the personality model analogues of FORTH and APL?

However, just as with programming languages, there are some rules of thumb that we can bring to bear on the design of personality models.

A personality model will consist of a set of traits, or variables. These are numbers that define the personality of the character. One such trait might be gullibility, the degree to which a character is willing to believe other people’s assertions.

At this point we run into a fundamental question: what kind of number to we want to represent our character attributes? This may seem like a strange question to the nonprogrammer, but it can be very important. There are two basic approaches: floating point values and integers.

The floating point value permits more accurate calculations. When using a floating-point value, the character attribute would be assigned a value between 0 and 1. Thus, a person with gullibility of 1.0 is totally, completely gullible ("Golly gee, you’ll really sell me the whole Brooklyn Bridge for just $100? That’s a real bargain!") whereas a person with a gullibility of 0.0 believes nobody ("You think that just because we’re in the Vatican and you’re wearing that white robe and surrounded by all those guys in red, that I’m gonna believe that you’re really the Pope? I’m not that dumb!")

However, floating point values take up lots of memory to store (typically six bytes per value) and they take lots more CPU time to process (typically 10 - 100 times as much CPU time as integers). My experience has been that the RAM costs of using floating point values for personality attributes are not worth worrying about. However, the costs in execution speed are, in my opinion, a significant factor. My experience with a 40 MHz 68030 suggests that, even with integer calculations, execution times for complex interactive storytelling calculations are significant. With floating point calculations, I believe that execution times would impose a significant constraint on the performance of the system as a whole. However, I have not performed the detailed execution time analyses necessary to assign great confidence to my hunch.

My own project uses integer values for personality attributes. In this case, each attribute falls in the range 0 - 100. This allows me to multiply two of these integers together and still remain in the safe zone for 16-bit calculations. It would not be difficult to extend these values to 32-bit longwords, with attribute ranges of 0 - 10,000. In fact I think that it would be advisable, because I have encountered one class of calculation in which roundoff error is a significant problem.

My overall conclusions as to word size are as follows: with 32-bit processors, the 16-bit integers offer few speed advantages and some significant problems with roundoff error. I suspect that 32-bit integers are the ideal word for personality modelling with such processors. While I suspect that 32-bit integers would offer overall better performance than floating-point values, I would not take issue with a designer who opted for the floating-point values.

The next big question concerns the type of attributes permitted. There are three broad types of attributes: one-dimensional, two-dimensional, and three-dimensional.

One-dimensional attributes are traits intrinsic to the character alone, traits such as gullibility, greed, pride, and so forth.

Two-dimensional attributes concern the character’s relationship with other characters, such as affection, trust, or respect.

Three-dimensional attributes concern the character’s perception of other characters’ relationships with each other. Does Mary think that Joe loves his secretary? Does John believe that Fred respects his boss? These are important factors in the prosecution of gossip.

I have described these attributes as falling in a positive numeric range: 0 to 1 or 0 to 100. In practice, it’s a little more complicated. One-dimensional attributes are best used in this positive range, but the two- and three-dimensional attributes are more readily handled as signed variables. Thus, gullibility is something that you can have little of or lots of, but there’s no such thing (in my system) as "negative gullibility". On the other hand, trust can definitely be negative. Zero trust is not as bad as active distrust.

This distinction between unsigned variables and signed variables is based on much experience with using personality models. There are plenty of cases in which, in writing your behavior equations, you want to take advantage of the sign of the personality attribute. Suppose, for example, that Tom observes Fred punching Joe, and we wish to calculate Tom’s reaction, which in turn depends heavily on Tom’s affection for Joe. If Tom likes Joe, then he’ll be angry with Fred, but if he hates Joe, then he might applaud Fred. Such a reaction springs directly from the equations if we use signed variables.

Now that we know the broad classes of attributes, it is necessary to choose a set of likely attributes. What factors inform our selection?

The first factor is our desire for completeness. We need a set of attributes that cover the territory of our characters’ behavior. If, for example, our characters will be wheeling and dealing, then gullibility had better be one of the attributes in our personality model. On the other hand, if this is a kiddie game, with no sexual behavior considered, then we really don’t need to keep track of each character’s lust value. In general, we want a broad set of attributes that cover all the bases. The temptation then becomes to pile on the attributes, to build a big model with lots and lots of attributes, to be absolutely certain that we’ve got everything covered. And why shouldn’t we? Adding another attribute costs perhaps two bytes per character. Big deal, pile ’em on, right?

Wrong. Designing a personality model is like designing a programming language. Every beginning programmer at some time attempts to design his own language, and the most common error in these cases is "kitchen sink design". He throws in all sorts of obscure, clever, picayune features that make perfect sense to the designer and are utterly obscure to everybody else. A programming language is meant to be used, and it is not practical to learn a language that is cluttered with a large set of special-case, narrow-application capabilities. In the same way, a personality model needs parsimony. If you pile on too many attributes, when it comes time to actually use the model, you’ll have a hell of time figuring out how to apply the different attributes. Should Fred’s reaction to Tom’s abusive words be based on Fred’s respect for Tom, or his dominance over him, or his fear for him, or his innate submissiveness, or perhaps his affection for Tom would cause him to overlook Tom’s behavior, but then there’s Fred’s pride to consider, and his natural volatility he might lose his temper -- but his self-confidence could alleviate that... Aargh!!! Too many variables make your design work harder, not easier.

What you need is orthogonality, the mathematical notion of independence. Two lines are orthogonal if they are at right angles to each other; moving down one line yields no motion in the direction of the other. If the two lines are at an angle other than a right angle, then moving down one line produces a partial displacement in the direction of the other line. You want much the same thing with your personality attributes. For example, respect and dominance are not orthogonal; if I respect you then I probably accord you some degree of dominance. On the other hand, lust and gullibility are probably orthogonal; if I know that you are gullible, that does not suggest how lusty you might be.

So we now have a means for establishing a good set of personality attributes. We want the biggest, most complete set of attributes whose members are orthogonal. (For all you math types, all I’m saying is that we want the set of orthogonal vectors that span the vector space of desired character personality.)

The next concept I will advance is the notion of correspondence between the different dimensions of attributes. In other words, we want each one-dimensional attribute to have a corresponding two-dimensional attribute and a corresponding three-dimensional attribute. This may sound abstruse, but it’s really quite simple. Gullibility is a one-dimensional attribute, a factor that is intrinsic to the personality of the character. Trust is the two-dimensional attribute analog of gullibility, and perceived trust is the three-dimensional attribute.

To refine the point, let me observe that there should really be two one-dimensional attributes for every two-dimensional attribute. The first attribute is the proclivity to accord the emotion in question to another person; the second attribute is the character trait that causes other characters to accord it to the character. In our example involving trust, these two attributes would be gullibility and honesty.

These are the basic principles you use in building a personality model.