easy to use KeyboardState chaining function caller

Author: just-do-halee

examples/keyboard_state.rs

@@ -33,30 +33,32 @@ fn logic(game_state: &mut Engine, _: &mut ()) {
 
     // Handle keyboard input
     let ks = &mut game_state.keyboard_state;
-    if ks.pressed_any(&[KeyCode::A, KeyCode::Left]) {
-        race_car.translation.x -= move_amount;
-    }
-    if ks.pressed_any(&[KeyCode::D, KeyCode::Right, KeyCode::E]) {
-        race_car.translation.x += move_amount;
-    }
-    if ks.pressed_any(&[KeyCode::O, KeyCode::Down, KeyCode::S]) {
-        race_car.translation.y -= move_amount;
-    }
-    if ks.pressed_any(&[KeyCode::W, KeyCode::Up, KeyCode::Comma]) {
-        race_car.translation.y += move_amount;
-    }
-    if ks.pressed_any(&[KeyCode::Z, KeyCode::Semicolon]) {
-        race_car.rotation += rotation_amount;
-    }
-    if ks.pressed_any(&[KeyCode::C, KeyCode::J]) {
-        race_car.rotation -= rotation_amount;
-    }
-    if ks.pressed_any(&[KeyCode::Plus, KeyCode::Equals]) {
-        race_car.scale *= 1.0 + scale_amount;
-    }
-    if ks.pressed_any(&[KeyCode::Minus, KeyCode::Underline]) {
-        race_car.scale *= 1.0 - scale_amount;
-    }
+
+    ks //
+        .pressed_any_do(&[KeyCode::A, KeyCode::Left], || {
+            race_car.translation.x -= move_amount;
+        })
+        .pressed_any_do(&[KeyCode::D, KeyCode::Right, KeyCode::E], || {
+            race_car.translation.x += move_amount;
+        })
+        .pressed_any_do(&[KeyCode::O, KeyCode::Down, KeyCode::S], || {
+            race_car.translation.y -= move_amount;
+        })
+        .pressed_any_do(&[KeyCode::W, KeyCode::Up, KeyCode::Comma], || {
+            race_car.translation.y += move_amount;
+        })
+        .pressed_any_do(&[KeyCode::Z, KeyCode::Semicolon], || {
+            race_car.rotation += rotation_amount;
+        })
+        .pressed_any_do(&[KeyCode::C, KeyCode::J], || {
+            race_car.rotation -= rotation_amount;
+        })
+        .pressed_any_do(&[KeyCode::Plus, KeyCode::Equals], || {
+            race_car.scale *= 1.0 + scale_amount;
+        })
+        .pressed_any_do(&[KeyCode::Minus, KeyCode::Underline], || {
+            race_car.scale *= 1.0 - scale_amount;
+        });
 
     // Clamp the scale to a certain range so the scaling is reasonable
     race_car.scale = race_car.scale.clamp(0.1, 3.0);

examples/scenarios/extreme_drivers_ed.rs

@@ -860,19 +860,21 @@ fn logic(engine: &mut Engine, game_state: &mut GameState) {
     {
         use KeyCode::*;
         // Acceleration input
-        if engine.keyboard_state.pressed_any(&[W, Up, Comma]) {
-            acceleration += 1.0;
-        }
-        if engine.keyboard_state.pressed_any(&[S, Down, O]) {
-            acceleration -= 1.0;
-        }
-        // Rotation/Turning input
-        if engine.keyboard_state.pressed_any(&[A, Left]) {
-            rotation += 1.0;
-        }
-        if engine.keyboard_state.pressed_any(&[D, Right, E]) {
-            rotation -= 1.0;
-        }
+        engine
+            .keyboard_state
+            .pressed_any_do(&[W, Up, Comma], || {
+                acceleration += 1.0;
+            })
+            .pressed_any_do(&[S, Down, O], || {
+                acceleration -= 1.0;
+            })
+            // Rotation/Turning input
+            .pressed_any_do(&[A, Left], || {
+                rotation += 1.0;
+            })
+            .pressed_any_do(&[D, Right, E], || {
+                rotation -= 1.0;
+            });
     }
     let mut velocity_magnitude = game_state.velocity.length();
     velocity_magnitude += (acceleration * ACCELERATION_RATE) * engine.delta_f32;

examples/scenarios/road_race.rs

@@ -72,18 +72,14 @@ fn game_logic(engine: &mut Engine, game_state: &mut GameState) {
 
     // Collect keyboard input
     let mut direction = 0.0;
-    if engine
+    engine
         .keyboard_state
-        .pressed_any(&[KeyCode::Up, KeyCode::W, KeyCode::Comma])
-    {
-        direction += 1.0;
-    }
-    if engine
-        .keyboard_state
-        .pressed_any(&[KeyCode::Down, KeyCode::S, KeyCode::O])
-    {
-        direction -= 1.0;
-    }
+        .pressed_any_do(&[KeyCode::Up, KeyCode::W, KeyCode::Comma], || {
+            direction += 1.0;
+        })
+        .pressed_any_do(&[KeyCode::Down, KeyCode::S, KeyCode::O], || {
+            direction -= 1.0;
+        });
 
     // Move the player sprite
     let player1 = engine.sprites.get_mut("player1").unwrap();

src/keyboard.rs

@@ -65,6 +65,55 @@ impl KeyboardState {
     pub fn just_released_any(&self, key_codes: &[KeyCode]) -> bool {
         key_codes.iter().any(|k| self.just_released(*k))
     }
+    // -----------------------------------
+    /// Calls the closure if a key is currently pressed
+    #[inline]
+    pub fn pressed_do(&self, key: KeyCode, mut f: impl FnMut()) -> &Self {
+        if self.pressed(key) {
+            f();
+        }
+        self
+    }
+    /// Calls the closure if any of the keys are currently pressed
+    #[inline]
+    pub fn pressed_any_do(&self, key_codes: &[KeyCode], mut f: impl FnMut()) -> &Self {
+        if self.pressed_any(key_codes) {
+            f();
+        }
+        self
+    }
+    /// Calls the closure if a key started being pressed this frame
+    #[inline]
+    pub fn just_pressed_do(&self, key: KeyCode, mut f: impl FnMut()) -> &Self {
+        if self.just_pressed(key) {
+            f();
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated keys started being pressed this frame
+    #[inline]
+    pub fn just_pressed_any_do(&self, key_codes: &[KeyCode], mut f: impl FnMut()) -> &Self {
+        if self.just_pressed_any(key_codes) {
+            f();
+        }
+        self
+    }
+    /// Calls the closure if a key started being released this frame
+    #[inline]
+    pub fn just_released_do(&self, key: KeyCode, mut f: impl FnMut()) -> &Self {
+        if self.just_released(key) {
+            f();
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated keys started being released this frame
+    #[inline]
+    pub fn just_released_any_do(&self, key_codes: &[KeyCode], mut f: impl FnMut()) -> &Self {
+        if self.just_released_any(key_codes) {
+            f();
+        }
+        self
+    }
 }
 
 /// store bevy's keyboard state for our own use