From 7cd23c10d5de2ea1c0603d1e55dfc9ee004ddd9b Mon Sep 17 00:00:00 2001
From: Seldom <38388947+Seldom-SE@users.noreply.github.com>
Date: Wed, 21 Feb 2024 15:57:33 -0700
Subject: [PATCH] Bevy 0.13, `on_event` fix, trigger combinator fix

---
 Cargo.toml           | 20 ++++++++---------
 examples/chase.rs    |  6 ++---
 examples/done.rs     |  5 ++++-
 examples/input.rs    |  8 +++----
 src/trigger.rs       | 52 ++++++++++++++++++++++++++++++++++++++++----
 src/trigger/input.rs | 24 ++++++++++----------
 6 files changed, 81 insertions(+), 34 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index fbce0ff..1793843 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,30 +2,30 @@
 name = "seldom_state"
 version = "0.9.0"
 edition = "2021"
-categories = [ "game-development" ]
+categories = ["game-development"]
 description = "Component-based state machine plugin for Bevy. Useful for AI, player state, and other entities that occupy various states."
-exclude = [ "assets/" ]
-keywords = [ "gamedev", "bevy", "ai", "state-machine" ]
+exclude = ["assets/"]
+keywords = ["gamedev", "bevy", "ai", "state-machine"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/Seldom-SE/seldom_state"
 
 [features]
-leafwing_input = [ "dep:leafwing-input-manager" ]
+leafwing_input = ["dep:leafwing-input-manager"]
 
 [dependencies]
-bevy = { version = "0.12.0", default-features = false }
+bevy = { version = "0.13.0", default-features = false }
 either = "1.9"
-leafwing-input-manager = { version = "0.11.1", default-features = false, optional = true }
-seldom_fn_plugin = "0.5.0"
+leafwing-input-manager = { version = "0.13.0", default-features = false, optional = true }
+seldom_fn_plugin = "0.6.0"
 
 [dev-dependencies]
-bevy = "0.12.0"
-leafwing-input-manager = "0.11.1"
+bevy = "0.13.0"
+leafwing-input-manager = "0.13.0"
 
 [[example]]
 name = "input"
-required-features = [ "leafwing_input" ]
+required-features = ["leafwing_input"]
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/examples/chase.rs b/examples/chase.rs
index a7fe3e4..773e11f 100644
--- a/examples/chase.rs
+++ b/examples/chase.rs
@@ -151,12 +151,12 @@ const PLAYER_SPEED: f32 = 200.;
 
 fn move_player(
     mut players: Query<&mut Transform, With<Player>>,
-    keys: Res<Input<KeyCode>>,
+    keys: Res<ButtonInput<KeyCode>>,
     time: Res<Time>,
 ) {
     players.single_mut().translation += Vec3::new(
-        (keys.pressed(KeyCode::Right) as i32 - keys.pressed(KeyCode::Left) as i32) as f32,
-        (keys.pressed(KeyCode::Up) as i32 - keys.pressed(KeyCode::Down) as i32) as f32,
+        (keys.pressed(KeyCode::ArrowRight) as i32 - keys.pressed(KeyCode::ArrowLeft) as i32) as f32,
+        (keys.pressed(KeyCode::ArrowUp) as i32 - keys.pressed(KeyCode::ArrowDown) as i32) as f32,
         0.,
     )
     .normalize_or_zero()
diff --git a/examples/done.rs b/examples/done.rs
index b7638aa..c4e4e3c 100644
--- a/examples/done.rs
+++ b/examples/done.rs
@@ -38,7 +38,10 @@ fn init(mut commands: Commands, asset_server: Res<AssetServer>) {
     ));
 }
 
