pecs 0.6.0

Asynchronous operations for Bevy Engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! This Example shows how you can create custom promises
//! with `Promise::register()` method and resolve them from
//! you system with `commands.promise(id).resolve(result)`
use bevy::prelude::*;
use pecs::prelude::*;
fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(PecsPlugin)
        .add_systems(Startup, setup)
        .add_systems(Update, process_timers_system)
        .run();
}

#[derive(Component)]
/// Holds PromiseId and the time when the timer should time out.
pub struct MyTimer(PromiseId, f32);

/// creates promise that will resolve after [`duration`] seconds
pub fn delay(duration: f32) -> Promise<(), ()> {
    Promise::register(
        // this will be invoked when promise's turn comes
        move |world, id| {
            let now = world.resource::<Time>().elapsed_seconds();
            // store timer
            world.spawn(MyTimer(id, now + duration));
        },
        // this will be invoked when promise got discarded
        move |world, id| {
            let entity = {
                let mut timers = world.query::<(Entity, &MyTimer)>();
                timers
                    .iter(world)
                    .filter(|(_entity, timer)| timer.0 == id)
                    .map(|(entity, _timer)| entity)
                    .next()
            };
            if let Some(entity) = entity {
                world.despawn(entity);
            }
        },
    )
}

/// iterate ofver all timers and resolves completed
pub fn process_timers_system(timers: Query<(Entity, &MyTimer)>, mut commands: Commands, time: Res<Time>) {
    let now = time.elapsed_seconds();
    for (entity, timer) in timers.iter().filter(|(_, t)| t.1 < now) {
        let promise_id = timer.0;
        commands.promise(promise_id).resolve(());
        commands.entity(entity).despawn();
    }
}

fn setup(mut commands: Commands) {
    // `delay()` can be called from inside promise
    commands
        .promise(|| ())
        .then(asyn! {
            info!("Starting");
            delay(1.)
        })
        .then(asyn! {
            info!("Completing");
        });

    // or queued directly to Commands
    commands.promise(delay(2.)).then(asyn! {
        info!("I'm another timer");
        asyn::app::exit()
    });
}