From a9a4d2215322a74a746415007c00929631b65a4b Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 03:04:04 +0200
Subject: [PATCH 01/27] Move player spawning to game

---
 src/game/mod.rs         |  5 ++++-
 src/game/spawn_level.rs | 25 +++++++++++++++++++++++++
 src/screen/playing.rs   | 11 +++--------
 3 files changed, 32 insertions(+), 9 deletions(-)
 create mode 100644 src/game/spawn_level.rs

diff --git a/src/game/mod.rs b/src/game/mod.rs
index 993202a3..4445fe9b 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -1,7 +1,10 @@
 //! Game mechanics and content.
 
 use bevy::prelude::*;
+pub(crate) use spawn_level::SpawnLevel;
+
+mod spawn_level;
 
 pub(super) fn plugin(app: &mut App) {
-    let _ = app;
+    app.add_plugins(spawn_level::plugin);
 }
diff --git a/src/game/spawn_level.rs b/src/game/spawn_level.rs
new file mode 100644
index 00000000..0f0cd990
--- /dev/null
+++ b/src/game/spawn_level.rs
@@ -0,0 +1,25 @@
+use bevy::prelude::*;
+
+use crate::screen::Screen;
+
+#[derive(Debug, Event)]
+pub(crate) struct SpawnLevel;
+
+pub(super) fn plugin(app: &mut App) {
+    app.observe(spawn_level);
+}
+
+fn spawn_level(
+    _trigger: Trigger<SpawnLevel>,
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    commands.spawn((
+        Name::new("Player"),
+        SpriteBundle {
+            texture: asset_server.load("ducky.png"),
+            ..Default::default()
+        },
+        StateScoped(Screen::Playing),
+    ));
+}
diff --git a/src/screen/playing.rs b/src/screen/playing.rs
index 62add4aa..4458984e 100644
--- a/src/screen/playing.rs
+++ b/src/screen/playing.rs
@@ -3,6 +3,7 @@
 use bevy::{input::common_conditions::input_just_pressed, prelude::*};
 
 use super::Screen;
+use crate::game::SpawnLevel;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Playing), enter_playing)
@@ -15,14 +16,8 @@ pub(super) fn plugin(app: &mut App) {
     );
 }
 
-fn enter_playing(mut commands: Commands, asset_server: Res<AssetServer>) {
-    commands.spawn((
-        SpriteBundle {
-            texture: asset_server.load("ducky.png"),
-            ..Default::default()
-        },
-        StateScoped(Screen::Playing),
-    ));
+fn enter_playing(mut commands: Commands) {
+    commands.trigger(SpawnLevel);
 }
 
 // TODO: Reset camera transform here.

From eef00af77aa177943514da4cfd5d8c5eff7db6bc Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 12:57:33 +0200
Subject: [PATCH 02/27] Add movement mod

---
 src/game/mod.rs      | 10 +++++++++-
 src/game/movement.rs | 28 ++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 src/game/movement.rs

diff --git a/src/game/mod.rs b/src/game/mod.rs
index 4445fe9b..b62742fb 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -3,8 +3,16 @@
 use bevy::prelude::*;
 pub(crate) use spawn_level::SpawnLevel;
 
+mod movement;
 mod spawn_level;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_plugins(spawn_level::plugin);
+    app.configure_sets(Update, GameSystem::Movement);
+
+    app.add_plugins((spawn_level::plugin, movement::plugin));
+}
+
+#[derive(Debug, SystemSet, Clone, Copy, Eq, PartialEq, Hash)]
+enum GameSystem {
+    Movement,
 }
diff --git a/src/game/movement.rs b/src/game/movement.rs
new file mode 100644
index 00000000..4e7a9742
--- /dev/null
+++ b/src/game/movement.rs
@@ -0,0 +1,28 @@
+use bevy::prelude::*;
+
+pub(super) fn plugin(app: &mut App) {}
+
+fn move_player(
+    time: Res<Time>,
+    keyboard_input: Res<Input<KeyCode>>,
+    mut query: Query<(&mut Transform, &Player)>,
+) {
+    for (mut transform, _player) in query.iter_mut() {
+        let mut direction = Vec3::ZERO;
+        if keyboard_input.pressed(KeyCode::W) {
+            direction.y += 1.0;
+        }
+        if keyboard_input.pressed(KeyCode::S) {
+            direction.y -= 1.0;
+        }
+        if keyboard_input.pressed(KeyCode::A) {
+            direction.x -= 1.0;
+        }
+        if keyboard_input.pressed(KeyCode::D) {
+            direction.x += 1.0;
+        }
+        if direction.length() > 0.0 {
+            transform.translation += direction.normalize() * 4.0 * time.delta_seconds();
+        }
+    }
+}

From f4bdddc902875d1598c2a9761fb8f4014924222b Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 13:22:26 +0200
Subject: [PATCH 03/27] Add velocity

---
 src/game/movement.rs | 47 ++++++++++++++++++++++++++++----------------
 1 file changed, 30 insertions(+), 17 deletions(-)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index 4e7a9742..9d74d700 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -2,27 +2,40 @@ use bevy::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {}
 
