How to fast forward time (or just skip it) properly?

Thanks for the suggestions. I still don't quite understand why its bad that the deltaTime goes faster.

So if it takes 1/3 of a second to skip the dialog, your worldTime will advance by 30 seconds.

Just for me to understand, lets say the dialog line would normally take 10 seconds. When I do the fast forward time will go faster 90x so ins$$anonymous$$d of 10 sec it would be 0.1sec right? What I don't understand is why the worldTime doesn't also just go faster so that in 0.1 secs it adds 10 seconds to its total time (just like it would have it I had waited for the dialog line to go).

As for the suggestions, I have other things attached to the worldTime (sun angle and rotation and other events dependent on what time it is on the clock) so if I only speed up the letterPause I won't really get the speed up that I need for the other things in the world.

The save/restore worldTime seems like a good suggestion but still makes me wonder why its "wrong" in the first place. I think I need to understand why there is a discrepancy between both!

Your logic is backwards. Here is a script to show you what is going on. Attach it to an empty game object, set factor as appropriate, and hit play:

 #pragma strict
 
 var factor = 90.0;
 private var sumTime = 0.0;
 
 function Start() {
     Time.timeScale = factor;
 }
 
 function Update() {
     sumTime += Time.deltaTime;
 }
 
 function OnGUI() {
     GUI.Label(Rect(0,0,500, 50), "Time since startup: "+Time.realtimeSinceStartup);
     GUI.Label(Rect(0,75,500, 50), "Time.time: "+Time.time);
     GUI.Label(Rect(0,150,500, 50), "Sum of deltaTime "+sumTime);
 }

The first number is real world time. That is, it would match a stop watch or the second hand on your watch. The second number is Time.time which is the game time. The third number is the sum of all deltaTimes which will be very close to Time.time.

With the default value of 90 for 'factor', you will see that when one second passes in the real world, you end up with 90 seconds passing in the game world. At 10 seconds real time, you have 900 seconds of game time.

Think about what happens in a game. If we are scaling things by deltaTime for movement, and we speed up Time.timeScale by a factor of 90, then each deltaTime will also be increased by a factor of 90 causing things to move further each frame.

Thanks for taking the time to explain me this!

I think I now understand the concept that time.deltaTime will increase exponentially depending on how much I multiply it by the timeScale.

This makes sense to me :

With the default value of 90 for 'factor', you will see that when one second passes in the real world, you end up with 90 seconds passing in the game world. At 10 seconds real time, you have 900 seconds of game time.

Now I made a little experiment on my side. I scripted a character walking to another character and say a line. Once the line is said I paused the editor window programmatically to see the times I get.

This are the additions I did to the gui times (the game clock starts at 7.32pm):

 function OnGUI() {
     GUI.Label(Rect(0,0,500, 50), "Time since startup: "+Time.realtimeSinceStartup.ToString("f2") + "secs");
     GUI.Label(Rect(0,20,500, 50), "Time.time: "+Time.time.ToString("f2") + "secs");
     GUI.Label(Rect(0,40,500, 50), "Sum of deltaTime "+sumTime.ToString("f2") + "secs");
     GUI.Label(Rect(0,60,500, 50), " gameTime " + worldTime.ToString("f2") + "secs");
     GUI.Label(Rect(0,80,500, 50), " gameClock " + hour + ":" + $$anonymous$$utes);
 }

Case 1: TimeScale is always 1 through the whole thing. This is what i get when the game is paused at the end of the dialog line:

Case 2: Here I speed up the timeScale to 90 the moment the character starts to say the line. This are the results at the end of the dialog line:

And this is the exact moment the character starts to say the line and I change the timeScale from 1 to 90 (2.13secs into the game):

Now what I would assume is that the second example would have Time.time/Sum of deltaTime/gameTime just like the first case BUT with a shorter Time since startup since I made the dialog that originally took 3 seconds to take only 0.7 secs.

Thanks for the patience so far :)

What I keep thinking is if I'm staying at timeScale = 90 for too long. $$anonymous$$aybe what is happening is that the "speed up" dialog line is actually taking longer than it should?

What happens to this function that I use for the time it takes to say a line? Does it get scaled correctly?

 function DoTextLine (){
     currentDisplayLine = null;
  
     for (var letter in currentScriptStep.textLine.ToCharArray()) {
        currentDisplayLine += letter;
        yield WaitForSeconds (letterPause);
     }
  
     yield WaitForSeconds (endDialogPause);
  
     currentState = DialogStates.Idle;
 }

If the dialog line takes 3.13 secs (5.26 - 2.13 secs) at timeScale =1, then if it would take 0.03 secs at timeScale = 90 right?

So on the Case 2 the Time since startup should read 2.13/2.14 secs and not 2.92secs, its like the function DoTextLine is taking a lot longer than 0.03 seconds to execute.

Case 2: Here I speed up the timeScale to 90 the moment the character starts to say the line. This are the results at the end of the dialog line:

Now what I would assume is that the second example would have Time.time/Sum of deltaTime/gameTime just like the first case BUT with a shorter Time since startup since I made the dialog that originally took 3 seconds to take only 0.7 secs.

The difference between Time.time and Time startup is approximately what I would expect. If your dialog is taking .25 seconds and you set Time.timeScale = 90, then Time.time will increase by approximately 22.5 during the time the dialog is up. I don't know how you are capturing your data, but 21 seconds different is approximately what I would expect to see.

But as mentioned earlier, saving and restoring worldTime is a solution regardless of how these numbers pan out.