quaso 0.57.6

Toolset for making Micro Games quickly
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

use crate::{context::GameContext, game::GameState, multiplayer::GameMultiplayer};
use std::any::Any;
use tehuti_timeline::time::TimeStamp;

pub struct LocalPrepareFrameEvent {
    pub current_tick: TimeStamp,
}

pub struct LocalHandleInputsEvent {
    pub current_tick: TimeStamp,
}

pub struct LocalTickEvent {
    pub current_tick: TimeStamp,
    pub delta_time: f32,
}

pub struct LocalCommitFrameEvent {
    pub current_tick: TimeStamp,
}

pub trait LocalGameState {
    fn is(payload: &dyn Any) -> bool {
        payload.is::<LocalPrepareFrameEvent>()
            || payload.is::<LocalHandleInputsEvent>()
            || payload.is::<LocalTickEvent>()
            || payload.is::<LocalCommitFrameEvent>()
    }

    fn custom_event(&mut self, context: GameContext, payload: &mut dyn Any) {
        if let Some(payload) = payload.downcast_ref::<LocalPrepareFrameEvent>() {
            self.prepare_frame(context, payload.current_tick);
        } else if let Some(payload) = payload.downcast_ref::<LocalHandleInputsEvent>() {
            self.handle_inputs(context, payload.current_tick);
        } else if let Some(payload) = payload.downcast_ref::<LocalTickEvent>() {
            self.tick(context, payload.current_tick, payload.delta_time);
        } else if let Some(payload) = payload.downcast_ref::<LocalCommitFrameEvent>() {
            self.commit_frame(context, payload.current_tick);
        }
    }

    #[allow(unused_variables)]
    fn prepare_frame(&mut self, context: GameContext, current_tick: TimeStamp) {}

    #[allow(unused_variables)]
    fn handle_inputs(&mut self, context: GameContext, current_tick: TimeStamp) {}

    #[allow(unused_variables)]
    fn tick(&mut self, context: GameContext, current_tick: TimeStamp, delta_time: f32) {}

    #[allow(unused_variables)]
    fn commit_frame(&mut self, context: GameContext, current_tick: TimeStamp) {}
}

#[derive(Default)]
pub struct LocalMultiplayer {
    current_tick: TimeStamp,
}

impl GameMultiplayer for LocalMultiplayer {
    fn current_tick(&self) -> TimeStamp {
        self.current_tick
    }

    fn maintain(&mut self, state: &mut dyn GameState, mut context: GameContext, delta_time: f32) {
        {
            let current_tick = self.current_tick;
            let mut context = unsafe { context.fork() };
            context.multiplayer = Some(self);
            state.custom_event(context, &mut LocalPrepareFrameEvent { current_tick });
        }

        {
            let current_tick = self.current_tick;
            let mut context = unsafe { context.fork() };
            context.multiplayer = Some(self);
            state.custom_event(context, &mut LocalHandleInputsEvent { current_tick });
        }

        {
            let current_tick = self.current_tick;
            let mut context = unsafe { context.fork() };
            context.multiplayer = Some(self);
            state.custom_event(
                context,
                &mut LocalTickEvent {
                    current_tick,
                    delta_time,
                },
            );
            self.current_tick += 1;
        }

        {
            let current_tick = self.current_tick;
            let mut context = unsafe { context.fork() };
            context.multiplayer = Some(self);
            state.custom_event(context, &mut LocalCommitFrameEvent { current_tick });
        }
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}