some fixes

Author: mockersf

bevy-workshop/src/1-intro/progress.md

@@ -1,6 +1,6 @@
 # Progress Report
 
-Let's review what was done: <https://github.com/vleue/bevy_workshop-rustweek-2025/compare/before-05..05-intro-to-bevy>
+Let's review what was done: <https://github.com/vleue/bevy_workshop-rustweek-2025/compare/0-zero..05-intro-to-bevy>
 
 ## What You've learned
 

bevy-workshop/src/2-basics/actual-physics.md

@@ -23,18 +23,17 @@ Let's pick a physics engine that's easy to use with Bevy. There are two options:
 
 We'll use Avian in this workshop, but you could use Rapier and get similar results.
 
-First we'll add a dependency on `avian2d` to our `Cargo.toml` file:
+First we'll add a dependency on `avian2d` to our project:
 
 ```toml
-[dependencies]
-avian2d = "0.3"
+cargo add avian2d
 ```
 
 To finish the setup, we need to add the `PhysicsPlugins::default()` to our app. And as we're in space, let's remove gravity! This can be done by adding the resource `Gravity::ZERO`.
 
 ## Asteroid Movements
 
-Asteroids are the easiest to do! First remove the `inertia` system, as that will now be handled by the physics engine.
+Asteroids are the easiest to do! First remove the `inertia` system, and the fields of the `Asteroid` component, as that will now be handled by the physics engine.
 
 When spawning an asteroid, we'll need to add the following components:
 
