shipyard 0.5.0

Entity Component System
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

use core::any::type_name;
use shipyard::error;
use shipyard::*;

#[test]
fn no_pack() {
    let mut world = World::new();

    let entity1 = world.add_entity((0usize, 1u32));
    let entity2 = world.add_entity((2usize, 3u32));

    let (component,) = world.remove::<(usize,)>(entity1);
    assert_eq!(component, Some(0usize));

    let (usizes, u32s) = world.borrow::<(View<usize>, View<u32>)>().unwrap();
    assert_eq!(
        (&usizes).get(entity1).err(),
        Some(error::MissingComponent {
            id: entity1,
            name: type_name::<usize>(),
        })
    );
    assert_eq!(u32s.get(entity1), Ok(&1));
    assert_eq!(usizes.get(entity2), Ok(&2));
    assert_eq!(u32s.get(entity2), Ok(&3));
}

#[test]
fn update() {
    let mut world = World::new();

    world.borrow::<ViewMut<usize>>().unwrap().track_all();

    let entity1 = world.add_entity((0usize,));
    let entity2 = world.add_entity((2usize,));

    let (component,) = world.remove::<(usize,)>(entity1);
    assert_eq!(component, Some(0));

    world
        .run(|usizes: View<usize>| {
            assert_eq!(
                usizes.get(entity1),
                Err(error::MissingComponent {
                    id: entity1,
                    name: type_name::<usize>(),
                })
            );
            assert_eq!(usizes.get(entity2), Ok(&2));
            assert_eq!(usizes.len(), 1);
            assert_eq!(usizes.inserted().iter().count(), 1);
            assert_eq!(usizes.modified().iter().count(), 0);
            assert_eq!(usizes.deleted().len(), 0);
            assert_eq!(usizes.removed(), &[entity1]);

            let mut iter = usizes.removed_or_deleted();
            assert_eq!(iter.next(), Some(entity1));
            assert_eq!(iter.next(), None);

            drop(iter);
        })
        .unwrap();

    world.delete_component::<(usize,)>(entity2);

    world
        .run(|usizes: View<usize>| {
            let mut iter = usizes.removed_or_deleted();
            assert_eq!(iter.next(), Some(entity1));
            assert_eq!(iter.next(), Some(entity2));
            assert_eq!(iter.next(), None);
        })
        .unwrap();
}

#[test]
fn old_key() {
    let mut world = World::new();

    let entity = world.add_entity((0usize, 1u32));
    world.delete_entity(entity);

    world.add_entity((2usize, 3u32));

    let (old_usize, old_u32) = world.remove::<(usize, u32)>(entity);
    assert!(old_usize.is_none() && old_u32.is_none());
}

#[test]
fn newer_key() {
    let mut world = World::new();

    let entity = world.add_entity((0usize, 1u32));

    world
        .borrow::<EntitiesViewMut>()
        .unwrap()
        .delete_unchecked(entity);

    world
        .run(|(usizes, u32s): (ViewMut<usize>, ViewMut<u32>)| {
            assert_eq!(usizes.len(), 1);
            assert_eq!(u32s.len(), 1);
        })
        .unwrap();

    let new_entity = world.add_entity(());
    let (old_usize, old_u32) = world.remove::<(usize, u32)>(new_entity);

    assert_eq!(old_usize, None);
    assert_eq!(old_u32, None);

    world
        .run(|(usizes, u32s): (ViewMut<usize>, ViewMut<u32>)| {
            assert_eq!(usizes.len(), 0);
            assert_eq!(u32s.len(), 0);
        })
        .unwrap();
}