feat: make character controller usable for the enemy too

Author: invertedEcho

src/character_controller/mod.rs

@@ -3,7 +3,6 @@ use bevy::prelude::*;
 
 use crate::{
     GRAVITY,
-    enemy::Enemy,
     game_flow::states::InGameState,
     player::{Player, camera::components::ViewModelCamera},
 };
@@ -32,7 +31,12 @@ pub enum MovementStateEnum {
 }
 
 #[derive(Message)]
-pub enum MovementAction {
+pub struct MovementAction {
+    pub direction: MovementDirection,
+    pub character_controller_entity: Entity,
+}
+
+pub enum MovementDirection {
     // TODO: should be possible to just have Vec2
     Move(Vec3),
     Jump,
@@ -73,7 +77,7 @@ impl Default for CharacterControllerBundle {
                 Quaternion::default(),
                 Dir3::NEG_Y,
             )
-            .with_max_distance(0.2),
+            .with_max_distance(0.1),
         }
     }
 }
@@ -98,8 +102,7 @@ impl Plugin for CharacterControllerPlugin {
                     update_on_ground,
                     apply_gravity_over_time,
                     handle_keyboard_input_for_player,
-                    handle_movement_actions_for_player,
-                    debug_remove_grounded_from_enemies,
+                    handle_movement_actions_for_character_controllers,
                 )
                     .run_if(in_state(InGameState::Playing)),
             )