-fn move_player(
-    time: Res<Time>,
-    keyboard_input: Res<Input<KeyCode>>,
-    mut query: Query<(&mut Transform, &Player)>,
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Component)]
+struct Player;
+
+#[derive(Debug, Clone, Copy, PartialEq, Component, Deref, DerefMut)]
+struct Velocity(Vec2);
+
+fn handle_input(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut query: Query<&mut Velocity, With<Player>>,
 ) {
-    for (mut transform, _player) in query.iter_mut() {
-        let mut direction = Vec3::ZERO;
-        if keyboard_input.pressed(KeyCode::W) {
-            direction.y += 1.0;
-        }
-        if keyboard_input.pressed(KeyCode::S) {
-            direction.y -= 1.0;
+    for mut velocity in query.iter_mut() {
+        if keyboard_input.pressed(KeyCode::KeyW) {
+            velocity.y += 1.0;
         }
-        if keyboard_input.pressed(KeyCode::A) {
-            direction.x -= 1.0;
+        if keyboard_input.pressed(KeyCode::KeyS) {
+            velocity.y -= 1.0;
         }
-        if keyboard_input.pressed(KeyCode::D) {
-            direction.x += 1.0;
+        if keyboard_input.pressed(KeyCode::KeyA) {
+            velocity.x -= 1.0;
         }
-        if direction.length() > 0.0 {
-            transform.translation += direction.normalize() * 4.0 * time.delta_seconds();
+        if keyboard_input.pressed(KeyCode::KeyD) {
+            velocity.x += 1.0;
         }
     }
 }
+
+fn dampen_velocity(mut query: Query<&mut Velocity, With<Player>>) {
+    for mut velocity in query.iter_mut() {
+        velocity.0 *= 0.9;
+    }
+}
+
+fn apply_velocity(time: Res<Time>, mut query: Query<(&mut Transform, &Velocity), With<Player>>) {
+    for (mut transform, velocity) in query.iter_mut() {
+        transform.translation += Vec3::new(velocity.0.x, velocity.0.y, 0.0) * time.delta_seconds();
+    }
+}

From 7dec08ea61a2f2a94f92276e4f2abb05b00d687c Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 16:35:42 +0200
Subject: [PATCH 04/27] Use Bevy example code

---
 src/game/movement.rs    | 79 +++++++++++++++++++++++++++++++----------
 src/game/spawn_level.rs |  4 +++
 2 files changed, 64 insertions(+), 19 deletions(-)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index 9d74d700..f593bf28 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -1,41 +1,82 @@
 use bevy::prelude::*;
 
-pub(super) fn plugin(app: &mut App) {}
+pub(super) fn plugin(app: &mut App) {
+    app
+        // `FixedUpdate` runs before `Update`, so the physics simulation is advanced before the
+        // player's visual representation is updated.
+        .add_systems(FixedUpdate, advance_physics)
+        .add_systems(Update, (update_displayed_transform, handle_input).chain());
+}
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Component)]
-struct Player;
+/// How many units per second the player should move.
+#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct Velocity(pub(crate) Vec3);
 
-#[derive(Debug, Clone, Copy, PartialEq, Component, Deref, DerefMut)]
-struct Velocity(Vec2);
+/// The actual position of the player in the physics simulation.
+/// This is separate from the `Transform`, which is merely a visual
+/// representation.
+///
+/// If you want to make sure that this component is always initialized
+/// with the same value as the `Transform`'s translation, you can
+/// use a [component lifecycle hook](https://docs.rs/bevy/0.14.0/bevy/ecs/component/struct.ComponentHooks.html)
+#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct PhysicalTranslation(pub(crate) Vec3);
 
-fn handle_input(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<&mut Velocity, With<Player>>,
-) {
+/// Handle keyboard input to move the player.
+fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut Velocity>) {
+    /// Since Bevy's default 2D camera setup is scaled such that
+    /// one unit is one pixel, you can think of this as
+    /// "How many pixels per second should the player move?"
+    const SPEED: f32 = 210.0;
     for mut velocity in query.iter_mut() {
+        velocity.0 = Vec3::ZERO;
+
         if keyboard_input.pressed(KeyCode::KeyW) {
-            velocity.y += 1.0;
+            velocity.y += SPEED;
         }
         if keyboard_input.pressed(KeyCode::KeyS) {
-            velocity.y -= 1.0;
+            velocity.y -= SPEED;
         }
         if keyboard_input.pressed(KeyCode::KeyA) {
-            velocity.x -= 1.0;
+            velocity.x -= SPEED;
         }
         if keyboard_input.pressed(KeyCode::KeyD) {
-            velocity.x += 1.0;
+            velocity.x += SPEED;
         }
+
+        // Need to normalize and scale because otherwise
+        // diagonal movement would be faster than horizontal or vertical movement.
+        velocity.0 = velocity.normalize_or_zero() * SPEED;
     }
 }
 
-fn dampen_velocity(mut query: Query<&mut Velocity, With<Player>>) {
-    for mut velocity in query.iter_mut() {
-        velocity.0 *= 0.9;
+/// Advance the physics simulation by one fixed timestep. This may run zero or
+/// multiple times per frame.
+///
+/// Note that since this runs in `FixedUpdate`, `Res<Time>` would be
+/// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
+fn advance_physics(
+    fixed_time: Res<Time<Fixed>>,
+    mut query: Query<(&mut PhysicalTranslation, &Velocity)>,
+) {
+    for (mut physical_translation, velocity) in query.iter_mut() {
+        physical_translation.0 += velocity.0 * fixed_time.delta_seconds();
     }
 }
 
-fn apply_velocity(time: Res<Time>, mut query: Query<(&mut Transform, &Velocity), With<Player>>) {
-    for (mut transform, velocity) in query.iter_mut() {
-        transform.translation += Vec3::new(velocity.0.x, velocity.0.y, 0.0) * time.delta_seconds();
+fn update_displayed_transform(
+    fixed_time: Res<Time<Fixed>>,
+    mut query: Query<(&mut Transform, &PhysicalTranslation)>,
+) {
+    for (mut transform, physical_translation) in query.iter_mut() {
+        let last_displayed_translation = transform.translation;
+        // The overstep fraction is a value between 0 and 1 that tells us how far we are
+        // between two fixed timesteps.
+        let alpha = fixed_time.overstep_fraction();
+
+        let next_displayed_translation =
+            last_displayed_translation.lerp(physical_translation.0, alpha);
+
+        transform.translation = next_displayed_translation;
     }
 }
diff --git a/src/game/spawn_level.rs b/src/game/spawn_level.rs
index 0f0cd990..a81a7425 100644
--- a/src/game/spawn_level.rs
+++ b/src/game/spawn_level.rs
@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 
+use super::movement::{PhysicalTranslation, Velocity};
 use crate::screen::Screen;
 
 #[derive(Debug, Event)]
@@ -18,8 +19,11 @@ fn spawn_level(
         Name::new("Player"),
         SpriteBundle {
             texture: asset_server.load("ducky.png"),
+            transform: Transform::from_scale(Vec3::splat(0.4)),
             ..Default::default()
         },
+        Velocity::default(),
+        PhysicalTranslation::default(),
         StateScoped(Screen::Playing),
     ));
 }

From 5d652eb2dcc5978324f5278cca48ebbeafa1db6f Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 16:50:09 +0200
Subject: [PATCH 05/27] Split stuff into files

---
 src/game/{spawn_level.rs => level.rs} |  4 +-
 src/game/mod.rs                       | 18 +++++++--
 src/game/movement.rs                  | 53 +++------------------------
 src/game/physics.rs                   | 37 +++++++++++++++++++
 src/game/render.rs                    | 26 +++++++++++++
 5 files changed, 87 insertions(+), 51 deletions(-)
 rename src/game/{spawn_level.rs => level.rs} (89%)
 create mode 100644 src/game/physics.rs
 create mode 100644 src/game/render.rs

diff --git a/src/game/spawn_level.rs b/src/game/level.rs
similarity index 89%
rename from src/game/spawn_level.rs
rename to src/game/level.rs
index a81a7425..2dd1a9ab 100644
--- a/src/game/spawn_level.rs
+++ b/src/game/level.rs
@@ -1,6 +1,8 @@
+//! Setup the level
+
 use bevy::prelude::*;
 
-use super::movement::{PhysicalTranslation, Velocity};
+use super::physics::{PhysicalTranslation, Velocity};
 use crate::screen::Screen;
 
 #[derive(Debug, Event)]
diff --git a/src/game/mod.rs b/src/game/mod.rs
index b62742fb..33fdee69 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -1,15 +1,27 @@
 //! Game mechanics and content.
+//!
+//! The basic movement code shipped with the template is taken from the corresponding
+//! [Bevy example](https://github.com/janhohenheim/bevy/blob/fixed-time-movement/examples/movement/physics_in_fixed_timestep.rs).
+//! See that link for an in-depth explanation of the code and the motivation behind it.
 
 use bevy::prelude::*;
-pub(crate) use spawn_level::SpawnLevel;
+pub(crate) use level::SpawnLevel;
 
+mod level;
 mod movement;
-mod spawn_level;
+mod physics;
+mod render;
 
 pub(super) fn plugin(app: &mut App) {
     app.configure_sets(Update, GameSystem::Movement);
 
-    app.add_plugins((spawn_level::plugin, movement::plugin));
+    app.add_plugins((
+        movement::plugin,
+        physics::plugin,
+        render::plugin,
+        level::plugin,
+        movement::plugin,
+    ));
 }
 
 #[derive(Debug, SystemSet, Clone, Copy, Eq, PartialEq, Hash)]
diff --git a/src/game/movement.rs b/src/game/movement.rs
index f593bf28..53782457 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -1,26 +1,15 @@
+//! Handle player input and translate it into velocity.
+
 use bevy::prelude::*;
 
+use super::physics::Velocity;
+
+
 pub(super) fn plugin(app: &mut App) {
     app
-        // `FixedUpdate` runs before `Update`, so the physics simulation is advanced before the
-        // player's visual representation is updated.
-        .add_systems(FixedUpdate, advance_physics)
-        .add_systems(Update, (update_displayed_transform, handle_input).chain());
+        .add_systems(Update, handle_input);
 }
 
-/// How many units per second the player should move.
-#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
-pub(crate) struct Velocity(pub(crate) Vec3);
-
-/// The actual position of the player in the physics simulation.
-/// This is separate from the `Transform`, which is merely a visual
-/// representation.
-///
-/// If you want to make sure that this component is always initialized
-/// with the same value as the `Transform`'s translation, you can
-/// use a [component lifecycle hook](https://docs.rs/bevy/0.14.0/bevy/ecs/component/struct.ComponentHooks.html)
-#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
-pub(crate) struct PhysicalTranslation(pub(crate) Vec3);
 
 /// Handle keyboard input to move the player.
 fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut Velocity>) {
@@ -50,33 +39,3 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut
     }
 }
 
-/// Advance the physics simulation by one fixed timestep. This may run zero or
-/// multiple times per frame.
-///
-/// Note that since this runs in `FixedUpdate`, `Res<Time>` would be
-/// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
-fn advance_physics(
-    fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut PhysicalTranslation, &Velocity)>,
-) {
-    for (mut physical_translation, velocity) in query.iter_mut() {
-        physical_translation.0 += velocity.0 * fixed_time.delta_seconds();
-    }
-}
-
-fn update_displayed_transform(
-    fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut Transform, &PhysicalTranslation)>,
-) {
-    for (mut transform, physical_translation) in query.iter_mut() {
-        let last_displayed_translation = transform.translation;
-        // The overstep fraction is a value between 0 and 1 that tells us how far we are
-        // between two fixed timesteps.
-        let alpha = fixed_time.overstep_fraction();
-
-        let next_displayed_translation =
-            last_displayed_translation.lerp(physical_translation.0, alpha);
-
-        transform.translation = next_displayed_translation;
-    }
-}
diff --git a/src/game/physics.rs b/src/game/physics.rs
new file mode 100644
index 00000000..315ab762
--- /dev/null
+++ b/src/game/physics.rs
@@ -0,0 +1,37 @@
+//! Run a very simple physics simulation.
+
+use bevy::prelude::*;
+
+pub(super) fn plugin(app: &mut App) {
+    // `FixedUpdate` runs before `Update`, so the physics simulation is advanced
+    // before the player's visual representation is updated.
+    app.add_systems(FixedUpdate, advance_physics);
+}
+
+/// How many units per second the player should move.
+#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct Velocity(pub(crate) Vec3);
+
+/// The actual position of the player in the physics simulation.
+/// This is separate from the `Transform`, which is merely a visual
+/// representation.
+///
+/// If you want to make sure that this component is always initialized
+/// with the same value as the `Transform`'s translation, you can
+/// use a [component lifecycle hook](https://docs.rs/bevy/0.14.0/bevy/ecs/component/struct.ComponentHooks.html)
+#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct PhysicalTranslation(pub(crate) Vec3);
+
+/// Advance the physics simulation by one fixed timestep. This may run zero or
+/// multiple times per frame.
+///
+/// Note that since this runs in `FixedUpdate`, `Res<Time>` would be
+/// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
+fn advance_physics(
+    fixed_time: Res<Time<Fixed>>,
+    mut query: Query<(&mut PhysicalTranslation, &Velocity)>,
+) {
+    for (mut physical_translation, velocity) in query.iter_mut() {
+        physical_translation.0 += velocity.0 * fixed_time.delta_seconds();
+    }
+}
diff --git a/src/game/render.rs b/src/game/render.rs
new file mode 100644
index 00000000..2d448a15
--- /dev/null
+++ b/src/game/render.rs
@@ -0,0 +1,26 @@
+//! Handle how the physically simulated world should be rendered.
+
+use bevy::prelude::*;
+
+use super::physics::PhysicalTranslation;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_systems(Update, update_rendered_transform);
+}
+
+fn update_rendered_transform(
+    fixed_time: Res<Time<Fixed>>,
+    mut query: Query<(&mut Transform, &PhysicalTranslation)>,
+) {
+    for (mut transform, physical_translation) in query.iter_mut() {
+        let last_rendered_translation = transform.translation;
+        // The overstep fraction is a value between 0 and 1 that tells us how far we are
+        // between two fixed timesteps.
+        let alpha = fixed_time.overstep_fraction();
+
+        let next_rendered_translation =
+            last_rendered_translation.lerp(physical_translation.0, alpha);
+
+        transform.translation = next_rendered_translation;
+    }
+}

