The core of Drama Princess is the combination of
- the choice of interactions, based on afffection, and
- the effect of these interactions on that affection.
Drama Princess will choose the interaction that best matches the desire of the actor. This desire is a combination of the current affection for the object and the enthusiasm of the actor. When the interaction is done, Drama Princess changes the affection of the actor for the object by comparing the intimacy of the interaction with the affection for the object (with regards to the enthusiasm of the object, if the object is another actor).
If you say these things, it all sounds very plausible. But a first (undoubtedly bug-infested) implementation shows that the translation into mathematical formulas isn’t as “gentle” as the text version of the algorithm. This problem is much bigger and general than anything I can solve on my own (to allow computers to be more vague, less strict) but I do have to work around it. Currently this is done by adding some randomness to the mix. But random is just random. It’s equally strict as a formula, only unpredictable. So the whole thing jitters instead. Which is hardly a solution.
Another way to work around this is lag. Applying a change with lag means that you apply a combination of the previous change and the current change instead of only the current change. This allows for smoother transitions. Perhaps I should use more lag in Drama Princess. But it may not be sufficient.
Ultimately we want the affections of our actors to grow and shrink gently. Extreme changes in affections should be rare and will be interpreted as meaningful by the viewer (they would be the result of a shock, for instance). This is the main reason why Drama Princess is designed the way it is. But at first sight, we’re not getting the desired result. Perhaps, rather than tweaking our robots so they behave more like we expected, we should first take a good look at what we’re doing and what we want.
We want smooth emotional transitions. Perhaps the system we have designed (in particular the affection changing routine) is too strict and factual. Rather than trying to do things like
if the Object is an Actor
-if the difference between Intimacy and Affection is larger than (a fraction of) the Enthusiasm of the Object
--reverse desired effect:
---if Attitude is positive, Affection decreases
---else, Affection increases
-else
--confirm desired effect:
---if Attitude is positive, Affection increases
---else, Affection decreases
else
-if Object is inanimate (i.e. does not have Enthusiasm), Affection will get better if you do something nice, and vice versa)
--if Intimacy is greater than Affection
---Affection increases
--else
---Affection decreases(literal quote from the Drama Princess development wiki)
perhaps we should find a way to say something like
increase the affection slightly if you did something sort of nice and decrease it slightly if you did something that was really bad.
So don’t compare things too much. Just take them for what they are.
Unless you really dislike the object. Then you should say the opposite
decrease the affection slightly if you did something sort of bad and increase it slightly if you did something that was really good.
But only if you really really dislike the object.
The problem with math -unless you use something insanely complex like fuzzy logic (that I just can’t wrap my brain around)- is that there always needs to be a break off point: e.g.
affection below -0.5 is considered dislike.
So -0.4 is still ok and -0.6 is really bad. This destroys the smoothness of our transitions.
Up until now, I have tried to use gliding scales to solve this. Something like
the closer to the break off point, the less likely a severe impact will be
or something. But this doesn’t seem satisfactory anymore. It’s just too mathematical. Too precise. Not gentle enough. Smoothness seems to be an exception with such an algorithm while jitter is the rule. The opposite of what we want.
One of the problems is that Attitude (= whether or not the actor wants to improve the relationship) is too strict. Currently Attitude is generated on the fly based on Affection. It is more likely to be positive if the affection is positive and more likely to be negative if the affection is negative. And when the affection is neither here nor there, Attitude becomes more random. The “more likely” part is expressed by comparing a random number with a fixed number and this doesn’t seem like a good idea anymore.
Attitude should be more consistent.
It needs to be expressed as either positive or negative because this allows for choices regarding an intention to improve a relationship or not. Which is important for consistency. But a switch between positive or negative shouldn’t be made lightly. Perhaps Attitude can be stored internally as a range. Like a health bar in a video game: you’re still alive as long as your health is not completely down, and every hit only decreases it a bit. As long as you “have health”, your Attitude is positive. But the attitude bar, unlike the health bar, should continue in the negative as well.
Anyway, this is only one part of the problem.
The real question is
Should we throw out some of emotion metaphor and replace it by more formal, abstract systems that simply garantee smoothness?
The emotion and relationship metaphor may be confusing things. After all, our goal is not to build a simulator (of emotions in the actor) but rather a generator (of emotions in the viewer)!