Merge branch 'master' into levels_update_img

.gitignore

@@ -10,3 +10,4 @@ Cargo.lock
 **/*.rs.bk
 
 /*.gif
+/savegame.json

README.md

@@ -28,11 +28,12 @@ This game is developed by a team of 6 students from *Sheridan College* and *Tren
 - [**Luna Sicardi**](https://github.com/LuS404)
   - Software developer
   - UI design
-- **Emilia Frias**
+- [**Emilia Frias**](https://www.instagram.com/demilurii/)
   - Character art
   - Animations
-  - Map assets
+  - Tilesets
-- **Kori**
+- [**Kori**](https://www.instagram.com/korigama/)
   - Concept art
+  - Tilesets
 
 A special thanks goes out to: [James Nickoli](https://github.com/rsninja722/) for insight on 2D collision detection, as well as [Ray](https://github.com/raysan5) and the members of the [raylib community](https://discord.gg/raylib) on discord for their support with the past two game jam projects.

game/Cargo.toml

@@ -14,7 +14,7 @@ tracing = { version = "0.1", features = ["log"] }
 serde = { version = "1.0.126", features = ["derive"] }
 serde_json = "1.0.64"
 thiserror = "1.0"
-chrono = "0.4"
+chrono = { version = "0.4", features = ["serde"] }
 rust-embed = "6.2.0"
 raylib = { version = "3.5", git = "https://github.com/ewpratten/raylib-rs", rev = "2ae949cb3488dd1bb052ece71d61021c8dd6e910", features = [
     "serde"
@@ -31,7 +31,7 @@ pkg-version = "1.0"
 cfg-if = "1.0"
 num-derive = "0.3"
 num = "0.4"
-tiled = { version  ="0.9.5", default-features = false }
+tiled = { version = "0.9.5", default-features = false }
 async-trait = "0.1.51"
 webbrowser = "0.5"
 

game/src/context.rs

@@ -1,20 +1,30 @@
-use std::{cell::RefCell, sync::mpsc::Sender};
+use std::{cell::RefCell, collections::HashMap, sync::mpsc::Sender};
 
+use chrono::{DateTime, Duration, Utc};
 use discord_sdk::activity::ActivityBuilder;
+use raylib::audio::Sound;
 
-use crate::{utilities::non_ref_raylib::HackedRaylibHandle, GameConfig};
+use crate::{GameConfig, progress::ProgressData, utilities::{audio_player::AudioPlayer, non_ref_raylib::HackedRaylibHandle}};
 
 #[derive(Debug)]
 pub enum ControlFlag {
     Quit,
     SwitchLevel(usize),
+    UpdateLevelStart(DateTime<Utc>),
+    SaveProgress,
+    MaybeUpdateHighScore(usize, Duration),
+    SoundTrigger(String)
 }
 
 #[derive(Debug)]
 pub struct GameContext {
     pub renderer: RefCell<HackedRaylibHandle>,
+    pub audio: AudioPlayer,
+    pub sounds: HashMap<String, Sound>,
     pub config: GameConfig,
+    pub player_progress: ProgressData,
     pub current_level: usize,
+    pub level_start_time: DateTime<Utc>,
     pub discord_rpc_send: Sender<Option<ActivityBuilder>>,
     pub flag_send: Sender<Option<ControlFlag>>,
 }

game/src/lib.rs

@@ -70,8 +70,9 @@
 )]
 #![clippy::msrv = "1.57.0"]
 
-use std::{borrow::BorrowMut, cell::RefCell, sync::mpsc::TryRecvError};
+use std::{borrow::BorrowMut, cell::RefCell, collections::HashMap, sync::mpsc::TryRecvError};
 
+use chrono::Utc;
 use discord_sdk::activity::ActivityBuilder;
 use raylib::prelude::*;
 use tracing::{error, info, warn};
@@ -80,8 +81,11 @@ use utilities::discord::DiscordConfig;
 use crate::{
     context::GameContext,
     discord_rpc::{maybe_set_discord_presence, try_connect_to_local_discord},
+    progress::ProgressData,
     scenes::{build_screen_state_machine, Scenes},
     utilities::{
+        audio_player::AudioPlayer,
+        datastore::{load_music_from_internal_data, load_sound_from_internal_data},
         game_config::FinalShaderConfig,
         shaders::{
             shader::ShaderWrapper,
@@ -107,6 +111,7 @@ mod scenes;
 mod utilities;
 pub use utilities::{datastore::StaticGameData, game_config::GameConfig};
 mod character;
+mod progress;
 
 /// The game entrypoint
 pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std::error::Error>> {
@@ -147,6 +152,9 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
     // Build an MPSC for signaling the control thread
     let (send_control_signal, recv_control_signal) = std::sync::mpsc::channel();
 
+    // Load the savefile
+    let mut save_file = ProgressData::load_from_file();
+
     let mut context;
     let raylib_thread;
     {
@@ -166,16 +174,42 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
         rl.set_target_fps(60);
         raylib_thread = thread;
 
+        // Init the audio subsystem
+        let mut audio_system = AudioPlayer::new(RaylibAudio::init_audio_device());
+        audio_system.set_master_volume(0.4);
+
+        // Load any other sounds
+        let mut sounds = HashMap::new();
+        sounds.insert(
+            "button-press".to_string(),
+            load_sound_from_internal_data("audio/button-press.mp3").unwrap(),
+        );
+
         // Build the game context
         context = Box::new(GameContext {
             renderer: RefCell::new(rl.into()),
             config: game_config.clone(),
+            audio: audio_system,
+            sounds,
             current_level: 0,
+            player_progress: save_file,
+            level_start_time: Utc::now(),
             discord_rpc_send: send_discord_rpc,
             flag_send: send_control_signal,
         });
     }
 
+    // Load the game's main song
+    let mut main_song = load_music_from_internal_data(
+        &mut context.renderer.borrow_mut(),
+        &raylib_thread,
+        "audio/soundtrack.mp3",
+    )
+    .unwrap();
+
+    // Start the song
+    context.audio.play_music_stream(&mut main_song);
+
     // Get the main state machine
     info!("Setting up the scene management state machine");
     let mut game_state_machine =
@@ -215,6 +249,12 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
         puffin::profile_scope!("main_loop");
         puffin::GlobalProfiler::lock().new_frame();
 
+        // Update the audio
+        context.audio.update_music_stream(&mut main_song);
+        if !context.audio.is_music_playing(&main_song) {
+            context.audio.play_music_stream(&mut main_song);
+        }
+
         // Update the GPU texture that we draw to. This handles screen resizing and some other stuff
         dynamic_texture
             .update(&mut context.renderer.borrow_mut(), &raylib_thread)
@@ -318,6 +358,25 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
                         context::ControlFlag::Quit => break,
                         context::ControlFlag::SwitchLevel(level) => {
                             context.as_mut().current_level = level;
+                            context.as_mut().player_progress.save();
+                        }
+                        context::ControlFlag::UpdateLevelStart(time) => {
+                            context.as_mut().level_start_time = time;
+                            context.as_mut().player_progress.save();
+                        }
+                        context::ControlFlag::SaveProgress => {
+                            context.as_mut().player_progress.save();
+                        }
+                        context::ControlFlag::MaybeUpdateHighScore(level, time) => {
+                            context
+                                .as_mut()
+                                .player_progress
+                                .maybe_write_new_time(level, &time);
+                        }
+                        context::ControlFlag::SoundTrigger(name) => {
+                            context.audio.play_sound(
+                                context.sounds.get(&name).unwrap(),
+                            );
                         }
                     }
                 }
@@ -328,5 +387,6 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
             }
         }
     }
+    context.as_mut().player_progress.save();
     Ok(())
 }

game/src/progress.rs

@@ -0,0 +1,44 @@
+use std::collections::HashMap;
+
+use chrono::Duration;
+use tracing::info;
+
+#[derive(Debug, Deserialize, Serialize, Default)]
+pub struct ProgressData {
+    pub level_best_times: HashMap<usize, i64>,
+}
+
+impl ProgressData {
+    pub fn get_level_best_time(&self, level: usize) -> Option<Duration> {
+        let level_best_time = self.level_best_times.get(&level);
+        match level_best_time {
+            Some(time) => Some(Duration::seconds(*time)),
+            None => None,
+        }
+    }
+
+    pub fn maybe_write_new_time(&mut self, level: usize, time: &Duration) {
+        let time_in_seconds = time.num_seconds();
+        if let Some(best_time) = self.get_level_best_time(level) {
+            if best_time.num_seconds() > time_in_seconds {
+                self.level_best_times.insert(level, time_in_seconds);
+            }
+        } else {
+            self.level_best_times.insert(level, time_in_seconds);
+        }
+    }
+
+    pub fn load_from_file() -> Self {
+        info!("Loading progress data from file");
+        serde_json::from_str(
+            &std::fs::read_to_string("./savegame.json")
+                .unwrap_or("{\"level_best_times\":{}}".to_string()),
+        )
+        .unwrap_or(Self::default())
+    }
+
+    pub fn save(&self) {
+        info!("Saving progress data to file");
+        std::fs::write("./savegame.json", serde_json::to_string(self).unwrap()).unwrap()
+    }
+}

game/src/scenes/death_screen.rs

@@ -6,7 +6,7 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{GameConfig, context::GameContext, utilities::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
@@ -15,18 +15,20 @@ use crate::{GameConfig, context::GameContext, utilities::{
     }};
 
 use super::{Scenes, ScreenError};
-use tracing::{debug, info, error, trace};
+use tracing::{debug, error, info, trace};
 
 #[derive(Debug)]
 pub struct DeathScreen {
-    is_retry_pressed: bool
+    is_retry_pressed: bool,
+    timer_value: String,
 }
 
 impl DeathScreen {
     /// Construct a new `DeathScreen`
     pub fn new() -> Self {
         Self {
-            is_retry_pressed: false
+            is_retry_pressed: false,
+            timer_value: "XX:XX".to_string(),
         }
     }
 }
@@ -41,11 +43,9 @@ impl Action<Scenes, ScreenError, GameContext> for DeathScreen {
         debug!("Running DeathScreen for the first time");
 
         if let Err(e) = context.discord_rpc_send.send(Some(
-            ActivityBuilder::default()
+            ActivityBuilder::default().details("dead... again").assets(
-                .details("dead... again")
+                Assets::default().large("game-logo-small", Some(context.config.name.clone())),
-                .assets(
+            ),
-                    Assets::default().large("game-logo-small", Some(context.config.name.clone())),
-                )
         )) {
             error!("Failed to update discord: {}", e);
         }
@@ -61,11 +61,16 @@ impl Action<Scenes, ScreenError, GameContext> for DeathScreen {
         trace!("execute() called on DeathScreen");
         self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
 
+        let elapsed = Utc::now() - context.level_start_time;
+        self.timer_value = format!("{:02}:{:02}", elapsed.num_minutes(), elapsed.num_seconds() % 60);
 
         if self.is_retry_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::InGameScene))
-        }
+        } else {
-        else{
             Ok(ActionFlag::Continue)
         }
     }
@@ -81,9 +86,8 @@ impl ScreenSpaceRender for DeathScreen {
     fn render_screen_space(
         &mut self,
         raylib: &mut crate::utilities::non_ref_raylib::HackedRaylibHandle,
-        config: &GameConfig
+        config: &GameConfig,
     ) {
-
         // Render the background
         raylib.clear_background(Color::DARKBLUE);
 
@@ -95,8 +99,8 @@ impl ScreenSpaceRender for DeathScreen {
         let mouse_pressed: bool = raylib.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON);
 
         raylib.draw_text(
-
+            &format!(
-            "ERR: Corrupted Player Data Detected
+                "ERR: Corrupted Player Data Detected
 
 The program has detected lowering player integrity,
 and has halted as a safety precaution.
@@ -104,13 +108,18 @@ and has halted as a safety precaution.
 If this is the first time you've seen this error screen,
 restart the level. If problems continue, simply get good.
 
+The timer has not been reset. You are wasting time
+reading this message. GLHF ;)
+
 --------   Technical information   --------
 *** CALL STACK:
 *** C  [libraylib.so+0x75c] END_DRAWING()
 *** RS [data_loss.so+0x48f] validate_player()
 *** ---------------------------------------
-*** PROGRAM_HALT (TIME: XX:XX, BEST: XX:XX)
+*** PROGRAM_HALT (TIMER: {})
 *** ---------------------------------------",
+                self.timer_value
+            ),
             25,
             20,
             20,
@@ -118,9 +127,10 @@ restart the level. If problems continue, simply get good.
         );
 
         //Retry
-        if Rectangle::new(35.0, screen_size.y as f32 - 80.0, 200.0, 40.0).check_collision_point_rec(mouse_position){
+        if Rectangle::new(35.0, screen_size.y as f32 - 80.0, 200.0, 40.0)
+            .check_collision_point_rec(mouse_position)
+        {
             raylib.draw_text(
-
                 ">>CLICK HERE TO RETRY",
                 20,
                 screen_size.y as i32 - 40,
@@ -129,10 +139,8 @@ restart the level. If problems continue, simply get good.
             );
 
             self.is_retry_pressed = mouse_pressed
-        }
+        } else {
-        else {
             raylib.draw_text(
-
                 ">>CLICK HERE TO RETRY",
                 25,
                 screen_size.y as i32 - 40,

game/src/scenes/how_to_play_screen.rs

@@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
-    context::GameContext,
-    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    },
+    }};
-    GameConfig,
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -66,6 +62,10 @@ impl Action<Scenes, ScreenError, GameContext> for HowToPlayScreen {
         self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
 
         if self.is_btm_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::MainMenuScreen))
         } else {
             Ok(ActionFlag::Continue)

game/src/scenes/ingame_scene/mod.rs

@@ -69,7 +69,6 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
         // Handle cleanup after death
         self.player_dead = false;
         self.player.reset();
-        self.level_switch_timestamp = Utc::now();
 
         // Set the player to running
         let cur_level = self.levels.get(context.current_level).unwrap();
@@ -105,6 +104,12 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
         if self.current_level_idx != context.current_level {
             self.current_level_idx = context.current_level;
             self.level_switch_timestamp = Utc::now();
+            context
+                .flag_send
+                .send(Some(ControlFlag::UpdateLevelStart(
+                    self.level_switch_timestamp,
+                )))
+                .unwrap();
         }
 
         // Grab exclusive access to the renderer
@@ -128,9 +133,26 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
         // Render the HUD
         self.render_screen_space(&mut renderer, &context.config);
 
+
         // Check if the player won
         let cur_level = self.levels.get(context.current_level).unwrap();
         if self.player.position.x > cur_level.zones.win.x {
+            // Save the current time
+            let elapsed = Utc::now() - self.level_switch_timestamp;
+            context
+                .flag_send
+                .send(Some(ControlFlag::MaybeUpdateHighScore(
+                    self.current_level_idx,
+                    elapsed,
+                )))
+                .unwrap();
+
+            // Save the progress
+            context
+                .flag_send
+                .send(Some(ControlFlag::SaveProgress))
+                .unwrap();
+
             // If this is the last level, win the game
             if self.current_level_idx >= self.levels.len() - 1 {
                 return Ok(ActionFlag::SwitchState(Scenes::WinScreen));
@@ -140,6 +162,7 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
                     .flag_send
                     .send(Some(ControlFlag::SwitchLevel(self.current_level_idx + 1)))
                     .unwrap();
+
                 return Ok(ActionFlag::SwitchState(Scenes::NextLevelScreen));
             }
         }

game/src/scenes/main_menu_screen.rs

@@ -1,18 +1,22 @@
-use std::ops::{Div, Sub};
+use std::{collections::hash_map::Iter, iter::Enumerate, ops::{Div, Sub}};
 
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, Duration, Utc};
 use dirty_fsm::{Action, ActionFlag};
 use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
+use crate::{
+    context::{ControlFlag, GameContext},
+    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    }};
+    },
+    GameConfig,
+};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -23,6 +27,7 @@ pub struct MainMenuScreen {
     is_htp_pressed: bool,     //Is how to play button pressed
     is_options_pressed: bool, //Is options button pressed
     is_quit_pressed: bool,    //Is quit button pressed
+    level_times: Option<Vec<(usize, (usize, i64))>>
 }
 
 impl MainMenuScreen {
@@ -33,6 +38,7 @@ impl MainMenuScreen {
             is_htp_pressed: false,
             is_options_pressed: false,
             is_quit_pressed: false,
+            level_times: None
         }
     }
 }
@@ -66,13 +72,32 @@ impl Action<Scenes, ScreenError, GameContext> for MainMenuScreen {
         trace!("execute() called on MainMenuScreen");
         self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
 
+
+        self.level_times = Some(context.player_progress.level_best_times.iter().map(|x| (*x.0, *x.1)).collect::<Vec<(_,_)>>().iter().map(|x| *x).enumerate().collect());
+
         if self.is_start_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::InGameScene))
         } else if self.is_htp_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::HowToPlayScreen))
         } else if self.is_options_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::OptionsScreen))
         } else if self.is_quit_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             context.flag_send.send(Some(ControlFlag::Quit)).unwrap();
             Ok(ActionFlag::Continue)
         } else {
@@ -108,6 +133,8 @@ impl ScreenSpaceRender for MainMenuScreen {
             config.colors.white,
         );
 
+
+
         // Calculate the logo position
         let screen_size = raylib.get_screen_size();
 
@@ -170,7 +197,7 @@ impl ScreenSpaceRender for MainMenuScreen {
             Color::WHITE,
         );
 
-        if hovering_start_game{
+        if hovering_start_game {
             raylib.draw_rgb_split_text(
                 Vector2::new(50.0, 300.0),
                 ">>",
@@ -192,7 +219,7 @@ impl ScreenSpaceRender for MainMenuScreen {
             hovering_htp,
             Color::WHITE,
         );
-        if hovering_htp{
+        if hovering_htp {
             raylib.draw_rgb_split_text(
                 Vector2::new(50.0, 350.0),
                 ">>",
@@ -213,7 +240,7 @@ impl ScreenSpaceRender for MainMenuScreen {
             hovering_options,
             Color::WHITE,
         );
-        if hovering_options{
+        if hovering_options {
             raylib.draw_rgb_split_text(
                 Vector2::new(50.0, 400.0),
                 ">>",
@@ -224,25 +251,66 @@ impl ScreenSpaceRender for MainMenuScreen {
         };
         self.is_options_pressed = mouse_pressed && hovering_options;
 
-        // QUIT
+        // CREDITS
-        let hovering_quit =
+        let hovering_credits =
-            Rectangle::new(80.0, 445.0, 65.0, 20.0).check_collision_point_rec(mouse_position);
+            Rectangle::new(80.0, 445.0, 135.0, 20.0).check_collision_point_rec(mouse_position);
         raylib.draw_rgb_split_text(
             Vector2::new(80.0, 450.0),
+            "CREDITS",
+            25,
+            hovering_credits,
+            Color::WHITE,
+        );
+        if hovering_credits {
+            raylib.draw_rgb_split_text(Vector2::new(50.0, 450.0), ">>", 25, true, Color::WHITE);
+        };
+        if hovering_credits && mouse_pressed {
+            let _ = webbrowser::open("https://github.com/Ewpratten/ludum-dare-49#the-team");
+        }
+
+        // QUIT
+        let hovering_quit =
+            Rectangle::new(80.0, 495.0, 65.0, 20.0).check_collision_point_rec(mouse_position);
+        raylib.draw_rgb_split_text(
+            Vector2::new(80.0, 500.0),
             "QUIT",
             25,
             hovering_quit,
             Color::WHITE,
         );
-        if hovering_quit{
+        if hovering_quit {
             raylib.draw_rgb_split_text(
-                Vector2::new(50.0, 450.0),
+                Vector2::new(50.0, 500.0),
                 ">>",
                 25,
                 hovering_quit,
                 Color::WHITE,
             );
         };
+
+        // Best Times
+        raylib.draw_text(
+            "BEST TIMES",
+            screen_size.x as i32 - 200,
+            40,
+            25,
+            Color::DARKGRAY,
+        );
+
+        if let Some(times) = &self.level_times{
+            for (i, (level, time)) in times.iter() {
+                let time = Duration::seconds(*time);
+                raylib.draw_text(
+                    &format!("Lvl {}         {}:{}", level + 1, time.num_minutes(), time.num_seconds() % 60),
+                    screen_size.x as i32 - 200,
+                    100 + (25 * (*i as i32)),
+                    20,
+                    Color::DARKGRAY,
+                );
+            }
+        }
         self.is_quit_pressed = mouse_pressed && hovering_quit;
+
+        // for
     }
 }

game/src/scenes/mod.rs

@@ -6,13 +6,7 @@ use self::{
     death_screen::DeathScreen, win_screen::WinScreen,
     next_level_screen::NextLevelScreen
 };
-use crate::{
+use crate::{context::GameContext, utilities::{datastore::{ResourceLoadError, load_music_from_internal_data, load_sound_from_internal_data, load_texture_from_internal_data}, non_ref_raylib::HackedRaylibHandle}};
-    context::GameContext,
-    utilities::{
-        datastore::{load_texture_from_internal_data, ResourceLoadError},
-        non_ref_raylib::HackedRaylibHandle,
-    },
-};
 use dirty_fsm::StateMachine;
 use raylib::{texture::Texture2D, RaylibThread};
 

game/src/scenes/next_level_screen.rs

@@ -1,22 +1,18 @@
 use std::ops::{Div, Sub};
 
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, Duration, Utc};
 use dirty_fsm::{Action, ActionFlag};
 use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
-    context::GameContext,
-    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    },
+    }};
-    GameConfig,
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -24,6 +20,9 @@ use tracing::{debug, error, info, trace};
 #[derive(Debug)]
 pub struct NextLevelScreen {
     is_next_pressed: bool,
+    screen_load_time: DateTime<Utc>,
+    attempt_time: String,
+    best_time: String,
 }
 
 impl NextLevelScreen {
@@ -31,6 +30,9 @@ impl NextLevelScreen {
     pub fn new() -> Self {
         Self {
             is_next_pressed: false,
+            screen_load_time: Utc::now(),
+            attempt_time: String::new(),
+            best_time: String::new(),
         }
     }
 }
@@ -43,6 +45,7 @@ impl Action<Scenes, ScreenError, GameContext> for NextLevelScreen {
 
     fn on_first_run(&mut self, context: &GameContext) -> Result<(), ScreenError> {
         debug!("Running NextLevelScreen for the first time");
+        self.screen_load_time = Utc::now();
 
         if let Err(e) = context.discord_rpc_send.send(Some(
             ActivityBuilder::default().details("accepting fate").assets(
@@ -63,7 +66,27 @@ impl Action<Scenes, ScreenError, GameContext> for NextLevelScreen {
         trace!("execute() called on NextLevelScreen");
         self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
 
+        let attempt_elapsed = self.screen_load_time - context.level_start_time;
+        self.attempt_time = format!(
+            "{:02}:{:02}",
+            attempt_elapsed.num_minutes(),
+            attempt_elapsed.num_seconds() % 60
+        );
+        let best_time = context
+            .player_progress
+            .get_level_best_time(context.current_level)
+            .unwrap_or(attempt_elapsed);
+        self.best_time = format!(
+            "{:02}:{:02}",
+            best_time.num_minutes(),
+            best_time.num_seconds() % 60
+        );
+
         if self.is_next_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::InGameScene))
         } else {
             Ok(ActionFlag::Continue)
@@ -114,7 +137,14 @@ impl ScreenSpaceRender for NextLevelScreen {
         //Time
         raylib.draw_rgb_split_text(
             Vector2::new(80.0, screen_size.y / 2.0 - 40.0),
-            "YOUR TIME: ",
+            &format!("YOUR TIME: {}", self.attempt_time),
+            20,
+            false,
+            Color::WHITE,
+        );
+        raylib.draw_rgb_split_text(
+            Vector2::new(80.0, screen_size.y / 2.0 - 20.0),
+            &format!("BEST TIME: {}", self.best_time),
             20,
             false,
             Color::WHITE,

game/src/scenes/options_screen.rs

@@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
-    context::GameContext,
-    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    },
+    }};
-    GameConfig,
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -69,6 +65,10 @@ impl Action<Scenes, ScreenError, GameContext> for OptionsScreen {
         self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
 
         if self.is_btm_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             Ok(ActionFlag::SwitchState(Scenes::MainMenuScreen))
         } else {
             Ok(ActionFlag::Continue)

game/src/scenes/pause_screen.rs

@@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
-    context::GameContext,
-    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    },
+    }};
-    GameConfig,
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -82,6 +78,10 @@ impl Action<Scenes, ScreenError, GameContext> for PauseScreen {
             && Rectangle::new(centered_x_paused, centered_y_paused, 435.0, 80.0)
                 .check_collision_point_rec(mouse_position)
         {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             return Ok(ActionFlag::SwitchState(Scenes::InGameScene));
         }
         //For Menu
@@ -89,6 +89,10 @@ impl Action<Scenes, ScreenError, GameContext> for PauseScreen {
             && Rectangle::new(centered_x_menu, centered_y_menu, 200.0, 50.0)
                 .check_collision_point_rec(mouse_position)
         {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
             return Ok(ActionFlag::SwitchState(Scenes::MainMenuScreen));
         }
 

game/src/scenes/win_screen.rs

@@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
 use pkg_version::pkg_version_major;
 use raylib::prelude::*;
 
-use crate::{
+use crate::{GameConfig, context::{ControlFlag, GameContext}, utilities::{
-    context::GameContext,
-    utilities::{
         datastore::{load_texture_from_internal_data, ResourceLoadError},
         game_version::get_version_string,
         math::interpolate_exp,
         non_ref_raylib::HackedRaylibHandle,
         render_layer::ScreenSpaceRender,
-    },
+    }};
-    GameConfig,
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, error, info, trace};
@@ -69,6 +65,11 @@ impl Action<Scenes, ScreenError, GameContext> for WinScreen {
         self.counter += 1;
 
         if self.is_menu_pressed {
+            context
+                .flag_send
+                .send(Some(ControlFlag::SoundTrigger("button-press".to_string())))
+                .unwrap();
+            context.flag_send.send(Some(ControlFlag::SwitchLevel(0))).unwrap();
             Ok(ActionFlag::SwitchState(Scenes::MainMenuScreen))
         } else {
             Ok(ActionFlag::Continue)
@@ -79,6 +80,7 @@ impl Action<Scenes, ScreenError, GameContext> for WinScreen {
         debug!("Finished WinScreen");
         self.is_menu_pressed = false;
         self.counter = 0;
+
         Ok(())
     }
 }

game/src/utilities/audio_player.rs

@@ -0,0 +1,49 @@
+use raylib::audio::RaylibAudio;
+
+/// A thin wrapper around `raylib::core::audio::RaylibAudio` that keeps track of the volume of its audio channels.
+#[derive(Debug)]
+pub struct AudioPlayer {
+    backend: RaylibAudio,
+
+    // Volume
+    pub master_volume: f32,
+}
+
+impl AudioPlayer {
+    /// Construct an AudioPlayer around a RaylibAudio
+    pub fn new(backend: RaylibAudio) -> Self {
+        Self {
+            backend,
+            master_volume: 1.0,
+        }
+    }
+
+    /// Set the master volume for all tracks. `0.0` to `1.0`
+    pub fn set_master_volume(&mut self, volume: f32) {
+        // The volume must be 0-1
+        let volume = volume.clamp(0.0, 1.0);
+
+        // Set the volume
+        self.master_volume = volume;
+        self.backend.set_master_volume(volume);
+    }
+
+    /// Get the master volume
+    pub fn get_master_volume(&self) -> f32 {
+        self.master_volume
+    }
+}
+
+impl std::ops::Deref for AudioPlayer {
+    type Target = RaylibAudio;
+    fn deref(&self) -> &Self::Target {
+        &self.backend
+    }
+}
+
+
+impl std::ops::DerefMut for AudioPlayer {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.backend
+    }
+}

game/src/utilities/datastore.rs

@@ -1,6 +1,10 @@
 use std::{io::Write, path::Path};
 
-use raylib::{texture::Texture2D, RaylibHandle, RaylibThread};
+use raylib::{
+    audio::{Music, Sound},
+    texture::Texture2D,
+    RaylibHandle, RaylibThread,
+};
 use tempfile::{tempdir, NamedTempFile};
 use tracing::debug;
 
@@ -67,3 +71,71 @@ pub fn load_texture_from_internal_data(
 
     Ok(texture)
 }
+
+pub fn load_music_from_internal_data(
+    raylib_handle: &mut RaylibHandle,
+    thread: &RaylibThread,
+    path: &str,
+) -> Result<Music, ResourceLoadError> {
+    // Create a temp file path to work with
+    let temp_dir = tempdir()?;
+    debug!(
+        "Created temporary directory for passing embedded data to Raylib: {}",
+        temp_dir.path().display()
+    );
+    let tmp_path = temp_dir.path().join(Path::new(path).file_name().unwrap());
+
+    // Unpack the raw sound data to a real file on the local filesystem so raylib will read it correctly
+    std::fs::write(
+        &tmp_path,
+        &StaticGameData::get(path)
+            .ok_or(ResourceLoadError::AssetNotFound(path.to_string()))?
+            .data,
+    )?;
+
+    // Call through via FFI to re-load the file
+    let texture = Music::load_music_stream(thread, tmp_path.to_str().unwrap())
+        .map_err(ResourceLoadError::Generic)?;
+
+    // Close the file
+    debug!(
+        "Dropping temporary directory: {}",
+        temp_dir.path().display()
+    );
+    // temp_dir.close()?;
+
+    Ok(texture)
+}
+
+pub fn load_sound_from_internal_data(
+    path: &str,
+) -> Result<Sound, ResourceLoadError> {
+    // Create a temp file path to work with
+    let temp_dir = tempdir()?;
+    debug!(
+        "Created temporary directory for passing embedded data to Raylib: {}",
+        temp_dir.path().display()
+    );
+    let tmp_path = temp_dir.path().join(Path::new(path).file_name().unwrap());
+
+    // Unpack the raw sound data to a real file on the local filesystem so raylib will read it correctly
+    std::fs::write(
+        &tmp_path,
+        &StaticGameData::get(path)
+            .ok_or(ResourceLoadError::AssetNotFound(path.to_string()))?
+            .data,
+    )?;
+
+    // Call through via FFI to re-load the file
+    let texture =
+        Sound::load_sound(tmp_path.to_str().unwrap()).map_err(ResourceLoadError::Generic)?;
+
+    // Close the file
+    debug!(
+        "Dropping temporary directory: {}",
+        temp_dir.path().display()
+    );
+    temp_dir.close()?;
+
+    Ok(texture)
+}

game/src/utilities/mod.rs

@@ -8,3 +8,4 @@ pub mod non_ref_raylib;
 pub mod render_layer;
 pub mod shaders;
 pub mod world_paint_texture;
+pub mod audio_player;