571 lines
25 KiB
Rust
571 lines
25 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use itertools::Itertools;
|
|
|
|
use crate::framework::context::Context;
|
|
use crate::framework::error::GameResult;
|
|
use crate::framework::filesystem;
|
|
use crate::input::combined_menu_controller::CombinedMenuController;
|
|
use crate::menu::MenuEntry;
|
|
use crate::menu::{Menu, MenuSelectionResult};
|
|
use crate::scene::title_scene::TitleScene;
|
|
use crate::shared_game_state::{Language, ScreenShakeIntensity, SharedGameState, TimingMode, WindowMode};
|
|
use crate::sound::InterpolationMode;
|
|
use crate::{graphics, VSyncMode};
|
|
|
|
#[derive(PartialEq, Eq, Copy, Clone)]
|
|
#[repr(u8)]
|
|
#[allow(unused)]
|
|
enum CurrentMenu {
|
|
MainMenu,
|
|
GraphicsMenu,
|
|
SoundMenu,
|
|
SoundtrackMenu,
|
|
LanguageMenu,
|
|
}
|
|
|
|
pub struct SettingsMenu {
|
|
current: CurrentMenu,
|
|
main: Menu,
|
|
graphics: Menu,
|
|
sound: Menu,
|
|
soundtrack: Menu,
|
|
language: Menu,
|
|
pub on_title: bool,
|
|
}
|
|
|
|
static DISCORD_LINK: &str = "https://discord.gg/fbRsNNB";
|
|
|
|
impl SettingsMenu {
|
|
pub fn new() -> SettingsMenu {
|
|
let main = Menu::new(0, 0, 220, 0);
|
|
let graphics = Menu::new(0, 0, 180, 0);
|
|
let sound = Menu::new(0, 0, 260, 0);
|
|
let soundtrack = Menu::new(0, 0, 260, 0);
|
|
let language = Menu::new(0, 0, 120, 0);
|
|
|
|
SettingsMenu { current: CurrentMenu::MainMenu, main, graphics, sound, soundtrack, language, on_title: false }
|
|
}
|
|
|
|
pub fn init(&mut self, state: &mut SharedGameState, ctx: &mut Context) -> GameResult {
|
|
#[cfg(not(target_os = "android"))]
|
|
self.graphics.push_entry(MenuEntry::Options(
|
|
state.t("menus.options_menu.graphics_menu.window_mode.entry"),
|
|
state.settings.window_mode as usize,
|
|
vec![
|
|
state.t("menus.options_menu.graphics_menu.window_mode.windowed"),
|
|
state.t("menus.options_menu.graphics_menu.window_mode.fullscreen"),
|
|
],
|
|
));
|
|
|
|
#[cfg(target_os = "android")]
|
|
{
|
|
let entry_text = state.t("menus.options_menu.graphics_menu.window_mode.entry") + " N/A";
|
|
self.graphics.push_entry(MenuEntry::Disabled(entry_text));
|
|
self.graphics.selected += 1;
|
|
}
|
|
|
|
self.graphics.push_entry(MenuEntry::DescriptiveOptions(
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.entry"),
|
|
state.settings.vsync_mode as usize,
|
|
vec![
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.uncapped"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vsync"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_1x"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_2x"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_3x"),
|
|
],
|
|
vec![
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.uncapped_desc"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vsync_desc"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_1x_desc"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_2x_desc"),
|
|
state.t("menus.options_menu.graphics_menu.vsync_mode.vrr_3x_desc"),
|
|
],
|
|
));
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.lighting_effects"),
|
|
state.settings.shader_effects,
|
|
));
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.weapon_light_cone"),
|
|
state.settings.light_cone,
|
|
));
|
|
self.graphics.push_entry(MenuEntry::Options(
|
|
state.t("menus.options_menu.graphics_menu.screen_shake.entry"),
|
|
state.settings.screen_shake_intensity as usize,
|
|
vec![
|
|
state.t("menus.options_menu.graphics_menu.screen_shake.full"),
|
|
state.t("menus.options_menu.graphics_menu.screen_shake.half"),
|
|
state.t("menus.options_menu.graphics_menu.screen_shake.off"),
|
|
],
|
|
));
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.motion_interpolation"),
|
|
state.settings.motion_interpolation,
|
|
));
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.subpixel_scrolling"),
|
|
state.settings.subpixel_coords,
|
|
));
|
|
|
|
// NS version uses two different maps, therefore we can't dynamically switch between graphics presets.
|
|
if state.constants.supports_og_textures {
|
|
if !state.constants.is_switch || self.on_title {
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.original_textures"),
|
|
state.settings.original_textures,
|
|
));
|
|
} else {
|
|
self.graphics
|
|
.push_entry(MenuEntry::Disabled(state.t("menus.options_menu.graphics_menu.original_textures")));
|
|
}
|
|
} else {
|
|
self.graphics.push_entry(MenuEntry::Hidden);
|
|
}
|
|
|
|
if state.constants.is_cs_plus {
|
|
self.graphics.push_entry(MenuEntry::Toggle(
|
|
state.t("menus.options_menu.graphics_menu.seasonal_textures"),
|
|
state.settings.seasonal_textures,
|
|
));
|
|
} else {
|
|
self.graphics.push_entry(MenuEntry::Hidden);
|
|
}
|
|
|
|
self.graphics.push_entry(MenuEntry::Disabled(format!(
|
|
"{} {}",
|
|
state.t("menus.options_menu.graphics_menu.renderer"),
|
|
ctx.renderer.as_ref().unwrap().renderer_name()
|
|
)));
|
|
|
|
self.graphics.push_entry(MenuEntry::Active(state.t("common.back")));
|
|
|
|
self.main.push_entry(MenuEntry::Active(state.t("menus.options_menu.graphics")));
|
|
self.main.push_entry(MenuEntry::Active(state.t("menus.options_menu.sound")));
|
|
|
|
self.language.push_entry(MenuEntry::Disabled(state.t("menus.options_menu.language")));
|
|
for language in Language::values() {
|
|
self.language.push_entry(MenuEntry::Active(language.to_string()));
|
|
}
|
|
self.language.push_entry(MenuEntry::Active(state.t("common.back")));
|
|
|
|
if self.on_title {
|
|
self.main.push_entry(MenuEntry::Active(state.t("menus.options_menu.language")));
|
|
} else {
|
|
self.main.push_entry(MenuEntry::Disabled(state.t("menus.options_menu.language")));
|
|
}
|
|
|
|
self.main.push_entry(MenuEntry::Options(
|
|
state.t("menus.options_menu.game_timing.entry"),
|
|
if state.settings.timing_mode == TimingMode::_50Hz { 0 } else { 1 },
|
|
vec![state.t("menus.options_menu.game_timing.50tps"), state.t("menus.options_menu.game_timing.60tps")],
|
|
));
|
|
|
|
self.main.push_entry(MenuEntry::Active(DISCORD_LINK.to_owned()));
|
|
|
|
self.main.push_entry(MenuEntry::Active(state.t("common.back")));
|
|
|
|
self.sound.push_entry(MenuEntry::OptionsBar(
|
|
state.t("menus.options_menu.sound_menu.music_volume"),
|
|
state.settings.bgm_volume,
|
|
));
|
|
self.sound.push_entry(MenuEntry::OptionsBar(
|
|
state.t("menus.options_menu.sound_menu.effects_volume"),
|
|
state.settings.sfx_volume,
|
|
));
|
|
|
|
self.sound.push_entry(MenuEntry::DescriptiveOptions(
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.entry"),
|
|
state.settings.organya_interpolation as usize,
|
|
vec![
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.nearest"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.linear"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.cosine"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.cubic"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.linear_lp"),
|
|
],
|
|
vec![
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.nearest_desc"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.linear_desc"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.cosine_desc"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.cubic_desc"),
|
|
state.t("menus.options_menu.sound_menu.bgm_interpolation.linear_lp_desc"),
|
|
],
|
|
));
|
|
self.sound.push_entry(MenuEntry::Active(state.tt(
|
|
"menus.options_menu.sound_menu.soundtrack",
|
|
HashMap::from([("soundtrack".to_owned(), state.settings.soundtrack.to_owned())]),
|
|
)));
|
|
self.sound.push_entry(MenuEntry::Active(state.t("common.back")));
|
|
|
|
let mut soundtrack_entries =
|
|
state.constants.soundtracks.iter().filter(|s| s.available).map(|s| s.name.to_owned()).collect_vec();
|
|
soundtrack_entries.push("Organya".to_owned());
|
|
|
|
if let Ok(dir) = filesystem::read_dir(ctx, "/Soundtracks/") {
|
|
for entry in dir {
|
|
if filesystem::is_dir(ctx, &entry) {
|
|
let filename = entry.file_name().unwrap().to_string_lossy().to_string();
|
|
|
|
if !soundtrack_entries.contains(&filename) {
|
|
soundtrack_entries.push(filename);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
soundtrack_entries.sort();
|
|
|
|
for soundtrack in &soundtrack_entries {
|
|
self.soundtrack.push_entry(MenuEntry::Active(soundtrack.to_string()));
|
|
}
|
|
|
|
self.soundtrack.width = soundtrack_entries
|
|
.into_iter()
|
|
.map(|str| state.font.text_width(str.chars(), &state.constants))
|
|
.max_by(|a, b| a.abs().partial_cmp(&b.abs()).unwrap())
|
|
.unwrap_or(self.soundtrack.width as f32) as u16
|
|
+ 32;
|
|
|
|
self.soundtrack.push_entry(MenuEntry::Active(state.t("common.back")));
|
|
|
|
self.update_sizes(state);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn update_sizes(&mut self, state: &SharedGameState) {
|
|
self.main.update_width(state);
|
|
self.main.update_height();
|
|
self.main.x = ((state.canvas_size.0 - self.main.width as f32) / 2.0).floor() as isize;
|
|
self.main.y = 30 + ((state.canvas_size.1 - self.main.height as f32) / 2.0).floor() as isize;
|
|
|
|
self.graphics.update_width(state);
|
|
self.graphics.update_height();
|
|
self.graphics.x = ((state.canvas_size.0 - self.graphics.width as f32) / 2.0).floor() as isize;
|
|
self.graphics.y = 20 + ((state.canvas_size.1 - self.graphics.height as f32) / 2.0).floor() as isize;
|
|
|
|
self.sound.update_width(state);
|
|
self.sound.update_height();
|
|
self.sound.x = ((state.canvas_size.0 - self.sound.width as f32) / 2.0).floor() as isize;
|
|
self.sound.y = 30 + ((state.canvas_size.1 - self.sound.height as f32) / 2.0).floor() as isize;
|
|
|
|
self.soundtrack.update_width(state);
|
|
self.soundtrack.update_height();
|
|
self.soundtrack.x = ((state.canvas_size.0 - self.soundtrack.width as f32) / 2.0).floor() as isize;
|
|
self.soundtrack.y = ((state.canvas_size.1 - self.soundtrack.height as f32) / 2.0).floor() as isize;
|
|
|
|
self.language.update_width(state);
|
|
self.language.update_height();
|
|
self.language.x = ((state.canvas_size.0 - self.language.width as f32) / 2.0).floor() as isize;
|
|
self.language.y = ((state.canvas_size.1 - self.language.height as f32) / 2.0).floor() as isize;
|
|
}
|
|
|
|
pub fn tick(
|
|
&mut self,
|
|
exit_action: &mut dyn FnMut(),
|
|
controller: &mut CombinedMenuController,
|
|
state: &mut SharedGameState,
|
|
ctx: &mut Context,
|
|
) -> GameResult {
|
|
self.update_sizes(state);
|
|
|
|
match self.current {
|
|
CurrentMenu::MainMenu => match self.main.tick(controller, state) {
|
|
MenuSelectionResult::Selected(0, _) => {
|
|
self.current = CurrentMenu::GraphicsMenu;
|
|
}
|
|
MenuSelectionResult::Selected(1, _) => {
|
|
self.current = CurrentMenu::SoundMenu;
|
|
}
|
|
MenuSelectionResult::Selected(2, _) => {
|
|
self.language.selected = (state.settings.locale as usize) + 1;
|
|
self.current = CurrentMenu::LanguageMenu;
|
|
}
|
|
MenuSelectionResult::Selected(3, toggle) => {
|
|
if let MenuEntry::Options(_, value, _) = toggle {
|
|
match state.settings.timing_mode {
|
|
TimingMode::_50Hz => {
|
|
state.settings.timing_mode = TimingMode::_60Hz;
|
|
*value = 1;
|
|
}
|
|
TimingMode::_60Hz => {
|
|
state.settings.timing_mode = TimingMode::_50Hz;
|
|
*value = 0;
|
|
}
|
|
_ => {}
|
|
}
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(4, _) => {
|
|
if let Err(e) = webbrowser::open(DISCORD_LINK) {
|
|
log::warn!("Error opening web browser: {}", e);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(5, _) | MenuSelectionResult::Canceled => exit_action(),
|
|
_ => (),
|
|
},
|
|
CurrentMenu::GraphicsMenu => match self.graphics.tick(controller, state) {
|
|
MenuSelectionResult::Selected(0, toggle)
|
|
| MenuSelectionResult::Right(0, toggle, _)
|
|
| MenuSelectionResult::Left(0, toggle, _) => {
|
|
if let MenuEntry::Options(_, value, _) = toggle {
|
|
let (new_mode, new_value) = match *value {
|
|
0 => (WindowMode::Fullscreen, 1),
|
|
1 => (WindowMode::Windowed, 0),
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.window_mode = new_mode;
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(1, toggle) | MenuSelectionResult::Right(1, toggle, _) => {
|
|
if let MenuEntry::DescriptiveOptions(_, value, _, _) = toggle {
|
|
let (new_mode, new_value) = match *value {
|
|
0 => (VSyncMode::VSync, 1),
|
|
1 => (VSyncMode::VRRTickSync1x, 2),
|
|
2 => (VSyncMode::VRRTickSync2x, 3),
|
|
3 => (VSyncMode::VRRTickSync3x, 4),
|
|
_ => (VSyncMode::Uncapped, 0),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.vsync_mode = new_mode;
|
|
graphics::set_vsync_mode(ctx, new_mode)?;
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Left(1, toggle, _) => {
|
|
if let MenuEntry::DescriptiveOptions(_, value, _, _) = toggle {
|
|
let (new_mode, new_value) = match *value {
|
|
0 => (VSyncMode::VRRTickSync3x, 4),
|
|
1 => (VSyncMode::Uncapped, 0),
|
|
2 => (VSyncMode::VSync, 1),
|
|
3 => (VSyncMode::VRRTickSync1x, 2),
|
|
_ => (VSyncMode::VRRTickSync2x, 3),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.vsync_mode = new_mode;
|
|
graphics::set_vsync_mode(ctx, new_mode)?;
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(2, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.shader_effects = !state.settings.shader_effects;
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.shader_effects;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(3, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.light_cone = !state.settings.light_cone;
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.light_cone;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(4, toggle) | MenuSelectionResult::Right(4, toggle, _) => {
|
|
if let MenuEntry::Options(_, value, _) = toggle {
|
|
let (new_intensity, new_value) = match *value {
|
|
0 => (ScreenShakeIntensity::Half, 1),
|
|
1 => (ScreenShakeIntensity::Off, 2),
|
|
_ => (ScreenShakeIntensity::Full, 0),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.screen_shake_intensity = new_intensity;
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Left(4, toggle, _) => {
|
|
if let MenuEntry::Options(_, value, _) = toggle {
|
|
let (new_intensity, new_value) = match *value {
|
|
0 => (ScreenShakeIntensity::Off, 2),
|
|
1 => (ScreenShakeIntensity::Full, 0),
|
|
_ => (ScreenShakeIntensity::Half, 1),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.screen_shake_intensity = new_intensity;
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(5, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.motion_interpolation = !state.settings.motion_interpolation;
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.motion_interpolation;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(6, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.subpixel_coords = !state.settings.subpixel_coords;
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.subpixel_coords;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(7, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.original_textures = !state.settings.original_textures;
|
|
if self.on_title {
|
|
state.reload_resources(ctx)?;
|
|
} else {
|
|
state.reload_graphics();
|
|
}
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.original_textures;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(8, toggle) => {
|
|
if let MenuEntry::Toggle(_, value) = toggle {
|
|
state.settings.seasonal_textures = !state.settings.seasonal_textures;
|
|
state.reload_graphics();
|
|
let _ = state.settings.save(ctx);
|
|
|
|
*value = state.settings.seasonal_textures;
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(10, _) | MenuSelectionResult::Canceled => {
|
|
self.current = CurrentMenu::MainMenu
|
|
}
|
|
_ => (),
|
|
},
|
|
CurrentMenu::SoundMenu => match self.sound.tick(controller, state) {
|
|
MenuSelectionResult::Left(0, bgm, direction) | MenuSelectionResult::Right(0, bgm, direction) => {
|
|
if let MenuEntry::OptionsBar(_, value) = bgm {
|
|
*value = (*value * 10.0 + (direction as f32)).clamp(0.0, 10.0) / 10.0;
|
|
state.settings.bgm_volume = *value;
|
|
state.sound_manager.set_song_volume(*value);
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Left(1, sfx, direction) | MenuSelectionResult::Right(1, sfx, direction) => {
|
|
if let MenuEntry::OptionsBar(_, value) = sfx {
|
|
*value = (*value * 10.0 + (direction as f32)).clamp(0.0, 10.0) / 10.0;
|
|
state.settings.sfx_volume = *value;
|
|
state.sound_manager.set_sfx_volume(*value);
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(2, toggle) => {
|
|
if let MenuEntry::DescriptiveOptions(_, value, _, _) = toggle {
|
|
let (new_mode, new_value) = match *value {
|
|
0 => (InterpolationMode::Linear, 1),
|
|
1 => (InterpolationMode::Cosine, 2),
|
|
2 => (InterpolationMode::Cubic, 3),
|
|
3 => (InterpolationMode::Polyphase, 4),
|
|
_ => (InterpolationMode::Nearest, 0),
|
|
};
|
|
|
|
*value = new_value;
|
|
state.settings.organya_interpolation = new_mode;
|
|
state.sound_manager.set_org_interpolation(new_mode);
|
|
|
|
let _ = state.settings.save(ctx);
|
|
}
|
|
}
|
|
MenuSelectionResult::Selected(3, _) => {
|
|
let mut active_soundtrack_index = 0;
|
|
|
|
for (idx, entry) in self.soundtrack.entries.iter().enumerate() {
|
|
if let MenuEntry::Active(soundtrack) = entry {
|
|
if soundtrack == &state.settings.soundtrack {
|
|
active_soundtrack_index = idx;
|
|
let _ = state.settings.save(ctx);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
self.soundtrack.selected = active_soundtrack_index;
|
|
|
|
self.current = CurrentMenu::SoundtrackMenu
|
|
}
|
|
MenuSelectionResult::Selected(4, _) | MenuSelectionResult::Canceled => {
|
|
self.current = CurrentMenu::MainMenu
|
|
}
|
|
_ => (),
|
|
},
|
|
CurrentMenu::LanguageMenu => {
|
|
let last = self.language.entries.len() - 1;
|
|
|
|
match self.language.tick(controller, state) {
|
|
MenuSelectionResult::Selected(idx, entry) => {
|
|
if let (true, MenuEntry::Active(_)) = (idx != last, entry) {
|
|
let new_locale = Language::from_primitive(idx.saturating_sub(1));
|
|
if new_locale == state.settings.locale {
|
|
self.current = CurrentMenu::MainMenu;
|
|
} else {
|
|
state.settings.locale = new_locale;
|
|
state.reload_fonts(ctx);
|
|
|
|
let _ = state.settings.save(ctx);
|
|
|
|
let mut new_menu = TitleScene::new();
|
|
new_menu.open_settings_menu()?;
|
|
state.next_scene = Some(Box::new(new_menu));
|
|
}
|
|
}
|
|
|
|
self.current = CurrentMenu::MainMenu;
|
|
}
|
|
MenuSelectionResult::Canceled => {
|
|
self.current = CurrentMenu::MainMenu;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
CurrentMenu::SoundtrackMenu => {
|
|
let last = self.soundtrack.entries.len() - 1;
|
|
match self.soundtrack.tick(controller, state) {
|
|
MenuSelectionResult::Selected(idx, entry) => {
|
|
if let (true, MenuEntry::Active(name)) = (idx != last, entry) {
|
|
state.settings.soundtrack = name.to_owned();
|
|
let _ = state.settings.save(ctx);
|
|
self.sound.entries[3] =
|
|
MenuEntry::Active(format!("Soundtrack: {}", state.settings.soundtrack));
|
|
state.sound_manager.reload_songs(&state.constants, &state.settings, ctx)?;
|
|
}
|
|
|
|
self.current = CurrentMenu::SoundMenu;
|
|
}
|
|
MenuSelectionResult::Canceled => {
|
|
self.current = CurrentMenu::SoundMenu;
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw(&self, state: &mut SharedGameState, ctx: &mut Context) -> GameResult {
|
|
match self.current {
|
|
CurrentMenu::MainMenu => self.main.draw(state, ctx)?,
|
|
CurrentMenu::GraphicsMenu => self.graphics.draw(state, ctx)?,
|
|
CurrentMenu::SoundMenu => self.sound.draw(state, ctx)?,
|
|
CurrentMenu::SoundtrackMenu => self.soundtrack.draw(state, ctx)?,
|
|
CurrentMenu::LanguageMenu => self.language.draw(state, ctx)?,
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|