Throw projectile (#19)

src/abilities/gun.rs

@@ -1,13 +1,12 @@
+use super::{Projectile, TriggerState};
 use crate::{
     GameState,
     aim::AimState,
     billboards::Billboard,
     loading_assets::GameAssets,
-    npc::Hit,
     physics_layers::GameLayer,
     player::{Player, PlayerRig},
     sounds::PlaySound,
-    tb_entities::EnemySpawn,
     utils::sprite_3d_animation::AnimationTimer,
 };
 use avian3d::prelude::{
@@ -19,18 +18,12 @@ use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
 use std::f32::consts::PI;
 
 #[derive(Component)]
-struct Shot {
+struct GunProjectile {
     time: f32,
 }
 
 const MAX_SHOT_AGES: f32 = 1.;
 
-#[derive(Event, Reflect)]
-pub enum TriggerState {
-    Active,
-    Inactive,
-}
-
 #[derive(Resource)]
 struct ShotAssets {
     image: Handle<Image>,
@@ -41,7 +34,7 @@ pub fn plugin(app: &mut App) {
     app.add_systems(OnEnter(GameState::Playing), setup);
     app.add_systems(
         Update,
-        (update, shot_collision, enemy_hit, timeout).run_if(in_state(GameState::Playing)),
+        (update, shot_collision, timeout).run_if(in_state(GameState::Playing)),
     );
     app.add_observer(on_trigger_state);
 }
@@ -61,19 +54,26 @@ fn on_trigger_state(
     mut commands: Commands,
     aim: Res<AimState>,
     player_rot: Query<&Transform, With<PlayerRig>>,
-    player_pos: Query<&Transform, With<Player>>,
+    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) {
-        commands.trigger(PlaySound::Gun);
+        let Some((player_pos, player_head)) =
-
+            player.iter().next().map(|(t, p)| (t.translation, p.0))
-        let Some(player_pos) = player_pos.iter().next().map(|t| t.translation) else {
+        else {
             return;
         };
 
+        // TODO: proper weapon classes
+        if ![2, 3, 9].contains(&player_head) {
+            return;
+        }
+
+        commands.trigger(PlaySound::Gun);
+
         let Some(rotation) = player_rot.iter().next().map(|t| t.rotation) else {
             return;
         };
@@ -94,11 +94,16 @@ fn on_trigger_state(
 
         commands
             .spawn((
-                Shot {
+                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::ALL),
+                CollisionLayers::new(
+                    LayerMask(GameLayer::Projectile.to_bits()),
+                    LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
+                ),
                 Sensor,
                 Visibility::default(),
                 t,
@@ -118,54 +123,32 @@ fn on_trigger_state(
     }
 }
 
-fn update(mut query: Query<&mut Transform, With<Shot>>) {
+fn update(mut query: Query<&mut Transform, With<GunProjectile>>) {
     for mut transform in query.iter_mut() {
         let forward = transform.forward();
         transform.translation += forward * 2.;
     }
 }
 
-fn timeout(mut commands: Commands, query: Query<(Entity, &Shot)>, time: Res<Time>) {
+fn timeout(mut commands: Commands, query: Query<(Entity, &GunProjectile)>, time: Res<Time>) {
     let current_time = time.elapsed_secs();
 
-    for (e, Shot { time }) in query.iter() {
+    for (e, GunProjectile { time }) in query.iter() {
         if current_time > time + MAX_SHOT_AGES {
             commands.entity(e).despawn_recursive();
         }
     }
 }
 
-fn enemy_hit(
-    mut commands: Commands,
-    mut collision_event_reader: EventReader<CollisionStarted>,
-    query_npc: Query<&EnemySpawn>,
-) {
-    for CollisionStarted(e1, e2) in collision_event_reader.read() {
-        if !(query_npc.contains(*e1) || query_npc.contains(*e2)) {
-            continue;
-        }
-
-        let enemy_entity = if query_npc.contains(*e1) { *e1 } else { *e2 };
-
-        commands.entity(enemy_entity).trigger(Hit { damage: 20 });
-    }
-}
-
 fn shot_collision(
     mut commands: Commands,
     mut collision_event_reader: EventReader<CollisionStarted>,
-    query_shot: Query<(&Shot, &Transform)>,
+    query_shot: Query<(&GunProjectile, &Transform)>,
-    query_player: Query<&Player>,
     assets: Res<ShotAssets>,
     mut sprite_params: Sprite3dParams,
 ) {
     for CollisionStarted(e1, e2) in collision_event_reader.read() {
-        if !(query_shot.contains(*e1) || query_shot.contains(*e2)) {
+        if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
-            continue;
-        }
-        // filter out collision with player
-        // TODO: give level geo a layer and we can simply use `CollisionLayers`
-        if query_player.contains(*e1) || query_player.contains(*e2) {
             continue;
         }
 

src/abilities/mod.rs

@@ -0,0 +1,49 @@
+mod gun;
+mod thrown;
+
+use crate::{GameState, npc::Hit, tb_entities::EnemySpawn};
+use avian3d::prelude::*;
+use bevy::prelude::*;
+
+#[derive(Component)]
+pub struct Projectile {
+    pub damage: u32,
+}
+
+#[derive(Event, Reflect)]
+pub enum TriggerState {
+    Active,
+    Inactive,
+}
+
+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)));
+}
+
+fn enemy_hit(
+    mut commands: Commands,
+    mut collision_event_reader: EventReader<CollisionStarted>,
+    query_shot: Query<&Projectile>,
+    query_npc: Query<&EnemySpawn>,
+) {
+    for CollisionStarted(e1, e2) in collision_event_reader.read() {
+        if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
+            continue;
+        }
+        if !query_npc.contains(*e1) && !query_npc.contains(*e2) {
+            continue;
+        }
+
+        let (enemy_entity, projectile) = if query_npc.contains(*e1) {
+            (*e1, query_shot.get(*e2))
+        } else {
+            (*e2, query_shot.get(*e1))
+        };
+
+        let damage = projectile.map(|p| p.damage).unwrap_or_default();
+        commands.entity(enemy_entity).trigger(Hit { damage });
+    }
+}

src/abilities/thrown.rs

@@ -0,0 +1,217 @@
+use super::TriggerState;
+use crate::{
+    GameState,
+    abilities::Projectile,
+    aim::AimState,
+    billboards::Billboard,
+    loading_assets::GameAssets,
+    physics_layers::GameLayer,
+    player::{Player, PlayerRig},
+    sounds::PlaySound,
+    utils::sprite_3d_animation::AnimationTimer,
+};
+use avian3d::prelude::*;
+use bevy::{pbr::NotShadowCaster, prelude::*};
+use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
+use std::f32::consts::PI;
+
+#[derive(Component)]
+struct ThrownProjectile;
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+struct AutoRotation(Quat);
+
+#[derive(Resource)]
+struct ShotAssets {
+    image: Handle<Image>,
+    layout: Handle<TextureAtlasLayout>,
+}
+
+pub fn plugin(app: &mut App) {
+    app.register_type::<AutoRotation>();
+
+    app.add_systems(OnEnter(GameState::Playing), setup);
+    app.add_systems(Update, shot_collision.run_if(in_state(GameState::Playing)));
+    app.add_systems(FixedUpdate, update_auto_rotation);
+    app.add_observer(on_trigger_state);
+}
+
+fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
+    let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
+    let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
+
+    commands.insert_resource(ShotAssets {
+        image: assets.impact_atlas.clone(),
+        layout: texture_atlas_layout,
+    });
+}
+
+fn launch_velocity(
+    start_pos: Vec3,
+    target_pos: Vec3,
+    initial_velocity: f32,
+    gravity: f32,
+) -> Option<Vec3> {
+    // Calculate displacement
+    let delta = target_pos - start_pos;
+
+    // Calculate horizontal distance
+    let horizontal_dist = (delta.x * delta.x + delta.z * delta.z).sqrt();
+
+    // Calculate terms for the quadratic formula
+    let v_squared = initial_velocity * initial_velocity;
+    let discriminant = v_squared * v_squared
+        - gravity * (gravity * horizontal_dist * horizontal_dist + 2.0 * delta.y * v_squared);
+
+    if discriminant < 0.0 {
+        return None;
+    }
+
+    // Calculate pitch angles
+    let term1 = v_squared / (gravity * horizontal_dist);
+    let term2 = discriminant.sqrt() / (gravity * horizontal_dist);
+
+    // let pitch_high = (term1 + term2).atan();
+    let pitch_low = (term1 - term2).atan();
+
+    // Calculate yaw angle
+    let yaw = delta.z.atan2(delta.x);
+
+    let pitch = pitch_low;
+
+    let dir_x = pitch.cos() * yaw.cos();
+    let dir_y = pitch.sin();
+    let dir_z = pitch.cos() * yaw.sin();
+
+    let result = Vec3::new(
+        initial_velocity * dir_x,
+        initial_velocity * dir_y,
+        initial_velocity * dir_z,
+    );
+
+    Some(result)
+}
+
+fn on_trigger_state(
+    trigger: Trigger<TriggerState>,
+    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;
+        };
+
+        // TODO: proper weapon classes
+        if ![0, 8, 16, 17].contains(&player_head) {
+            return;
+        }
+
+        commands.trigger(PlaySound::Throw);
+
+        let Some((rotation, player_forward)) =
+            player_rot.iter().next().map(|t| (t.rotation, t.forward()))
+        else {
+            return;
+        };
+
+        const SPEED: f32 = 35.;
+
+        let vel = if let Some(target) = aim.target {
+            let t = target_transform
+                .get(target)
+                .expect("target must have transform");
+
+            launch_velocity(
+                player_pos + player_forward.as_vec3() * 2.,
+                t.translation,
+                SPEED,
+                9.81,
+            )
+            .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,
+                Projectile { damage: 20 },
+                Collider::sphere(0.5),
+                CollisionLayers::new(
+                    LayerMask(GameLayer::Projectile.to_bits()),
+                    LayerMask(GameLayer::Npc.to_bits() | GameLayer::Level.to_bits()),
+                ),
+                RigidBody::Dynamic,
+                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(
+    mut commands: Commands,
+    mut collision_event_reader: EventReader<CollisionStarted>,
+    query_shot: Query<(&ThrownProjectile, &Transform)>,
+    assets: Res<ShotAssets>,
+    mut sprite_params: Sprite3dParams,
+) {
+    for CollisionStarted(e1, e2) in collision_event_reader.read() {
+        if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
+            continue;
+        }
+
+        let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };
+
+        let shot_pos = query_shot.get(shot_entity).unwrap().1.translation;
+
+        commands.entity(shot_entity).despawn_recursive();
+
+        let texture_atlas = TextureAtlas {
+            layout: assets.layout.clone(),
+            index: 0,
+        };
+
+        commands.trigger(PlaySound::ThrowHit);
+        commands
+            .spawn(
+                Sprite3dBuilder {
+                    image: assets.image.clone(),
+                    pixels_per_metre: 32.,
+                    alpha_mode: AlphaMode::Blend,
+                    unlit: true,
+                    ..default()
+                }
+                .bundle_with_atlas(&mut sprite_params, texture_atlas),
+            )
+            .insert((
+                Billboard,
+                Transform::from_translation(shot_pos),
+                NotShadowCaster,
+                AnimationTimer::new(Timer::from_seconds(0.02, TimerMode::Repeating)),
+            ));
+    }
+}
+
+fn update_auto_rotation(mut query: Query<(&AutoRotation, &mut Transform)>) {
+    for (auto_rotation, mut transform) in query.iter_mut() {
+        transform.rotate_local(auto_rotation.0);
+    }
+}

src/aim/mod.rs

@@ -24,7 +24,7 @@ impl Default for AimState {
     fn default() -> Self {
         Self {
             target: None,
-            range: 40.,
+            range: 80.,
             max_angle: PI / 8.,
         }
     }

src/control/controls.rs

@@ -1,5 +1,5 @@
 use crate::{
-    GameState, backpack::BackpackAction, heads_ui::SelectActiveHead, shooting::TriggerState,
+    GameState, abilities::TriggerState, backpack::BackpackAction, heads_ui::SelectActiveHead,
 };
 use bevy::{
     input::{

src/loading_assets.rs

@@ -19,6 +19,11 @@ pub struct AudioAssets {
     #[asset(path = "sfx/ui/selection.ogg")]
     pub selection: Handle<AudioSource>,
 
+    #[asset(path = "sfx/abilities/throw.ogg")]
+    pub throw: Handle<AudioSource>,
+    #[asset(path = "sfx/abilities/throw-explosion.ogg")]
+    pub throw_explosion: Handle<AudioSource>,
+
     #[asset(path = "sfx/ui/backpack_open.ogg")]
     pub backpack_open: Handle<AudioSource>,
     #[asset(path = "sfx/ui/backpack_close.ogg")]
@@ -62,6 +67,9 @@ pub struct GameAssets {
     #[asset(path = "models/cash.glb#Scene0")]
     pub mesh_cash: Handle<Scene>,
 
+    #[asset(path = "models/head_misc/molotov_cocktail.glb#Scene0")]
+    pub molotov: Handle<Scene>,
+
     #[asset(path = "models/alien_naked.glb#Scene0")]
     pub mesh_alien: Handle<Scene>,
 

src/main.rs

@@ -1,3 +1,4 @@
+mod abilities;
 mod aim;
 mod alien;
 mod backpack;
@@ -15,7 +16,6 @@ mod npc;
 mod physics_layers;
 mod platforms;
 mod player;
-mod shooting;
 mod sounds;
 mod tb_entities;
 mod utils;
@@ -102,7 +102,6 @@ fn main() {
     app.add_plugins(movables::plugin);
     app.add_plugins(billboards::plugin);
     app.add_plugins(aim::plugin);
-    app.add_plugins(shooting::plugin);
     app.add_plugins(npc::plugin);
     app.add_plugins(keys::plugin);
     app.add_plugins(squish_animation::plugin);
@@ -114,6 +113,7 @@ fn main() {
     app.add_plugins(loading_assets::LoadingPlugin);
     app.add_plugins(loading_map::plugin);
     app.add_plugins(sprite_3d_animation::plugin);
+    app.add_plugins(abilities::plugin);
 
     app.init_state::<GameState>();
 

src/player.rs

@@ -26,7 +26,7 @@ use bevy::{
 use std::time::Duration;
 
 #[derive(Component, Default)]
-pub struct Player;
+pub struct Player(pub usize);
 
 #[derive(Component, Default)]
 struct PlayerAnimations;
@@ -94,7 +94,7 @@ fn spawn(
     commands
         .spawn((
             Name::from("player"),
-            Player,
+            Player(0),
             CameraTarget,
             transform,
             Visibility::default(),
@@ -258,11 +258,18 @@ fn update_head(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
     head: Query<Entity, With<PlayerHead>>,
+    mut player: Query<&mut Player>,
 ) {
     let Ok(head) = head.get_single() else {
         return;
     };
 
+    let Ok(mut player) = player.get_single_mut() else {
+        return;
+    };
+
+    player.0 = trigger.0;
+
     let head_str = head_id_to_str(trigger.0);
 
     commands.trigger(PlaySound::Head(head_str.to_string()));

src/sounds.rs

@@ -6,6 +6,8 @@ pub enum PlaySound {
     Hit,
     KeyCollect,
     Gun,
+    Throw,
+    ThrowHit,
     Gate,
     CashCollect,
     Selection,
@@ -40,6 +42,8 @@ fn spawn_sounds(
         PlaySound::Gate => assets.gate.clone(),
         PlaySound::CashCollect => assets.cash.clone(),
         PlaySound::Selection => assets.selection.clone(),
+        PlaySound::Throw => assets.throw.clone(),
+        PlaySound::ThrowHit => assets.throw_explosion.clone(),
         PlaySound::Backpack { open } => {
             if *open {
                 assets.backpack_open.clone()