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.

Resource insertions immediately bump the Resources generation counter so that the convergence loop in App can detect them without needing to inspect the world after every flush.

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.

Bumps the Resources generation counter immediately so the convergence loop knows another pass is needed even before the command buffer is flushed.

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>

fn requires() -> Vec<RequiredResource>

Resource types this parameter unconditionally needs present to avoid panicking. Used by App to validate — before running a non-convergent stage’s systems — that every hard requirement is already satisfied, failing fast with a clear message instead of panicking deep inside whichever system happens to run first.