Struct bevy_proto_typetag::data::ProtoCommands

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

A wrapper around [EntityCommands] and ProtoData for a specified prototype. This allows ProtoData to be accessed with the underlying prototype directly, and grants direct access to the [EntityCommands] that spawned that prototype in.

Implementations

impl<'w, 's, 'a, 'p> ProtoCommands<'w, 's, 'a, 'p>

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

Get raw access to [EntityCommands]

pub fn protoype(&self) -> &dyn Prototypical

Get the associated prototype

pub fn raw_data(&self) -> &ProtoData

Get raw access to the underlying ProtoData resource

pub fn get_handle<T, I>( &self, component: &dyn ProtoComponent, id: I ) -> Option<Handle<T>>where T: Asset, I: Into<HandleId>,

Get a cloned handle

Arguments

• component: The ProtoComponent this handle belongs to
• id: The handle’s id

returns: Option<Handle>

pub fn get_handle_weak<T: Asset>( &self, component: &dyn ProtoComponent, id: HandleId ) -> Option<Handle<T>>

Get a weakly cloned handle

Arguments

• component: The ProtoComponent this handle belongs to
• id: The handle’s id

returns: Option<Handle>

pub fn get_untyped_handle( &self, component: &dyn ProtoComponent, id: HandleId, asset_type: Uuid ) -> Option<&HandleUntyped>

Get a untyped handle reference

Arguments

• component: The ProtoComponent this handle belongs to
• path: The handle’s path
• asset_type: The asset type

returns: Option<&HandleUntyped>

Methods from Deref<Target = 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, 'p> Deref for ProtoCommands<'w, 's, 'a, 'p>

type Target = EntityCommands<'w, 's, 'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'w, 's, 'a, 'p> DerefMut for ProtoCommands<'w, 's, 'a, 'p>

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

Mutably dereferences the value.

impl<'w, 's, 'a, 'p> From<ProtoCommands<'w, 's, 'a, 'p>> for EntityCommands<'w, 's, 'a>

fn from(cmds: ProtoCommands<'w, 's, 'a, 'p>) -> Self

Converts to this type from the input type.