Struct EntityCommands 

pub struct EntityCommands<'w, 's, 'a> { /* private fields */ }

A list of commands that will be run to modify an entity.

Implementations

impl<'w, 's, 'a> EntityCommands<'w, 's, 'a>

pub fn id(&self) -> Entity

Returns the Entity id of the entity.

Example

fn my_system(mut commands: Commands) {
    let entity_id = commands.spawn_empty().id();
}

pub fn insert(&mut self, bundle: impl Bundle) -> &mut EntityCommands<'w, 's, 'a>

Adds a Bundle of components to the entity.

This will overwrite any previous value(s) of the same component type.

Panics

The command will panic when applied if the associated entity does not exist.

Example

#[derive(Component)]
struct Health(u32);
#[derive(Component)]
struct Strength(u32);
#[derive(Component)]
struct Defense(u32);

#[derive(Bundle)]
struct CombatBundle {
    health: Health,
    strength: Strength,
}

fn add_combat_stats_system(mut commands: Commands, player: Res<PlayerEntity>) {
    commands
        .entity(player.entity)
        // You can insert individual components:
        .insert(Defense(10))
        // You can also insert pre-defined bundles of components:
        .insert(CombatBundle {
            health: Health(100),
            strength: Strength(40),
        })
        // You can also insert tuples of components and bundles.
        // This is equivalent to the calls above:
        .insert((
            Defense(10),
            CombatBundle {
                health: Health(100),
                strength: Strength(40),
            },
        ));
}

pub fn remove<T>(&mut self) -> &mut EntityCommands<'w, 's, 'a>

where T: Bundle,

Removes a Bundle of components from the entity.

See EntityMut::remove for more details.

Example

#[derive(Component)]
struct Health(u32);
#[derive(Component)]
struct Strength(u32);
#[derive(Component)]
struct Defense(u32);

#[derive(Bundle)]
struct CombatBundle {
    health: Health,
    strength: Strength,
}

fn remove_combat_stats_system(mut commands: Commands, player: Res<PlayerEntity>) {
    commands
        .entity(player.entity)
        // You can remove individual components:
        .remove::<Defense>()
        // You can also remove pre-defined Bundles of components:
        .remove::<CombatBundle>()
        // You can also remove tuples of components and bundles.
        // This is equivalent to the calls above:
        .remove::<(Defense, CombatBundle)>();
}

pub fn despawn(&mut self)

Despawns the entity.

See World::despawn for more details.

Panics

The command will panic when applied if the associated entity does not exist.

Example

fn remove_character_system(
    mut commands: Commands,
    character_to_remove: Res<CharacterToRemove>
)
{
    commands.entity(character_to_remove.entity).despawn();
}

pub fn add<C>(&mut self, command: C) -> &mut EntityCommands<'w, 's, 'a>

where C: EntityCommand,

Pushes an EntityCommand to the queue, which will get executed for the current Entity.

Examples

commands
    .spawn_empty()
    // Closures with this signature implement `EntityCommand`.
    .add(|id: Entity, world: &mut World| {
        println!("Executed an EntityCommand for {id:?}");
    });

pub fn log_components(&mut self)

Logs the components of the entity at the info level.

Panics

The command will panic when applied if the associated entity does not exist.

pub fn commands(&mut self) -> &mut Commands<'w, 's>

Returns the underlying Commands.

Trait Implementations

impl<'w, 's, 'a> BuildChildren for EntityCommands<'w, 's, 'a>

fn with_children( &mut self, spawn_children: impl FnOnce(&mut ChildBuilder<'_, '_, '_>), ) -> &mut EntityCommands<'w, 's, 'a>

Creates a ChildBuilder with the given children built in the given closure

fn push_children( &mut self, children: &[Entity], ) -> &mut EntityCommands<'w, 's, 'a>

Pushes children to the back of the builder’s children. For any entities that are already a child of this one, this method does nothing.

fn insert_children( &mut self, index: usize, children: &[Entity], ) -> &mut EntityCommands<'w, 's, 'a>

Inserts children at the given index

fn remove_children( &mut self, children: &[Entity], ) -> &mut EntityCommands<'w, 's, 'a>

Removes the given children

fn add_child(&mut self, child: Entity) -> &mut EntityCommands<'w, 's, 'a>

Adds a single child

fn clear_children(&mut self) -> &mut EntityCommands<'w, 's, 'a>

Removes all children from this entity. The Children component will be removed if it exists, otherwise this does nothing.

fn replace_children( &mut self, children: &[Entity], ) -> &mut EntityCommands<'w, 's, 'a>

Removes all current children from this entity, replacing them with the specified list of entities.

fn set_parent(&mut self, parent: Entity) -> &mut EntityCommands<'w, 's, 'a>

Sets the parent of this entity.

fn remove_parent(&mut self) -> &mut EntityCommands<'w, 's, 'a>

Removes the parent of this entity.

impl<'w, 's, 'a> BuildChildrenTransformExt for EntityCommands<'w, 's, 'a>

fn remove_parent_in_place(&mut self) -> &mut EntityCommands<'w, 's, 'a>

Make this entity parentless while preserving this entity’s GlobalTransform by updating its Transform to be equal to its current GlobalTransform.

fn set_parent_in_place( &mut self, parent: Entity, ) -> &mut EntityCommands<'w, 's, 'a>

Change this entity’s parent while preserving this entity’s GlobalTransform by updating its Transform.

impl<'w, 's, 'a> DespawnRecursiveExt for EntityCommands<'w, 's, 'a>

fn despawn_recursive(self)

Despawns the provided entity and its children.

fn despawn_descendants(&mut self)

Despawns all descendants of the given entity.