@@ -120,9 +123,14 @@ fn handle_player_dead_velocity(
 fn handle_keyboard_input_for_player(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     mut movement_action_writer: MessageWriter<MovementAction>,
-    player_query: Single<(&Transform, &mut MovementState), With<Player>>,
+    player_query: Single<
+        (&Transform, &mut MovementState, Entity),
+        With<Player>,
+    >,
 ) {
-    let (player_transform, mut movement_state) = player_query.into_inner();
+    let (player_transform, mut movement_state, player_entity) =
+        player_query.into_inner();
+
     let speed = if keyboard_input.pressed(KeyCode::ShiftLeft) {
         RUN_VELOCITY
     } else {
@@ -146,7 +154,11 @@ fn handle_keyboard_input_for_player(
 
     let world_velocity = player_transform.rotation * local_velocity;
 
-    movement_action_writer.write(MovementAction::Move(world_velocity));
+    movement_action_writer.write(MovementAction {
+        direction: MovementDirection::Move(world_velocity),
+        character_controller_entity: player_entity,
+    });
+
     if local_velocity.x == 0.0 && local_velocity.z == 0.0 {
         if movement_state.0 != MovementStateEnum::Idle {
             movement_state.0 = MovementStateEnum::Idle;
@@ -162,59 +174,78 @@ fn handle_keyboard_input_for_player(
     }
 
     if keyboard_input.just_pressed(KeyCode::Space) {
-        movement_action_writer.write(MovementAction::Jump);
+        movement_action_writer.write(MovementAction {
+            direction: MovementDirection::Jump,
+            character_controller_entity: player_entity,
+        });
     }
 }
 
-fn handle_movement_actions_for_player(
+fn handle_movement_actions_for_character_controllers(
     mut movement_action_reader: MessageReader<MovementAction>,
-    player_query: Single<
-        (&mut LinearVelocity, &Grounded, &Transform, Entity),
-        With<Player>,
-    >,
+    mut character_controller_query: Query<(
+        &mut LinearVelocity,
+        &Grounded,
+        &Transform,
+        Entity,
+    )>,
+    // TODO: i dont want this here
     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;
+        let direction = &movement_action.direction;
+        let character_controller_entity =
+            movement_action.character_controller_entity;
+        let Ok((mut velocity, grounded, transform, entity)) =
+            character_controller_query.get_mut(character_controller_entity)
+        else {
+            // FIXME
+            warn!("lkjdsflkjdsf");
+            continue;
+        };
+
+        match *direction {
+            MovementDirection::Jump => {
+                if grounded.0 {
+                    velocity.y = JUMP_VELOCITY;
                 }
             }
             // TODO: should probably move the content of this block elsewhere
-            MovementAction::Move(world_velocity) => {
+            MovementDirection::Move(world_velocity) => {
                 let Ok(direction_from_world_velocity) =
-                    Dir3::new(*world_velocity)
+                    Dir3::new(world_velocity)
                 else {
-                    player_velocity.x = 0.0;
-                    player_velocity.z = 0.0;
+                    velocity.x = 0.0;
+                    velocity.z = 0.0;
                     return;
                 };
 
-                let ray_origin = player_transform.translation
+                let ray_origin = transform.translation
                     - direction_from_world_velocity.as_vec3() * 0.025;
                 let max_distance = 0.3;
 
+                let spatial_query_filter = &SpatialQueryFilter::default()
+                    .with_excluded_entities([
+                        entity,
+                        // TODO: should only be excluded when we have player
+                        *player_camera_entity,
+                    ]);
+
                 if let Some(hit_ahead) = spatial_query.cast_shape(
                     &Collider::capsule(
                         CHARACTER_CAPSULE_RADIUS,
                         CHARACTER_CAPSULE_LENGTH,
                     ),
                     ray_origin,
-                    player_transform.rotation,
+                    transform.rotation,
                     direction_from_world_velocity,
                     &ShapeCastConfig {
                         max_distance,
                         ..default()
                     },
-                    &SpatialQueryFilter::default().with_excluded_entities([
-                        player_entity,
-                        *player_camera_entity,
-                    ]),
+                    spatial_query_filter,
                 ) {
                     // obstacle in the way, check if we can slimb it
                     // a normal is just a direction something is facing
@@ -226,12 +257,12 @@ fn handle_movement_actions_for_player(
                         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 =
+                        velocity.0 =
                             world_velocity.reject_from_normalized(normal);
 
                         // slope snapping
                         let ray_down_origin =
-                            player_transform.translation + Vec3::Y * 0.5;
+                            transform.translation + Vec3::Y * 0.5;
                         let ray_down_direction = Dir3::NEG_Y;
                         let max_down_distance = 1.0;
 
@@ -240,21 +271,16 @@ fn handle_movement_actions_for_player(
                             ray_down_direction,
                             max_down_distance,
                             true,
-                            &SpatialQueryFilter::default()
-                                .with_excluded_entities([
-                                    player_entity,
-                                    *player_camera_entity,
-                                ]),
+                            spatial_query_filter,
                         ) {
                             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 player_y = transform.translation.y;
                             let difference_y = hit_down_y - player_y;
                             if difference_y.abs() < 0.3 {
-                                info!("Snapping player to slope");
-                                player_velocity.y =
-                                    difference_y / time.delta_secs();
+                                info!("Snapping character controller to slope");
+                                velocity.y = difference_y / time.delta_secs();
                             }
                         }
                     } else {
@@ -267,14 +293,14 @@ fn handle_movement_actions_for_player(
                         // want to climb up
                         let impulse =
                             world_velocity.reject_from_normalized(normal);
-                        player_velocity.x = impulse.x;
-                        player_velocity.z = impulse.z
+                        velocity.x = impulse.x;
+                        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;
+                    velocity.x = world_velocity.x;
+                    velocity.z = world_velocity.z;
                 }
             }
         }
@@ -283,20 +309,11 @@ fn handle_movement_actions_for_player(
 
 /// Updates the [`Grounded`] status for character controllers.
 fn update_on_ground(
-    mut query: Query<(
-        &ShapeHits,
-        &Rotation,
-        &mut Grounded,
-        &mut LinearVelocity,
-    )>,
+    mut query: Query<(&ShapeHits, &mut Grounded, &mut LinearVelocity)>,
 ) {
-    for (hits, rotation, mut grounded, mut velocity) in &mut query {
-        // The character is grounded if the shape caster has a hit with a normal
-        // that isn't too steep.
-        let on_ground = hits.iter().any(|hit| {
-            (rotation * -hit.normal2).angle_between(Vec3::Y).abs()
-                <= MAX_SLOPE_ANGLE
-        });
+    for (hits, mut grounded, mut velocity) in &mut query {
+        let on_ground = hits.0.len() > 0;
+
         if grounded.0 != on_ground {
             grounded.0 = on_ground;
         }
@@ -318,15 +335,3 @@ fn apply_gravity_over_time(
         }
     }
 }
-
-fn debug_remove_grounded_from_enemies(
-    mut commands: Commands,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    enemy_query: Query<Entity, With<Enemy>>,
-) {
-    if keyboard_input.just_pressed(KeyCode::KeyU) {
-        for enemy in enemy_query {
-            commands.entity(enemy).remove::<Grounded>();
-        }
-    }
-}

src/enemy/ai/systems.rs

@@ -3,6 +3,7 @@ use bevy::prelude::*;
 use bevy_landmass::{AgentState, AgentTarget3d, Velocity3d};
 
 use crate::{
+    character_controller::{MovementAction, MovementDirection},
     enemy::{
         Enemy, ai::EnemyState, shooting::components::EnemyBullet,
         spawn::AgentEnemyEntityPointer,
@@ -135,12 +136,13 @@ pub fn set_zero_velocity_if_not_chasing(
 }
 
 pub fn handle_chasing_enemies(
-    mut enemy_query: Query<(&Enemy, &mut LinearVelocity)>,
+    mut enemy_query: Query<(&Enemy, Entity, &mut LinearVelocity)>,
     enemy_agents_query: Query<(&Velocity3d, &AgentEnemyEntityPointer)>,
     current_in_game_state: Res<State<InGameState>>,
+    mut movement_action_writer: MessageWriter<MovementAction>,
 ) {
     for (agent_velocity, agent_enemy_entity_pointer) in enemy_agents_query {
-        let Ok((enemy, mut velocity)) =
+        let Ok((enemy, entity, mut velocity)) =
             enemy_query.get_mut(agent_enemy_entity_pointer.0)
         else {
             warn!(
@@ -162,7 +164,9 @@ pub fn handle_chasing_enemies(
             continue;
         }
 
-        debug!("Applying agent velocity to actual velocity of enemy");
-        velocity.0 = agent_velocity.velocity;
+        movement_action_writer.write(MovementAction {
+            direction: MovementDirection::Move(agent_velocity.velocity),
+            character_controller_entity: entity,
+        });
     }
 }

src/enemy/spawn/mod.rs

@@ -1,6 +1,7 @@
 use crate::{
     character_controller::{
         CHARACTER_CAPSULE_LENGTH, CHARACTER_CAPSULE_RADIUS, Grounded,
+        RUN_VELOCITY, WALK_VELOCITY,
     },
     enemy::{
         animate::ENEMY_MODEL_PATH,

src/main.rs

@@ -1,5 +1,9 @@
 use avian3d::prelude::*;
-use bevy::{prelude::*, window::PresentMode};
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    prelude::*,
+    window::PresentMode,
+};
 use bevy_hanabi::HanabiPlugin;
 use bevy_inspector_egui::{
     bevy_egui::{self, EguiPlugin},
@@ -55,8 +59,8 @@ fn main() {
                 ..default()
             }),
     );
-    // app.add_plugins(FrameTimeDiagnosticsPlugin::default());
-    // app.add_plugins(LogDiagnosticsPlugin::default());
+    app.add_plugins(FrameTimeDiagnosticsPlugin::default());
+    app.add_plugins(LogDiagnosticsPlugin::default());
 
     // External plugins
     app.add_plugins(PhysicsPlugins::default())

src/nav_mesh_pathfinding/mod.rs

@@ -89,6 +89,7 @@ fn update_agent_velocity(
     }
 }
 
+// FIXME: dont need this anymore
 fn snap_agent_to_floor(
     query: Query<
         (Entity, &Transform, &mut LinearVelocity, &ShapeHits),