Bevy Defer

一个简单的异步运行时，用于执行异步协程。

动机

异步Rust非常适合建模以等待为中心的任务，如协程。在游戏开发中不使用异步是一种巨大的浪费。

想象一下，我们想要模拟一个快速的剑攻击动画，在异步Rust中这很简单

swing_animation().await;
show_damage_number().await;
damage_vfx().await;

swing_animation().await;
show_damage_number().await;
damage_vfx().await;

在每个await点，我们等待某个操作完成，而不浪费资源在循环中空转线程或在一个系统中定义复杂的状态机。

如果我们想同时运行伤害数字和伤害特效，并在下一次攻击之前等待两者完成呢？使用async语义就很简单了！

futures::join! {
    show_damage_number(),
    damage_vfx()
};

swing_animation().await;

为什么不使用bevy_tasks呢？

bevy_tasks没有直接访问世界的能力，这使得在其中编写游戏逻辑变得困难。

bevy_defer背后的核心思想很简单

// Pseudocode
static WORLD_CELL: Mutex<&mut World>;

fn run_async_executor(world: &mut World) {
    let executor = world.get_executor();
    WORLD_CELL.set(world);
    executor.run();
    WORLD_CELL.remove(world);
}

在执行器上生成的Futures可以通过访问函数访问World，类似于数据库事务的工作方式

WORLD_CELL.with(|world: &mut World| {
    world.entity(entity).get::<Transform>().clone()
})

只要不能从世界中借用引用，并且执行器是单线程的，这完全没问题！

启动任务

您可以从World、App、Commands、AsyncWorld或AsyncExecutor将任务启动到bevy_defer上。

以下是一个示例

commands.spawn_task(|| async move {
    // Wait for state to be `GameState::Animating`.
    AsyncWorld.state_stream::<GameState>().filter(|x| x == &GameState::Animating).next().await;
    // Obtain info from a resource.
    // Since the `World` stored as a thread local, 
    // a closure is the preferable syntax to access it.
    let richard_entity = AsyncWorld.resource::<NamedEntities>()
        .get(|res| *res.get("Richard").unwrap())?;
    // Move to an entity's scope, does not verify the entity exists.
    let richard = AsyncWorld.entity(richard_entity);
    // We can also mutate the world directly.
    richard.component::<HP>().set(|hp| hp.set(500))?;
    // Move to a component's scope, does not verify the entity or component exists.
    let animator = AsyncWorld.component::<Animator>();
    // Implementing `AsyncComponentDeref` allows you to add extension methods to `AsyncComponent`.
    animator.animate("Wave").await?;
    // Spawn another future on the executor.
    let audio = AsyncWorld.spawn(sound_routine(richard_entity));
    // Dance for 5 seconds with `select`.
    futures::select!(
        _ = animator.animate("Dance").fuse() => (),
        _ = AsyncWorld.sleep(Duration::from_secs(5)) => println!("Dance cancelled"),
    );
    // animate back to idle
    richard.component::<Animator>().animate("Idle").await?;
    // Wait for spawned future to complete
    audio.await?;
    // Tell the bevy App to quit.
    AsyncWorld.quit();
    Ok(())
});

世界访问器

所有世界访问的入口点是AsyncWorld，例如，可以通过以下方式访问一个Component

let translation = AsyncWorld
    .entity(entity)
    .component::<Transform>()
    .get(|t| {
        t.translation
    }
)

这适用于您期望的所有Bevy功能，如Resource、Query等。有关更多详细信息，请参阅access模块和AsyncAccess特质。

如果您拥有底层类型，可以通过Deref为这些访问器添加扩展方法。有关更多详细信息，请参阅access::deref模块。对于添加异步访问器的方法，async_access派生宏非常有用。

我们不提供AsyncSystemParam，相反，您应该使用基于单次系统的API在AsyncWorld上。它们可以涵盖您需要在bevy_defer中运行系统的所有用例。

异步基础

以下是一些您可能从异步生态系统中发现的有用公用工具。

• AsyncWorld.spawn() 创建一个未来。

• AsyncWorld.spawn_scoped() 创建一个未来，并提供一个获取结果的句柄。

• AsyncWorld.yield_now() 使当前帧暂停执行，类似于协程的工作方式。

• AsyncWorld.sleep(4.0) 暂停未来 4 秒。

• AsyncWorld.sleep_frames(4) 暂停未来 4 帧。

async {
    entity.component::<IsJumping>().set(|j| *j == true);
}

pub fn jump_system(query: Query<Name, Changed<IsJumping>>) {
    for name in &query {
        println!("{} is jumping!", name);
    }
}