scion 0.7.0

Game making library on top of wgpu, winit, hecs
Documentation 
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

//! Everything that is linked to the running of scenes.

use crate::core::world::GameData;

/// Trait to implement in order to define a `Scene`.
pub trait Scene {
    /// Will be called once before the new game loop iteration. Useful to initialize resources and add everything you need in the world.
    fn on_start(&mut self, _data: &mut GameData) {}
    /// Will be called each game loop, before the systems execution
    fn on_update(&mut self, _data: &mut GameData) {}
    /// Will be called each game loop, after the systems execution
    fn late_update(&mut self, _data: &mut GameData) {}
    /// Will be called for deleted scene at the end of the frame where it was deleted
    fn on_stop(&mut self, _data: &mut GameData) {}
}

pub(crate) enum SceneAction {
    Update,
    Start,
    EndFrame,
    LateUpdate,
}

/// `SceneMachine` is the Resource used to control the game scene.
#[derive(Default)]
pub(crate) struct SceneMachine {
    pub(crate) current_scene: Option<Box<dyn Scene>>,
    pub(crate) current_scene_started: bool
}

impl SceneMachine {
    pub(crate) fn apply_scene_action(&mut self, action: SceneAction, data: &mut GameData) {
        if let Some(scene) = self.current_scene.as_mut() {
            match action {
                SceneAction::Update => {
                    if !self.current_scene_started{
                        scene.on_start(data);
                        self.current_scene_started = true;
                    }
                    scene.on_update(data);
                },
                SceneAction::Start => {
                    scene.on_start(data);
                    self.current_scene_started = true;
                },
                SceneAction::EndFrame => {}
                SceneAction::LateUpdate => scene.late_update(data),
            };
        }

        match action {
            SceneAction::EndFrame => {
                let action = data.scene_controller().action();
                match action {
                    Some(SceneTrans::Switch(new_scene)) => {
                        if let Some(mut scene) = self.current_scene.take() {
                            scene.on_stop(data);
                        }
                        self.current_scene = Some(new_scene);
                        self.current_scene_started = false;
                    }
                    _ => {}
                }
            }
            _ => {}
        }
    }
}

pub(crate) enum SceneTrans {
    Switch(Box<dyn Scene>)
}

/// `SceneController` is the Resource used to control the game scenes.
#[derive(Default)]
pub struct SceneController {
    /// scene action that has to be executed at the end of the frame
    pub(crate) action: Option<SceneTrans>,
}

impl SceneController {
    /// Replace the current scene with the name `` with the scene created from type `T`. (Useful for level switching).
    /// Note that the scene's stop will happen at the end of the frame.
    pub fn switch<T: Scene + Default + 'static>(&mut self) {
        self.action = Some(SceneTrans::Switch(Box::<T>::default()));
    }

    pub(crate) fn action(&mut self) -> Option<SceneTrans> {
        self.action.take()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Default)]
    struct A;

    #[derive(Default)]
    struct B;

    #[derive(Default)]
    struct C;

    #[derive(Default)]
    struct D;

    impl Scene for A {}

    impl Scene for B {}

    #[test]
    fn switch_scene_should_replace_at_same_index() {
        let mut world = GameData::default();
        world.insert_resource(SceneController::default());

        let scene = Box::new(A);
        let mut machine = SceneMachine { current_scene: Some(scene), current_scene_started: false };

        world.scene_controller().switch::<B>();
        machine.apply_scene_action(SceneAction::EndFrame, &mut world);
    }
}