Throw projectile (#19)

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);
+    }
+}