Struct bevy_rollback::RollbackWorld

pub struct RollbackWorld { /* fields omitted */ }

Methods from Deref<Target = World>

pub fn id(&self) -> WorldId

Retrieves this world’s unique ID

pub fn entities(&self) -> &Entities

Retrieves this world’s [Entities] collection

pub fn archetypes(&self) -> &Archetypes

Retrieves this world’s [Archetypes] collection

pub fn components(&self) -> &Components

Retrieves this world’s [Components] collection

pub fn components_mut(&mut self) -> &mut Components

Retrieves a mutable reference to this world’s [Components] collection

pub fn storages(&self) -> &Storages

Retrieves this world’s [Storages] collection

pub fn bundles(&self) -> &Bundles

Retrieves this world’s [Bundles] collection

pub fn cell(&mut self) -> WorldCell<'_>

Retrieves a [WorldCell], which safely enables multiple mutable World accesses at the same time, provided those accesses do not conflict with each other.

pub fn register_component(
    &mut self,
    descriptor: ComponentDescriptor
) -> Result<ComponentId, ComponentsError>

Registers a new component using the given [ComponentDescriptor]. Components do not need to be manually registered. This just provides a way to override default configuration. Attempting to register a component with a type that has already been used by [World] will result in an error.

The default component storage type can be overridden like this:

use bevy_ecs::{component::{ComponentDescriptor, StorageType}, world::World};

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet)).unwrap();

pub fn entity(&self, entity: Entity) -> EntityRef<'_>

Retrieves an [EntityRef] that exposes read-only operations for the given entity. This will panic if the entity does not exist. Use [World::get_entity] if you want to check for entity existence instead of implicitly panic-ing.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();

let position = world.entity(entity).get::<Position>().unwrap();
assert_eq!(position.x, 0.0);

pub fn entity_mut(&mut self, entity: Entity) -> EntityMut<'_>

Retrieves an [EntityMut] that exposes read and write operations for the given entity. This will panic if the entity does not exist. Use [World::get_entity_mut] if you want to check for entity existence instead of implicitly panic-ing.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();

let mut position = world.entity_mut(entity).get_mut::<Position>().unwrap();
position.x = 1.0;

pub fn get_entity(&self, entity: Entity) -> Option<EntityRef<'_>>

Retrieves an [EntityRef] that exposes read-only operations for the given entity. Returns None if the entity does not exist. Use [World::entity] if you don’t want to unwrap the [EntityRef] yourself.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();

let entity_ref = world.get_entity(entity).unwrap();
let position = entity_ref.get::<Position>().unwrap();
assert_eq!(position.x, 0.0);

pub fn get_entity_mut(&mut self, entity: Entity) -> Option<EntityMut<'_>>

Retrieves an [EntityMut] that exposes read and write operations for the given entity. Returns None if the entity does not exist. Use [World::entity_mut] if you don’t want to unwrap the [EntityMut] yourself.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();

let mut entity_mut = world.get_entity_mut(entity).unwrap();
let mut position = entity_mut.get_mut::<Position>().unwrap();
position.x = 1.0;

pub fn spawn(&mut self) -> EntityMut<'_>

Spawns a new [Entity] and returns a corresponding [EntityMut], which can be used to add components to the entity or retrieve its id.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 }) // add a single component
    .insert_bundle((1, 2.0, "hello")) // add a bundle of components
    .id();

let position = world.entity(entity).get::<Position>().unwrap();
assert_eq!(position.x, 0.0);

pub fn spawn_batch<I>(
    &mut self,
    iter: I
) -> SpawnBatchIter<'_, <I as IntoIterator>::IntoIter> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Bundle, 

Spawns a batch of entities with the same component [Bundle] type. Takes a given [Bundle] iterator and returns a corresponding [Entity] iterator. This is more efficient than spawning entities and adding components to them individually, but it is limited to spawning entities with the same [Bundle] type, whereas spawning individually is more flexible.

use bevy_ecs::{entity::Entity, world::World};

let mut world = World::new();
let entities = world.spawn_batch(vec![
  ("a", 0.0), // the first entity
  ("b", 1.0), // the second entity
]).collect::<Vec<Entity>>();

assert_eq!(entities.len(), 2);

pub fn get<T>(&self, entity: Entity) -> Option<&T> where
    T: Component, 

Retrieves a reference to the given entity’s [Component] of the given type. Returns None if the entity does not have a [Component] of the given type.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();
let position = world.get::<Position>(entity).unwrap();
assert_eq!(position.x, 0.0);

pub fn get_mut<T>(&mut self, entity: Entity) -> Option<Mut<'_, T>> where
    T: Component, 

Retrieves a mutable reference to the given entity’s [Component] of the given type. Returns None if the entity does not have a [Component] of the given type.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();
let mut position = world.get_mut::<Position>(entity).unwrap();
position.x = 1.0;

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

Despawns the given entity, if it exists. This will also remove all of the entity’s [Component]s. Returns true if the entity is successfully despawned and false if the entity does not exist.

use bevy_ecs::world::World;

struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn()
    .insert(Position { x: 0.0, y: 0.0 })
    .id();
assert!(world.despawn(entity));
assert!(world.get_entity(entity).is_none());
assert!(world.get::<Position>(entity).is_none());

pub fn clear_trackers(&mut self)

Clears component tracker state

pub fn query<Q>(&mut self) -> QueryState<Q, ()> where
    Q: WorldQuery, 

Returns [QueryState] for the given [WorldQuery], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{entity::Entity, world::World};