@@ -152,7 +151,7 @@ fn control_player(
     >,
     mut visibility: Query<&mut Visibility>,
 ) -> Result {
-    let Ok((transform, mut angular_velocity, mut linear_velocity, children)) = player.single_mut()
+    let Ok((player_transform, mut angular_velocity, mut linear_velocity, children)) = player.single_mut()
     else {
         // No player at the moment, skip control logic
         return Ok(());
@@ -164,8 +163,9 @@ fn control_player(
         angular_velocity.0 -= 0.2;
     }
     if keyboard_input.pressed(KeyCode::KeyW) {
-        linear_velocity.0 += transform.local_y().xy() * 2.0;
-        linear_velocity.0 = linear_velocity.0.clamp_length_max(200.0);
+        let forward = player_transform.local_y();
+        linear_velocity.0 += forward.xy() * 2.0;
+        linear_velocity.0 = linear_velocity.0.clamp_length_max(300.0);
         *visibility.get_mut(children[0])? = Visibility::Visible;
     } else {
         visibility

bevy-workshop/src/2-basics/controls.md

@@ -2,6 +2,8 @@
 
 We'll control our player with the `A` and `D` keys on the keyboard to turn, and `W` for thrust.
 
+Let's start by handling rotation:
+
 ```rust,no_run
 # extern crate bevy;
 # use bevy::prelude::*;
@@ -11,17 +13,18 @@ We'll control our player with the `A` and `D` keys on the keyboard to turn, and
 fn control_player(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     mut player: Query<&mut Transform, With<Player>>,
+    time: Res<Time>,
 ) -> Result {
     let mut player_transform = player.single_mut()?;
+
+    let fixed_rotation_rate = 0.2;
+    let rotation_rate = fixed_rotation_rate / (1.0 / (60.0 * time.delta().as_secs_f32()));
+
     if keyboard_input.pressed(KeyCode::KeyA) {
-        player_transform.rotate_z(FRAC_PI_8 / 4.0);
+        player_transform.rotate_z(rotation_rate);
     }
     if keyboard_input.pressed(KeyCode::KeyD) {
-        player_transform.rotate_z(-FRAC_PI_8 / 4.0);
-    }
-    if keyboard_input.pressed(KeyCode::KeyW) {
-        let forward = player_transform.local_y();
-        player_transform.translation += forward * 5.0;
+        player_transform.rotate_z(-rotation_rate);
     }
     Ok(())
 }
@@ -57,6 +60,10 @@ Bevy exposes helper methods to manipulate the `Transform`:
 
 As Bevy doesn't specialize for 2D, `Transform` has all the needed part for 3D and can be a bit hard to use in 2D.
 
+## Time Delta
+
+TODO
+
 ## Error handling in systems
 
 Bevy systems can return a [`Result`](https://docs.rs/bevy/0.16.0/bevy/ecs/error/type.Result.html) (an alias to `Result<(), BevyError>`) to be able to use error handling, like `?`.

bevy-workshop/src/2-basics/display.md

@@ -1,5 +1,7 @@
 # Displaying Something
 
+Let's start building a game! First step is to add a new `Game` variant to the `GameState` enum, and change to it in the menu instead of just printing something.
+
 We'll just display blocks of color for now, as placeholders. Red is the player, blue is an asteroid.
 
 ```rust,no_run
@@ -8,7 +10,7 @@ We'll just display blocks of color for now, as placeholders. Red is the player,
 # enum GameState { #[default] Game }
 use bevy::prelude::*;
 
-fn game_plugin(app: &mut App) {
+pub fn game_plugin(app: &mut App) {
     app.add_systems(OnEnter(GameState::Game), display_level);
 }
 

bevy-workshop/src/2-basics/exercises2.md

@@ -2,13 +2,22 @@
 
 It's very easy to avoid collisions with the asteroids as they don't move... Let's make this game a bit harder!
 
+You can continue from your code, or get the branch with the workshop up till now:
+
+```sh
+git checkout 06-basic-game-mid
+```
+
+Let's review what was changed: <https://github.com/vleue/bevy_workshop-rustweek-2025/compare/06-basic-game..06-basic-game-mid>
+
 ## Moving the Asteroids
 
 Make the asteroids move in random directions, at random speeds.
 
 Tips:
 
 - Add information about direction and speed to the `Asteroid` component.
+- Add the rand crate (`cargo add rand@0.8`) to set them to random values with [`Rng::gen_range`](https://docs.rs/rand/0.8.5/rand/trait.Rng.html#method.gen_range)
 - Add a system to update the position of the asteroids based on their direction and speed.
 
 ## Losing the Game
@@ -17,7 +26,7 @@ Let's go back to the menu when colliding with an asteroid.
 
 Tips:
 
-- Use the `ResMut<NextState<GameStates>>` system parameter to change the current state on collision
+- Use the `ResMut<NextState<GameState>>` system parameter to change the current state on collision
 
 ## Explosion Effect on Collision
 

bevy-workshop/src/2-basics/physics.md

@@ -62,7 +62,7 @@ fn collision(
             .translation
             .distance(player_transform.translation);
         if distance < (asteroid_radius + player_radius) {
-            info!("Collision detected!");
+            println!("Collision detected!");
         }
     }
 
@@ -112,7 +112,7 @@ fn collision(
             .translation
             .distance(player_transform.translation);
         if distance < (asteroid_radius + player_radius) {
-            info!("Collision detected!");
+            println!("Collision detected!");
         }
     }
 

bevy-workshop/src/3-level/loading.md

@@ -26,6 +26,12 @@ pub struct Level {
 
 ## Asset Loader
 
+Let's add `thiserror` as a dependency, this will help us when declaring the kind of errors that can happen when loading our file.
+
+```sh
+cargo add thiserror
+```
+
 To load this format, we'll read the file character by character, then choose the right tile depending on the character. Bevy expects custom asset loader to implement the trait [`AssetLoader`](https://docs.rs/bevy/0.16.0/bevy/asset/trait.AssetLoader.html).
 
 ```rust
@@ -108,7 +114,7 @@ Custom asset formats and loaders must be initiated in the application with [`App
 #     async fn load(&self, reader: &mut dyn Reader, _settings: &(), _load_context: &mut LoadContext<'_>) -> Result<Self::Asset, Self::Error> { unimplemented!() }
 #     fn extensions(&self) -> &[&str] { &["bw"] }
 # }
-fn level_loader_plugin(app: &mut App) {
+pub fn level_loader_plugin(app: &mut App) {
     app.init_asset::<Level>().init_asset_loader::<LevelLoader>();
 }
 ```

bevy-workshop/src/5-sound/firing.md

@@ -71,7 +71,7 @@ fn fire_laser(
 
 To receive an event, we must use the [`EventReader`](https://docs.rs/bevy/0.16.0/bevy/ecs/event/struct.EventReader.html) system parameter, and by calling [`EventReader::read`](https://docs.rs/bevy/0.16.0/bevy/ecs/event/struct.EventReader.html#method.read) we can iterate over events.
 
-To play audio, we must spawn an entity with the [`AudioStart`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioStart.html) component that will contain an [`Handle`](https://docs.rs/bevy/0.16.0/bevy/asset/enum.Handle.html) to the [`AudioSource`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioSource.html) asset.
+To play audio, we must spawn an entity with the [`AudioPlayer`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioPlayer.html) component that will contain an [`Handle`](https://docs.rs/bevy/0.16.0/bevy/asset/enum.Handle.html) to the [`AudioSource`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioSource.html) asset.
 
 By default, audio entities remain present once the audio is done playing. You can change this behaviour with the component [`PlaybackSettings::DESPAWN`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.PlaybackSettings.html#associatedconstant.DESPAWN).
 

bevy-workshop/src/5-sound/progress.md

@@ -4,7 +4,7 @@
 
 - Playing a sound reacting to an action by the user
   - Loading audio assets of the [`AudioSource`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioSource.html) asset type
-  - And playing them by spawning the [`AudioStart`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioStart.html) component
+  - And playing them by spawning the [`AudioPlayer`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.AudioPlayer.html) component
   - Controlling playback settings with the [`PlaybackSettings`](https://docs.rs/bevy/0.16.0/bevy/audio/struct.PlaybackSettings.html) component
 - How events work
   - With [`App::add_event`](https://docs.rs/bevy/0.16.0/bevy/app/struct.App.html#method.add_event) to register an event

bevy-workshop/src/6-visuals/particles.md

@@ -13,7 +13,7 @@ bevy_hanabi uses the GPU through compute shaders, while bevy_enoki does it all o
 
 Let's add the plugin to our project:
 
-```bash
+```sh
 cargo add bevy_enoki
 ```