Struct Commands 

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

Deferred world-mutation commands available as a system parameter.

Mutations are buffered and applied to the world after all systems in the current stage have finished running.

Implementations

impl<'a> Commands<'a>

pub fn insert_resource<T: Component>(&mut self, res: T)

Queue a resource insertion. Applied after the current stage finishes.

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

Queue a resource removal. Applied after the current stage finishes.

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 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) -> &Self::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl SystemParam for Commands<'static>

type Item<'a> = Commands<'a>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, _world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>