Finish song select scene

Author: 0e4ef622

sample_config.toml

@@ -24,11 +24,11 @@ osu_hitsound_enable = false
 
 [game.skins.o2jamu]
 type = "osu"
-path = "test/test_skin"
+path = "test/o2jamuskin"
 
 [game.skins.jhlee]
 type = "osu"
-path = "jhlee"
+path = "test/jhlee"
 
 [game.skins.o2jamdefault]
 type = "o2jam"

src/chart/mod.rs

@@ -167,6 +167,6 @@ pub struct ChartSet {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Difficulty {
-    name: String,
-    path: path::PathBuf,
+    pub name: String,
+    pub path: path::PathBuf,
 }

src/chart/osu.rs

@@ -1037,7 +1037,8 @@ pub fn gen_song_list<P: AsRef<Path>>(path: P) -> Result<Vec<super::ChartSet>, io
                     chart_set.song_name = c.song_name;
                     chart_set.song_name_unicode = c.song_name_unicode;
                 }
-                Err(e) => remani_warn!("Error parsing osu file `{}': {}", path.display(), e),
+                // Err(e) => remani_warn!("Error parsing osu file `{}': {}", path.display(), e),
+                Err(_) => (), // ignore for now since they're annoying
             }
         }
         if chart_set != super::ChartSet::default() {

src/lib.rs

@@ -1,4 +1,6 @@
 #![deny(rust_2018_idioms)]
+#![feature(fnbox)]
+#![feature(inner_deref)]
 
 macro_rules! remani_warn {
     ($fmt:expr) => (eprintln!(concat!("WARNING: ", $fmt)));

src/window/game/mod.rs

@@ -12,7 +12,7 @@ mod model;
 mod view;
 
 use self::{model::Model, view::View};
-use super::WindowContext;
+use super::{song_select::SongSelect, WindowContext};
 
 use crate::{audio, chart::Chart, config::Config, judgement::Judgement, gameskin};
 
@@ -26,6 +26,7 @@ pub struct GameScene {
     first_playhead_received: bool,
     first_playhead_request: bool,
     current_autoplay_sound_index: usize,
+    chart_end_time: Option<f64>,
 }
 
 impl GameScene {
@@ -54,6 +55,7 @@ impl GameScene {
             first_playhead_received: false,
             first_playhead_request: false,
             current_autoplay_sound_index: 0,
+            chart_end_time: None,
         }
     }
 
@@ -97,9 +99,11 @@ impl GameScene {
 
         if let Some(u) = e.update_args() {
             let view = &mut self.view;
+            // Update notes in model, draw any misses that occurred
             self.model.update(u, config, &*self.chart, self.time, |k| {
                 view.draw_judgement(k, Judgement::Miss, false)
             });
+            // Play the autoplay sounds if one needs to be played
             if let Some(autoplay_sound) = self.chart.autoplay_sounds().get(self.current_autoplay_sound_index) {
                 // Unapply the offset to make sure the autoplay sound lines up with the music
                 if self.time - config.game.offset >= autoplay_sound.time {
@@ -112,6 +116,16 @@ impl GameScene {
                         );
                 }
             }
+            if view.chart_ended(&*self.chart) && self.chart_end_time.is_none() {
+                self.chart_end_time = Some(self.time);
+            }
+
+            if let Some(chart_end_time) = self.chart_end_time {
+                if self.time - 10.0 > chart_end_time {
+                    let song_select_scene = SongSelect::new(window, config);
+                    window.change_scene(song_select_scene);
+                }
+            }
         }
 
         if let Some(i) = e.press_args() {

src/window/game/view.rs

@@ -166,6 +166,12 @@ impl<G: Graphics> View<G> {
         self.skin.key_up(column);
         self.skin.long_note_hit_anim_stop(column);
     }
+
+    pub fn chart_ended(&self, chart: &dyn chart::Chart) -> bool {
+        self.next_note_index >= chart.notes().len()
+            && self.notes_on_screen_indices.len() == 0
+            && self.notes_below_screen_indices.len() == 0
+    }
 }
 
 /// Given the time in seconds from the start of the song, calculate the position, taking into

src/window/main_menu.rs

@@ -6,9 +6,8 @@ use piston::{
 };
 use texture::{ImageSize, TextureSettings};
 
-// use super::{options, game, WindowContext};
 use super::{options, song_select, WindowContext};
-use crate::{audio, chart, config::Config};
+use crate::{audio, config::Config};
 
 pub struct MainMenu {
     play_texture: Texture,
@@ -43,11 +42,8 @@ impl MainMenu {
     ) {
         if let Some(i) = e.press_args() {
             if i == Button::Mouse(mouse::MouseButton::Left) && window.mouse_position[1] < self.window_height / 3.0 {
-                // match chart::osu::from_path("test/test_chart/test.osu") {
-                //     Ok(x) => window.change_scene(game::GameScene::new(Box::new(x), config, audio)),
-                //     Err(e) => println!("{}", e),
-                // }
-                window.change_scene(song_select::SongSelect::new(window, config));
+                let song_select = song_select::SongSelect::new(window, config);
+                window.change_scene(song_select);
             } else if i == Button::Mouse(mouse::MouseButton::Left) && window.mouse_position[1] < self.window_height / 3.0 * 2.0 {
                 window.change_scene(options::Options::new(window, config));
             }

src/window/mod.rs

@@ -4,7 +4,7 @@ use glutin_window::GlutinWindow;
 use opengl_graphics::GlGraphics;
 use piston::{input::MouseCursorEvent, event_loop::EventLoop};
 
-use crate::{audio, config::Config};
+use crate::{audio, chart, config::Config};
 
 mod game;
 mod main_menu;
@@ -59,21 +59,83 @@ impl From<song_select::SongSelect> for Scene {
     }
 }
 
+impl From<Scene> for Option<main_menu::MainMenu> {
+    fn from(t: Scene) -> Self {
+        match t {
+            Scene::MainMenu(s) => Some(s),
+            _ => None,
+        }
+    }
+}
+
+impl From<Scene> for Option<options::Options> {
+    fn from(t: Scene) -> Self {
+        match t {
+            Scene::Options(s) => Some(s),
+            _ => None,
+        }
+    }
+}
+
+impl From<Scene> for Option<game::GameScene> {
+    fn from(t: Scene) -> Self {
+        match t {
+            Scene::Game(s) => Some(s),
+            _ => None,
+        }
+    }
+}
+
+impl From<Scene> for Option<song_select::SongSelect> {
+    fn from(t: Scene) -> Self {
+        match t {
+            Scene::SongSelect(s) => Some(s),
+            _ => None,
+        }
+    }
+}
+
+/// A struct for caching things scenes use so e.g. the song list scene doesn't have to regenerate
+/// the song list everytime it's viewed.
+#[derive(Default)]
+struct SceneResources {
+    song_list: Option<Vec<chart::ChartSet>>,
+    last_selected_song_index: usize,
+}
+
+enum NextScene {
+    Plain(Scene),
+    Function(Box<dyn std::boxed::FnBox(Scene, &mut WindowContext) -> Scene>),
+}
+
 struct WindowContext {
     gl: GlGraphics,
     font: conrod::text::Font, // one font for now
 
     /// Kept track of here so that mouse coordinates don't get messed up when changing scenes.
     mouse_position: [f64; 2],
-    next_scene: Option<Scene>,
+    next_scene: Option<NextScene>,
 
     /// The underlying window
     window: GlutinWindow,
+
+    resources: SceneResources,
 }
 
 impl WindowContext {
     fn change_scene<T: Into<Scene>>(&mut self, next_scene: T) {
-        self.next_scene = Some(next_scene.into());
+        self.next_scene = Some(NextScene::Plain(next_scene.into()));
+    }
+    fn change_scene_with<S, T, F>(&mut self, next_scene: F)
+    where
+        Option<S>: From<Scene>,
+        T: Into<Scene>,
+        for<'a> F: FnOnce(S, &'a mut WindowContext) -> T + 'static,
+    {
+        self.next_scene = Some(NextScene::Function(Box::new(move |scene: Scene, wc: &mut WindowContext| {
+            let scene = Option::from(scene).expect("Wrong scene type");
+            next_scene(scene, wc).into()
+        })));
     }
 }
 
@@ -109,19 +171,24 @@ pub fn start(mut config: Config) {
             .expect("Failed to load Wen Quan Yi Micro Hei font"),
         mouse_position: [-1.0, -1.0],
         window: glutin_window,
+        resources: SceneResources::default(),
     };
-    let mut current_scene = Scene::MainMenu(main_menu::MainMenu::new());
+    let mut current_scene = Some(Scene::MainMenu(main_menu::MainMenu::new()));
 
     // the UI scenes need to be able to manually swap buffers to allow lazy redrawing
     let mut events = Events::new(EventSettings::new().swap_buffers(false));
     while let Some(e) = events.next(&mut window.window) {
         if let Some(p) = e.mouse_cursor_args() {
             window.mouse_position = p;
         }
-        current_scene.event(e, &mut config, &audio, &mut window);
+        current_scene.as_mut().unwrap().event(e, &mut config, &audio, &mut window);
 
         if window.next_scene.is_some() {
-            current_scene = window.next_scene.take().unwrap();
+            current_scene = Some(match window.next_scene.take() {
+                Some(NextScene::Plain(s)) => s,
+                Some(NextScene::Function(f)) => f.call_box((current_scene.take().unwrap(), &mut window)),
+                None => unreachable!(),
+            });
         }
     }
 }