specs 0.14.3

Specs is an Entity-Component System library written in 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
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

extern crate ron;

use super::*;
use error::{Error, NoError};
use prelude::*;

mod marker_test {
    use super::*;

    #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
    struct A(i32);

    impl Component for A {
        type Storage = VecStorage<Self>;
    }

    #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
    struct B(bool);

    impl Component for B {
        type Storage = VecStorage<Self>;
    }

    /// Ensure that the marker correctly allocates IDs for entities that come
    /// from mixed sources: normal entity creation, lazy creation, and
    /// deserialization.
    #[test]
    fn bumps_index_after_reload() {
        let mut world = World::new();

        world.add_resource(U64MarkerAllocator::new());
        world.register::<A>();
        world.register::<B>();
        world.register::<U64Marker>();

        world
            .create_entity()
            .with(A(32))
            .with(B(true))
            .marked::<U64Marker>()
            .build();
        world
            .create_entity()
            .with(A(64))
            .with(B(false))
            .marked::<U64Marker>()
            .build();

        // Serialze all entities
        let mut ser = ron::ser::Serializer::new(Some(Default::default()), true);

        world.exec(
            |(ents, comp_a, comp_b, markers, _alloc): (
                Entities,
                ReadStorage<A>,
                ReadStorage<B>,
                ReadStorage<U64Marker>,
                Read<U64MarkerAllocator>,
            )| {
                SerializeComponents::<NoError, U64Marker>::serialize(
                    &(&comp_a, &comp_b),
                    &ents,
                    &markers,
                    &mut ser,
                ).unwrap();
            },
        );

        let serial = ser.into_output_string();

        let mut de = ron::de::Deserializer::from_str(&serial).unwrap();

        // Throw the old world away and deserialzie into a new world
        let mut world = World::new();

        world.add_resource(U64MarkerAllocator::new());
        world.register::<A>();
        world.register::<B>();
        world.register::<U64Marker>();

        world.exec(
            |(ents, comp_a, comp_b, mut markers, mut alloc): (
                Entities,
                WriteStorage<A>,
                WriteStorage<B>,
                WriteStorage<U64Marker>,
                Write<U64MarkerAllocator>,
            )| {
                DeserializeComponents::<Error, _>::deserialize(
                    &mut (comp_a, comp_b),
                    &ents,
                    &mut markers,
                    &mut alloc,
                    &mut de,
                ).unwrap();
            },
        );

        // Two marked entities should be deserialized
        assert_marked_entity_count(&mut world, 2);

        // Queue lazy creation of 2 more entities
        world.exec(|(ents, lazy): (Entities, Read<LazyUpdate>)| {
            lazy.create_entity(&ents)
                .with(A(128))
                .with(B(false))
                .marked::<U64Marker>()
                .build();
            lazy.create_entity(&ents)
                .with(A(256))
                .with(B(true))
                .marked::<U64Marker>()
                .build();
        });

        // Create 2 new entities besides the deserialized ones
        world
            .create_entity()
            .with(A(512))
            .with(B(false))
            .marked::<U64Marker>()
            .build();
        world
            .create_entity()
            .with(A(1024))
            .with(B(true))
            .marked::<U64Marker>()
            .build();

        // Check that markers of deserialized entities and newly created entities are unique
        assert_marked_entity_count(&mut world, 4);
        assert_markers_are_unique(&mut world);

        // Check that markers of lazily created entities are unique
        world.maintain();
        assert_marked_entity_count(&mut world, 6);
        assert_markers_are_unique(&mut world);
    }

    /// Assert that the number of entities marked with `U64Marker` is equal to `count`
    fn assert_marked_entity_count(world: &mut World, count: usize) {
        world.exec(|(ents, markers): (Entities, ReadStorage<U64Marker>)| {
            let marked_entity_count = (&ents, &markers).join().count();

            assert_eq!(marked_entity_count, count);
        });
    }

    /// Ensure there are no duplicate marker .ids() in the world
    fn assert_markers_are_unique(world: &mut World) {
        world.exec(|(ents, markers): (Entities, ReadStorage<U64Marker>)| {
            use std::collections::HashSet;

            let marker_ids: Vec<_> = (&ents, &markers)
                .join()
                .map(|(_entity, marker)| marker.id())
                .collect();

            let marker_id_set: HashSet<_> = marker_ids.iter().cloned().collect();

            assert_eq!(marker_ids.len(), marker_id_set.len());
        });
    }
}