pragma_ecs 1.0.2

Entity Component System for pragma.core-based game engines and frameworks, in pure Rust
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

//! A reader of fuzzer input that never fails: once the input ends, it yields zeros.

/// Reads little-endian values from the front of a byte slice.
#[derive(Debug)]
pub struct Bytes<'a> {
    data: &'a [u8],
}

impl<'a> Bytes<'a> {
    pub fn new(data: &'a [u8]) -> Self {
        Self { data }
    }

    pub fn is_empty(&self) -> bool {
        self.data.is_empty()
    }

    pub fn byte(&mut self) -> u8 {
        match self.data.split_first() {
            Some((first, rest)) => {
                self.data = rest;
                *first
            }
            None => 0,
        }
    }

    pub fn bool(&mut self) -> bool {
        self.byte() & 1 == 1
    }

    pub fn u16(&mut self) -> u16 {
        u16::from_le_bytes([self.byte(), self.byte()])
    }

    pub fn u32(&mut self) -> u32 {
        u32::from_le_bytes([self.byte(), self.byte(), self.byte(), self.byte()])
    }

    pub fn i32(&mut self) -> i32 {
        i32::from_le_bytes(self.u32().to_le_bytes())
    }

    /// A raw index, reduced modulo the length of whatever it picks from.
    pub fn index(&mut self) -> usize {
        usize::from(self.u16())
    }

    /// A value in `0..bound` (`bound > 0`).
    pub fn below(&mut self, bound: u8) -> u8 {
        self.byte() % bound
    }
}

/// Picks `raw % len` from `items`, or `None` if it is empty.
pub fn pick<T: Copy>(items: &[T], raw: usize) -> Option<T> {
    if items.is_empty() {
        None
    } else {
        items.get(raw % items.len()).copied()
    }
}