From 271659506955334129b2c8d9e51aa871f92e300c Mon Sep 17 00:00:00 2001
From: eri <eri@inventati.org>
Date: Wed, 13 Dec 2023 22:37:05 +0100
Subject: [PATCH] =?UTF-8?q?feat:=20input=20movement=20axis=20=F0=9F=8E=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/jump.rs |  27 ++++--
 src/data.rs      |  73 ++++++++-------
 src/input.rs     | 228 ++++++++++++++++++++++++++++++++++++++---------
 src/lib.rs       |   7 +-
 src/ui.rs        |   1 -
 src/ui/menu.rs   |  17 ++--
 6 files changed, 258 insertions(+), 95 deletions(-)

diff --git a/examples/jump.rs b/examples/jump.rs
index 966844c..33fe2aa 100644
--- a/examples/jump.rs
+++ b/examples/jump.rs
@@ -1,5 +1,7 @@
 #![allow(clippy::too_many_arguments)]
 
+use std::cmp::Ordering;
+
 use bevy::{
     prelude::*,
     sprite::MaterialMesh2dBundle,
@@ -10,8 +12,9 @@ use hello_bevy::{
     GameOptions,
     GamePlugin,
     GameState,
-    Keybind,
+    KeyBind,
     Keybinds,
+    Movement,
 };
 
 const SIZE: Vec2 = Vec2::new(600., 600.);
@@ -118,10 +121,11 @@ fn init_sample(
 
 fn update_sample(
     time: Res<Time>,
+    input: Res<Input<KeyBind>>,
+    movement: Res<Movement>,
+    keybinds: Res<Persistent<Keybinds>>,
     mut objects: Query<(&mut Player, &mut Transform)>,
     mut counter: Query<(&mut Text, &mut Counter)>,
-    input: Res<Input<Keybind>>,
-    keybinds: Res<Persistent<Keybinds>>,
 ) {
     for (mut player, mut trans) in objects.iter_mut() {
         let t = &mut trans.translation;
@@ -148,15 +152,20 @@ fn update_sample(
         }
 
         // Move
-        if keybinds.left.iter().any(|bind| input.pressed(*bind)) {
-            player.velocity.x = -MOVE_VEL;
-        } else if keybinds.right.iter().any(|bind| input.pressed(*bind)) {
-            player.velocity.x = MOVE_VEL;
-        } else if player.velocity.x.abs() > MOVE_CUTOFF {
+        let vel = keybinds
+            .x_axis
+            .iter()
+            .map(|bind| movement.get(*bind))
+            .sum::<f32>()
+            .clamp(-1., 1.);
+
+        player.velocity.x = vel * MOVE_VEL;
+
+        /*if player.velocity.x.abs() > MOVE_CUTOFF {
             player.velocity.x *= MOVE_FACTOR;
         } else {
             player.velocity.x = 0.;
-        }
+        }*/
 
         // Update position based on velocity and add bounds
         *t += player.velocity.extend(0.) * time.delta_seconds();
diff --git a/src/data.rs b/src/data.rs
index b14690a..83e8c94 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -8,7 +8,10 @@ use serde::{
 };
 
 use crate::{
-    input::Keybind,
+    input::{
+        KeyBind,
+        MoveBind,
+    },
     ui::{
         FONT_MULTIPLIERS,
         FONT_SIZES,
@@ -91,20 +94,25 @@ pub struct GameOptions {
 
 #[derive(Resource, Serialize, Deserialize, Reflect)]
 pub struct Keybinds {
-    pub up: Vec<Keybind>,
-    pub down: Vec<Keybind>,
-    pub left: Vec<Keybind>,
-    pub right: Vec<Keybind>,
-    pub jump: Vec<Keybind>,
-    pub interact: Vec<Keybind>,
-    pub inventory: Vec<Keybind>,
-    pub pause: Vec<Keybind>,
+    pub x_axis: Vec<MoveBind>,
+    pub y_axis: Vec<MoveBind>,
+    pub jump: Vec<KeyBind>,
+    pub interact: Vec<KeyBind>,
+    pub inventory: Vec<KeyBind>,
+    pub pause: Vec<KeyBind>,
 }
 
 impl Keybinds {
-    pub fn all(&self) -> Vec<&Keybind> {
+    pub fn keys(&self) -> Vec<&KeyBind> {
         self.iter_fields()
-            .filter_map(|f| f.downcast_ref::<Vec<Keybind>>())
+            .filter_map(|f| f.downcast_ref::<Vec<KeyBind>>())
+            .flatten()
+            .collect()
+    }
+
+    pub fn moves(&self) -> Vec<&MoveBind> {
+        self.iter_fields()
+            .filter_map(|f| f.downcast_ref::<Vec<MoveBind>>())
             .flatten()
             .collect()
     }
@@ -113,38 +121,32 @@ impl Keybinds {
 impl Default for Keybinds {
     fn default() -> Self {
         Self {
-            up: vec![
-                Keybind::Key(KeyCode::W),
-                Keybind::Gamepad(GamepadButtonType::DPadUp),
-            ],
-            down: vec![
-                Keybind::Key(KeyCode::S),
-                Keybind::Gamepad(GamepadButtonType::DPadDown),
+            x_axis: vec![
+                MoveBind::KeyAxis(KeyCode::D, KeyCode::A),
+                MoveBind::Gamepad(GamepadAxisType::LeftStickX),
+                // MoveBind::MouseAxis(MouseAxis::X),
             ],
-            left: vec![
-                Keybind::Key(KeyCode::A),
-                Keybind::Gamepad(GamepadButtonType::DPadLeft),
-            ],
-            right: vec![
-                Keybind::Key(KeyCode::D),
-                Keybind::Gamepad(GamepadButtonType::DPadRight),
+            y_axis: vec![
+                MoveBind::KeyAxis(KeyCode::W, KeyCode::S),
+                MoveBind::Gamepad(GamepadAxisType::LeftStickY),
+                // MoveBind::MouseAxis(MouseAxis::Y),
             ],
             jump: vec![
-                Keybind::Key(KeyCode::Space),
-                Keybind::Gamepad(GamepadButtonType::South),
+                KeyBind::Key(KeyCode::Space),
+                KeyBind::Gamepad(GamepadButtonType::South),
             ],
             interact: vec![
-                Keybind::Key(KeyCode::E),
-                Keybind::Mouse(MouseButton::Left),
-                Keybind::Gamepad(GamepadButtonType::East),
+                KeyBind::Key(KeyCode::E),
+                KeyBind::Mouse(MouseButton::Left),
+                KeyBind::Gamepad(GamepadButtonType::East),
             ],
             inventory: vec![
-                Keybind::Key(KeyCode::Tab),
-                Keybind::Gamepad(GamepadButtonType::West),
+                KeyBind::Key(KeyCode::Tab),
+                KeyBind::Gamepad(GamepadButtonType::West),
             ],
             pause: vec![
-                Keybind::Key(KeyCode::Escape),
-                Keybind::Gamepad(GamepadButtonType::Start),
+                KeyBind::Key(KeyCode::Escape),
+                KeyBind::Gamepad(GamepadButtonType::Start),
             ],
         }
     }
@@ -160,6 +162,9 @@ fn init_persistence(mut cmd: Commands) {
     #[cfg(target_arch = "wasm32")]
     let config_dir = Path::new("local");
 
+    // Append the package name to have unique configs (especially on web)
+    let config_dir = config_dir.join(env!("CARGO_PKG_NAME"));
+
     cmd.insert_resource(
         Persistent::<GameOptions>::builder()
             .name("options")
diff --git a/src/input.rs b/src/input.rs
index 4822769..cd1cf90 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -1,8 +1,16 @@
+use std::collections::HashMap;
+
 use bevy::{
     input::{
-        gamepad::GamepadButtonInput,
+        gamepad::{
+            GamepadAxisChangedEvent,
+            GamepadButtonInput,
+        },
         keyboard::KeyboardInput,
-        mouse::MouseButtonInput,
+        mouse::{
+            MouseButtonInput,
+            MouseMotion,
+        },
         ButtonState,
     },
     prelude::*,
@@ -15,8 +23,7 @@ use serde::{
 
 use crate::Keybinds;
 
-// TODO: Mouse movement and gamepad axis
-// TODO: Add touch
+// TODO: Add touch input
 
 // ······
 // Plugin
@@ -26,7 +33,8 @@ pub struct InputPlugin;
 
 impl Plugin for InputPlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(Input::<Keybind>::default())
+        app.insert_resource(Input::<KeyBind>::default())
+            .insert_resource(Movement::default())
             .add_systems(
                 PreUpdate,
                 (
@@ -44,82 +52,218 @@ impl Plugin for InputPlugin {
 // Resources
 // ·········
 
-#[derive(Resource, Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Reflect)]
-pub enum Keybind {
-    Key(KeyCode),
-    Mouse(MouseButton),
-    Gamepad(GamepadButtonType),
+#[derive(Resource)]
+pub struct Movement {
+    map: HashMap<MoveBind, f32>,
 }
 
-impl ToString for Keybind {
-    fn to_string(&self) -> String {
-        // TODO: Replace this with a key icon lookup
-        match self {
-            Keybind::Key(key) => format!("{:?}", key),
-            Keybind::Mouse(button) => format!("m{:?}", button),
-            Keybind::Gamepad(button) => format!("g{:?}", button).replace("DPad", ""),
+impl Default for Movement {
+    fn default() -> Self {
+        Self {
+            map: HashMap::new(),
         }
     }
 }
 
+impl Movement {
+    fn add(&mut self, bind: MoveBind, value: f32) {
+        if value.abs() < 0.1 {
+            self.map.remove(&bind);
+        } else {
+            self.map.insert(bind, value);
+        }
+    }
+
+    // Don't clear gamepad
+    pub fn clear(&mut self) {
+        self.map.retain(|bind, _| match bind {
+            MoveBind::Gamepad(_) => true,
+            _ => false,
+        });
+    }
+
+    pub fn get(&self, bind: MoveBind) -> f32 { self.map.get(&bind).copied().unwrap_or(0.) }
+}
+
 // ·······
 // Systems
 // ·······
 
 fn handle_input_keyboard(
-    mut input: ResMut<Input<Keybind>>,
+    mut input: ResMut<Input<KeyBind>>,
+    mut movement: ResMut<Movement>,
     keybinds: Res<Persistent<Keybinds>>,
     mut keyboard: EventReader<KeyboardInput>,
 ) {
     for event in keyboard.read() {
         let Some(event_key) = event.key_code else { continue };
 
-        if let Some(keybind) = keybinds.all().iter().find(|bind| match bind {
-            Keybind::Key(key) => key == &event_key,
-            _ => false,
-        }) {
-            match event.state {
-                ButtonState::Pressed => input.press(**keybind),
-                ButtonState::Released => input.release(**keybind),
+        for bind in keybinds.keys() {
+            match bind {
+                KeyBind::Key(key) => {
+                    if key != &event_key {
+                        continue;
+                    }
+                    match event.state {
+                        ButtonState::Pressed => input.press(*bind),
+                        ButtonState::Released => input.release(*bind),
+                    }
+                },
+                _ => (),
+            }
+        }
+
+        for bind in keybinds.moves() {
+            match bind {
+                MoveBind::KeyAxis(a, b) => {
+                    if a == &event_key {
+                        match event.state {
+                            ButtonState::Pressed => input.press(KeyBind::Key(*a)),
+                            ButtonState::Released => input.release(KeyBind::Key(*a)),
+                        }
+                    } else if b == &event_key {
+                        match event.state {
+                            ButtonState::Pressed => input.press(KeyBind::Key(*b)),
+                            ButtonState::Released => input.release(KeyBind::Key(*b)),
+                        }
+                    }
+                },
+                _ => (),
             }
         }
     }
+
+    for bind in keybinds.moves() {
+        match bind {
+            MoveBind::KeyAxis(a, b) => {
+                let mut value = 0.;
+                if input.pressed(KeyBind::Key(*a)) {
+                    value += 1.
+                } else if input.pressed(KeyBind::Key(*b)) {
+                    value -= 1.
+                };
+                movement.add(*bind, value);
+            },
+            _ => (),
+        }
+    }
 }
 
 fn handle_input_mouse(
-    mut input: ResMut<Input<Keybind>>,
+    mut input: ResMut<Input<KeyBind>>,
+    mut movement: ResMut<Movement>,
     keybinds: Res<Persistent<Keybinds>>,
     mut mouse: EventReader<MouseButtonInput>,
+    mut mouse_motion: EventReader<MouseMotion>,
 ) {
     for event in mouse.read() {
-        if let Some(keybind) = keybinds.all().iter().find(|bind| match bind {
-            Keybind::Mouse(button) => button == &event.button,
-            _ => false,
-        }) {
-            match event.state {
-                ButtonState::Pressed => input.press(**keybind),
-                ButtonState::Released => input.release(**keybind),
+        for bind in keybinds.keys() {
+            match bind {
+                KeyBind::Mouse(button) => {
+                    if button != &event.button {
+                        continue;
+                    }
+                    match event.state {
+                        ButtonState::Pressed => input.press(*bind),
+                        ButtonState::Released => input.release(*bind),
+                    }
+                },
+                _ => (),
+            }
+        }
+    }
+
+    for event in mouse_motion.read() {
+        for bind in keybinds.moves() {
+            match bind {
+                MoveBind::MouseAxis(axis) => {
+                    let value = match axis {
+                        MouseAxis::X => event.delta.x,
+                        MouseAxis::Y => event.delta.y,
+                    };
+                    movement.add(*bind, value);
+                },
+                _ => (),
             }
         }
     }
 }
 
 fn handle_input_gamepad(
-    mut input: ResMut<Input<Keybind>>,
+    mut input: ResMut<Input<KeyBind>>,
+    mut movement: ResMut<Movement>,
     keybinds: Res<Persistent<Keybinds>>,
     mut gamepad_buttons: EventReader<GamepadButtonInput>,
+    mut gamepad_axis: EventReader<GamepadAxisChangedEvent>,
 ) {
     for event in gamepad_buttons.read() {
-        if let Some(keybind) = keybinds.all().iter().find(|bind| match bind {
-            Keybind::Gamepad(button) => button == &event.button.button_type,
-            _ => false,
-        }) {
-            match event.state {
-                ButtonState::Pressed => input.press(**keybind),
-                ButtonState::Released => input.release(**keybind),
+        for bind in keybinds.keys() {
+            match bind {
+                KeyBind::Gamepad(button) => {
+                    if button != &event.button.button_type {
+                        continue;
+                    }
+                    match event.state {
+                        ButtonState::Pressed => input.press(*bind),
+                        ButtonState::Released => input.release(*bind),
+                    }
+                },
+                _ => (),
+            }
+        }
+    }
+
+    for event in gamepad_axis.read() {
+        for bind in keybinds.moves() {
+            match bind {
+                MoveBind::Gamepad(axis) => {
+                    if axis != &event.axis_type {
+                        continue;
+                    }
+                    movement.add(*bind, event.value);
+                },
+                _ => (),
             }
         }
     }
 }
 
-fn clear_input(mut input: ResMut<Input<Keybind>>) { input.clear(); }
+fn clear_input(mut input: ResMut<Input<KeyBind>>, mut movement: ResMut<Movement>) {
+    input.clear();
+    movement.clear();
+}
+
+// ·····
+// Extra
+// ·····
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Reflect)]
+pub enum KeyBind {
+    Key(KeyCode),
+    Mouse(MouseButton),
+    Gamepad(GamepadButtonType),
+}
+
+impl ToString for KeyBind {
+    fn to_string(&self) -> String {
+        // TODO: Replace this with a key icon lookup, maybe use the ones from kenney once released
+        match self {
+            KeyBind::Key(key) => format!("{:?}", key),
+            KeyBind::Mouse(button) => format!("m{:?}", button),
+            KeyBind::Gamepad(button) => format!("g{:?}", button).replace("DPad", ""),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Reflect)]
+pub enum MouseAxis {
+    X,
+    Y,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Reflect)]
+pub enum MoveBind {
+    KeyAxis(KeyCode, KeyCode),
+    MouseAxis(MouseAxis),
+    Gamepad(GamepadAxisType),
+}
diff --git a/src/lib.rs b/src/lib.rs
index 74a5953..6bf3735 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -22,7 +22,12 @@ pub use crate::{
         GameOptions,
         Keybinds,
     },
-    input::Keybind,
+    input::{
+        KeyBind,
+        MouseAxis,
+        MoveBind,
+        Movement
+    },
 };
 
 // TODO: Port improvements from the game jam
diff --git a/src/ui.rs b/src/ui.rs
index eb2d6ef..2d91ac8 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -68,7 +68,6 @@ struct UIStyle {
 #[derive(Component)]
 struct UiCam;
 
-// TODO: Make private, move every ui inside the ui module
 #[derive(Component)]
 struct UiNode;
 
diff --git a/src/ui/menu.rs b/src/ui/menu.rs
index 5497ee6..b64ad53 100644
--- a/src/ui/menu.rs
+++ b/src/ui/menu.rs
@@ -11,7 +11,7 @@ use crate::{
     ui::*,
     GameOptions,
     GameState,
-    Keybind,
+    KeyBind,
     Keybinds,
 };
 
@@ -264,11 +264,12 @@ fn exit_menu(
     node.despawn_descendants();
 }
 
+// TODO: Add movement keybinds
 fn return_to_menu(
     mut game_state: ResMut<NextState<GameState>>,
     current_menu_state: Res<State<MenuState>>,
     mut next_menu_state: ResMut<NextState<MenuState>>,
-    input: Res<Input<Keybind>>,
+    input: Res<Input<KeyBind>>,
     keybinds: Res<Persistent<Keybinds>>,
 ) {
     if keybinds.pause.iter().any(|bind| input.just_pressed(*bind)) {
@@ -293,11 +294,11 @@ fn remap_keybind(
     let mut bind = None;
 
     if let Some(key) = keyboard.get_pressed().next() {
-        bind = Some(Keybind::Key(*key));
+        bind = Some(KeyBind::Key(*key));
     } else if let Some(button) = mouse.get_pressed().find(|b| **b != MouseButton::Left) {
-        bind = Some(Keybind::Mouse(*button));
+        bind = Some(KeyBind::Mouse(*button));
     } else if let Some(button) = gamepad_buttons.get_pressed().next() {
-        bind = Some(Keybind::Gamepad(button.button_type));
+        bind = Some(KeyBind::Gamepad(button.button_type));
     }
 
     let Some(bind) = bind else { return };
@@ -312,13 +313,13 @@ fn remap_keybind(
             // Remove the keybind from all fields
             for i in 0..len {
                 let Some(field) = keybinds.field_at_mut(i) else { continue };
-                let Some(value) = field.downcast_mut::<Vec<Keybind>>() else { continue };
+                let Some(value) = field.downcast_mut::<Vec<KeyBind>>() else { continue };
                 value.retain(|b| b != &bind);
             }
 
             // Add the keybind to the field
             let Some(field) = keybinds.field_mut(&rebind_key.0) else { return };
-            let Some(value) = field.downcast_mut::<Vec<Keybind>>() else { return };
+            let Some(value) = field.downcast_mut::<Vec<KeyBind>>() else { return };
             value.push(bind);
         })
         .unwrap_or_else(|e| error!("Failed to remap keybind: {}", e));
@@ -374,7 +375,7 @@ fn layout_keybinds(mut cmd: Commands, node: Entity, style: &UIStyle, keybinds: &
         // TODO: Scrollable section (Requires #8104 to be merged in 0.13)
         for (i, value) in keybinds.iter_fields().enumerate() {
             let field_name = keybinds.name_at(i).unwrap();
-            let Some(value) = value.downcast_ref::<Vec<Keybind>>() else { continue };
+            let Some(value) = value.downcast_ref::<Vec<KeyBind>>() else { continue };
 
             UIOption::new(style, field_name).add(parent, |row| {
                 let keys = value