shine-input 0.2.1

SHINE. Input handling for the shine 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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::ModifierId;

pub const MAX_MODIFIER_COUNT: u32 = 128;

#[derive(Clone, Debug)]
pub struct ModifierMask(pub(crate) u128);

impl ModifierMask {
    pub fn new() -> ModifierMask {
        ModifierMask(0)
    }

    pub fn new_from(filter: &[ModifierId]) -> ModifierMask {
        let mut mask = ModifierMask(0);
        mask.set_from_slice(filter);
        mask
    }

    pub fn from_masked_clear(mask: &ModifierMask, clear_mask: &ModifierMask) -> ModifierMask {
        ModifierMask(mask.0 & !clear_mask.0)
    }

    pub fn clear(&mut self) {
        self.0 = 0;
    }

    pub fn get(&self, modifier: ModifierId) -> bool {
        let m = 1_u128 << modifier.id();
        (self.0 & m) != 0
    }

    pub fn set(&mut self, modifier: ModifierId, value: bool) {
        let m = 1_u128 << modifier.id();
        if value {
            self.0 |= m;
        } else {
            self.0 &= !m;
        }
    }

    pub fn set_from_slice(&mut self, filter: &[ModifierId]) {
        for i in filter {
            let m = 1_u128 << i.id();
            self.0 |= m;
        }
    }
}

impl Default for ModifierMask {
    fn default() -> ModifierMask {
        ModifierMask::new()
    }
}

impl From<&[ModifierId]> for ModifierMask {
    fn from(value: &[ModifierId]) -> ModifierMask {
        ModifierMask::new_from(value)
    }
}

impl From<[ModifierId; 1]> for ModifierMask {
    fn from(value: [ModifierId; 1]) -> ModifierMask {
        ModifierMask::new_from(&value)
    }
}

#[derive(Clone, Debug)]
pub struct ModifierFilterMask {
    /// Tha mask to consider in the required mask
    filter: ModifierMask,

    /// The required value for each modifiers
    required: ModifierMask,
}

impl ModifierFilterMask {
    pub fn new() -> ModifierFilterMask {
        ModifierFilterMask {
            filter: ModifierMask::new(),
            required: ModifierMask::new(),
        }
    }

    pub fn new_from(filter: &[(ModifierId, bool)]) -> ModifierFilterMask {
        let mut mask = ModifierFilterMask::new();

        for (i, f) in filter {
            log::trace!("{:?}", mask.filter);
            assert!(!mask.filter.get(*i), "filter already set for {:?}", i);
            mask.filter.set(*i, true);
            mask.required.set(*i, *f);
        }
        mask
    }

    pub fn check(&self, mask: &ModifierMask) -> bool {
        (mask.0 & self.filter.0) == self.required.0
    }
}

impl Default for ModifierFilterMask {
    fn default() -> ModifierFilterMask {
        ModifierFilterMask::new()
    }
}

impl From<&[(ModifierId, bool)]> for ModifierFilterMask {
    fn from(value: &[(ModifierId, bool)]) -> ModifierFilterMask {
        ModifierFilterMask::new_from(value)
    }
}

impl From<[(ModifierId, bool); 1]> for ModifierFilterMask {
    fn from(value: [(ModifierId, bool); 1]) -> ModifierFilterMask {
        ModifierFilterMask::new_from(&value)
    }
}