ammo system

* heads have abilities
* health and ammo shows in ui

src/abilities/gun.rs

@@ -1,4 +1,4 @@
-use super::{Projectile, TriggerState};
+use super::{Projectile, TriggerGun};
 use crate::{
     GameState,
     aim::AimState,
@@ -50,77 +50,60 @@ fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Spr
 }
 
 fn on_trigger_state(
-    trigger: Trigger<TriggerState>,
+    trigger: Trigger<TriggerGun>,
     mut commands: Commands,
     aim: Res<AimState>,
-    player_rot: Query<&Transform, With<PlayerRig>>,
-    player: Query<(&Transform, &Player)>,
     target_transform: Query<&Transform, (Without<Player>, Without<PlayerRig>)>,
     time: Res<Time>,
     mut polyline_materials: ResMut<Assets<PolylineMaterial>>,
     mut polylines: ResMut<Assets<Polyline>>,
 ) {
-    if matches!(trigger.event(), TriggerState::Active) {
-        let Some((player_pos, player_head)) =
-            player.iter().next().map(|(t, p)| (t.translation, p.0))
-        else {
-            return;
-        };
+    let state = trigger.0;
 
-        // TODO: proper weapon classes
-        if ![2, 3, 9].contains(&player_head) {
-            return;
-        }
+    commands.trigger(PlaySound::Gun);
 
-        commands.trigger(PlaySound::Gun);
+    let rotation = if let Some(target) = aim.target {
+        let t = target_transform
+            .get(target)
+            .expect("target must have transform");
+        Transform::from_translation(state.pos)
+            .looking_at(t.translation, Vec3::Y)
+            .rotation
+    } else {
+        state.rot.mul_quat(Quat::from_rotation_y(PI))
+    };
 
-        let Some(rotation) = player_rot.iter().next().map(|t| t.rotation) else {
-            return;
-        };
+    let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
+    t.translation += t.forward().as_vec3() * 2.;
 
-        let rotation = if let Some(target) = aim.target {
-            let t = target_transform
-                .get(target)
-                .expect("target must have transform");
-            Transform::from_translation(player_pos)
-                .looking_at(t.translation, Vec3::Y)
-                .rotation
-        } else {
-            rotation.mul_quat(Quat::from_rotation_y(PI))
-        };
-
-        let mut t = Transform::from_translation(player_pos).with_rotation(rotation);
-        t.translation += t.forward().as_vec3() * 2.;
-
-        commands
-            .spawn((
-                Name::new("projectile-gun"),
-                GunProjectile {
-                    time: time.elapsed_secs(),
-                },
-                Projectile { damage: 10 },
-                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()),
-                ),
-                Sensor,
-                Visibility::default(),
-                t,
-            ))
-            .with_child(PolylineBundle {
-                polyline: PolylineHandle(polylines.add(Polyline {
-                    vertices: vec![Vec3::Z * 2., Vec3::Z * -2.],
-                })),
-                material: PolylineMaterialHandle(polyline_materials.add(PolylineMaterial {
-                    width: 10.0,
-                    color: LinearRgba::rgb(0.9, 0.9, 0.),
-                    perspective: false,
-                    ..default()
-                })),
+    commands
+        .spawn((
+            Name::new("projectile-gun"),
+            GunProjectile {
+                time: time.elapsed_secs(),
+            },
+            Projectile { damage: 10 },
+            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()),
+            ),
+            Sensor,
+            Visibility::default(),
+            t,
+        ))
+        .with_child(PolylineBundle {
+            polyline: PolylineHandle(polylines.add(Polyline {
+                vertices: vec![Vec3::Z * 2., Vec3::Z * -2.],
+            })),
+            material: PolylineMaterialHandle(polyline_materials.add(PolylineMaterial {
+                width: 10.0,
+                color: LinearRgba::rgb(0.9, 0.9, 0.),
+                perspective: false,
                 ..default()
-            });
-    }
+            })),
+            ..default()
+        });
 }
 
 fn update(mut query: Query<&mut Transform, With<GunProjectile>>) {