ammo system

* heads have abilities * health and ammo shows in ui
2025-04-02 01:35:02 +08:00
parent 8187eb58a9
commit 01e6e944d3
13 changed files with 360 additions and 234 deletions
--- a/src/abilities/gun.rs
+++ b/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>>) {
--- a/src/abilities/mod.rs
+++ b/src/abilities/mod.rs
@@ -1,7 +1,13 @@
 mod gun;
 mod thrown;

-use crate::{GameState, npc::Hit, tb_entities::EnemySpawn};
+use crate::{
+    GameState,
+    active_heads::ActiveHeads,
+    npc::Hit,
+    player::{Player, PlayerRig},
+    tb_entities::EnemySpawn,
+};
 use avian3d::prelude::*;
 use bevy::prelude::*;

@@ -16,11 +22,33 @@ pub enum TriggerState {
    Inactive,
 }

+#[derive(Debug, Copy, Clone, PartialEq, Reflect)]
+pub enum HeadAbility {
+    None,
+    Arrow,
+    Thrown,
+    Gun,
+}
+
+#[derive(Debug, Reflect, Clone, Copy)]
+pub struct PlayerTriggerState {
+    dir: Dir3,
+    rot: Quat,
+    pos: Vec3,
+}
+
+#[derive(Event, Reflect)]
+pub struct TriggerGun(pub PlayerTriggerState);
+#[derive(Event, Reflect)]
+pub struct TriggerThrow(pub PlayerTriggerState);
+
 pub fn plugin(app: &mut App) {
    app.add_plugins(gun::plugin);
    app.add_plugins(thrown::plugin);

    app.add_systems(Update, enemy_hit.run_if(in_state(GameState::Playing)));
+
+    app.add_observer(on_trigger_state);
 }

 fn enemy_hit(
@@ -47,3 +75,44 @@ fn enemy_hit(
        commands.entity(enemy_entity).trigger(Hit { damage });
    }
 }
+
+fn on_trigger_state(
+    trigger: Trigger<TriggerState>,
+    mut commands: Commands,
+    player_rot: Query<&Transform, With<PlayerRig>>,
+    player_transform: Query<&Transform, With<Player>>,
+    mut active_heads: ResMut<ActiveHeads>,
+) {
+    if matches!(trigger.event(), TriggerState::Active) {
+        let Some(state) = active_heads.current() else {
+            return;
+        };
+
+        if !state.has_ammo() {
+            //TOOD: play sound
+            return;
+        }
+
+        let Some(transform) = player_transform.iter().next().copied() else {
+            return;
+        };
+
+        let Some((rot, dir)) = player_rot.iter().next().map(|t| (t.rotation, t.forward())) else {
+            return;
+        };
+
+        let trigger_state = PlayerTriggerState {
+            dir,
+            rot,
+            pos: transform.translation,
+        };
+
+        active_heads.use_ammo();
+
+        match state.ability {
+            HeadAbility::Thrown => commands.trigger(TriggerThrow(trigger_state)),
+            HeadAbility::Gun => commands.trigger(TriggerGun(trigger_state)),
+            _ => (),
+        };
+    }
+}
--- a/src/abilities/thrown.rs
+++ b/src/abilities/thrown.rs
@@ -1,4 +1,4 @@
-use super::TriggerState;
+use super::TriggerThrow;
 use crate::{
    GameState,
    aim::AimState,
@@ -83,77 +83,58 @@ fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Spr
 }

 fn on_trigger_state(
-    trigger: Trigger<TriggerState>,
+    trigger: Trigger<TriggerThrow>,
    mut commands: Commands,
    aim: Res<AimState>,
-    player_rot: Query<&Transform, With<PlayerRig>>,
-    player: Query<(&Transform, &Player)>,
    target_transform: Query<&Transform, (Without<Player>, Without<PlayerRig>)>,
    assets: Res<GameAssets>,
 ) {
-    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.event().0;

-        // TODO: proper weapon classes
-        if ![0, 8, 16, 17].contains(&player_head) {
-            return;
-        }
+    commands.trigger(PlaySound::Throw);

-        commands.trigger(PlaySound::Throw);
+    const SPEED: f32 = 35.;

-        let Some((rotation, player_forward)) =
-            player_rot.iter().next().map(|t| (t.rotation, t.forward()))
-        else {
-            return;
-        };
+    let vel = if let Some(target) = aim.target {
+        let t = target_transform
+            .get(target)
+            .expect("target must have transform");

-        const SPEED: f32 = 35.;
+        launch_velocity(
+            state.pos + state.dir.as_vec3() * 2.,
+            t.translation,
+            SPEED,
+            9.81,
+        )
+        .map(|(low, _)| low)
+        .unwrap()
+    } else {
+        state.rot.mul_quat(Quat::from_rotation_y(-PI / 2.))
+            * (Vec3::new(2., 1., 0.).normalize() * SPEED)
+    };

-        let vel = if let Some(target) = aim.target {
-            let t = target_transform
-                .get(target)
-                .expect("target must have transform");
+    let t = Transform::from_translation(state.pos);

-            launch_velocity(
-                player_pos + player_forward.as_vec3() * 2.,
-                t.translation,
-                SPEED,
-                9.81,
-            )
-            .map(|(low, _)| low)
-            .unwrap()
-        } else {
-            rotation.mul_quat(Quat::from_rotation_y(-PI / 2.))
-                * (Vec3::new(2., 1., 0.).normalize() * SPEED)
-        };
-
-        let t = Transform::from_translation(player_pos);
-
-        commands
-            .spawn((
-                Name::new("projectile-thrown"),
-                ThrownProjectile,
-                Collider::sphere(0.5),
-                CollisionLayers::new(
-                    LayerMask(GameLayer::Projectile.to_bits()),
-                    LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
-                ),
-                RigidBody::Dynamic,
-                Mass(0.01),
-                LinearVelocity(vel),
-                Visibility::default(),
-                t,
-            ))
-            .with_child((
-                AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
-                Transform::from_scale(Vec3::splat(10.)),
-                SceneRoot(assets.molotov.clone()),
-            ));
-    }
+    commands
+        .spawn((
+            Name::new("projectile-thrown"),
+            ThrownProjectile,
+            Collider::sphere(0.5),
+            CollisionLayers::new(
+                LayerMask(GameLayer::Projectile.to_bits()),
+                LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
+            ),
+            RigidBody::Dynamic,
+            Mass(0.01),
+            LinearVelocity(vel),
+            Visibility::default(),
+            t,
+        ))
+        .with_child((
+            AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
+            Transform::from_scale(Vec3::splat(10.)),
+            SceneRoot(assets.molotov.clone()),
+        ));
 }

 fn shot_collision(