#[derive(Debug, PartialEq)]
struct Position {
  x: f32,
  y: f32,
}

struct Velocity {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entities = world.spawn_batch(vec![
    (Position { x: 0.0, y: 0.0}, Velocity { x: 1.0, y: 0.0 }),    
    (Position { x: 0.0, y: 0.0}, Velocity { x: 0.0, y: 1.0 }),    
]).collect::<Vec<Entity>>();

let mut query = world.query::<(&mut Position, &Velocity)>();
for (mut position, velocity) in query.iter_mut(&mut world) {
   position.x += velocity.x;
   position.y += velocity.y;
}     

assert_eq!(world.get::<Position>(entities[0]).unwrap(), &Position { x: 1.0, y: 0.0 });
assert_eq!(world.get::<Position>(entities[1]).unwrap(), &Position { x: 0.0, y: 1.0 });

pub fn query_filtered<Q, F>(&mut self) -> QueryState<Q, F> where
    Q: WorldQuery,
    F: WorldQuery,
    <F as WorldQuery>::Fetch: FilterFetch, 

Returns [QueryState] for the given filtered [WorldQuery], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{entity::Entity, world::World, query::With};

struct A;
struct B;

let mut world = World::new();
let e1 = world.spawn().insert(A).id();
let e2 = world.spawn().insert_bundle((A, B)).id();

let mut query = world.query_filtered::<Entity, With<B>>();
let matching_entities = query.iter(&world).collect::<Vec<Entity>>();

assert_eq!(matching_entities, vec![e2]);

pub fn removed<T>(&self) -> Cloned<Iter<'_, Entity>> where
    T: Component, 

Returns an iterator of entities that had components of type T removed since the last call to [World::clear_trackers].

pub fn removed_with_id(
    &self,
    component_id: ComponentId
) -> Cloned<Iter<'_, Entity>>

Returns an iterator of entities that had components with the given component_id removed since the last call to [World::clear_trackers].

pub fn insert_resource<T>(&mut self, value: T) where
    T: Component, 

Inserts a new resource with the given value. Resources are “unique” data of a given type.

pub fn insert_non_send<T>(&mut self, value: T) where
    T: 'static, 

Inserts a new non-send resource with the given value. Resources are “unique” data of a given type.

pub fn remove_resource<T>(&mut self) -> Option<T> where
    T: Component, 

Removes the resource of a given type and returns it, if it exists. Otherwise returns None. Resources are “unique” data of a given type.

pub fn remove_non_send<T>(&mut self) -> Option<T> where
    T: 'static, 

pub unsafe fn remove_resource_unchecked<T>(&mut self) -> Option<T> where
    T: 'static, 

Safety

make sure you’re on main thread if T isn’t Send + Sync

pub fn contains_resource<T>(&self) -> bool where
    T: Component, 

Returns true if a resource of type T exists. Otherwise returns false.

pub fn get_resource<T>(&self) -> Option<&T> where
    T: Component, 

Gets a reference to the resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

pub fn is_resource_added<T>(&self) -> bool where
    T: Component, 

pub fn is_resource_changed<T>(&self) -> bool where
    T: Component, 

pub fn get_resource_mut<T>(&mut self) -> Option<Mut<'_, T>> where
    T: Component, 

Gets a mutable reference to the resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

pub fn get_resource_or_insert_with<T>(
    &mut self,
    func: impl FnOnce() -> T
) -> Mut<'_, T> where
    T: Component, 

Gets a resource of type T if it exists, otherwise inserts the resource using the result of calling func.

pub unsafe fn get_resource_unchecked_mut<T>(&self) -> Option<Mut<'_, T>> where
    T: Component, 

Gets a mutable reference to the resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

Safety

This will allow aliased mutable access to the given resource type. The caller must ensure that only one mutable access exists at a time.

pub fn get_non_send_resource<T>(&self) -> Option<&T> where
    T: 'static, 

Gets a reference to the non-send resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

pub fn get_non_send_resource_mut<T>(&mut self) -> Option<Mut<'_, T>> where
    T: 'static, 

Gets a mutable reference to the non-send resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

pub unsafe fn get_non_send_resource_unchecked_mut<T>(
    &self
) -> Option<Mut<'_, T>> where
    T: 'static, 

Gets a mutable reference to the non-send resource of the given type, if it exists. Otherwise returns None Resources are “unique” data of a given type.

Safety

This will allow aliased mutable access to the given non-send resource type. The caller must ensure that only one mutable access exists at a time.

pub fn resource_scope<T, U>(
    &mut self,
    f: impl FnOnce(&mut World, Mut<'_, T>) -> U
) -> U where
    T: Component, 

Temporarily removes the requested resource from this [World], then re-adds it before returning. This enables safe mutable access to a resource while still providing mutable world access

use bevy_ecs::world::{World, Mut};
struct A(u32);
struct B(u32);
let mut world = World::new();
world.insert_resource(A(1));
let entity = world.spawn().insert(B(1)).id();

world.resource_scope(|world, mut a: Mut<A>| {
    let b = world.get_mut::<B>(entity).unwrap();
    a.0 += b.0;
});
assert_eq!(world.get_resource::<A>().unwrap().0, 2);

pub fn increment_change_tick(&self) -> u32

pub fn read_change_tick(&self) -> u32

pub fn change_tick(&mut self) -> u32

pub fn last_change_tick(&self) -> u32

pub fn check_change_ticks(&mut self)

Trait Implementations

impl Default for RollbackWorld

fn default() -> Self

Returns the “default value” for a type.

impl Deref for RollbackWorld

type Target = World

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for RollbackWorld

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.