From d87c8d9c50875e01227339a5aab173a07fa2a9f9 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:04:22 +0200
Subject: [PATCH 06/27] Add component hook, make translation full transform

---
 src/game/level.rs   |  4 ++--
 src/game/mod.rs     |  8 ++++----
 src/game/physics.rs | 36 +++++++++++++++++++++++++-----------
 src/game/render.rs  | 10 +++++-----
 4 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/game/level.rs b/src/game/level.rs
index 2dd1a9ab..04b13112 100644
--- a/src/game/level.rs
+++ b/src/game/level.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 
-use super::physics::{PhysicalTranslation, Velocity};
+use super::physics::{PhysicalTransform, Velocity};
 use crate::screen::Screen;
 
 #[derive(Debug, Event)]
@@ -25,7 +25,7 @@ fn spawn_level(
             ..Default::default()
         },
         Velocity::default(),
-        PhysicalTranslation::default(),
+        PhysicalTransform::default(),
         StateScoped(Screen::Playing),
     ));
 }
diff --git a/src/game/mod.rs b/src/game/mod.rs
index 33fdee69..a90d4560 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -1,8 +1,9 @@
 //! Game mechanics and content.
 //!
-//! The basic movement code shipped with the template is taken from the corresponding
-//! [Bevy example](https://github.com/janhohenheim/bevy/blob/fixed-time-movement/examples/movement/physics_in_fixed_timestep.rs).
-//! See that link for an in-depth explanation of the code and the motivation behind it.
+//! The basic movement code shipped with the template is based on the
+//! corresponding [Bevy example](https://github.com/janhohenheim/bevy/blob/fixed-time-movement/examples/movement/physics_in_fixed_timestep.rs).
+//! See that link for an in-depth explanation of the code and the motivation
+//! behind it.
 
 use bevy::prelude::*;
 pub(crate) use level::SpawnLevel;
@@ -20,7 +21,6 @@ pub(super) fn plugin(app: &mut App) {
         physics::plugin,
         render::plugin,
         level::plugin,
-        movement::plugin,
     ));
 }
 
