From 3876c58a25ed1cb4afebe804ff1590204992575a Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 11:44:42 +0100
Subject: [PATCH 1/7] wip: basic climbing slopes

---
 assets/blender_src/fun_shooter.blend  |   2 +-
 assets/blender_src/fun_shooter.blend1 |   2 +-
 src/character_controller/mod.rs       | 112 ++++++++++++++++++++++++++
 src/enemy/spawn/mod.rs                |   4 +-
 src/kinematic_controller/mod.rs       |  95 ----------------------
 src/main.rs                           |   8 +-
 src/nav_mesh_pathfinding/mod.rs       |  58 ++++++-------
 src/player/movement/mod.rs            |  57 ++++++++-----
 src/player/spawn/mod.rs               |   4 +-
 9 files changed, 188 insertions(+), 154 deletions(-)
 create mode 100644 src/character_controller/mod.rs
 delete mode 100644 src/kinematic_controller/mod.rs

diff --git a/assets/blender_src/fun_shooter.blend b/assets/blender_src/fun_shooter.blend
index 3a58104..0d3b466 100644
--- a/assets/blender_src/fun_shooter.blend
+++ b/assets/blender_src/fun_shooter.blend
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:13cd38a7fba85aa1fd7c3825d2203ea436e47d24eb3d327b4c9632a43e72b955
+oid sha256:794adc3aa328ac508bba89c4a02a95732c83528f67243eb6a8474c67899da195
 size 109793554
diff --git a/assets/blender_src/fun_shooter.blend1 b/assets/blender_src/fun_shooter.blend1
index 019340b..3a58104 100644
--- a/assets/blender_src/fun_shooter.blend1
+++ b/assets/blender_src/fun_shooter.blend1
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c1eb5795fcfd04457b198ba49b9d066fe9719445eb575cd571e7417163a7c93
+oid sha256:13cd38a7fba85aa1fd7c3825d2203ea436e47d24eb3d327b4c9632a43e72b955
 size 109793554
diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
new file mode 100644
index 0000000..e396e1c
--- /dev/null
+++ b/src/character_controller/mod.rs
@@ -0,0 +1,112 @@
+use avian3d::prelude::*;
+use bevy::prelude::*;
+
+use crate::GRAVITY;
+
+const CAPSULE_RADIUS: f32 = 0.2;
+const CAPSULE_LENGTH: f32 = 1.3;
+
+/// Contains all needed components for a character that should be controlled by the player
+#[derive(Bundle)]
+pub struct CharacterControllerBundle {
+    velocity: LinearVelocity,
+    rigid_body: RigidBody,
+    collider: Collider,
+    grounded: Grounded,
+    locked_axes: LockedAxes,
+}
+
+impl Default for CharacterControllerBundle {
+    fn default() -> Self {
+        Self {
+            velocity: LinearVelocity::ZERO,
+            rigid_body: RigidBody::Kinematic,
+            collider: Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
+            grounded: Grounded::default(),
+            locked_axes: LockedAxes::new()
+                .lock_rotation_x()
+                .lock_rotation_y()
+                .lock_rotation_z(),
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct Grounded(pub bool);
+
+impl Default for Grounded {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
+pub struct CharacterControllerPlugin;
+
+impl Plugin for CharacterControllerPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, (update_on_ground, apply_gravity_over_time));
+    }
+}
+
+fn update_on_ground(
+    query: Query<(&Transform, Entity, &mut LinearVelocity, &mut Grounded)>,
+    spatial_query: SpatialQuery,
+) {
+    for (transform, entity, mut velocity, mut grounded) in query {
+        let on_ground = spatial_query
+            .cast_shape(
+                &Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
+                transform.translation,
+                transform.rotation,
+                Dir3::NEG_Y,
+                &ShapeCastConfig {
+                    max_distance: 0.1,
+                    ..default()
+                },
+                &SpatialQueryFilter::default().with_excluded_entities([entity]),
+            )
+            .is_some();
+        if grounded.0 != on_ground {
+            grounded.0 = on_ground;
+        }
+
+        if on_ground && velocity.y <= 0.0 {
+            velocity.y = 0.0;
+        }
+    }
+}
+
+fn apply_gravity_over_time(
+    query: Query<(&Grounded, &mut LinearVelocity)>,
+    time: Res<Time>,
+) {
+    for (grounded, mut velocity) in query {
+        if !grounded.0 {
+            velocity.y -= GRAVITY * time.delta_secs();
+        }
+    }
+}
+
+fn check_shape_hit_ahead(
+    spatial_query: SpatialQuery,
+    shape: &Collider,
+    origin: Vec3,
+    shape_rotation: Quat,
+    direction: Dir3,
+    excluded_entities: Vec<Entity>,
+) -> bool {
+    spatial_query
+        .cast_shape(
+            shape,
+            origin,
+            shape_rotation,
+            direction,
+            &ShapeCastConfig {
+                max_distance: 0.2,
+                ..default()
+            },
+            &SpatialQueryFilter::default()
+                .with_excluded_entities(excluded_entities),
+        )
+        .is_some()
+}
diff --git a/src/enemy/spawn/mod.rs b/src/enemy/spawn/mod.rs
index 9626df6..0f2d13c 100644
--- a/src/enemy/spawn/mod.rs
+++ b/src/enemy/spawn/mod.rs
@@ -1,9 +1,9 @@
 use crate::{
+    character_controller::Grounded,
     enemy::{
         animate::ENEMY_MODEL_PATH,
         shooting::components::EnemyShootPlayerCooldownTimer,
     },
-    kinematic_controller::KinematicController,
     nav_mesh_pathfinding::{ArchipelagoRef, ENEMY_AGENT_RADIUS},
     player::spawn::{PLAYER_CAPSULE_LENGTH, PLAYER_CAPSULE_RADIUS},
 };
@@ -131,7 +131,7 @@ fn handle_spawn_enemies_at_enemy_spawn_locations_message(
                                 health: 100.0,
                                 ..default()
                             },
-                            KinematicController::default(),
+                            Grounded::default(),
                             EnemyShootPlayerCooldownTimer(Timer::from_seconds(
                                 0.5,
                                 TimerMode::Repeating,
diff --git a/src/kinematic_controller/mod.rs b/src/kinematic_controller/mod.rs
deleted file mode 100644
index ac7f8c8..0000000
--- a/src/kinematic_controller/mod.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use avian3d::prelude::*;
-use bevy::prelude::*;
-
-use crate::GRAVITY;
-
-const CAPSULE_RADIUS: f32 = 0.2;
-const CAPSULE_LENGTH: f32 = 1.3;
-
-#[derive(Component)]
-pub struct KinematicController {
-    pub on_ground: bool,
-}
-
-impl Default for KinematicController {
-    fn default() -> Self {
-        Self { on_ground: true }
-    }
-}
-
-pub struct KinematicControllerPlugin;
-
-impl Plugin for KinematicControllerPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(
-            Update,
-            (
-                add_required_components_for_kinematic_controllers,
-                update_on_ground,
-                apply_gravity_over_time,
-            ),
-        );
-    }
-}
-
-fn add_required_components_for_kinematic_controllers(
-    mut commands: Commands,
-    query: Query<Entity, Added<KinematicController>>,
-) {
-    for entity in query {
-        commands.entity(entity).insert((
-            RigidBody::Kinematic,
-            LockedAxes::new()
-                .lock_rotation_x()
-                .lock_rotation_y()
-                .lock_rotation_z(),
-            Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
-            LinearVelocity::ZERO,
-            CollidingEntities::default(),
-        ));
-    }
-}
-
-fn update_on_ground(
-    query: Query<(
-        &Transform,
-        Entity,
-        &mut LinearVelocity,
-        &mut KinematicController,
-    )>,
-    spatial_query: SpatialQuery,
-) {
-    for (transform, entity, mut velocity, mut kinematic_controller) in query {
-        let on_ground = spatial_query
-            .cast_shape(
-                &Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
-                transform.translation,
-                transform.rotation,
-                Dir3::NEG_Y,
-                &ShapeCastConfig {
-                    max_distance: 0.1,
-                    ..default()
-                },
-                &SpatialQueryFilter::default().with_excluded_entities([entity]),
-            )
-            .is_some();
-        if kinematic_controller.on_ground != on_ground {
-            kinematic_controller.on_ground = on_ground;
-        }
-
-        if on_ground && velocity.y <= 0.0 {
-            velocity.y = 0.0;
-        }
-    }
-}
-
-fn apply_gravity_over_time(
-    query: Query<(&KinematicController, &mut LinearVelocity)>,
-    time: Res<Time>,
-) {
-    for (kinematic_controller, mut velocity) in query {
-        if !kinematic_controller.on_ground {
-            velocity.y -= GRAVITY * time.delta_secs();
-        }
-    }
-}
diff --git a/src/main.rs b/src/main.rs
index cbd2f99..5fa2fbe 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,16 +8,16 @@ use bevy_inspector_egui::{
 use bevy_skein::SkeinPlugin;
 
 use crate::{
-    enemy::EnemyPlugin, game_flow::GameFlowPlugin,
-    kinematic_controller::KinematicControllerPlugin, music::MusicPlugin,
+    character_controller::CharacterControllerPlugin, enemy::EnemyPlugin,
+    game_flow::GameFlowPlugin, music::MusicPlugin,
     nav_mesh_pathfinding::NavMeshPathfindingPlugin, particles::ParticlesPlugin,
     player::PlayerPlugin, shared::CommonPlugin,
     user_interface::UserInterfacePlugin, world::WorldPlugin,
 };
 
+mod character_controller;
 mod enemy;
 mod game_flow;
-mod kinematic_controller;
 mod music;
 mod nav_mesh_pathfinding;
 mod particles;
@@ -82,7 +82,7 @@ fn main() {
         .add_plugins(ParticlesPlugin)
         .add_plugins(MusicPlugin)
         .add_plugins(NavMeshPathfindingPlugin)
-        .add_plugins(KinematicControllerPlugin);
+        .add_plugins(CharacterControllerPlugin);
 
     app.run();
 }
diff --git a/src/nav_mesh_pathfinding/mod.rs b/src/nav_mesh_pathfinding/mod.rs
index 3833dad..b76f54c 100644
--- a/src/nav_mesh_pathfinding/mod.rs
+++ b/src/nav_mesh_pathfinding/mod.rs
@@ -1,13 +1,11 @@
 use avian_rerecast::AvianBackendPlugin;
 use bevy::prelude::*;
-use bevy_landmass::prelude::*;
+use bevy_landmass::{debug::Landmass3dDebugPlugin, prelude::*};
 use bevy_rerecast::{debug::DetailNavmeshGizmo, prelude::*};
 use landmass_rerecast::{
     Island3dBundle, LandmassRerecastPlugin, NavMeshHandle3d,
 };
 
-use crate::game_flow::states::GameLoadingState;
-
 pub const ENEMY_AGENT_RADIUS: f32 = 0.3;
 
 pub struct NavMeshPathfindingPlugin;
@@ -18,11 +16,8 @@ impl Plugin for NavMeshPathfindingPlugin {
         app.add_plugins(NavmeshPlugins::default());
         app.add_plugins(Landmass3dPlugin::default());
         app.add_plugins(LandmassRerecastPlugin::default());
-        // app.add_plugins(Landmass3dDebugPlugin::default());
-        app.add_systems(
-            OnEnter(GameLoadingState::WorldLoadedWithDependencies),
-            generate_navmesh,
-        );
+        app.add_plugins(Landmass3dDebugPlugin::default());
+        app.add_systems(Update, generate_navmesh);
         app.add_systems(Update, update_agent_velocity);
     }
 }
@@ -30,27 +25,32 @@ impl Plugin for NavMeshPathfindingPlugin {
 #[derive(Resource)]
 pub struct ArchipelagoRef(pub Entity);
 
-fn generate_navmesh(mut commands: Commands, mut generator: NavmeshGenerator) {
-    info!("Generating navmesh");
-    let archipelago_id = commands
-        .spawn(Archipelago3d::new(ArchipelagoOptions::from_agent_radius(
-            ENEMY_AGENT_RADIUS,
-        )))
-        .id();
-    commands.insert_resource(ArchipelagoRef(archipelago_id));
-
-    let navmesh = generator.generate(NavmeshSettings {
-        agent_radius: ENEMY_AGENT_RADIUS,
-        ..default()
-    });
-
-    commands.spawn(DetailNavmeshGizmo::new(&navmesh));
-
-    commands.spawn(Island3dBundle {
-        island: Island,
-        archipelago_ref: ArchipelagoRef3d::new(archipelago_id),
-        nav_mesh: NavMeshHandle3d(navmesh),
-    });
+fn generate_navmesh(
+    mut commands: Commands,
+    mut generator: NavmeshGenerator,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+) {
+    if keyboard_input.just_pressed(KeyCode::KeyO) {
+        let archipelago_id = commands
+            .spawn(Archipelago3d::new(ArchipelagoOptions::from_agent_radius(
+                ENEMY_AGENT_RADIUS,
+            )))
+            .id();
+        commands.insert_resource(ArchipelagoRef(archipelago_id));
+
+        let navmesh = generator.generate(NavmeshSettings {
+            agent_radius: ENEMY_AGENT_RADIUS,
+            ..default()
+        });
+
+        commands.spawn(DetailNavmeshGizmo::new(&navmesh));
+
+        commands.spawn(Island3dBundle {
+            island: Island,
+            archipelago_ref: ArchipelagoRef3d::new(archipelago_id),
+            nav_mesh: NavMeshHandle3d(navmesh),
+        });
+    }
 }
 
 fn update_agent_velocity(
diff --git a/src/player/movement/mod.rs b/src/player/movement/mod.rs
index 731b74e..abf9880 100644
--- a/src/player/movement/mod.rs
+++ b/src/player/movement/mod.rs
@@ -2,8 +2,8 @@ use avian3d::prelude::*;
 use bevy::prelude::*;
 
 use crate::{
+    character_controller::Grounded,
     game_flow::states::{AppState, InGameState},
-    kinematic_controller::KinematicController,
     player::{
         Player,
         animate::{ArmWithWeaponAnimation, PlayArmWithWeaponAnimationMessage},
@@ -52,7 +52,7 @@ pub fn player_movement(
         &Transform,
         &mut PlayerMovementState,
         &PlayerWeapon,
-        &KinematicController,
+        &Grounded,
     )>,
     player_camera_entity: Single<Entity, With<ViewModelCamera>>,
     spatial_query: SpatialQuery,
@@ -67,7 +67,7 @@ pub fn player_movement(
         player_transform,
         mut player_movement_state,
         player_weapon,
-        kinematic_controller,
+        grounded,
     ) = player.into_inner();
 
     let currently_playing =
@@ -107,9 +107,7 @@ pub fn player_movement(
     if keyboard_input.pressed(KeyCode::KeyS) {
         local_velocity.z += 1.0 * speed;
     }
-    if keyboard_input.just_pressed(KeyCode::Space)
-        && kinematic_controller.on_ground
-    {
+    if keyboard_input.just_pressed(KeyCode::Space) && grounded.0 {
         velocity.y = JUMP_VELOCITY;
     }
 
@@ -134,25 +132,44 @@ pub fn player_movement(
         return;
     };
 
-    if let Some(_) = spatial_query.cast_shape(
-        &Collider::capsule(PLAYER_CAPSULE_RADIUS, PLAYER_CAPSULE_LENGTH),
-        player_transform.translation - direction.as_vec3() * 0.025,
-        player_transform.rotation,
-        direction,
-        &ShapeCastConfig {
-            max_distance: 0.2,
-            ..default()
-        },
+    let mut move_dir = world_velocity;
+
+    let max_slope_angle = 45.0_f32.to_radians();
+    // raycast down to detect ground normal
+    let ray_origin = player_transform.translation + Vec3::Y * 0.5;
+    let ray_direction = Dir3::NEG_Y;
+    let max_distance = 1.0;
+    let solid = true;
+    if let Some(ground_hit) = spatial_query.cast_ray(
+        ray_origin,
+        ray_direction,
+        max_distance,
+        solid,
         &SpatialQueryFilter::default()
             .with_excluded_entities([entity, *player_camera_entity]),
     ) {
-        velocity.x = 0.0;
-        velocity.z = 0.0;
-        return;
+        info!("Got ground hit, checking if we can climb");
+
+        // a normal is just a direction something is facing
+        let normal = ground_hit.normal;
+        let slope_angle = normal.angle_between(Vec3::Y);
+        info!("slope_angle: {}", slope_angle);
+
+        if slope_angle < max_slope_angle {
+            // this is the most important part to make the slope climbing possible. instead of trying to go straight, we slide along
+            // the ground
+            move_dir = direction.reject_from(normal).normalize_or_zero();
+        } else {
+            move_dir = Vec3::ZERO;
+        }
     }
 
-    velocity.x = world_velocity.x;
-    velocity.z = world_velocity.z;
+    velocity.x = move_dir.x;
+    velocity.z = move_dir.z;
+
+    if grounded.0 {
+        velocity.y = move_dir.y;
+    }
 
     if player_weapon.reloading {
         return;
diff --git a/src/player/spawn/mod.rs b/src/player/spawn/mod.rs
index 5f572a1..d3d0205 100644
--- a/src/player/spawn/mod.rs
+++ b/src/player/spawn/mod.rs
@@ -2,7 +2,7 @@ use avian3d::prelude::*;
 use bevy::prelude::*;
 
 use crate::{
-    kinematic_controller::KinematicController,
+    character_controller::CharacterControllerBundle,
     player::{Player, spawn::components::PlayerSpawnLocation},
 };
 
@@ -39,7 +39,7 @@ fn handle_player_spawn_event(
             Transform::from_translation(event.spawn_location),
             Visibility::Visible,
             DebugRender::collider(Color::WHITE),
-            KinematicController::default(),
+            CharacterControllerBundle::default(),
         ));
     }
 }

From b62874186707f34aa15d012408ce1311ba7683fc Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 11:50:40 +0100
Subject: [PATCH 2/7] docs: update readme character controller section

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 21d8025..8d63aa8 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,8 @@
 - [ ] Player movement
   - [x] Basic movement
   - [ ] Write a proper kinematic character controller from scratch because i dont want to just copy some code
-    - this is harder than i thought... even all the examples out there have some issues
+    - [ ] Climb slopes
+    - [ ] slide along walls when going into walls instead of zeroeing velocity
 - [X] Game modes
   - [x] Wave mode (the game gets more difficult each round, e.g. more enemies are spawned)
   - [ ] Capture the flag

From 2f2988a2f1469def366b48c20773bd305a59de4a Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 12:13:03 +0100
Subject: [PATCH 3/7] feat: very basic climb slopes and slide along walls

---
 src/character_controller/mod.rs |  2 ++
 src/player/movement/mod.rs      | 47 +++++++++++++++++----------------
 2 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
index e396e1c..acb25c8 100644
--- a/src/character_controller/mod.rs
+++ b/src/character_controller/mod.rs
@@ -6,6 +6,8 @@ use crate::GRAVITY;
 const CAPSULE_RADIUS: f32 = 0.2;
 const CAPSULE_LENGTH: f32 = 1.3;
 
+pub const MAX_SLOPE_ANGLE: f32 = 45.0_f32.to_radians();
+
 /// Contains all needed components for a character that should be controlled by the player
 #[derive(Bundle)]
 pub struct CharacterControllerBundle {
diff --git a/src/player/movement/mod.rs b/src/player/movement/mod.rs
index abf9880..bfcc51e 100644
--- a/src/player/movement/mod.rs
+++ b/src/player/movement/mod.rs
@@ -2,14 +2,13 @@ use avian3d::prelude::*;
 use bevy::prelude::*;
 
 use crate::{
-    character_controller::Grounded,
+    character_controller::{Grounded, MAX_SLOPE_ANGLE},
     game_flow::states::{AppState, InGameState},
     player::{
         Player,
         animate::{ArmWithWeaponAnimation, PlayArmWithWeaponAnimationMessage},
         camera::components::ViewModelCamera,
         shooting::components::PlayerWeapon,
-        spawn::{PLAYER_CAPSULE_LENGTH, PLAYER_CAPSULE_RADIUS},
     },
     shared::{JUMP_VELOCITY, MovementState, RUN_VELOCITY, WALK_VELOCITY},
 };
@@ -128,47 +127,49 @@ pub fn player_movement(
     }
 
     let world_velocity = player_transform.rotation * local_velocity;
-    let Ok(direction) = Dir3::new(world_velocity) else {
+    let Ok(direction_from_world_velocity) = Dir3::new(world_velocity) else {
         return;
     };
 
-    let mut move_dir = world_velocity;
-
-    let max_slope_angle = 45.0_f32.to_radians();
     // raycast down to detect ground normal
-    let ray_origin = player_transform.translation + Vec3::Y * 0.5;
-    let ray_direction = Dir3::NEG_Y;
-    let max_distance = 1.0;
+    let ray_origin = player_transform.translation
+        - direction_from_world_velocity.as_vec3() * 0.025;
+    let max_distance = 0.3;
     let solid = true;
-    if let Some(ground_hit) = spatial_query.cast_ray(
+
+    if let Some(hit_ahead) = spatial_query.cast_ray(
         ray_origin,
-        ray_direction,
+        direction_from_world_velocity,
         max_distance,
         solid,
         &SpatialQueryFilter::default()
             .with_excluded_entities([entity, *player_camera_entity]),
     ) {
-        info!("Got ground hit, checking if we can climb");
+        info!("Got shape cast hit, checking if we can climb");
 
         // a normal is just a direction something is facing
-        let normal = ground_hit.normal;
+        let normal = hit_ahead.normal;
         let slope_angle = normal.angle_between(Vec3::Y);
         info!("slope_angle: {}", slope_angle);
 
-        if slope_angle < max_slope_angle {
+        let slope_climable = slope_angle < MAX_SLOPE_ANGLE;
+
+        if slope_climable {
             // this is the most important part to make the slope climbing possible. instead of trying to go straight, we slide along
             // the ground
-            move_dir = direction.reject_from(normal).normalize_or_zero();
+            velocity.0 = world_velocity.reject_from_normalized(normal);
         } else {
-            move_dir = Vec3::ZERO;
+            // not climable, e.g. a wall. we want to slide along the wall, similar to the collide
+            // and slide algorithm
+            // the main difference is that we ignore the Y part, because its too step, so we dont
+            // want to climb up
+            let impulse = world_velocity.reject_from_normalized(normal);
+            velocity.x = impulse.x;
+            velocity.z = impulse.z
         }
-    }
-
-    velocity.x = move_dir.x;
-    velocity.z = move_dir.z;
-
-    if grounded.0 {
-        velocity.y = move_dir.y;
+    } else {
+        velocity.x = world_velocity.x;
+        velocity.z = world_velocity.z;
     }
 
     if player_weapon.reloading {

From 67a17910a5ef426539ba081d088c21cfa8505388 Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 12:50:08 +0100
Subject: [PATCH 4/7] fix: snap on slopes

---
 src/character_controller/mod.rs | 38 ++++++--------------
 src/enemy/spawn/mod.rs          |  9 ++---
 src/player/movement/mod.rs      | 62 ++++++++++++++++++++++++++-------
 src/player/spawn/mod.rs         |  3 --
 src/world/collider_rules.rs     |  8 ++---
 5 files changed, 66 insertions(+), 54 deletions(-)

diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
index acb25c8..5d1b59c 100644
--- a/src/character_controller/mod.rs
+++ b/src/character_controller/mod.rs
@@ -3,8 +3,8 @@ use bevy::prelude::*;
 
 use crate::GRAVITY;
 
-const CAPSULE_RADIUS: f32 = 0.2;
-const CAPSULE_LENGTH: f32 = 1.3;
+pub const CHARACTER_CAPSULE_RADIUS: f32 = 0.2;
+pub const CHARACTER_CAPSULE_LENGTH: f32 = 1.3;
 
 pub const MAX_SLOPE_ANGLE: f32 = 45.0_f32.to_radians();
 
@@ -23,7 +23,10 @@ impl Default for CharacterControllerBundle {
         Self {
             velocity: LinearVelocity::ZERO,
             rigid_body: RigidBody::Kinematic,
-            collider: Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
+            collider: Collider::capsule(
+                CHARACTER_CAPSULE_RADIUS,
+                CHARACTER_CAPSULE_LENGTH,
+            ),
             grounded: Grounded::default(),
             locked_axes: LockedAxes::new()
                 .lock_rotation_x()
@@ -57,7 +60,10 @@ fn update_on_ground(
     for (transform, entity, mut velocity, mut grounded) in query {
         let on_ground = spatial_query
             .cast_shape(
-                &Collider::capsule(CAPSULE_RADIUS, CAPSULE_LENGTH),
+                &Collider::capsule(
+                    CHARACTER_CAPSULE_RADIUS,
+                    CHARACTER_CAPSULE_LENGTH,
+                ),
                 transform.translation,
                 transform.rotation,
                 Dir3::NEG_Y,
@@ -88,27 +94,3 @@ fn apply_gravity_over_time(
         }
     }
 }
-
-fn check_shape_hit_ahead(
-    spatial_query: SpatialQuery,
-    shape: &Collider,
-    origin: Vec3,
-    shape_rotation: Quat,
-    direction: Dir3,
-    excluded_entities: Vec<Entity>,
-) -> bool {
-    spatial_query
-        .cast_shape(
-            shape,
-            origin,
-            shape_rotation,
-            direction,
-            &ShapeCastConfig {
-                max_distance: 0.2,
-                ..default()
-            },
-            &SpatialQueryFilter::default()
-                .with_excluded_entities(excluded_entities),
-        )
-        .is_some()
-}
diff --git a/src/enemy/spawn/mod.rs b/src/enemy/spawn/mod.rs
index 0f2d13c..dd3c03c 100644
--- a/src/enemy/spawn/mod.rs
+++ b/src/enemy/spawn/mod.rs
@@ -1,11 +1,12 @@
 use crate::{
-    character_controller::Grounded,
+    character_controller::{
+        CHARACTER_CAPSULE_LENGTH, CHARACTER_CAPSULE_RADIUS, Grounded,
+    },
     enemy::{
         animate::ENEMY_MODEL_PATH,
         shooting::components::EnemyShootPlayerCooldownTimer,
     },
     nav_mesh_pathfinding::{ArchipelagoRef, ENEMY_AGENT_RADIUS},
-    player::spawn::{PLAYER_CAPSULE_LENGTH, PLAYER_CAPSULE_RADIUS},
 };
 use avian3d::math::PI;
 use bevy::prelude::*;
@@ -144,8 +145,8 @@ fn handle_spawn_enemies_at_enemy_spawn_locations_message(
                                     0.0,
                                     // center enemy model -> in blender, feet are at bottom, so in
                                     // bevy model feet are at center of collider, 0.0
-                                    -((PLAYER_CAPSULE_LENGTH
-                                        + PLAYER_CAPSULE_RADIUS * 2.0)
+                                    -((CHARACTER_CAPSULE_LENGTH
+                                        + CHARACTER_CAPSULE_RADIUS * 2.0)
                                         / 2.),
                                     0.0,
                                 ),
diff --git a/src/player/movement/mod.rs b/src/player/movement/mod.rs
index bfcc51e..6fde3e3 100644
--- a/src/player/movement/mod.rs
+++ b/src/player/movement/mod.rs
@@ -2,7 +2,10 @@ use avian3d::prelude::*;
 use bevy::prelude::*;
 
 use crate::{
-    character_controller::{Grounded, MAX_SLOPE_ANGLE},
+    character_controller::{
+        CHARACTER_CAPSULE_LENGTH, CHARACTER_CAPSULE_RADIUS, Grounded,
+        MAX_SLOPE_ANGLE,
+    },
     game_flow::states::{AppState, InGameState},
     player::{
         Player,
@@ -59,6 +62,7 @@ pub fn player_movement(
     mut play_player_arm_weapon_animation_message_writer: MessageWriter<
         PlayArmWithWeaponAnimationMessage,
     >,
+    time: Res<Time>,
 ) {
     let (
         entity,
@@ -131,34 +135,64 @@ pub fn player_movement(
         return;
     };
 
-    // raycast down to detect ground normal
     let ray_origin = player_transform.translation
         - direction_from_world_velocity.as_vec3() * 0.025;
     let max_distance = 0.3;
-    let solid = true;
 
-    if let Some(hit_ahead) = spatial_query.cast_ray(
+    if let Some(hit_ahead) = spatial_query.cast_shape(
+        &Collider::capsule(CHARACTER_CAPSULE_RADIUS, CHARACTER_CAPSULE_LENGTH),
         ray_origin,
+        player_transform.rotation,
         direction_from_world_velocity,
-        max_distance,
-        solid,
+        &ShapeCastConfig {
+            max_distance,
+            ..default()
+        },
         &SpatialQueryFilter::default()
             .with_excluded_entities([entity, *player_camera_entity]),
     ) {
-        info!("Got shape cast hit, checking if we can climb");
-
+        // obstacle in the way, check if we can slimb it
         // a normal is just a direction something is facing
-        let normal = hit_ahead.normal;
+        let normal = hit_ahead.normal1;
         let slope_angle = normal.angle_between(Vec3::Y);
-        info!("slope_angle: {}", slope_angle);
-
         let slope_climable = slope_angle < MAX_SLOPE_ANGLE;
 
         if slope_climable {
-            // this is the most important part to make the slope climbing possible. instead of trying to go straight, we slide along
-            // the ground
+            info!("MOVEMENT: Climable slope!");
+            // this is the most important part to make the slope climbing possible.
+            // instead of trying to go straight, we slide along the ground
             velocity.0 = world_velocity.reject_from_normalized(normal);
+
+            // slope snapping
+            let ray_down_origin = player_transform.translation + Vec3::Y * 0.5;
+            let ray_down_direction = Dir3::NEG_Y;
+            let max_down_distance = 1.0;
+
+            if let Some(hit_down) = spatial_query.cast_ray(
+                ray_down_origin,
+                ray_down_direction,
+                max_down_distance,
+                true,
+                &SpatialQueryFilter::default()
+                    .with_excluded_entities([entity, *player_camera_entity]),
+            ) {
+                let hit_down_point =
+                    ray_down_origin + ray_down_direction * hit_down.distance;
+                let ground_y = hit_down_point.y;
+                let current_y = player_transform.translation.y;
+                let diff_y = ground_y - current_y;
+                if diff_y.abs() < 0.3 {
+                    let res = diff_y / time.delta_secs();
+                    info!(
+                        "MOVEMENT: y velocity needs to be adjusted, setting \
+                         to: {}",
+                        res
+                    );
+                    velocity.y = res;
+                }
+            }
         } else {
+            info!("MOVEMENT: Obstacle in the way, sliding along wall");
             // not climable, e.g. a wall. we want to slide along the wall, similar to the collide
             // and slide algorithm
             // the main difference is that we ignore the Y part, because its too step, so we dont
@@ -168,6 +202,8 @@ pub fn player_movement(
             velocity.z = impulse.z
         }
     } else {
+        info!("MOVEMENT: No obstacle ahead, free movement");
+        // no obstacle ahead, free movement
         velocity.x = world_velocity.x;
         velocity.z = world_velocity.z;
     }
diff --git a/src/player/spawn/mod.rs b/src/player/spawn/mod.rs
index d3d0205..808b84f 100644
--- a/src/player/spawn/mod.rs
+++ b/src/player/spawn/mod.rs
@@ -8,9 +8,6 @@ use crate::{
 
 pub mod components;
 
-pub const PLAYER_CAPSULE_RADIUS: f32 = 0.2;
-pub const PLAYER_CAPSULE_LENGTH: f32 = 1.4;
-
 pub struct PlayerSpawnPlugin;
 
 impl Plugin for PlayerSpawnPlugin {
diff --git a/src/world/collider_rules.rs b/src/world/collider_rules.rs
index f726d08..346140b 100644
--- a/src/world/collider_rules.rs
+++ b/src/world/collider_rules.rs
@@ -1,5 +1,7 @@
 use avian3d::prelude::ColliderConstructor;
 
+// TODO: validate the collider rules, e.g. whether these Names actually exist and have a mesh
+// defined
 // NOTE:
 // To get the correct name to use here when inspecting entities in Blender:
 // Must be the actual Mesh, e.g. the green triangle, followed by a dot, and then the
@@ -43,9 +45,3 @@ pub fn get_collider_rules_for_medium_map()
         ),
     ]
 }
-
-// TODO: validate the collider rules, e.g. whether these Names actually exist and have a mesh
-// defined
-pub fn validate_collider_rules() {
-    todo!()
-}

From e0fe767ecb16acaabf797a4b178438925c637be6 Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 14:10:54 +0100
Subject: [PATCH 5/7] refactor: move player movement into character controller

---
 src/character_controller/mod.rs     | 192 ++++++++++++++++++++-
 src/player/animate/mod.rs           |  98 +++++++++++
 src/player/mod.rs                   |   3 -
 src/player/movement/mod.rs          | 249 ----------------------------
 src/player/shooting/mod.rs          |   6 +-
 src/player/shooting/systems.rs      |  22 +--
 src/shared/mod.rs                   |  11 --
 src/user_interface/debug_overlay.rs |  29 ++--
 8 files changed, 316 insertions(+), 294 deletions(-)
 delete mode 100644 src/player/movement/mod.rs

diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
index 5d1b59c..436b8ce 100644
--- a/src/character_controller/mod.rs
+++ b/src/character_controller/mod.rs
@@ -1,13 +1,41 @@
 use avian3d::prelude::*;
 use bevy::prelude::*;
 
-use crate::GRAVITY;
+use crate::{
+    GRAVITY,
+    player::{Player, camera::components::ViewModelCamera},
+};
 
 pub const CHARACTER_CAPSULE_RADIUS: f32 = 0.2;
 pub const CHARACTER_CAPSULE_LENGTH: f32 = 1.3;
 
+pub const WALK_VELOCITY: f32 = 2.0;
+pub const RUN_VELOCITY: f32 = 5.0;
+pub const JUMP_VELOCITY: f32 = 3.0;
+
 pub const MAX_SLOPE_ANGLE: f32 = 45.0_f32.to_radians();
 
+// NOTE: So far this character controller is only for the player. The code needs a bit of
+// adjustment to be able to support using it for enemies. But I guess we also don't really need a
+// character controller for enemies.
+
+#[derive(Component)]
+pub struct MovementState(MovementStateEnum);
+
+#[derive(Debug, Reflect, PartialEq)]
+pub enum MovementStateEnum {
+    Idle,
+    Walking,
+    Running,
+}
+
+#[derive(Message)]
+pub enum MovementAction {
+    // TODO: should be possible to just have Vec3
+    Move(Vec3),
+    Jump,
+}
+
 /// Contains all needed components for a character that should be controlled by the player
 #[derive(Bundle)]
 pub struct CharacterControllerBundle {
@@ -16,6 +44,7 @@ pub struct CharacterControllerBundle {
     collider: Collider,
     grounded: Grounded,
     locked_axes: LockedAxes,
+    movement_state: MovementState,
 }
 
 impl Default for CharacterControllerBundle {
@@ -32,6 +61,7 @@ impl Default for CharacterControllerBundle {
                 .lock_rotation_x()
                 .lock_rotation_y()
                 .lock_rotation_z(),
+            movement_state: MovementState(MovementStateEnum::Idle),
         }
     }
 }
@@ -49,7 +79,165 @@ pub struct CharacterControllerPlugin;
 
 impl Plugin for CharacterControllerPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, (update_on_ground, apply_gravity_over_time));
+        app.add_message::<MovementAction>().add_systems(
+            Update,
+            (
+                update_on_ground,
+                apply_gravity_over_time,
+                handle_keyboard_input_for_player,
+                handle_movement_actions_for_player,
+            ),
+        );
+    }
+}
+
+fn handle_keyboard_input_for_player(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut movement_action_writer: MessageWriter<MovementAction>,
+    player_transform: Single<&Transform, With<Player>>,
+) {
+    let speed = if keyboard_input.pressed(KeyCode::ShiftLeft) {
+        RUN_VELOCITY
+    } else {
+        WALK_VELOCITY
+    };
+
+    let mut local_velocity = Vec3::ZERO;
+
+    if keyboard_input.pressed(KeyCode::KeyW) {
+        local_velocity.z -= 1.0 * speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyA) {
+        local_velocity.x -= 1.0 * speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyD) {
+        local_velocity.x += 1.0 * speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyS) {
+        local_velocity.z += 1.0 * speed;
+    }
+
+    let world_velocity = player_transform.rotation * local_velocity;
+
+    movement_action_writer.write(MovementAction::Move(world_velocity));
+
+    if keyboard_input.just_pressed(KeyCode::Space) {
+        movement_action_writer.write(MovementAction::Jump);
+    }
+}
+
+fn handle_movement_actions_for_player(
+    mut movement_action_reader: MessageReader<MovementAction>,
+    player_query: Single<
+        (&mut LinearVelocity, &Grounded, &Transform, Entity),
+        With<Player>,
+    >,
+    player_camera_entity: Single<Entity, With<ViewModelCamera>>,
+    spatial_query: SpatialQuery,
+    time: Res<Time>,
+) {
+    let (mut player_velocity, player_grounded, player_transform, player_entity) =
+        player_query.into_inner();
+    for movement_action in movement_action_reader.read() {
+        match movement_action {
+            MovementAction::Jump => {
+                if player_grounded.0 {
+                    player_velocity.y = JUMP_VELOCITY;
+                }
+            }
+            // TODO: should probably move the content of this block elsewhere
+            MovementAction::Move(world_velocity) => {
+                let Ok(direction_from_world_velocity) =
+                    Dir3::new(*world_velocity)
+                else {
+                    player_velocity.x = 0.0;
+                    player_velocity.z = 0.0;
+                    return;
+                };
+
+                let ray_origin = player_transform.translation
+                    - direction_from_world_velocity.as_vec3() * 0.025;
+                let max_distance = 0.3;
+
+                if let Some(hit_ahead) = spatial_query.cast_shape(
+                    &Collider::capsule(
+                        CHARACTER_CAPSULE_RADIUS,
+                        CHARACTER_CAPSULE_LENGTH,
+                    ),
+                    ray_origin,
+                    player_transform.rotation,
+                    direction_from_world_velocity,
+                    &ShapeCastConfig {
+                        max_distance,
+                        ..default()
+                    },
+                    &SpatialQueryFilter::default().with_excluded_entities([
+                        player_entity,
+                        *player_camera_entity,
+                    ]),
+                ) {
+                    // obstacle in the way, check if we can slimb it
+                    // a normal is just a direction something is facing
+                    let normal = hit_ahead.normal1;
+                    let slope_angle = normal.angle_between(Vec3::Y);
+                    let slope_climable = slope_angle < MAX_SLOPE_ANGLE;
+
+                    if slope_climable {
+                        debug!("MOVEMENT: Climable slope!");
+                        // this is the most important part to make the slope climbing possible.
+                        // instead of trying to go straight, we slide along the ground
+                        player_velocity.0 =
+                            world_velocity.reject_from_normalized(normal);
+
+                        // slope snapping
+                        let ray_down_origin =
+                            player_transform.translation + Vec3::Y * 0.5;
+                        let ray_down_direction = Dir3::NEG_Y;
+                        let max_down_distance = 1.0;
+
+                        if let Some(hit_down) = spatial_query.cast_ray(
+                            ray_down_origin,
+                            ray_down_direction,
+                            max_down_distance,
+                            true,
+                            &SpatialQueryFilter::default()
+                                .with_excluded_entities([
+                                    player_entity,
+                                    *player_camera_entity,
+                                ]),
+                        ) {
+                            let hit_down_point = ray_down_origin
+                                + ray_down_direction * hit_down.distance;
+                            let hit_down_y = hit_down_point.y;
+                            let player_y = player_transform.translation.y;
+                            let difference_y = hit_down_y - player_y;
+                            if difference_y.abs() < 0.3 {
+                                debug!("Snapping player to slope");
+                                player_velocity.y =
+                                    difference_y / time.delta_secs();
+                            }
+                        }
+                    } else {
+                        debug!(
+                            "MOVEMENT: Obstacle in the way, sliding along wall"
+                        );
+                        // not climable, e.g. a wall. we want to slide along the wall, similar to the collide
+                        // and slide algorithm
+                        // the main difference is that we ignore the Y part, because its too step, so we dont
+                        // want to climb up
+                        let impulse =
+                            world_velocity.reject_from_normalized(normal);
+                        player_velocity.x = impulse.x;
+                        player_velocity.z = impulse.z
+                    }
+                } else {
+                    debug!("MOVEMENT: No obstacle ahead, free movement");
+                    // no obstacle ahead, free movement
+                    player_velocity.x = world_velocity.x;
+                    player_velocity.z = world_velocity.z;
+                }
+            }
+        }
     }
 }
 
diff --git a/src/player/animate/mod.rs b/src/player/animate/mod.rs
index 604ccc0..5188271 100644
--- a/src/player/animate/mod.rs
+++ b/src/player/animate/mod.rs
@@ -264,3 +264,101 @@ fn get_animation_duration_for_animation_type(
         ArmWithWeaponAnimation::FullReload => 3.65,
     }
 }
+
+// FIXME:
+// pub fn use_me(
+//     player: Single<(
+//         Entity,
+//         &mut LinearVelocity,
+//         &Transform,
+//         &mut PlayerMovementState,
+//         &PlayerWeapon,
+//         &Grounded,
+//     )>,
+//     current_in_game_state: Res<State<InGameState>>,
+//     mut play_player_arm_weapon_animation_message_writer: MessageWriter<
+//         PlayArmWithWeaponAnimationMessage,
+//     >,
+// ) {
+//     let (
+//         entity,
+//         mut velocity,
+//         player_transform,
+//         mut player_movement_state,
+//         player_weapon,
+//         grounded,
+//     ) = player.into_inner();
+//
+//     let currently_playing =
+//         *current_in_game_state.get() == InGameState::Playing;
+//     if !currently_playing {
+//         **velocity = Vec3::ZERO;
+//         if player_movement_state.0 != MovementState::Idle {
+//             player_movement_state.0 = MovementState::Idle;
+//             play_player_arm_weapon_animation_message_writer.write(
+//                 PlayArmWithWeaponAnimationMessage {
+//                     animation_type: ArmWithWeaponAnimation::Idle,
+//                     repeat: true,
+//                     block_until_done: false,
+//                 },
+//             );
+//         }
+//         return;
+//     }
+//
+//     // FIXME: this all below of this function needs to go into player/animate
+//     // if local_velocity == Vec3::ZERO {
+//     //     velocity.x = 0.0;
+//     //     velocity.z = 0.0;
+//     //     if player_movement_state.0 != MovementState::Idle {
+//     //         player_movement_state.0 = MovementState::Idle;
+//     //         play_player_arm_weapon_animation_message_writer.write(
+//     //             PlayArmWithWeaponAnimationMessage {
+//     //                 animation_type: ArmWithWeaponAnimation::Idle,
+//     //                 repeat: true,
+//     //                 block_until_done: false,
+//     //             },
+//     //         );
+//     //     };
+//     //     return;
+//     // }
+//
+//     // if player_weapon.reloading {
+//     //     return;
+//     // }
+//     //
+//     // if speed == RUN_VELOCITY {
+//     //     if player_movement_state.0 != MovementState::Running {
+//     //         player_movement_state.0 = MovementState::Running;
+//     //         play_player_arm_weapon_animation_message_writer.write(
+//     //             PlayArmWithWeaponAnimationMessage {
+//     //                 animation_type: ArmWithWeaponAnimation::Run,
+//     //                 repeat: true,
+//     //                 block_until_done: false,
+//     //             },
+//     //         );
+//     //     }
+//     // } else if local_velocity.x != 0.0 || local_velocity.z != 0.0 {
+//     //     if player_movement_state.0 != MovementState::Walking {
+//     //         player_movement_state.0 = MovementState::Walking;
+//     //         play_player_arm_weapon_animation_message_writer.write(
+//     //             PlayArmWithWeaponAnimationMessage {
+//     //                 animation_type: ArmWithWeaponAnimation::Walk,
+//     //                 repeat: true,
+//     //                 block_until_done: false,
+//     //             },
+//     //         );
+//     //     }
+//     // } else if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
+//     //     if player_movement_state.0 != MovementState::Idle {
+//     //         player_movement_state.0 = MovementState::Idle;
+//     //         play_player_arm_weapon_animation_message_writer.write(
+//     //             PlayArmWithWeaponAnimationMessage {
+//     //                 animation_type: ArmWithWeaponAnimation::Idle,
+//     //                 repeat: true,
+//     //                 block_until_done: false,
+//     //             },
+//     //         );
+//     //     }
+//     // }
+// }
diff --git a/src/player/mod.rs b/src/player/mod.rs
index b93ebcd..50bb229 100644
--- a/src/player/mod.rs
+++ b/src/player/mod.rs
@@ -4,7 +4,6 @@ use crate::player::{
     animate::PlayerAnimatePlugin,
     camera::{PlayerCameraPlugin, components::PlayerCameraState},
     hud::PlayerHudPlugin,
-    movement::PlayerMovementPlugin,
     shooting::PlayerShootingPlugin,
     spawn::PlayerSpawnPlugin,
 };
@@ -12,7 +11,6 @@ use crate::player::{
 mod animate;
 pub mod camera;
 mod hud;
-pub mod movement;
 pub mod shooting;
 pub mod spawn;
 
@@ -43,7 +41,6 @@ impl Plugin for PlayerPlugin {
             .add_plugins(PlayerCameraPlugin)
             .add_plugins(PlayerShootingPlugin)
             .add_plugins(PlayerHudPlugin)
-            .add_plugins(PlayerMovementPlugin)
             .add_plugins(PlayerAnimatePlugin);
     }
 }
diff --git a/src/player/movement/mod.rs b/src/player/movement/mod.rs
deleted file mode 100644
index 6fde3e3..0000000
--- a/src/player/movement/mod.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-use avian3d::prelude::*;
-use bevy::prelude::*;
-
-use crate::{
-    character_controller::{
-        CHARACTER_CAPSULE_LENGTH, CHARACTER_CAPSULE_RADIUS, Grounded,
-        MAX_SLOPE_ANGLE,
-    },
-    game_flow::states::{AppState, InGameState},
-    player::{
-        Player,
-        animate::{ArmWithWeaponAnimation, PlayArmWithWeaponAnimationMessage},
-        camera::components::ViewModelCamera,
-        shooting::components::PlayerWeapon,
-    },
-    shared::{JUMP_VELOCITY, MovementState, RUN_VELOCITY, WALK_VELOCITY},
-};
-
-pub struct PlayerMovementPlugin;
-
-impl Plugin for PlayerMovementPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(
-            Update,
-            (
-                player_movement,
-                setup_player_movement_state_for_added_players,
-            )
-                .run_if(in_state(AppState::InGame)),
-        );
-    }
-}
-
-#[derive(Component)]
-pub struct PlayerMovementState(pub MovementState);
-
-pub fn setup_player_movement_state_for_added_players(
-    mut commands: Commands,
-    added_players: Query<Entity, Added<Player>>,
-) {
-    for added_player in added_players {
-        commands
-            .entity(added_player)
-            .insert(PlayerMovementState(MovementState::Idle));
-    }
-}
-
-// TODO: its time to split this up, so we can also the character controller for our enemies
-pub fn player_movement(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    player: Single<(
-        Entity,
-        &mut LinearVelocity,
-        &Transform,
-        &mut PlayerMovementState,
-        &PlayerWeapon,
-        &Grounded,
-    )>,
-    player_camera_entity: Single<Entity, With<ViewModelCamera>>,
-    spatial_query: SpatialQuery,
-    current_in_game_state: Res<State<InGameState>>,
-    mut play_player_arm_weapon_animation_message_writer: MessageWriter<
-        PlayArmWithWeaponAnimationMessage,
-    >,
-    time: Res<Time>,
-) {
-    let (
-        entity,
-        mut velocity,
-        player_transform,
-        mut player_movement_state,
-        player_weapon,
-        grounded,
-    ) = player.into_inner();
-
-    let currently_playing =
-        *current_in_game_state.get() == InGameState::Playing;
-    if !currently_playing {
-        **velocity = Vec3::ZERO;
-        if player_movement_state.0 != MovementState::Idle {
-            player_movement_state.0 = MovementState::Idle;
-            play_player_arm_weapon_animation_message_writer.write(
-                PlayArmWithWeaponAnimationMessage {
-                    animation_type: ArmWithWeaponAnimation::Idle,
-                    repeat: true,
-                    block_until_done: false,
-                },
-            );
-        }
-        return;
-    }
-
-    let speed = if keyboard_input.pressed(KeyCode::ShiftLeft) {
-        RUN_VELOCITY
-    } else {
-        WALK_VELOCITY
-    };
-
-    let mut local_velocity = Vec3::ZERO;
-
-    if keyboard_input.pressed(KeyCode::KeyW) {
-        local_velocity.z -= 1.0 * speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyA) {
-        local_velocity.x -= 1.0 * speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyD) {
-        local_velocity.x += 1.0 * speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyS) {
-        local_velocity.z += 1.0 * speed;
-    }
-    if keyboard_input.just_pressed(KeyCode::Space) && grounded.0 {
-        velocity.y = JUMP_VELOCITY;
-    }
-
-    if local_velocity == Vec3::ZERO {
-        velocity.x = 0.0;
-        velocity.z = 0.0;
-        if player_movement_state.0 != MovementState::Idle {
-            player_movement_state.0 = MovementState::Idle;
-            play_player_arm_weapon_animation_message_writer.write(
-                PlayArmWithWeaponAnimationMessage {
-                    animation_type: ArmWithWeaponAnimation::Idle,
-                    repeat: true,
-                    block_until_done: false,
-                },
-            );
-        };
-        return;
-    }
-
-    let world_velocity = player_transform.rotation * local_velocity;
-    let Ok(direction_from_world_velocity) = Dir3::new(world_velocity) else {
-        return;
-    };
-
-    let ray_origin = player_transform.translation
-        - direction_from_world_velocity.as_vec3() * 0.025;
-    let max_distance = 0.3;
-
-    if let Some(hit_ahead) = spatial_query.cast_shape(
-        &Collider::capsule(CHARACTER_CAPSULE_RADIUS, CHARACTER_CAPSULE_LENGTH),
-        ray_origin,
-        player_transform.rotation,
-        direction_from_world_velocity,
-        &ShapeCastConfig {
-            max_distance,
-            ..default()
-        },
-        &SpatialQueryFilter::default()
-            .with_excluded_entities([entity, *player_camera_entity]),
-    ) {
-        // obstacle in the way, check if we can slimb it
-        // a normal is just a direction something is facing
-        let normal = hit_ahead.normal1;
-        let slope_angle = normal.angle_between(Vec3::Y);
-        let slope_climable = slope_angle < MAX_SLOPE_ANGLE;
-
-        if slope_climable {
-            info!("MOVEMENT: Climable slope!");
-            // this is the most important part to make the slope climbing possible.
-            // instead of trying to go straight, we slide along the ground
-            velocity.0 = world_velocity.reject_from_normalized(normal);
-
-            // slope snapping
-            let ray_down_origin = player_transform.translation + Vec3::Y * 0.5;
-            let ray_down_direction = Dir3::NEG_Y;
-            let max_down_distance = 1.0;
-
-            if let Some(hit_down) = spatial_query.cast_ray(
-                ray_down_origin,
-                ray_down_direction,
-                max_down_distance,
-                true,
-                &SpatialQueryFilter::default()
-                    .with_excluded_entities([entity, *player_camera_entity]),
-            ) {
-                let hit_down_point =
-                    ray_down_origin + ray_down_direction * hit_down.distance;
-                let ground_y = hit_down_point.y;
-                let current_y = player_transform.translation.y;
-                let diff_y = ground_y - current_y;
-                if diff_y.abs() < 0.3 {
-                    let res = diff_y / time.delta_secs();
-                    info!(
-                        "MOVEMENT: y velocity needs to be adjusted, setting \
-                         to: {}",
-                        res
-                    );
-                    velocity.y = res;
-                }
-            }
-        } else {
-            info!("MOVEMENT: Obstacle in the way, sliding along wall");
-            // not climable, e.g. a wall. we want to slide along the wall, similar to the collide
-            // and slide algorithm
-            // the main difference is that we ignore the Y part, because its too step, so we dont
-            // want to climb up
-            let impulse = world_velocity.reject_from_normalized(normal);
-            velocity.x = impulse.x;
-            velocity.z = impulse.z
-        }
-    } else {
-        info!("MOVEMENT: No obstacle ahead, free movement");
-        // no obstacle ahead, free movement
-        velocity.x = world_velocity.x;
-        velocity.z = world_velocity.z;
-    }
-
-    if player_weapon.reloading {
-        return;
-    }
-
-    if speed == RUN_VELOCITY {
-        if player_movement_state.0 != MovementState::Running {
-            player_movement_state.0 = MovementState::Running;
-            play_player_arm_weapon_animation_message_writer.write(
-                PlayArmWithWeaponAnimationMessage {
-                    animation_type: ArmWithWeaponAnimation::Run,
-                    repeat: true,
-                    block_until_done: false,
-                },
-            );
-        }
-    } else if local_velocity.x != 0.0 || local_velocity.z != 0.0 {
-        if player_movement_state.0 != MovementState::Walking {
-            player_movement_state.0 = MovementState::Walking;
-            play_player_arm_weapon_animation_message_writer.write(
-                PlayArmWithWeaponAnimationMessage {
-                    animation_type: ArmWithWeaponAnimation::Walk,
-                    repeat: true,
-                    block_until_done: false,
-                },
-            );
-        }
-    } else if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
-        if player_movement_state.0 != MovementState::Idle {
-            player_movement_state.0 = MovementState::Idle;
-            play_player_arm_weapon_animation_message_writer.write(
-                PlayArmWithWeaponAnimationMessage {
-                    animation_type: ArmWithWeaponAnimation::Idle,
-                    repeat: true,
-                    block_until_done: false,
-                },
-            );
-        }
-    }
-}
diff --git a/src/player/shooting/mod.rs b/src/player/shooting/mod.rs
index 37a5f52..abca303 100644
--- a/src/player/shooting/mod.rs
+++ b/src/player/shooting/mod.rs
@@ -8,9 +8,8 @@ use crate::{
         systems::{
             accurate_check_bullet_collision_for_impact_particle,
             detect_enemy_bullet_collision_with_player,
-            handle_blood_screen_effect, handle_player_death_event,
-            handle_reload_timer, player_shooting, reload_player_weapon,
-            setup_player_weapon, spawn_muzzle_flash,
+            handle_blood_screen_effect, handle_reload_timer, player_shooting,
+            reload_player_weapon, setup_player_weapon, spawn_muzzle_flash,
             tick_player_weapon_shoot_cooldown_timer,
         },
     },
@@ -38,7 +37,6 @@ impl Plugin for PlayerShootingPlugin {
                     spawn_muzzle_flash,
                     accurate_check_bullet_collision_for_impact_particle,
                     setup_player_weapon,
-                    handle_player_death_event,
                     handle_reload_timer,
                     detect_enemy_bullet_collision_with_player,
                 )
diff --git a/src/player/shooting/systems.rs b/src/player/shooting/systems.rs
index 613dc4f..893f512 100644
--- a/src/player/shooting/systems.rs
+++ b/src/player/shooting/systems.rs
@@ -8,10 +8,9 @@ use crate::{
     game_flow::{score::GameScore, states::InGameState},
     particles::{BulletImpactEffectVariant, SpawnBulletImpactEffectMessage},
     player::{
-        Player, PlayerDeathMessage,
+        Player,
         animate::{ArmWithWeaponAnimation, PlayArmWithWeaponAnimationMessage},
         camera::components::{ViewModelCamera, WorldModelCamera},
-        movement::PlayerMovementState,
         shooting::{
             components::{
                 BloodScreenEffect, MuzzleFlash, PlayerBullet,
@@ -21,7 +20,7 @@ use crate::{
             resources::ReloadTimer,
         },
     },
-    shared::{BULLET_VELOCITY, MovementState, components::DespawnTimer},
+    shared::{BULLET_VELOCITY, components::DespawnTimer},
     utils::random::get_random_number_from_range_i32,
 };
 
@@ -441,11 +440,12 @@ pub fn accurate_check_bullet_collision_for_impact_particle(
     }
 }
 
-pub fn handle_player_death_event(
-    mut message_reader: MessageReader<PlayerDeathMessage>,
-    mut player_movement_state: Single<&mut PlayerMovementState>,
-) {
-    for _ in message_reader.read() {
-        player_movement_state.0 = MovementState::Idle;
-    }
-}
+// FIXME: add again
+// pub fn handle_player_death_event(
+//     mut message_reader: MessageReader<PlayerDeathMessage>,
+//     mut player_movement_state: Single<&mut PlayerMovementState>,
+// ) {
+//     for _ in message_reader.read() {
+//         player_movement_state.0 = MovementState::Idle;
+//     }
+// }
diff --git a/src/shared/mod.rs b/src/shared/mod.rs
index e169460..12a3a07 100644
--- a/src/shared/mod.rs
+++ b/src/shared/mod.rs
@@ -9,17 +9,6 @@ pub mod systems;
 
 pub const BULLET_VELOCITY: f32 = 100.0;
 
-pub const WALK_VELOCITY: f32 = 2.0;
-pub const RUN_VELOCITY: f32 = 5.0;
-pub const JUMP_VELOCITY: f32 = 3.0;
-
-#[derive(Debug, Reflect, PartialEq)]
-pub enum MovementState {
-    Idle,
-    Walking,
-    Running,
-}
-
 pub struct CommonPlugin;
 
 impl Plugin for CommonPlugin {
diff --git a/src/user_interface/debug_overlay.rs b/src/user_interface/debug_overlay.rs
index cef1ebd..5da2961 100644
--- a/src/user_interface/debug_overlay.rs
+++ b/src/user_interface/debug_overlay.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 use crate::{
     game_flow::states::{AppDebugState, AppState, InGameState, MainMenuState},
-    player::{Player, movement::PlayerMovementState},
+    player::Player,
 };
 
 const DEBUG_OVERLAY_TEXT_SIZE: f32 = 15.0;
@@ -23,7 +23,7 @@ impl Plugin for DebugOverlayPlugin {
                 toggle_debug,
                 update_player_info_text,
                 update_current_main_menu_state,
-                update_player_movement_state_text,
+                // update_player_movement_state_text,
             ),
         );
     }
@@ -189,15 +189,16 @@ fn update_player_info_text(
     }
 }
 
-fn update_player_movement_state_text(
-    changed_player_movement_state: Single<
-        &PlayerMovementState,
-        Changed<PlayerMovementState>,
-    >,
-    player_movement_state_text: Query<&mut Text, With<PlayerMovementStateText>>,
-) {
-    for mut player_movement_state_text in player_movement_state_text {
-        **player_movement_state_text =
-            format!("{:?}", changed_player_movement_state.0);
-    }
-}
+// FIXME: maybe add again
+// fn update_player_movement_state_text(
+//     changed_player_movement_state: Single<
+//         &PlayerMovementState,
+//         Changed<PlayerMovementState>,
+//     >,
+//     player_movement_state_text: Query<&mut Text, With<PlayerMovementStateText>>,
+// ) {
+//     for mut player_movement_state_text in player_movement_state_text {
+//         **player_movement_state_text =
+//             format!("{:?}", changed_player_movement_state.0);
+//     }
+// }

From a9e0284ea05cb1ccbe633f93677b3bea255ce7ff Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 16:26:04 +0100
Subject: [PATCH 6/7] fix: add back player movement animation again

---
 README.md                           |   9 +-
 src/character_controller/mod.rs     |  21 ++++-
 src/player/animate/mod.rs           | 141 +++++++++-------------------
 src/user_interface/debug_overlay.rs |  28 +++---
 4 files changed, 81 insertions(+), 118 deletions(-)

diff --git a/README.md b/README.md
index 8d63aa8..ee3c810 100644
--- a/README.md
+++ b/README.md
@@ -14,11 +14,12 @@
 
 ## Todo and feature list
 - [x] User interface
-- [ ] Player movement
+- [x] Player movement
   - [x] Basic movement
-  - [ ] Write a proper kinematic character controller from scratch because i dont want to just copy some code
-    - [ ] Climb slopes
-    - [ ] slide along walls when going into walls instead of zeroeing velocity
+  - [x] Write a proper kinematic character controller from scratch because i dont want to just copy some code
+    - [x] Climb slopes
+    - [x] slide along walls when going into walls instead of zeroeing velocity
+    - there are still some improvements and fixes needed, but it works pretty good so far
 - [X] Game modes
   - [x] Wave mode (the game gets more difficult each round, e.g. more enemies are spawned)
   - [ ] Capture the flag
diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
index 436b8ce..bac5628 100644
--- a/src/character_controller/mod.rs
+++ b/src/character_controller/mod.rs
@@ -20,7 +20,7 @@ pub const MAX_SLOPE_ANGLE: f32 = 45.0_f32.to_radians();
 // character controller for enemies.
 
 #[derive(Component)]
-pub struct MovementState(MovementStateEnum);
+pub struct MovementState(pub MovementStateEnum);
 
 #[derive(Debug, Reflect, PartialEq)]
 pub enum MovementStateEnum {
@@ -94,8 +94,9 @@ impl Plugin for CharacterControllerPlugin {
 fn handle_keyboard_input_for_player(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     mut movement_action_writer: MessageWriter<MovementAction>,
-    player_transform: Single<&Transform, With<Player>>,
+    player_query: Single<(&Transform, &mut MovementState), With<Player>>,
 ) {
+    let (player_transform, mut movement_state) = player_query.into_inner();
     let speed = if keyboard_input.pressed(KeyCode::ShiftLeft) {
         RUN_VELOCITY
     } else {
@@ -120,6 +121,22 @@ fn handle_keyboard_input_for_player(
     let world_velocity = player_transform.rotation * local_velocity;
 
     movement_action_writer.write(MovementAction::Move(world_velocity));
+    if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
+        if movement_state.0 != MovementStateEnum::Idle {
+            info!("changing to idle");
+            movement_state.0 = MovementStateEnum::Idle;
+        }
+    } else if speed == RUN_VELOCITY {
+        if movement_state.0 != MovementStateEnum::Running {
+            info!("changing to running");
+            movement_state.0 = MovementStateEnum::Running;
+        }
+    } else if speed == WALK_VELOCITY {
+        if movement_state.0 != MovementStateEnum::Walking {
+            info!("changing to walking");
+            movement_state.0 = MovementStateEnum::Walking;
+        }
+    }
 
     if keyboard_input.just_pressed(KeyCode::Space) {
         movement_action_writer.write(MovementAction::Jump);
diff --git a/src/player/animate/mod.rs b/src/player/animate/mod.rs
index 5188271..3a9f7fa 100644
--- a/src/player/animate/mod.rs
+++ b/src/player/animate/mod.rs
@@ -2,7 +2,11 @@ use std::time::Duration;
 
 use bevy::{animation::RepeatAnimation, prelude::*};
 
-use crate::{player::Player, shared::components::AnimationPlayerEntityPointer};
+use crate::{
+    character_controller::{MovementState, MovementStateEnum},
+    player::Player,
+    shared::components::AnimationPlayerEntityPointer,
+};
 
 pub const PLAYER_ARM_WEAPON_PATH: &str = "models/player/arm_and_weapon.glb";
 
@@ -30,6 +34,7 @@ impl Plugin for PlayerAnimatePlugin {
                     link_player_animation,
                     handle_play_arm_with_weapon_animation_event,
                     handle_player_arm_weapon_animation_block_timer,
+                    animate_current_movement_state,
                 ),
             );
     }
@@ -265,100 +270,40 @@ fn get_animation_duration_for_animation_type(
     }
 }
 
-// FIXME:
-// pub fn use_me(
-//     player: Single<(
-//         Entity,
-//         &mut LinearVelocity,
-//         &Transform,
-//         &mut PlayerMovementState,
-//         &PlayerWeapon,
-//         &Grounded,
-//     )>,
-//     current_in_game_state: Res<State<InGameState>>,
-//     mut play_player_arm_weapon_animation_message_writer: MessageWriter<
-//         PlayArmWithWeaponAnimationMessage,
-//     >,
-// ) {
-//     let (
-//         entity,
-//         mut velocity,
-//         player_transform,
-//         mut player_movement_state,
-//         player_weapon,
-//         grounded,
-//     ) = player.into_inner();
-//
-//     let currently_playing =
-//         *current_in_game_state.get() == InGameState::Playing;
-//     if !currently_playing {
-//         **velocity = Vec3::ZERO;
-//         if player_movement_state.0 != MovementState::Idle {
-//             player_movement_state.0 = MovementState::Idle;
-//             play_player_arm_weapon_animation_message_writer.write(
-//                 PlayArmWithWeaponAnimationMessage {
-//                     animation_type: ArmWithWeaponAnimation::Idle,
-//                     repeat: true,
-//                     block_until_done: false,
-//                 },
-//             );
-//         }
-//         return;
-//     }
-//
-//     // FIXME: this all below of this function needs to go into player/animate
-//     // if local_velocity == Vec3::ZERO {
-//     //     velocity.x = 0.0;
-//     //     velocity.z = 0.0;
-//     //     if player_movement_state.0 != MovementState::Idle {
-//     //         player_movement_state.0 = MovementState::Idle;
-//     //         play_player_arm_weapon_animation_message_writer.write(
-//     //             PlayArmWithWeaponAnimationMessage {
-//     //                 animation_type: ArmWithWeaponAnimation::Idle,
-//     //                 repeat: true,
-//     //                 block_until_done: false,
-//     //             },
-//     //         );
-//     //     };
-//     //     return;
-//     // }
-//
-//     // if player_weapon.reloading {
-//     //     return;
-//     // }
-//     //
-//     // if speed == RUN_VELOCITY {
-//     //     if player_movement_state.0 != MovementState::Running {
-//     //         player_movement_state.0 = MovementState::Running;
-//     //         play_player_arm_weapon_animation_message_writer.write(
-//     //             PlayArmWithWeaponAnimationMessage {
-//     //                 animation_type: ArmWithWeaponAnimation::Run,
-//     //                 repeat: true,
-//     //                 block_until_done: false,
-//     //             },
-//     //         );
-//     //     }
-//     // } else if local_velocity.x != 0.0 || local_velocity.z != 0.0 {
-//     //     if player_movement_state.0 != MovementState::Walking {
-//     //         player_movement_state.0 = MovementState::Walking;
-//     //         play_player_arm_weapon_animation_message_writer.write(
-//     //             PlayArmWithWeaponAnimationMessage {
-//     //                 animation_type: ArmWithWeaponAnimation::Walk,
-//     //                 repeat: true,
-//     //                 block_until_done: false,
-//     //             },
-//     //         );
-//     //     }
-//     // } else if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
-//     //     if player_movement_state.0 != MovementState::Idle {
-//     //         player_movement_state.0 = MovementState::Idle;
-//     //         play_player_arm_weapon_animation_message_writer.write(
-//     //             PlayArmWithWeaponAnimationMessage {
-//     //                 animation_type: ArmWithWeaponAnimation::Idle,
-//     //                 repeat: true,
-//     //                 block_until_done: false,
-//     //             },
-//     //         );
-//     //     }
-//     // }
-// }
+pub fn animate_current_movement_state(
+    player: Single<&MovementState, Changed<MovementState>>,
+    mut play_player_arm_weapon_animation_message_writer: MessageWriter<
+        PlayArmWithWeaponAnimationMessage,
+    >,
+) {
+    info!("Movement state changed, playing corresponding animation!");
+    match player.into_inner().0 {
+        MovementStateEnum::Idle => {
+            play_player_arm_weapon_animation_message_writer.write(
+                PlayArmWithWeaponAnimationMessage {
+                    animation_type: ArmWithWeaponAnimation::Idle,
+                    repeat: true,
+                    block_until_done: false,
+                },
+            );
+        }
+        MovementStateEnum::Walking => {
+            play_player_arm_weapon_animation_message_writer.write(
+                PlayArmWithWeaponAnimationMessage {
+                    animation_type: ArmWithWeaponAnimation::Walk,
+                    repeat: true,
+                    block_until_done: false,
+                },
+            );
+        }
+        MovementStateEnum::Running => {
+            play_player_arm_weapon_animation_message_writer.write(
+                PlayArmWithWeaponAnimationMessage {
+                    animation_type: ArmWithWeaponAnimation::Run,
+                    repeat: true,
+                    block_until_done: false,
+                },
+            );
+        }
+    }
+}
diff --git a/src/user_interface/debug_overlay.rs b/src/user_interface/debug_overlay.rs
index 5da2961..f347802 100644
--- a/src/user_interface/debug_overlay.rs
+++ b/src/user_interface/debug_overlay.rs
@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 
 use crate::{
+    character_controller::MovementState,
     game_flow::states::{AppDebugState, AppState, InGameState, MainMenuState},
     player::Player,
 };
@@ -23,7 +24,7 @@ impl Plugin for DebugOverlayPlugin {
                 toggle_debug,
                 update_player_info_text,
                 update_current_main_menu_state,
-                // update_player_movement_state_text,
+                update_player_movement_state_text,
             ),
         );
     }
@@ -189,16 +190,15 @@ fn update_player_info_text(
     }
 }
 
-// FIXME: maybe add again
-// fn update_player_movement_state_text(
-//     changed_player_movement_state: Single<
-//         &PlayerMovementState,
-//         Changed<PlayerMovementState>,
-//     >,
-//     player_movement_state_text: Query<&mut Text, With<PlayerMovementStateText>>,
-// ) {
-//     for mut player_movement_state_text in player_movement_state_text {
-//         **player_movement_state_text =
-//             format!("{:?}", changed_player_movement_state.0);
-//     }
-// }
+fn update_player_movement_state_text(
+    changed_player_movement_state: Single<
+        &MovementState,
+        Changed<MovementState>,
+    >,
+    player_movement_state_text: Query<&mut Text, With<PlayerMovementStateText>>,
+) {
+    for mut player_movement_state_text in player_movement_state_text {
+        **player_movement_state_text =
+            format!("{:?}", changed_player_movement_state.0);
+    }
+}

From 8632d8b82cdf353b2ac842c400e41123d7dd4607 Mon Sep 17 00:00:00 2001
From: Jakob Stechow <jakob.stechow@pm.me>
Date: Sun, 26 Oct 2025 16:33:13 +0100
Subject: [PATCH 7/7] fix: stuff from self code review

---
 src/character_controller/mod.rs           |  7 +++----
 src/player/animate/mod.rs                 |  4 ++--
 src/player/shooting/mod.rs                |  6 ++++--
 src/player/shooting/systems.rs            | 20 ++++++++++----------
 src/user_interface/game_mode_selection.rs |  8 ++++----
 5 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/src/character_controller/mod.rs b/src/character_controller/mod.rs
index bac5628..9fdc1f7 100644
--- a/src/character_controller/mod.rs
+++ b/src/character_controller/mod.rs
@@ -31,7 +31,7 @@ pub enum MovementStateEnum {
 
 #[derive(Message)]
 pub enum MovementAction {
-    // TODO: should be possible to just have Vec3
+    // TODO: should be possible to just have Vec2
     Move(Vec3),
     Jump,
 }
@@ -45,6 +45,7 @@ pub struct CharacterControllerBundle {
     grounded: Grounded,
     locked_axes: LockedAxes,
     movement_state: MovementState,
+    colliding_entities: CollidingEntities,
 }
 
 impl Default for CharacterControllerBundle {
@@ -62,6 +63,7 @@ impl Default for CharacterControllerBundle {
                 .lock_rotation_y()
                 .lock_rotation_z(),
             movement_state: MovementState(MovementStateEnum::Idle),
+            colliding_entities: CollidingEntities::default(),
         }
     }
 }
@@ -123,17 +125,14 @@ fn handle_keyboard_input_for_player(
     movement_action_writer.write(MovementAction::Move(world_velocity));
     if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
         if movement_state.0 != MovementStateEnum::Idle {
-            info!("changing to idle");
             movement_state.0 = MovementStateEnum::Idle;
         }
     } else if speed == RUN_VELOCITY {
         if movement_state.0 != MovementStateEnum::Running {
-            info!("changing to running");
             movement_state.0 = MovementStateEnum::Running;
         }
     } else if speed == WALK_VELOCITY {
         if movement_state.0 != MovementStateEnum::Walking {
-            info!("changing to walking");
             movement_state.0 = MovementStateEnum::Walking;
         }
     }
diff --git a/src/player/animate/mod.rs b/src/player/animate/mod.rs
index 3a9f7fa..76900dc 100644
--- a/src/player/animate/mod.rs
+++ b/src/player/animate/mod.rs
@@ -179,7 +179,7 @@ fn handle_play_arm_with_weapon_animation_event(
         };
 
         if animation_block_timer.is_some() {
-            info!(
+            debug!(
                 "Got animation request, but the AnimationBlockTimer resource \
                  currently exists, not playing animation {:?}",
                 event.animation_type
@@ -276,7 +276,7 @@ pub fn animate_current_movement_state(
         PlayArmWithWeaponAnimationMessage,
     >,
 ) {
-    info!("Movement state changed, playing corresponding animation!");
+    debug!("Movement state changed, playing corresponding animation!");
     match player.into_inner().0 {
         MovementStateEnum::Idle => {
             play_player_arm_weapon_animation_message_writer.write(
diff --git a/src/player/shooting/mod.rs b/src/player/shooting/mod.rs
index abca303..59da50b 100644
--- a/src/player/shooting/mod.rs
+++ b/src/player/shooting/mod.rs
@@ -8,8 +8,9 @@ use crate::{
         systems::{
             accurate_check_bullet_collision_for_impact_particle,
             detect_enemy_bullet_collision_with_player,
-            handle_blood_screen_effect, handle_reload_timer, player_shooting,
-            reload_player_weapon, setup_player_weapon, spawn_muzzle_flash,
+            handle_blood_screen_effect, handle_player_death_event,
+            handle_reload_timer, player_shooting, reload_player_weapon,
+            setup_player_weapon, spawn_muzzle_flash,
             tick_player_weapon_shoot_cooldown_timer,
         },
     },
@@ -39,6 +40,7 @@ impl Plugin for PlayerShootingPlugin {
                     setup_player_weapon,
                     handle_reload_timer,
                     detect_enemy_bullet_collision_with_player,
+                    handle_player_death_event,
                 )
                     .run_if(in_state(InGameState::Playing)),
             );
diff --git a/src/player/shooting/systems.rs b/src/player/shooting/systems.rs
index 893f512..43ec418 100644
--- a/src/player/shooting/systems.rs
+++ b/src/player/shooting/systems.rs
@@ -4,11 +4,12 @@ use avian3d::prelude::*;
 use bevy::{color::palettes::css::WHITE, prelude::*};
 
 use crate::{
+    character_controller::{MovementState, MovementStateEnum},
     enemy::{Enemy, shooting::components::EnemyBullet},
     game_flow::{score::GameScore, states::InGameState},
     particles::{BulletImpactEffectVariant, SpawnBulletImpactEffectMessage},
     player::{
-        Player,
+        Player, PlayerDeathMessage,
         animate::{ArmWithWeaponAnimation, PlayArmWithWeaponAnimationMessage},
         camera::components::{ViewModelCamera, WorldModelCamera},
         shooting::{
@@ -440,12 +441,11 @@ pub fn accurate_check_bullet_collision_for_impact_particle(
     }
 }
 
-// FIXME: add again
-// pub fn handle_player_death_event(
-//     mut message_reader: MessageReader<PlayerDeathMessage>,
-//     mut player_movement_state: Single<&mut PlayerMovementState>,
-// ) {
-//     for _ in message_reader.read() {
-//         player_movement_state.0 = MovementState::Idle;
-//     }
-// }
+pub fn handle_player_death_event(
+    mut message_reader: MessageReader<PlayerDeathMessage>,
+    mut player_movement_state: Single<&mut MovementState, With<Player>>,
+) {
+    for _ in message_reader.read() {
+        player_movement_state.0 = MovementStateEnum::Idle;
+    }
+}
diff --git a/src/user_interface/game_mode_selection.rs b/src/user_interface/game_mode_selection.rs
index 71185e0..608d2b1 100644
--- a/src/user_interface/game_mode_selection.rs
+++ b/src/user_interface/game_mode_selection.rs
@@ -84,7 +84,7 @@ fn spawn_game_mode_selection_screen(
                     TextColor::WHITE,
                 ))
                 .with_child((
-                    Text::new("Waves"),
+                    Text::new("Waves (Currently disabled!)"),
                     TextFont {
                         font: asset_server.load(DEFAULT_GAME_FONT_PATH),
                         font_size: DEFAULT_FONT_SIZE,
@@ -147,9 +147,9 @@ fn handle_game_mode_selection_button_press(
         if let Interaction::Pressed = interaction {
             match game_mode_selection_button.0 {
                 GameMode::Waves => {
-                    next_app_state.set(AppState::InGame);
-                    next_game_mode_state.set(GameMode::Waves);
-                    message_writer.write(StartGameModeMessage(GameMode::Waves));
+                    // next_app_state.set(AppState::InGame);
+                    // next_game_mode_state.set(GameMode::Waves);
+                    // message_writer.write(StartGameModeMessage(GameMode::Waves));
                 }
                 GameMode::FreePlay => {
                     next_app_state.set(AppState::InGame);