Merge pull request #37 from CleanCut/engine

Rename EngineState -> Engine and engine_state -> engine

Author: CleanCut

CHANGELOG.md

@@ -4,6 +4,7 @@
 ### BREAKING CHANGES
 
 - Logic functions no longer return a `bool` to simplify the learning curve. If you want logic functions to run conditionally, instead track your state in your `GameState` and use it to exit early from your logic function.
+- The `EngineState` struct and `engine_state` variables have been renamed to `Engine` and `engine`, respectively, for brevity.
 
 ## [4.0.0] - 2022-01-29
 

README.md

@@ -73,7 +73,7 @@ Write your game!
  fn main() {
      // Create a game
      let mut game = Game::new();
-     // Set up your game. `Game` exposes all of the methods (but not fields) of `EngineState` as well.
+     // Set up your game. `Game` exposes all of the methods (but not fields) of `Engine` as well.
      let sprite = game.add_sprite("player", SpritePreset::RacingCarBlue);
      sprite.scale = 2.0;
      game.audio_manager.play_music(MusicPreset::Classy8Bit, 1.0);
@@ -86,16 +86,16 @@ Write your game!
  }
 
  // Your game logic functions can be named anything, but the first parameter is always a
- // `&mut EngineState`, and the second parameter is a mutable reference to your custom game
+ // `&mut Engine`, and the second parameter is a mutable reference to your custom game
  // state struct (`&mut GameState` in this case). The function returns a `bool`.
  //
  // This function will be run once each frame.
- fn game_logic(engine_state: &mut EngineState, game_state: &mut GameState) {
-     // The `EngineState` contains all sorts of built-in goodies.
+ fn game_logic(engine: &mut Engine, game_state: &mut GameState) {
+     // The `Engine` contains all sorts of built-in goodies.
      // Get access to the player sprite...
-     let player = engine_state.sprites.get_mut("player").unwrap();
+     let player = engine.sprites.get_mut("player").unwrap();
      // Rotate the player...
-     player.rotation += std::f32::consts::PI * engine_state.delta_f32;
+     player.rotation += std::f32::consts::PI * engine.delta_f32;
      // Damage the player if it is out of bounds...
      if player.translation.x > 100.0 {
          game_state.health -= 1;

examples/collider.rs

@@ -82,51 +82,51 @@ fn main() {
     game.run(Default::default());
 }
 
-fn game_logic(engine_state: &mut EngineState, game_state: &mut GameState) {
-    let sprite = engine_state.sprites.get_mut("sprite").unwrap();
+fn game_logic(engine: &mut Engine, game_state: &mut GameState) {
+    let sprite = engine.sprites.get_mut("sprite").unwrap();
     // Zoom levels
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key1) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key1) {
         sprite.scale = 1.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key2) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key2) {
         sprite.scale = 2.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key3) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key3) {
         sprite.scale = 3.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key4) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key4) {
         sprite.scale = 4.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key5) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key5) {
         sprite.scale = 5.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key6) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key6) {
         sprite.scale = 6.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key7) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key7) {
         sprite.scale = 7.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key8) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key8) {
         sprite.scale = 8.0;
     }
