beet_flow 0.0.8

An ECS control flow library
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::prelude::*;
use beet_core::prelude::*;

/// Reattaches the [`RunOnSpawn`] component whenever [`End`] is called.
/// Using [`RunOnSpawn`] means this does **not** directly trigger observers, which avoids infinite loops.
///
/// Note that [`Repeat`] requires [`PreventPropagateEnd`] so results must be bubbled up manually
/// if the [`Self::if_result_matches`] option is unused.
///
/// ## Tags
/// - [ControlFlow](ActionTag::ControlFlow)
/// ## Example
/// Repeat the action twice, then bubble up the failure
/// ```
/// # use beet_core::prelude::*;
/// # use beet_flow::prelude::*;
/// # let mut world = ControlFlowPlugin::world();
/// world
/// .spawn((Repeat::if_success(), SucceedTimes::new(2)))
/// .trigger_target(GetOutcome);
/// ```
#[action(repeat)]
#[derive(Debug, Clone, PartialEq, Component, Reflect)]
#[reflect(Default, Component)]
#[require(PreventPropagateEnd)]
pub struct Repeat {
	/// Optional predicate to only repeat if the result matches.
	pub if_result_matches: Option<Outcome>,
}

impl Repeat {
	/// Repeats the action if the result is [`Outcome::Pass`].
	pub fn if_success() -> Self {
		Self {
			if_result_matches: Some(Outcome::Pass),
		}
	}
	/// Repeats the action if the result is [`Outcome::Fail`].
	pub fn if_failure() -> Self {
		Self {
			if_result_matches: Some(Outcome::Fail),
		}
	}
}

impl Default for Repeat {
	fn default() -> Self {
		Self {
			if_result_matches: None,
		}
	}
}

fn repeat(
	ev: On<Outcome>,
	query: Query<&Repeat>,
	mut commands: Commands,
) -> Result {
	let target = ev.target();
	let repeat = query.get(target)?;
	if let Some(check) = &repeat.if_result_matches {
		if *ev != *check {
			// repeat is completed, propagate the result to the parent if it exists
			ChildEnd::trigger(commands, target, ev.event().clone());
			return Ok(());
		}
	}
	// otherwise run again on the next tick
	commands
		.entity(target)
		.insert(TriggerDeferred::get_outcome());
	Ok(())
}

#[cfg(test)]
mod test {
	use crate::prelude::*;
	use beet_core::prelude::*;

	#[test]
	fn repeat_always() {
		let mut world = ControlFlowPlugin::world();
		let on_result = collect_on_result(&mut world);

		world
			.spawn((Repeat::default(), SucceedTimes::new(2)))
			.trigger_target(GetOutcome)
			.flush();

		on_result.get().len().xpect_eq(1);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(2);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(3);
		world.run_schedule(Update);
		// even though child failed, it keeps repeating
		on_result.get().len().xpect_eq(4);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(5);
	}

	#[test]
	fn repeat_if() {
		let mut world = ControlFlowPlugin::world();
		let on_result = collect_on_result(&mut world);

		world
			.spawn((Repeat::if_success(), SucceedTimes::new(2)))
			.trigger_target(GetOutcome)
			.flush();

		on_result.get().len().xpect_eq(1);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(2);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(3);
		world.run_schedule(Update);
		// it stopped repeating
		on_result.get().len().xpect_eq(3);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(3);
	}

	#[test]
	fn repeat_child() {
		let mut world = ControlFlowPlugin::world();
		let on_result = collect_on_result(&mut world);

		world
			.spawn((Sequence, children![(
				Repeat::if_success(),
				SucceedTimes::new(2)
			)]))
			.trigger_target(GetOutcome)
			.flush();

		on_result.get().len().xpect_eq(2);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(4);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(7);
		world.run_schedule(Update);
		on_result.get().len().xpect_eq(7);
		world.run_schedule(Update);
		// last one, it stopped repeating
		on_result.get().len().xpect_eq(7);
	}
}