Struct World

pub struct World { /* private fields */ }

Sparse typed storage with generational entities and checked component borrows.

RefCell deliberately makes World !Sync. Parallel mutation should use separate worlds or explicit synchronization around the whole world.

Implementations

impl World

pub fn new() -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

pub fn spawn<B: Bundle>(&mut self, bundle: B) -> Entity

Spawns one entity containing zero to four components. Panics if a bundle repeats a component type; no entity is allocated in that case.

pub fn try_spawn<B: Bundle>(&mut self, bundle: B) -> Result<Entity, Error>

pub fn despawn(&mut self, entity: Entity) -> Result<(), Error>

Drops every component and invalidates the handle before reusing its slot.

pub fn insert<B: Bundle>( &mut self, entity: Entity, bundle: B, ) -> Result<(), Error>

Inserts or replaces a bundle’s components. Other components remain unchanged. Invalid identities and duplicate bundle types are rejected before any writes.

pub fn remove<T: 'static>(&mut self, entity: Entity) -> Result<T, Error>

pub fn has<T: 'static>(&self, entity: Entity) -> bool

pub fn get<A: Access>(&self, entity: Entity) -> Result<A::Item<'_>, Error>

Reads or mutates a typed component through an explicit access type. Use get::<&T> or get::<&mut T>; returned guards enforce runtime aliasing.

pub fn get_mut<T: 'static>( &self, entity: Entity, ) -> Result<RefMut<'_, T>, Error>

pub fn query<Q: Query>(&self) -> QueryBorrow<'_, Q>

Queries up to four component access types, optionally including Entity. Repeated shared access is valid; any repeated mutable access is rejected.

pub fn try_query<Q: Query>(&self) -> Result<QueryBorrow<'_, Q>, Error>

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

Live identities in stable slot order, without borrowing any components.

Trait Implementations

impl Default for World

fn default() -> World

Returns the “default value” for a type.