Struct mecs::world::World

pub struct World<'a, S> where
    S: Storage<'a>,
    S::Id: KeyType,  { /* fields omitted */ }

Collection of entities

Id

Each entity has it's own unique id, that will not be re-used even after the entity is removed from this world. The entity id 0 is reserved to mean a null entity, that is, an entity which does not exist.

Methods

impl<'a, S> World<'a, S> where
    S: Storage<'a>,
    S::Id: KeyType, 

#[must_use] pub fn new() -> Self

Create a new empty world

#[must_use] pub fn from_entities(entities: Vec<Entity<'a, S>>) -> Self

Creates a world from a list of entities

pub fn add(&mut self, entity: Entity<'a, S>) -> EntityId

Adds an entity to this world

pub fn remove(&mut self, id: EntityId) -> Option<Entity<'a, S>>

Removes an entity from this world given it's id

#[must_use] pub fn get(&self, id: EntityId) -> Option<&Entity<'a, S>>

Returns a reference to an entity given it's id

#[must_use] pub fn get_mut(&mut self, id: EntityId) -> Option<&mut Entity<'a, S>>

Returns a mutable reference to an entity given it's id

pub fn add_pred<F>(&mut self, f: F) -> usize where
    F: Fn(&Entity<'a, S>) -> bool + 'static, 

Registers a predicate to filter entities through

pub fn iter_all(&self) -> impl Iterator<Item = &Entity<'a, S>>

Returns an iterator over all entities in this world

pub fn iter_mut_all(&mut self) -> impl Iterator<Item = &mut Entity<'a, S>>

Returns a mutable iterator over all entities in this world

#[must_use] pub fn iter_pred(&self, id: usize) -> Option<PredIter<'a, '_, S>>

Returns an iterator over a predicate

#[must_use] pub fn iter_pred_mut(&mut self, id: usize) -> Option<PredIterMut<'a, '_, S>>

Returns a mutable iterator over a predicate

Trait Implementations

impl<'a, S> Default for World<'a, S> where
    S: Storage<'a>,
    S::Id: KeyType, 

#[must_use] fn default() -> Self

Returns the "default value" for a type.

impl<'a, S> Eq for World<'a, S> where
    S: Storage<'a> + Eq,
    S::Id: KeyType, 

impl<'a, S> PartialEq<World<'a, S>> for World<'a, S> where
    S: Storage<'a> + PartialEq,
    S::Id: KeyType, 

#[must_use] fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.