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

use shipyard::*;

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

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

    let entity10 = world.add_entity(());
    let entity20 = world.add_entity(());

    world.add_component(entity10, (10usize, 30u32));
    world.add_component(entity20, (20usize,));
    world.add_component(entity20, (50u32,));

    let (usizes, u32s) = world.borrow::<(View<usize>, View<u32>)>().unwrap();

    assert_eq!(usizes.get(entity0).unwrap(), &0);
    assert_eq!(u32s.get(entity1).unwrap(), &1);
    assert_eq!((&usizes, &u32s).get(entity10).unwrap(), (&10, &30));
    assert_eq!((&usizes, &u32s).get(entity20).unwrap(), (&20, &50));

    let mut iter = (&usizes, &u32s).iter();
    assert_eq!(iter.next(), Some((&10, &30)));
    assert_eq!(iter.next(), Some((&20, &50)));
    assert_eq!(iter.next(), None);
}

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

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

    let entity = world.add_entity(());

    world.add_component(entity, (1usize,));

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

    world.add_component(entity, (2usize,));

    world
        .run(|mut usizes: ViewMut<usize>| {
            let mut iter = usizes.inserted().iter();
            assert_eq!(iter.next(), Some(&2));
            assert_eq!(iter.next(), None);

            usizes.clear_all_inserted();

            usizes[entity] = 3;
        })
        .unwrap();

    world.add_component(entity, (4usize,));

    world
        .run(|mut usizes: ViewMut<usize>| {
            let mut iter = usizes.modified().iter();
            assert_eq!(iter.next(), Some(&4));
            assert_eq!(iter.next(), None);

            usizes.clear_all_modified();
        })
        .unwrap();

    world.add_component(entity, (5usize,));

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

#[test]
#[should_panic(expected = "Entity has to be alive to add component to it.")]
fn dead_entity() {
    let mut world = World::new();

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

    let u32s = world.borrow::<View<u32>>().unwrap();
    assert!(u32s.get(entity).is_err());
}