From 133124408f41ecc8457a4d5082ab8a194755aee4 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Sun, 21 Jan 2024 20:48:23 -0600
Subject: [PATCH 01/10] add audio settings

---
 assets/game.yaml                       |   1 +
 assets/locales/en-US/settings.ftl      |   4 +
 src/audio.rs                           | 164 ++++++++++++++++++++++++
 src/audio/music.rs                     | 101 +++++++++++++++
 src/core.rs                            |   6 +-
 src/core/audio.rs                      |  69 ----------
 src/core/bullet.rs                     |   4 +-
 src/core/elements/crate_item.rs        |   6 +-
 src/core/elements/flappy_jellyfish.rs  |   4 +-
 src/core/elements/grenade.rs           |   8 +-
 src/core/elements/kick_bomb.rs         |   8 +-
 src/core/elements/mine.rs              |   6 +-
 src/core/elements/musket.rs            |   6 +-
 src/core/elements/sproinger.rs         |   4 +-
 src/core/elements/sword.rs             |   4 +-
 src/core/player/state.rs               |   6 +-
 src/core/player/state/states/idle.rs   |   4 +-
 src/core/player/state/states/midair.rs |   4 +-
 src/core/player/state/states/walk.rs   |   4 +-
 src/main.rs                            |   6 +-
 src/music.rs                           | 170 -------------------------
 src/sessions.rs                        |   4 +-
 src/settings.rs                        |   3 +
 src/ui/main_menu/settings.rs           |  10 ++
 src/ui/main_menu/settings/audio.rs     |  55 ++++++++
 25 files changed, 379 insertions(+), 282 deletions(-)
 create mode 100644 src/audio.rs
 create mode 100644 src/audio/music.rs
 delete mode 100644 src/core/audio.rs
 delete mode 100644 src/music.rs
 create mode 100644 src/ui/main_menu/settings/audio.rs

diff --git a/assets/game.yaml b/assets/game.yaml
index 7d2b8a5834..49b6743bb7 100644
--- a/assets/game.yaml
+++ b/assets/game.yaml
@@ -30,6 +30,7 @@ main_menu:
   menu_width: 350
 
 default_settings:
+  main_volume: 1.0
   matchmaking_server: matchmaker.bones.fishfolk.org:65534
   player_controls:
     # Gamepad controls
diff --git a/assets/locales/en-US/settings.ftl b/assets/locales/en-US/settings.ftl
index 2363951568..1d72e5d5e2 100644
--- a/assets/locales/en-US/settings.ftl
+++ b/assets/locales/en-US/settings.ftl
@@ -19,6 +19,10 @@ action = Action
 networking = Networking
 matchmaking-server = Matchmaking Server
 
+# Audio settings
+audio = Audio
+main-volume = Main Volume
+
 # Graphics settings
 graphics = Graphics
 fullscreen = Fullscreen
