Struct World 

pub struct World {
    pub resources: Resources,
    pub components: ComponentStores,
}

The World is simply a collection of Resources, and ComponentStores.

Also stored in the world is the Entities, but it is stored as a resource.

World is designed to be trivially Cloneed to allow for snapshotting the world state. The is especially useful in the context of rollback networking, which requires the ability to snapshot and restore state.

Fields

resources: Resources

Stores the world resources.

components: ComponentStores

Stores the world components.

Implementations

impl World

pub fn new() -> World

Create a new World.

pub fn with_entities(entities: AtomicResource<Entities>) -> World

Create a new world that uses the provided entities resource.

This allows multiple worlds to avoid allocating the same entity IDs.

pub fn maintain(&self)

Remove the component info for dead entities.

This should be called every game frame to cleanup entities that have been killed.

This will remove the component storage for all killed entities, and allow their slots to be re-used for any new entities.

pub fn run_system<'system, R, In, Out, S>(&self, system: S, input: In) -> Out

where In: 'system, Out: 'system, S: IntoSystem<R, In, Out>, <S as IntoSystem<R, In, Out>>::Sys: 'system,

Run a system once.

This is good for initializing the world with setup systems.

pub fn entity_components<Q>( &self, entity: Entity, query: Q, ) -> <<Q as QueryItem>::Iter as Iterator>::Item

where Q: QueryItem,

Get an entity’s components.

Panics

Panics if the entity does not have the required components from the query.

pub fn get_entity_components<Q>( &self, entity: Entity, query: Q, ) -> Option<<<Q as QueryItem>::Iter as Iterator>::Item>

where Q: QueryItem,

Get an entity’s components.

pub fn init_resource<R>(&self) -> RefMut<'_, R>

where R: HasSchema + FromWorld,

Initialize a resource of type T by inserting it’s default value.

pub fn insert_resource<R>(&self, resource: R) -> Option<R>

where R: HasSchema,

Insert a resource, replacing it if it already exists.

pub fn resource<T>(&self) -> Ref<'_, T>

where T: HasSchema,

Borrow a resource from the world.

Panics

Panics if the resource does not exist in the store.

pub fn resource_mut<T>(&self) -> RefMut<'_, T>

where T: HasSchema,

Borrow a resource from the world.

Panics

Panics if the resource does not exist in the store.

pub fn get_resource<T>(&self) -> Option<Ref<'_, T>>

where T: HasSchema,

Borrow a resource from the world, if it exists.

pub fn get_resource_mut<T>(&self) -> Option<RefMut<'_, T>>

where T: HasSchema,

Borrow a resource from the world, if it exists.

pub fn clear_owned_resources(&self)

Removes all resources that are not shared. Shared resources are preserved.

pub fn retain_resources<F>(&self, predicate: F)

where F: FnMut(SchemaId) -> bool,

Iterates through owned and shared resource cells removing them if the predicate returns false.

See also: Self::retain_owned_resources.

pub fn retain_owned_resources<F>(&self, predicate: F)

where F: FnMut(SchemaId) -> bool,

Iterates through resource cells removing them if the predicate returns false.

Doesn’t include shared resources. See also: Self::retain_resources.

pub fn component<T>(&self) -> Ref<'_, ComponentStore<T>>

where T: HasSchema,

Borrow a component store from the world.

Panics

Panics if the component store does not exist in the world.

pub fn component_mut<T>(&self) -> RefMut<'_, ComponentStore<T>>

where T: HasSchema,

Mutably borrow a component store from the world.

Panics

Panics if the component store does not exist in the world.

pub fn load_snapshot(&mut self, snapshot: World)

Load snapshot of World into self.

Trait Implementations

impl Clone for World

fn clone(&self) -> World

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for World

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for World

fn default() -> World

Returns the “default value” for a type.

impl SystemParam for &World

type State = ()

The intermediate state for the parameter, that may be extracted from the world.

type Param<'s> = &'s World

The type of the parameter, ranging over the lifetime of the intermediate state.

fn get_state(_world: &World) -> <&World as SystemParam>::State

This is called to produce the intermediate state of the system parameter.

fn borrow<'s>( world: &'s World, _state: &'s mut <&World as SystemParam>::State, ) -> <&World as SystemParam>::Param<'s>

This is used create an instance of the system parame, possibly borrowed from the intermediate parameter state.