From 642342d2c8142218fef8c2d28f42bfcc433c3fc1 Mon Sep 17 00:00:00 2001
From: L <leeorr@gmail.com>
Date: Fri, 29 Dec 2023 10:55:38 -0500
Subject: [PATCH] fix compilation issues

---
 crates/bevy_ecs/macros/src/lib.rs             |  1 -
 crates/bevy_ecs/src/schedule/state.rs         |  9 +------
 .../bevy_ecs/src/schedule/state_matching.rs   |  4 +++
 examples/ecs/black_box_state.rs               | 26 +++++++++----------
 examples/ecs/nested_state.rs                  | 26 +++++++++----------
 examples/ecs/state.rs                         | 16 ++++++------
 examples/ecs/state_transitions.rs             |  2 +-
 examples/ecs/struct_state.rs                  | 26 +++++++++----------
 8 files changed, 53 insertions(+), 57 deletions(-)

diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index d975de569a524..8c2022ba96ca7 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -1,7 +1,6 @@
 extern crate proc_macro;
 
 mod component;
-mod fetch;
 mod state_matchers;
 mod query_data;
 mod query_filter;
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
index ee0fbda5672d5..3e9c00b017556 100644
--- a/crates/bevy_ecs/src/schedule/state.rs
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -4,7 +4,6 @@ use std::mem;
 use std::ops::Deref;
 
 use crate as bevy_ecs;
-use crate::change_detection::DetectChangesMut;
 use crate::prelude::FromWorld;
 #[cfg(feature = "bevy_reflect")]
 use crate::reflect::ReflectResource;
@@ -208,7 +207,7 @@ impl<S: States> Deref for State<S> {
 /// To queue a transition, just set the contained value to `Some(next_state)`.
 /// Note that these transitions can be overridden by other systems:
 /// only the actual value of this resource at the time of [`apply_state_transition`] matters.
-#[derive(Resource, Debug)]
+#[derive(Resource, Debug, Default)]
 #[cfg_attr(
     feature = "bevy_reflect",
     derive(bevy_reflect::Reflect),
@@ -274,12 +273,6 @@ impl<S: States> Debug for NextState<S> {
     }
 }
 
-impl<S: States> Default for NextState<S> {
-    fn default() -> Self {
-        Self(None)
-    }
-}
-
 impl<S: States> NextState<S> {
     /// Tentatively set a planned state transition to `Some(state)`.
     pub fn set(&mut self, state: S) {
diff --git a/crates/bevy_ecs/src/schedule/state_matching.rs b/crates/bevy_ecs/src/schedule/state_matching.rs
index a455b38d4d4c7..4bff062e5cc83 100644
--- a/crates/bevy_ecs/src/schedule/state_matching.rs
+++ b/crates/bevy_ecs/src/schedule/state_matching.rs
@@ -538,6 +538,10 @@ impl<S: States, M: 'static, Sm: StateMatcher<S, M>> System for StateMatcherSyste
     fn set_last_run(&mut self, last_run: crate::component::Tick) {
         self.0.set_last_run(last_run);
     }
+
+    fn has_deferred(&self) -> bool {
+        false
+    }
 }
 
 /// SAFETY: The boxed system is must be a read only system
diff --git a/examples/ecs/black_box_state.rs b/examples/ecs/black_box_state.rs
index 071916461b188..e48835f71817b 100644
--- a/examples/ecs/black_box_state.rs
+++ b/examples/ecs/black_box_state.rs
@@ -16,7 +16,7 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_systems(Update, toggle_pause)
         .add_systems(Startup, setup)
-        .add_state::<AppState>()
+        .init_state::<AppState>()
         // Because we can't really see the internals of `AppState`, we need to rely on matching functions exported from
         // the `state` module. Fortunately, we can use these with the `entering`/`exiting`/`transitioning` functions!
         // Here we are using the `in_menu` function, which uses a derive to match any state with `in_menu: true`
@@ -303,21 +303,21 @@ fn setup_game(
 const SPEED: f32 = 100.0;
 fn movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y -= 1.0;
         }
 
@@ -329,21 +329,21 @@ fn movement(
 
 fn inverted_movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y -= 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y += 1.0;
         }
 
@@ -361,14 +361,14 @@ fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
     }
 }
 
-fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn toggle_pause(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::Escape) {
         // Like above, we can use the supported operations
         next_state.setter(|state| state.toggle_pause());
     }
 }
 
