twors 0.4.0

A simple Rust 2D game engine based on canvas and WASM
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
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

use std::collections::HashMap;
use std::hash::Hash;

/// "Pressed" and "Released" should be active for a single frame
/// "Down" and "Up" are returned instead of "Pressed" and "Released" after that single frame
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyState {
    Up,
    Down,
    Pressed,
    Released,
}

pub struct KeyStateMap<T>
where
    T: Clone + Eq + Hash + PartialEq,
{
    keys: HashMap<T, KeyState>,
}

// #[derive(Default)] doesn't work if T is not Default, but T doesn't need to be Default, so we
// implement Defaulgit@github_vimlucid:vimlucid/twors.git manually instead
impl<T> Default for KeyStateMap<T>
where
    T: Clone + Eq + Hash + PartialEq,
{
    fn default() -> Self {
        Self {
            keys: HashMap::default(),
        }
    }
}

// TODO: Sort trait bounds automatically?
impl<T> KeyStateMap<T>
where
    T: Clone + Eq + Hash + PartialEq,
{
    pub fn is_pressed(&self, key: &T) -> bool {
        let state = self.state(key);
        state == KeyState::Pressed
    }

    pub fn is_down(&self, key: &T) -> bool {
        let state = self.state(key);
        (state == KeyState::Pressed) || (state == KeyState::Down)
    }

    pub fn is_released(&self, key: &T) -> bool {
        let state = self.state(key);
        state == KeyState::Released
    }

    pub fn is_up(&self, key: &T) -> bool {
        let state = self.state(key);
        (state == KeyState::Released) || (state == KeyState::Up)
    }

    pub fn transition_states(&mut self) {
        for (_, curr_state) in self.keys.iter_mut() {
            let new_state = match curr_state {
                KeyState::Pressed => KeyState::Down,
                KeyState::Released => KeyState::Up,
                _ => *curr_state,
            };

            *curr_state = new_state;
        }
    }

    pub fn handle_key_down(&mut self, key: &T) {
        self.keys.insert(key.clone(), KeyState::Pressed);
    }

    pub fn handle_key_up(&mut self, key: &T) {
        self.keys.insert(key.clone(), KeyState::Released);
    }

    fn state(&self, key: &T) -> KeyState {
        let state = self.keys.get(key);
        match state {
            Some(current_state) => *current_state,
            None => KeyState::Up,
        }
    }
}

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

    #[derive(Clone, Eq, Hash, PartialEq)]
    enum MouseButton {
        Main,
        Secondary,
    }

    #[test]
    fn initial() {
        let input = KeyStateMap::default();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Up);
    }

    #[test]
    fn transition_noop() {
        let mut input = KeyStateMap::default();
        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Up);
    }

    #[test]
    fn transition_pressed_down() {
        let mut input = KeyStateMap::default();

        input.handle_key_down(&MouseButton::Main);
        assert_eq!(input.state(&MouseButton::Main), KeyState::Pressed);

        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Down);
    }

    #[test]
    fn transition_released_inactive() {
        let mut input = KeyStateMap::default();
        input.handle_key_down(&MouseButton::Main);
        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Down);

        input.handle_key_up(&MouseButton::Main);
        assert_eq!(input.state(&MouseButton::Main), KeyState::Released); // pressed vs released

        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Up);
    }

    #[test]
    fn independent() {
        let mut input = KeyStateMap::default();

        input.handle_key_down(&MouseButton::Main);
        assert_eq!(input.state(&MouseButton::Main), KeyState::Pressed);
        assert_eq!(input.state(&MouseButton::Secondary), KeyState::Up);

        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Down);
        assert_eq!(input.state(&MouseButton::Secondary), KeyState::Up);

        input.handle_key_up(&MouseButton::Main);
        input.handle_key_down(&MouseButton::Secondary);
        assert_eq!(input.state(&MouseButton::Main), KeyState::Released);
        assert_eq!(input.state(&MouseButton::Secondary), KeyState::Pressed);

        input.transition_states();
        assert_eq!(input.state(&MouseButton::Main), KeyState::Up);
        assert_eq!(input.state(&MouseButton::Secondary), KeyState::Down);
    }
}