evan/ludum-dare-49
Archived
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into levels_update_img

Browse Source
This commit is contained in:
Evan Pratten 2021-10-03 14:42:54 -04:00
commit 41eda20b38
20 changed files with 449 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

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

7
README.md
View File

@ -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
- **Kori**
- Tilesets
- [**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.

4
game/Cargo.toml
View File

@ -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"

BIN
game/assets/audio/button-press.mp3 Normal file
View File

Binary file not shown.

BIN
game/assets/audio/soundtrack.mp3 Normal file
View File

Binary file not shown.

14
game/src/context.rs
View File

@ -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>>,
}

62
game/src/lib.rs
View File

@ -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(())
}

44
game/src/progress.rs Normal file
View File

@ -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()
}
}

50
game/src/scenes/death_screen.rs
View File

@ -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()
.details("dead... again")
.assets(
Assets::default().large("game-logo-small", Some(context.config.name.clone())),
)
ActivityBuilder::default().details("dead... again").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(
"ERR: Corrupted Player Data Detected
&format!(
"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,

12
game/src/scenes/how_to_play_screen.rs
View File

@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
use pkg_version::pkg_version_major;
use raylib::prelude::*;
use crate::{
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,
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)

25
game/src/scenes/ingame_scene/mod.rs
View File

@ -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));
}
}

92
game/src/scenes/main_menu_screen.rs
View File

@ -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
let hovering_quit =
Rectangle::new(80.0, 445.0, 65.0, 20.0).check_collision_point_rec(mouse_position);
// CREDITS
let hovering_credits =
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
}
}

8
game/src/scenes/mod.rs
View File

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

46
game/src/scenes/next_level_screen.rs
View File

@ -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::{
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,
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,

12
game/src/scenes/options_screen.rs
View File

@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
use pkg_version::pkg_version_major;
use raylib::prelude::*;
use crate::{
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,
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)

16
game/src/scenes/pause_screen.rs
View File

@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
use pkg_version::pkg_version_major;
use raylib::prelude::*;
use crate::{
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,
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));
}

14
game/src/scenes/win_screen.rs
View File

@ -6,17 +6,13 @@ use discord_sdk::activity::{ActivityBuilder, Assets};
use pkg_version::pkg_version_major;
use raylib::prelude::*;
use crate::{
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,
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(())
}
}

49
game/src/utilities/audio_player.rs Normal file
View File

@ -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
}
}

74
game/src/utilities/datastore.rs
View File

@ -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)
}

1
game/src/utilities/mod.rs
View File

@ -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;