refactor: kinematic controller plugin

Author: invertedEcho

src/enemy/ai/mod.rs

@@ -3,9 +3,8 @@ use bevy::prelude::*;
 use crate::{
     enemy::{
         ai::systems::{
-            apply_gravity_over_time, check_if_enemy_can_see_player,
-            check_if_enemy_reached_target, handle_chasing_enemies,
-            set_zero_velocity_if_not_chasing, update_enemy_on_ground,
+            check_if_enemy_can_see_player, check_if_enemy_reached_target,
+            handle_chasing_enemies, set_zero_velocity_if_not_chasing,
         },
         shooting::systems::enemy_shoot_player,
     },
@@ -36,8 +35,6 @@ impl Plugin for EnemyAiPlugin {
                 // needs to run after enemy_shoot_player, so we can include all enemy bullets in
                 // the SpatialQueryFilter
                 check_if_enemy_can_see_player.after(enemy_shoot_player),
-                update_enemy_on_ground,
-                apply_gravity_over_time,
                 check_if_enemy_reached_target,
                 set_zero_velocity_if_not_chasing,
             )

src/enemy/ai/systems.rs

@@ -3,16 +3,12 @@ use bevy::prelude::*;
 use bevy_landmass::{AgentState, AgentTarget3d, Velocity3d};
 
 use crate::{
-    GRAVITY,
     enemy::{
         Enemy, ai::EnemyState, shooting::components::EnemyBullet,
         spawn::AgentEnemyEntityPointer,
     },
     game_flow::states::InGameState,
-    player::{
-        Player,
-        spawn::{PLAYER_CAPSULE_LENGTH, PLAYER_CAPSULE_RADIUS},
-    },
+    player::Player,
 };
 
 /// This system iterates over each enemy, and with a raycast, determines whether the enemy can see
@@ -127,11 +123,13 @@ pub fn set_zero_velocity_if_not_chasing(
     enemy_query: Query<(&Enemy, &mut LinearVelocity)>,
 ) {
     for (enemy, mut velocity) in enemy_query {
-        if enemy.state != EnemyState::ChasingPlayer && velocity.0 != Vec3::ZERO
+        if enemy.state != EnemyState::ChasingPlayer
+            && velocity.x != 0.0
+            && velocity.z != 0.0
         {
-            info!("current velocity: {}", velocity.0);
             info!("Enemy no longer chasing player, zeoring velocity!");
-            velocity.0 = Vec3::ZERO;
+            velocity.z = 0.0;
+            velocity.x = 0.0
         }
     }
 }
@@ -167,49 +165,3 @@ pub fn handle_chasing_enemies(
         velocity.0 = agent_velocity.velocity;
     }
 }
-
-pub fn update_enemy_on_ground(
-    enemies: Query<(&mut Enemy, &Transform, Entity, &mut LinearVelocity)>,
-    spatial_query: SpatialQuery,
-) {
-    for (mut enemy, transform, player_entity, mut player_velocity) in enemies {
-        let on_ground = spatial_query
-            .cast_shape(
-                &Collider::capsule(
-                    PLAYER_CAPSULE_RADIUS,
-                    PLAYER_CAPSULE_LENGTH,
-                ),
-                transform.translation,
-                transform.rotation,
-                Dir3::NEG_Y,
-                &ShapeCastConfig {
-                    max_distance: 0.1,
-                    ..default()
-                },
-                &SpatialQueryFilter::default()
-                    .with_excluded_entities([player_entity]),
-            )
-            .is_some();
-        if enemy.on_ground != on_ground {
-            enemy.on_ground = on_ground;
-        }
-
-        if on_ground {
-            if player_velocity.y <= 0.0 {
-                player_velocity.y = 0.0;
-            }
-        }
-    }
-}
-
-pub fn apply_gravity_over_time(
-    mut enemy_query: Single<(&Enemy, &mut LinearVelocity)>,
-    time: Res<Time>,
-) {
-    let enemy = enemy_query.0;
-    let enemy_velocity = &mut enemy_query.1;
-
-    if !enemy.on_ground && enemy_velocity.y > 0.0 {
-        enemy_velocity.y -= GRAVITY * time.delta_secs();
-    }
-}

src/enemy/mod.rs

