diff --git a/.claude/commands/create-pr.md b/.claude/commands/create-pr.md new file mode 100644 index 0000000..c8b6c62 --- /dev/null +++ b/.claude/commands/create-pr.md @@ -0,0 +1,6 @@ +--- +allowed-tools: Bash(git:*), +description: Create PR +--- + +Please create a PR. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3071668..afe830c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -28,6 +28,9 @@ jobs: run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev pkg-config if: runner.os == 'linux' - name: Build & run tests + env: + RUSTFLAGS: "-C debuginfo=0" + CARGO_BUILD_JOBS: "1" run: | cargo test -F state,audio,tokio,record,side-effect - name: Run tests with all features diff --git a/CHANGELOG.md b/CHANGELOG.md index e16df37..6bbaa1f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,16 @@ ### Features - Support for Bevy 0.17.0 +- Added `once::message` module with `write()`, `write_default()`, and `app_exit_success()` actions +- Added `wait::message` module with `comes()`, `comes_and()`, `read()`, and `read_and()` actions + +### Deprecations +- Deprecated `once::event` module in favor of `once::message` (Event trait replaced with Message in Bevy 0.17) +- Deprecated `wait::event` module in favor of `wait::message` (Event trait replaced with Message in Bevy 0.17) + +### Improvements +- Updated all examples, documentation, and tests to use the new `message` API +- Deprecated functions now delegate to their `message` equivalents for consistency ## v0.12.0 [Release note](https://github.com/not-elm/bevy_flurx/releases/tag/v0.12.0) diff --git a/README.md b/README.md index 0efca02..daef271 100644 --- a/README.md +++ b/README.md @@ -89,7 +89,7 @@ fn spawn_reactor(mut commands: Commands) { assert_eq!(message, "count is 4"); info!("Done!"); - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; })); } ``` diff --git a/docs/src/actions/delay.md b/docs/src/actions/delay.md index 4772346..ecf060e 100644 --- a/docs/src/actions/delay.md +++ b/docs/src/actions/delay.md @@ -66,7 +66,7 @@ fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Delay for 1 second, then send an event task.will(Update, delay::time().with(Duration::from_secs(1)) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) ).await; })); } diff --git a/docs/src/actions/inspect.md b/docs/src/actions/inspect.md index f5935a8..74ad43b 100644 --- a/docs/src/actions/inspect.md +++ b/docs/src/actions/inspect.md @@ -26,7 +26,7 @@ struct Hp(u8); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Use inspect to log damage without affecting the main flow - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .pipe(inspect(once::run(|In(Damage(damage)): In| { println!("Players take {damage} points of damage."); }))) @@ -57,7 +57,7 @@ struct Hp(u8); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Use the inspect method for a more concise syntax - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .inspect(once::run(|In(Damage(damage)): In| { println!("Players take {damage} points of damage."); })) @@ -134,7 +134,7 @@ struct Damage(u8); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Collect metrics while processing events - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .inspect(once::run(|In(Damage(damage)): In, mut metrics: ResMut| { metrics.damage_dealt += damage as u32; println!("Total damage dealt: {}", metrics.damage_dealt); @@ -173,7 +173,7 @@ enum ActionType { fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Perform conditional side effects based on input values - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .inspect(once::run(|In(action): In| { match action.action_type { ActionType::Attack => println!("Player attacks for {} damage!", action.value), diff --git a/docs/src/actions/once/event.md b/docs/src/actions/once/event.md index 55341db..f4f7f9b 100644 --- a/docs/src/actions/once/event.md +++ b/docs/src/actions/once/event.md @@ -1,6 +1,8 @@ # once::event -The `once::event` module provides actions for sending Bevy events exactly once. These actions are specialized versions of `once::run` that focus specifically on event sending operations. +> **⚠️ DEPRECATED**: This module is deprecated since Bevy 0.17. Please use [`once::message`](./message.md) instead. The `Event` trait has been replaced with `Message` in Bevy 0.17. + +The `once::event` module provides actions for sending Bevy messages exactly once. These actions are specialized versions of `once::run` that focus specifically on message sending operations. ## Functions @@ -20,14 +22,14 @@ use bevy::prelude::*; use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { - task.will(Update, once::event::send().with(AppExit::Success)).await; + task.will(Update, once::message::write().with(AppExit::Success)).await; }); ``` ### send_default ```rust -once::event::send_default() -> ActionSeed +once::message::write_default() -> ActionSeed ``` Creates an action that sends a default-constructed event once. The event type must implement the `Default` trait. @@ -40,14 +42,14 @@ use bevy::prelude::*; use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { - task.will(Update, once::event::send_default::()).await; + task.will(Update, once::message::write_default::()).await; }); ``` ### app_exit_success ```rust -once::event::app_exit_success() -> Action +once::message::app_exit_success() -> Action ``` A convenience function that creates an action to send the `AppExit::Success` event once, which will exit the application successfully. @@ -59,15 +61,17 @@ use bevy::prelude::*; use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; }); ``` ## When to Use -Use `once::event` actions when you need to: -- Send a specific event exactly once -- Send a default-constructed event exactly once +> **Note**: This module is deprecated. Use `once::message` instead. + +Use `once::message` actions when you need to: +- Send a specific message exactly once +- Send a default-constructed message exactly once - Exit the application with a success status -For more complex event handling or when you need to access other system parameters, consider using the more general `once::run` action. +For more complex message handling or when you need to access other system parameters, consider using the more general `once::run` action. diff --git a/docs/src/actions/pipe.md b/docs/src/actions/pipe.md index 78fe64b..2c4515e 100644 --- a/docs/src/actions/pipe.md +++ b/docs/src/actions/pipe.md @@ -76,7 +76,7 @@ fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Wait for a PlayerHit event and then process it task.will(Update, - wait::event::read::() + wait::message::read::() .pipe(once::run(|In(PlayerHit(entity)): In, mut players: Query<&mut Hp>| { players.get_mut(entity).unwrap().0 -= 10; println!("Player hit! HP reduced to {}", players.get(entity).unwrap().0); diff --git a/docs/src/actions/through.md b/docs/src/actions/through.md index 5fc381c..48883af 100644 --- a/docs/src/actions/through.md +++ b/docs/src/actions/through.md @@ -24,7 +24,7 @@ struct Damage(usize); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Use through to insert a delay without affecting the data flow - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .pipe(through(delay::time().with(Duration::from_millis(500)))) .pipe(once::run(|In(Damage(damage)): In| { println!("Player takes {damage} points of damage."); @@ -49,7 +49,7 @@ struct Damage(usize); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Use the through method for a more concise syntax - task.will(Update, wait::event::read::() + task.will(Update, wait::message::read::() .through(delay::time().with(Duration::from_millis(500))) .pipe(once::run(|In(Damage(damage)): In| { println!("Player takes {damage} points of damage."); @@ -139,7 +139,7 @@ fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { // Create a complex action flow with through task.will(Update, - wait::event::read::() + wait::message::read::() .through(once::run(|In(action): In| { println!("Received action: {} with value {}", action.action_type, action.value); })) diff --git a/docs/src/actions/wait/all.md b/docs/src/actions/wait/all.md index 8a6c8a2..ea8902f 100644 --- a/docs/src/actions/wait/all.md +++ b/docs/src/actions/wait/all.md @@ -56,8 +56,8 @@ struct Event2; Reactor::schedule(|task| async move { // Wait for both events and get their values let (event1, event2) = task.will(Update, wait_all![ - wait::event::read::(), - wait::event::read::() + wait::message::read::(), + wait::message::read::() ]).await; // This code runs after both events are received diff --git a/docs/src/actions/wait/any.md b/docs/src/actions/wait/any.md index dbaeec8..a2a1463 100644 --- a/docs/src/actions/wait/any.md +++ b/docs/src/actions/wait/any.md @@ -24,7 +24,7 @@ Reactor::schedule(|task| async move { // Wait until either the B key is pressed or an AppExit event is received let index = task.will(Update, wait::any().with(actions![ wait::input::just_pressed().with(KeyCode::KeyB), - wait::event::comes::() + wait::message::comes::() ])).await; // Check which action completed diff --git a/docs/src/actions/wait/both.md b/docs/src/actions/wait/both.md index 239b2a6..a8e127f 100644 --- a/docs/src/actions/wait/both.md +++ b/docs/src/actions/wait/both.md @@ -22,7 +22,7 @@ Reactor::schedule(|task| async move { // Wait for both the R key to be pressed and an AppExit event to be received let (_, exit_event) = task.will(Update, wait::both( wait::input::just_pressed().with(KeyCode::KeyR), - wait::event::read::() + wait::message::read::() )).await; // This code runs after both conditions are met diff --git a/docs/src/actions/wait/either.md b/docs/src/actions/wait/either.md index a383629..14f07c0 100644 --- a/docs/src/actions/wait/either.md +++ b/docs/src/actions/wait/either.md @@ -40,7 +40,7 @@ Reactor::schedule(|task| async move { // Wait until either a system returns false or an AppExit event is received let result = task.will(Update, wait::either( wait::until(|| false), - wait::event::read::() + wait::message::read::() )).await; match result { diff --git a/docs/src/actions/wait/event.md b/docs/src/actions/wait/event.md index 81b35dc..4de94d9 100644 --- a/docs/src/actions/wait/event.md +++ b/docs/src/actions/wait/event.md @@ -1,13 +1,15 @@ # wait::event -The `wait::event` module provides actions for waiting to receive Bevy events. These actions are useful for creating tasks that respond to events in your game or application. +> **⚠️ DEPRECATED**: This module is deprecated since Bevy 0.17. Please use [`wait::message`](./message.md) instead. The `Event` trait has been replaced with `Message` in Bevy 0.17. + +The `wait::event` module provides actions for waiting to receive Bevy messages. These actions are useful for creating tasks that respond to messages in your game or application. ## Functions ### comes ``` -wait::event::comes() -> ActionSeed +wait::message::comes() -> ActionSeed ``` Creates an action that waits until an event of type `E` is received. The action completes when the event is received but does not return the event itself. @@ -21,7 +23,7 @@ use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { // Wait for an AppExit event - task.will(Update, wait::event::comes::()).await; + task.will(Update, wait::message::comes::()).await; // This code runs after an AppExit event is received println!("App is exiting!"); @@ -31,7 +33,7 @@ Reactor::schedule(|task| async move { ### comes_and ``` -wait::event::comes_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed +wait::message::comes_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed ``` Creates an action that waits until an event of type `E` is received and the event matches the given predicate. The action completes when a matching event is received but does not return the event itself. @@ -45,7 +47,7 @@ use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { // Wait for a successful AppExit event - task.will(Update, wait::event::comes_and::(|e| { + task.will(Update, wait::message::comes_and::(|e| { e.is_success() })).await; @@ -57,7 +59,7 @@ Reactor::schedule(|task| async move { ### read ``` -wait::event::read() -> ActionSeed<(), E> +wait::message::read() -> ActionSeed<(), E> ``` Creates an action that waits until an event of type `E` is received and returns a clone of the event. This is similar to `comes`, but it returns the event itself. @@ -71,7 +73,7 @@ use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { // Wait for an AppExit event and get the event - let exit_event = task.will(Update, wait::event::read::()).await; + let exit_event = task.will(Update, wait::message::read::()).await; // This code runs after an AppExit event is received println!("App is exiting with status: {:?}", exit_event); @@ -81,7 +83,7 @@ Reactor::schedule(|task| async move { ### read_and ```rust -wait::event::read_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed<(), E> +wait::message::read_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed<(), E> ``` Creates an action that waits until an event of type `E` is received, the event matches the given predicate, and returns a clone of the event. This is similar to `comes_and`, but it returns the event itself. @@ -95,7 +97,7 @@ use bevy_flurx::prelude::*; Reactor::schedule(|task| async move { // Wait for a successful AppExit event and get the event - let exit_event = task.will(Update, wait::event::read_and::(|e| { + let exit_event = task.will(Update, wait::message::read_and::(|e| { e.is_success() })).await; @@ -106,10 +108,12 @@ Reactor::schedule(|task| async move { ## When to Use -Use `wait::event` actions when you need to: -- Wait for specific events to occur before continuing execution -- React to events in an asynchronous manner -- Filter events based on their content using predicates -- Retrieve event data for further processing +> **Note**: This module is deprecated. Use `wait::message` instead. + +Use `wait::message` actions when you need to: +- Wait for specific messages to occur before continuing execution +- React to messages in an asynchronous manner +- Filter messages based on their content using predicates +- Retrieve message data for further processing -For more complex event handling scenarios, consider combining `wait::event` with other wait actions like `wait::either` or `wait::any` to wait for multiple different event types. \ No newline at end of file +For more complex message handling scenarios, consider combining `wait::message` with other wait actions like `wait::either` or `wait::any` to wait for multiple different message types. \ No newline at end of file diff --git a/examples/custom_runner.rs b/examples/custom_runner.rs index 2907be7..ddc47c9 100644 --- a/examples/custom_runner.rs +++ b/examples/custom_runner.rs @@ -22,7 +22,7 @@ fn spawn_reactor(mut commands: Commands) { delay: Duration::from_secs(3), message: "After 3 seconds, this message is displayed.", })) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) }) .await; })); diff --git a/examples/cut_in.rs b/examples/cut_in.rs index f636c6d..e7a4403 100644 --- a/examples/cut_in.rs +++ b/examples/cut_in.rs @@ -56,7 +56,7 @@ fn spawn_reactor(mut commands: Commands) { .then(once::switch::off::()) .then(once::switch::on::()) .then(delay::time().with(Duration::from_millis(300))) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) }) .await; })); diff --git a/examples/inspect.rs b/examples/inspect.rs index aa329e7..4f73490 100644 --- a/examples/inspect.rs +++ b/examples/inspect.rs @@ -30,7 +30,7 @@ struct Damage(usize); fn spawn_reactor(mut commands: Commands) { commands.spawn(Reactor::schedule(|task| async move { task.will(Update, { - wait::event::read::() + wait::message::read::() .inspect(once::run(|In(damage): In| { info!("Hit damage: {}", damage.0); })) @@ -40,7 +40,7 @@ fn spawn_reactor(mut commands: Commands) { info!("Player HP: {}", player_hp.0); }, )) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) }) .await; })); diff --git a/examples/side_effect.rs b/examples/side_effect.rs index f347ddc..9ab5ddc 100644 --- a/examples/side_effect.rs +++ b/examples/side_effect.rs @@ -48,7 +48,7 @@ fn spawn_reactor(mut commands: Commands) { .await; info!("Done!"); - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; })); } diff --git a/examples/simple.rs b/examples/simple.rs index 321fbac..753426e 100644 --- a/examples/simple.rs +++ b/examples/simple.rs @@ -84,6 +84,6 @@ fn spawn_reactor(mut commands: Commands) { assert_eq!(message, "count is 4"); info!("Done!"); - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; })); } diff --git a/src/action.rs b/src/action.rs index 5522c62..fd8ce31 100644 --- a/src/action.rs +++ b/src/action.rs @@ -118,7 +118,7 @@ where /// let actions: [ActionSeed; 3] = actions![ /// once::run(||{}), /// delay::frames().with(3), -/// wait::event::comes::() +/// wait::message::comes::() /// ]; /// ``` #[macro_export] diff --git a/src/action/delay.rs b/src/action/delay.rs index 3e151fe..f53e7da 100644 --- a/src/action/delay.rs +++ b/src/action/delay.rs @@ -70,7 +70,7 @@ mod tests { First, delay::frames() .with(1) - .then(once::event::app_exit_success()), + .then(once::message::app_exit_success()), ) .await; })); diff --git a/src/action/inspect.rs b/src/action/inspect.rs index 57a36d6..d3649a8 100644 --- a/src/action/inspect.rs +++ b/src/action/inspect.rs @@ -41,7 +41,7 @@ //! struct Hp(u8); //! //! Reactor::schedule(|task| async move { -//! task.will(Update, wait::event::read::() +//! task.will(Update, wait::message::read::() //! .pipe(inspect(once::run(|In(Damage(damage)): In| { //! println!("Players take {damage} points of damage."); //! }))) @@ -66,7 +66,7 @@ //! struct Hp(u8); //! //! Reactor::schedule(|task| async move { -//! task.will(Update, wait::event::read::() +//! task.will(Update, wait::message::read::() //! .inspect(once::run(|In(Damage(damage)): In| { //! println!("Players take {damage} points of damage."); //! })) @@ -129,7 +129,7 @@ use crate::action::Map; /// struct Hp(u8); /// /// Reactor::schedule(|task| async move { -/// task.will(Update, wait::event::read::() +/// task.will(Update, wait::message::read::() /// .pipe(inspect(once::run(|In(Damage(damage)): In| { /// println!("Players take {damage} points of damage."); /// }))) @@ -184,7 +184,7 @@ where /// struct Hp(u8); /// /// Reactor::schedule(|task| async move { -/// task.will(Update, wait::event::read::() +/// task.will(Update, wait::message::read::() /// .inspect(once::run(|In(Damage(damage)): In| { /// println!("Players take {damage} points of damage."); /// })) diff --git a/src/action/once.rs b/src/action/once.rs index 814f7bc..59eef50 100644 --- a/src/action/once.rs +++ b/src/action/once.rs @@ -12,6 +12,7 @@ mod _no_op; #[cfg_attr(docsrs, doc(cfg(feature = "audio")))] pub mod audio; pub mod event; +pub mod message; pub mod non_send; pub mod res; #[cfg(feature = "state")] diff --git a/src/action/once/event.rs b/src/action/once/event.rs index d4a2362..73b44c3 100644 --- a/src/action/once/event.rs +++ b/src/action/once/event.rs @@ -3,7 +3,7 @@ use crate::action::seed::ActionSeed; use crate::action::{once, Action}; use bevy::app::AppExit; -use bevy::prelude::*; +use bevy::prelude::Message; /// Once send an event. /// @@ -14,17 +14,19 @@ use bevy::prelude::*; /// use bevy::prelude::*; /// use bevy_flurx::prelude::*; /// Reactor::schedule(|task| async move{ -/// task.will(Update, once::event::send().with(AppExit::Success)).await; +/// task.will(Update, once::message::write().with(AppExit::Success)).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `once::message::write()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] #[inline(always)] pub fn send() -> ActionSeed where E: Message, { - once::run(|In(event): In, mut w: MessageWriter| { - w.write(event); - }) + once::message::write::() } /// Once send an event using [`Default`] trait. @@ -36,17 +38,19 @@ where /// use bevy::prelude::*; /// use bevy_flurx::prelude::*; /// Reactor::schedule(|task| async move{ -/// task.will(Update, once::event::send_default::()).await; +/// task.will(Update, once::message::write_default::()).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `once::message::write_default()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] #[inline(always)] pub fn send_default() -> ActionSeed where E: Message + Default, { - once::run(|mut w: MessageWriter| { - w.write(E::default()); - }) + once::message::write_default::() } /// Once send [`AppExit::Success`]. @@ -58,47 +62,14 @@ where /// use bevy::prelude::*; /// use bevy_flurx::prelude::*; /// Reactor::schedule(|task| async move{ -/// task.will(Update, once::event::app_exit_success()).await; +/// task.will(Update, once::message::app_exit_success()).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `once::message::app_exit_success()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] #[inline(always)] pub fn app_exit_success() -> Action { - send().with(AppExit::Success) -} - -#[cfg(test)] -mod tests { - use crate::action::once; - use crate::prelude::Reactor; - use crate::tests::{came_event, test_app}; - use bevy::app::{AppExit, First, Startup}; - use bevy::prelude::Commands; - - #[test] - fn send_event() { - let mut app = test_app(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will(First, once::event::send().with(AppExit::Success)) - .await; - })); - }); - - app.update(); - assert!(came_event::(&mut app)); - } - - #[test] - fn send_default_event() { - let mut app = test_app(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will(First, once::event::send_default::()) - .await; - })); - }); - - app.update(); - assert!(came_event::(&mut app)); - } + once::message::app_exit_success() } diff --git a/src/action/once/message.rs b/src/action/once/message.rs new file mode 100644 index 0000000..73da441 --- /dev/null +++ b/src/action/once/message.rs @@ -0,0 +1,104 @@ +//! [`once::message`] creates a task that only once run system related to [`Message`]. + +use crate::action::seed::ActionSeed; +use crate::action::{once, Action}; +use bevy::app::AppExit; +use bevy::prelude::*; + +/// Once write a message. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// Reactor::schedule(|task| async move{ +/// task.will(Update, once::message::write().with(AppExit::Success)).await; +/// }); +/// ``` +#[inline(always)] +pub fn write() -> ActionSeed +where + M: Message, +{ + once::run(|In(message): In, mut w: MessageWriter| { + w.write(message); + }) +} + +/// Once write a message using [`Default`] trait. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// Reactor::schedule(|task| async move{ +/// task.will(Update, once::message::write_default::()).await; +/// }); +/// ``` +#[inline(always)] +pub fn write_default() -> ActionSeed +where + M: Message + Default, +{ + once::run(|mut w: MessageWriter| { + w.write(M::default()); + }) +} + +/// Once write [`AppExit::Success`]. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// Reactor::schedule(|task| async move{ +/// task.will(Update, once::message::app_exit_success()).await; +/// }); +/// ``` +#[inline(always)] +pub fn app_exit_success() -> Action { + write().with(AppExit::Success) +} + +#[cfg(test)] +mod tests { + use crate::action::once; + use crate::prelude::Reactor; + use crate::tests::{came_event, test_app}; + use bevy::app::{AppExit, First, Startup}; + use bevy::prelude::Commands; + + #[test] + fn write_message() { + let mut app = test_app(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will(First, once::message::write().with(AppExit::Success)) + .await; + })); + }); + + app.update(); + assert!(came_event::(&mut app)); + } + + #[test] + fn write_default_message() { + let mut app = test_app(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will(First, once::message::write_default::()) + .await; + })); + }); + + app.update(); + assert!(came_event::(&mut app)); + } +} diff --git a/src/action/once/no_op.rs b/src/action/once/no_op.rs index ab85c01..ef20c88 100644 --- a/src/action/once/no_op.rs +++ b/src/action/once/no_op.rs @@ -71,7 +71,7 @@ mod tests { app.add_systems(Startup, |mut commands: Commands| { commands.spawn(Reactor::schedule(|task| async move { task.will(Update, { - once::no_op_with_generics::<(), ()>().then(once::event::app_exit_success()) + once::no_op_with_generics::<(), ()>().then(once::message::app_exit_success()) }) .await; })); diff --git a/src/action/pipe.rs b/src/action/pipe.rs index 7e55c5c..db6b6e5 100644 --- a/src/action/pipe.rs +++ b/src/action/pipe.rs @@ -24,7 +24,7 @@ pub trait Pipe { /// /// Reactor::schedule(|task| async move{ /// task.will(Update, { - /// wait::event::read::() + /// wait::message::read::() /// .pipe(once::run(|In(PlayerHit(entity)): In, mut players: Query<&mut Hp>|{ /// players.get_mut(entity).unwrap().0 -= 10; /// })) @@ -131,7 +131,7 @@ mod tests { .map(|dummy| dummy) .through(delay::frames().with(2)) .through(once::run(|| {})) - .then(once::event::app_exit_success()), + .then(once::message::app_exit_success()), ) .await; })); diff --git a/src/action/record/redo.rs b/src/action/record/redo.rs index 70e6e3a..7df9930 100644 --- a/src/action/record/redo.rs +++ b/src/action/record/redo.rs @@ -411,7 +411,7 @@ mod tests { .await .is_err() { - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; } t1.await.unwrap(); })); diff --git a/src/action/sequence.rs b/src/action/sequence.rs index 22013cd..c1c4e14 100644 --- a/src/action/sequence.rs +++ b/src/action/sequence.rs @@ -30,7 +30,7 @@ pub trait Then { /// Reactor::schedule(|task| async move{ /// task.will(Update, { /// wait::input::just_pressed().with(KeyCode::KeyR) - /// .then(once::event::app_exit_success()) + /// .then(once::message::app_exit_success()) /// }).await; /// }); /// ``` diff --git a/src/action/side_effect/tokio.rs b/src/action/side_effect/tokio.rs index 2bd3cde..4a5b542 100644 --- a/src/action/side_effect/tokio.rs +++ b/src/action/side_effect/tokio.rs @@ -175,7 +175,7 @@ mod tests { tokio::time::sleep(Duration::from_millis(100)).await; TASK_FINISHED.store(true, Ordering::Relaxed); }) - .then(once::event::app_exit_success()), + .then(once::message::app_exit_success()), ) // keep running while the test is running .then(delay::time().with(Duration::from_secs(1000))) @@ -206,7 +206,7 @@ mod tests { tokio::time::sleep(Duration::from_millis(100)).await; TASK_FINISHED.store(true, Ordering::Relaxed); }) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) ]) // keep running while the test is running .then(delay::time().with(Duration::from_secs(1000))) diff --git a/src/action/through.rs b/src/action/through.rs index 945a875..65883d3 100644 --- a/src/action/through.rs +++ b/src/action/through.rs @@ -26,7 +26,7 @@ use bevy::prelude::World; /// struct Damage(usize); /// /// Reactor::schedule(|task|async move{ -/// task.will(Update, wait::event::read::() +/// task.will(Update, wait::message::read::() /// .pipe(through(delay::time().with(Duration::from_millis(500)))) /// .pipe(once::run(|In(Damage(damage)): In|{ /// println!("Player takes {damage} points of damage."); @@ -65,7 +65,7 @@ pub trait Through { /// struct Damage(usize); /// /// Reactor::schedule(|task|async move{ - /// task.will(Update, wait::event::read::() + /// task.will(Update, wait::message::read::() /// .through(delay::time().with(Duration::from_millis(500))) /// .pipe(once::run(|In(Damage(damage)): In|{ /// println!("Player takes {damage} points of damage."); diff --git a/src/action/wait.rs b/src/action/wait.rs index d8a12d2..e0b7dbe 100644 --- a/src/action/wait.rs +++ b/src/action/wait.rs @@ -21,6 +21,7 @@ mod all; pub mod audio; pub mod event; pub mod input; +pub mod message; #[cfg(feature = "state")] #[cfg_attr(docsrs, doc(cfg(feature = "state")))] pub mod state; @@ -185,7 +186,7 @@ mod tests { let mut app = test_app(); app.add_systems(Startup, |mut commands: Commands| { commands.spawn(Reactor::schedule(|task| async move { - let event = task.will(PreUpdate, wait::event::read::()).await; + let event = task.will(PreUpdate, wait::message::read::()).await; task.will(Update, once::non_send::insert().with(event)) .await; })); @@ -206,8 +207,8 @@ mod tests { let mut app = test_app(); app.add_systems(Startup, |mut commands: Commands| { commands.spawn(Reactor::schedule(|task| async move { - let t1 = wait::event::read::(); - let t2 = wait::event::read::(); + let t1 = wait::message::read::(); + let t2 = wait::message::read::(); let (event1, event2) = task.will(Update, wait::both(t1, t2)).await; assert_eq!(event1, TestEvent1); diff --git a/src/action/wait/all.rs b/src/action/wait/all.rs index 4a121de..027d8c7 100644 --- a/src/action/wait/all.rs +++ b/src/action/wait/all.rs @@ -87,10 +87,10 @@ impl Runner for AllRunner { /// /// Reactor::schedule(|task| async move{ /// let (event1, event2, event3, event4) = task.will(Update, wait_all![ -/// wait::event::read::(), -/// wait::event::read::(), -/// wait::event::read::(), -/// wait::event::read::(), +/// wait::message::read::(), +/// wait::message::read::(), +/// wait::message::read::(), +/// wait::message::read::(), /// ]).await; /// assert_eq!(event1, Event1); /// assert_eq!(event2, Event2); @@ -252,7 +252,7 @@ mod tests { ] }) .pipe(wait::all()) - .then(once::event::app_exit_success()) + .then(once::message::app_exit_success()) }) .await; })); @@ -276,8 +276,8 @@ mod tests { .will( Update, wait_all![ - wait::event::read::(), - wait::event::read::(), + wait::message::read::(), + wait::message::read::(), wait::until(|mut c: Local| { *c += 1; *c == 3 @@ -315,8 +315,8 @@ mod tests { let (event1, ..) = task .will( Update, - once::event::send_default::().then(wait_all![ - wait::event::read::(), + once::message::write_default::().then(wait_all![ + wait::message::read::(), once::run(|| {}) ]), ) diff --git a/src/action/wait/any.rs b/src/action/wait/any.rs index 29826ba..456c27a 100644 --- a/src/action/wait/any.rs +++ b/src/action/wait/any.rs @@ -22,7 +22,7 @@ use bevy::prelude::*; /// // The output value is the index of the completed action. /// let index: usize = task.will(Update, wait::any().with(actions![ /// wait::input::just_pressed().with(KeyCode::KeyB), -/// wait::event::comes::() +/// wait::message::comes::() /// ])).await; /// }); /// ``` @@ -96,7 +96,7 @@ mod tests { ) .await; if index == 1 { - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; } })); }); @@ -122,7 +122,7 @@ mod tests { ) .await; if index == 0 { - task.will(Update, once::event::app_exit_success()).await; + task.will(Update, once::message::app_exit_success()).await; } })); }); diff --git a/src/action/wait/both.rs b/src/action/wait/both.rs index 81a8200..1911095 100644 --- a/src/action/wait/both.rs +++ b/src/action/wait/both.rs @@ -16,7 +16,7 @@ use bevy::prelude::World; /// Reactor::schedule(|task|async move{ /// task.will(Update, wait::both( /// wait::input::just_pressed().with(KeyCode::KeyR), -/// wait::event::read::() +/// wait::message::read::() /// )).await; /// }); /// ``` diff --git a/src/action/wait/either.rs b/src/action/wait/either.rs index 071fff8..41abcad 100644 --- a/src/action/wait/either.rs +++ b/src/action/wait/either.rs @@ -41,7 +41,7 @@ impl Either { /// Reactor::schedule(|task| async move{ /// let either = task.will(Update, wait::either( /// wait::until(||false), -/// wait::event::read::() +/// wait::message::read::() /// )).await; /// match either { /// Either::Left(_) => {} diff --git a/src/action/wait/event.rs b/src/action/wait/event.rs index 1949e38..7fced46 100644 --- a/src/action/wait/event.rs +++ b/src/action/wait/event.rs @@ -2,7 +2,6 @@ use crate::prelude::seed::ActionSeed; use crate::prelude::wait; -use bevy::ecs::message::MessageCursor; use bevy::prelude::*; /// Waits until the event is received. @@ -15,31 +14,18 @@ use bevy::prelude::*; /// use bevy_flurx::prelude::*; /// /// Reactor::schedule(|task| async move{ -/// task.will(Update, wait::event::comes::()).await; +/// task.will(Update, wait::message::comes::()).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `wait::message::comes()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] pub fn comes() -> ActionSeed where E: Message, { - wait::until( - |mut er: Local>>, mut events: ResMut>| { - if er.is_none() { - if 0 < events.iter_current_update_messages().count() { - events.clear(); - return true; - } - er.replace(events.get_cursor_current()); - } - - if 0 < er.as_mut().unwrap().read(&events).count() { - events.clear(); - true - } else { - false - } - }, - ) + wait::message::comes::() } /// Waits until the event is received and the event matches the predicate. @@ -52,39 +38,25 @@ where /// use bevy_flurx::prelude::*; /// /// Reactor::schedule(|task| async move{ -/// task.will(Update, wait::event::comes_and::(|e: &AppExit|{ +/// task.will(Update, wait::message::comes_and::(|e: &AppExit|{ /// e.is_success() /// })).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `wait::message::comes_and()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] pub fn comes_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed where E: Message, { - wait::until( - move |mut er: Local>>, mut events: ResMut>| { - if er.is_none() { - let received = events.iter_current_update_messages().any(&predicate); - if received { - events.clear(); - return true; - } - er.replace(events.get_cursor_current()); - } - - if er.as_mut().unwrap().read(&events).any(&predicate) { - events.clear(); - true - } else { - false - } - }, - ) + wait::message::comes_and::(predicate) } /// Waits until the event is received. /// -/// This is similar to [`wait::event::comes`], but it returns a cloned event. +/// This is similar to [`wait::message::comes`], but it returns a cloned event. /// /// ## Examples /// @@ -94,20 +66,24 @@ where /// use bevy_flurx::prelude::*; /// /// Reactor::schedule(|task| async move{ -/// task.will(Update, wait::event::read::()).await; +/// task.will(Update, wait::message::read::()).await; /// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `wait::message::read()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] #[inline(always)] pub fn read() -> ActionSeed<(), E> where E: Message + Clone, { - wait::event::read_and(|_| true) + wait::message::read::() } /// Waits until the event is received and the event matches the predicate. /// -/// This is similar to [`wait::event::comes`], but it returns a cloned event. +/// This is similar to [`wait::message::comes`], but it returns a cloned event. /// /// ## Examples /// @@ -117,166 +93,19 @@ where /// use bevy_flurx::prelude::*; /// /// Reactor::schedule(|task| async move{ -/// task.will(Update, wait::event::read_and::(|e: &AppExit|{ +/// task.will(Update, wait::message::read_and::(|e: &AppExit|{ /// e.is_success() /// })).await; -/// }); +/// }); /// ``` +#[deprecated( + since = "0.13.0", + note = "Use `wait::message::read_and()` instead. The `Event` trait has been replaced with `Message` in Bevy 0.17." +)] #[inline(always)] pub fn read_and(predicate: impl Fn(&E) -> bool + Send + Sync + 'static) -> ActionSeed<(), E> where E: Message + Clone, { - wait::output( - move |mut er: Local>>, mut events: ResMut>| { - if er.is_none() { - let event = { - events - .iter_current_update_messages() - .find(|e| predicate(e)) - .cloned() - }; - if let Some(event) = event { - events.clear(); - return Some(event); - } - } - let er = er.get_or_insert_with(|| events.get_cursor_current()); - if let Some(event) = er.read(&events).find(|e| predicate(e)).cloned() { - events.clear(); - Some(event) - } else { - None - } - }, - ) -} - -#[cfg(test)] -mod tests { - use crate::action::{once, wait}; - use crate::prelude::{Either, Pipe, Reactor, Then}; - use crate::tests::test_app; - use bevy::app::{App, Startup, Update}; - use bevy::prelude::*; - use bevy_test_helper::event::*; - use bevy_test_helper::resource::DirectResourceControl; - - #[test] - fn wait_until_event_consumed_events() { - let mut app = test_app(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will( - Update, - once::event::send_default::() - .then(wait::event::comes::()), - ) - .await; - - task.will(Update, { - wait::either(wait::event::comes::(), once::run(|| {})).pipe( - once::run( - |In(either): In>, mut ew: MessageWriter| { - if either.is_right() { - ew.write_default(); - } - }, - ), - ) - }) - .await; - })); - }); - - app.update(); - app.update(); - - let mut er = app.resource_mut::>().get_cursor(); - app.assert_message_comes(&mut er); - } - - #[test] - fn wait_read_event_consumed_events() { - let mut app = test_app(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will( - Update, - once::event::send_default::() - .then(wait::event::read::()), - ) - .await; - - task.will(Update, { - wait::either(wait::event::read::(), once::run(|| {})).pipe( - once::run( - |In(either): In>, - mut ew: MessageWriter| { - if either.is_right() { - ew.write_default(); - } - }, - ), - ) - }) - .await; - })); - }); - - app.update(); - app.update(); - - let mut er = app.resource_mut::>().get_cursor(); - app.assert_message_comes(&mut er); - } - - #[derive(Message, Clone, Debug, Eq, PartialEq, Resource)] - struct PredicateMessage(bool); - - #[test] - fn wait_read_event_with_predicate() { - let mut app = test_app(); - app.add_message::(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will( - Update, - wait::event::read_and::(|e| e.0).pipe(once::res::insert()), - ) - .await; - })); - }); - assert_event_predicate(&mut app); - } - - #[test] - fn wait_comes_event_with_predicate() { - let mut app = test_app(); - app.add_message::(); - app.add_systems(Startup, |mut commands: Commands| { - commands.spawn(Reactor::schedule(|task| async move { - task.will( - Update, - wait::event::comes_and::(|e| e.0) - .then(once::res::insert().with(PredicateMessage(true))), - ) - .await; - })); - }); - assert_event_predicate(&mut app); - } - - fn assert_event_predicate(app: &mut App) { - app.update(); - assert!(!app.world().contains_resource::()); - - app.write(PredicateMessage(false)); - app.update(); - assert!(!app.world().contains_resource::()); - - app.write(PredicateMessage(true)); - app.update(); - app.assert_resource_eq(PredicateMessage(true)); - } + wait::message::read_and::(predicate) } diff --git a/src/action/wait/message.rs b/src/action/wait/message.rs new file mode 100644 index 0000000..28fa099 --- /dev/null +++ b/src/action/wait/message.rs @@ -0,0 +1,282 @@ +//! [`wait::message`] creates a task related to waiting to receive messages. + +use crate::prelude::seed::ActionSeed; +use crate::prelude::wait; +use bevy::ecs::message::MessageCursor; +use bevy::prelude::*; + +/// Waits until the message is received. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// +/// Reactor::schedule(|task| async move{ +/// task.will(Update, wait::message::comes::()).await; +/// }); +/// ``` +pub fn comes() -> ActionSeed +where + M: Message, +{ + wait::until( + |mut er: Local>>, mut messages: ResMut>| { + if er.is_none() { + if 0 < messages.iter_current_update_messages().count() { + messages.clear(); + return true; + } + er.replace(messages.get_cursor_current()); + } + + if 0 < er.as_mut().unwrap().read(&messages).count() { + messages.clear(); + true + } else { + false + } + }, + ) +} + +/// Waits until the message is received and the message matches the predicate. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// +/// Reactor::schedule(|task| async move{ +/// task.will(Update, wait::message::comes_and::(|e: &AppExit|{ +/// e.is_success() +/// })).await; +/// }); +/// ``` +pub fn comes_and(predicate: impl Fn(&M) -> bool + Send + Sync + 'static) -> ActionSeed +where + M: Message, +{ + wait::until( + move |mut er: Local>>, mut messages: ResMut>| { + if er.is_none() { + let received = messages.iter_current_update_messages().any(&predicate); + if received { + messages.clear(); + return true; + } + er.replace(messages.get_cursor_current()); + } + + if er.as_mut().unwrap().read(&messages).any(&predicate) { + messages.clear(); + true + } else { + false + } + }, + ) +} + +/// Waits until the message is received. +/// +/// This is similar to [`wait::message::comes`], but it returns a cloned message. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// +/// Reactor::schedule(|task| async move{ +/// task.will(Update, wait::message::read::()).await; +/// }); +/// ``` +#[inline(always)] +pub fn read() -> ActionSeed<(), M> +where + M: Message + Clone, +{ + wait::message::read_and(|_| true) +} + +/// Waits until the message is received and the message matches the predicate. +/// +/// This is similar to [`wait::message::comes`], but it returns a cloned message. +/// +/// ## Examples +/// +/// ```no_run +/// use bevy::app::AppExit; +/// use bevy::prelude::*; +/// use bevy_flurx::prelude::*; +/// +/// Reactor::schedule(|task| async move{ +/// task.will(Update, wait::message::read_and::(|e: &AppExit|{ +/// e.is_success() +/// })).await; +/// }); +/// ``` +#[inline(always)] +pub fn read_and(predicate: impl Fn(&M) -> bool + Send + Sync + 'static) -> ActionSeed<(), M> +where + M: Message + Clone, +{ + wait::output( + move |mut er: Local>>, mut messages: ResMut>| { + if er.is_none() { + let message = { + messages + .iter_current_update_messages() + .find(|e| predicate(e)) + .cloned() + }; + if let Some(message) = message { + messages.clear(); + return Some(message); + } + } + let er = er.get_or_insert_with(|| messages.get_cursor_current()); + if let Some(message) = er.read(&messages).find(|e| predicate(e)).cloned() { + messages.clear(); + Some(message) + } else { + None + } + }, + ) +} + +#[cfg(test)] +mod tests { + use crate::action::{once, wait}; + use crate::prelude::{Either, Pipe, Reactor, Then}; + use crate::tests::test_app; + use bevy::app::{App, Startup, Update}; + use bevy::prelude::*; + use bevy_test_helper::event::*; + use bevy_test_helper::resource::DirectResourceControl; + + #[test] + fn wait_until_message_consumed_messages() { + let mut app = test_app(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will( + Update, + once::message::write_default::() + .then(wait::message::comes::()), + ) + .await; + + task.will(Update, { + wait::either(wait::message::comes::(), once::run(|| {})).pipe( + once::run( + |In(either): In>, mut ew: MessageWriter| { + if either.is_right() { + ew.write_default(); + } + }, + ), + ) + }) + .await; + })); + }); + + app.update(); + app.update(); + + let mut er = app.resource_mut::>().get_cursor(); + app.assert_message_comes(&mut er); + } + + #[test] + fn wait_read_message_consumed_messages() { + let mut app = test_app(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will( + Update, + once::message::write_default::() + .then(wait::message::read::()), + ) + .await; + + task.will(Update, { + wait::either(wait::message::read::(), once::run(|| {})).pipe( + once::run( + |In(either): In>, + mut ew: MessageWriter| { + if either.is_right() { + ew.write_default(); + } + }, + ), + ) + }) + .await; + })); + }); + + app.update(); + app.update(); + + let mut er = app.resource_mut::>().get_cursor(); + app.assert_message_comes(&mut er); + } + + #[derive(Message, Clone, Debug, Eq, PartialEq, Resource)] + struct PredicateMessage(bool); + + #[test] + fn wait_read_message_with_predicate() { + let mut app = test_app(); + app.add_message::(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will( + Update, + wait::message::read_and::(|e| e.0).pipe(once::res::insert()), + ) + .await; + })); + }); + assert_message_predicate(&mut app); + } + + #[test] + fn wait_comes_message_with_predicate() { + let mut app = test_app(); + app.add_message::(); + app.add_systems(Startup, |mut commands: Commands| { + commands.spawn(Reactor::schedule(|task| async move { + task.will( + Update, + wait::message::comes_and::(|e| e.0) + .then(once::res::insert().with(PredicateMessage(true))), + ) + .await; + })); + }); + assert_message_predicate(&mut app); + } + + fn assert_message_predicate(app: &mut App) { + app.update(); + assert!(!app.world().contains_resource::()); + + app.write(PredicateMessage(false)); + app.update(); + assert!(!app.world().contains_resource::()); + + app.write(PredicateMessage(true)); + app.update(); + app.assert_resource_eq(PredicateMessage(true)); + } +} diff --git a/src/runner.rs b/src/runner.rs index dcf6b65..eb2b078 100644 --- a/src/runner.rs +++ b/src/runner.rs @@ -694,7 +694,7 @@ mod tests { Update, delay::frames() .with(1) - .then(once::event::app_exit_success()), + .then(once::message::app_exit_success()), ) .await; })); diff --git a/src/task.rs b/src/task.rs index d95e44f..a3aa823 100644 --- a/src/task.rs +++ b/src/task.rs @@ -71,8 +71,8 @@ impl ReactorTask { /// app.add_plugins(FlurxPlugin); /// app.add_systems(Startup, |mut commands: Commands|{ /// commands.spawn(Reactor::schedule(|task|async move{ - /// let wait_event = task.run(Update, wait::event::comes::()).await; - /// task.will(Update, once::event::send().with(AppExit::Success)).await; + /// let wait_event = task.run(Update, wait::message::comes::()).await; + /// task.will(Update, once::message::write().with(AppExit::Success)).await; /// wait_event.await; /// })); /// }); @@ -111,8 +111,8 @@ mod tests { let mut app = test_app(); app.add_systems(Startup, |mut commands: Commands| { commands.spawn(Reactor::schedule(|task| async move { - let event_task = task.run(First, wait::event::read::()).await; - task.will(Update, once::event::send().with(AppExit::Success)) + let event_task = task.run(First, wait::message::read::()).await; + task.will(Update, once::message::write().with(AppExit::Success)) .await; event_task.await; task.will(Update, once::non_send::insert().with(AppExit::Success))