Java游戏开发教程中Game Loop及Delta变量理解求助

Hey there! Let’s break down this game loop code and demystify the delta variable—this is a core concept for keeping your game consistent across different hardware, so let’s take it step by step.

First, What’s the Point of This Game Loop? #

The goal is to run your game’s logic updates (like moving characters, checking collisions, or updating scores) at a stable, fixed rate—in this case, 60 times per second (60 Ticks Per Second, or TPS). Without this, your game would run super fast on powerful PCs and crawl on slower ones, which is obviously not ideal.

Let’s Walk Through Each Variable in the Code #

Let’s break down what each line does to see where delta fits in:

• long lastTime = System.nanoTime();: We start by recording the current time in nanoseconds (super precise, which we need for accurate timing).
• final double amountOfTicks = 60.0;: We want our game logic to update 60 times every second.
• double ns = 1000000000 / amountOfTicks;: Calculates how many nanoseconds should pass between each logic update. For 60 TPS, that’s ~16,666,666 nanoseconds per tick.
• double delta = 0;: This is our "time accumulator"—the star of the show.

The Role of delta (Finally!) #

Think of delta as a counter that tracks how much "tick time" has accumulated since the last logic update. Here’s how it works in the loop:

1. long now = System.nanoTime();: Grab the current time every loop iteration.
2. delta += (now - lastTime) / ns;: Calculate the time that’s passed since the last loop (now - lastTime), then divide by the nanoseconds per tick (ns). This tells us how many full "tick intervals" have passed. For example:
   • If 33,333,332 nanoseconds passed (twice the interval for one tick), (now - lastTime)/ns equals 2, so delta becomes 2.
3. if(delta >= 1) { tick(); delta --; }: Once delta is 1 or more, we’ve waited long enough to run a logic update. We call tick() (your game’s logic code), then subtract 1 from delta because we’ve "used up" one tick’s worth of time.
   • If delta was 2, this would run tick() twice, subtracting 1 each time until delta is back to 0.

Why This Matters #

This system ensures your game’s logic runs at exactly 60 TPS no matter what:

• If your PC is fast, the loop will run many times, but delta will only hit 1 every ~16ms, so tick() runs 60 times per second.
• If your PC is slow and takes 33ms between loop iterations, delta will jump to 2, and tick() will run twice in a row to catch up. This way, your game’s logic doesn’t slow down—your character still moves the same distance per second, even if the frame rate drops.

A Quick Fix for the Code #

Wait, there’s a small missing piece in your code! You need to update lastTime = now; at the end of the loop, otherwise now - lastTime will keep getting bigger every iteration, and delta will spiral out of control. Here’s the corrected loop:

public void run() { 
    long lastTime = System.nanoTime(); 
    final double amountOfTicks = 60.0; 
    double ns = 1000000000 / amountOfTicks; 
    double delta = 0; 
    while(running) { 
        long now = System.nanoTime(); 
        delta += (now - lastTime) / ns; 
        lastTime = now; // Add this line!
        while(delta >= 1) { // Using a while loop here handles multiple missed ticks at once
            tick(); 
            delta --; 
        } 
    } 
}

Using a while loop instead of if ensures we catch up on all missed ticks if a lot of time passed (like if the game froze for a moment).

内容的提问来源于stack exchange，提问作者J.Ramsey