1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! The render code for various scenes
//!
//! ## Overview
//!
//! This will probably become a messy module over time. Stick your rendering code here
use raylib::prelude::*;

use crate::{
    discord::DiscordChannel,
    global_resource_package::GlobalResources,
    persistent::{save_state::GameSaveState, settings::PersistentGameSettings},
    project_constants::ProjectConstants,
};

use self::{
    main_menu::{MainMenu, MenuStateSignal},
    pause_menu::PauseMenu,
    player_interaction::PlayableScene,
    test_fox::TestFoxScene,
};
mod main_menu;
mod pause_menu;
mod player_interaction;
mod test_fox;

/// Delegate for handling rendering.
/// This is a struct to allow for stateful data (like sub-screens) to be set up
pub struct SceneRenderDelegate {
    menu_control_signal: MenuStateSignal,
    pub needs_exit: bool,
    audio_subsystem: RaylibAudio,
    /* Scenes */
    scene_test_fox: TestFoxScene,
    scene_playable: PlayableScene,
    scene_main_menu: MainMenu,
    scene_pause_menu: PauseMenu,
}

impl SceneRenderDelegate {
    /// This is called when the game first loads
    pub fn on_game_start(
        raylib: &mut RaylibHandle,
        rl_thread: &RaylibThread,
        constants: &ProjectConstants,
        audio_subsystem: RaylibAudio,
        game_settings: &mut PersistentGameSettings,
        save_state: &mut GameSaveState,
    ) -> Self {
        // Init some scenes
        let scene_test_fox = TestFoxScene::new(raylib, rl_thread);
        let scene_playable = PlayableScene::new(raylib, rl_thread, constants);
        let scene_main_menu = MainMenu::new(raylib, rl_thread, constants, game_settings);
        let scene_pause_menu = PauseMenu::new(raylib, rl_thread, constants, game_settings);

        Self {
            menu_control_signal: MenuStateSignal::DoMainMenu,
            needs_exit: false,
            audio_subsystem,
            scene_test_fox,
            scene_playable,
            scene_main_menu,
            scene_pause_menu,
        }
    }

    /// This is called every frame once the game has started.
    ///
    /// Keep in mind everything you do here will block the main thread (no loading files plz)
    pub async fn process_ingame_frame(
        &mut self,
        raylib: &mut RaylibHandle,
        rl_thread: &RaylibThread,
        discord: &DiscordChannel,
        global_resources: &GlobalResources,
        constants: &ProjectConstants,
        game_settings: &mut PersistentGameSettings,
        save_state: &mut GameSaveState,
    ) {
        // Render the main menu if in it, otherwise, render the game
        match self.menu_control_signal {
            MenuStateSignal::StartGame => {
                self.menu_control_signal = self.scene_playable
                    .render_frame(
                        raylib,
                        rl_thread,
                        &discord,
                        global_resources,
                        constants,
                        &mut self.audio_subsystem,
                    )
                    .await;
                self.scene_playable.update_physics(raylib, constants).await;

                // Clear the menu system discord status
                self.scene_main_menu.has_updated_discord_rpc = false;
            }
            MenuStateSignal::QuitGame => {
                self.needs_exit = true;
            }
            MenuStateSignal::DoMainMenu => {
                self.menu_control_signal = self
                    .scene_main_menu
                    .render_main_menu_frame(
                        raylib,
                        rl_thread,
                        discord,
                        global_resources,
                        constants,
                        &mut self.audio_subsystem,
                        game_settings,
                    )
                    .await;

                // Clear the ingame discord status
                self.scene_playable.has_updated_discord_rpc = false;
            }
            MenuStateSignal::DoOptions => {
                self.menu_control_signal = self
                    .scene_main_menu
                    .render_options_frame(raylib, rl_thread, discord, global_resources, constants)
                    .await
            }
            MenuStateSignal::DoCredits => {
                self.menu_control_signal = self
                    .scene_main_menu
                    .render_credits_frame(
                        raylib,
                        rl_thread,
                        discord,
                        global_resources,
                        constants,
                        &mut self.audio_subsystem,
                    )
                    .await
            }
            MenuStateSignal::DoLeaderboard => {
                self.menu_control_signal = self
                    .scene_main_menu
                    .render_leaderboard_frame(
                        raylib,
                        rl_thread,
                        discord,
                        global_resources,
                        constants,
                        &mut self.audio_subsystem,
                    )
                    .await
            }
            MenuStateSignal::DoPauseMenu => {
                self.menu_control_signal = self
                    .scene_pause_menu
                    .render_pause_menu_frame(
                        raylib,
                        rl_thread,
                        discord,
                        global_resources,
                        constants,
                        &mut self.audio_subsystem,
                    )
                    .await;
            }
        }
    }
}

impl Drop for SceneRenderDelegate {
    /// If you need anything to happen when the game closes, stick it here.
    fn drop(&mut self) {}
}