Struct Sim 

pub struct Sim {
    pub world: World,
    pub step: Duration,
    pub max_steps: u32,
    /* private fields */
}

Fixed-step sim state. Game registers systems, feeds wall time with step, reads world for the snapshot.

Fields

world: World

Entity/component store. Game crates add their own components here.

step: Duration

Fixed step size. Default 60 Hz.

Each tick adds this to SimTime. Set before first step.

max_steps: u32

Max ticks per step call. Default 8.

Caps catch-up after hitches. Excess wall time is dropped. Clamped to a minimum of 1 so the sim keeps moving.

Implementations

impl Sim

pub fn new(step: Duration) -> Self

pub fn with_default_step() -> Self

60 Hz fixed-step sim.

pub fn add_system<M>(&mut self, system: impl IntoSystem<(), (), M>) -> &mut Self

Register a system into the per-step schedule.

pub fn add_chained_systems<M>( &mut self, systems: impl IntoScheduleConfigs<ScheduleSystem, M>, ) -> &mut Self

Register systems with a fixed execution order.

Use one (a, b, c).chain() tuple for pipelines that need order.

pub fn step(&mut self, dt: Duration) -> u32

Advance by dt wall time. Returns ticks run.

Small dt banks for later. Large dt runs up to max_steps ticks, then drops leftover whole steps. Example:

let steps = sim.step(frame_dt);

pub fn leftover(&self) -> Duration

Unconsumed time carried to the next frame. Below one step.

pub fn alpha(&self) -> f32

Blend factor accumulator / step, clamped to 0..1. Zero step returns 0.0. For render blending between snapshots: keep the previous snapshot and lerp toward the current one by this alpha (NT motion at 30 Hz sim on 144 Hz display needs it; without it every fast mover judders on 4-5 identical frames then jumps).

pub fn tick(&mut self)

Run the schedule once, advancing sim time by one step. Tick-model games drive this directly instead of step.