Make settings resettable

rust/src/game_settings.rs

@@ -51,7 +51,7 @@ pub struct KeybindSettings {
     pub jump: Keybind,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
 pub enum Keybind {
     Key(i32),
     MouseButton(i32),

rust/src/ui/settings.rs

@@ -10,7 +10,7 @@ use godot::{
 };
 
 use crate::{
-    game_settings::{GameSettingsManager, Keybind},
+    game_settings::{GameSettings, GameSettingsManager, Keybind},
     ui::slider::SliderContainer,
 };
 
@@ -85,14 +85,14 @@ impl Setting {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum SettingValue {
     SliderNumber(SliderValue),
     String(String),
     Keybind(Keybind),
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct SliderValue {
     min: f64,
     max: f64,
@@ -114,9 +114,13 @@ pub struct SettingsPanel {
     reset_button: Option<Gd<PackedScene>>,
 
     settings: HashMap<Setting, SettingValue>,
+    default_settings: HashMap<Setting, SettingValue>,
 
     keybind_button: Option<(Setting, Gd<Button>)>,
 
+    values: HashMap<Setting, Gd<Control>>,
+    reset_buttons: HashMap<Setting, Gd<Button>>,
+
     base: Base<PanelContainer>,
 }
 
@@ -125,91 +129,16 @@ impl IPanelContainer for SettingsPanel {
     fn ready(&mut self) {
         let singleton = GameSettingsManager::singleton();
         let settings = &singleton.bind().settings;
-        self.settings.insert(
+        let default_settings = GameSettings::default();
-            Setting::FoV,
+        settings_from(&mut self.settings, settings);
-            SettingValue::SliderNumber(SliderValue {
+        settings_from(&mut self.default_settings, &default_settings);
-                min: 60.,
-                max: 120.,
-                value: settings.fov,
-            }),
-        );
-        self.settings.insert(
-            Setting::DefaultName,
-            SettingValue::String(settings.default_name.clone()),
-        );
-        self.settings.insert(
-            Setting::MasterVolume,
-            SettingValue::SliderNumber(SliderValue {
-                min: 0.,
-                max: 100.,
-                value: settings.volume.master_volume,
-            }),
-        );
-        self.settings.insert(
-            Setting::SfxVolume,
-            SettingValue::SliderNumber(SliderValue {
-                min: 0.,
-                max: 100.,
-                value: settings.volume.sfx_volume,
-            }),
-        );
-        self.settings.insert(
-            Setting::MusicVolume,
-            SettingValue::SliderNumber(SliderValue {
-                min: 0.,
-                max: 100.,
-                value: settings.volume.music_volume,
-            }),
-        );
-        self.settings.insert(
-            Setting::AnnouncerVolume,
-            SettingValue::SliderNumber(SliderValue {
-                min: 0.,
-                max: 100.,
-                value: settings.volume.announcer_volume,
-            }),
-        );
-
-        self.settings.insert(
-            Setting::MoveForward,
-            SettingValue::Keybind(settings.keybinds.move_forward),
-        );
-        self.settings.insert(
-            Setting::MoveBackward,
-            SettingValue::Keybind(settings.keybinds.move_backward),
-        );
-        self.settings.insert(
-            Setting::MoveLeft,
-            SettingValue::Keybind(settings.keybinds.move_left),
-        );
-        self.settings.insert(
-            Setting::MoveRight,
-            SettingValue::Keybind(settings.keybinds.move_right),
-        );
-        self.settings.insert(
-            Setting::SelectRaygun,
-            SettingValue::Keybind(settings.keybinds.select_raygun),
-        );
-        self.settings.insert(
-            Setting::SelectShotgun,
-            SettingValue::Keybind(settings.keybinds.select_shotgun),
-        );
-        self.settings.insert(
-            Setting::Shoot,
-            SettingValue::Keybind(settings.keybinds.shoot),
-        );
-        self.settings.insert(
-            Setting::Melee,
-            SettingValue::Keybind(settings.keybinds.melee),
-        );
-        self.settings
-            .insert(Setting::Jump, SettingValue::Keybind(settings.keybinds.jump));
 
         let mut keys = self.settings.keys().collect::<Vec<_>>();
         keys.sort();
 
         for setting in keys.into_iter() {
             let value = self.settings.get(setting).unwrap().clone();
+            let default_value = self.default_settings.get(setting).unwrap().clone();
 
             let grid = match setting.tab() {
                 SettingsTab::General => self.general_grid.clone(),
@@ -224,9 +153,17 @@ impl IPanelContainer for SettingsPanel {
                 grid.add_child(&label);
 
                 if let Some(reset_btn) = &self.reset_button {
-                    let button = reset_btn.instantiate_as::<Button>();
+                    let mut button = reset_btn.instantiate_as::<Button>();
+                    button.set_disabled(value == default_value);
+
+                    let setting_clone = setting.clone();
+                    let default_value_clone = default_value.clone();
+                    button.signals().pressed().connect_other(self, move |s| {
+                        s.change_value(setting_clone, default_value_clone.clone());
+                    });
 
                     grid.add_child(&button);
+                    self.reset_buttons.insert(*setting, button);
                 }
 
                 if let Some(scene) = self.slider_scene.clone() {
@@ -297,6 +234,8 @@ impl IPanelContainer for SettingsPanel {
                         }
                     };
 
+                    self.values.insert(*setting, node.clone());
+
                     grid.add_child(&node);
                 }
             }
@@ -319,7 +258,38 @@ impl IPanelContainer for SettingsPanel {
 
 #[godot_api]
 impl SettingsPanel {
+    pub fn change_value(&mut self, setting: Setting, new_value: SettingValue) {
+        if let Some(control) = self.values.get(&setting).cloned() {
+            match new_value.clone() {
+                SettingValue::SliderNumber(slider_value) => {
+                    if let Ok(mut slider) = control.try_cast::<SliderContainer>() {
+                        slider.bind_mut().value = slider_value.value;
+                    }
+                }
+                SettingValue::String(text) => {
+                    if let Ok(mut edit) = control.try_cast::<LineEdit>() {
+                        edit.set_text(&text);
+                        self.on_change(setting, new_value);
+                    }
+                }
+                SettingValue::Keybind(keybind) => {
+                    if let Ok(mut button) = control.try_cast::<Button>() {
+                        button.set_text(&keybind.to_string());
+                        self.on_change(setting, new_value);
+                    }
+                }
+            }
+        }
+    }
+
     pub fn on_change(&mut self, setting: Setting, new_value: SettingValue) {
+        if let Some(reset_btn) = self.reset_buttons.get_mut(&setting)
+            && let Some(default_value) = self.default_settings.get(&setting)
+        {
+            godot_print!("{:?} == {:?}", new_value, default_value);
+            reset_btn.set_disabled(new_value == *default_value);
+        }
+
         self.settings.insert(setting, new_value);
 
         let mut new_settings = GameSettingsManager::singleton().bind().settings.clone();
@@ -361,7 +331,7 @@ impl SettingsPanel {
                     new_settings.keybinds.select_raygun = *keybind;
                 }
                 (Setting::SelectShotgun, SettingValue::Keybind(keybind)) => {
-                    new_settings.keybinds.select_raygun = *keybind;
+                    new_settings.keybinds.select_shotgun = *keybind;
                 }
                 (Setting::Shoot, SettingValue::Keybind(keybind)) => {
                     new_settings.keybinds.shoot = *keybind;
@@ -390,3 +360,84 @@ impl SettingsPanel {
         self.base_mut().set_visible(false);
     }
 }
+
+fn settings_from(map: &mut HashMap<Setting, SettingValue>, settings: &GameSettings) {
+    map.insert(
+        Setting::FoV,
+        SettingValue::SliderNumber(SliderValue {
+            min: 60.,
+            max: 120.,
+            value: settings.fov,
+        }),
+    );
+    map.insert(
+        Setting::DefaultName,
+        SettingValue::String(settings.default_name.clone()),
+    );
+    map.insert(
+        Setting::MasterVolume,
+        SettingValue::SliderNumber(SliderValue {
+            min: 0.,
+            max: 100.,
+            value: settings.volume.master_volume,
+        }),
+    );
+    map.insert(
+        Setting::SfxVolume,
+        SettingValue::SliderNumber(SliderValue {
+            min: 0.,
+            max: 100.,
+            value: settings.volume.sfx_volume,
+        }),
+    );
+    map.insert(
+        Setting::MusicVolume,
+        SettingValue::SliderNumber(SliderValue {
+            min: 0.,
+            max: 100.,
+            value: settings.volume.music_volume,
+        }),
+    );
+    map.insert(
+        Setting::AnnouncerVolume,
+        SettingValue::SliderNumber(SliderValue {
+            min: 0.,
+            max: 100.,
+            value: settings.volume.announcer_volume,
+        }),
+    );
+
+    map.insert(
+        Setting::MoveForward,
+        SettingValue::Keybind(settings.keybinds.move_forward),
+    );
+    map.insert(
+        Setting::MoveBackward,
+        SettingValue::Keybind(settings.keybinds.move_backward),
+    );
+    map.insert(
+        Setting::MoveLeft,
+        SettingValue::Keybind(settings.keybinds.move_left),
+    );
+    map.insert(
+        Setting::MoveRight,
+        SettingValue::Keybind(settings.keybinds.move_right),
+    );
+    map.insert(
+        Setting::SelectRaygun,
+        SettingValue::Keybind(settings.keybinds.select_raygun),
+    );
+    map.insert(
+        Setting::SelectShotgun,
+        SettingValue::Keybind(settings.keybinds.select_shotgun),
+    );
+    map.insert(
+        Setting::Shoot,
+        SettingValue::Keybind(settings.keybinds.shoot),
+    );
+    map.insert(
+        Setting::Melee,
+        SettingValue::Keybind(settings.keybinds.melee),
+    );
+    map.insert(Setting::Jump, SettingValue::Keybind(settings.keybinds.jump));
+}