thallium_ecs 0.6.0

The ECS for the thallium crate
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

#![doc = include_str!("../README.md")]

mod app;
mod commands;
mod component;
mod component_container;
mod entities;
mod query;
mod query_parameters;
mod resource;
mod system;
mod system_parameters;
mod system_set;
mod resource_container;

pub use app::App;
pub use commands::Commands;
pub use component::Component;
pub use entities::{Entities, Entity};
pub use query::{Query, Ref, RefMut};
pub use query_parameters::QueryParameter;
pub use resource::{Res, ResMut, Resource};
pub use system::{IntoSystem, System, SystemFunction};
pub use system_parameters::SystemParameter;
pub use system_set::SystemSet;

#[cfg(test)]
mod tests {
    use crate::{App, Commands, Component, Entities, Query, Ref, RefMut, SystemSet};

    #[test]
    fn test() {
        struct TestComponent {
            value: i32,
        }
        impl Component for TestComponent {}

        struct TestComponent2 {
            value: i32,
        }
        impl Component for TestComponent2 {}

        let mut app = App::new();

        let entity1 = app.create_entity();
        app.add_component(entity1, TestComponent { value: 42 });

        let entity2 = app.create_entity();
        app.add_component(entity2, TestComponent { value: 44 });
        app.add_component(entity2, TestComponent2 { value: 0 });

        app.run(|mut q: Query<'_, RefMut<'_, TestComponent>>| {
            let [mut c1, mut c2] = q.get_many_mut([entity1, entity2]).unwrap();
            assert_eq!(c1.value, 42);
            assert_eq!(c2.value, 44);
            c1.value += 1;
            c2.value -= 1;
        });

        let mut set = SystemSet::new();
        set.register_system(
            |q1: Query<'_, Ref<'_, TestComponent>>,
             q2: Query<'_, Option<(Ref<'_, TestComponent2>, Ref<'_, TestComponent>)>>| {
                for (entity, c) in q1.iter() {
                    assert_eq!(c.value, 43);
                    if let Some((c2, c)) = q2.get(entity).unwrap() {
                        assert_eq!(c2.value, 0);
                        assert_eq!(c.value, 43);
                    }
                }
            },
        );
        app.run(&mut set);

        app.run(|mut commands: Commands<'_>| {
            commands.create_entity(());
            commands.create_entity(TestComponent { value: 5 });
        });

        app.run(
            |entities: Entities<'_>, q: Query<'_, Ref<'_, TestComponent>>| {
                assert_eq!(entities.iter().count(), 4);
                assert_eq!(
                    entities
                        .iter()
                        .filter(|&entity| q.get(entity).is_some())
                        .count(),
                    3
                );
            },
        );
    }
}