blackout/src/sound/icon.rs

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

use bevy::{asset::HandleId, prelude::*, transform::TransformSystem};
use bevy_synthizer::{DistanceMax, DistanceRef, Rolloff, Sound};

use rand::random;

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

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

impl Default for SoundIcon {
    fn default() -> Self {
        let seconds = random::<f32>() + 4.5;
        let mut icon = Self {
            sound: "".into(),
            gain: 1.,
            pitch: 1.,
            reference_distance: None,
            max_distance: None,
            rolloff: None,
            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 added(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    icons: Query<(Entity, &SoundIcon), Added<SoundIcon>>,
) {
    for (entity, icon) in icons.iter() {
        let buffer = asset_server.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 = icon.rolloff;
        commands.run_if_exists(entity, move |mut entity| {
            entity.insert(Sound {
                buffer,
                gain,
                pitch,
                looping,
                paused: true,
                ..default()
            });
            if let Some(v) = reference_distance {
                entity.insert(DistanceRef(v));
            }
            if let Some(v) = max_distance {
                entity.insert(DistanceMax(v));
            }
            if let Some(v) = rolloff {
                entity.insert(Rolloff(v));
            }
        });
    }
}

fn update<S>(
    mut commands: Commands,
    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,
        Option<&DistanceRef>,
        Option<&DistanceMax>,
        Option<&Rolloff>,
    )>,
    asset_server: Res<AssetServer>,
) 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,
            distance_ref,
            distance_max,
            rolloff,
        ) in icons.iter_mut()
        {
            let entity = if visibility.is_some() {
                Some(icon_entity)
            } else if parent.is_some() {
                Some(**parent.unwrap())
            } else {
                None
            };
            if let Some(entity) = entity {
                if visible.contains(&entity) {
                    if sound.looping {
                        sound.paused = false;
                    } else if let Some(interval) = icon.interval.as_mut() {
                        interval.tick(time.delta());
                        if interval.finished() {
                            sound.paused = false;
                            sound.restart = true;
                            interval.reset();
                        }
                    }
                    let buffer = asset_server.get_handle(icon.sound);
                    if sound.buffer != buffer {
                        sound.buffer = buffer;
                    }
                    sound.gain = icon.gain;
                    sound.pitch = icon.pitch;
                    sound.looping = icon.interval.is_none();
                    if let Some(v) = icon.reference_distance {
                        let insert = if let Some(v2) = distance_ref {
                            v != **v2
                        } else {
                            true
                        };
                        if insert {
                            commands.run_if_exists(icon_entity, move |mut entity| {
                                entity.insert(DistanceRef(v));
                            })
                        }
                    } else if distance_ref.is_some() {
                        commands.run_if_exists(icon_entity, |mut entity| {
                            entity.remove::<DistanceRef>();
                        });
                    }
                    if let Some(v) = icon.max_distance {
                        let insert = if let Some(v2) = distance_max {
                            v != **v2
                        } else {
                            true
                        };
                        if insert {
                            commands.run_if_exists(icon_entity, move |mut entity| {
                                entity.insert(DistanceMax(v));
                            })
                        }
                    } else if distance_max.is_some() {
                        commands.run_if_exists(icon_entity, |mut entity| {
                            entity.remove::<DistanceMax>();
                        });
                    }
                    if let Some(v) = icon.rolloff {
                        let insert = if let Some(v2) = rolloff {
                            v != **v2
                        } else {
                            true
                        };
                        if insert {
                            commands.run_if_exists(icon_entity, move |mut entity| {
                                entity.insert(Rolloff(v));
                            })
                        }
                    } else if rolloff.is_some() {
                        commands.run_if_exists(icon_entity, |mut entity| {
                            entity.remove::<Rolloff>();
                        });
                    }
                } else if !sound.paused {
                    sound.paused = true;
                    sound.restart = true;
                }
            }
        }
    }
}

fn exploration_focus_changed(
    mut focused: Query<(Entity, Option<&Children>), Changed<ExplorationFocused>>,
    mut icons: Query<&mut SoundIcon>,
) {
    const ICON_GAIN: f64 = 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: f64 = 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;
                }
            }
        }
    }
}

fn reset_timer_on_visibility_gain(
    mut events: EventReader<VisibilityChanged>,
    player: Query<Entity, With<Player>>,
    mut icons: Query<&mut SoundIcon>,
    children: Query<&Children>,
) {
    for event in events.iter() {
        if let VisibilityChanged::Gained { viewer, viewed } = event {
            if player.get(*viewer).is_ok() {
                let mut targets = vec![];
                if icons.get(*viewed).is_ok() {
                    targets.push(viewed);
                }
                if let Ok(children) = children.get(*viewed) {
                    for child in children.iter() {
                        if icons.get(*child).is_ok() {
                            targets.push(&*child);
                        }
                    }
                }
                for icon in targets.iter_mut() {
                    if let Ok(mut icon) = icons.get_mut(**icon) {
                        if let Some(timer) = icon.interval.as_mut() {
                            timer.set_elapsed(timer.duration());
                        }
                    }
                }
            }
        }
    }
}

#[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<S> Plugin for SoundIconPlugin<'static, S>
where
    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
{
    fn build(&self, app: &mut App) {
        app.add_system(added)
            .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),
            )
            .add_system_to_stage(CoreStage::PostUpdate, reset_timer_on_visibility_gain);
    }
}