flax 0.7.1

An ergonomic archetypical ECS
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::sync::Arc;

use flax::components::*;
use flax::*;

use itertools::Itertools;
component! {
    shared: Arc<String>,
    health: f32,
}

#[test]
fn commandbuffer() {
    let mut world = World::new();
    let ids = world.spawn_many().take(10).collect_vec();

    let mut cmd = CommandBuffer::new();

    let shared_value = Arc::new("Foo".to_string());

    cmd.set(ids[1], name(), "Johnathan".into())
        .set(ids[3], shared(), shared_value.clone())
        .set(ids[6], name(), "Bertha".into())
        .set(ids[8], health(), 28.5);

    cmd.apply(&mut world).unwrap();

    assert_eq!(
        world.get(ids[1], name()).as_deref(),
        Ok(&"Johnathan".to_string())
    );

    assert_eq!(world.get(ids[3], shared()).as_deref(), Ok(&shared_value));

    assert_eq!(
        world.get(ids[6], name()).as_deref(),
        Ok(&"Bertha".to_string())
    );

    assert_eq!(world.get(ids[8], health()).as_deref(), Ok(&28.5));

    // Add a name to each component which doesn't have a name
    let mut query = Query::new(entity_ids()).filter(name().without());

    // Deferred world modification while iterating
    query.borrow(&world).iter().enumerate().for_each(|(i, id)| {
        eprintln!("Adding name to id: {id}");
        cmd.set(id, name(), format!("Unnamed: {i}"));
    });

    cmd.apply(&mut world).unwrap();

    let mut name_query = Query::new(name());
    let names = name_query
        .borrow(&world)
        .iter()
        .cloned()
        .sorted()
        .collect_vec();

    assert_eq!(
        names,
        [
            "Bertha",
            "Johnathan",
            "Unnamed: 0",
            "Unnamed: 1",
            "Unnamed: 2",
            "Unnamed: 3",
            "Unnamed: 4",
            "Unnamed: 5",
            "Unnamed: 6",
            "Unnamed: 7",
        ]
    );

    Query::new((entity_ids(), name()))
        .filter(name().cmp(|name: &String| name.contains("Unnamed")))
        .borrow(&world)
        .iter()
        .for_each(|(id, n)| {
            eprintln!("Removing name for entity: {id} {n}");
            cmd.remove(id, name());
        });

    cmd.despawn(ids[8]);

    cmd.apply(&mut world).unwrap();

    let names = name_query
        .borrow(&world)
        .iter()
        .cloned()
        .sorted()
        .collect_vec();

    assert_eq!(names, ["Bertha", "Johnathan"]);

    assert!(!world.is_alive(ids[8]));

    // Spawn some entities
    component! {
        soldier: (),
    }

    (0..100).for_each(|i| {
        EntityBuilder::new()
            .set_default(soldier())
            .set(name(), format!("Soldier: {i}"))
            .set(health(), 100.0)
            .spawn_into(&mut cmd)
    });

    cmd.apply(&mut world).unwrap();

    let soldiers = Query::new(health())
        .filter(soldier().with())
        .borrow(&world)
        .iter()
        .copied()
        .collect_vec();

    // Ensure all soldiers are present and up to health
    assert_eq!(soldiers.len(), 100);
    assert_eq!(soldiers, [100.0; 100]);

    // Oh no, one got shot
    if let Some(health) = Query::new(health().as_mut())
        .filter(soldier().with())
        .borrow(&world)
        .iter()
        .nth(42)
    {
        *health -= 20.0
    }

    // Well, there are only 99 unwounded soldiers left
    // Lets count them
    let soldiers = Query::new(name())
        .filter(soldier().with() & health().ge(100.0))
        .borrow(&world)
        .iter()
        .cloned()
        .collect_vec();

    assert_eq!(soldiers.len(), 99);
}