why is time faster in my virtual world?

[billjarrold]

(This is a post and a solution to a post! I first went to the trouble of writing it up. But going to that trouble caused me to figure out the problem. Since I had gone to the trouble of writing it up I figured I would post the problem and the solution).

Why is time in my virtual world seeming to go by so much faster than in the real world? In other words, an event (a waittime) that should last a few seconds seems to take a few hundredths of a second. Has anyone seen behavior like this?

One idea (see below as to why) is that time goes faster in complex worlds than it does for simple ones. Does anyone know if this is true or false?

Apart from world complexity, are there other hypotheses as to why time seems to speed up in some worlds?

Is this a sign that there is some sort of bug or bad practice in the code that created my world?

Here is some "ground truth" context to my question:

Thanks to the post by Jeff called "Vizard tech tip: Blinking Avatars"
(about making avatars blink their eyes), I am able to make avatars with
blinking eyes.

I used his code verbatim and it behaves as expected when I have a file that
has his verbatim code and nothing else. E.g. when I have this...

wait_blink = vizact.waittime(vizact.randfloat(1,5))

...blinks take, roughtly 2 to 5 seconds. And when I have this...

wait_blink = vizact.waittime(vizact.randfloat(1,2))

...they happen faster.

However, in *my* virtual world, if I use those parameters (and other parameters in his post) the blinks happen way to fast. My world has 9 avatars moving their heads according to an array of eulers, the avatars are sensitive to whether the human's HMD is pointed at them. (The avatars are constantly fading to invisible unless they are looked at and then they lighten up). This is why I say my world is more complex than the verbatim version from Jeff's post.

To make it look like a normal person, instead of saying...

wait_blink = vizact.waittime(vizact.randfloat(1,5))

...I find that I have to say...

wait_blink = vizact.waittime(vizact.randfloat(1000,5000))

...to make it look normal. Analogously I had to change the
eye close and open action speeds. Thus, where in Jeff's code
we find that 0.1 in the following...

close_eye = vizact.morph(BLINK_MORPH,1,0.1)
open_eye = vizact.morph(BLINK_MORPH,0,0.1)

..gives us a nice eye blink speed, it is too fast in my world. To make
it look normal in my world I need to do this...

close_eye = vizact.morph(BLINK_MORPH,1,200)
open_eye = vizact.morph(BLINK_MORPH,0,200)

...Any thoughts here?

Maybe the fact that my avatars are constantly having setEuler called on their heads so that their head motions can follow head motion recordings of real humans.

One more odd thing I do: As I newbie, I'm not sure how to make the avatars sit and stay still. I find there is a good animation that I can call and then call freeze on it. That way they stay put and look like normal people staying still
while seated...Here is how I do that...I basically have them (they are from the complete characters set) do action 32 and then freeze. However, they do action 32 sped up very fast (1000X) and then freeze. Thus, "to us humans" it basically looks like they are just sitting there frozen.

sit_and_freeze = vizact.animation(32, freeze = True)
avatar.addAction(sit_and_freeze)
avatar.speed(1000)

So, in sum, again my main questions are:

What are factors known to make virtual events or virtual time (such as waittime or morph events) happen faster?

Do complex worlds cause this?

Bad coding practices?

Constantly having setEuler called on avatar heads to animate head motion?

My hack for having the avatar assume a seated posture?

Other hypotheses?

Thanks,

Bill