Add player movement code

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

src/game/mod.rs

@@ -1,7 +1,29 @@
 //! Game mechanics and content.
+//!
+//! 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::*;
 
+mod movement;
+mod physics;
+mod render;
+pub(crate) mod spawn;
+
 pub(super) fn plugin(app: &mut App) {
-    let _ = app;
+    app.configure_sets(Update, GameSystem::Movement);
+
+    app.add_plugins((
+        movement::plugin,
+        physics::plugin,
+        render::plugin,
+        spawn::plugin,
+    ));
+}
+
+#[derive(Debug, SystemSet, Clone, Copy, Eq, PartialEq, Hash)]
+enum GameSystem {
+    Movement,
 }

src/game/movement.rs

@@ -0,0 +1,38 @@
+//! Handle player input and translate it into velocity.
+
+use bevy::prelude::*;
+
+use super::physics::Velocity;
+
+pub(super) fn plugin(app: &mut App) {
+    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
+    /// 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;
+
+        if keyboard_input.pressed(KeyCode::KeyW) {
+            velocity.y += SPEED;
+        }
+        if keyboard_input.pressed(KeyCode::KeyS) {
+            velocity.y -= SPEED;
+        }
+        if keyboard_input.pressed(KeyCode::KeyA) {
+            velocity.x -= SPEED;
+        }
+        if keyboard_input.pressed(KeyCode::KeyD) {
+            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;
+    }
+}

src/game/physics.rs

@@ -0,0 +1,50 @@
+//! Run a very simple physics simulation.
+
+use bevy::{
+    ecs::component::{ComponentHooks, StorageType},
+    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 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);
+
+/// 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.
+///
+/// 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 PhysicalTransform, &Velocity)>,
+) {
+    for (mut physical_transform, velocity) in query.iter_mut() {
+        physical_transform.translation += velocity.0 * fixed_time.delta_seconds();
+    }
+}

src/game/render.rs

@@ -0,0 +1,26 @@
+//! Handle how the physically simulated world should be rendered.
+
+use bevy::prelude::*;
+
+use super::physics::PhysicalTransform;
+
+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, &PhysicalTransform)>,
+) {
+    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, alpha);
+
+        transform.translation = next_rendered_translation;
+    }
+}

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);
+}

src/game/spawn/mod.rs

@@ -0,0 +1,12 @@
+//! 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::*;
+
+pub(crate) mod level;
+mod player;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins((level::plugin, player::plugin));
+}

src/game/spawn/player.rs

@@ -0,0 +1,36 @@
+//! Spawn the player.
+
+use bevy::prelude::*;
+
+use crate::{
+    game::physics::{PhysicalTransform, Velocity},
+    screen::Screen,
+};
+
+#[derive(Debug, Event)]
+pub(crate) struct SpawnPlayer;
+
+pub(super) fn plugin(app: &mut App) {
+    app.observe(spawn_player);
+}
+
+fn spawn_player(
+    _trigger: Trigger<SpawnPlayer>,
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    commands.spawn((
+        Name::new("Player"),
+        SpriteBundle {
+            texture: asset_server.load("ducky.png"),
+            transform: Transform::from_scale(Vec3::splat(0.4)),
+            ..Default::default()
+        },
+        Velocity::default(),
+        // 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),
+    ));
+}

src/screen/playing.rs

@@ -3,6 +3,7 @@
 use bevy::{input::common_conditions::input_just_pressed, prelude::*};
 
 use super::Screen;
+use crate::game::spawn::level::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.