diff --git a/src/game/physics.rs b/src/game/physics.rs
index 315ab762..64b4b0cd 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -1,6 +1,9 @@
 //! Run a very simple physics simulation.
 
-use bevy::prelude::*;
+use bevy::{
+    ecs::component::{ComponentHooks, StorageType},
+    prelude::*,
+};
 
 pub(super) fn plugin(app: &mut App) {
     // `FixedUpdate` runs before `Update`, so the physics simulation is advanced
@@ -12,15 +15,26 @@ pub(super) fn plugin(app: &mut App) {
 #[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct Velocity(pub(crate) Vec3);
 
-/// The actual position of the player in the physics simulation.
+/// The actual transform of the player in the physics simulation.
 /// This is separate from the `Transform`, which is merely a visual
 /// representation.
-///
-/// If you want to make sure that this component is always initialized
-/// with the same value as the `Transform`'s translation, you can
-/// use a [component lifecycle hook](https://docs.rs/bevy/0.14.0/bevy/ecs/component/struct.ComponentHooks.html)
-#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
-pub(crate) struct PhysicalTranslation(pub(crate) Vec3);
+
+#[derive(Debug, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct PhysicalTransform(pub(crate) Transform);
+
+/// Make sure that this component is always initialized
+/// with the same value as the `Transform`
+impl Component for PhysicalTransform {
+    const STORAGE_TYPE: StorageType = StorageType::Table;
+
+    fn register_component_hooks(hooks: &mut ComponentHooks) {
+        hooks.on_add(|mut world, entity, _component_id| {
+            let rendered_transform = *world.get::<Transform>(entity).unwrap();
+            let mut physical_transform = world.get_mut::<PhysicalTransform>(entity).unwrap();
+            physical_transform.0 = rendered_transform;
+        });
+    }
+}
 
 /// Advance the physics simulation by one fixed timestep. This may run zero or
 /// multiple times per frame.
@@ -29,9 +43,9 @@ pub(crate) struct PhysicalTranslation(pub(crate) Vec3);
 /// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
 fn advance_physics(
     fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut PhysicalTranslation, &Velocity)>,
+    mut query: Query<(&mut PhysicalTransform, &Velocity)>,
 ) {
-    for (mut physical_translation, velocity) in query.iter_mut() {
-        physical_translation.0 += velocity.0 * fixed_time.delta_seconds();
+    for (mut physical_transform, velocity) in query.iter_mut() {
+        physical_transform.translation += velocity.0 * fixed_time.delta_seconds();
     }
 }
diff --git a/src/game/render.rs b/src/game/render.rs
index 2d448a15..201b5dd7 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 
-use super::physics::PhysicalTranslation;
+use super::physics::PhysicalTransform;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(Update, update_rendered_transform);
@@ -10,16 +10,16 @@ pub(super) fn plugin(app: &mut App) {
 
 fn update_rendered_transform(
     fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut Transform, &PhysicalTranslation)>,
+    mut query: Query<(&mut Transform, &PhysicalTransform)>,
 ) {
-    for (mut transform, physical_translation) in query.iter_mut() {
+    for (mut transform, physical_transform) in query.iter_mut() {
         let last_rendered_translation = transform.translation;
+        let physical_translation = physical_transform.translation;
         // The overstep fraction is a value between 0 and 1 that tells us how far we are
         // between two fixed timesteps.
         let alpha = fixed_time.overstep_fraction();
 
-        let next_rendered_translation =
-            last_rendered_translation.lerp(physical_translation.0, alpha);
+        let next_rendered_translation = last_rendered_translation.lerp(physical_translation, alpha);
 
         transform.translation = next_rendered_translation;
     }

From 54e79f74e51cd39cbbc0ba7eadef61205ed99bc7 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:06:47 +0200
Subject: [PATCH 07/27] Run cargo fmt

---
 src/core/dev.rs        | 3 +--
 src/game/movement.rs   | 6 +-----
 src/util/ui/widgets.rs | 6 +++++-
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/core/dev.rs b/src/core/dev.rs
index 62975501..f7a2ab15 100644
--- a/src/core/dev.rs
+++ b/src/core/dev.rs
@@ -2,9 +2,8 @@
 
 use bevy::{dev_tools::states::log_transitions, prelude::*};
 
-use crate::screen::Screen;
-
 use super::booting::Booting;
+use crate::screen::Screen;
 
 pub(super) fn plugin(app: &mut App) {
     // Print state transitions in dev builds
diff --git a/src/game/movement.rs b/src/game/movement.rs
index 53782457..d726ea5d 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -4,13 +4,10 @@ use bevy::prelude::*;
 
 use super::physics::Velocity;
 
-
 pub(super) fn plugin(app: &mut App) {
-    app
-        .add_systems(Update, handle_input);
+    app.add_systems(Update, handle_input);
 }
 
-
 /// Handle keyboard input to move the player.
 fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut Velocity>) {
     /// Since Bevy's default 2D camera setup is scaled such that
@@ -38,4 +35,3 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut
         velocity.0 = velocity.normalize_or_zero() * SPEED;
     }
 }
-
diff --git a/src/util/ui/widgets.rs b/src/util/ui/widgets.rs
index f447a2e1..afcd407c 100644
--- a/src/util/ui/widgets.rs
+++ b/src/util/ui/widgets.rs
@@ -5,7 +5,11 @@ use bevy::{ecs::system::EntityCommands, prelude::*};
 use super::{
     interaction::InteractionPalette,
     palette::{
-        BACKGROUND, BUTTON_HOVERED_BACKGROUND, BUTTON_PRESSED_BACKGROUND, BUTTON_TEXT, LABEL_TEXT,
+        BACKGROUND,
+        BUTTON_HOVERED_BACKGROUND,
+        BUTTON_PRESSED_BACKGROUND,
+        BUTTON_TEXT,
+        LABEL_TEXT,
         NODE_BACKGROUND,
     },
 };

From 3433c364de7333087caed2447a7963b70b7d0057 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:08:21 +0200
Subject: [PATCH 08/27] Run stable cargo fmt

---
 src/util/ui/widgets.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/util/ui/widgets.rs b/src/util/ui/widgets.rs
index afcd407c..f447a2e1 100644
--- a/src/util/ui/widgets.rs
+++ b/src/util/ui/widgets.rs
@@ -5,11 +5,7 @@ use bevy::{ecs::system::EntityCommands, prelude::*};
 use super::{
     interaction::InteractionPalette,
     palette::{
-        BACKGROUND,
-        BUTTON_HOVERED_BACKGROUND,
-        BUTTON_PRESSED_BACKGROUND,
-        BUTTON_TEXT,
-        LABEL_TEXT,
+        BACKGROUND, BUTTON_HOVERED_BACKGROUND, BUTTON_PRESSED_BACKGROUND, BUTTON_TEXT, LABEL_TEXT,
         NODE_BACKGROUND,
     },
 };

From a97fea8713f85f2788b6adb7b084a31e42d8a875 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:30:53 +0200
Subject: [PATCH 09/27] Remove whitespace

Co-authored-by: MiniaczQ <xnetroidpl@gmail.com>
---
 src/game/physics.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/game/physics.rs b/src/game/physics.rs
index 64b4b0cd..f3366684 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -18,7 +18,6 @@ pub(crate) struct Velocity(pub(crate) Vec3);
 /// The actual transform of the player in the physics simulation.
 /// This is separate from the `Transform`, which is merely a visual
 /// representation.
-
 #[derive(Debug, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct PhysicalTransform(pub(crate) Transform);
 

From adf3708a8dca71ccc723068bd3b54ceaf8f7ca60 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:40:52 +0200
Subject: [PATCH 10/27] Give hint for alternative hierarchy

---
 src/game/level.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/game/level.rs b/src/game/level.rs
index 04b13112..4e8b8d8a 100644
--- a/src/game/level.rs
+++ b/src/game/level.rs
@@ -25,6 +25,8 @@ fn spawn_level(
             ..Default::default()
         },
         Velocity::default(),
+        // A good alternative hierarchy would also be to have a `Player` root entity
+        // with the physical transform and the rendered transform as individual children.
         PhysicalTransform::default(),
         StateScoped(Screen::Playing),
     ));

From ffb0e52e3ef963e767e5a10f3dc1fba2e68114bd Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:43:19 +0200
Subject: [PATCH 11/27] Improve hint

---
 src/game/level.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/game/level.rs b/src/game/level.rs
index 4e8b8d8a..42076ee3 100644
--- a/src/game/level.rs
+++ b/src/game/level.rs
@@ -25,7 +25,8 @@ fn spawn_level(
             ..Default::default()
         },
         Velocity::default(),
-        // A good alternative hierarchy would also be to have a `Player` root entity
+        // If your physics engine of choice uses `Transform` directly,
+        // a good hierarchy to follow instead is to have a `Player` root entity
         // with the physical transform and the rendered transform as individual children.
         PhysicalTransform::default(),
         StateScoped(Screen::Playing),

From cd4934f0536b731875d1150e1bc83b9691130b8a Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 17:52:40 +0200
Subject: [PATCH 12/27] Split spawning into files

---
 src/game/mod.rs                        |  5 ++---
 src/game/spawn/level.rs                | 18 ++++++++++++++++++
 src/game/spawn/mod.rs                  | 11 +++++++++++
 src/game/{level.rs => spawn/player.rs} | 16 +++++++++-------
 src/screen/playing.rs                  |  2 +-
 5 files changed, 41 insertions(+), 11 deletions(-)
 create mode 100644 src/game/spawn/level.rs
 create mode 100644 src/game/spawn/mod.rs
 rename src/game/{level.rs => spawn/player.rs} (77%)

diff --git a/src/game/mod.rs b/src/game/mod.rs
index a90d4560..c40679d6 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -6,12 +6,11 @@
 //! behind it.
 
 use bevy::prelude::*;
-pub(crate) use level::SpawnLevel;
 
-mod level;
 mod movement;
 mod physics;
 mod render;
+pub(crate) mod spawn;
 
 pub(super) fn plugin(app: &mut App) {
     app.configure_sets(Update, GameSystem::Movement);
@@ -20,7 +19,7 @@ pub(super) fn plugin(app: &mut App) {
         movement::plugin,
         physics::plugin,
         render::plugin,
-        level::plugin,
+        spawn::plugin,
     ));
 }
 