diff --git a/src/audio.rs b/src/audio.rs
new file mode 100644
index 0000000000..2bb8188af5
--- /dev/null
+++ b/src/audio.rs
@@ -0,0 +1,164 @@
+use std::collections::VecDeque;
+
+use bones_framework::prelude::kira::{
+    sound::{
+        static_sound::{StaticSoundHandle, StaticSoundSettings},
+        PlaybackState,
+    },
+    tween::{self, Tween},
+    Volume,
+};
+
+use crate::prelude::*;
+
+pub mod music;
+
+pub use music::*;
+
+pub fn game_plugin(game: &mut Game) {
+    game.init_shared_resource::<AudioCenter>();
+
+    let session = game.sessions.create(SessionNames::AUDIO);
+
+    // Audio doesn't do any rendering
+    session.visible = false;
+    session
+        .stages
+        .add_system_to_stage(First, music_system)
+        .add_system_to_stage(First, process_audio_events);
+}
+
+#[derive(HasSchema)]
+#[schema(no_clone)]
+pub struct AudioCenter {
+    events: VecDeque<AudioEvent>,
+    music: Option<StaticSoundHandle>,
+}
+
+impl Default for AudioCenter {
+    fn default() -> Self {
+        Self {
+            events: VecDeque::with_capacity(16),
+            music: None,
+        }
+    }
+}
+
+impl AudioCenter {
+    pub fn event(&mut self, event: AudioEvent) {
+        self.events.push_back(event);
+    }
+
+    pub fn music_state(&self) -> Option<PlaybackState> {
+        self.music.as_ref().map(StaticSoundHandle::state)
+    }
+
+    pub fn play_sound(&mut self, sound_source: Handle<AudioSource>, volume: f64) {
+        self.events.push_back(AudioEvent::PlaySound {
+            sound_source,
+            volume,
+        })
+    }
+
+    pub fn play_music(
+        &mut self,
+        sound_source: Handle<AudioSource>,
+        sound_settings: StaticSoundSettings,
+    ) {
+        self.events.push_back(AudioEvent::PlayMusic {
+            sound_source,
+            sound_settings: Box::new(sound_settings),
+        });
+    }
+}
+
+/// An audio event that may be sent to the [`AudioEvents`] resource.
+#[derive(Clone, Debug)]
+pub enum AudioEvent {
+    MainVolumeChange(f64),
+    PlayMusic {
+        sound_source: Handle<AudioSource>,
+        sound_settings: Box<StaticSoundSettings>,
+    },
+    /// Play a sound.
+    PlaySound {
+        /// The handle to the sound to play.
+        sound_source: Handle<AudioSource>,
+        /// The volume to play the sound at.
+        volume: f64,
+    },
+}
+
+#[derive(HasSchema)]
+#[schema(no_clone, no_default, opaque)]
+#[repr(C)]
+pub struct Audio {
+    handle: StaticSoundHandle,
+    volume: f64,
+}
+
+fn process_audio_events(
+    mut audio_manager: ResMut<AudioManager>,
+    mut audio_center: ResMut<AudioCenter>,
+    assets: ResInit<AssetServer>,
+    mut entities: ResMut<Entities>,
+    mut audios: CompMut<Audio>,
+    storage: Res<Storage>,
+) {
+    for event in audio_center.events.drain(..).collect::<Vec<_>>() {
+        match event {
+            AudioEvent::MainVolumeChange(main_volume) => {
+                let tween = Tween::default();
+                if let Some(music) = &mut audio_center.music {
+                    if let Err(err) = music.set_volume(main_volume * MUSIC_VOLUME, tween) {
+                        warn!("Error setting music volume: {err}");
+                    }
+                }
+                for audio in audios.iter_mut() {
+                    if let Err(err) = audio.handle.set_volume(main_volume * audio.volume, tween) {
+                        warn!("Error setting audio volume: {err}");
+                    }
+                }
+            }
+            AudioEvent::PlayMusic {
+                sound_source,
+                mut sound_settings,
+            } => {
+                if let Some(mut music) = audio_center.music.take() {
+                    let tween = Tween {
+                        start_time: kira::StartTime::Immediate,
+                        duration: MUSIC_FADE_DURATION,
+                        easing: tween::Easing::Linear,
+                    };
+                    music.stop(tween).unwrap();
+                }
+                let settings = storage.get::<Settings>().unwrap();
+                let volume = match sound_settings.volume {
+                    tween::Value::Fixed(vol) => settings.main_volume * vol.as_amplitude(),
+                    _ => settings.main_volume * MUSIC_VOLUME,
+                };
+                sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(volume));
+                let sound_data = assets.get(sound_source).with_settings(*sound_settings);
+                match audio_manager.play(sound_data) {
+                    Err(err) => warn!("Error playing music: {err}"),
+                    Ok(handle) => audio_center.music = Some(handle),
+                }
+            }
+            AudioEvent::PlaySound {
+                sound_source,
+                volume,
+            } => {
+                let sound_data = assets
+                    .get(sound_source)
+                    .with_settings(StaticSoundSettings::default().volume(volume));
+                match audio_manager.play(sound_data) {
+                    Err(err) => warn!("Error playing sound: {err}"),
+                    Ok(handle) => {
+                        let audio_ent = entities.create();
+                        audios.insert(audio_ent, Audio { handle, volume });
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/audio/music.rs b/src/audio/music.rs
new file mode 100644
index 0000000000..954c9273c2
--- /dev/null
+++ b/src/audio/music.rs
@@ -0,0 +1,101 @@
+use bones_framework::prelude::kira::{
+    sound::{static_sound::StaticSoundSettings, PlaybackState, Region},
+    tween::Tween,
+};
+
+use crate::{prelude::*, ui::main_menu::MenuPage};
+
+/// The music playback state.
+#[derive(HasSchema, Default, PartialEq, Eq)]
+#[schema(no_clone)]
+pub enum MusicState {
+    /// Music is not playing.
+    #[default]
+    None,
+    /// Playing the main menu music.
+    MainMenu,
+    /// Playing the character select music.
+    CharacterSelect,
+    /// Playing the credits music.
+    Credits,
+    /// Playing the fight music.
+    Fight {
+        /// The index of the song in the shuffled playlist.
+        idx: usize,
+    },
+}
+
+/// Bevy resource containing the in-game music playlist shuffled.
+#[derive(HasSchema, Deref, DerefMut, Clone, Default)]
+#[repr(C)]
+pub struct ShuffledPlaylist(pub SVec<Handle<AudioSource>>);
+
+/// The amount of time to spend fading the music in and out.
+pub const MUSIC_FADE_DURATION: Duration = Duration::from_millis(500);
+
+pub const MUSIC_VOLUME: f64 = 0.1;
+
+/// System that plays music according to the game mode.
+pub(super) fn music_system(
+    meta: Root<GameMeta>,
+    mut audio: ResMut<AudioCenter>,
+    mut shuffled_fight_music: ResMutInit<ShuffledPlaylist>,
+    mut music_state: ResMutInit<MusicState>,
+    ctx: Res<EguiCtx>,
+    sessions: Res<Sessions>,
+) {
+    if shuffled_fight_music.is_empty() {
+        let mut songs = meta.music.fight.clone();
+        THREAD_RNG.with(|rng| rng.shuffle(&mut songs));
+        **shuffled_fight_music = songs;
+    }
+
+    let tween = Tween {
+        start_time: kira::StartTime::Immediate,
+        duration: MUSIC_FADE_DURATION,
+        easing: kira::tween::Easing::Linear,
+    };
+    let play_settings = StaticSoundSettings::default()
+        .volume(MUSIC_VOLUME)
+        .fade_in_tween(tween);
+
+    // If we are in a game
+    if sessions.get(SessionNames::GAME).is_some() {
+        if let MusicState::Fight { idx } = &mut *music_state {
+            if let Some(PlaybackState::Stopped) = audio.music_state() {
+                *idx = (*idx + 1) % shuffled_fight_music.len();
+                audio.play_music(shuffled_fight_music[*idx], play_settings);
+            }
+        } else if let Some(song) = shuffled_fight_music.get(0) {
+            audio.play_music(*song, play_settings);
+            *music_state = MusicState::Fight { idx: 0 };
+        }
+
+    // If we are on a menu page
+    } else if sessions.get(SessionNames::MAIN_MENU).is_some() {
+        let menu_page = ctx.get_state::<MenuPage>();
+        match menu_page {
+            MenuPage::PlayerSelect | MenuPage::MapSelect { .. } | MenuPage::NetworkGame => {
+                if *music_state != MusicState::CharacterSelect {
+                    audio.play_music(
+                        meta.music.title_screen,
+                        play_settings.loop_region(Region::default()),
+                    );
+                    *music_state = MusicState::CharacterSelect;
+                }
+            }
+            MenuPage::Home | MenuPage::Settings => {
+                if *music_state != MusicState::MainMenu {
+                    audio.play_music(meta.music.title_screen, play_settings);
+                    *music_state = MusicState::MainMenu;
+                }
+            }
+            MenuPage::Credits => {
+                if *music_state != MusicState::Credits {
+                    audio.play_music(meta.music.credits, play_settings);
+                    *music_state = MusicState::Credits;
+                }
+            }
+        }
+    }
+}
diff --git a/src/core.rs b/src/core.rs
index 1a05921708..cc319696e0 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -1,5 +1,4 @@
 pub mod attachment;
-pub mod audio;
 pub mod bullet;
 pub mod camera;
 pub mod damage;
@@ -30,7 +29,7 @@ use crate::{prelude::*, settings::PlayerControlMapping};
 
 pub mod prelude {
     pub use super::{
-        attachment::*, audio::*, bullet::*, camera::*, damage::*, debug::*, editor::*, editor::*,
+        attachment::*, bullet::*, camera::*, damage::*, debug::*, editor::*, editor::*,
         elements::prelude::*, flappy_jellyfish::*, globals::*, input::*, item::*, lifetime::*,
         map::*, map_constructor::*, metadata::*, physics::*, player::*, random::*, utils::*, FPS,
         MAX_PLAYERS,
@@ -67,8 +66,7 @@ impl SessionPlugin for MatchPlugin {
     fn install(self, session: &mut Session) {
         session
             .install_plugin(DefaultSessionPlugin)
-            .install_plugin(LuaPluginLoaderSessionPlugin(self.plugins))
-            .install_plugin(audio::session_plugin);
+            .install_plugin(LuaPluginLoaderSessionPlugin(self.plugins));
 
         physics::install(session);
         input::install(session);
diff --git a/src/core/audio.rs b/src/core/audio.rs
deleted file mode 100644
index ca24a16841..0000000000
--- a/src/core/audio.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use std::collections::VecDeque;
-
-use bones_framework::prelude::kira::sound::static_sound::StaticSoundSettings;
-
-use crate::prelude::*;
-
-pub fn session_plugin(session: &mut Session) {
-    session.add_system_to_stage(Last, play_sounds);
-}
-
-/// Resource containing the audio event queue.
-#[derive(Default, HasSchema, Clone, Debug)]
-pub struct AudioEvents {
-    /// List of audio events that haven't been handled by the audio system yet.
-    pub queue: VecDeque<AudioEvent>,
-}
-
-impl AudioEvents {
-    /// Add an event to the audio event queue.
-    pub fn send(&mut self, event: AudioEvent) {
-        self.queue.push_back(event);
-    }
-
-    /// Play a sound.
-    ///
-    /// Shortcut for sending an [`AudioEvent`] with [`send()`][Self::send].
-    pub fn play(&mut self, sound_source: Handle<AudioSource>, volume: f64) {
-        self.queue.push_back(AudioEvent::PlaySound {
-            sound_source,
-            volume,
-        })
-    }
-}
-
-/// An audio event that may be sent to the [`AudioEvents`] resource.
-#[derive(Clone, Debug)]
-pub enum AudioEvent {
-    /// Play a sound.
-    PlaySound {
-        /// The handle to the sound to play.
-        sound_source: Handle<AudioSource>,
-        /// The volume to play the sound at.
-        volume: f64,
-    },
-}
-
-fn play_sounds(
-    mut audio: ResMut<AudioManager>,
-    mut audio_events: ResMut<AudioEvents>,
-    assets: Res<AssetServer>,
-) {
-    // Play all the sounds in the queue
-    for event in audio_events.queue.drain(..) {
-        match event {
-            AudioEvent::PlaySound {
-                sound_source,
-                volume,
-            } => {
-                if let Err(e) = audio.play(
-                    assets
-                        .get(sound_source)
-                        .with_settings(StaticSoundSettings::default().volume(volume)),
-                ) {
-                    warn!("Error playing sound: {e}");
-                };
-            }
-        }
-    }
-}
diff --git a/src/core/bullet.rs b/src/core/bullet.rs
index bcbd13667a..ce364d754b 100644
--- a/src/core/bullet.rs
+++ b/src/core/bullet.rs
@@ -109,7 +109,7 @@ fn update(
     collision_world: CollisionWorld,
     mut transforms: CompMut<Transform>,
     mut bullets: CompMut<Bullet>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     invincibles: CompMut<Invincibility>,
     mut emote_regions: CompMut<EmoteRegion>,
     asset_server: Res<AssetServer>,
@@ -163,7 +163,7 @@ fn update(
 
         // Bullet hit something
         if hit_player || hit_solid {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             let mut explosion_transform = *transforms.get(entity).unwrap();
             explosion_transform.translation.z += 1.0;
diff --git a/src/core/elements/crate_item.rs b/src/core/elements/crate_item.rs
index 3153f0e459..a7beabf1fa 100644
--- a/src/core/elements/crate_item.rs
+++ b/src/core/elements/crate_item.rs
@@ -191,7 +191,7 @@ fn update_thrown_crates(
     players: Comp<PlayerIdx>,
     collision_world: CollisionWorld,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     transforms: Comp<Transform>,
     spawners: Comp<DehydrateOutOfBounds>,
     invincibles: CompMut<Invincibility>,
@@ -245,7 +245,7 @@ fn update_thrown_crates(
         if colliding_with_tile && !thrown_crate.was_colliding {
             thrown_crate.was_colliding = true;
             thrown_crate.crate_break_state += 1;
-            audio_events.play(*bounce_sound, *bounce_sound_volume);
+            audio_center.play_sound(*bounce_sound, *bounce_sound_volume);
         } else if !colliding_with_tile {
             thrown_crate.was_colliding = false;
         }
@@ -297,7 +297,7 @@ fn update_thrown_crates(
             let breaking_anim_fps = *breaking_anim_fps;
             let atlas = *breaking_atlas;
 
-            audio_events.play(*break_sound, *break_sound_volume);
+            audio_center.play_sound(*break_sound, *break_sound_volume);
 
             commands.add(
                 move |mut entities: ResMutInit<Entities>,
diff --git a/src/core/elements/flappy_jellyfish.rs b/src/core/elements/flappy_jellyfish.rs
index b7986c8e94..65703fa7f1 100644
--- a/src/core/elements/flappy_jellyfish.rs
+++ b/src/core/elements/flappy_jellyfish.rs
@@ -225,7 +225,7 @@ fn explode_flappy_jellyfish(
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
     mut transforms: CompMut<Transform>,
-    mut audio_events: ResMut<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMut<CameraTraumaEvents>,
     mut sprites: CompMut<AtlasSprite>,
     mut animated_sprites: CompMut<AnimatedSprite>,
@@ -301,7 +301,7 @@ fn explode_flappy_jellyfish(
 
         entities.kill(flappy_ent);
 
-        audio_events.play(flappy_meta.explosion_sound, flappy_meta.explosion_volume);
+        audio_center.play_sound(flappy_meta.explosion_sound, flappy_meta.explosion_volume);
 
         trauma_events.send(5.0);
 
diff --git a/src/core/elements/grenade.rs b/src/core/elements/grenade.rs
index 93274c5c9b..2f03101a3c 100644
--- a/src/core/elements/grenade.rs
+++ b/src/core/elements/grenade.rs
@@ -142,7 +142,7 @@ fn update_idle_grenades(
     items_used: Comp<ItemUsed>,
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut idle_grenades: CompMut<IdleGrenade>,
     mut animated_sprites: CompMut<AnimatedSprite>,
 ) {
@@ -171,7 +171,7 @@ fn update_idle_grenades(
             animated_sprite.fps = 8.0;
 
             // Play that hissss sound
-            audio_events.play(*fuse_sound, *fuse_sound_volume);
+            audio_center.play_sound(*fuse_sound, *fuse_sound_volume);
 
             commands.add(
                 move |mut lit: CompMut<LitGrenade>,
@@ -204,7 +204,7 @@ fn update_lit_grenades(
     transforms: CompMut<Transform>,
     element_handles: Comp<ElementHandle>,
     spawners: Comp<DehydrateOutOfBounds>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut lit_grenades: CompMut<LitGrenade>,
     player_inventories: PlayerInventories,
     assets: Res<AssetServer>,
@@ -266,7 +266,7 @@ fn update_lit_grenades(
 
         // If it's time to explode
         if grenade.fuse_time.finished() {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             trauma_events.send(5.0);
 
diff --git a/src/core/elements/kick_bomb.rs b/src/core/elements/kick_bomb.rs
index 762b135417..9dd2090f88 100644
--- a/src/core/elements/kick_bomb.rs
+++ b/src/core/elements/kick_bomb.rs
@@ -140,7 +140,7 @@ fn update_idle_kick_bombs(
     entities: Res<Entities>,
     mut commands: Commands,
     mut items_used: CompMut<ItemUsed>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     element_handles: Comp<ElementHandle>,
     mut idle_bombs: CompMut<IdleKickBomb>,
     assets: Res<AssetServer>,
@@ -167,7 +167,7 @@ fn update_idle_kick_bombs(
         let fuse_time = *fuse_time;
 
         if items_used.remove(entity).is_some() {
-            audio_events.play(*fuse_sound, *fuse_sound_volume);
+            audio_center.play_sound(*fuse_sound, *fuse_sound_volume);
             let animated_sprite = animated_sprites.get_mut(entity).unwrap();
             animated_sprite.frames = [3, 4, 5].into_iter().collect();
             animated_sprite.repeat = true;
@@ -197,7 +197,7 @@ fn update_lit_kick_bombs(
 
     collision_world: CollisionWorld,
     player_indexes: Comp<PlayerIdx>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMutInit<CameraTraumaEvents>,
     mut lit_grenades: CompMut<LitKickBomb>,
     mut sprites: CompMut<AtlasSprite>,
@@ -293,7 +293,7 @@ fn update_lit_kick_bombs(
 
         // If it's time to explode
         if should_explode {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             trauma_events.send(7.5);
 
diff --git a/src/core/elements/mine.rs b/src/core/elements/mine.rs
index de7a6a0072..3d7df802a9 100644
--- a/src/core/elements/mine.rs
+++ b/src/core/elements/mine.rs
@@ -173,7 +173,7 @@ fn update_thrown_mines(
     entities: Res<Entities>,
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMutInit<CameraTraumaEvents>,
     mut thrown_mines: CompMut<ThrownMine>,
     mut animated_sprites: CompMut<AnimatedSprite>,
@@ -221,7 +221,7 @@ fn update_thrown_mines(
         thrown_mine.arm_delay.tick(time.delta());
 
         if thrown_mine.arm_delay.just_finished() {
-            audio_events.play(*arm_sound, *arm_sound_volume);
+            audio_center.play_sound(*arm_sound, *arm_sound_volume);
 
             sprite.frames = (0..*armed_frames).collect();
             sprite.fps = *armed_fps;
@@ -247,7 +247,7 @@ fn update_thrown_mines(
                 ));
             }
 
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             hydrated.remove(**spawner);
 
diff --git a/src/core/elements/musket.rs b/src/core/elements/musket.rs
index a2820819b2..00fcbc134f 100644
--- a/src/core/elements/musket.rs
+++ b/src/core/elements/musket.rs
@@ -145,7 +145,7 @@ fn update(
     mut muskets: CompMut<Musket>,
     transforms: CompMut<Transform>,
     mut sprites: CompMut<AtlasSprite>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 
     player_inventories: PlayerInventories,
     mut items_used: CompMut<ItemUsed>,
@@ -186,14 +186,14 @@ fn update(
             if item_used && musket.cooldown.finished() {
                 // Empty
                 if musket.ammo.eq(&0) {
-                    audio_events.play(*empty_shoot_sound, *empty_shoot_sound_volume);
+                    audio_center.play_sound(*empty_shoot_sound, *empty_shoot_sound_volume);
                     continue;
                 }
 
                 // Reset fire cooldown and subtract ammo
                 musket.cooldown = Timer::new(*cooldown, TimerMode::Once);
                 musket.ammo = musket.ammo.saturating_sub(1).clamp(0, musket.ammo);
-                audio_events.play(*shoot_sound, *shoot_sound_volume);
+                audio_center.play_sound(*shoot_sound, *shoot_sound_volume);
 
                 let player_sprite = sprites.get_mut(player).unwrap();
                 let player_flip_x = player_sprite.flip_x;
diff --git a/src/core/elements/sproinger.rs b/src/core/elements/sproinger.rs
index f3227e0747..fd7c80c528 100644
--- a/src/core/elements/sproinger.rs
+++ b/src/core/elements/sproinger.rs
@@ -100,7 +100,7 @@ fn update(
     mut atlas_sprites: CompMut<AtlasSprite>,
     mut bodies: CompMut<KinematicBody>,
     collision_world: CollisionWorld,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     for (entity, (sproinger, sprite)) in entities.iter_with((&mut sproingers, &mut atlas_sprites)) {
         let element_handle = element_handles.get(entity).unwrap();
@@ -136,7 +136,7 @@ fn update(
         for collider_ent in collision_world.actor_collisions(entity) {
             if let Some(body) = bodies.get_mut(collider_ent) {
                 if body.velocity.y < *spring_velocity - body.gravity {
-                    audio_events.play(*sound, *sound_volume);
+                    audio_center.play_sound(*sound, *sound_volume);
                     body.velocity.y = *spring_velocity;
                     sproinger.sproinging = true;
                 }
diff --git a/src/core/elements/sword.rs b/src/core/elements/sword.rs
index 97a7587c05..b95009366b 100644
--- a/src/core/elements/sword.rs
+++ b/src/core/elements/sword.rs
@@ -139,7 +139,7 @@ fn update(
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
     collision_world: CollisionWorld,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut swords: CompMut<Sword>,
     mut sprites: CompMut<AtlasSprite>,
     bodies: CompMut<KinematicBody>,
@@ -289,7 +289,7 @@ fn update(
             if item_used && matches!(sword.state, SwordState::Idle) {
                 sprite.index = 8;
                 sword.state = SwordState::Swinging { frame: 0 };
-                audio_events.play(*sound, *sound_volume);
+                audio_center.play_sound(*sound, *sound_volume);
             }
         } else {
             let body = bodies.get(entity).unwrap();
diff --git a/src/core/player/state.rs b/src/core/player/state.rs
index 179f16d6c3..91fc8a985c 100644
--- a/src/core/player/state.rs
+++ b/src/core/player/state.rs
@@ -71,7 +71,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
            items: Comp<Item>,
            collision_world: CollisionWorld,
            mut inventories: CompMut<Inventory>,
-           mut audio_events: ResMutInit<AudioEvents>,
+           mut audio_center: ResMut<AudioCenter>,
            mut commands: Commands| {
         // Collect a list of items that are being held by players
         let held_items = entities
@@ -110,7 +110,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
                         commands.add(PlayerCommand::set_inventory(player_ent, Some(*item)));
 
                         // Play grab sound
-                        audio_events.play(meta.sounds.grab, meta.sounds.grab_volume);
+                        audio_center.play_sound(meta.sounds.grab, meta.sounds.grab_volume);
                     }
 
                 // If we are already carrying an item
@@ -119,7 +119,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
                     commands.add(PlayerCommand::set_inventory(player_ent, None));
 
                     // Play drop sound
-                    audio_events.play(meta.sounds.drop, meta.sounds.drop_volume);
+                    audio_center.play_sound(meta.sounds.drop, meta.sounds.drop_volume);
                 }
             }
 
diff --git a/src/core/player/state/states/idle.rs b/src/core/player/state/states/idle.rs
index d2f2713d5a..eaeca821ee 100644
--- a/src/core/player/state/states/idle.rs
+++ b/src/core/player/state/states/idle.rs
@@ -42,7 +42,7 @@ pub fn handle_player_state(
     assets: Res<AssetServer>,
     mut sprites: CompMut<AnimationBankSprite>,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     collision_world: CollisionWorld,
     slippery: CompMut<Slippery>,
 ) {
@@ -65,7 +65,7 @@ pub fn handle_player_state(
         // If we are jumping
         if control.jump_just_pressed {
             // Play jump sound
-            audio_events.play(meta.sounds.jump, meta.sounds.jump_volume);
+            audio_center.play_sound(meta.sounds.jump, meta.sounds.jump_volume);
 
             // Move up
             body.velocity.y = meta.stats.jump_speed;
diff --git a/src/core/player/state/states/midair.rs b/src/core/player/state/states/midair.rs
index d7d5e2fde4..14c0bb555b 100644
--- a/src/core/player/state/states/midair.rs
+++ b/src/core/player/state/states/midair.rs
@@ -15,7 +15,7 @@ pub fn player_state_transition(
     assets: Res<AssetServer>,
     mut player_states: CompMut<PlayerState>,
     bodies: Comp<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     for (_ent, (player_idx, player_state, body)) in
         entities.iter_with((&player_indexes, &mut player_states, &bodies))
@@ -28,7 +28,7 @@ pub fn player_state_transition(
 
         if body.is_on_ground {
             // Play land sound
-            audio_events.play(meta.sounds.land, meta.sounds.land_volume);
+            audio_center.play_sound(meta.sounds.land, meta.sounds.land_volume);
             // Switch to idle state
             player_state.current = *idle::ID;
         }
diff --git a/src/core/player/state/states/walk.rs b/src/core/player/state/states/walk.rs
index 3f9be72f94..45be01ceb3 100644
--- a/src/core/player/state/states/walk.rs
+++ b/src/core/player/state/states/walk.rs
@@ -43,7 +43,7 @@ pub fn handle_player_state(
     mut sprites: CompMut<AtlasSprite>,
     mut animations: CompMut<AnimationBankSprite>,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     let players = entities.iter_with((
         &player_states,
@@ -68,7 +68,7 @@ pub fn handle_player_state(
 
         // If we are jumping
         if control.jump_just_pressed {
-            audio_events.play(meta.sounds.jump, meta.sounds.jump_volume);
+            audio_center.play_sound(meta.sounds.jump, meta.sounds.jump_volume);
 
             // Move up
             body.velocity.y = meta.stats.jump_speed;
diff --git a/src/main.rs b/src/main.rs
index 1dd20b5a9c..14b0d264af 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,18 +12,18 @@
 use bones_bevy_renderer::BonesBevyRenderer;
 use bones_framework::prelude::*;
 
+pub mod audio;
 pub mod core;
 pub mod debug;
 pub mod fullscreen;
 pub mod input;
-pub mod music;
 pub mod sessions;
 pub mod settings;
 pub mod ui;
 
 mod prelude {
     pub use crate::{
-        core::prelude::*, impl_system_param, input::*, sessions::*, settings::*, GameMeta,
+        audio::*, core::prelude::*, impl_system_param, input::*, sessions::*, settings::*, GameMeta,
     };
     pub use bones_framework::prelude::*;
     pub use once_cell::sync::Lazy;
@@ -120,7 +120,7 @@ fn main() {
     game
         // Install game plugins
         .install_plugin(DefaultGamePlugin)
-        .install_plugin(music::game_plugin)
+        .install_plugin(audio::game_plugin)
         .install_plugin(settings::game_plugin)
         .install_plugin(fullscreen::game_plugin)
         .install_plugin(input::game_plugin)
diff --git a/src/music.rs b/src/music.rs
deleted file mode 100644
index 969f6e3918..0000000000
--- a/src/music.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use bones_framework::prelude::kira::{
-    sound::{
-        static_sound::{StaticSoundHandle, StaticSoundSettings},
-        PlaybackState, Region,
-    },
-    tween::Tween,
-};
-
-use crate::{prelude::*, ui::main_menu::MenuPage};
-
-pub fn game_plugin(game: &mut Game) {
-    let session = game.sessions.create(SessionNames::MUSIC_PLAYER);
-
-    // Music player doesn't do any rendering
-    session.visible = false;
-    session.stages.add_system_to_stage(First, music_system);
-}
-
-/// The music playback state.
-#[derive(HasSchema, Default)]
-#[schema(no_clone)]
-pub enum MusicState {
-    /// Music is not playing.
-    #[default]
-    None,
-    /// Playing the main menu music.
-    MainMenu(StaticSoundHandle),
-    /// Playing the character select music.
-    CharacterSelect(StaticSoundHandle),
-    /// Playing the credits music.
-    Credits(StaticSoundHandle),
-    /// Playing the fight music.
-    Fight {
-        /// The handle to the audio instance.
-        instance: StaticSoundHandle,
-        /// The index of the song in the shuffled playlist.
-        idx: usize,
-    },
-}
-
-impl MusicState {
-    /// Get the current audio instance, if one is contained.
-    fn current_instance(&mut self) -> Option<&mut StaticSoundHandle> {
-        match self {
-            MusicState::None => None,
-            MusicState::MainMenu(i) => Some(i),
-            MusicState::CharacterSelect(i) => Some(i),
-            MusicState::Credits(i) => Some(i),
-            MusicState::Fight { instance, .. } => Some(instance),
-        }
-    }
-}
-
-/// Bevy resource containing the in-game music playlist shuffled.
-#[derive(HasSchema, Deref, DerefMut, Clone, Default)]
-#[repr(C)]
-pub struct ShuffledPlaylist(pub SVec<Handle<AudioSource>>);
-
-/// The amount of time to spend fading the music in and out.
-const MUSIC_FADE_DURATION: Duration = Duration::from_millis(500);
-
-const MUSIC_VOLUME: f64 = 0.1;
-
-/// System that plays music according to the game mode.
-fn music_system(
-    meta: Root<GameMeta>,
-    mut audio: ResMut<AudioManager>,
-    mut shuffled_fight_music: ResMutInit<ShuffledPlaylist>,
-    mut music_state: ResMutInit<MusicState>,
-    ctx: Res<EguiCtx>,
-    sessions: Res<Sessions>,
-    assets: Res<AssetServer>,
-) {
-    if shuffled_fight_music.is_empty() {
-        let mut songs = meta.music.fight.clone();
-        THREAD_RNG.with(|rng| rng.shuffle(&mut songs));
-        **shuffled_fight_music = songs;
-    }
-
-    let tween = Tween {
-        start_time: kira::StartTime::Immediate,
-        duration: MUSIC_FADE_DURATION,
-        easing: kira::tween::Easing::Linear,
-    };
-    let play_settings = StaticSoundSettings::default()
-        .volume(MUSIC_VOLUME)
-        .fade_in_tween(tween);
-
-    // If we are in a game
-    if sessions.get(SessionNames::GAME).is_some() {
-        if let MusicState::Fight { instance, idx } = &mut *music_state {
-            if let PlaybackState::Stopped = instance.state() {
-                *idx += 1;
-                *idx %= shuffled_fight_music.len();
-
-                *instance = audio
-                    .play(
-                        assets
-                            .get(shuffled_fight_music[*idx])
-                            .0
-                            .with_settings(play_settings),
-                    )
-                    .unwrap();
-            }
-        } else {
-            if let Some(instance) = music_state.current_instance() {
-                instance.stop(tween).unwrap();
-            }
-
-            if let Some(song) = shuffled_fight_music.get(0) {
-                *music_state = MusicState::Fight {
-                    instance: audio
-                        .play(assets.get(*song).with_settings(play_settings))
-                        .unwrap(),
-                    idx: 0,
-                };
-            }
-        }
-
-    // If we are on a menu page
-    } else if sessions.get(SessionNames::MAIN_MENU).is_some() {
-        let menu_page = ctx.get_state::<MenuPage>();
-        match menu_page {
-            MenuPage::PlayerSelect | MenuPage::MapSelect { .. } | MenuPage::NetworkGame => {
-                if !matches!(*music_state, MusicState::CharacterSelect(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::CharacterSelect(
-                        audio
-                            .play(
-                                assets
-                                    .get(meta.music.character_screen)
-                                    .with_settings(play_settings.loop_region(Region::default())),
-                            )
-                            .unwrap(),
-                    );
-                }
-            }
-            MenuPage::Home | MenuPage::Settings => {
-                if !matches!(*music_state, MusicState::MainMenu(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::MainMenu(
-                        audio
-                            .play(
-                                assets
-                                    .get(meta.music.title_screen)
-                                    .with_settings(play_settings),
-                            )
-                            .unwrap(),
-                    );
-                }
-            }
-            MenuPage::Credits => {
-                if !matches!(*music_state, MusicState::Credits(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::Credits(
-                        audio
-                            .play(assets.get(meta.music.credits).with_settings(play_settings))
-                            .unwrap(),
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/src/sessions.rs b/src/sessions.rs
index e39a7a81af..6c375fb129 100644
--- a/src/sessions.rs
+++ b/src/sessions.rs
@@ -2,11 +2,11 @@ use crate::{core::JumpyDefaultMatchRunner, prelude::*};
 
 pub struct SessionNames;
 impl SessionNames {
-    pub const GAME: &'static str = "game";
+    pub const AUDIO: &'static str = "audio";
     pub const DEBUG: &'static str = "debug";
+    pub const GAME: &'static str = "game";
     pub const MAIN_MENU: &'static str = "main_menu";
     pub const PAUSE_MENU: &'static str = "pause_menu";
-    pub const MUSIC_PLAYER: &'static str = "music_player";
 }
 
 pub trait SessionExt {
diff --git a/src/settings.rs b/src/settings.rs
index b2f8a1e425..452bceb66a 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -24,6 +24,8 @@ fn load_settings(game: &mut Game) {
 #[derive(HasSchema, Debug, Clone)]
 #[repr(C)]
 pub struct Settings {
+    /// The main scaling factor for all game audios.
+    pub main_volume: f64,
     /// Whether to display the game fullscreen.
     pub fullscreen: bool,
     /// The player controller bindings
@@ -35,6 +37,7 @@ pub struct Settings {
 impl Default for Settings {
     fn default() -> Self {
         Self {
+            main_volume: 1.0,
             fullscreen: true,
             player_controls: default(),
             matchmaking_server: default(),
diff --git a/src/ui/main_menu/settings.rs b/src/ui/main_menu/settings.rs
index 4fe4c5cc94..00b1905f38 100644
--- a/src/ui/main_menu/settings.rs
+++ b/src/ui/main_menu/settings.rs
@@ -5,6 +5,7 @@ use crate::{
 
 use super::MenuPage;
 
+mod audio;
 mod controls;
 mod graphics;
 mod networking;
@@ -23,6 +24,7 @@ enum SettingsTab {
     #[default]
     Controls,
     Networking,
+    Audio,
     Graphics,
 }
 
@@ -30,6 +32,7 @@ impl SettingsTab {
     const TABS: &'static [(Self, &'static str)] = &[
         (Self::Controls, "controls"),
         (Self::Networking, "networking"),
+        (Self::Audio, "audio"),
         (Self::Graphics, "graphics"),
     ];
 }
@@ -132,6 +135,10 @@ pub fn widget(
                             ui.ctx().set_state(MenuPage::Home);
                             // Reset the modified settings to their stored settings.
                             state.modified_settings = storage.get::<Settings>().unwrap().clone();
+                            // Run cancel callbacks
+                            if state.tab == SettingsTab::Audio {
+                                world.run_system(audio::on_cancel, &state);
+                            }
                         }
 
                         ui.add_space(button_spacing);
@@ -174,6 +181,9 @@ pub fn widget(
                         SettingsTab::Networking => {
                             world.run_system(networking::widget, (ui, &mut state, should_reset))
                         }
+                        SettingsTab::Audio => {
+                            world.run_system(audio::widget, (ui, &mut state, should_reset))
+                        }
                         SettingsTab::Graphics => {
                             world.run_system(graphics::widget, (ui, &mut state, should_reset))
                         }
diff --git a/src/ui/main_menu/settings/audio.rs b/src/ui/main_menu/settings/audio.rs
new file mode 100644
index 0000000000..ee003c9f49
--- /dev/null
+++ b/src/ui/main_menu/settings/audio.rs
@@ -0,0 +1,55 @@
+use bones_framework::render::ui::egui;
+
+use super::*;
+
+pub(super) fn on_cancel(In(state): In<&SettingsState>, mut audio_center: ResMut<AudioCenter>) {
+    audio_center.event(AudioEvent::MainVolumeChange(
+        state.modified_settings.main_volume,
+    ));
+}
+
+pub(super) fn widget(
+    In((ui, state, should_reset)): In<(&mut egui::Ui, &mut SettingsState, bool)>,
+    meta: Root<GameMeta>,
+    localization: Localization<GameMeta>,
+    mut audio_center: ResMut<AudioCenter>,
+) {
+    let normal_font = meta
+        .theme
+        .font_styles
+        .normal
+        .with_color(meta.theme.panel.font_color);
+
+    if should_reset {
+        state.modified_settings.main_volume = meta.default_settings.main_volume;
+        audio_center.event(AudioEvent::MainVolumeChange(
+            state.modified_settings.main_volume,
+        ));
+    }
+
+    ui.add_space(normal_font.size);
+
+    ui.scope(|ui| {
+        ui.spacing_mut().indent = normal_font.size / 2.5;
+        ui.indent("audio-controls", |ui| {
+            ui.horizontal(|ui| {
+                ui.label(normal_font.rich(localization.get("main-volume")));
+                let style = ui.style_mut();
+                style.drag_value_text_style = egui::TextStyle::Monospace;
+                style.spacing.button_padding = egui::vec2(6.0, 3.0);
+                let main_volume = &mut state.modified_settings.main_volume;
+                let response = ui.add(
+                    egui::Slider::new(main_volume, 0.0..=1.0)
+                        .smallest_positive(0.0)
+                        .step_by(0.01)
+                        .fixed_decimals(3)
+                        .custom_formatter(|x, _| format!("{:5.1}", x * 100.0))
+                        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0)),
+                );
+                if response.changed() {
+                    audio_center.event(AudioEvent::MainVolumeChange(*main_volume));
+                }
+            });
+        });
+    });
+}

From 131d875632c49e1102398d23372c0b9a96175f18 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Sun, 21 Jan 2024 21:11:37 -0600
Subject: [PATCH 02/10] add docs

---
 src/audio.rs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/audio.rs b/src/audio.rs
index 2bb8188af5..51e9bd4038 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -28,10 +28,13 @@ pub fn game_plugin(game: &mut Game) {
         .add_system_to_stage(First, process_audio_events);
 }
 
+/// A resource that can be used to control game audios.
 #[derive(HasSchema)]
 #[schema(no_clone)]
 pub struct AudioCenter {
+    /// Buffer for audio events that have not yet been processed.
     events: VecDeque<AudioEvent>,
+    /// The handle to the current music.
     music: Option<StaticSoundHandle>,
 }
 
@@ -45,14 +48,18 @@ impl Default for AudioCenter {
 }
 
 impl AudioCenter {
+    /// Push an audio event to the queue for later processing.
     pub fn event(&mut self, event: AudioEvent) {
         self.events.push_back(event);
     }
 
+    /// Get the playback state of the music.
     pub fn music_state(&self) -> Option<PlaybackState> {
         self.music.as_ref().map(StaticSoundHandle::state)
     }
 
+    /// Play a sound. These are usually short audios that indicate something
+    /// happened in game, e.g. a player jump, an explosion, etc.
     pub fn play_sound(&mut self, sound_source: Handle<AudioSource>, volume: f64) {
         self.events.push_back(AudioEvent::PlaySound {
             sound_source,
@@ -60,6 +67,9 @@ impl AudioCenter {
         })
     }
 
+    /// Play some music. These may or may not loop.
+    ///
+    /// Any current music is stopped.
     pub fn play_music(
         &mut self,
         sound_source: Handle<AudioSource>,
@@ -75,9 +85,15 @@ impl AudioCenter {
 /// An audio event that may be sent to the [`AudioEvents`] resource.
 #[derive(Clone, Debug)]
 pub enum AudioEvent {
+    /// Update the volume of all audios using the new main volume.
     MainVolumeChange(f64),
+    /// Play some music.
+    ///
+    /// Any current music is stopped.
     PlayMusic {
+        /// The handle for the music.
         sound_source: Handle<AudioSource>,
+        /// The settings for the music.
         sound_settings: Box<StaticSoundSettings>,
     },
     /// Play a sound.
@@ -93,7 +109,9 @@ pub enum AudioEvent {
 #[schema(no_clone, no_default, opaque)]
 #[repr(C)]
 pub struct Audio {
+    /// The handle for the audio.
     handle: StaticSoundHandle,
+    /// The original volume requested for the audio.
     volume: f64,
 }
 
@@ -109,11 +127,13 @@ fn process_audio_events(
         match event {
             AudioEvent::MainVolumeChange(main_volume) => {
                 let tween = Tween::default();
+                // Update music volume
                 if let Some(music) = &mut audio_center.music {
                     if let Err(err) = music.set_volume(main_volume * MUSIC_VOLUME, tween) {
                         warn!("Error setting music volume: {err}");
                     }
                 }
+                // Update sound volumes
                 for audio in audios.iter_mut() {
                     if let Err(err) = audio.handle.set_volume(main_volume * audio.volume, tween) {
                         warn!("Error setting audio volume: {err}");
@@ -124,6 +144,7 @@ fn process_audio_events(
                 sound_source,
                 mut sound_settings,
             } => {
+                // Stop the current music
                 if let Some(mut music) = audio_center.music.take() {
                     let tween = Tween {
                         start_time: kira::StartTime::Immediate,
@@ -132,12 +153,14 @@ fn process_audio_events(
                     };
                     music.stop(tween).unwrap();
                 }
+                // Scale the requested volume by the settings value
                 let settings = storage.get::<Settings>().unwrap();
                 let volume = match sound_settings.volume {
                     tween::Value::Fixed(vol) => settings.main_volume * vol.as_amplitude(),
                     _ => settings.main_volume * MUSIC_VOLUME,
                 };
                 sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(volume));
+                // Play the new music
                 let sound_data = assets.get(sound_source).with_settings(*sound_settings);
                 match audio_manager.play(sound_data) {
                     Err(err) => warn!("Error playing music: {err}"),

From 58652fa8bb78b5223a799adf22672fb32e43b74c Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Sun, 21 Jan 2024 23:08:47 -0600
Subject: [PATCH 03/10] store requested music volume like sounds do

---
 src/audio.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/audio.rs b/src/audio.rs
index 51e9bd4038..3cce8366a4 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -35,7 +35,7 @@ pub struct AudioCenter {
     /// Buffer for audio events that have not yet been processed.
     events: VecDeque<AudioEvent>,
     /// The handle to the current music.
-    music: Option<StaticSoundHandle>,
+    music: Option<Audio>,
 }
 
 impl Default for AudioCenter {
@@ -55,7 +55,7 @@ impl AudioCenter {
 
     /// Get the playback state of the music.
     pub fn music_state(&self) -> Option<PlaybackState> {
-        self.music.as_ref().map(StaticSoundHandle::state)
+        self.music.as_ref().map(|m| m.handle.state())
     }
 
     /// Play a sound. These are usually short audios that indicate something
@@ -129,7 +129,7 @@ fn process_audio_events(
                 let tween = Tween::default();
                 // Update music volume
                 if let Some(music) = &mut audio_center.music {
-                    if let Err(err) = music.set_volume(main_volume * MUSIC_VOLUME, tween) {
+                    if let Err(err) = music.handle.set_volume(main_volume * music.volume, tween) {
                         warn!("Error setting music volume: {err}");
                     }
                 }
@@ -151,7 +151,7 @@ fn process_audio_events(
                         duration: MUSIC_FADE_DURATION,
                         easing: tween::Easing::Linear,
                     };
-                    music.stop(tween).unwrap();
+                    music.handle.stop(tween).unwrap();
                 }
                 // Scale the requested volume by the settings value
                 let settings = storage.get::<Settings>().unwrap();
@@ -164,7 +164,7 @@ fn process_audio_events(
                 let sound_data = assets.get(sound_source).with_settings(*sound_settings);
                 match audio_manager.play(sound_data) {
                     Err(err) => warn!("Error playing music: {err}"),
-                    Ok(handle) => audio_center.music = Some(handle),
+                    Ok(handle) => audio_center.music = Some(Audio { handle, volume }),
                 }
             }
             AudioEvent::PlaySound {

From f779d28028ce558827dba7e71956aec8ad8a7769 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 17:11:46 -0600
Subject: [PATCH 04/10] fix: scale volume consistently

---
 src/audio.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/audio.rs b/src/audio.rs
index 3cce8366a4..2023de9ac9 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -123,6 +123,8 @@ fn process_audio_events(
     mut audios: CompMut<Audio>,
     storage: Res<Storage>,
 ) {
+    let settings = storage.get::<Settings>().unwrap();
+
     for event in audio_center.events.drain(..).collect::<Vec<_>>() {
         match event {
             AudioEvent::MainVolumeChange(main_volume) => {
@@ -154,12 +156,12 @@ fn process_audio_events(
                     music.handle.stop(tween).unwrap();
                 }
                 // Scale the requested volume by the settings value
-                let settings = storage.get::<Settings>().unwrap();
                 let volume = match sound_settings.volume {
-                    tween::Value::Fixed(vol) => settings.main_volume * vol.as_amplitude(),
-                    _ => settings.main_volume * MUSIC_VOLUME,
+                    tween::Value::Fixed(vol) => vol.as_amplitude(),
+                    _ => MUSIC_VOLUME,
                 };
-                sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(volume));
+                let scaled_volume = settings.main_volume * volume;
+                sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(scaled_volume));
                 // Play the new music
                 let sound_data = assets.get(sound_source).with_settings(*sound_settings);
                 match audio_manager.play(sound_data) {
@@ -171,9 +173,10 @@ fn process_audio_events(
                 sound_source,
                 volume,
             } => {
+                let scaled_volume = settings.main_volume * volume;
                 let sound_data = assets
                     .get(sound_source)
-                    .with_settings(StaticSoundSettings::default().volume(volume));
+                    .with_settings(StaticSoundSettings::default().volume(scaled_volume));
                 match audio_manager.play(sound_data) {
                     Err(err) => warn!("Error playing sound: {err}"),
                     Ok(handle) => {

From d521930f0e482c7b5c61b168c7f59dda4d78e414 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 17:17:56 -0600
Subject: [PATCH 05/10] kill audio entities that are stopped

---
 src/audio.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/audio.rs b/src/audio.rs
index 2023de9ac9..5cd9f929a0 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -25,7 +25,8 @@ pub fn game_plugin(game: &mut Game) {
     session
         .stages
         .add_system_to_stage(First, music_system)
-        .add_system_to_stage(First, process_audio_events);
+        .add_system_to_stage(First, process_audio_events)
+        .add_system_to_stage(Last, kill_finished_audios);
 }
 
 /// A resource that can be used to control game audios.
@@ -188,3 +189,11 @@ fn process_audio_events(
         }
     }
 }
+
+fn kill_finished_audios(entities: Res<Entities>, audios: Comp<Audio>, mut commands: Commands) {
+    for (audio_ent, audio) in entities.iter_with(&audios) {
+        if audio.handle.state() == PlaybackState::Stopped {
+            commands.add(move |mut entities: ResMut<Entities>| entities.kill(audio_ent));
+        }
+    }
+}

From cb4df2c7ddf88b2d15a9b2ce4692e5f0135b021c Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 17:58:00 -0600
Subject: [PATCH 06/10] add settings for music & sound effects

---
 assets/locales/en-US/settings.ftl  |  2 +
 src/audio.rs                       | 24 ++++++---
 src/settings.rs                    |  9 +++-
 src/ui/main_menu/settings/audio.rs | 79 +++++++++++++++++++++---------
 4 files changed, 83 insertions(+), 31 deletions(-)

diff --git a/assets/locales/en-US/settings.ftl b/assets/locales/en-US/settings.ftl
index 1d72e5d5e2..3fc2975fc6 100644
--- a/assets/locales/en-US/settings.ftl
+++ b/assets/locales/en-US/settings.ftl
@@ -22,6 +22,8 @@ matchmaking-server = Matchmaking Server
 # Audio settings
 audio = Audio
 main-volume = Main Volume
+music-volume = Music Volume
+effects-volume = Effects Volume
 
 # Graphics settings
 graphics = Graphics
diff --git a/src/audio.rs b/src/audio.rs
index 5cd9f929a0..1de9e016b0 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -86,8 +86,12 @@ impl AudioCenter {
 /// An audio event that may be sent to the [`AudioEvents`] resource.
 #[derive(Clone, Debug)]
 pub enum AudioEvent {
-    /// Update the volume of all audios using the new main volume.
-    MainVolumeChange(f64),
+    /// Update the volume of all audios using the new values.
+    VolumeChange {
+        main_volume: f64,
+        music_volume: f64,
+        effects_volume: f64,
+    },
     /// Play some music.
     ///
     /// Any current music is stopped.
@@ -128,17 +132,23 @@ fn process_audio_events(
 
     for event in audio_center.events.drain(..).collect::<Vec<_>>() {
         match event {
-            AudioEvent::MainVolumeChange(main_volume) => {
+            AudioEvent::VolumeChange {
+                main_volume,
+                music_volume,
+                effects_volume,
+            } => {
                 let tween = Tween::default();
                 // Update music volume
                 if let Some(music) = &mut audio_center.music {
-                    if let Err(err) = music.handle.set_volume(main_volume * music.volume, tween) {
+                    let volume = main_volume * music_volume * music.volume;
+                    if let Err(err) = music.handle.set_volume(volume, tween) {
                         warn!("Error setting music volume: {err}");
                     }
                 }
                 // Update sound volumes
                 for audio in audios.iter_mut() {
-                    if let Err(err) = audio.handle.set_volume(main_volume * audio.volume, tween) {
+                    let volume = main_volume * effects_volume * audio.volume;
+                    if let Err(err) = audio.handle.set_volume(volume, tween) {
                         warn!("Error setting audio volume: {err}");
                     }
                 }
@@ -161,7 +171,7 @@ fn process_audio_events(
                     tween::Value::Fixed(vol) => vol.as_amplitude(),
                     _ => MUSIC_VOLUME,
                 };
-                let scaled_volume = settings.main_volume * volume;
+                let scaled_volume = settings.main_volume * settings.music_volume * volume;
                 sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(scaled_volume));
                 // Play the new music
                 let sound_data = assets.get(sound_source).with_settings(*sound_settings);
@@ -174,7 +184,7 @@ fn process_audio_events(
                 sound_source,
                 volume,
             } => {
-                let scaled_volume = settings.main_volume * volume;
+                let scaled_volume = settings.main_volume * settings.effects_volume * volume;
                 let sound_data = assets
                     .get(sound_source)
                     .with_settings(StaticSoundSettings::default().volume(scaled_volume));
diff --git a/src/settings.rs b/src/settings.rs
index 452bceb66a..d160d66755 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -24,8 +24,13 @@ fn load_settings(game: &mut Game) {
 #[derive(HasSchema, Debug, Clone)]
 #[repr(C)]
 pub struct Settings {
-    /// The main scaling factor for all game audios.
+    /// The main scaling factor for all game audios. This is done on top of the
+    /// scaling factor specific to the audio type.
     pub main_volume: f64,
+    /// The scaling factor for music.
+    pub music_volume: f64,
+    /// The scaling factor for sound effects.
+    pub effects_volume: f64,
     /// Whether to display the game fullscreen.
     pub fullscreen: bool,
     /// The player controller bindings
@@ -38,6 +43,8 @@ impl Default for Settings {
     fn default() -> Self {
         Self {
             main_volume: 1.0,
+            music_volume: 1.0,
+            effects_volume: 1.0,
             fullscreen: true,
             player_controls: default(),
             matchmaking_server: default(),
diff --git a/src/ui/main_menu/settings/audio.rs b/src/ui/main_menu/settings/audio.rs
index ee003c9f49..443e72ccc0 100644
--- a/src/ui/main_menu/settings/audio.rs
+++ b/src/ui/main_menu/settings/audio.rs
@@ -2,10 +2,22 @@ use bones_framework::render::ui::egui;
 
 use super::*;
 
+trait SettingsExts {
+    fn volume_change_event(&self) -> AudioEvent;
+}
+
+impl SettingsExts for Settings {
+    fn volume_change_event(&self) -> AudioEvent {
+        AudioEvent::VolumeChange {
+            main_volume: self.main_volume,
+            music_volume: self.music_volume,
+            effects_volume: self.effects_volume,
+        }
+    }
+}
+
 pub(super) fn on_cancel(In(state): In<&SettingsState>, mut audio_center: ResMut<AudioCenter>) {
-    audio_center.event(AudioEvent::MainVolumeChange(
-        state.modified_settings.main_volume,
-    ));
+    audio_center.event(state.modified_settings.volume_change_event());
 }
 
 pub(super) fn widget(
@@ -22,34 +34,55 @@ pub(super) fn widget(
 
     if should_reset {
         state.modified_settings.main_volume = meta.default_settings.main_volume;
-        audio_center.event(AudioEvent::MainVolumeChange(
-            state.modified_settings.main_volume,
-        ));
+        audio_center.event(state.modified_settings.volume_change_event());
     }
 
     ui.add_space(normal_font.size);
 
     ui.scope(|ui| {
-        ui.spacing_mut().indent = normal_font.size / 2.5;
+        let style = ui.style_mut();
+        style.drag_value_text_style = egui::TextStyle::Monospace;
+        style.spacing.indent = normal_font.size / 2.5;
+        style.spacing.button_padding = egui::vec2(6.0, 3.0);
+        style.visuals.indent_has_left_vline = false;
+
         ui.indent("audio-controls", |ui| {
-            ui.horizontal(|ui| {
+            // Main volume
+            let response = ui.horizontal(|ui| {
+                let value = &mut state.modified_settings.main_volume;
                 ui.label(normal_font.rich(localization.get("main-volume")));
-                let style = ui.style_mut();
-                style.drag_value_text_style = egui::TextStyle::Monospace;
-                style.spacing.button_padding = egui::vec2(6.0, 3.0);
-                let main_volume = &mut state.modified_settings.main_volume;
-                let response = ui.add(
-                    egui::Slider::new(main_volume, 0.0..=1.0)
-                        .smallest_positive(0.0)
-                        .step_by(0.01)
-                        .fixed_decimals(3)
-                        .custom_formatter(|x, _| format!("{:5.1}", x * 100.0))
-                        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0)),
-                );
-                if response.changed() {
-                    audio_center.event(AudioEvent::MainVolumeChange(*main_volume));
-                }
+                ui.add(audio_slider(value)).changed()
             });
+            let main_changed = response.inner;
+
+            // Music volume
+            let response = ui.horizontal(|ui| {
+                let value = &mut state.modified_settings.music_volume;
+                ui.label(normal_font.rich(localization.get("music-volume")));
+                ui.add(audio_slider(value)).changed()
+            });
+            let music_changed = response.inner;
+
+            // Effects volume
+            let response = ui.horizontal(|ui| {
+                let value = &mut state.modified_settings.effects_volume;
+                ui.label(normal_font.rich(localization.get("effects-volume")));
+                ui.add(audio_slider(value)).changed()
+            });
+            let effects_changed = response.inner;
+
+            if main_changed || music_changed || effects_changed {
+                audio_center.event(state.modified_settings.volume_change_event());
+            }
         });
     });
 }
+
+fn audio_slider(value: &mut f64) -> egui::Slider {
+    egui::Slider::new(value, 0.0..=1.0)
+        .smallest_positive(0.0)
+        .step_by(0.01)
+        .fixed_decimals(3)
+        .custom_formatter(|x, _| format!("{:5.1}", x * 100.0))
+        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0))
+}

From d4015cfaa1d9b44f0e88ee6e65c9bdbba76db261 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 18:22:48 -0600
Subject: [PATCH 07/10] layout settings in a grid

---
 assets/locales/en-US/settings.ftl  |  7 +--
 src/ui/main_menu/settings/audio.rs | 74 +++++++++++++++++++-----------
 2 files changed, 51 insertions(+), 30 deletions(-)

diff --git a/assets/locales/en-US/settings.ftl b/assets/locales/en-US/settings.ftl
index 3fc2975fc6..79ab2c36f0 100644
--- a/assets/locales/en-US/settings.ftl
+++ b/assets/locales/en-US/settings.ftl
@@ -21,9 +21,10 @@ matchmaking-server = Matchmaking Server
 
 # Audio settings
 audio = Audio
-main-volume = Main Volume
-music-volume = Music Volume
-effects-volume = Effects Volume
+volume = Volume
+volume-main = Main
+volume-music = Music
+volume-effects = Effects
 
 # Graphics settings
 graphics = Graphics
diff --git a/src/ui/main_menu/settings/audio.rs b/src/ui/main_menu/settings/audio.rs
index 443e72ccc0..59b1304f73 100644
--- a/src/ui/main_menu/settings/audio.rs
+++ b/src/ui/main_menu/settings/audio.rs
@@ -26,6 +26,11 @@ pub(super) fn widget(
     localization: Localization<GameMeta>,
     mut audio_center: ResMut<AudioCenter>,
 ) {
+    let bigger_font = meta
+        .theme
+        .font_styles
+        .bigger
+        .with_color(meta.theme.panel.font_color);
     let normal_font = meta
         .theme
         .font_styles
@@ -44,45 +49,60 @@ pub(super) fn widget(
         style.drag_value_text_style = egui::TextStyle::Monospace;
         style.spacing.indent = normal_font.size / 2.5;
         style.spacing.button_padding = egui::vec2(6.0, 3.0);
+        style.spacing.slider_width = 200.0;
         style.visuals.indent_has_left_vline = false;
 
         ui.indent("audio-controls", |ui| {
-            // Main volume
-            let response = ui.horizontal(|ui| {
-                let value = &mut state.modified_settings.main_volume;
-                ui.label(normal_font.rich(localization.get("main-volume")));
-                ui.add(audio_slider(value)).changed()
-            });
-            let main_changed = response.inner;
+            ui.label(bigger_font.rich(localization.get("volume")));
+            ui.add_space(normal_font.size / 2.0);
 
-            // Music volume
-            let response = ui.horizontal(|ui| {
-                let value = &mut state.modified_settings.music_volume;
-                ui.label(normal_font.rich(localization.get("music-volume")));
-                ui.add(audio_slider(value)).changed()
-            });
-            let music_changed = response.inner;
+            egui::Grid::new("volume-grid").show(ui, |ui| {
+                // Main
+                let main_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-main")),
+                    &mut state.modified_settings.main_volume,
+                )
+                .changed();
+                ui.end_row();
 
-            // Effects volume
-            let response = ui.horizontal(|ui| {
-                let value = &mut state.modified_settings.effects_volume;
-                ui.label(normal_font.rich(localization.get("effects-volume")));
-                ui.add(audio_slider(value)).changed()
-            });
-            let effects_changed = response.inner;
+                // Music
+                let music_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-music")),
+                    &mut state.modified_settings.music_volume,
+                )
+                .changed();
+                ui.end_row();
 
-            if main_changed || music_changed || effects_changed {
-                audio_center.event(state.modified_settings.volume_change_event());
-            }
+                // Effects
+                let effects_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-effects")),
+                    &mut state.modified_settings.effects_volume,
+                )
+                .changed();
+                ui.end_row();
+
+                if main_changed || music_changed || effects_changed {
+                    audio_center.event(state.modified_settings.volume_change_event());
+                }
+            });
         });
     });
 }
 
-fn audio_slider(value: &mut f64) -> egui::Slider {
-    egui::Slider::new(value, 0.0..=1.0)
+fn volume_control_widget(
+    ui: &mut egui::Ui,
+    label: impl Into<egui::WidgetText>,
+    value: &mut f64,
+) -> egui::Response {
+    ui.label(label);
+    let slider = egui::Slider::new(value, 0.0..=1.0)
         .smallest_positive(0.0)
         .step_by(0.01)
         .fixed_decimals(3)
         .custom_formatter(|x, _| format!("{:5.1}", x * 100.0))
-        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0))
+        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0));
+    ui.add(slider)
 }

From 8bcba1fb9730c434060773be10659f7d894a691a Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 19:20:55 -0600
Subject: [PATCH 08/10] add some spacing to settings

---
 src/ui/main_menu/settings.rs          | 5 ++++-
 src/ui/main_menu/settings/controls.rs | 2 ++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/ui/main_menu/settings.rs b/src/ui/main_menu/settings.rs
index 00b1905f38..abdb1295c5 100644
--- a/src/ui/main_menu/settings.rs
+++ b/src/ui/main_menu/settings.rs
@@ -112,7 +112,7 @@ pub fn widget(
 
                 // Add buttons to the bottom
                 ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
-                    ui.horizontal(|ui| {
+                    let buttons_response = ui.horizontal(|ui| {
                         // Calculate button size and spacing
                         let width = ui.available_width();
                         let button_width = width / 4.0;
@@ -174,6 +174,9 @@ pub fn widget(
                         }
                     });
 
+                    let buttons_rect = buttons_response.response.rect;
+                    ui.add_space(buttons_rect.height() / 2.0);
+
                     ui.vertical(|ui| match state.tab {
                         SettingsTab::Controls => {
                             world.run_system(controls::widget, (ui, &mut state, should_reset))
diff --git a/src/ui/main_menu/settings/controls.rs b/src/ui/main_menu/settings/controls.rs
index 9ea6cb3c97..b16aab4493 100644
--- a/src/ui/main_menu/settings/controls.rs
+++ b/src/ui/main_menu/settings/controls.rs
@@ -187,6 +187,8 @@ pub(super) fn widget(
 
                         // Render the button
                         row.col(|ui| {
+                            ui.set_width(ui.available_width() * 0.92);
+
                             let button = BorderedButton::themed(
                                 &meta.theme.buttons.small,
                                 input.to_string(),

From fd2ae431f724d654146c0cb3c255c4c4aec4b60c Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Mon, 22 Jan 2024 20:12:17 -0600
Subject: [PATCH 09/10] fix: outdated docs

---
 src/audio.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/audio.rs b/src/audio.rs
index 1de9e016b0..fd3882f0f9 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -83,7 +83,8 @@ impl AudioCenter {
     }
 }
 
-/// An audio event that may be sent to the [`AudioEvents`] resource.
+/// An audio event that may be sent to the [`AudioCenter`] resource for
+/// processing.
 #[derive(Clone, Debug)]
 pub enum AudioEvent {
     /// Update the volume of all audios using the new values.

From 9ec225f9c3391a130afb910abc836e30d19ecd93 Mon Sep 17 00:00:00 2001
From: Nelson Earle <nelson.earle137@gmail.com>
Date: Tue, 23 Jan 2024 19:55:37 -0600
Subject: [PATCH 10/10] fix: update `shlex` due to security advisory

https://github.com/comex/rust-shlex/security/advisories/GHSA-r7qv-8r2h-pg27
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7666376923..6205821c53 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4828,9 +4828,9 @@ dependencies = [
 
 [[package]]
 name = "shlex"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "simba"