Struct rs_ecs::World

pub struct World { /* private fields */ }

The world storing entities and their components.

Implementations

impl World

pub fn new() -> Self

Create an empty world.

impl World

pub fn alloc(&mut self) -> Entity

Create an Entity without any components. To add components, see Self::insert().

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));

pub fn free(&mut self, ent: Entity)

Remove an Entity and all its components from the world. To remove components, see Self::remove().

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));

world.free(entity);

pub fn clear(&mut self)

Remove all entites and their components from the world.

Note that this will re-use the memory allocations but it will drop the meta-data which implies that previously used Entity values will be repeated.

impl World

pub fn insert<B>(&mut self, ent: Entity, comps: B) where
    B: Bundle, 

Insert components for a given Entity.

If a component is already present for the entity, its value will be overwritten.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));
world.insert(entity, (String::from("Hello"),));

pub fn remove<B>(&mut self, ent: Entity) -> Option<B> where
    B: Bundle, 

Remove components for a given Entity.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true, String::from("Hello")));

world.remove::<(u32, bool)>(entity).unwrap();
world.remove::<(String,)>(entity).unwrap();

pub fn exchange<B1, B2>(&mut self, ent: Entity, new_comps: B2) -> Option<B1> where
    B1: Bundle,
    B2: Bundle, 

Exchange components for a given Entity

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));
assert!(world.contains::<u32>(entity));
assert!(world.contains::<bool>(entity));
assert!(!world.contains::<String>(entity));

world.exchange::<(u32, bool), _>(entity, (String::from("Hello"),)).unwrap();
assert!(!world.contains::<u32>(entity));
assert!(!world.contains::<bool>(entity));
assert!(world.contains::<String>(entity));

impl World

pub fn transfer(&mut self, ent: Entity, other: &mut World) -> Entity

Transfer an Entity and its components from this world to another.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (23_i32, false, String::from("Goodbye")));

let mut another_world = World::new();
let entity = world.transfer(entity, &mut another_world);

let comp = another_world.get::<String>(entity).unwrap();
assert_eq!(&*comp, "Goodbye");

impl World

pub fn exists(&self, ent: Entity) -> bool

Check if a given Entity exists.

Example

let mut world = World::new();

let entity = world.alloc();
assert!(world.exists(entity));

world.free(entity);
assert!(!world.exists(entity));

pub fn contains<C>(&self, ent: Entity) -> bool where
    C: 'static, 

Check if a certain component type is present for an Entity.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));

assert!(world.contains::<u32>(entity));

pub fn get<C>(&self, ent: Entity) -> Option<Comp<'_, C>> where
    C: 'static, 

Get an immutable reference to the component of the given type for an Entity.

Note that for repeated calls, map can be used to amortize the set-up costs.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));

let comp = world.get::<u32>(entity).unwrap();

pub fn get_mut<C>(&self, ent: Entity) -> Option<CompMut<'_, C>> where
    C: 'static, 

Get a mutable reference to the component of the given type for an Entity.

Note that for repeated calls, map can be used to amortize the set-up costs.

Example

let mut world = World::new();

let entity = world.alloc();
world.insert(entity, (42_u32, true));

let comp = world.get_mut::<u32>(entity).unwrap();

Trait Implementations

impl Default for World

fn default() -> Self

Create an empty world.