Struct Entity 

pub struct Entity { /* private fields */ }

Components associated by a common identifier.

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

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

use std::sync::Arc;
use apecs::*;

let mut world = World::default();
let mut facade = world.facade();

// here we use `smol` but `apecs` works with any async runtime
// asynchronously create new entities from within a future
let task = smol::spawn(async move {
    let mut b = facade
        .visit(|mut ents: ViewMut<Entities>| {
            ents.create().with_bundle((123, "entity B", true))
        })
        .await
        .unwrap();
    // 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();
    assert!(did_visit);
});

while !task.is_finished() {
    // tick the world
    world.tick().unwrap();
    // send resources to the facade
    world.get_facade_schedule().unwrap().run().unwrap();
}

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 from 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 = 18_446_744_073_709_551_615usize

pub const BITS: u32 = 64u32

Trait Implementations

impl AsRef<usize> for Entity

fn as_ref(&self) -> &usize

Converts this type into a shared reference of the (usually inferred) input type.

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 duplicate of the value.

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.