Struct scoundrel::Entities

pub struct Entities { /* private fields */ }

Entities holds the EntityIds to all entities: living, removed and dead.

A living entity is an entity currently present, with or without component.

Removed and dead entities don’t have any component.

The big difference is that removed ones can become alive again.

The life cycle of an entity looks like this:

Generation -> Deletion -> Dead
          ⬑–––––↵

Implementations

impl Entities

pub fn is_alive(&self, entity: EntityId) -> bool

Returns true if entity matches a living entity.

pub fn add_component<S>(
    &self,
    entity: EntityId,
    storages: S,
    component: <S as AddComponent>::Component
) where
    S: AddComponent, 

Adds component to entity, multiple components can be added at the same time using a tuple.
Entities is only borrowed immutably.

Panics

• entity is not alive.

Example

use shipyard::{EntitiesView, ViewMut, World};

let mut world = World::new();

let entity = world.add_entity(());

let (entities, mut u32s) = world.borrow::<(EntitiesView, ViewMut<u32>)>().unwrap();

entities.add_component(entity, &mut u32s, 0);

pub fn delete_unchecked(&mut self, entity_id: EntityId) -> bool

Deletes an entity, returns true if the entity was alive.
If the entity has components, they will not be deleted and still be accessible using this id.

pub fn add_entity<T>(
    &mut self,
    storages: T,
    component: <T as AddEntity>::Component
) -> EntityId where
    T: AddEntity, 

Stores component in a new entity and returns its EntityId.
Multiple components can be added at the same time using a tuple.

Example:

use shipyard::{EntitiesViewMut, ViewMut, World};

let world = World::new();

let (mut entities, mut usizes, mut u32s) = world
    .borrow::<(EntitiesViewMut, ViewMut<usize>, ViewMut<u32>)>()
    .unwrap();

let entity = entities.add_entity((&mut usizes, &mut u32s), (0, 1));
assert_eq!(usizes[entity], 0);
assert_eq!(u32s[entity], 1);

pub fn bulk_add_entity<T, I>(
    &mut self,
    storages: T,
    component: I
) -> BulkEntityIter<'_> where
    T: AddEntity + BulkReserve,
    I: IntoIterator<Item = <T as AddEntity>::Component>, 

Creates multiple new entities and returns an iterator yielding the new EntityIds.
Multiple components can be added at the same time using a tuple.

Example

use shipyard::{EntitiesViewMut, ViewMut, World};

let world = World::new();

let (mut entities, mut usizes, mut u32s) = world
    .borrow::<(EntitiesViewMut, ViewMut<usize>, ViewMut<u32>)>()
    .unwrap();

let entity0 = entities.bulk_add_entity((), (0..1).map(|_| {})).next();
let entity1 = entities.bulk_add_entity(&mut u32s, 1..2).next();
let new_entities =
    entities.bulk_add_entity((&mut u32s, &mut usizes), (10..20).map(|i| (i as u32, i)));

pub fn iter(&self) -> EntitiesIter<'_>

Creates an iterator over all entities.

pub fn spawn(&mut self, entity: EntityId) -> bool

Make the given entity alive.
Does nothing if an entity with a greater generation is already at this index.
Returns true if the entity is successfully spawned.

Trait Implementations

impl<'a> IntoIterator for &'a Entities

type Item = EntityId

The type of the elements being iterated over.

type IntoIter = EntitiesIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Entities as IntoIterator>::IntoIter

Creates an iterator from a value.

impl Storage for Entities

fn clear(&mut self)

Deletes all components of this storage.

fn memory_usage(&self) -> Option<StorageMemoryUsage>

Returns how much memory this storage uses.

fn any(&self) -> &(dyn Any + 'static)

Casts to &dyn Any.

fn any_mut(&mut self) -> &mut (dyn Any + 'static)

Casts to &mut dyn Any.

fn delete(&mut self, _entity: EntityId)

Deletes an entity from this storage.

fn name(&self) -> Cow<'static, str>

Returns the storage’s name.

fn sparse_array(&self) -> Option<&SparseArray<[EntityId; 32]>>

Returns a SparseSet’s internal SparseArray.