diff --git a/src/game/spawn/level.rs b/src/game/spawn/level.rs
new file mode 100644
index 00000000..3c601393
--- /dev/null
+++ b/src/game/spawn/level.rs
@@ -0,0 +1,18 @@
+//! Spawn our main level by triggering other spawn events.
+
+use bevy::prelude::*;
+
+use super::player::SpawnPlayer;
+
+#[derive(Debug, Event)]
+pub(crate) struct SpawnLevel;
+
+pub(super) fn plugin(app: &mut App) {
+    app.observe(spawn_level);
+}
+
+fn spawn_level(_trigger: Trigger<SpawnLevel>, mut commands: Commands) {
+    // The only thing we have in our level is a player,
+    // but add things like walls etc. here.
+    commands.trigger(SpawnPlayer);
+}
diff --git a/src/game/spawn/mod.rs b/src/game/spawn/mod.rs
new file mode 100644
index 00000000..906a23e3
--- /dev/null
+++ b/src/game/spawn/mod.rs
@@ -0,0 +1,11 @@
+//! Handles spawning of entities. This is typically done through
+//! [observers](https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Observer.html).
+
+use bevy::prelude::*;
+
+pub(crate) mod level;
+mod player;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins((level::plugin, player::plugin));
+}
diff --git a/src/game/level.rs b/src/game/spawn/player.rs
similarity index 77%
rename from src/game/level.rs
rename to src/game/spawn/player.rs
index 42076ee3..e4f675a4 100644
--- a/src/game/level.rs
+++ b/src/game/spawn/player.rs
@@ -1,19 +1,21 @@
-//! Setup the level
+//! Spawn the player.
 
 use bevy::prelude::*;
 
-use super::physics::{PhysicalTransform, Velocity};
-use crate::screen::Screen;
+use crate::{
+    game::physics::{PhysicalTransform, Velocity},
+    screen::Screen,
+};
 
 #[derive(Debug, Event)]
-pub(crate) struct SpawnLevel;
+pub(crate) struct SpawnPlayer;
 
 pub(super) fn plugin(app: &mut App) {
-    app.observe(spawn_level);
+    app.observe(spawn_player);
 }
 
-fn spawn_level(
-    _trigger: Trigger<SpawnLevel>,
+fn spawn_player(
+    _trigger: Trigger<SpawnPlayer>,
     mut commands: Commands,
     asset_server: Res<AssetServer>,
 ) {
diff --git a/src/screen/playing.rs b/src/screen/playing.rs
index 4458984e..1a87a94a 100644
--- a/src/screen/playing.rs
+++ b/src/screen/playing.rs
@@ -3,7 +3,7 @@
 use bevy::{input::common_conditions::input_just_pressed, prelude::*};
 
 use super::Screen;
-use crate::game::SpawnLevel;
+use crate::game::spawn::level::SpawnLevel;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Playing), enter_playing)

From cbb6409d169053c36823d9ed5ef5c92fafe869d5 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:20:05 +0200
Subject: [PATCH 13/27] Add disclaimer

Co-authored-by: MiniaczQ <xnetroidpl@gmail.com>
---
 src/game/movement.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index d726ea5d..5835daca 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -13,6 +13,7 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut
     /// Since Bevy's default 2D camera setup is scaled such that
     /// one unit is one pixel, you can think of this as
     /// "How many pixels per second should the player move?"
