geng-utils 0.3.0

A collection of utilities for Geng engine.
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

use geng::{
    prelude::{Deserialize, Serialize},
    Window,
};

/// A convenience type that combines [Key](geng::Key) and [MouseButton](geng::MouseButton).
/// Can often be used for specifying controls where only press/release plays a role.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum EventKey {
    Key(geng::Key),
    Mouse(geng::MouseButton),
}

impl From<&EventKey> for EventKey {
    fn from(value: &EventKey) -> Self {
        *value
    }
}

impl From<geng::Key> for EventKey {
    fn from(value: geng::Key) -> Self {
        Self::Key(value)
    }
}

impl From<&geng::Key> for EventKey {
    fn from(value: &geng::Key) -> Self {
        Self::Key(*value)
    }
}

impl From<geng::MouseButton> for EventKey {
    fn from(value: geng::MouseButton) -> Self {
        Self::Mouse(value)
    }
}

impl From<&geng::MouseButton> for EventKey {
    fn from(value: &geng::MouseButton) -> Self {
        Self::Mouse(*value)
    }
}

impl EventKey {
    /// Check whether the key is pressed.
    pub fn is_pressed(self, window: &geng::Window) -> bool {
        match self {
            Self::Key(key) => window.is_key_pressed(key),
            Self::Mouse(button) => window.is_button_pressed(button),
        }
    }

    /// Check whether the event corresponds to the press of the key.
    pub fn is_event_press(self, event: &geng::Event) -> bool {
        match (&self, event) {
            (Self::Key(self_key), geng::Event::KeyPress { key }) => self_key == key,
            (Self::Mouse(self_button), geng::Event::MousePress { button, .. }) => {
                self_button == button
            }
            _ => false,
        }
    }

    /// Check whether the event corresponds to the release of the key.
    pub fn is_event_release(self, event: &geng::Event) -> bool {
        match (&self, event) {
            (Self::Key(self_key), geng::Event::KeyRelease { key }) => self_key == key,
            (Self::Mouse(self_button), geng::Event::MouseRelease { button, .. }) => {
                self_button == button
            }
            _ => false,
        }
    }
}

/// Check whether at least one of the keys is pressed.
pub fn is_key_pressed(
    window: &Window,
    keys: impl IntoIterator<Item = impl Into<EventKey>>,
) -> bool {
    keys.into_iter()
        .any(|key| Into::<EventKey>::into(key).is_pressed(window))
}

/// Check whether the event corresponds to the press of at least one of the keys.
pub fn is_event_press(
    event: &geng::Event,
    keys: impl IntoIterator<Item = impl Into<EventKey>>,
) -> bool {
    keys.into_iter()
        .any(|key| Into::<EventKey>::into(key).is_event_press(event))
}

/// Check whether the event corresponds to the release of at least one of the keys.
pub fn is_event_release(
    event: &geng::Event,
    keys: impl IntoIterator<Item = impl Into<EventKey>>,
) -> bool {
    keys.into_iter()
        .any(|key| Into::<EventKey>::into(key).is_event_release(event))
}