Simulation Time — Falling Behind and Catching Up

The Problem

The simulation runs a fixed step, 512 times a second. When the Brain cannot finish its steps in time — a stall, a slow machine, a burst of rollback — it owes real time. Today it repays up to 250 ms of that by running extra steps and drops the rest (Known Issue 35). Simulated time is then behind the clock for good: five seconds is no longer five seconds, and two machines under different load are at different moments.

Across a network the same gap shows up as freezing. An Owner that falls behind pushes the Authority into stalling the simulation for everyone (Known Issue 17), and nothing ever pulls a drifting Owner back (Known Issue 19, Networking Without Rollback #4).

The Idea

Time owed is kept, and there are several ways of paying it back. Each is a mechanism a game turns on or off and tunes; they work together, each doing what it is good at; and which of them a game wants depends on the game. The engine's part is to make every one available, to keep them from undoing each other, and to show at all times how far behind the simulation is and what is being done about it.

What Is Owed

Debt is counted in whole steps against that reference, not built up from per-loop times that are each clamped: the clamping is what loses time now. Being ahead is debt with the other sign, and the same mechanisms pay it.

A gap that is not lag — a breakpoint, a laptop asleep, a window held in a modal loop on a platform with no keep-alive — would otherwise be repaid as ten minutes of simulation. Past a configurable length a gap is treated as a suspension and the reference is moved up to now.

The Mechanisms

Pacing is the one that changes what the others have to do. With it, an Owner a few frames behind speeds up by a few percent for a moment rather than the Authority waiting for it, so the hard limits can sit far further out than 250 ms: they become a matter of how much history is kept, not of how little lag can be tolerated.

struct SimTimePolicy
{
    // 1. Pacing
    bool  Pacing        = true;
    float MaxSpeedUp    = 1.25f;   // the fastest the simulation may run to catch up
    float MaxSlowDown   = 0.90f;   // the slowest it may run to let an Authority catch up to it
    float PacingGain    = 0.5f;    // how hard it pushes: share of the debt repaid per second

    // 2-4. Cheaper catch-up
    bool  QuietFrames    = true;
    bool  CoarseCosmetic = false;
    bool  VariableStep   = false;  // refused in a build with rollback
    float MaxStepScale   = 8.0f;   // the longest a variable step may be, in fixed steps

    // 5-7. Past the cutoff
    float CutoffSeconds     = 2.0f;
    float SuspensionSeconds = 5.0f;   // a gap this long is not lag: start again from now
    PastCutoff OwnerDoes    = PastCutoff::Resync;
    PastCutoff HostDoes     = PastCutoff::SharedSlowdown;
    PastCutoff SoloDoes     = PastCutoff::SlowDown;      // or DropTime
};

What Follows From It

• Input lands on the frame it belongs to. Sentinel goes on polling through a Brain stall, and input is already a timestamped stream. With frames tied to a reference clock each has a span of real time, so what the player did during a stall is replayed at the moments they did it, not piled onto the first catch-up frame.
• Rollback is the same debt. Time spent resimulating is time owed; it is repaid by the same mechanisms and shows in the same number.
• Drawing is undisturbed by quiet frames. Encoder interpolates between the last two frames it was given; during a burst it gets the last one only. Under pacing the world runs a few percent fast or slow, evenly.
• What is not simulation follows real time. The fallback free camera moves by real elapsed time, not by steps run, so looking around stays smooth while the simulation struggles.
• It is all visible. Debt, the rate the simulation is running at, and which mechanisms are in use are engine statistics, shown by the overlay. The resilience demo gets a control for each setting, so the difference between them can be seen by turning them on and off under the same load.
• The tests change. Stress_BrainHitch and Stress_BrainOverrun assert today's loss of time as the policy. They come to assert each mechanism: a long stall repaid in full under pacing; a slow Brain reaching the cutoff and doing what the role says; a step that is variable only where it may be.

Build Order

Steps 1–6 need no network. Steps 7 and 8 come with Host, Join, and Solo.

Decisions

Proposed. Each needs a yes, a no, or a different answer.

Open Questions

• How pacing and a display's refresh interact: a simulation at 1.25× under a 60 Hz display is a visible speed-up; whether the limit should tighten when the debt is small enough to hide entirely.
• Physics under variable step: Jolt is stepped once per eight fixed steps today. A longer step needs more collision sub-steps to stay stable, which costs back some of what was saved.
• What coarse cosmetic steps mean for a Volatile entity with a physics body.
• Sound during catch-up: what was triggered in quiet frames and is still relevant when the burst ends.