Struct WorldHandle 

pub struct WorldHandle {
    pub entity: Entity,
    pub sender: JobSender,
    pub state: SnapshotReader<WorldState>,
    status: ThreadStatus,
}

A cloneable handle to a spawned world.

It carries the host entity the world’s proxy component lives on, a cloneable command sender, and the state the world publishes about itself. It can be handed to the world that queues work without the host’s World in hand. Cloning it does not spawn anything: the world lives on until the host drops the proxy entity.

Fields

entity: Entity

The host entity the world’s proxy component lives on.

sender: JobSender

The command queue. Queueing through send never blocks: a full or stopped queue reports SendError and hands the job back.

state: SnapshotReader<WorldState>

What the world is doing, and how it ended.

A world publishes its state, so a reader that arrives after the end still learns how the world ended, and reading never takes the answer away from another reader.

status: ThreadStatus

Implementations

impl WorldHandle

pub fn new(entity: Entity, sender: JobSender) -> Self

Bind a handle to the entity carrying the world’s proxy.

A runner of the caller’s own builds its handle this way: the world it drives shares its thread, so it stays running until that runner ends it.

pub(crate) fn with_status( entity: Entity, sender: JobSender, status: ThreadStatus, ) -> Self

Bind a handle to a world the spawn functions drive themselves.

pub fn is_finished(&self) -> bool

Whether the world has stopped or died.

It reads the same state the world publishes, so a world of any kind answers it: a threaded world when its thread ends, a stepped world when its tick ends or its owner despawns it, and a sub-world when its host stops it or drops it.

pub fn stop(&self)

Ask the world to stop, without waiting for it.

The world ends on its driver’s next turn — the thread’s next loop, the host’s next step_stepped_world or drain_sub_world — and only then does its queue close. A job sent in between is accepted and then dropped, so a caller that must know the job ran reads state rather than trusting the send.

Trait Implementations

impl Clone for WorldHandle

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.