layer-system 0.1.2

A system for handling different kinds of events
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
125
126
127
128

enum Event {
    Fixed, // generated at fixed times
    Click(u16, u16), // generated by click
    Quit, // genreated by try to close window
}

use self::Event::*;

struct State; // a global state

type LayerManager<'m> = layer_system::LayerManager<'m, State, Event>; // the layer manager

use layer_system::{Layer, Change}; // other imports from layer System

struct World; // layer for the game world

impl Layer<State, Event> for World {
    fn passive_update(&mut self, state: &mut State, event: &Event) {
        match event {
            Fixed => { /* render here */ }
            _ => (),
        }
    }

    fn update(&mut self, state: &mut State, event: &Event) -> Change<State, Event> {
        match event {
            Fixed => { /* world physics update */ }
            _ => ()
        }
        Change::Stay
    }
}

struct Interface;

enum ClickEvent {
    Action,
    Pause,
    Exit,
    Nothing,
}

impl Interface {
    fn click(&self, x: u16, y: u16) -> ClickEvent {
        use self::ClickEvent::*;
        if y < 16 {
            if x < 64 {
                Action
            } else if x < 128 {
                Pause
            } else if x < 192 {
                Exit
            } else {
                Nothing
            }
        } else {
            Nothing
        }
    }
}

impl Layer<State, Event> for Interface {
    fn passive_update(&mut self, state: &mut State, event: &Event) {
        match event {
            Fixed => { /* render here */ }
            _ => (),
        }
    }

    fn update(&mut self, state: &mut State, event: &Event) -> Change<State, Event> {
        match event {
            Click(x, y) => match self.click(*x, *y) {
                // execute some action when clicking "Action"
                ClickEvent::Action => {
                    /* execute action */
                    Change::Stay
                },
                // pause when clicking "Pause"
                ClickEvent::Pause => Change::Add(Box::new(Pause)),
                // remove all layers when clicking "Exit"
                ClickEvent::Exit => Change::Close,
                // nothing was clicked, so in case the world supports a click event, just defer it
                ClickEvent::Nothing => Change::Defer,
            }
            // when trying to quit the game, pause it first
            Quit => Change::Add(Box::new(Pause)),
            // Defer all other events, so World will handle everything else
            _ => Change::Defer,
        }
    }
}

struct Pause;

impl Layer<State, Event> for Pause {
    fn passive_update(&mut self, state: &mut State, event: &Event) {
        match event {
            Fixed => { /* render here */ }
            _ => (),
        }
    }

    fn update(&mut self, state: &mut State, event: &Event) -> Change<State, Event> {
        match event {
            // do not defer `Fixed`, so world physics won't be updated anymore
            Fixed => Change::Stay,
            // end pause by clicking somewhere
            Click(_, _) => Change::Remove,
            // when trying to quit the game again, quit it
            Quit => Change::Close,
        }
    }
}

fn main() {
    let mut manager = LayerManager::new();
    manager.add(World); // add World
    manager.add(Interface); // add Interface above world
    
    let mut state = State;

    while manager.is_active() {
        manager.update(&mut state, Fixed);
        /* handle other events in events loop */
        /* wait for a fixed time */
    }
}