-fn click(mouse: Res<Input<MouseButton>>, cursor_position: Res<CursorPosition>) -> Option<Vec2> {
+fn click(
+    mouse: Res<ButtonInput<MouseButton>>,
+    cursor_position: Res<CursorPosition>,
+) -> Option<Vec2> {
     mouse
         .just_pressed(MouseButton::Left)
         .then_some(())
diff --git a/examples/input.rs b/examples/input.rs
index 11572e0..0c9c2c9 100644
--- a/examples/input.rs
+++ b/examples/input.rs
@@ -31,13 +31,13 @@ fn init(mut commands: Commands, asset_server: Res<AssetServer>) {
         // From `leafwing-input-manager`
         InputManagerBundle {
             input_map: InputMap::default()
-                .insert(VirtualAxis::horizontal_arrow_keys(), Action::Move)
+                .insert(Action::Move, VirtualAxis::horizontal_arrow_keys())
                 .insert(
-                    SingleAxis::symmetric(GamepadAxisType::LeftStickX, 0.),
                     Action::Move,
+                    SingleAxis::symmetric(GamepadAxisType::LeftStickX, 0.),
                 )
-                .insert(KeyCode::Space, Action::Jump)
-                .insert(GamepadButtonType::South, Action::Jump)
+                .insert(Action::Jump, KeyCode::Space)
+                .insert(Action::Jump, GamepadButtonType::South)
                 .build(),
             ..default()
         },
diff --git a/src/trigger.rs b/src/trigger.rs
index 4a726a4..37214c0 100644
--- a/src/trigger.rs
+++ b/src/trigger.rs
@@ -113,17 +113,52 @@ pub trait IntoTrigger<Marker>: Sized {
     fn into_trigger(self) -> Self::Trigger;
 
     /// Negates the trigger. Do not override.
-    fn not(self) -> impl Trigger {
+    fn not(
+        self,
+    ) -> impl Trigger<
+        Out = Result<
+            <<Self::Trigger as Trigger>::Out as TriggerOut>::Err,
+            <<Self::Trigger as Trigger>::Out as TriggerOut>::Ok,
+        >,
+    > {
         NotTrigger(self.into_trigger())
     }
 
     /// Combines these triggers by logical AND. Do not override.
-    fn and<Marker2>(self, other: impl IntoTrigger<Marker2>) -> impl Trigger {
+    fn and<Marker2, T: IntoTrigger<Marker2>>(
+        self,
+        other: T,
+    ) -> impl Trigger<
+        Out = Result<
+            (
+                <<Self::Trigger as Trigger>::Out as TriggerOut>::Ok,
+                <<T::Trigger as Trigger>::Out as TriggerOut>::Ok,
+            ),
+            Either<
+                <<Self::Trigger as Trigger>::Out as TriggerOut>::Err,
+                <<T::Trigger as Trigger>::Out as TriggerOut>::Err,
+            >,
+        >,
+    > {
         AndTrigger(self.into_trigger(), other.into_trigger())
     }
 
     /// Combines these triggers by logical OR. Do not override.
-    fn or<Marker2>(self, other: impl IntoTrigger<Marker2>) -> impl Trigger {
+    fn or<Marker2, T: IntoTrigger<Marker2>>(
+        self,
+        other: T,
+    ) -> impl Trigger<
+        Out = Result<
+            Either<
+                <<Self::Trigger as Trigger>::Out as TriggerOut>::Ok,
+                <<T::Trigger as Trigger>::Out as TriggerOut>::Ok,
+            >,
+            (
+                <<Self::Trigger as Trigger>::Out as TriggerOut>::Err,
+                <<T::Trigger as Trigger>::Out as TriggerOut>::Err,
+            ),
+        >,
+    > {
         OrTrigger(self.into_trigger(), other.into_trigger())
     }
 }
@@ -291,7 +326,16 @@ pub fn done(expected: Option<Done>) -> impl Trigger<Out = bool> {
 }
 
 /// Trigger that transitions when it receives the associated event
-pub fn on_event<T: Clone + Event>(mut reader: EventReader<T>) -> Option<T> {
+pub fn on_event<T: Clone + Event>(
+    mut has_run: Local<bool>,
+    mut reader: EventReader<T>,
+) -> Option<T> {
+    if !*has_run {
+        reader.read().last();
+        *has_run = true;
+        return None;
+    }
+
     reader.read().last().cloned()
 }
 
diff --git a/src/trigger/input.rs b/src/trigger/input.rs
index 0156de6..bd5892c 100644
--- a/src/trigger/input.rs
+++ b/src/trigger/input.rs
@@ -18,7 +18,7 @@ pub fn value<A: Actionlike>(action: A, bounds: Range<f32>) -> impl Trigger<Out =
                     type_name::<A>()
                 )
             })
-            .value(action.clone());
+            .value(&action);
 
         if bounds.contains(&value) {
             Ok(value)
@@ -58,7 +58,7 @@ pub fn clamped_value<A: Actionlike>(
                     type_name::<A>()
                 )
             })
-            .clamped_value(action.clone());
+            .clamped_value(&action);
 
         if bounds.contains(&value) {
             Ok(value)
@@ -109,7 +109,7 @@ pub fn axis_pair<A: Actionlike>(
                     type_name::<A>()
                 )
             })
-            .axis_pair(action.clone());
+            .axis_pair(&action);
 
         axis_pair
             .and_then(|axis_pair| {
@@ -191,7 +191,7 @@ pub fn clamped_axis_pair<A: Actionlike>(
                     type_name::<A>()
                 )
             })
-            .clamped_axis_pair(action.clone());
+            .clamped_axis_pair(&action);
 
         axis_pair
             .and_then(|axis_pair| {
@@ -269,7 +269,7 @@ pub fn just_pressed<A: Actionlike>(action: A) -> impl Trigger<Out = bool> {
                     type_name::<A>()
                 )
             })
-            .just_pressed(action.clone())
+            .just_pressed(&action)
     })
     .into_trigger()
 }
@@ -285,7 +285,7 @@ pub fn pressed<A: Actionlike>(action: A) -> impl Trigger<Out = bool> {
                     type_name::<A>()
                 )
             })
-            .pressed(action.clone())
+            .pressed(&action)
     })
     .into_trigger()
 }
@@ -301,15 +301,15 @@ pub fn just_released<A: Actionlike>(action: A) -> impl Trigger<Out = bool> {
                     type_name::<A>()
                 )
             })
-            .just_released(action.clone())
+            .just_released(&action)
     })
     .into_trigger()
 }
 
-/// Trigger that always transitions, providing the given [`Actionlike`]'s [`ActionData`]
-pub fn action_data<A: Actionlike>(action: A) -> impl Trigger<Out = Result<ActionData, Never>> {
+/// Provides the given [`Actionlike`]'s [`ActionData`]
+pub fn action_data<A: Actionlike>(action: A) -> impl Trigger<Out = Option<ActionData>> {
     (move |In(entity): In<Entity>, actors: Query<&ActionState<A>>| {
-        Ok(actors
+        actors
             .get(entity)
             .unwrap_or_else(|_| {
                 panic!(
@@ -317,8 +317,8 @@ pub fn action_data<A: Actionlike>(action: A) -> impl Trigger<Out = Result<Action
                     type_name::<A>()
                 )
             })
-            .action_data(action.clone())
-            .clone())
+            .action_data(&action)
+            .cloned()
     })
     .into_trigger()
 }