Struct Commands 

pub struct Commands<'a> { /* private fields */ }

Deferred entity spawns and resource/observer mutations — applied at the end of the current stage, not immediately. Derefs to hecs::CommandBuffer for spawning/despawning entities and adding/removing components.

Implementations

impl<'a> Commands<'a>

pub fn insert_resource<T: 'static>(&mut self, value: T)

Queues a resource insert, applied once commands are synced.

pub fn remove_resource<T: 'static>(&mut self)

Queues a resource removal, applied once commands are synced.

pub fn trigger<E: 'static + Send + Sync>(&mut self, event: E)

Queues event to be dispatched to every observer registered for E via App::add_observer, once commands are synced (right after the system that called this returns — same tick, not necessarily end of stage).

Methods from Deref<Target = CommandBuffer>

pub fn insert(&mut self, entity: Entity, components: impl DynamicBundle)

Add components from bundle to entity, if it exists

Pairs well with World::reserve_entity to spawn entities with a known handle.

When inserting a single component, see insert_one for convenience.

pub fn insert_one(&mut self, entity: Entity, component: impl Component)

Add component to entity, if the entity exists

See insert.

pub fn remove<T>(&mut self, ent: Entity)

where T: Bundle + 'static,

Remove components from entity if they exist

When removing a single component, see remove_one for convenience.

pub fn remove_one<T>(&mut self, ent: Entity)

where T: Component,

Remove a component from entity if it exists

See remove.

pub fn despawn(&mut self, entity: Entity)

Despawn entity from World

pub fn queue(&mut self, f: impl FnOnce(&mut World) + Send + Sync + 'static)

Queue an arbitrary operation to be run on a World

pub fn spawn(&mut self, components: impl DynamicBundle)

Spawn a new entity with components

If the Entity is needed immediately, consider combining World::reserve_entity with insert instead.

pub fn run_on(&mut self, world: &mut World)

Run recorded commands on world, clearing the command buffer

pub fn clear(&mut self)

Drop all recorded commands

Trait Implementations

impl<'a> Deref for Commands<'a>

type Target = CommandBuffer

The resulting type after dereferencing.

fn deref(&self) -> &CommandBuffer

Dereferences the value.

impl<'a> DerefMut for Commands<'a>

fn deref_mut(&mut self) -> &mut CommandBuffer

Mutably dereferences the value.

impl SystemParam for Commands<'_>

type Item<'w> = Commands<'w>

The value actually handed to the system function.

type State = ((), (), ())

Per-system persistent state (e.g. Local’s stored value) — () for anything stateless.

fn fetch<'w>( world: &'w World, resources: &'w Resources, state: &'w mut Self::State, ) -> Self::Item<'w>