bevy_coroutine 0.4.0

A simple library to run coroutines in Bevy
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::time::Duration;

use bevy::ecs::system::{Adapt, AdapterSystem, RunSystemError};
use bevy::prelude::*;

use crate::{CoResult, co_continue, co_break};

fn break_if(break_: bool) -> CoResult
{
	if break_
	{
		co_break()
	}
	else
	{
		co_continue()
	}
}

/// Generates a coroutine system that waits for the given duration then breaks
pub fn wait(duration: Duration) -> impl FnMut(Res<Time>) -> CoResult + Clone
{
	let mut timer = Timer::new(duration, TimerMode::Once);
	move |time: Res<Time>|
	{
		timer.tick(time.delta());
		break_if(timer.just_finished())
	}
}

/// Generates a coroutine system that waits for the given real time duration then breaks
pub fn wait_real_time(duration: Duration) -> impl FnMut(Res<Time<Real>>) -> CoResult + Clone
{
	let mut timer = Timer::new(duration, TimerMode::Once);
	move |time: Res<Time<Real>>|
	{
		timer.tick(time.delta());
		break_if(timer.just_finished())
	}
}

/// Generates a coroutine system that waits until the given system returns true then breaks
pub fn wait_until<M, S: IntoSystem<(), bool, M>>(condition: S) -> AdapterSystem<UntilMarker, S::System>
{
	let system = IntoSystem::into_system(condition);
	let name = format!("wait_until({})", system.name());
	AdapterSystem::new(UntilMarker, system, name.into())
}

/// Used with [`AdapterSystem`] to return `co_break()` when the system return true
#[doc(hidden)]
#[derive(Copy, Clone)]
pub struct UntilMarker;

impl<S> Adapt<S> for UntilMarker
where
	S: System<Out = bool>
{
	type In = S::In;
	type Out = CoResult;

	fn adapt(
		&mut self,
		input: <Self::In as SystemInput>::Inner<'_>,
		run_system: impl FnOnce(SystemIn<'_, S>) -> Result<bool, RunSystemError>,
	) -> Result<Self::Out, RunSystemError>
	{
		Ok(break_if(run_system(input)?))
	}
}


/// Generates a coroutine system that waits while the given system returns true then breaks
pub fn wait_while<M, S: IntoSystem<(), bool, M>>(condition: S) -> AdapterSystem<WhileMarker, S::System>
{
	let system = IntoSystem::into_system(condition);
	let name = format!("wait_while({})", system.name());
	AdapterSystem::new(WhileMarker, system, name.into())
}

/// Used with [`AdapterSystem`] to return `co_break()` when the system return false
#[doc(hidden)]
#[derive(Copy, Clone)]
pub struct WhileMarker;

impl<S> Adapt<S> for WhileMarker
where
	S: System<Out = bool>
{
	type In = S::In;
	type Out = CoResult;

	fn adapt(
		&mut self,
		input: <Self::In as SystemInput>::Inner<'_>,
		run_system: impl FnOnce(SystemIn<'_, S>) -> Result<bool, RunSystemError>,
	) -> Result<Self::Out, RunSystemError>
	{
		Ok(break_if(!run_system(input)?))
	}
}