HEDZReloaded/src/abilities/thrown.rs

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_ballistic::launch_velocity;
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 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,
            )
            .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,
                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);
    }
}