Struct ThreadControl 

pub struct ThreadControl {
    stop: Arc<Stop>,
    self_driven: bool,
    last_tick: Mutex<Option<Instant>>,
}

How a world’s tick paces itself and observes a stop.

Every method may be called from inside the tick, which holds the control by shared reference only: the stop lives in a shared flag, so a tick that sleeps through the stop signal still sees it when it wakes.

Fields

stop: Arc<Stop>

The stop signal the world’s owner sends.

self_driven: bool

Whether a thread drives the world.

A world the host steps has no thread to sleep on: its waits return at once, and the host paces it by stepping it when a step is due.

last_tick: Mutex<Option<Instant>>

When the previous tick started, for a self-driven world’s elapsed time.

Implementations

impl ThreadControl

pub fn stop_requested(&self) -> bool

Whether a stop has been requested.

Once true, stays true.

pub fn self_driven(&self) -> bool

Whether a thread drives the world.

A world the host steps is not self-driven: its waits return at once, because the host is what decides when a step is due.

pub(crate) fn elapsed_seconds(&self) -> f32

Seconds since the previous tick, measured once per turn.

pub fn wait_timeout(&self, timeout: Duration)

Sleep for at most timeout, returning early when a stop is requested.

A world the host steps has no thread to sleep on, so this returns at once: the host owns the pacing, and one tick body then serves both modes unchanged.