-fn invert_movement(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn invert_movement(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::ShiftLeft) {
         next_state.setter(|s| s.invert_movement());
     }
diff --git a/examples/ecs/nested_state.rs b/examples/ecs/nested_state.rs
index 0cd403aba431d..bdb03c00aa5f1 100644
--- a/examples/ecs/nested_state.rs
+++ b/examples/ecs/nested_state.rs
@@ -20,7 +20,7 @@ fn main() {
         .add_systems(Startup, setup)
         // You need to register a state type for it to be usable in the app.
         // This sets up all the necessary systems, schedules & resources in the background.
-        .add_state::<AppState>()
+        .init_state::<AppState>()
         // This system runs when we enter `AppState::Menu`, during the `StateTransition` schedule.
         // All systems from the exit schedule of the state we're leaving are run first,
         // and then all systems from the enter schedule of the state we're entering are run second.
@@ -196,21 +196,21 @@ fn setup_game(
 const SPEED: f32 = 100.0;
 fn movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y -= 1.0;
         }
 
@@ -222,21 +222,21 @@ fn movement(
 
 fn inverted_movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y -= 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y += 1.0;
         }
 
@@ -254,7 +254,7 @@ fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
     }
 }
 
-fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn toggle_pause(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::Escape) {
         // Alternatively, you provide next_state with a setter function, which will take the current state, and output the new state, allowing for some degree of update-in-place
         next_state.setter(|state| match &state {
@@ -267,7 +267,7 @@ fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<App
     }
 }
 
-fn invert_movement(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn invert_movement(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::ShiftLeft) {
         next_state.set(AppState::InGame(GameState::Running { inverted: true }));
     }
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index ac53eb2ed6dcc..fbcc1f97e96a9 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -58,7 +58,7 @@ fn main() {
         )
         // We can also have more than one state type set up in an app.
         // In this case, we are adding a Struct as our state type, instead of an enum.
-        .add_state::<MovementState>()
+        .init_state::<MovementState>()
         // And we can chain states just like any run condition, to check against multiple different states!
         .add_systems(
             Update,
@@ -212,21 +212,21 @@ fn movement(
 
 fn inverted_movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y -= 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y += 1.0;
         }
 
@@ -244,7 +244,7 @@ fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
     }
 }
 
-fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn toggle_pause(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::Escape) {
         // Alternatively, you provide next_state with a setter function, which will take the current state, and output the new state, allowing for some degree of update-in-place
         next_state.setter(|state| match &state {
@@ -257,7 +257,7 @@ fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<App
     }
 }
 
-fn invert_movement(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<MovementState>>) {
+fn invert_movement(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<MovementState>>) {
     if input.just_pressed(KeyCode::ShiftLeft) {
         next_state.set(MovementState { inverted: true });
     }
diff --git a/examples/ecs/state_transitions.rs b/examples/ecs/state_transitions.rs
index 6fa22609c4469..17052582b0434 100644
--- a/examples/ecs/state_transitions.rs
+++ b/examples/ecs/state_transitions.rs
@@ -12,7 +12,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, setup)
-        .add_state::<AppState>()
+        .init_state::<AppState>()
         .add_systems(
             Exiting,
             cleanup_ui.run_if(state_matches!(AppState, every _)),
diff --git a/examples/ecs/struct_state.rs b/examples/ecs/struct_state.rs
index 5751820b4ae14..42a2b4667e85d 100644
--- a/examples/ecs/struct_state.rs
+++ b/examples/ecs/struct_state.rs
@@ -24,7 +24,7 @@ fn main() {
         .add_systems(Startup, setup)
         // You need to register a state type for it to be usable in the app.
         // This sets up all the necessary systems, schedules & resources in the background.
-        .add_state::<AppState>()
+        .init_state::<AppState>()
         // Because our state is a complex object, it isn't worth using a value for OnEnter in this case.
         // Instead, we will stick with pattern matching
         .add_systems(
@@ -276,21 +276,21 @@ fn setup_game(
 const SPEED: f32 = 100.0;
 fn movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y -= 1.0;
         }
 
@@ -302,21 +302,21 @@ fn movement(
 
 fn inverted_movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<ButtonInput<KeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::Left) {
+        if input.pressed(KeyCode::ArrowLeft) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::Right) {
+        if input.pressed(KeyCode::ArrowRight) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::Up) {
+        if input.pressed(KeyCode::ArrowUp) {
             direction.y -= 1.0;
         }
-        if input.pressed(KeyCode::Down) {
+        if input.pressed(KeyCode::ArrowDown) {
             direction.y += 1.0;
         }
 
@@ -334,14 +334,14 @@ fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
     }
 }
 
-fn toggle_pause(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn toggle_pause(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::Escape) {
         // Like above, we can use the supported operations
         next_state.setter(|state| state.toggle_pause());
     }
 }
 
-fn invert_movement(input: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
+fn invert_movement(input: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
     if input.just_pressed(KeyCode::ShiftLeft) {
         next_state.setter(|s| s.invert_movement());
     }