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

working on redoing the loading sequence

Browse Source
This commit is contained in:
Evan Pratten 2021-10-02 19:15:07 -04:00
parent 8c0cdc959c
commit 74170f8876
3 changed files with 1 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
game/src/lib.rs
View File

@ -176,7 +176,7 @@ pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std:
let mut game_state_machine =
build_screen_state_machine(&mut context.renderer.borrow_mut(), &raylib_thread).unwrap();
game_state_machine
.force_change_state(Scenes::LoadingScreen)
.force_change_state(Scenes::MainMenuScreen)
.unwrap();
// Create a dynamic texture to draw to for processing by shaders

164
game/src/scenes/loading_screen.rs
View File

@ -1,164 +0,0 @@
use std::ops::{Div, Sub};
use cfg_if::cfg_if;
use chrono::{DateTime, Utc};
use dirty_fsm::{Action, ActionFlag};
use discord_sdk::activity::{ActivityBuilder, Assets};
use raylib::prelude::*;
use crate::{GameConfig, context::GameContext, utilities::{
datastore::{load_texture_from_internal_data, ResourceLoadError},
math::interpolate_exp,
non_ref_raylib::HackedRaylibHandle,
render_layer::ScreenSpaceRender,
}};
use super::{Scenes, ScreenError};
use tracing::{debug, info, error, trace};
/// Defines how long the loading screen should be displayed.
const LOADING_SCREEN_DURATION_SECONDS: u8 = 3;
#[derive(Debug)]
pub struct LoadingScreen {
start_timestamp: Option<DateTime<Utc>>,
game_logo_texture: Texture2D,
game_logo_size: Vector2,
}
impl LoadingScreen {
/// Construct a new `LoadingScreen`
pub fn new(
raylib_handle: &mut HackedRaylibHandle,
thread: &RaylibThread,
) -> Result<Self, ResourceLoadError> {
// Load the game logo asset
let game_logo =
load_texture_from_internal_data(raylib_handle, thread, "logos/game-logo.png")?;
Ok(Self {
start_timestamp: None,
game_logo_size: Vector2::new(game_logo.width as f32, game_logo.height as f32),
game_logo_texture: game_logo,
})
}
}
impl Action<Scenes, ScreenError, GameContext> for LoadingScreen {
fn on_register(&mut self) -> Result<(), ScreenError> {
debug!("Registered");
Ok(())
}
fn on_first_run(&mut self, context: &GameContext) -> Result<(), ScreenError> {
debug!("Running LoadingScreen for the first time");
// Update discord
if let Err(e) = context.discord_rpc_send.send(Some(
ActivityBuilder::default().details("loading...").assets(
Assets::default().large("game-logo-small", Some(context.config.name.clone())),
),
)) {
error!("Failed to update discord: {}", e);
}
// Keep track of when this screen is opened
self.start_timestamp = Some(Utc::now());
Ok(())
}
fn execute(
&mut self,
_delta: &chrono::Duration,
context: &GameContext,
) -> Result<dirty_fsm::ActionFlag<Scenes>, ScreenError> {
trace!("execute() called on LoadingScreen");
self.render_screen_space(&mut context.renderer.borrow_mut(), &context.config);
// Check for a quick skip button in debug builds
cfg_if! {
if #[cfg(debug_assertions)] {
let debug_skip_screen = context.renderer.borrow_mut().is_key_pressed(KeyboardKey::KEY_ESCAPE);
} else {
let debug_skip_screen = false;
}
}
// Keep rendering until we pass the loading screen duration
if let Some(start_timestamp) = self.start_timestamp {
let duration = Utc::now().signed_duration_since(start_timestamp);
if duration.num_seconds() >= LOADING_SCREEN_DURATION_SECONDS as i64 || debug_skip_screen
{
info!("LoadingScreen duration reached, moving to next screen");
Ok(ActionFlag::SwitchState(Scenes::MainMenuScreen))
} else {
Ok(ActionFlag::Continue)
}
} else {
Ok(ActionFlag::Continue)
}
}
fn on_finish(&mut self, _interrupted: bool) -> Result<(), ScreenError> {
debug!("Finished LoadingScreen");
// Reset the start timestamp
self.start_timestamp = None;
Ok(())
}
}
impl ScreenSpaceRender for LoadingScreen {
fn render_screen_space(
&mut self,
raylib: &mut crate::utilities::non_ref_raylib::HackedRaylibHandle,
config: &GameConfig
) {
// Calculate the loading screen fade in/out value
// This makes the loading screen fade in/out over the duration of the loading screen
let cur_time = Utc::now();
let time_since_start =
cur_time.signed_duration_since(self.start_timestamp.unwrap_or(cur_time));
let fade_percentage = interpolate_exp(
time_since_start.num_milliseconds() as f32,
0.0..(LOADING_SCREEN_DURATION_SECONDS as f32 * 1000.0),
0.0..1.0,
8.0,
);
trace!("Loading screen fade at {:.2}%", fade_percentage);
// Render the background
raylib.clear_background(Color::BLACK);
// Calculate the logo position
let screen_size = raylib.get_screen_size();
// Render the game logo
raylib.draw_texture_ex(
&self.game_logo_texture,
screen_size.div(2.0).sub(self.game_logo_size.div(2.0)),
0.0,
1.0,
Color::WHITE.fade(fade_percentage),
);
// Only in debug mode, render a debug message
#[cfg(debug_assertions)]
{
raylib.draw_rectangle_v(
Vector2::zero(),
Vector2::new(screen_size.x, 40.0),
Color::RED,
);
raylib.draw_text(
"Game in DEBUG MODE. Do not redistribute!",
10,
10,
20,
Color::WHITE,
);
}
}
}

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

@ -2,7 +2,6 @@ use self::{
pause_screen::PauseScreen,
fsm_error_screen::FsmErrorScreen,
ingame_scene::{level::loader::load_all_levels, InGameScreen},
loading_screen::LoadingScreen,
main_menu_screen::MainMenuScreen, options_screen::OptionsScreen, how_to_play_screen::HowToPlayScreen,
};
use crate::{
@ -17,7 +16,6 @@ use raylib::{texture::Texture2D, RaylibThread};
pub mod fsm_error_screen;
pub mod ingame_scene;
pub mod loading_screen;
pub mod main_menu_screen;
pub mod how_to_play_screen;
pub mod options_screen;
@ -28,7 +26,6 @@ pub mod pause_screen;
pub enum Scenes {
#[default]
FsmErrorScreen,
LoadingScreen,
MainMenuScreen,
InGameScene,
HowToPlayScreen,
@ -62,10 +59,6 @@ pub fn build_screen_state_machine(
// Set up the state machine
let mut machine = StateMachine::new();
machine.add_action(Scenes::FsmErrorScreen, FsmErrorScreen::new())?;
machine.add_action(
Scenes::LoadingScreen,
LoadingScreen::new(raylib_handle, thread)?,
)?;
machine.add_action(Scenes::MainMenuScreen, MainMenuScreen::new())?;
machine.add_action(Scenes::HowToPlayScreen, HowToPlayScreen::new())?;
machine.add_action(Scenes::OptionsScreen, OptionsScreen::new())?;