revert most of the examples

Author: CleanCut

examples/keyboard_state.rs

@@ -33,32 +33,41 @@ 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;
-        });
+    // If you prefer a more functional style, there are also methods ending in `_do` that accept a
+    // closure to perform your logic with and are chainable, like this:
+    //
+    // 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;
+    // })
+    // ...etc
 
     // Clamp the scale to a certain range so the scaling is reasonable
     race_car.scale = race_car.scale.clamp(0.1, 3.0);

examples/mouse_state.rs

@@ -43,16 +43,12 @@ fn logic(engine: &mut Engine, _: &mut ()) {
     if let Some(sprite) = engine.sprites.get_mut("Race Car") {
         // Use the latest state of the mouse buttons to rotate the sprite
         let mut rotation_amount = 0.0;
-
-        engine
-            .mouse_state
-            .pressed_do(MouseButton::Left, |_| {
-                rotation_amount += ROTATION_SPEED * engine.delta_f32;
-            })
-            .pressed_do(MouseButton::Right, |_| {
-                rotation_amount -= ROTATION_SPEED * engine.delta_f32;
-            });
-
+        if engine.mouse_state.pressed(MouseButton::Left) {
+            rotation_amount += ROTATION_SPEED * engine.delta_f32;
+        }
+        if engine.mouse_state.pressed(MouseButton::Right) {
+            rotation_amount -= ROTATION_SPEED * engine.delta_f32;
+        }
         sprite.rotation += rotation_amount;
 
         // Use the latest state of the mouse wheel to scale the sprite

examples/scenarios/extreme_drivers_ed.rs

@@ -860,21 +860,19 @@ fn logic(engine: &mut Engine, game_state: &mut GameState) {
     {
         use KeyCode::*;
         // Acceleration input
-        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;
-            });
+        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;
+        }
     }
     let mut velocity_magnitude = game_state.velocity.length();
     velocity_magnitude += (acceleration * ACCELERATION_RATE) * engine.delta_f32;

examples/scenarios/road_race.rs

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