skullball/rust/src/game_settings.rs

use std::{
    net::SocketAddr,
    time::{Duration, SystemTime, UNIX_EPOCH},
};

use godot::{
    classes::{AudioBusLayout, AudioServer, FileAccess, file_access::ModeFlags},
    prelude::*,
    tools::get_autoload_by_name,
};
use serde::{Deserialize, Serialize};

use crate::ui::settings::Setting::MusicVolume;

pub const NETWORK_SINGLETON_NAME: &str = "GameSettingsGlobal";

pub const MASTER_BUS: &str = "Master";
pub const SFX_BUS: &str = "SFX";
pub const MUSIC_BUS: &str = "Music";
pub const ANNOUNCER_BUS: &str = "Announcer";

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct GameSettings {
    pub fov: f64,
    pub default_name: String,
    pub recent_servers: Vec<RecentServer>,
    pub volume: VolumeSettings,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct VolumeSettings {
    pub master_volume: f64,
    pub sfx_volume: f64,
    pub music_volume: f64,
    pub announcer_volume: f64,
}

impl VolumeSettings {
    pub fn master(&self) -> f32 {
        (self.master_volume / 100.) as f32
    }

    pub fn sfx(&self) -> f32 {
        (self.sfx_volume / 100.) as f32
    }

    pub fn music(&self) -> f32 {
        (self.music_volume / 10_000.) as f32
    }

    pub fn announcer(&self) -> f32 {
        (self.announcer_volume / 100.) as f32
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RecentServer {
    pub addr: SocketAddr,
    pub visited: u128,
}

impl Default for GameSettings {
    fn default() -> Self {
        Self {
            fov: 90.,
            default_name: "Default McGee".to_owned(),
            recent_servers: Vec::new(),
            volume: VolumeSettings {
                master_volume: 100.,
                sfx_volume: 100.,
                music_volume: 100.,
                announcer_volume: 100.,
            },
        }
    }
}

#[derive(GodotClass)]
#[class(base=Node)]
pub struct GameSettingsManager {
    pub settings: GameSettings,
    base: Base<Node>,
}

#[godot_api]
impl INode for GameSettingsManager {
    fn init(base: Base<Node>) -> GameSettingsManager {
        let mut settings = GameSettings::default();
        if let Some(file) = FileAccess::open("user://config.toml", ModeFlags::READ) {
            if let Ok(deserialized) = toml::from_str(&file.get_as_text().to_string()) {
                settings = deserialized;
            }
        }
        GameSettingsManager { settings, base }
    }
}

#[godot_api]
impl GameSettingsManager {
    #[signal]
    pub fn on_settings_changed();

    pub fn singleton() -> Gd<GameSettingsManager> {
        get_autoload_by_name::<GameSettingsManager>(NETWORK_SINGLETON_NAME)
    }

    pub fn update_settings(&mut self, settings: GameSettings) {
        set_bus_volume(MASTER_BUS, settings.volume.master());
        set_bus_volume(SFX_BUS, settings.volume.sfx());
        set_bus_volume(MUSIC_BUS, settings.volume.music());
        set_bus_volume(ANNOUNCER_BUS, settings.volume.announcer());

        self.settings = settings;
        if let Some(mut file) = FileAccess::open("user://config.toml", ModeFlags::WRITE) {
            if let Ok(serialized) = toml::to_string(&self.settings) {
                file.store_string(&serialized);
            }
        }

        self.run_deferred(|s| s.signals().on_settings_changed().emit());
    }

    pub fn visit_server(&mut self, server: SocketAddr) {
        if let Some(server) = self
            .settings
            .recent_servers
            .iter_mut()
            .find(|s| s.addr == server)
        {
            server.visited = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap_or(Duration::from_millis(0))
                .as_nanos();
        } else {
            self.settings.recent_servers.push(RecentServer {
                addr: server,
                visited: SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap_or(Duration::from_millis(0))
                    .as_nanos(),
            });
        }
        let mut servers = self.settings.recent_servers.clone();

        servers.sort_by_key(|s| s.visited);
        servers = servers.into_iter().rev().collect();
        while servers.len() > 10 {
            servers.remove(0);
        }
        let settings = GameSettings {
            recent_servers: servers,
            ..self.settings.clone()
        };
        self.update_settings(settings);
    }
}

fn set_bus_volume(bus: &str, volume: f32) {
    let idx = AudioServer::singleton().get_bus_index(bus);
    AudioServer::singleton().set_bus_volume_linear(idx, volume);
}