Struct CommandScope 

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

Builder API to construct hierarchies of relations from commands.

use bevy::prelude::*;
use aery::prelude::*;

#[derive(Relation)]
struct ChildOf;

#[derive(Component)]
struct C<const N: usize>;

fn sys(mut cmds: Commands) {
    cmds.spawn(C::<0>)
        .scope::<ChildOf>(|scope| {
            // 1, 2, 3 are implicitly `ChildOf` the last spawned entity (0)
            scope.add(C::<1>)
                 .add(C::<2>)
                 .add(C::<3>)
                 .scope::<ChildOf>(|scope| {
                      // 4, 5 are implicitly `ChildOf` the last spawned entity (3)
                     scope.add(C::<4>)
                          .add(C::<5>);
                 });
        });
}

Implementations

impl<T: Relation> CommandScope<'_, '_, '_, T>

pub fn scope<R: Relation>( &mut self, func: impl FnMut(&mut CommandScope<'_, '_, '_, R>), ) -> &mut Self

Scope the last spawned entity via R. Any targets or hosts that are added in the scope implicitly use R as the edge.

impl<R: Relation> CommandScope<'_, '_, '_, R>

pub fn add(&mut self, bundle: impl Bundle) -> &mut Self

Spawn an entity from a bundle and have it target the currently scoped entity via R.

pub fn add_target(&mut self, bundle: impl Bundle) -> &mut Self

Spawn an entity from a bundle and set it as a target of the currently scoped entity.

pub fn add_and( &mut self, func: impl for<'a> FnMut(&mut EntityCommands<'a>), ) -> &mut Self

Spawn an entity and have it target the currently scoped entity via. This function takes a closure to provide entity mut access.

pub fn add_target_and( &mut self, func: impl for<'a> FnMut(&mut EntityCommands<'a>), ) -> &mut Self

Spawn an entity and set it as a target of the currently scoped entity. This function takes a closure to provide entity mut access.