Throw projectile (#19)

src/abilities/gun.rs

@@ -0,0 +1,184 @@
+use super::{Projectile, TriggerState};
+use crate::{
+    GameState,
+    aim::AimState,
+    billboards::Billboard,
+    loading_assets::GameAssets,
+    physics_layers::GameLayer,
+    player::{Player, PlayerRig},
+    sounds::PlaySound,
+    utils::sprite_3d_animation::AnimationTimer,
+};
+use avian3d::prelude::{
+    Collider, CollisionLayers, CollisionStarted, LayerMask, PhysicsLayer, Sensor,
+};
+use bevy::{pbr::NotShadowCaster, prelude::*};
+use bevy_polyline::prelude::*;
+use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
+use std::f32::consts::PI;
+
+#[derive(Component)]
+struct GunProjectile {
+    time: f32,
+}
+
+const MAX_SHOT_AGES: f32 = 1.;
+
+#[derive(Resource)]
+struct ShotAssets {
+    image: Handle<Image>,
+    layout: Handle<TextureAtlasLayout>,
+}
+
+pub fn plugin(app: &mut App) {
+    app.add_systems(OnEnter(GameState::Playing), setup);
+    app.add_systems(
+        Update,
+        (update, shot_collision, timeout).run_if(in_state(GameState::Playing)),
+    );
+    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 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>)>,
+    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;
+        };
+
+        // 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;
+        };
+
+        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()
+                })),
+                ..default()
+            });
+    }
+}
+
+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, &GunProjectile)>, time: Res<Time>) {
+    let current_time = time.elapsed_secs();
+
+    for (e, GunProjectile { time }) in query.iter() {
+        if current_time > time + MAX_SHOT_AGES {
+            commands.entity(e).despawn_recursive();
+        }
+    }
+}
+
+fn shot_collision(
+    mut commands: Commands,
+    mut collision_event_reader: EventReader<CollisionStarted>,
+    query_shot: Query<(&GunProjectile, &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
+            .spawn(
+                Sprite3dBuilder {
+                    image: assets.image.clone(),
+                    pixels_per_metre: 128.,
+                    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.01, TimerMode::Repeating)),
+            ));
+    }
+}