+    /// Note that physics engines may use different unit/pixel ratios.
     const SPEED: f32 = 210.0;
     for mut velocity in query.iter_mut() {
         velocity.0 = Vec3::ZERO;

From a1e6d25cfdc996d9236d03d98a193da7d5aa4fdc Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:22:02 +0200
Subject: [PATCH 14/27] Add alternatives

Co-authored-by: MiniaczQ <xnetroidpl@gmail.com>
---
 src/game/spawn/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/game/spawn/mod.rs b/src/game/spawn/mod.rs
index 906a23e3..cad7fbec 100644
--- a/src/game/spawn/mod.rs
+++ b/src/game/spawn/mod.rs
@@ -1,5 +1,6 @@
 //! Handles spawning of entities. This is typically done through
 //! [observers](https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Observer.html).
+// Alternatively this can be done through `Events<E>` or `Commands`.
 
 use bevy::prelude::*;
 

From 79453462dd6fabb65ccad4203f0e2d2938147e0c Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:38:40 +0200
Subject: [PATCH 15/27] Remove authority

---
 src/game/spawn/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/game/spawn/mod.rs b/src/game/spawn/mod.rs
index cad7fbec..5b8e76cd 100644
--- a/src/game/spawn/mod.rs
+++ b/src/game/spawn/mod.rs
@@ -1,6 +1,6 @@
-//! Handles spawning of entities. This is typically done through
-//! [observers](https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Observer.html).
-// Alternatively this can be done through `Events<E>` or `Commands`.
+//! Handles spawning of entities. Here, we are using
+//! [observers](https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Observer.html)
+//! for this, but you could also use `Events<E>` or `Commands`.
 
 use bevy::prelude::*;
 

From bfd64afbc6f19a06df0ddc7803b508d238db877e Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:39:28 +0200
Subject: [PATCH 16/27] Reorder plugins

---
 src/game/spawn/level.rs  | 6 +++---
 src/game/spawn/player.rs | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/game/spawn/level.rs b/src/game/spawn/level.rs
index 3c601393..11b62b31 100644
--- a/src/game/spawn/level.rs
+++ b/src/game/spawn/level.rs
@@ -4,13 +4,13 @@ use bevy::prelude::*;
 
 use super::player::SpawnPlayer;
 
-#[derive(Debug, Event)]
-pub(crate) struct SpawnLevel;
-
 pub(super) fn plugin(app: &mut App) {
     app.observe(spawn_level);
 }
 
+#[derive(Debug, Event)]
+pub(crate) struct SpawnLevel;
+
 fn spawn_level(_trigger: Trigger<SpawnLevel>, mut commands: Commands) {
     // The only thing we have in our level is a player,
     // but add things like walls etc. here.
diff --git a/src/game/spawn/player.rs b/src/game/spawn/player.rs
index e4f675a4..fe050fe4 100644
--- a/src/game/spawn/player.rs
+++ b/src/game/spawn/player.rs
@@ -7,13 +7,13 @@ use crate::{
     screen::Screen,
 };
 
-#[derive(Debug, Event)]
-pub(crate) struct SpawnPlayer;
-
 pub(super) fn plugin(app: &mut App) {
     app.observe(spawn_player);
 }
 
+#[derive(Debug, Event)]
+pub(crate) struct SpawnPlayer;
+
 fn spawn_player(
     _trigger: Trigger<SpawnPlayer>,
     mut commands: Commands,

From d1b5de82b563baf6d240307f3fbdc22e2e115238 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:40:09 +0200
Subject: [PATCH 17/27] Improve phrasing

---
 src/game/spawn/level.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/game/spawn/level.rs b/src/game/spawn/level.rs
index 11b62b31..51cf0da8 100644
--- a/src/game/spawn/level.rs
+++ b/src/game/spawn/level.rs
@@ -1,4 +1,4 @@
-//! Spawn our main level by triggering other spawn events.
+//! Spawn the main level by triggering other observers.
 
 use bevy::prelude::*;
 

From 9c83090141be2b778f048a367a0c9f613d312698 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 18:48:42 +0200
Subject: [PATCH 18/27] Simplify code

---
 src/game/movement.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index 5835daca..c22dc147 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -19,16 +19,16 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut
         velocity.0 = Vec3::ZERO;
 
         if keyboard_input.pressed(KeyCode::KeyW) {
-            velocity.y += SPEED;
+            velocity.y += 1.0;
         }
         if keyboard_input.pressed(KeyCode::KeyS) {
-            velocity.y -= SPEED;
+            velocity.y -= 1.0;
         }
         if keyboard_input.pressed(KeyCode::KeyA) {
-            velocity.x -= SPEED;
+            velocity.x -= 1.0;
         }
         if keyboard_input.pressed(KeyCode::KeyD) {
-            velocity.x += SPEED;
+            velocity.x += 1.0;
         }
 
         // Need to normalize and scale because otherwise

From a7f89b51e84921bfc9a70b476f1788174c359050 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 20:40:45 +0200
Subject: [PATCH 19/27] Fix faulty interpolation

---
 src/game/physics.rs | 39 +++++++++++++++++++++++++++++++++------
 src/game/render.rs  | 20 ++++++++++++--------
 2 files changed, 45 insertions(+), 14 deletions(-)

diff --git a/src/game/physics.rs b/src/game/physics.rs
index f3366684..7e76efa1 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -8,7 +8,8 @@ use bevy::{
 pub(super) fn plugin(app: &mut App) {
     // `FixedUpdate` runs before `Update`, so the physics simulation is advanced
     // before the player's visual representation is updated.
-    app.add_systems(FixedUpdate, advance_physics);
+    app.add_systems(FixedUpdate, advance_physics)
+        .observe(on_add_physical_transform);
 }
 
 /// How many units per second the player should move.
@@ -21,8 +22,27 @@ pub(crate) struct Velocity(pub(crate) Vec3);
 #[derive(Debug, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct PhysicalTransform(pub(crate) Transform);
 
-/// Make sure that this component is always initialized
-/// with the same value as the `Transform`
+/// The value that [`PhysicalTranslation`] had in the last fixed timestep.
+/// Used for interpolation in the `update_rendered_transform` system.
+#[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
+pub(crate) struct PreviousPhysicalTransform(pub(crate) Transform);
+
+/// Make sure that [`PhysicalTransform`] is always initialized
+/// with the same value as the [`Transform`] and add a
+/// [`PreviousPhysicalTransform`]
+fn on_add_physical_transform(
+    trigger: Trigger<OnAdd, PhysicalTransform>,
+    mut commands: Commands,
+    mut query: Query<(&mut PhysicalTransform, &Transform)>,
+) {
+    let entity = trigger.entity();
+    let (mut physical_transform, &initial_transform) = query.get_mut(entity).unwrap();
+    physical_transform.0 = initial_transform;
+    commands
+        .entity(entity)
+        .insert(PreviousPhysicalTransform(initial_transform));
+}
+
 impl Component for PhysicalTransform {
     const STORAGE_TYPE: StorageType = StorageType::Table;
 
@@ -42,9 +62,16 @@ impl Component for PhysicalTransform {
 /// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
 fn advance_physics(
     fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut PhysicalTransform, &Velocity)>,
+    mut query: Query<(
+        &mut PhysicalTransform,
+        &mut PreviousPhysicalTransform,
+        &Velocity,
+    )>,
 ) {
-    for (mut physical_transform, velocity) in query.iter_mut() {
-        physical_transform.translation += velocity.0 * fixed_time.delta_seconds();
+    for (mut current_physical_transform, mut previous_physical_transform, velocity) in
+        query.iter_mut()
+    {
+        previous_physical_transform.0 = current_physical_transform.0;
+        current_physical_transform.translation += velocity.0 * fixed_time.delta_seconds();
     }
 }
diff --git a/src/game/render.rs b/src/game/render.rs
index 201b5dd7..ca11dd3b 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 
-use super::physics::PhysicalTransform;
+use super::physics::{PhysicalTransform, PreviousPhysicalTransform};
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(Update, update_rendered_transform);
@@ -10,17 +10,21 @@ pub(super) fn plugin(app: &mut App) {
 
 fn update_rendered_transform(
     fixed_time: Res<Time<Fixed>>,
-    mut query: Query<(&mut Transform, &PhysicalTransform)>,
+    mut query: Query<(
+        &mut Transform,
+        &PhysicalTransform,
+        &PreviousPhysicalTransform,
+    )>,
 ) {
-    for (mut transform, physical_transform) in query.iter_mut() {
-        let last_rendered_translation = transform.translation;
-        let physical_translation = physical_transform.translation;
+    for (mut transform, current_physical_transform, previous_physical_transform) in query.iter_mut()
+    {
+        let previous = previous_physical_transform.translation;
+        let current = current_physical_transform.translation;
         // The overstep fraction is a value between 0 and 1 that tells us how far we are
         // between two fixed timesteps.
         let alpha = fixed_time.overstep_fraction();
 
-        let next_rendered_translation = last_rendered_translation.lerp(physical_translation, alpha);
-
-        transform.translation = next_rendered_translation;
+        let rendered_translation = previous.lerp(current, alpha);
+        transform.translation = rendered_translation;
     }
 }

From e7be801b973cf5435654fb7fb0bd7c6b92898d04 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 20:43:25 +0200
Subject: [PATCH 20/27] Add docs

---
 src/game/physics.rs | 7 ++++++-
 src/game/render.rs  | 3 +++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/game/physics.rs b/src/game/physics.rs
index 7e76efa1..47ce8cdf 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -19,11 +19,16 @@ pub(crate) struct Velocity(pub(crate) Vec3);
 /// The actual transform of the player in the physics simulation.
 /// This is separate from the `Transform`, which is merely a visual
 /// representation.
+/// The reason for this separation is that physics simulations
+/// want to run at a fixed timestep, while rendering should run
+/// as fast as possible. The rendering will then interpolate between
+/// the previous and current physical translation to get a smooth
+/// visual representation of the player.
 #[derive(Debug, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct PhysicalTransform(pub(crate) Transform);
 
 /// The value that [`PhysicalTranslation`] had in the last fixed timestep.
-/// Used for interpolation in the `update_rendered_transform` system.
+/// Used for interpolation when rendering.
 #[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct PreviousPhysicalTransform(pub(crate) Transform);
 
diff --git a/src/game/render.rs b/src/game/render.rs
index ca11dd3b..4d8e5bae 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -8,6 +8,9 @@ pub(super) fn plugin(app: &mut App) {
     app.add_systems(Update, update_rendered_transform);
 }
 
+/// Interpolate between the previous and current physical translation to get a
+/// smooth visual representation of the player. This is a tradeoff, as it will
+/// also make visual representation lag slightly behind the actual physics simulation.
 fn update_rendered_transform(
     fixed_time: Res<Time<Fixed>>,
     mut query: Query<(

From a4c1565bd7d5e0fdb41255e19ea148d77c0c24b4 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 20:44:26 +0200
Subject: [PATCH 21/27] Remove unnecessary expliciteness

---
 src/game/physics.rs | 5 +----
 src/game/render.rs  | 3 ++-
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/game/physics.rs b/src/game/physics.rs
index 47ce8cdf..88591c16 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -62,11 +62,8 @@ impl Component for PhysicalTransform {
 
 /// Advance the physics simulation by one fixed timestep. This may run zero or
 /// multiple times per frame.
-///
-/// Note that since this runs in `FixedUpdate`, `Res<Time>` would be
-/// `Res<Time<Fixed>>` automatically. We are being explicit here for clarity.
 fn advance_physics(
-    fixed_time: Res<Time<Fixed>>,
+    fixed_time: Res<Time>,
     mut query: Query<(
         &mut PhysicalTransform,
         &mut PreviousPhysicalTransform,
diff --git a/src/game/render.rs b/src/game/render.rs
index 4d8e5bae..f85b58e8 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -10,7 +10,8 @@ pub(super) fn plugin(app: &mut App) {
 
 /// Interpolate between the previous and current physical translation to get a
 /// smooth visual representation of the player. This is a tradeoff, as it will
-/// also make visual representation lag slightly behind the actual physics simulation.
+/// also make visual representation lag slightly behind the actual physics
+/// simulation.
 fn update_rendered_transform(
     fixed_time: Res<Time<Fixed>>,
     mut query: Query<(

From d2d568a5451144c1115b3a2b3ca495c9fcaaa19b Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 20:45:21 +0200
Subject: [PATCH 22/27] Make ducky more glorious

---
 src/game/movement.rs     | 2 +-
 src/game/spawn/player.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index c22dc147..825d675a 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -14,7 +14,7 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut
     /// one unit is one pixel, you can think of this as
     /// "How many pixels per second should the player move?"
     /// Note that physics engines may use different unit/pixel ratios.
-    const SPEED: f32 = 210.0;
+    const SPEED: f32 = 240.0;
     for mut velocity in query.iter_mut() {
         velocity.0 = Vec3::ZERO;
 
diff --git a/src/game/spawn/player.rs b/src/game/spawn/player.rs
index fe050fe4..ec74d36e 100644
--- a/src/game/spawn/player.rs
+++ b/src/game/spawn/player.rs
@@ -23,7 +23,7 @@ fn spawn_player(
         Name::new("Player"),
         SpriteBundle {
             texture: asset_server.load("ducky.png"),
-            transform: Transform::from_scale(Vec3::splat(0.4)),
+            transform: Transform::from_scale(Vec3::splat(0.5)),
             ..Default::default()
         },
         Velocity::default(),

From 7ae0325c9e01159448faceec4ff5ac5c216c8341 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 20:49:13 +0200
Subject: [PATCH 23/27] Scope input to player entity

---
 src/game/movement.rs     | 9 ++++++---
 src/game/spawn/mod.rs    | 2 +-
 src/game/spawn/player.rs | 4 ++++
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/game/movement.rs b/src/game/movement.rs
index 825d675a..8effe2ba 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -2,14 +2,17 @@
 
 use bevy::prelude::*;
 
-use super::physics::Velocity;
+use super::{physics::Velocity, spawn::player::Player};
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Update, handle_input);
+    app.add_systems(Update, handle_player_movement_input);
 }
 
 /// Handle keyboard input to move the player.
-fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut Velocity>) {
+fn handle_player_movement_input(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut query: Query<&mut Velocity, With<Player>>,
+) {
     /// Since Bevy's default 2D camera setup is scaled such that
     /// one unit is one pixel, you can think of this as
     /// "How many pixels per second should the player move?"
diff --git a/src/game/spawn/mod.rs b/src/game/spawn/mod.rs
index 5b8e76cd..c1688936 100644
--- a/src/game/spawn/mod.rs
+++ b/src/game/spawn/mod.rs
@@ -5,7 +5,7 @@
 use bevy::prelude::*;
 
 pub(crate) mod level;
-mod player;
+pub(crate) mod player;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_plugins((level::plugin, player::plugin));
diff --git a/src/game/spawn/player.rs b/src/game/spawn/player.rs
index ec74d36e..7a8cd2ea 100644
--- a/src/game/spawn/player.rs
+++ b/src/game/spawn/player.rs
@@ -14,6 +14,9 @@ pub(super) fn plugin(app: &mut App) {
 #[derive(Debug, Event)]
 pub(crate) struct SpawnPlayer;
 
+#[derive(Debug, Component, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Player;
+
 fn spawn_player(
     _trigger: Trigger<SpawnPlayer>,
     mut commands: Commands,
@@ -21,6 +24,7 @@ fn spawn_player(
 ) {
     commands.spawn((
         Name::new("Player"),
+        Player,
         SpriteBundle {
             texture: asset_server.load("ducky.png"),
             transform: Transform::from_scale(Vec3::splat(0.5)),

From 4899d2f59761347a6c082b349471885454d1ebf3 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 21:00:05 +0200
Subject: [PATCH 24/27] Fix duplicate on_add logic

---
 src/game/physics.rs | 27 +++++++++------------------
 1 file changed, 9 insertions(+), 18 deletions(-)

diff --git a/src/game/physics.rs b/src/game/physics.rs
index 88591c16..14f58599 100644
--- a/src/game/physics.rs
+++ b/src/game/physics.rs
@@ -8,8 +8,7 @@ use bevy::{
 pub(super) fn plugin(app: &mut App) {
     // `FixedUpdate` runs before `Update`, so the physics simulation is advanced
     // before the player's visual representation is updated.
-    app.add_systems(FixedUpdate, advance_physics)
-        .observe(on_add_physical_transform);
+    app.add_systems(FixedUpdate, advance_physics);
 }
 
 /// How many units per second the player should move.
@@ -32,22 +31,10 @@ pub(crate) struct PhysicalTransform(pub(crate) Transform);
 #[derive(Debug, Component, Clone, Copy, PartialEq, Default, Deref, DerefMut)]
 pub(crate) struct PreviousPhysicalTransform(pub(crate) Transform);
 
-/// Make sure that [`PhysicalTransform`] is always initialized
-/// with the same value as the [`Transform`] and add a
-/// [`PreviousPhysicalTransform`]
-fn on_add_physical_transform(
-    trigger: Trigger<OnAdd, PhysicalTransform>,
-    mut commands: Commands,
-    mut query: Query<(&mut PhysicalTransform, &Transform)>,
-) {
-    let entity = trigger.entity();
-    let (mut physical_transform, &initial_transform) = query.get_mut(entity).unwrap();
-    physical_transform.0 = initial_transform;
-    commands
-        .entity(entity)
-        .insert(PreviousPhysicalTransform(initial_transform));
-}
-
+/// When adding a [`PhysicalTransform`]:
+/// - make sure it is always initialized with the same value as the
+///   [`Transform`]
+/// - add a [`PreviousPhysicalTransform`] as well
 impl Component for PhysicalTransform {
     const STORAGE_TYPE: StorageType = StorageType::Table;
 
@@ -56,6 +43,10 @@ impl Component for PhysicalTransform {
             let rendered_transform = *world.get::<Transform>(entity).unwrap();
             let mut physical_transform = world.get_mut::<PhysicalTransform>(entity).unwrap();
             physical_transform.0 = rendered_transform;
+            world
+                .commands()
+                .entity(entity)
+                .insert(PreviousPhysicalTransform(rendered_transform));
         });
     }
 }

From 91768564b5b965e68215e798bf7e9e5c87f9aad8 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 21:04:45 +0200
Subject: [PATCH 25/27] Fix missing system set

---
 src/game/mod.rs      | 12 +++++++++---
 src/game/movement.rs |  7 +++++--
 src/game/render.rs   |  7 +++++--
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/game/mod.rs b/src/game/mod.rs
index c40679d6..c53c9ea8 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -13,8 +13,10 @@ mod render;
 pub(crate) mod spawn;
 
 pub(super) fn plugin(app: &mut App) {
-    app.configure_sets(Update, GameSystem::Movement);
-
+    app.configure_sets(
+        Update,
+        (GameSystem::ReadInput, GameSystem::Movement).chain(),
+    );
     app.add_plugins((
         movement::plugin,
         physics::plugin,
@@ -25,5 +27,9 @@ pub(super) fn plugin(app: &mut App) {
 
 #[derive(Debug, SystemSet, Clone, Copy, Eq, PartialEq, Hash)]
 enum GameSystem {
-    Movement,
+    /// Reads input from the player.
+    ReadInput,
+    /// Updates the [`Transform`] of entities based on their
+    /// [`physics::PhysicalTransform`].
+    UpdateTransform,
 }
diff --git a/src/game/movement.rs b/src/game/movement.rs
index 8effe2ba..6e2597e3 100644
--- a/src/game/movement.rs
+++ b/src/game/movement.rs
@@ -2,10 +2,13 @@
 
 use bevy::prelude::*;
 
-use super::{physics::Velocity, spawn::player::Player};
+use super::{physics::Velocity, spawn::player::Player, GameSystem};
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Update, handle_player_movement_input);
+    app.add_systems(
+        Update,
+        handle_player_movement_input.in_set(GameSystem::ReadInput),
+    );
 }
 
 /// Handle keyboard input to move the player.
diff --git a/src/game/render.rs b/src/game/render.rs
index f85b58e8..ec11718c 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -2,10 +2,13 @@
 
 use bevy::prelude::*;
 
-use super::physics::{PhysicalTransform, PreviousPhysicalTransform};
+use super::{physics::{PhysicalTransform, PreviousPhysicalTransform}, GameSystem};
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Update, update_rendered_transform);
+    app.add_systems(
+        Update,
+        update_rendered_transform.in_set(GameSystem::UpdateTransform),
+    );
 }
 
 /// Interpolate between the previous and current physical translation to get a

From 88a15dd333f0bcf9bc009c64c79e842db7990529 Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 21:05:31 +0200
Subject: [PATCH 26/27] Fix order

---
 src/game/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/game/mod.rs b/src/game/mod.rs
index c53c9ea8..62277d64 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -15,7 +15,7 @@ pub(crate) mod spawn;
 pub(super) fn plugin(app: &mut App) {
     app.configure_sets(
         Update,
-        (GameSystem::ReadInput, GameSystem::Movement).chain(),
+        (GameSystem::UpdateTransform, GameSystem::ReadInput).chain(),
     );
     app.add_plugins((
         movement::plugin,
@@ -27,9 +27,9 @@ pub(super) fn plugin(app: &mut App) {
 
 #[derive(Debug, SystemSet, Clone, Copy, Eq, PartialEq, Hash)]
 enum GameSystem {
-    /// Reads input from the player.
-    ReadInput,
     /// Updates the [`Transform`] of entities based on their
     /// [`physics::PhysicalTransform`].
     UpdateTransform,
+    /// Reads input from the player.
+    ReadInput,
 }

From 7db0c67d1a76f3c476ffa5d44622802842cb32ab Mon Sep 17 00:00:00 2001
From: Jan Hohenheim <jan@hohenheim.ch>
Date: Mon, 8 Jul 2024 21:06:25 +0200
Subject: [PATCH 27/27] Run cargo fmt

---
 src/game/render.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/game/render.rs b/src/game/render.rs
index ec11718c..9367089b 100644
--- a/src/game/render.rs
+++ b/src/game/render.rs
@@ -2,7 +2,10 @@
 
 use bevy::prelude::*;
 
-use super::{physics::{PhysicalTransform, PreviousPhysicalTransform}, GameSystem};
+use super::{
+    physics::{PhysicalTransform, PreviousPhysicalTransform},
+    GameSystem,
+};
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(