update changelog and tutorial for the Bevy 0.10 upgrade

Author: CleanCut

CHANGELOG.md

@@ -1,6 +1,21 @@
 <!-- next-header -->
 ## [Unreleased] - ReleaseDate
 
+### Breaking changes
+
+- `WindowDescriptor` has been renamed to `Window`
+- You must new add `#[derive(Resource)]` above your `GameState` struct.
+- It is no longer possible to use the unit type `()` instead of a `GameState` struct. Always create a `GameState` struct (it can be an empty struct with no fields).
+- The `Timer` now takes a `TimerMode` enum variant instead of a `bool`. Use `TimerMode::Once` for a timer that runs once, or `TimerMode::Repeating` for a repeating timer.
+
+### Improved
+
+- Update bevy from 0.8 to 0.10
+- Update bevy_prototype_lyon from 0.6 to 0.8
+- Update ron from 0.7 to 0.8
+- Fixed some inconsistent parameter names in examples
+
+
 ## [5.2.1] - 2022-11-15
 
 ### Improved

examples/mouse_state.rs

@@ -13,7 +13,7 @@ struct GameState {}
 fn main() {
     let mut game = Game::new();
 
-    let race_car = game.add_sprite("Race Car", SpritePreset::RacingCarGreen);
+    let race_car = game.add_sprite("Race Car", "sprite/racing/car_blue.png");
     race_car.translation = Vec2::new(0.0, 0.0);
     race_car.rotation = UP;
     race_car.scale = 1.0;

examples/window.rs

@@ -19,7 +19,7 @@ fn main() {
         resizable: false,
         decorations: false,
         cursor,
-        ..Default::default() // for the rest of the options, see https://docs.rs/bevy/0.11.3/bevy/window/struct.Window.html
+        ..Default::default() // for the rest of the options, see https://docs.rs/bevy/0.10.1/bevy/index.html
     });
     let _ = game.add_text(
         "message",

src/lib.rs

@@ -79,6 +79,7 @@ pub mod prelude {
         DOWN, EAST, LEFT, NORTH, NORTH_EAST, NORTH_WEST, RIGHT, SOUTH, SOUTH_EAST, SOUTH_WEST, UP,
         WEST,
     };
+    pub use bevy::ecs as bevy_ecs;
     pub use bevy::{
         self,
         prelude::{Resource, Time, Timer, TimerMode, Vec2},

tutorial/src/00-welcome.md

@@ -2,10 +2,10 @@
 
 Rusty Engine is a simple, 2D game engine for those who are learning Rust. Create simple game prototypes using straightforward Rust code without needing to learning difficult game engine concepts! It works on macOS, Linux, and Windows. Rusty Engine is a simplification wrapper over [Bevy](https://bevyengine.org/), which I encourage you to use directly for more serious game engine needs.
 
-The following courses use Rusty Engine in their curriculum:
+The following courses currently use Rusty Engine in their curriculum:
+
+- [Ultimate Rust 2: Intermediate Concepts](https://agileperception.com/ultimate_rust_2) (the sequel to [Ultimate Rust Crash Course](https://agileperception.com/ultimate_rust_crash_course))
 
-- [Ultimate Rust 2: Intermediate Concepts](https://www.udemy.com/course/ultimate-rust-2/?referralCode=8ED694EBE5637F954414) on Udemy (the sequel to [Ultimate Rust Crash Course](https://www.udemy.com/course/ultimate-rust-crash-course/?referralCode=AF30FAD8C6CCCC2C94F0))
-- [Rust in 3 Weeks](https://agileperception.com) conducted live on O'Reilly Online approximately once each quarter.
 
 # Tutorial
 

tutorial/src/02-quick-start.md

@@ -1,6 +1,6 @@
 # Quick Start Example
 
-- Create a new Rust project and add `rusty_engine` as a dependency (see the [Configuration](05-config.md) page for more details)
+- Create a new Rust project and run `cargo add rusty_engine` to add Rusty Engine as a dependency (see the [Configuration](05-config.md) page for more details). Your `Cargo.toml` file should end up with a line similar to this:
 ```toml
 # In your [dependencies] section of Cargo.toml
 rusty_engine = "5.2.1"
@@ -13,48 +13,44 @@ curl -L https://github.com/CleanCut/rusty_engine/archive/refs/heads/main.tar.gz
 
 ```rust,ignore
 // in src/main.rs
- use rusty_engine::prelude::*;
-
- // Define a struct to hold custom data for your game (it can be a lot more complicated than this one!)
- struct GameState {
-     health: i32,
- }
-
- fn main() {
-     // Create a game
-     let mut game = Game::new();
-
-     // Set up your game. `Game` exposes all of the methods and fields of `Engine`
-     let sprite = game.add_sprite("player", SpritePreset::RacingCarBlue);
-     sprite.scale = 2.0;
-
-     game.audio_manager.play_music(MusicPreset::Classy8Bit, 1.0);
-
-     // Add one or more functions with logic for your game. When the game is run, the logic
-     // functions will run in the order they were added.
-     game.add_logic(game_logic);
-
-     // Run the game, with an initial state
-     game.run(GameState { health: 100 });
- }
-
- // Your game logic functions can be named anything, but the first parameter is always a
- // `&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: &mut Engine, game_state: &mut GameState) {
-     // The `Engine` contains all sorts of built-in goodies.
-     // Get access to the player sprite...
-     let player = engine.sprites.get_mut("player").unwrap();
-     // Rotate the player...
-     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;
-     }
- }
- ```
+use rusty_engine::prelude::*;
+// Define a struct to hold custom data for your game. If you don't yet know what data fields you
+// need, it can be an empty struct. It must have `#[derive(Resource)]` on the line before it.
+#[derive(Resource)]
+struct GameState {
+    health: i32, // add any fields you want, or leave the struct without fields
+}
+fn main() {
+    // Create a game
+    let mut game = Game::new();
+    // Set up your game. `Game` exposes all of the methods and fields of `Engine`
+    let sprite = game.add_sprite("player", SpritePreset::RacingCarBlue);
+    sprite.scale = 2.0;
+    // Start some music!
+    game.audio_manager.play_music(MusicPreset::Classy8Bit, 1.0);
+    // Add one or more functions with logic for your game. When the game is run, the logic
+    // functions will run in the order they were added.
+    game.add_logic(game_logic);
+    // Run the game, with an initial state
+    game.run(GameState { health: 100 });
+}
+// Your game logic functions can be named anything, but the first parameter is always a
+// `&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: &mut Engine, game_state: &mut GameState) {
+    // The `Engine` contains all sorts of built-in goodies.
+    // Get access to the player sprite...
+    let player = engine.sprites.get_mut("player").unwrap();
+    // Rotate the player...
+    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;
+    }
+}
+```
 
 - Run your game with `cargo run --release`.  Don't forget the `--release`!
 

tutorial/src/05-config.md

@@ -1,7 +1,7 @@
 # Configuration
 
 - Create a new Rust project
-- In your `Cargo.toml` file, add `rusty_engine` to your `[dependencies]` section:
+- Do `cargo add rusty_engine` to add the latest version of Rusty Engine to the `[dependencies]` section of your `Cargo.toml`. It should add a line that looks something like this:
 
 ```toml
 # In your [dependencies] section of Cargo.toml

tutorial/src/10-assets.md

@@ -3,7 +3,7 @@
 Rusty Engine assumes the asset pack is present, so you MUST download the asset pack.
 
 Here are three different ways to download the assets (pick any of them--it should end up the same in the end):
-- RECOMMENDED: On a posix compatible shells run this command inside your project directory:
+- RECOMMENDED: In your terminal with a posix-compatible shell, run this command inside your project directory:
 ```shell
 curl -L https://github.com/CleanCut/rusty_engine/archive/refs/heads/main.tar.gz | tar -zxv --strip-components=1 rusty_engine-main/assets
 ```
@@ -27,7 +27,7 @@ assets
     └── rolling
 ```
 
-You can organize your own custom files wherever you like, but the asset pack will always be organized like this:
+You can organize your own custom files inside the `assets` folder wherever you like, but the provided asset pack is organized like this:
 
 - Audio files in `assets/audio`. The asset pack divides sounds into `music` and `sfx` subdirectories.
 - Font files in `assets/font`.

tutorial/src/105-keyboard-state.md

@@ -2,9 +2,9 @@
 
 You can think of keyboard _state_ as a snapshot of exactly which keys are pressed (or not) at the start of the frame. Keyboard state is best for interactive things like character movement.  If you need to process every single keystroke (like when entering text), check out the [Keyboard Event](110-keyboard-events.md) section instead.
 
-The `Engine.keyboard_state` field is a struct through which you query the state of the key(s) you are interested in.
+The `Engine` struct's `keyboard_state` field is a struct through which you query the state of the key(s) you are interested in.
 
-Rusty Engine exposes [Bevy](https://bevyengine.org/)'s [`KeyCode`](https://docs.rs/bevy/latest/bevy/input/keyboard/enum.KeyCode.html) enum directly. See [the `KeyCode` documentation](https://docs.rs/bevy/latest/bevy/input/keyboard/enum.KeyCode.html) for all the possible key variants.
+Rusty Engine exposes [Bevy](https://bevyengine.org/)'s [`KeyCode`](https://docs.rs/bevy/latest/bevy/input/keyboard/enum.KeyCode.html) enum through its prelude. See [the `KeyCode` documentation](https://docs.rs/bevy/latest/bevy/input/keyboard/enum.KeyCode.html) for all the possible key variants.
 
 ### Pressed / Released
 
@@ -54,7 +54,7 @@ if engine.keyboard_state.just_pressed_any(&[KeyCode::Q, KeyCode::F1]) {
     // open menu
 }
 if engine.keyboard_state.just_released_any(&[KeyCode::Space, KeyCode::LControl]) {
-    // reevaluate your life choices
+    // re-evaluate your life choices
 }
 ```
 

tutorial/src/110-keyboard-events.md

@@ -6,8 +6,8 @@ Keyboard events are passed through from Bevy as instances of the [`KeyboardInput
 
 ```rust,ignored
 for keyboard_event in game_state.keyboard_events.drain(..) {
-    // We're using `if let` and a pattern to both destructure the struct and at the
-    // same time match "Pressed" events containing some key code.
+    // We're using `if let` and a pattern to destructure the KeyboardInput struct and only look at
+    // keyboard input if the state is "Pressed". Then we match on the KeyCode and take action.
     if let KeyboardInput {
         scan_code: _,
         key_code: Some(key_code),