Struct rfw::ecs::Commands

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

A list of commands that will be run to modify a World

Implementations

impl<'a> Commands<'a>

pub fn new(queue: &'a mut CommandQueue, world: &'a World) -> Commands<'a>

pub fn spawn(&mut self) -> EntityCommands<'a, '_>

Creates a new empty entity and returns an EntityCommands builder for it.

Example

use bevy_ecs::prelude::*;

fn example_system(mut commands: Commands) {
    // Create a new empty entity and retrieve its id.
    let empty_entity = commands.spawn().id();

    // Create another empty entity, then add some component to it
    commands.spawn()
        // adds a new component bundle to the entity
        .insert_bundle((1usize, 2u32))
        // adds a single component to the entity
        .insert("hello world");
}

pub fn spawn_bundle<T>(&'b mut self, bundle: T) -> EntityCommands<'a, 'b> where
    T: Bundle, 

Creates a new entity with the components contained in bundle.

This returns an EntityCommands builder, which enables inserting more components and bundles using a “builder pattern”.

Note that bundle is a Bundle, which is a collection of components. Bundle is automatically implemented for tuples of components. You can also create your own bundle types by deriving Bundle.

Example

use bevy_ecs::prelude::*;

struct Component1;
struct Component2;

#[derive(Bundle)]
struct ExampleBundle {
    a: Component1,
    b: Component2,
}

fn example_system(mut commands: Commands) {
    // Create a new entity with a component bundle.
    commands.spawn_bundle(ExampleBundle {
        a: Component1,
        b: Component2,
    });

    commands
        // Create a new entity with two components using a "tuple bundle".
        .spawn_bundle((Component1, Component2))
        // spawn_bundle returns a builder, so you can insert more bundles like this:
        .insert_bundle((1usize, 2u32))
        // or insert single components like this:
        .insert("hello world");
}

pub fn entity(&mut self, entity: Entity) -> EntityCommands<'a, '_>

Returns an EntityCommands builder for the requested entity.

Example

use bevy_ecs::prelude::*;

fn example_system(mut commands: Commands) {
    // Create a new, empty entity
    let entity = commands.spawn().id();

    commands.entity(entity)
        // adds a new component bundle to the entity
        .insert_bundle((1usize, 2u32))
        // adds a single component to the entity
        .insert("hello world");
}

pub fn spawn_batch<I>(&mut self, bundles_iter: I) where
    I: IntoIterator + Send + Sync + 'static,
    <I as IntoIterator>::Item: Bundle, 

Equivalent to iterating bundles_iter and calling Self::spawn on each bundle, but slightly more performant.

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

See World::insert_resource.

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

pub fn add<C>(&mut self, command: C) where
    C: Command, 

Adds a command directly to the command list. Prefer this to [Self::add_command_boxed] if the type of command is statically known.

Trait Implementations

impl<'a> SystemParam for Commands<'a>

type Fetch = CommandQueue