-    if engine_state.keyboard_state.just_pressed(KeyCode::Key9) {
+    if engine.keyboard_state.just_pressed(KeyCode::Key9) {
         sprite.scale = 9.0;
     }
     // Rotate
-    if engine_state.mouse_state.pressed(MouseButton::Right) {
-        sprite.rotation += engine_state.delta_f32 * 6.0;
+    if engine.mouse_state.pressed(MouseButton::Right) {
+        sprite.rotation += engine.delta_f32 * 6.0;
     }
     // Delete collider
-    if engine_state.keyboard_state.just_pressed(KeyCode::Delete)
-        || engine_state.keyboard_state.just_pressed(KeyCode::Back)
+    if engine.keyboard_state.just_pressed(KeyCode::Delete)
+        || engine.keyboard_state.just_pressed(KeyCode::Back)
     {
         sprite.collider = Collider::NoCollider;
         sprite.collider_dirty = true;
     }
     // Modify a collider point
-    if engine_state.mouse_state.just_pressed(MouseButton::Left) {
-        if let Some(location) = engine_state.mouse_state.location() {
-            if engine_state
+    if engine.mouse_state.just_pressed(MouseButton::Left) {
+        if let Some(location) = engine.mouse_state.location() {
+            if engine
                 .keyboard_state
                 .pressed_any(&[KeyCode::RShift, KeyCode::LShift])
             {
@@ -137,20 +137,19 @@ fn game_logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         }
     }
     // Generate a circle collider
-    if engine_state.keyboard_state.just_pressed_any(&[
-        KeyCode::Plus,
-        KeyCode::Equals,
-        KeyCode::NumpadAdd,
-    ]) {
+    if engine
+        .keyboard_state
+        .just_pressed_any(&[KeyCode::Plus, KeyCode::Equals, KeyCode::NumpadAdd])
+    {
         game_state.circle_radius += 0.5;
     }
-    if engine_state
+    if engine
         .keyboard_state
         .just_pressed_any(&[KeyCode::Minus, KeyCode::NumpadSubtract])
     {
         game_state.circle_radius -= 0.5;
     }
-    if engine_state.keyboard_state.just_pressed_any(&[
+    if engine.keyboard_state.just_pressed_any(&[
         KeyCode::Plus,
         KeyCode::Equals,
         KeyCode::NumpadAdd,
@@ -161,7 +160,7 @@ fn game_logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         sprite.collider = Collider::circle(game_state.circle_radius);
     }
     // Let the user know whether or not their collider is currently convex
-    let convex = engine_state.texts.get_mut("convex").unwrap();
+    let convex = engine.texts.get_mut("convex").unwrap();
     const CONVEX_MESSAGE: &str = "Convex!";
     const NOT_CONVEX_MESSAGE: &str = "Not a convex polygon. :-(";
     if sprite.collider.is_convex() {
@@ -174,7 +173,7 @@ fn game_logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         }
     }
     // Write the collider file
-    if engine_state.keyboard_state.just_pressed(KeyCode::W) {
+    if engine.keyboard_state.just_pressed(KeyCode::W) {
         if sprite.write_collider() {
             println!(
                 "Successfully wrote the new collider file: {}",

examples/collision.rs

@@ -41,47 +41,47 @@ fn main() {
     game.run(());
 }
 
-fn logic(engine_state: &mut EngineState, _: &mut ()) {
+fn logic(engine: &mut Engine, _: &mut ()) {
     // If a collision event happened last frame, print it out and play a sound
-    for collision_event in engine_state.collision_events.drain(..) {
-        let text = engine_state.texts.get_mut("collision text").unwrap();
+    for collision_event in engine.collision_events.drain(..) {
+        let text = engine.texts.get_mut("collision text").unwrap();
         match collision_event.state {
             CollisionState::Begin => {
                 text.value = format!("{:?}", collision_event.pair);
-                engine_state.audio_manager.play_sfx(SfxPreset::Switch1, 1.0)
+                engine.audio_manager.play_sfx(SfxPreset::Switch1, 1.0)
             }
             CollisionState::End => {
                 text.value = "".into();
-                engine_state.audio_manager.play_sfx(SfxPreset::Switch2, 1.0)
+                engine.audio_manager.play_sfx(SfxPreset::Switch2, 1.0)
             }
         }
     }
 
-    if let Some(sprite) = engine_state.sprites.get_mut("Player") {
+    if let Some(sprite) = engine.sprites.get_mut("Player") {
         // Use the latest state of the mouse buttons to rotate the sprite
         let mut rotation_amount = 0.0;
-        if engine_state.mouse_state.pressed(MouseButton::Left) {
-            rotation_amount += ROTATION_SPEED * engine_state.delta_f32;
+        if engine.mouse_state.pressed(MouseButton::Left) {
+            rotation_amount += ROTATION_SPEED * engine.delta_f32;
         }
-        if engine_state.mouse_state.pressed(MouseButton::Right) {
-            rotation_amount -= ROTATION_SPEED * engine_state.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
-        if let Some(location) = engine_state.mouse_state.location() {
+        if let Some(location) = engine.mouse_state.location() {
             sprite.translation = location
         }
 
         // Mousewheel scales the car
-        for mouse_wheel in &engine_state.mouse_wheel_events {
+        for mouse_wheel in &engine.mouse_wheel_events {
             sprite.scale *= 1.0 + (0.05 * mouse_wheel.y);
             sprite.scale = sprite.scale.clamp(0.1, 4.0);
         }
     }
 
     // Pressing C toggles sprite collider debug lines
-    if engine_state.keyboard_state.just_pressed(KeyCode::C) {
-        engine_state.show_colliders = !engine_state.show_colliders;
+    if engine.keyboard_state.just_pressed(KeyCode::C) {
+        engine.show_colliders = !engine.show_colliders;
     }
 }

examples/game_state.rs

@@ -28,23 +28,18 @@ fn main() {
     game.run(initial_game_state);
 }
 
-fn logic(engine_state: &mut EngineState, game_state: &mut MyCustomGameStateStuff) {
+fn logic(engine: &mut Engine, game_state: &mut MyCustomGameStateStuff) {
     // Get mutable references to the variables in the game state that we care about
-    let race_car = engine_state.sprites.get_mut("Race Car").unwrap();
+    let race_car = engine.sprites.get_mut("Race Car").unwrap();
 
     // If we aren't turning, then tick the timer until it's time to start turning again
-    if !game_state.turning
-        && game_state
-            .change_timer
-            .tick(engine_state.delta)
-            .just_finished()
-    {
+    if !game_state.turning && game_state.change_timer.tick(engine.delta).just_finished() {
         game_state.turning = true;
     }
 
     // Rotate the player
     if game_state.turning {
-        race_car.rotation += engine_state.delta_f32 * 3.0;
+        race_car.rotation += engine.delta_f32 * 3.0;
         // If the player rotated all the way around, reset direction, stop turning
         // TAU == (2 * PI), which is exactly one rotation in radians
         if race_car.rotation > TAU {

examples/keyboard_events.rs

@@ -20,7 +20,7 @@ fn main() {
     game.run(());
 }
 
-fn logic(game_state: &mut EngineState, _: &mut ()) {
+fn logic(game_state: &mut Engine, _: &mut ()) {
     // Get the race car sprite
     let race_car = game_state.sprites.get_mut("Race Car").unwrap();
 

examples/keyboard_state.rs

@@ -22,7 +22,7 @@ fn main() {
     game.run(());
 }
 
-fn logic(game_state: &mut EngineState, _: &mut ()) {
+fn logic(game_state: &mut Engine, _: &mut ()) {
     // Compute how fast we should move, rotate, and scale
     let move_amount = 200.0 * game_state.delta_f32;
     let rotation_amount = PI * game_state.delta_f32;

examples/level_creator.rs

@@ -66,15 +66,15 @@ Z - Print out Rust code of current level
     game.run(game_state);
 }
 
-fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
+fn logic(engine: &mut Engine, game_state: &mut GameState) {
     // Gather keyboard input
     let mut reset = false;
     let mut print_level = false;
     let mut print_status = false;
     let mut place_sprite = false;
     let mut prev_preset = false;
     let mut next_preset = false;
-    for keyboard_event in &engine_state.keyboard_events {
+    for keyboard_event in &engine.keyboard_events {
         if let KeyboardInput {
             scan_code: _,
             key_code: Some(key_code),
@@ -122,7 +122,7 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         println!(
             "---------------\n\nuse rusty_engine::prelude::*;\n\nstruct GameState {{}}\n\nfn main() {{\n    let mut game = Game::new();\n"
         );
-        for sprite in engine_state.sprites.values() {
+        for sprite in engine.sprites.values() {
             if sprite.label == game_state.current_label {
                 continue;
             }
@@ -137,11 +137,11 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
                 sprite.layer,
             );
         }
-        println!("\n    game.add_logic(logic);\n    game.run(GameState {{}});\n}}\n\nfn logic(engine_state: &mut EngineState, game_state: &mut GameState) {{\n    // Game Logic Goes Here\n}}")
+        println!("\n    game.add_logic(logic);\n    game.run(GameState {{}});\n}}\n\nfn logic(engine: &mut Engine, game_state: &mut GameState) {{\n    // Game Logic Goes Here\n}}")
     }
 
     // Handle current sprite that has not yet been placed
-    if let Some(sprite) = engine_state.sprites.get_mut(&game_state.current_label) {
+    if let Some(sprite) = engine.sprites.get_mut(&game_state.current_label) {
         // Should we print out the status of the sprite?
         if print_status {
             println!(
@@ -160,11 +160,11 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         }
 
         // Handle translation via mouse location
-        for cursor_moved in &engine_state.mouse_location_events {
+        for cursor_moved in &engine.mouse_location_events {
             sprite.translation = cursor_moved.position;
         }
         // Handle rotation via mouse clicks
-        for mouse_button_input in &engine_state.mouse_button_events {
+        for mouse_button_input in &engine.mouse_button_events {
             if mouse_button_input.state != ElementState::Pressed {
                 break;
             }
@@ -181,7 +181,7 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
             println!("r: {:.8}", sprite.rotation);
         }
         // Handle scale via mousewheel
-        for mouse_wheel in &engine_state.mouse_wheel_events {
+        for mouse_wheel in &engine.mouse_wheel_events {
             let scale_amount = if game_state.shift_pressed { 0.01 } else { 0.1 };
             if mouse_wheel.y > 0.0 || mouse_wheel.x < 0.0 {
                 sprite.scale *= 1.0 + scale_amount;
@@ -196,7 +196,7 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
     // Change sprite to prev/next preset
     if prev_preset || next_preset {
         let old_sprite = {
-            engine_state
+            engine
                 .sprites
                 .get_mut(&game_state.current_label)
                 .unwrap()
@@ -226,19 +226,15 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         new_sprite.translation = old_sprite.translation;
         new_sprite.rotation = old_sprite.rotation;
         new_sprite.scale = old_sprite.scale;
-        engine_state
-            .sprites
-            .insert(new_sprite.label.clone(), new_sprite);
-        engine_state
-            .sprites
-            .remove::<str>(old_sprite.label.as_ref());
+        engine.sprites.insert(new_sprite.label.clone(), new_sprite);
+        engine.sprites.remove::<str>(old_sprite.label.as_ref());
         println!("{:?}", new_preset);
     }
 
     // Place an sprite
     if place_sprite {
         let mut sprite = {
-            engine_state
+            engine
                 .sprites
                 .get_mut(&game_state.current_label)
                 .unwrap()
@@ -248,6 +244,6 @@ fn logic(engine_state: &mut EngineState, game_state: &mut GameState) {
         game_state.next_layer += 0.01;
         sprite.label = game_state.next_sprite_num.to_string();
         game_state.next_sprite_num += 1;
-        engine_state.sprites.insert(sprite.label.clone(), sprite);
+        engine.sprites.insert(sprite.label.clone(), sprite);
     }
 }