@@ -30,5 +30,4 @@ impl Plugin for EnemyPlugin {
 pub struct Enemy {
     state: EnemyState,
     pub health: f32,
-    on_ground: bool,
 }

src/enemy/shooting/mod.rs

@@ -22,7 +22,7 @@ impl Plugin for EnemyShootingPlugin {
         app.add_message::<EnemyKilledMessage>().add_systems(
             Update,
             (
-                // enemy_shoot_player,
+                enemy_shoot_player,
                 tick_enemy_shoot_player_cooldown_timer,
                 detect_player_bullet_collision_with_enemy,
                 handle_enemy_killed_message,

src/enemy/spawn/mod.rs

@@ -3,10 +3,11 @@ use crate::{
         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},
 };
-use avian3d::{math::PI, prelude::*};
+use avian3d::math::PI;
 use bevy::prelude::*;
 use bevy_landmass::{
     Agent, Agent3dBundle, AgentSettings, AgentTarget3d, ArchipelagoRef3d,
@@ -130,23 +131,12 @@ fn handle_spawn_enemies_at_enemy_spawn_locations_message(
                                 health: 100.0,
                                 ..default()
                             },
-                            RigidBody::Kinematic,
-                            LockedAxes::new()
-                                .lock_rotation_x()
-                                .lock_rotation_y()
-                                .lock_rotation_z(),
-                            Collider::capsule(
-                                PLAYER_CAPSULE_RADIUS,
-                                PLAYER_CAPSULE_LENGTH,
-                            ),
-                            AngularVelocity::ZERO,
-                            LinearVelocity::ZERO,
+                            KinematicController::default(),
                             EnemyShootPlayerCooldownTimer(Timer::from_seconds(
                                 0.5,
                                 TimerMode::Repeating,
                             )),
                             Visibility::Visible,
-                            CollidingEntities::default(),
                         ))
                         .with_child((
                             Transform {

src/kinematic_controller/mod.rs

@@ -0,0 +1,96 @@
+use avian3d::prelude::*;
+use bevy::prelude::*;
+
+use crate::GRAVITY;
+
+// so total length is 1.9m = 1.4 + 0.25 * 2
+const CAPSULE_RADIUS: f32 = 0.25;
+const CAPSULE_LENGTH: f32 = 1.4;
+
+#[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();
+        }
+    }
+}

src/main.rs

@@ -8,14 +8,16 @@ use bevy_inspector_egui::{
 use bevy_skein::SkeinPlugin;
 
 use crate::{
-    enemy::EnemyPlugin, game_flow::GameFlowPlugin, music::MusicPlugin,
+    enemy::EnemyPlugin, game_flow::GameFlowPlugin,
+    kinematic_controller::KinematicControllerPlugin, music::MusicPlugin,
     nav_mesh_pathfinding::NavMeshPathfindingPlugin, particles::ParticlesPlugin,
     player::PlayerPlugin, shared::CommonPlugin,
     user_interface::UserInterfacePlugin, world::WorldPlugin,
 };
 
 mod enemy;
 mod game_flow;
+mod kinematic_controller;
 mod music;
 mod nav_mesh_pathfinding;
 mod particles;
@@ -61,9 +63,14 @@ fn main() {
         .add_plugins(PhysicsDebugPlugin::default())
         .insert_resource(Gravity(Vec3::NEG_Y * GRAVITY));
     app.add_plugins(SkeinPlugin::default());
+    app.add_plugins(HanabiPlugin);
+
     app.add_plugins(EguiPlugin::default())
         .add_plugins(WorldInspectorPlugin::new());
-    app.add_plugins(HanabiPlugin);
+    app.insert_resource(bevy_egui::EguiGlobalSettings {
+        auto_create_primary_context: false,
+        ..default()
+    });
 
     // own plugins
     app.add_plugins(PlayerPlugin)
@@ -74,12 +81,8 @@ fn main() {
         .add_plugins(UserInterfacePlugin)
         .add_plugins(ParticlesPlugin)
         .add_plugins(MusicPlugin)
-        .add_plugins(NavMeshPathfindingPlugin);
-
-    app.insert_resource(bevy_egui::EguiGlobalSettings {
-        auto_create_primary_context: false,
-        ..default()
-    });
+        .add_plugins(NavMeshPathfindingPlugin)
+        .add_plugins(KinematicControllerPlugin);
 
     app.run();
 }

src/player/mod.rs

@@ -19,7 +19,6 @@ pub mod spawn;
 #[derive(Component, Debug)]
 pub struct Player {
     pub health: f32,
-    pub on_ground: bool,
     // TODO: get rid of me or move me somewhere else
     pub camera_state: PlayerCameraState,
 }
@@ -28,7 +27,6 @@ impl Default for Player {
     fn default() -> Self {
         Player {
             health: 100.0,
-            on_ground: true,
             camera_state: PlayerCameraState::Normal,
         }
     }