Struct bones_framework::prelude::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>(&mut self) -> RefMut<'_, R>

where R: HasSchema + FromWorld,

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

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

where R: HasSchema,

Insert a resource.

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>(&mut self) -> Option<RefMut<'_, T>>

where T: HasSchema,

Borrow a resource from the world, if it exists.

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 reset_internals(&mut self, reset_components: bool, reset_entities: bool)

Provides an interface for resetting entities, and components.

Trait Implementations

impl Clone for World

fn clone(&self) -> World

Returns a copy 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.