Merge pull request #55 from just-do-halee/main

Making easy to use some features

Author: CleanCut

CHANGELOG.md

@@ -1,6 +1,16 @@
 <!-- next-header -->
 ## [Unreleased] - ReleaseDate
 
+## Added
+
+- Added `KeyboardStateChain` and `MouseStateChain` to provide a functional interface for dealing with user input. Call `.chain()` on  `KeyboardState` or `MouseState` to access them. These new structs have methods with the same names as in their `Chain`-less variants which accept closures to perform the logic, and can be chained. Contributed by [@just-do-halee](https://github.com/just-do-halee) in [#55].
+
+## Improved
+
+- `CollisionPair` now implements `IntoIterator`, so you can do, for example: `for label in event.pair { ... }`. Contributed by [@just-do-halee](https://github.com/just-do-halee) in [#55].
+
+[#55]: https://github.com/CleanCut/rusty_engine/pull/55
+
 ## [5.1.1] - 2022-08-01
 
 ## Improved

examples/keyboard_state.rs

@@ -33,31 +33,35 @@ 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::A, KeyCode::Left]) {
+        race_car.translation.x -= move_amount;
     }
-    if ks.pressed_any(&[KeyCode::Plus, KeyCode::Equals]) {
-        race_car.scale *= 1.0 + scale_amount;
+    if ks.pressed_any(&[KeyCode::S, KeyCode::Down, KeyCode::O]) {
+        race_car.translation.y -= move_amount;
     }
-    if ks.pressed_any(&[KeyCode::Minus, KeyCode::Underline]) {
-        race_car.scale *= 1.0 - scale_amount;
+    if ks.pressed_any(&[KeyCode::D, KeyCode::Right, KeyCode::E]) {
+        race_car.translation.x += move_amount;
     }
 
+    // If you prefer a more functional style that is equivalent to the kind of logic above,
+    // but takes closures to run if the buttons are pressed, you can call `.chain()`
+    ks.chain()
+        .pressed_any(&[KeyCode::Z, KeyCode::Semicolon], |_| {
+            race_car.rotation += rotation_amount;
+        })
+        .pressed_any(&[KeyCode::C, KeyCode::J], |_| {
+            race_car.rotation -= rotation_amount;
+        })
+        .pressed_any(&[KeyCode::Plus, KeyCode::Equals], |_| {
+            race_car.scale *= 1.0 + scale_amount;
+        })
+        .pressed_any(&[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/car_shoot.rs

@@ -132,7 +132,8 @@ fn game_logic(engine: &mut Engine, game_state: &mut GameState) {
         if !event.pair.one_starts_with("marble") {
             continue;
         }
-        for label in [event.pair.0, event.pair.1] {
+
+        for label in event.pair {
             engine.sprites.remove(&label);
             if label.starts_with("marble") {
                 game_state.marble_labels.push(label);

src/keyboard.rs

@@ -30,6 +30,71 @@ fn sync_keyboard_events(
     }
 }
 
+pub struct KeyboardStateChain(KeyboardState);
+
+impl KeyboardStateChain {
+    /// Calls the closure if a key is currently pressed
+    #[inline]
+    pub fn pressed(&self, key: KeyCode, mut then: impl FnMut(&KeyboardState)) -> &Self {
+        if self.0.pressed(key) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the keys are currently pressed
+    #[inline]
+    pub fn pressed_any(
+        &self,
+        key_codes: &[KeyCode],
+        mut then: impl FnMut(&KeyboardState),
+    ) -> &Self {
+        if self.0.pressed_any(key_codes) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if a key started being pressed this frame
+    #[inline]
+    pub fn just_pressed(&self, key: KeyCode, mut then: impl FnMut(&KeyboardState)) -> &Self {
+        if self.0.just_pressed(key) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated keys started being pressed this frame
+    #[inline]
+    pub fn just_pressed_any(
+        &self,
+        key_codes: &[KeyCode],
+        mut then: impl FnMut(&KeyboardState),
+    ) -> &Self {
+        if self.0.just_pressed_any(key_codes) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if a key started being released this frame
+    #[inline]
+    pub fn just_released(&self, key: KeyCode, mut then: impl FnMut(&KeyboardState)) -> &Self {
+        if self.0.just_released(key) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated keys started being released this frame
+    #[inline]
+    pub fn just_released_any(
+        &self,
+        key_codes: &[KeyCode],
+        mut then: impl FnMut(&KeyboardState),
+    ) -> &Self {
+        if self.0.just_released_any(key_codes) {
+            then(&self.0);
+        }
+        self
+    }
+}
+
 /// Represents the end-state of all keys during the last frame. Access it through
 /// [`Engine.keyboard_state`](crate::prelude::Engine) in your game logic function.
 #[derive(Clone, Debug, Default)]
@@ -65,6 +130,9 @@ impl KeyboardState {
     pub fn just_released_any(&self, key_codes: &[KeyCode]) -> bool {
         key_codes.iter().any(|k| self.just_released(*k))
     }
+    pub fn chain(&self) -> KeyboardStateChain {
+        KeyboardStateChain(self.clone())
+    }
 }
 
 /// store bevy's keyboard state for our own use

src/mouse.rs

@@ -22,6 +22,79 @@ impl Plugin for MousePlugin {
     }
 }
 
+pub struct MouseStateChain(MouseState);
+
+impl MouseStateChain {
+    /// Calls the closure if the mouse button was pressed
+    #[inline]
+    pub fn pressed(&self, mouse_button: MouseButton, mut then: impl FnMut(&MouseState)) -> &Self {
+        if self.0.pressed(mouse_button) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated mouse buttons were pressed
+    #[inline]
+    pub fn pressed_any(
+        &self,
+        mouse_buttons: &[MouseButton],
+        mut then: impl FnMut(&MouseState),
+    ) -> &Self {
+        if self.0.pressed_any(mouse_buttons) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if the mouse button started being pressed during the last frame
+    #[inline]
+    pub fn just_pressed(
+        &self,
+        mouse_button: MouseButton,
+        mut then: impl FnMut(&MouseState),
+    ) -> &Self {
+        if self.0.just_pressed(mouse_button) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated mouse buttons were just pressed this frame
+    #[inline]
+    pub fn just_pressed_any(
+        &self,
+        mouse_buttons: &[MouseButton],
+        mut then: impl FnMut(&MouseState),
+    ) -> &Self {
+        if self.0.just_pressed_any(mouse_buttons) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if the mouse button started being released during the last frame
+    #[inline]
+    pub fn just_released(
+        &self,
+        mouse_button: MouseButton,
+        mut then: impl FnMut(&MouseState),
+    ) -> &Self {
+        if self.0.just_released(mouse_button) {
+            then(&self.0);
+        }
+        self
+    }
+    /// Calls the closure if any of the indicated mouse buttons were just released this frame
+    #[inline]
+    pub fn just_released_any(
+        &self,
+        mouse_buttons: &[MouseButton],
+        mut then: impl FnMut(&MouseState),
+    ) -> &Self {
+        if self.0.just_released_any(mouse_buttons) {
+            then(&self.0);
+        }
+        self
+    }
+}
+
 /// `MouseState` represents the end-state of the mouse during the last frame. This should be used
 /// for "real time" processing of most input (except mousewheel scrolling), where you only care
 /// about the final state of buttons or mouse position for your logic.
@@ -99,6 +172,9 @@ impl MouseState {
     pub fn just_released_any(&self, mouse_buttons: &[MouseButton]) -> bool {
         mouse_buttons.iter().any(|k| self.just_released(*k))
     }
+    pub fn chain(&self) -> MouseStateChain {
+        MouseStateChain(self.clone())
+    }
 }
 
 /// Gather the mouse events from bevy and store them for our own use

src/physics.rs

@@ -25,14 +25,14 @@ impl Plugin for PhysicsPlugin {
 /// [Sprite]s which:
 /// - have colliders (you can use the `collider` example to create your own colliders)
 /// - have their `collision` flags set to `true`.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CollisionEvent {
     pub state: CollisionState,
     pub pair: CollisionPair,
 }
 
 /// Indicates whether a [`CollisionEvent`] is at the beginning or ending of a collision.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum CollisionState {
     Begin,
     End,
@@ -83,6 +83,21 @@ impl CollisionPair {
         let b_matches = self.1.starts_with(&text);
         (a_matches && !b_matches) || (!a_matches && b_matches)
     }
+
+    pub fn array(&self) -> [&str; 2] {
+        [self.0.as_str(), self.1.as_str()]
+    }
+    pub fn array_mut(&mut self) -> [&mut String; 2] {
+        [&mut self.0, &mut self.1]
+    }
+}
+
+impl IntoIterator for CollisionPair {
+    type Item = String;
+    type IntoIter = std::array::IntoIter<Self::Item, 2>;
+    fn into_iter(self) -> Self::IntoIter {
+        [self.0, self.1].into_iter()
+    }
 }
 
 impl PartialEq for CollisionPair {

src/sprite.rs

@@ -190,7 +190,7 @@ use std::{
 };
 
 /// Sprite presets using the asset pack all have colliders
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum SpritePreset {
     RacingBarrelBlue,
     RacingBarrelRed,