Update the dependencies to bevy 0.13 and bevy_egui 0.25

Cargo.toml

@@ -18,7 +18,10 @@ opt-level = 3
 members = ["./", "tools/ci", "macros"]
 
 [features]
-default = ['ui', 'block_ui_interactions']
+default = ['asset', 'ui', 'block_ui_interactions']
+
+# Allow you to use the `InputMap` as `bevy::asset::Asset`.
+asset = ['bevy/bevy_asset']
 
 # Provide functionality refer to `bevy::ui`:
 # - `MockUIInteraction` for `bevy::ui` input mocking.
@@ -35,11 +38,12 @@ egui = ['dep:bevy_egui']
 
 [dependencies]
 leafwing_input_manager_macros = { path = "macros", version = "0.12" }
-bevy = { version = "0.12", default-features = false, features = [
+bevy = { version = "0.13", default-features = false, features = [
   "serialize",
   "bevy_gilrs",
 ] }
-bevy_egui = { version = "0.24", optional = true }
+# TODO(clean): Existing PR repo for update `bevy_egui` to bevy 0.13
+bevy_egui = { git = "https://github.com/Shute052/bevy_egui.git", branch = "Bevy-0.13-and-Egui-0.26", optional = true }
 
 derive_more = { version = "0.99", default-features = false, features = [
   "display",
@@ -51,7 +55,7 @@ fixedbitset = "0.4.2"
 once_cell = "1.17.1"
 
 [dev-dependencies]
-bevy = { version = "0.12", default-features = false, features = [
+bevy = { version = "0.13", default-features = false, features = [
   "bevy_asset",
   "bevy_sprite",
   "bevy_text",
@@ -60,7 +64,8 @@ bevy = { version = "0.12", default-features = false, features = [
   "bevy_core_pipeline",
   "x11",
 ] }
-bevy_egui = { version = "0.24" }
+# TODO(clean): Existing PR repo for update `bevy_egui` to bevy 0.13
+bevy_egui = { git = "https://github.com/Shute052/bevy_egui.git", branch = "Bevy-0.13-and-Egui-0.26" }
 serde_test = "1.0"
 criterion = "0.5"
 

README.md

@@ -11,6 +11,16 @@ The mapping between inputs and actions is many-to-many, and easily configured an
 A single action can be triggered by multiple inputs (or set directly by UI elements or gameplay logic),
 and a single input can result in multiple actions being triggered, which can be handled contextually.
 
+## Supported Bevy Versions
+
+| Bevy | leafwing-input-manager |
+|------|------------------------|
+| 0.13 | 0.13                   |
+| 0.12 | 0.11..0.12             |
+| 0.11 | 0.10                   |
+| 0.10 | 0.9                    |
+| 0.9  | 0.7..0.8               |
+
 ## Features
 
 - Full keyboard, mouse and joystick support for button-like and axis inputs
@@ -25,13 +35,13 @@ and a single input can result in multiple actions being triggered, which can be
 - Ergonomic insertion API that seamlessly blends multiple input types for you
   - Can't decide between `input_map.insert(Action::Jump, KeyCode::Space)` and `input_map.insert(Action::Jump, GamepadButtonType::South)`? Have both!
 - Full support for arbitrary button combinations: chord your heart out.
-  - `input_map.insert_chord(Action::Console, [KeyCode::ControlLeft, KeyCode::Shift, KeyCode::C])`
+  - `input_map.insert_chord(Action::Console, [KeyCode::ControlLeft, KeyCode::Shift, KeyCode::KeyC])`
 - Sophisticated input disambiguation with the `ClashStrategy` enum: stop triggering individual buttons when you meant to press a chord!
 - Create an arbitrary number of strongly typed disjoint action sets by adding multiple copies of this plugin: decouple your camera and player state
 - Local multiplayer support: freely bind keys to distinct entities, rather than worrying about singular global state
 - Networked multiplayer support: serializable structs, and a space-conscious `ActionDiff` representation to send on the wire
 - Powerful and easy-to-use input mocking API for integration testing your Bevy applications
-  - `app.send_input(KeyCode::B)` or `world.send_input(UserInput::chord([KeyCode::B, KeyCode::E, KeyCode::V, KeyCode::Y])`
+  - `app.send_input(KeyCode::KeyB)` or `world.send_input(UserInput::chord([KeyCode::KeyB, KeyCode::KeyE, KeyCode::KeyV, KeyCode::KeyY])`
 - Control which state this plugin is active in: stop wandering around while in a menu!
 - Leafwing Studio's trademark `#![forbid(missing_docs)]`
 
@@ -100,5 +110,5 @@ This snippet is the `minimal.rs` example from the [`examples`](./examples) folde
 
 ## Crate Feature Flags
 
-This crate has three feature flags: `ui`, `block_ui_interactions`, and `egui`.
+This crate has four feature flags: `asset`, `ui`, `block_ui_interactions`, and `egui`.
 Please refer to the `[features]` section in the [`Cargo.toml`](./Cargo.toml) for detailed information about their configurations.

RELEASES.md

@@ -1,5 +1,23 @@
 # Release Notes
 
+## Unreleased
+
+### Breaking Changes
+
+- both `KeyCode`-based logical keybindings and `ScanCode`-based physical keybindings are no longer supported;
+- please migrate to:
+  - `KeyCode` is now representing physical keybindings.
+  - `InputKind::KeyLocation` have been removed; please use `InputKind::PhysicalKey` instead.
+  - `ScanCode` and `QwertyScanCode` have been removed; please use `KeyCode` instead:
+    - all letter keys now follow the format `KeyCode::Key<Letter>`, e.g., `ScanCode::K` is now `KeyCode::KeyK`.
+    - all number keys over letters now follow the format `KeyCode::Digit<Number>`, e.g., `ScanCode::Key1` is now `KeyCode::Digit1`.
+    - all arrow keys now follow the format `KeyCode::Arrow<Direction>`, e.g., `ScanCode::Up` is now `KeyCode::ArrowUp`.
+
+### Usability
+
+- `bevy` dependency has been bumped from 0.12 to 0.13.
+- `bevy_egui` dependency has been bumped from 0.24 to 0.25.
+
 ## Version 0.12
 
 ### Enhancements

benches/input_map.rs

@@ -28,32 +28,32 @@ enum TestAction {
 
 fn construct_input_map_from_iter() -> InputMap<TestAction> {
     black_box(InputMap::new([
-        (TestAction::A, KeyCode::A),
-        (TestAction::B, KeyCode::B),
-        (TestAction::C, KeyCode::C),
-        (TestAction::D, KeyCode::D),
-        (TestAction::E, KeyCode::E),
-        (TestAction::F, KeyCode::F),
-        (TestAction::G, KeyCode::G),
-        (TestAction::H, KeyCode::H),
-        (TestAction::I, KeyCode::I),
-        (TestAction::J, KeyCode::J),
+        (TestAction::A, KeyCode::KeyA),
+        (TestAction::B, KeyCode::KeyB),
+        (TestAction::C, KeyCode::KeyC),
+        (TestAction::D, KeyCode::KeyD),
+        (TestAction::E, KeyCode::KeyE),
+        (TestAction::F, KeyCode::KeyF),
+        (TestAction::G, KeyCode::KeyG),
+        (TestAction::H, KeyCode::KeyH),
+        (TestAction::I, KeyCode::KeyI),
+        (TestAction::J, KeyCode::KeyJ),
     ]))
 }
 
 fn construct_input_map_from_chained_calls() -> InputMap<TestAction> {
     black_box(
         InputMap::default()
-            .insert(TestAction::A, KeyCode::A)
-            .insert(TestAction::B, KeyCode::B)
-            .insert(TestAction::C, KeyCode::C)
-            .insert(TestAction::D, KeyCode::D)
-            .insert(TestAction::E, KeyCode::E)
-            .insert(TestAction::F, KeyCode::F)
-            .insert(TestAction::G, KeyCode::G)
-            .insert(TestAction::H, KeyCode::H)
-            .insert(TestAction::I, KeyCode::I)
-            .insert(TestAction::J, KeyCode::J)
+            .insert(TestAction::A, KeyCode::KeyA)
+            .insert(TestAction::B, KeyCode::KeyB)
+            .insert(TestAction::C, KeyCode::KeyC)
+            .insert(TestAction::D, KeyCode::KeyD)
+            .insert(TestAction::E, KeyCode::KeyE)
+            .insert(TestAction::F, KeyCode::KeyF)
+            .insert(TestAction::G, KeyCode::KeyG)
+            .insert(TestAction::H, KeyCode::KeyH)
+            .insert(TestAction::I, KeyCode::KeyI)
+            .insert(TestAction::J, KeyCode::KeyJ)
             .build(),
     )
 }
@@ -78,8 +78,8 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     // Constructing our test app / input stream outside of the timed benchmark
     let mut app = App::new();
     app.add_plugins(InputPlugin);
-    app.send_input(KeyCode::A);
-    app.send_input(KeyCode::B);
+    app.send_input(KeyCode::KeyA);
+    app.send_input(KeyCode::KeyB);
     app.update();
 
     let input_streams = InputStreams::from_world(&app.world, None);

examples/action_state_resource.rs

@@ -30,7 +30,7 @@ impl PlayerAction {
     fn mkb_input_map() -> InputMap<PlayerAction> {
         use KeyCode::*;
         InputMap::new([
-            (Self::Jump, UserInput::Single(InputKind::Keyboard(Space))),
+            (Self::Jump, UserInput::Single(InputKind::PhysicalKey(Space))),
             (Self::Move, UserInput::VirtualDPad(VirtualDPad::wasd())),
         ])
     }

examples/arpg_indirection.rs

@@ -96,10 +96,10 @@ fn spawn_player(mut commands: Commands) {
     commands.spawn(PlayerBundle {
         player: Player,
         slot_input_map: InputMap::new([
-            (Slot::Ability1, Q),
-            (Slot::Ability2, W),
-            (Slot::Ability3, E),
-            (Slot::Ability4, R),
+            (Slot::Ability1, KeyQ),
+            (Slot::Ability2, KeyW),
+            (Slot::Ability3, KeyE),
+            (Slot::Ability4, KeyR),
         ])
         .insert(Slot::Primary, MouseButton::Left)
         .insert(Slot::Secondary, MouseButton::Right)

examples/clash_handling.rs

@@ -36,13 +36,13 @@ fn spawn_input_map(mut commands: Commands) {
     let mut input_map = InputMap::default();
 
     // Setting up input mappings in the obvious way
-    input_map.insert_multiple([(One, Key1), (Two, Key2), (Three, Key3)]);
+    input_map.insert_multiple([(One, Digit1), (Two, Digit2), (Three, Digit3)]);
 
-    input_map.insert_chord(OneAndTwo, [Key1, Key2]);
-    input_map.insert_chord(OneAndThree, [Key1, Key3]);
-    input_map.insert_chord(TwoAndThree, [Key2, Key3]);
+    input_map.insert_chord(OneAndTwo, [Digit1, Digit2]);
+    input_map.insert_chord(OneAndThree, [Digit1, Digit3]);
+    input_map.insert_chord(TwoAndThree, [Digit2, Digit3]);
 
-    input_map.insert_chord(OneAndTwoAndThree, [Key1, Key2, Key3]);
+    input_map.insert_chord(OneAndTwoAndThree, [Digit1, Digit2, Digit3]);
 
     commands.spawn(InputManagerBundle {
         input_map,

examples/consuming_actions.rs

@@ -13,8 +13,8 @@ fn main() {
         .init_resource::<ActionState<MenuAction>>()
         .insert_resource(InputMap::<MenuAction>::new([
             (MenuAction::CloseWindow, KeyCode::Escape),
-            (MenuAction::OpenMainMenu, KeyCode::M),
-            (MenuAction::OpenSubMenu, KeyCode::S),
+            (MenuAction::OpenMainMenu, KeyCode::KeyM),
+            (MenuAction::OpenSubMenu, KeyCode::KeyS),
         ]))
         .init_resource::<MainMenu>()
         .init_resource::<SubMenu>()

examples/default_controls.rs

@@ -32,7 +32,7 @@ impl PlayerAction {
         // Match against the provided action to get the correct default keyboard-mouse input
         match self {
             Self::Run => UserInput::VirtualDPad(VirtualDPad::wasd()),
-            Self::Jump => UserInput::Single(InputKind::Keyboard(KeyCode::Space)),
+            Self::Jump => UserInput::Single(InputKind::PhysicalKey(KeyCode::Space)),
             Self::UseItem => UserInput::Single(InputKind::Mouse(MouseButton::Left)),
         }
     }

examples/multiplayer.rs

@@ -32,9 +32,9 @@ impl PlayerBundle {
     fn input_map(player: Player) -> InputMap<Action> {
         let mut input_map = match player {
             Player::One => InputMap::new([
-                (Action::Left, KeyCode::A),
-                (Action::Right, KeyCode::D),
-                (Action::Jump, KeyCode::W),
+                (Action::Left, KeyCode::KeyA),
+                (Action::Right, KeyCode::KeyD),
+                (Action::Jump, KeyCode::KeyW),
             ])
             // This is a quick and hacky solution:
             // you should coordinate with the `Gamepads` resource to determine the correct gamepad for each player
@@ -44,9 +44,9 @@ impl PlayerBundle {
             .set_gamepad(Gamepad { id: 0 })
             .build(),
             Player::Two => InputMap::new([
-                (Action::Left, KeyCode::Left),
-                (Action::Right, KeyCode::Right),
-                (Action::Jump, KeyCode::Up),
+                (Action::Left, KeyCode::ArrowLeft),
+                (Action::Right, KeyCode::ArrowRight),
+                (Action::Jump, KeyCode::ArrowUp),
             ])
             .set_gamepad(Gamepad { id: 1 })
             .build(),

examples/press_duration.rs

@@ -47,10 +47,10 @@ impl PlayerBundle {
         use Action::*;
 
         InputMap::new([
-            (Left, KeyCode::A),
-            (Left, KeyCode::Left),
-            (Right, KeyCode::D),
-            (Right, KeyCode::Right),
+            (Left, KeyCode::KeyA),
+            (Left, KeyCode::ArrowLeft),
+            (Right, KeyCode::KeyD),
+            (Right, KeyCode::ArrowRight),
         ])
     }
 }

examples/register_gamepads.rs

@@ -32,7 +32,7 @@ fn join(
     mut commands: Commands,
     mut joined_players: ResMut<JoinedPlayers>,
     gamepads: Res<Gamepads>,
-    button_inputs: Res<Input<GamepadButton>>,
+    button_inputs: Res<ButtonInput<GamepadButton>>,
 ) {
     for gamepad in gamepads.iter() {
         // Join the game when both bumpers (L+R) on the controller are pressed

examples/send_actions_over_network.rs

@@ -127,7 +127,7 @@ fn spawn_player(mut commands: Commands) {
 
     commands
         .spawn(InputManagerBundle {
-            input_map: InputMap::new([(MoveLeft, W), (MoveRight, D), (Jump, Space)])
+            input_map: InputMap::new([(MoveLeft, KeyW), (MoveRight, KeyD), (Jump, Space)])
                 .insert(Shoot, MouseButton::Left)
                 .build(),
             ..default()