Struct Sim 

pub struct Sim {
    pub world: World,
    pub step: Duration,
    pub time_scale: f32,
    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.

time_scale: f32

Sim speed multiplier. Zero or negative pauses the sim; a non-finite value runs at normal speed.

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 add_state<S: States>(&mut self, initial: S) -> &mut Self

Register a state set with its initial value.

Call once per state type, before on_enter/on_exit/on_transition. Transitions are applied at the head of each step, before the main schedule, so gameplay never observes a half-switched state.

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

where S: States,

Systems that run when state is entered.

Panics if add_state was not called for this state set first.

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

where S: States,

Systems that run when state is exited.

pub fn on_transition<S, M>( &mut self, exited: S, entered: S, systems: impl IntoScheduleConfigs<ScheduleSystem, M>, ) -> &mut Self

where S: States,

Systems that run on the exited -> entered edge.

pub fn set_state<S: States>(&mut self, next: S) -> &mut Self

Request a state change, equivalent to writing NextState<S> from a system. Panics if the state set was not registered.

pub fn state<S: States>(&self) -> &S

The current value of a state set.

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 step_with( &mut self, dt: Duration, after_tick: impl FnMut(&mut World), ) -> u32

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.