Struct World 

pub struct World<S = SoaStorage> { /* private fields */ }

World is the heart of this library. It owns all the Components and Storages. It also manages entities and allows Components to be safely queried.

Implementations

impl<S> World<S>

pub fn new() -> Self

Creates an empty World.

impl<S> World<S>

where S: Storage,

pub fn entities<'s>(&'s self) -> impl Iterator<Item = Entity> + 's

Creates an Iterator over every Entity inside World. The entities are not ordered.

pub fn matcher<'s, Q>( &'s self, ) -> impl Iterator<Item = <<Q as Query<'s>>::Iter as Iterator>::Item> + 's

where Q: Query<'s> + Matcher, Q::Borrow: RegisterBorrow,

Uses Query and Matcher to access the correct components. Read will borrow the component immutable while Write will borrow the component mutable.

fn update(world: &mut World) {
   world
       .matcher::<All<(Write<Position>, Read<Velocity>)>>()
       .for_each(|(p, v)| {
           p.x += v.dx;
           p.y += v.dy;
       });
}

pub fn matcher_with_entities<'s, Q>( &'s self, ) -> impl Iterator<Item = (Entity, <<Q as Query<'s>>::Iter as Iterator>::Item)> + 's

where Q: Query<'s> + Matcher, Q::Borrow: RegisterBorrow,

Same as World::matcher but also returns the corresponding Entity.

fn update(world: &mut World) {
   world
       .matcher_with_entities::<All<(Write<Position>, Read<Velocity>)>>()
       .for_each(|(entity, (p, v))| {
           p.x += v.dx;
           p.y += v.dy;
       });
}

impl<S> World<S>

where S: Storage + RegisterComponent,

pub fn append_components<A, I>(&mut self, i: I)

where A: AppendComponents + BuildStorage, I: IntoIterator<Item = A>,

Appends the components and also creates the necessary Entitys behind the scenes. If you only want to append a single set of components then you can do

world.append_components(Some((a, b, c)));

pub fn is_entity_valid(&self, entity: Entity) -> bool

Compares the version of the entity with the version in World and returns true if they match. Because version wraps around this is not a hard guarantee.

pub fn has_component<C: Component>(&self, e: Entity) -> bool

Returns true if the entity owns the requested component.

pub fn get_component<C: Component>(&self, e: Entity) -> Option<&C>

Retrieves a component for a specific Entity.

pub fn get_component_mut<C: Component>(&mut self, e: Entity) -> Option<&mut C>

Same as World::get_component but mutable.

pub fn remove_entities<I>(&mut self, entities: I)

where I: IntoIterator<Item = Entity>,

Removes the specified entities from World. Those entities are now considered invalid, which can be checked with World::is_entity_valid.

Trait Implementations

impl<S> Default for World<S>

fn default() -> Self

Returns the “default value” for a type.