From 273385dfe4cd6a15caa1656641597997f867b55f Mon Sep 17 00:00:00 2001 From: Ryan Walters Date: Thu, 11 Sep 2025 14:15:05 -0500 Subject: [PATCH] refactor: improve audio system states, add try_new(), organize constants, volume memory --- src/audio.rs | 190 ++++++++++++++++++---------------------- src/platform/desktop.rs | 1 + 2 files changed, 86 insertions(+), 105 deletions(-) diff --git a/src/audio.rs b/src/audio.rs index 00f45b4..202decc 100644 --- a/src/audio.rs +++ b/src/audio.rs @@ -2,12 +2,18 @@ use std::collections::HashMap; use crate::asset::Asset; +use anyhow::{anyhow, Result}; use sdl2::{ - mixer::{self, Chunk, InitFlag, LoaderRWops, AUDIO_S16LSB, DEFAULT_CHANNELS}, + mixer::{self, Chunk, InitFlag, LoaderRWops, AUDIO_S16LSB}, rwops::RWops, }; use strum::IntoEnumIterator; +const AUDIO_FREQUENCY: i32 = 16_000; +const AUDIO_CHANNELS: i32 = 4; +const DEFAULT_VOLUME: u8 = 32; +const WAKA_SOUND_COUNT: u8 = 4; + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum Sound { Waka(u8), @@ -23,19 +29,16 @@ impl IntoEnumIterator for Sound { type Iterator = std::vec::IntoIter; fn iter() -> Self::Iterator { - vec![ - Sound::Waka(0), - Sound::Waka(1), - Sound::Waka(2), - Sound::Waka(3), + let mut sounds = vec![ Sound::PacmanDeath, Sound::ExtraLife, Sound::Fruit, Sound::Ghost, Sound::Beginning, Sound::Intermission, - ] - .into_iter() + ]; + sounds.extend((0..WAKA_SOUND_COUNT).map(Sound::Waka)); + sounds.into_iter() } } @@ -48,8 +51,14 @@ pub struct Audio { _mixer_context: Option, sounds: HashMap, next_waka_index: u8, - muted: bool, - disabled: bool, + state: AudioState, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum AudioState { + Enabled { volume: u8 }, + Muted { previous_volume: u8 }, + Disabled, } impl Default for Audio { @@ -64,7 +73,21 @@ impl Audio { /// If audio fails to initialize, the audio system will be disabled and /// all functions will silently do nothing. pub fn new() -> Self { - let frequency = 16_000; + match Self::try_new() { + Ok(audio) => audio, + Err(e) => { + tracing::warn!("Failed to initialize audio: {}. Audio will be disabled.", e); + Self { + _mixer_context: None, + sounds: HashMap::new(), + next_waka_index: 0, + state: AudioState::Disabled, + } + } + } + } + + fn try_new() -> Result { let format = AUDIO_S16LSB; let chunk_size = { // 256 is the minimum for Emscripten, but in practice 1024 is much more reliable @@ -81,103 +104,52 @@ impl Audio { }; // Try to open audio, but don't panic if it fails - if let Err(e) = mixer::open_audio(frequency, format, DEFAULT_CHANNELS, chunk_size) { - tracing::warn!("Failed to open audio: {}. Audio will be disabled.", e); - return Self { - _mixer_context: None, - sounds: HashMap::new(), - next_waka_index: 0u8, - muted: false, - disabled: true, - }; - } + mixer::open_audio(AUDIO_FREQUENCY, format, AUDIO_CHANNELS, chunk_size) + .map_err(|e| anyhow!("Failed to open audio: {}", e))?; - let channels = 4; - mixer::allocate_channels(4); + mixer::allocate_channels(AUDIO_CHANNELS); // set channel volume - for i in 0..channels { - mixer::Channel(i).set_volume(32); + for i in 0..AUDIO_CHANNELS { + mixer::Channel(i).set_volume(DEFAULT_VOLUME as i32); } // Try to initialize mixer, but don't panic if it fails - let mixer_context = match mixer::init(InitFlag::OGG) { - Ok(ctx) => ctx, - Err(e) => { - tracing::warn!("Failed to initialize SDL2_mixer: {}. Audio will be disabled.", e); - return Self { - _mixer_context: None, - sounds: HashMap::new(), - next_waka_index: 0u8, - muted: false, - disabled: true, - }; - } - }; + let mixer_context = mixer::init(InitFlag::OGG).map_err(|e| anyhow!("Failed to initialize SDL2_mixer: {}", e))?; // Try to load sounds, but don't panic if any fail - let mut sounds = HashMap::new(); - for (i, sound_type) in Sound::iter().enumerate() { - let asset = Asset::SoundFile(sound_type); - match asset.get_bytes() { - Ok(data) => match RWops::from_bytes(&data) { - Ok(rwops) => match rwops.load_wav() { - Ok(chunk) => { - sounds.insert(sound_type, chunk); - } - Err(e) => { - tracing::warn!("Failed to load sound {} from asset API: {}", i + 1, e); - } - }, - Err(e) => { - tracing::warn!("Failed to create RWops for sound {}: {}", i + 1, e); - } - }, + let sounds: HashMap = Sound::iter() + .filter_map(|sound_type| match Self::load_sound(sound_type) { + Ok(chunk) => Some((sound_type, chunk)), Err(e) => { - tracing::warn!("Failed to load sound asset {}: {}", i + 1, e); - } - } - } - - let death_sound = match Asset::SoundFile(Sound::PacmanDeath).get_bytes() { - Ok(data) => match RWops::from_bytes(&data) { - Ok(rwops) => match rwops.load_wav() { - Ok(chunk) => Some(chunk), - Err(e) => { - tracing::warn!("Failed to load death sound from asset API: {}", e); - None - } - }, - Err(e) => { - tracing::warn!("Failed to create RWops for death sound: {}", e); + tracing::warn!("Failed to load sound {:?}: {}", sound_type, e); None } - }, - Err(e) => { - tracing::warn!("Failed to load death sound asset: {}", e); - None - } - }; + }) + .collect(); // If no sounds loaded successfully, disable audio - if sounds.is_empty() && death_sound.is_none() { - tracing::warn!("No sounds loaded successfully. Audio will be disabled."); - return Self { - _mixer_context: Some(mixer_context), - sounds: HashMap::new(), - next_waka_index: 0u8, - muted: false, - disabled: true, - }; + if sounds.is_empty() { + return Err(anyhow!("No sounds loaded successfully")); } - Audio { + Ok(Audio { _mixer_context: Some(mixer_context), sounds, next_waka_index: 0u8, - muted: false, - disabled: false, - } + state: AudioState::Enabled { volume: DEFAULT_VOLUME }, + }) + } + + fn load_sound(sound_type: Sound) -> Result { + let asset = Asset::SoundFile(sound_type); + let data = asset + .get_bytes() + .map_err(|e| anyhow!("Failed to get bytes for {:?}: {}", sound_type, e))?; + let rwops = RWops::from_bytes(&data).map_err(|e| anyhow!("Failed to create RWops for {:?}: {}", sound_type, e))?; + rwops + .load_wav() + .map_err(|e| anyhow!("Failed to load wav for {:?}: {}", sound_type, e)) } /// Plays the next waka eating sound in the cycle of four variants. @@ -186,7 +158,7 @@ impl Audio { /// advances to the next variant. Silently returns if audio is disabled, muted, /// or no sounds were loaded successfully. pub fn waka(&mut self) { - if self.disabled || self.muted || self.sounds.is_empty() { + if !matches!(self.state, AudioState::Enabled { .. }) { return; } @@ -200,12 +172,12 @@ impl Audio { } } } - self.next_waka_index = (self.next_waka_index + 1) & 3; + self.next_waka_index = (self.next_waka_index + 1) % WAKA_SOUND_COUNT; } /// Plays the provided sound effect once. pub fn play(&mut self, sound: Sound) { - if self.disabled || self.muted { + if !matches!(self.state, AudioState::Enabled { .. }) { return; } @@ -216,21 +188,21 @@ impl Audio { /// Halts all currently playing audio channels. pub fn stop_all(&mut self) { - if !self.disabled { + if self.state != AudioState::Disabled { mixer::Channel::all().halt(); } } /// Pauses all currently playing audio channels. pub fn pause_all(&mut self) { - if !self.disabled { + if self.state != AudioState::Disabled { mixer::Channel::all().pause(); } } /// Resumes all currently playing audio channels. pub fn resume_all(&mut self) { - if !self.disabled { + if self.state != AudioState::Disabled { mixer::Channel::all().resume(); } } @@ -241,15 +213,23 @@ impl Audio { /// their default volume (32) when unmuting. The mute state is tracked internally /// regardless of whether audio is disabled, allowing the state to be preserved. pub fn set_mute(&mut self, mute: bool) { - if !self.disabled { - let channels = 4; - let volume = if mute { 0 } else { 32 }; - for i in 0..channels { - mixer::Channel(i).set_volume(volume); + match (mute, self.state) { + // Mute + (true, AudioState::Enabled { volume }) => { + self.state = AudioState::Muted { previous_volume: volume }; + for i in 0..AUDIO_CHANNELS { + mixer::Channel(i).set_volume(0); + } } + // Unmute + (false, AudioState::Muted { previous_volume }) => { + self.state = AudioState::Enabled { volume: previous_volume }; + for i in 0..AUDIO_CHANNELS { + mixer::Channel(i).set_volume(previous_volume as i32); + } + } + _ => {} } - - self.muted = mute; } /// Returns the current mute state regardless of whether audio is functional. @@ -257,7 +237,7 @@ impl Audio { /// This tracks the user's mute preference and will return `true` if muted /// even when the audio system is disabled due to initialization failures. pub fn is_muted(&self) -> bool { - self.muted + matches!(self.state, AudioState::Muted { .. }) } /// Returns whether the audio system failed to initialize and is non-functional. @@ -266,6 +246,6 @@ impl Audio { /// audio device, or failure to load any sound assets. When disabled, all /// audio operations become no-ops. pub fn is_disabled(&self) -> bool { - self.disabled + matches!(self.state, AudioState::Disabled) } } diff --git a/src/platform/desktop.rs b/src/platform/desktop.rs index e48229a..0e24fe4 100644 --- a/src/platform/desktop.rs +++ b/src/platform/desktop.rs @@ -20,6 +20,7 @@ pub fn sleep(duration: Duration, focused: bool) { } } +#[allow(unused_variables)] pub fn init_console(force_console: bool) -> Result<(), PlatformError> { use crate::formatter::CustomFormatter; use tracing::Level;