Simple ai shooting PoC (#23)

src/abilities/gun.rs

@@ -1,13 +1,7 @@
 use super::{Projectile, TriggerGun};
 use crate::{
-    GameState,
-    aim::AimState,
-    billboards::Billboard,
-    loading_assets::GameAssets,
-    physics_layers::GameLayer,
-    player::{Player, PlayerRig},
-    sounds::PlaySound,
-    utils::sprite_3d_animation::AnimationTimer,
+    GameState, billboards::Billboard, loading_assets::GameAssets, physics_layers::GameLayer,
+    sounds::PlaySound, utils::sprite_3d_animation::AnimationTimer,
 };
 use avian3d::prelude::{
     Collider, CollisionLayers, CollisionStarted, LayerMask, PhysicsLayer, Sensor,
@@ -52,8 +46,7 @@ fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Spr
 fn on_trigger_state(
     trigger: Trigger<TriggerGun>,
     mut commands: Commands,
-    aim: Res<AimState>,
-    target_transform: Query<&Transform, (Without<Player>, Without<PlayerRig>)>,
+    query_transform: Query<&Transform>,
     time: Res<Time>,
     mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
     mut polylines: ResMut<Assets<Polyline>>,
@@ -62,8 +55,8 @@ fn on_trigger_state(
 
     commands.trigger(PlaySound::Gun);
 
-    let rotation = if let Some(target) = aim.target {
-        let t = target_transform
+    let rotation = if let Some(target) = state.target {
+        let t = query_transform
             .get(target)
             .expect("target must have transform");
         Transform::from_translation(state.pos)
@@ -86,7 +79,7 @@ fn on_trigger_state(
             Collider::capsule_endpoints(0.5, Vec3::new(0., 0., 0.), Vec3::new(0., 0., -3.)),
             CollisionLayers::new(
                 LayerMask(GameLayer::Projectile.to_bits()),
-                LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
+                LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
             ),
             Sensor,
             Visibility::default(),

src/abilities/mod.rs

@@ -3,8 +3,10 @@ mod thrown;
 
 use crate::{
     GameState,
+    aim::AimTarget,
     heads::ActiveHeads,
     hitpoints::Hit,
+    physics_layers::GameLayer,
     player::{Player, PlayerRig},
     sounds::PlaySound,
     tb_entities::EnemySpawn,
@@ -35,16 +37,36 @@ pub enum HeadAbility {
 }
 
 #[derive(Debug, Reflect, Clone, Copy)]
-pub struct PlayerTriggerState {
+pub struct TriggerData {
+    target: Option<Entity>,
     dir: Dir3,
     rot: Quat,
     pos: Vec3,
+    target_layer: GameLayer,
+}
+
+impl TriggerData {
+    pub fn new(
+        target: Option<Entity>,
+        dir: Dir3,
+        rot: Quat,
+        pos: Vec3,
+        target_layer: GameLayer,
+    ) -> Self {
+        Self {
+            target,
+            dir,
+            rot,
+            pos,
+            target_layer,
+        }
+    }
 }
 
 #[derive(Event, Reflect)]
-pub struct TriggerGun(pub PlayerTriggerState);
+pub struct TriggerGun(pub TriggerData);
 #[derive(Event, Reflect)]
-pub struct TriggerThrow(pub PlayerTriggerState);
+pub struct TriggerThrow(pub TriggerData);
 
 pub fn plugin(app: &mut App) {
     app.add_plugins(gun::plugin);
@@ -84,7 +106,7 @@ fn on_trigger_state(
     trigger: Trigger<TriggerState>,
     mut commands: Commands,
     player_rot: Query<&Transform, With<PlayerRig>>,
-    player_transform: Query<&Transform, With<Player>>,
+    player_query: Query<(&Transform, &AimTarget), With<Player>>,
     mut active_heads: ResMut<ActiveHeads>,
     time: Res<Time>,
 ) {
@@ -98,7 +120,7 @@ fn on_trigger_state(
             return;
         }
 
-        let Some(transform) = player_transform.iter().next().copied() else {
+        let Some((transform, target)) = player_query.iter().next() else {
             return;
         };
 
@@ -106,10 +128,12 @@ fn on_trigger_state(
             return;
         };
 
-        let trigger_state = PlayerTriggerState {
+        let trigger_state = TriggerData {
             dir,
             rot,
             pos: transform.translation,
+            target: target.0,
+            target_layer: GameLayer::Npc,
         };
 
         active_heads.use_ammo(time.elapsed_secs());

src/abilities/thrown.rs

@@ -1,14 +1,7 @@
 use super::TriggerThrow;
 use crate::{
-    GameState,
-    aim::AimState,
-    billboards::Billboard,
-    hitpoints::Hit,
-    loading_assets::GameAssets,
-    physics_layers::GameLayer,
-    player::{Player, PlayerRig},
-    sounds::PlaySound,
-    utils::sprite_3d_animation::AnimationTimer,
+    GameState, billboards::Billboard, hitpoints::Hit, loading_assets::GameAssets,
+    physics_layers::GameLayer, sounds::PlaySound, utils::sprite_3d_animation::AnimationTimer,
 };
 use avian3d::prelude::*;
 use bevy::{pbr::NotShadowCaster, prelude::*};
@@ -85,8 +78,7 @@ fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Spr
 fn on_trigger_state(
     trigger: Trigger<TriggerThrow>,
     mut commands: Commands,
-    aim: Res<AimState>,
-    target_transform: Query<&Transform, (Without<Player>, Without<PlayerRig>)>,
+    query_transform: Query<&Transform>,
     assets: Res<GameAssets>,
 ) {
     let state = trigger.event().0;
@@ -95,8 +87,8 @@ fn on_trigger_state(
 
     const SPEED: f32 = 35.;
 
-    let vel = if let Some(target) = aim.target {
-        let t = target_transform
+    let vel = if let Some(target) = state.target {
+        let t = query_transform
             .get(target)
             .expect("target must have transform");
 
@@ -122,7 +114,7 @@ fn on_trigger_state(
             Collider::sphere(0.5),
             CollisionLayers::new(
                 LayerMask(GameLayer::Projectile.to_bits()),
-                LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
+                LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
             ),
             RigidBody::Dynamic,
             Mass(0.01),

src/ai/mod.rs

@@ -0,0 +1,45 @@
+use bevy::prelude::*;
+
+use crate::{
+    GameState,
+    abilities::{TriggerData, TriggerThrow},
+    aim::AimTarget,
+    npc::Npc,
+};
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+pub struct Ai;
+
+pub fn plugin(app: &mut App) {
+    app.add_systems(Update, update.run_if(in_state(GameState::Playing)));
+}
+
+fn update(
+    mut commands: Commands,
+    mut query: Query<(&mut Npc, &AimTarget, &Transform), With<Ai>>,
+    time: Res<Time>,
+) {
+    for (mut npc, target, t) in query.iter_mut() {
+        if target.0.is_none() {
+            continue;
+        }
+
+        let can_shoot_again = npc.last_use + 1. < time.elapsed_secs();
+
+        if can_shoot_again && npc.has_ammo() {
+            npc.last_use = time.elapsed_secs();
+            npc.ammo -= 1;
+
+            let dir = t.forward();
+
+            commands.trigger(TriggerThrow(TriggerData::new(
+                target.0,
+                dir,
+                t.rotation,
+                t.translation,
+                crate::physics_layers::GameLayer::Player,
+            )));
+        }
+    }
+}

src/aim/marker.rs

@@ -0,0 +1,60 @@
+use crate::{GameState, loading_assets::UIAssets, utils::billboards::Billboard};
+use bevy::prelude::*;
+use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
+use ops::sin;
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+struct TargetMarker;
+
+#[derive(Event)]
+pub enum MarkerEvent {
+    Spawn(Entity),
+    Despawn,
+}
+
+pub fn plugin(app: &mut App) {
+    app.add_systems(Update, move_marker.run_if(in_state(GameState::Playing)));
+    app.add_observer(marker_event);
+}
+
+fn move_marker(mut query: Query<&mut Transform, With<TargetMarker>>, time: Res<Time>) {
+    for mut transform in query.iter_mut() {
+        transform.translation = Vec3::new(0., 3. + (sin(time.elapsed_secs() * 6.) * 0.2), 0.);
+    }
+}
+
+fn marker_event(
+    trigger: Trigger<MarkerEvent>,
+    mut commands: Commands,
+    assets: Res<UIAssets>,
+    mut sprite_params: Sprite3dParams,
+    marker: Query<Entity, With<TargetMarker>>,
+) {
+    for m in marker.iter() {
+        commands.entity(m).despawn_recursive();
+    }
+
+    let MarkerEvent::Spawn(target) = trigger.event() else {
+        return;
+    };
+
+    let id = commands
+        .spawn((
+            Name::new("aim-marker"),
+            Billboard,
+            TargetMarker,
+            Transform::default(),
+            Sprite3dBuilder {
+                image: assets.head_selector.clone(),
+                pixels_per_metre: 30.,
+                alpha_mode: AlphaMode::Blend,
+                unlit: true,
+                ..default()
+            }
+            .bundle(&mut sprite_params),
+        ))
+        .id();
+
+    commands.entity(*target).add_child(id);
+}

src/aim/mod.rs

@@ -1,114 +1,87 @@
+mod marker;
 mod target_ui;
 
 use crate::{
     GameState,
-    billboards::Billboard,
-    loading_assets::UIAssets,
     physics_layers::GameLayer,
     player::{Player, PlayerRig},
     tb_entities::EnemySpawn,
 };
 use avian3d::prelude::*;
 use bevy::prelude::*;
-use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
-use ops::sin;
+use marker::MarkerEvent;
 use std::f32::consts::PI;
 
-#[derive(Resource, Reflect)]
-#[reflect(Resource)]
+#[derive(Component, Reflect, Default, Deref)]
+#[reflect(Component)]
+pub struct AimTarget(pub Option<Entity>);
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+#[require(AimTarget)]
 pub struct AimState {
-    pub target: Option<Entity>,
     pub range: f32,
     pub max_angle: f32,
+    pub spawn_marker: bool,
 }
 
 impl Default for AimState {
     fn default() -> Self {
         Self {
-            target: None,
             range: 80.,
             max_angle: PI / 8.,
+            spawn_marker: true,
         }
     }
 }
 
-#[derive(Component, Reflect)]
-#[reflect(Component)]
-struct Marker;
-
-#[derive(Event)]
-enum MarkerEvent {
-    Spawn(Entity),
-    Despawn,
-}
-
 pub fn plugin(app: &mut App) {
-    app.init_resource::<AimState>();
-
     app.add_plugins(target_ui::plugin);
+    app.add_plugins(marker::plugin);
 
     app.add_systems(
         Update,
-        (update, move_marker).run_if(in_state(GameState::Playing)),
+        (update_player_aim, update_npc_aim).run_if(in_state(GameState::Playing)),
     );
-    app.add_observer(marker_event);
+    app.add_systems(Update, add_aim.run_if(in_state(GameState::Playing)));
 }
 
-fn marker_event(
-    trigger: Trigger<MarkerEvent>,
+fn add_aim(
     mut commands: Commands,
-    assets: Res<UIAssets>,
-    mut sprite_params: Sprite3dParams,
-    marker: Query<Entity, With<Marker>>,
+    query: Query<Entity, Added<Player>>,
+    query2: Query<Entity, Added<EnemySpawn>>,
 ) {
-    for m in marker.iter() {
-        commands.entity(m).despawn_recursive();
+    for e in query.iter() {
+        commands.entity(e).insert(AimState::default());
+    }
+    for e in query2.iter() {
+        commands.entity(e).insert(AimState::default());
+    }
 }
 
-    let MarkerEvent::Spawn(target) = trigger.event() else {
-        return;
-    };
-
-    let id = commands
-        .spawn((
-            Name::new("aim-marker"),
-            Billboard,
-            Marker,
-            Transform::default(),
-            Sprite3dBuilder {
-                image: assets.head_selector.clone(),
-                pixels_per_metre: 30.,
-                alpha_mode: AlphaMode::Blend,
-                unlit: true,
-                ..default()
-            }
-            .bundle(&mut sprite_params),
-        ))
-        .id();
-
-    commands.entity(*target).add_child(id);
-}
-
-fn update(
+fn update_player_aim(
     mut commands: Commands,
-    mut state: ResMut<AimState>,
-    query: Query<(Entity, &Transform), With<EnemySpawn>>,
-    player_pos: Query<&Transform, With<Player>>,
-    player_rot: Query<&Transform, With<PlayerRig>>,
+    potential_targets: Query<(Entity, &Transform), With<EnemySpawn>>,
+    player_rot: Query<(&Transform, &GlobalTransform), With<PlayerRig>>,
+    mut player_aim: Query<(&AimState, &mut AimTarget), With<Player>>,
     spatial_query: SpatialQuery,
 ) {
-    let Some(player_pos) = player_pos.iter().next().map(|t| t.translation) else {
+    let Some((state, mut aim_target)) = player_aim.iter_mut().next() else {
         return;
     };
 
-    let Some(player_forward) = player_rot.iter().next().map(|t| t.forward()) else {
+    let Some((player_pos, player_forward)) = player_rot
+        .iter()
+        .next()
+        .map(|(t, global)| (global.translation(), t.forward()))
+    else {
         return;
     };
 
     let mut new_target = None;
     let mut target_distance = f32::MAX;
 
-    for (e, t) in query.iter() {
+    for (e, t) in potential_targets.iter() {
         let delta = player_pos - t.translation;
 
         let distance = delta.length();
@@ -129,20 +102,68 @@ fn update(
         }
     }
 
-    if let Some(e) = state.target {
-        if commands.get_entity(e).is_none() {
-            state.target = None;
+    if let Some(e) = &aim_target.0 {
+        if commands.get_entity(*e).is_none() {
+            aim_target.0 = None;
             return;
         }
     }
 
-    if new_target != state.target {
+    if new_target != aim_target.0 {
+        if state.spawn_marker {
             if let Some(target) = new_target {
                 commands.trigger(MarkerEvent::Spawn(target));
             } else {
                 commands.trigger(MarkerEvent::Despawn);
             }
-        state.target = new_target;
+        }
+        aim_target.0 = new_target;
+    }
+}
+
+fn update_npc_aim(
+    mut commands: Commands,
+    mut subject: Query<(&AimState, &Transform, &mut AimTarget), With<EnemySpawn>>,
+    potential_targets: Query<(Entity, &Transform), With<Player>>,
+    spatial_query: SpatialQuery,
+) {
+    for (state, t, mut aim_target) in subject.iter_mut() {
+        let (pos, forward) = (t.translation, t.forward());
+
+        let mut new_target = None;
+        let mut target_distance = f32::MAX;
+
+        for (e, t) in potential_targets.iter() {
+            let delta = pos - t.translation;
+
+            let distance = delta.length();
+
+            if distance > state.range {
+                continue;
+            }
+
+            let angle = forward.angle_between(delta.normalize());
+
+            if angle < state.max_angle && distance < target_distance {
+                if !line_of_sight(&spatial_query, pos, delta, distance) {
+                    continue;
+                }
+
+                new_target = Some(e);
+                target_distance = distance;
+            }
+        }
+
+        if let Some(e) = &aim_target.0 {
+            if commands.get_entity(*e).is_none() {
+                aim_target.0 = None;
+                return;
+            }
+        }
+
+        if new_target != aim_target.0 {
+            aim_target.0 = new_target;
+        }
     }
 }
 
@@ -171,9 +192,3 @@ fn line_of_sight(
 
     true
 }
-
-fn move_marker(mut query: Query<&mut Transform, With<Marker>>, time: Res<Time>) {
-    for mut transform in query.iter_mut() {
-        transform.translation = Vec3::new(0., 3. + (sin(time.elapsed_secs() * 6.) * 0.2), 0.);
-    }
-}

src/aim/target_ui.rs

@@ -1,7 +1,7 @@
-use super::AimState;
+use super::AimTarget;
 use crate::{
     GameState, backpack::UiHeadState, heads::HeadsImages, hitpoints::Hitpoints,
-    loading_assets::UIAssets, npc::NpcHead,
+    loading_assets::UIAssets, npc::Npc, player::Player,
 };
 use bevy::prelude::*;
 
@@ -141,14 +141,14 @@ fn update(
 
 fn sync(
     mut target: ResMut<TargetUi>,
-    aim: Res<AimState>,
-    target_data: Query<(&Hitpoints, &NpcHead)>,
+    player_target: Query<&AimTarget, With<Player>>,
+    target_data: Query<(&Hitpoints, &Npc)>,
 ) {
     let mut new_state = None;
-    if let Some(e) = aim.target {
+    if let Some(e) = player_target.iter().next().and_then(|target| target.0) {
         if let Ok((hp, head)) = target_data.get(e) {
             new_state = Some(UiHeadState {
-                head: head.0,
+                head: head.head,
                 health: hp.health(),
                 ammo: 1.,
                 reloading: None,

src/heads/mod.rs

@@ -44,7 +44,7 @@ impl HeadState {
         }
     }
 
-    fn with_ability(mut self, ability: HeadAbility) -> Self {
+    pub fn with_ability(mut self, ability: HeadAbility) -> Self {
         self.ability = ability;
         self
     }

src/main.rs

@@ -1,4 +1,5 @@
 mod abilities;
+mod ai;
 mod aim;
 mod alien;
 mod backpack;
@@ -119,6 +120,7 @@ fn main() {
         //     });
     }
 
+    app.add_plugins(ai::plugin);
     app.add_plugins(alien::plugin);
     app.add_plugins(cash::plugin);
     app.add_plugins(player::plugin);

src/npc.rs

@@ -1,6 +1,7 @@
 use crate::{
     GameState,
-    heads::HEAD_COUNT,
+    ai::Ai,
+    heads::{HEAD_COUNT, HeadState},
     hitpoints::{Hitpoints, Kill},
     keys::KeySpawn,
     player::head_id_to_str,
@@ -9,8 +10,9 @@ use crate::{
 use bevy::prelude::*;
 use std::collections::HashMap;
 
-#[derive(Component)]
-pub struct NpcHead(pub usize);
+#[derive(Component, Reflect, Deref, DerefMut)]
+#[reflect(Component)]
+pub struct Npc(HeadState);
 
 pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(GameState::Playing), init);
@@ -25,7 +27,11 @@ fn init(mut commands: Commands, query: Query<(Entity, &EnemySpawn)>) {
         let id = names[&spawn.head];
         commands
             .entity(e)
-            .insert((Hitpoints::new(100), NpcHead(id)))
+            .insert((
+                Hitpoints::new(100),
+                Npc(HeadState::new(id, 10).with_ability(crate::abilities::HeadAbility::Thrown)),
+                Ai,
+            ))
             .observe(on_kill);
     }
 }

src/physics_layers.rs

@@ -1,6 +1,7 @@
 use avian3d::prelude::PhysicsLayer;
+use bevy::reflect::Reflect;
 
-#[derive(PhysicsLayer, Clone, Copy, Debug, Default)]
+#[derive(PhysicsLayer, Clone, Copy, Debug, Default, Reflect)]
 pub enum GameLayer {
     #[default]
     Level,