How do I implement time scaling?

Question

I want to be able to change the game speed, to speed up or slow down all animations and gameplay. Ideally, this could also be set to a negative number to make everything go backwards.

I tried this:

I made everything dependent on a time variable, updated every frame from the OS time:

void calledEveryFrame()
{
    time = System.accurateTime();
}

Then I tried just scaling that time.

lastTime = time;
long now = System.accurateTime();
double diff = now - lastTime;       
time = (lastTime + diff * speed);

That obviously doesn't work, because you can't just multiply the speed times the difference because it is not called exactly regularly.

How do I do this correctly?

Answer 1

Some points:

1. You should make all your movements time-dependent, more specifically depending on the timeSinceLastFrame. That way, your game will run equally fast on all computers in the sense that the possible movement distances are aligned (not in the sense that you get the same FPS, because that of course depends on the hardware specs).

   So, your movements would look something like this:

   newPosition = oldPosition * direction * speed * timeSinceLastFrame;

   To now slow down the whole application, you can just decrease timeSinceLastFrame by a certain factor, resulting in slower movements of your objects.

   // At startup
   long lastTime = 0;
   long now = 0;
   long timesinceLastFrame = 0;
   
   // Each game loop run
   now = System.accurateTime(); // get new time
   timeSinceLastFrame = now - lastTime; // calculated time passed since the last frame, e. g. in milliseconds      
   timeSinceLastFrame *= 0.5; // to get the game to half speed
   lastTime = now; // update the value for the next loop run
   

2. Backtracing in a game is difficult, because in order to do so, you need to store all user input to be able to un-do that in the correct reverse order. And this also only works if the rest of your application is completely deterministic which it is not when being based on variable (= un-deterministic since dependent on something as uncontrollable as the overall system performance at any given point in time) timestamps.

A good general overview about the discussion: fixed timestamp vs. variable timestamp (variable not in your sense that you can slow down or speed up the game, but in the sense that the time between frames is not constant), can be found in this GameDev.SE thread. Another important source is this blog entry by Glen Fielder.

Answer 2

In most rendering applications this is called Delta time, or the time since the last frame update. For example, in most of my applicaitons I have a master loop that looks like this:

while(running){
    updateDelta();
    update(delta);
    render(delta);
}

with the functions:

void updateDelta() {
    long currentTime = (Sys.getTime() * 1000 / Sys.getTimerResolution());
    delta = (int) (currentTime - LAST_FRAME);
    LAST_FRAME = (Sys.getTime() * 1000 / Sys.getTimerResolution());
}

void update(float delta){
    ...
}

void render(float delta){
    ...
}

If you start of with this format, your application will:

• Always run at the same speed independent of system performance

• Be able to change the update speed(delta).