blackout/src/sound/icon.rs

use std::{fmt::Debug, hash::Hash, time::Duration};

use bevy::{asset::HandleId, prelude::*, transform::TransformSystem};
use bevy_openal::{Buffer, Sound, SoundState};

use rand::random;

use crate::{
    commands::RunIfExistsExt,
    core::Player,
    exploration::ExplorationFocused,
    visibility::{Visible, VisibleEntities},
};

#[derive(Component, Clone, Debug)]
pub struct SoundIcon {
    pub sound: HandleId,
    pub gain: f32,
    pub pitch: f32,
    pub reference_distance: f32,
    pub max_distance: f32,
    pub rolloff_factor: f32,
    pub interval: Option<Timer>,
}

impl Default for SoundIcon {
    fn default() -> Self {
        let seconds = random::<f32>() + 4.5;
        let mut icon = Self {
            sound: "".into(),
            gain: 0.3,
            pitch: 1.,
            reference_distance: 1.,
            max_distance: f32::MAX,
            rolloff_factor: 1.,
            interval: Some(Timer::from_seconds(seconds, true)),
        };
        if let Some(ref mut interval) = icon.interval {
            let seconds = Duration::from_secs_f32(seconds - 0.1);
            interval.set_elapsed(seconds);
        }
        icon
    }
}

#[derive(Bundle, Clone, Debug, Default)]
pub struct SoundIconBundle {
    pub sound_icon: SoundIcon,
    pub transform: Transform,
    pub global_transform: GlobalTransform,
}

fn add_sound_icon_sounds(
    mut commands: Commands,
    icons: Query<(Entity, &SoundIcon), Added<SoundIcon>>,
    assets: Res<Assets<Buffer>>,
) {
    for (entity, icon) in icons.iter() {
        let buffer = assets.get_handle(icon.sound);
        let gain = icon.gain;
        let pitch = icon.pitch;
        let looping = icon.interval.is_none();
        let reference_distance = icon.reference_distance;
        let max_distance = icon.max_distance;
        let rolloff_factor = icon.rolloff_factor;
        commands.run_if_exists(entity, move |mut entity| {
            entity.insert(Sound {
                buffer,
                gain,
                pitch,
                looping,
                state: SoundState::Stopped,
                reference_distance,
                max_distance,
                rolloff_factor,
                ..default()
            });
        });
    }
}

fn update<S>(
    config: Res<SoundIconConfig<S>>,
    state: Res<State<S>>,
    time: Res<Time>,
    viewers: Query<&VisibleEntities, With<Player>>,
    mut icons: Query<(
        Entity,
        &mut SoundIcon,
        Option<&Visible>,
        Option<&Parent>,
        &mut Sound,
    )>,
    buffers: Res<Assets<Buffer>>,
) where
    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
{
    if !(*config).states.is_empty() && !config.states.contains(state.current()) {
        return;
    }
    for visible in viewers.iter() {
        for (icon_entity, mut icon, visibility, parent, mut sound) in icons.iter_mut() {
            let entity = if visibility.is_some() {
                icon_entity
            } else {
                **parent.unwrap()
            };
            if visible.contains(&entity) {
                let looping = sound.looping;
                if looping {
                    sound.state = SoundState::Playing;
                } else if let Some(interval) = icon.interval.as_mut() {
                    interval.tick(time.delta());
                    if interval.finished() {
                        sound.state = SoundState::Playing;
                        interval.reset();
                    }
                }
                let buffer = buffers.get_handle(icon.sound);
                sound.looping = icon.interval.is_none();
                if sound.buffer != buffer {
                    sound.buffer = buffer;
                }
                sound.gain = icon.gain;
                sound.pitch = icon.pitch;
                sound.reference_distance = icon.reference_distance;
                sound.max_distance = icon.max_distance;
                sound.rolloff_factor = icon.rolloff_factor;
            } else {
                sound.state = SoundState::Stopped;
            }
        }
    }
}

fn exploration_focus_changed(
    mut focused: Query<(Entity, Option<&Children>), Changed<ExplorationFocused>>,
    mut icons: Query<&mut SoundIcon>,
) {
    const ICON_GAIN: f32 = 3.;
    for (entity, children) in focused.iter_mut() {
        if let Ok(mut icon) = icons.get_mut(entity) {
            icon.gain *= ICON_GAIN;
        }
        if let Some(children) = children {
            for child in children.iter() {
                if let Ok(mut icon) = icons.get_mut(*child) {
                    icon.gain *= ICON_GAIN;
                }
            }
        }
    }
}

fn exploration_focus_removed(
    removed: RemovedComponents<ExplorationFocused>,
    mut query: Query<&mut SoundIcon>,
    children: Query<&Children>,
) {
    const ICON_GAIN: f32 = 3.;
    for entity in removed.iter() {
        if let Ok(mut icon) = query.get_mut(entity) {
            icon.gain /= ICON_GAIN;
        }
        if let Ok(children) = children.get(entity) {
            for child in children.iter() {
                if let Ok(mut icon) = query.get_mut(*child) {
                    icon.gain /= ICON_GAIN;
                }
            }
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct SoundIconConfig<S> {
    pub states: Vec<S>,
}

pub struct SoundIconPlugin<'a, S>(std::marker::PhantomData<&'a S>);

impl<'a, S> Default for SoundIconPlugin<'a, S> {
    fn default() -> Self {
        Self(std::marker::PhantomData)
    }
}

impl<'a, S> Plugin for SoundIconPlugin<'a, S>
where
    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
    'a: 'static,
{
    fn build(&self, app: &mut App) {
        app.add_system(add_sound_icon_sounds)
            .add_system_to_stage(
                CoreStage::PostUpdate,
                update::<S>.after(TransformSystem::TransformPropagate),
            )
            .add_system_to_stage(
                CoreStage::PostUpdate,
                exploration_focus_changed.after(update::<S>),
            )
            .add_system_to_stage(
                CoreStage::PostUpdate,
                exploration_focus_removed.after(exploration_focus_changed),
            );
    }
}