200 lines
14 KiB
Markdown
200 lines
14 KiB
Markdown
# Aetheria arena, cut sim-rate: one game tick, lowered for game and arena alike
|
|
|
|
Date: 2026-10-22. Status: map, drafted by Imagination for Self to commit beside `docs/aetheria-arena-target.md`.
|
|
Body pinned at `GameCult/Aetheria` origin/master `0267a191` (view-seam merged). Every claim below was probed on that tree.
|
|
Spec: `aetheria-arena:cut_spec:cut-sim-rate.r1`. Question: `aetheria-arena:question:sim-tick-rate`.
|
|
|
|
## 1. What the operator said
|
|
|
|
On 2026-10-21, while we were talking about Colosseum throughput (session transcript `53e9c70e`, lines 4811-4879):
|
|
|
|
- "So we can expect 160x realtime for the Colosseum? That's not bad, we can gather a few thousand matches per hour per
|
|
thread on Yggdrasil, then?"
|
|
- "I think we can fudge the time step just a little, as long as there's enough resolution for all the relevant decisions"
|
|
- "Projectiles are roll based, their flight is pure presentation, I made that decision partly with this in mind"
|
|
- "Physics definitely doesn't need 60, not at the pace we're setting. I don't think it even needs 30."
|
|
- Answering Self's proposal (lower the whole game's step, chosen by a timer check, an equivalence test and her playtest,
|
|
landing before the runner): "Go for it."
|
|
|
|
That is ruling `aetheria-arena:ruling:lower-game-sim-rate`. Her words decide two things: physics needs less than 60 Hz,
|
|
and probably less than 30. The proposal she approved decides the rest: the game's own rate is lowered (`A-one-sim` holds
|
|
unchanged), and the rate is chosen by the timer check, the equivalence test and her playtest.
|
|
|
|
Rulings already in force on the same clock (2026-10-07, campaign `aetheria-release`):
|
|
- `sim-speed-knob`: the sim's own clock owns pace; Unity's time scale is not touched.
|
|
- `sim-speed-surface`: a design speed in game data times the player's accessibility slow-down.
|
|
- `sim-speed-tenth`: the design speed will be about a tenth of today's; the tick rate stays hidden; the player's ship may be
|
|
extrapolated.
|
|
- `tick-rate-follows-design-speed`: the step follows the design speed, so the real-time tick rate is a chosen constant.
|
|
"6hz is the kind of rate players notice. But we definitely don't *need* 60."
|
|
- `tick-30hz-floor-half`: "30 Hz with 0.5 floor". TickRate is 30 Hz at design speed. The player's factor ranges from 0.5 to 1,
|
|
so the slowest tick is 15 Hz.
|
|
|
|
The design-speed and accessibility cut (`cut-sim-speed-scale.r2`) was withdrawn under `map-only-what-runs`. So on master the
|
|
game still runs at design speed 1 and 60 ticks per real second. The 30 Hz in `tick-30hz-floor-half` never landed. Her
|
|
2026-10-21 words ("I don't think it even needs 30") go below it, which is the fork in section 6.
|
|
|
|
## 2. Body facts
|
|
|
|
### Where the rate lives
|
|
|
|
- **Two hidden 60s.** `ActionGameManager.Clock = new SimClock(1f / 60f)` (`ActionGameManager.cs:251`) is the only clock
|
|
that steps the game. `SimClock`'s constructor defaults `stepsPerRealSecond = 60` (`SimClock.cs:21`). The two are
|
|
independent: changing the step to 1/20 while leaving the default would run 60 steps of 1/20 s per real second, which
|
|
makes the game three times faster. The 60 is decided twice, by two writers that do not know about each other.
|
|
- **ServerShared has no game rate.** `Zone.Update(float deltaTime)` (`Zone.cs:356`) steps by whatever it is given. Every
|
|
sim rule integrates the `dt` it is handed. Nothing in ServerShared knows the game's step.
|
|
- **The headless drivers choose their own step.** There is no runner yet. The tests that pin game histories step with
|
|
literals: the two-AI digest (`DeterminismLedgerTests.cs:217`, `arena.Update(1f / 60f)`, 3600 steps) and the Duel history
|
|
(`SimClockTests.OneHistoryTwice`, `ClockFrame = 1f / 60f`, `:134`). The tests contain 64 `1f / 60` literals, 31 of them
|
|
`Update(1f / 60f)` calls. Most are physics fixtures that need some small step, not the game's step.
|
|
- **Unity's fixed timestep is not the sim.** No `FixedUpdate` or `Rigidbody` exists in `Assets/Scripts`. The sim steps
|
|
only through `Clock.Advance(Time.deltaTime, ...)` (`ActionGameManager.cs:1333`). `ProjectSettings/TimeManager.asset`
|
|
decides nothing about the sim and is left alone.
|
|
|
|
### What assumes 60 Hz
|
|
|
|
The question is not whether a rule mentions 60. It is whether the rule's per-second meaning depends on the step.
|
|
|
|
- **Timers that drop their overshoot.** These rules restart a normalized countdown at 1 and discard what the last step
|
|
overshot:
|
|
- `InstantWeapon.Execute` (`InstantWeapon.cs:227-265`): the cooldown ends when `_cooldown < 0`. The next burst starts
|
|
only when a pilot triggers it again on a later step.
|
|
- `Cooldown.cs:51,60`.
|
|
- `Sensor` ping cooldown (`Sensor.cs:144-148,183`).
|
|
- `ConstantWeapon` ammo interval (`ConstantWeapon.cs:148-151`).
|
|
|
|
For the cooldown this works out to `floor(C/dt) + 1` steps per cycle, not `C/dt`. A 0.25 s cooldown fires every 16
|
|
steps at 60 Hz (0.267 s, 6.7% slow) and every 6 steps at 20 Hz (0.30 s, 20% slow). Damage per second is therefore a
|
|
function of the tick rate today, at 60 Hz as well. This is the rule that would make an equivalence test fail for the
|
|
wrong reason.
|
|
- **Timers that already carry.** Two rules keep their overshoot, so their per-second rates survive any step:
|
|
- the beam's roll cadence (`ConstantWeapon.cs:185-196`, `while (_beamTimer >= interval) _beamTimer -= interval`);
|
|
- the burst's round cadence (`InstantWeapon.cs:243-270`, several rounds in one step if the interval is shorter).
|
|
|
|
Transfer-verb's give budget (`CargoTransfer.cs:80-94` on its branch) carries too.
|
|
- **Passive sensing is a forward-Euler decay.** `Sensor.Execute` applies `next = saturate(previous + G dt)` and then
|
|
`next *= 1 - TargetInfoDecay * dt` (`Sensor.cs:225-231`). Its fixed point is `G (1 - k dt) / k`, not the `G / k` that
|
|
`Entity.PassiveInfo` documents and returns (`Entity.cs:518-532`). The bias is `k dt`: detection ranges shrink as the
|
|
step grows. The exact form, `x e^{-k dt} + (G/k)(1 - e^{-k dt})`, settles at `G / k` at every step. A ping is an impulse
|
|
with no `dt` (`Sensor.cs:251-254`) and is step-free.
|
|
- **Rules that are step-free already.**
|
|
- Drag is `decay(v, drag, delta)` (`Ship.cs:132`).
|
|
- Shots are rolls: commit and arrival are sim times checked each step (`FireControl.Step`, `CommitHorizon = .5 s`), so a
|
|
resolution lands up to one step late, never differently.
|
|
- Tunnelling does not exist for rounds (ruling `projectile-flight-is-presentation`).
|
|
- One-tick notifications (paints, ping crossings, `IncomingPaints`) are defined per tick and read per tick
|
|
(`ActionGameManager.cs:1336-1340`).
|
|
- **Integration error that remains.** Ship motion is stepped explicitly. At a larger step, a hard-turning ship's arc and the
|
|
in-arc and in-range test at commit move by O(dt). This is the residual her "fudge" admits. The equivalence test measures
|
|
it.
|
|
- **Hull contact.** `Contacts.Step` tests overlap after every move. A closing speed times the step that exceeds the
|
|
smallest hull's radius can pass through. The cut checks the catalog's fastest ship against its smallest hull at the
|
|
chosen step.
|
|
|
|
### How the render covers the step
|
|
|
|
`DrawAhead` (`DrawAhead.cs:13-19,114-139`) draws every moving thing at `T = Zone.ExactTime + Clock.Lead`:
|
|
- closed-form poses (orbits, belts, the field) at T;
|
|
- integrated poses (ships, bodies) as the last step plus step velocity times `Lead`;
|
|
- the ship's heading turned by `TurnRate * Lead`.
|
|
|
|
This is extrapolation (dead reckoning), not interpolation. It adds no latency, and presenters store no previous state, by
|
|
rule. At 20 Hz, `Lead` reaches 50 ms. The visible cost is a snap whenever velocity or turn rate changes between steps:
|
|
about `Δω * Lead` in heading (a full turn-rate reversal of 3 rad/s gives 0.15 rad at 20 Hz, against 0.05 at 60). Positions
|
|
move by `½ a Lead²`, which is negligible.
|
|
|
|
Input reaches the sim through `PilotCommand`. Held fields persist, and one-shots queue in order until the next step applies
|
|
them (`Pilot.cs:43-102`). A tap shorter than a step still fires, because a pull and then a release in one step both apply,
|
|
in order. The step costs the player up to one step of input lag: 33 ms at 30 Hz, 50 ms at 20 Hz.
|
|
|
|
### What the digest pins
|
|
|
|
`TwoAiDigestIsPinned` pins one SHA-256 over 3600 per-step `Snapshot`s of the two-AI fight at `1/60`, for host class
|
|
`linux-x64` (`DeterminismLedgerTests.cs:31-34,186-249`). It has been repinned twice, each for a stated cause. This cut
|
|
repins it once, for two causes landing together: the game step (the history has a different number of steps of a
|
|
different length), and the carried timers and exact sensor decay (cadence and detection change at any step). It still
|
|
pins the same simulated length: 60 s, which is `60 * TickRate` steps. `OneHistoryTwice` and `TwoAiFightIsOneHistory`
|
|
compare two runs and need no pin.
|
|
|
|
### Measured on Yggdrasil
|
|
|
|
**Not measured yet.**
|
|
- **The probe is ready.** `SimRateProbe.cs` sits beside this map. It runs a catalog timer survey and the two-AI fight over
|
|
120 simulated seconds at 60, 30, 20, 15 and 10 Hz, three reps each after a warm-up, and reports the best wall time,
|
|
shots, hits, first hull loss, first death and survivors.
|
|
- **Why it has not run.** It waited about an hour for a Yggdrasil slot. Then three runs failed in the fixture: the test
|
|
catalog now loads the first-party mod `aetheria.nakovalnya`, whose `ship.cc` and `ship.glb` are LFS objects the old
|
|
probe recipe did not resolve. With every pointer under `GameData` resolved, one is still missing.
|
|
- **The recipe to use.** transfer-verb's job script resolves LFS for current master
|
|
(`F:\Projects\eureka-handoff-aux-2026-10-19\imag-nak-r2\job.sh`).
|
|
- **What the earlier probe showed.** At d52b50f9 the Duel ran about 9,700 steps/s at 60 Hz, mostly with one ship alive.
|
|
- **Expectation, not a measurement.** The cost per step does not depend on dt, so cost per simulated second scales with
|
|
the tick rate: 2x at 30, 3x at 20, 4x at 15.
|
|
|
|
## 3. Prior art
|
|
|
|
- **Glenn Fiedler, "Fix Your Timestep!" (2004).** Use a fixed `dt`, an accumulator fed by real time, a clamp against the
|
|
spiral of death, and then draw either by interpolating the previous and current states (smooth, one step of added
|
|
latency) or by extrapolating. `SimClock` already is the accumulator and the clamp (`MaxFrameSeconds = .1`), and
|
|
`DrawAhead` is the extrapolating branch.
|
|
- **Supreme Commander (2007)** runs its sim at 10 ticks per second and draws interpolated, for fleets of hundreds. It is
|
|
the closest precedent for a large-unit, non-twitch game at a low tick.
|
|
- **StarCraft II** runs 16 game loops per sim second (22.4 per real second at Faster), with deterministic lockstep and
|
|
interpolated rendering.
|
|
- **Factorio** is fixed at 60 UPS, with every timer counted in ticks and lockstep multiplayer, and no decoupling of sim and
|
|
render rate. It is the counter-example: it keeps 60 because its belts and inserters are tick-quantised content. Ours are
|
|
per-second content.
|
|
- **EVE Online** runs its Destiny ball physics on a 1 Hz server tick, and clients interpolate and predict. It shows that
|
|
tactical space combat at a slow pace tolerates very coarse ticks when the player commands intent rather than twitch.
|
|
- **X4** steps the sectors the player is in at frame rate and the others at a much coarser, abstracted rate. That is the
|
|
living-world campaign's concern, not this cut's.
|
|
|
|
The lesson that carries over: content authored in seconds survives a step change only if every timer and integrator is
|
|
step-exact. Fiedler's accumulator gives that for the clock, and section 2's two families (timers that drop overshoot,
|
|
Euler decay) are the places where Aetheria does not have it yet.
|
|
|
|
## 4. Authority map
|
|
|
|
- **Owner.** `SimClock` owns the game's tick: `SimClock.TickRate` (steps per real second at design speed 1) and
|
|
`SimClock.GameStep = 1f / TickRate` (sim seconds per step). `SimClock.ForGame()` builds the game's clock from both.
|
|
- **Inputs.** None at run time. It is a code constant, so it is part of the code revision in `A-pure`'s tuple.
|
|
- **Outputs.** The `dt` every game-rate driver hands to `Zone.Update`, and `Lead`.
|
|
- **Derived.**
|
|
- `ActionGameManager.Clock` is `SimClock.ForGame()`.
|
|
- The digest, the Duel history and later the runner step by `SimClock.GameStep`.
|
|
- A timer's cadence and a sensor's settling level are functions of seconds, not of steps.
|
|
- **Demoted.**
|
|
- `SimClock`'s `stepsPerRealSecond` default is no longer an owner. The parameter becomes required, and the game's value is
|
|
derived from `TickRate`.
|
|
- `1f / 60f` in `ActionGameManager` is no longer an owner; it is derived from `SimClock.GameStep`.
|
|
- Physics fixtures may keep a literal step of their own, because they test physics, not the game's history.
|
|
- **Forbidden writers.**
|
|
- Any `new SimClock(` in `Assets/Scripts` other than `ForGame`.
|
|
- Any literal step in a driver of a pinned game history.
|
|
- A timer that resets to 1 and discards its overshoot.
|
|
- A per-step decay written as `1 - k * dt`.
|
|
- **Shared paths.** The player's game, the digest and Duel histories, and the future runner all step `Zone.Update` by
|
|
`SimClock.GameStep`. The design-speed cut, when re-mapped, sets `Step = DesignSpeed / TickRate` inside `ForGame` and
|
|
touches nothing else.
|
|
- **Deletion line.** The default `= 60` and the `1f / 60f` in `ActionGameManager` go first. The overshoot-dropping resets go
|
|
before the rate changes, so the rate change is measured on step-exact rules.
|
|
|
|
## 5. Not this cut
|
|
|
|
- **Brains deciding below the physics step.** The ruling allows it, and `PilotCommand`'s held fields already make it
|
|
possible. No brain-rate machinery lands here.
|
|
- **Design speed and the player's slow-down** (`sim-speed-scale`, withdrawn). `ForGame` is the one place where it will
|
|
land.
|
|
- **Render interpolation.** Extrapolation is ruled (`sim-speed-tenth`, DrawAhead's no-stored-state rule). Her playtest is
|
|
where a heading snap would show. If it does, interpolating the player's ship only is the follow-up, at one step of
|
|
latency.
|
|
- **Unity's `TimeManager` fixed timestep**, which the sim does not read.
|
|
|
|
## 6. The fork
|
|
|
|
`aetheria-arena:question:sim-tick-rate`: which tick rate Hands lands for her playtest, given `tick-30hz-floor-half`.
|
|
Options and recommendation are in the question. In short:
|
|
- 30 Hz keeps the in-force ruling and halves the cost.
|
|
- 20 Hz follows her 2026-10-21 words and costs a third, but at the 0.5 accessibility floor the real tick is 10 Hz.
|
|
- 15 Hz is a quarter of the cost and 7.5 Hz at the floor, near the 6 Hz she called noticeable.
|