Struct AsyncWorld

pub struct AsyncWorld(/* private fields */);

Exposes asynchronous access to the Bevy ECS World.

The easiest way to get an AsyncWorld is with AsyncWorld::from_world().

Commands

Apply any Command asynchronously with AsyncWorld::apply_command.

Systems

Just like their synchronous variants, asynchronous Systems must be registered before they can be used. Systems can optionally accept and return values asynchronously if they are registered with AsyncWorld::register_io_system.

Entities

Spawn entities with the AsyncWorld::spawn_* family.

Resources

Insert, remove, and wait for resources to exist.

Implementations

impl AsyncWorld

pub fn sender(&self) -> CommandQueueSender

Returns a copy of the underlying CommandQueueSender.

pub async fn apply<C: Command>(&self, command: C)

Applies the given Command to the world.

pub fn start_queue(&self) -> CommandQueueBuilder

Starts building a CommandQueue.

pub async fn run_system<M>( self, system: impl IntoSystem<(), (), M> + Send + 'static, )

Run a System once.

pub async fn register_system<M>( &self, system: impl IntoSystem<(), (), M> + Send, ) -> AsyncSystem

Registers a System and returns an AsyncSystem that can be used to run the system on demand.

pub async fn register_io_system<I: Send + 'static, O: Send + 'static, M>( &self, system: impl IntoSystem<In<I>, O, M> + Send, ) -> AsyncIOSystem<I, O>

Registers a System and returns an AsyncIOSystem that can be used to run the system on demand while supplying an input value and receiving an output value.

pub fn entity(&self, id: Entity) -> AsyncEntity

Constructs an AsyncEntity for the given Entity. If the entity does not exist, any operation performed on it will panic.

pub async fn spawn_empty(&self) -> AsyncEntity

Spawns a new Entity and returns an AsyncEntity that represents it, which can be used to further manipulate the entity.

pub async fn spawn<B: Bundle>(&self, bundle: B) -> AsyncEntity

Spawns a new Entity with the given Bundle and returns an AsyncEntity that represents it, which can be used to further manipulate the entity.

pub async fn spawn_named( &self, name: impl Into<Cow<'static, str>> + Send, ) -> AsyncEntity

Spawns a new Entity and returns an AsyncEntity that represents it, which can be used to further manipulate the entity. This function attaches a bevy Name component with the given value.

pub async fn insert_resource<R: Resource>(&self, resource: R)

Inserts a new resource or updates an existing resource with the given value.

pub async fn remove_resource<R: Resource>(&self)

Removes the resource of a given type, if it exists.

pub async fn start_waiting_for_resource<R: Resource + Clone>( &self, ) -> AsyncResource<R>

Start waiting for the Resource of a given type. Returns an AsyncResource which can be further waited to receive the value of the resource.

AsyncWorld::wait_for_resource().await is equivalent to AsyncWorld::start_waiting_for_resource().await.wait().await.

pub async fn wait_for_resource<R: Resource + Clone>(&self) -> R

Wait for the Resource of a given type. Returns the value of the resource, once it exists.

AsyncWorld::wait_for_resource().await is equivalent to AsyncWorld::start_waiting_for_resource().await.wait().await.

pub async fn send_event<E: Event>(&self, event: E)

Send an Event to the bevy world.

pub async fn start_waiting_for_events<E: Event + Clone>(&self) -> AsyncEvents<E>

Start listening for Events coming from the main bevy world. Returns an AsyncEvents which can be further waited to receive these events.

AsyncWorld::wait_for_event().await is equivalent to AsyncWorld::start_waiting_for_events().await.wait().await.

pub async fn wait_for_event<E: Event + Clone>(&self) -> E

Wait for the Event of a given type. Returns the value of the event, once it is received.

AsyncWorld::wait_for_event().await is equivalent to AsyncWorld::start_waiting_for_events().await.wait().await.

pub async fn trigger<E: Event>(&self, event: E)

Triggers the given Event, which will run any Observers watching for it.

pub async fn trigger_targets<E: Event, T: TriggerTargets + Send + Sync + 'static>( &self, event: E, targets: T, )

Triggers the given Event for the given targets, which will run any Observers watching for it.

Trait Implementations

impl Clone for AsyncWorld

fn clone(&self) -> AsyncWorld

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AsyncWorld

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

Formats the value using the given formatter.

impl From<CommandQueueSender> for AsyncWorld

fn from(sender: CommandQueueSender) -> Self

Converts to this type from the input type.

impl FromWorld for AsyncWorld

fn from_world(world: &mut World) -> Self

Creates Self using data from the given World.