Struct apecs::Entity

pub struct Entity { /* private fields */ }

Associates a group of components within the world.

Entities are mostly just usize identifiers that help locate components, but Entity comes with some conveniences.

After an entity is created you can attach and remove bundles of components asynchronously (or “lazily” if not in an async context).

let mut world = World::default();
// asynchronously create new entities from within an async system
world.with_async_system("spawn-b-entity", |mut facade: Facade| async move {
    let mut b = facade
        .visit(|mut ents: Write<Entities>| {
            Ok(ents.create().with_bundle((123, "entity B", true)))
        })
        .await?;
    // after this await `b` has its bundle
    b.updates().await;
    // visit a component or bundle
    let did_visit = b
        .visit::<&&str, ()>(|name| assert_eq!("entity B", *name.value()))
        .await
        .is_some();
    Ok(())
});
world.run();

Alternatively, if you have access to the Components resource you can attach components directly and immediately.

Implementations

impl Entity

pub fn id(&self) -> usize

pub fn with_bundle<B: IsBundle + Send + Sync + 'static>(self, bundle: B) -> Self

Lazily add a component bundle to archetype storage.

This entity will have the associated components after the next tick.

pub fn insert_bundle<B: IsBundle + Send + Sync + 'static>(&mut self, bundle: B)

Lazily add a component bundle to archetype storage.

This entity will have the associated components after the next tick.

pub fn insert_component<T: Send + Sync + 'static>(&mut self, component: T)

Lazily add a component bundle to archetype storage.

This entity will have the associated component after the next tick.

pub fn remove_component<T: Send + Sync + 'static>(&mut self)

Lazily remove a component bundle to archetype storage.

This entity will have lost the associated component after the next tick.

pub async fn updates(&mut self)

Await a future that completes after all lazy updates have been performed.

pub async fn visit<Q: IsQuery + 'static, T: Send + Sync + 'static>(
    &self,
    f: impl FnOnce(Q::QueryRow<'_>) -> T + Send + Sync + 'static
) -> Option<T>

Visit this entity’s query row in storage, if it exists.

Panics

Panics if the query is malformed (the bundle is not unique).

Methods from Deref<Target = usize>

pub const MIN: usize = 0usize

pub const MAX: usize = 4_294_967_295usize

pub const BITS: u32 = 32u32

Trait Implementations

impl Clone for Entity

You may clone entities, but each one does its own lazy updates, separate from all other clones.

fn clone(&self) -> Self

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Entity

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for Entity

type Target = usize

The resulting type after dereferencing.

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

Dereferences the value.