brood 0.9.1

A fast and flexible entity component system library.
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

use crate::{
    component::Component,
    entities::Null,
};
use alloc::vec::Vec;

pub trait Length {
    fn component_len(&self) -> usize;
    fn check_len(&self) -> bool;
    fn check_len_against(&self, len: usize) -> bool;
}

impl Length for Null {
    fn component_len(&self) -> usize {
        0
    }

    fn check_len(&self) -> bool {
        true
    }

    fn check_len_against(&self, _len: usize) -> bool {
        true
    }
}

impl<C, E> Length for (Vec<C>, E)
where
    C: Component,
    E: Length,
{
    fn component_len(&self) -> usize {
        self.0.len()
    }

    fn check_len(&self) -> bool {
        self.1.check_len_against(self.component_len())
    }

    fn check_len_against(&self, len: usize) -> bool {
        self.component_len() == len && self.1.check_len_against(len)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::entities;
    use alloc::vec;

    #[derive(Clone, Copy)]
    struct A;

    #[derive(Clone, Copy)]
    struct B;

    #[test]
    fn component_len() {
        assert_eq!(entities!((A, B); 100).entities.component_len(), 100);
    }

    #[test]
    fn check_len_passes() {
        assert!(entities!((A, B); 100).entities.check_len());
    }

    #[test]
    fn check_len_fails() {
        assert!(!(vec![A; 100], (vec![B; 99], entities::Null)).check_len());
    }
}