ecs-tiny 0.4.0

A minimal ECS supporting entity and component insertion/removal, association, and single-type iteration.
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

#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, bytemuck::Pod, bytemuck::Zeroable)]
pub struct ComponentA(i32);
impl ecs_tiny::Component for ComponentA {}

#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, bytemuck::Pod, bytemuck::Zeroable)]
pub struct ComponentB(i32);
impl ecs_tiny::Component for ComponentB {}

#[test]
fn crud_entity() {
    let mut world = ecs_tiny::World::new();
    let entity_key = world.insert_entity();

    assert_eq!(world.contains_entity(entity_key), true);
    assert_eq!(world.remove_entity(entity_key), Some(()));

    assert_eq!(world.contains_entity(entity_key), false);
    assert_eq!(world.remove_entity(entity_key), None);
}

#[test]
fn crud_component() {
    let mut world = ecs_tiny::World::new();
    let entity_key = world.insert_entity();
    assert_eq!(world.insert_component(entity_key, ComponentA(42)), Some(()));

    assert_eq!(world.get_component::<ComponentA>(entity_key), Some(&ComponentA(42)));
    assert_eq!(world.get_component_mut::<ComponentA>(entity_key), Some(&mut ComponentA(42)));
    assert_eq!(world.remove_component::<ComponentA>(entity_key), Some(()));

    assert_eq!(world.get_component::<ComponentA>(entity_key), None);
    assert_eq!(world.get_component_mut::<ComponentA>(entity_key), None);
    assert_eq!(world.remove_component::<ComponentA>(entity_key), None);
}

#[test]
fn insert_component_with_invalid_entity() {
    let mut world = ecs_tiny::World::new();
    let entity_key = world.insert_entity();
    assert_eq!(world.remove_entity(entity_key), Some(()));

    assert_eq!(world.insert_component(entity_key, ComponentA(42)), None);
}

#[test]
fn remove_component_with_invalid_type() {
    let mut world = ecs_tiny::World::new();
    let entity_key = world.insert_entity();
    assert_eq!(world.insert_component(entity_key, ComponentA(42)), Some(()));

    assert_eq!(world.get_component::<ComponentB>(entity_key), None);
    assert_eq!(world.get_component_mut::<ComponentB>(entity_key), None);
    assert_eq!(world.remove_component::<ComponentB>(entity_key), None);
}

#[test]
fn remove_entity_and_components() {
    let mut world = ecs_tiny::World::new();
    let entity_key = world.insert_entity();
    assert_eq!(world.insert_component(entity_key, ComponentA(42)), Some(()));
    assert_eq!(world.remove_entity(entity_key), Some(()));

    assert_eq!(world.contains_entity(entity_key), false);
    assert_eq!(world.get_component::<ComponentA>(entity_key), None);
    assert_eq!(world.get_component_mut::<ComponentA>(entity_key), None);
}

#[test]
fn iter_entity() {
    let mut world = ecs_tiny::World::new();
    let entity_key0 = world.insert_entity();
    let entity_key1 = world.insert_entity();

    let mut iter = world.iter_entity();
    assert_eq!(iter.next(), Some(entity_key0));
    assert_eq!(iter.next(), Some(entity_key1));
    assert_eq!(iter.next(), None);
}

#[test]
fn iter_component() {
    let mut world = ecs_tiny::World::new();
    let entity_key0 = world.insert_entity();
    let entity_key1 = world.insert_entity();
    assert_eq!(world.insert_component(entity_key0, ComponentA(42)), Some(()));
    assert_eq!(world.insert_component(entity_key0, ComponentB(63)), Some(()));
    assert_eq!(world.insert_component(entity_key1, ComponentA(13)), Some(()));
    assert_eq!(world.insert_component(entity_key1, ComponentB(87)), Some(()));

    let mut iter = world.iter_component::<ComponentA>();
    assert_eq!(iter.next(), Some(&ComponentA(42)));
    assert_eq!(iter.next(), Some(&ComponentA(13)));
    assert_eq!(iter.next(), None);
    drop(iter);

    let mut iter = world.iter_component_mut::<ComponentB>();
    assert_eq!(iter.next(), Some(&mut ComponentB(63)));
    assert_eq!(iter.next(), Some(&mut ComponentB(87)));
    assert_eq!(iter.next(), None);
}

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

    assert_eq!(world.iter_component::<ComponentA>().count(), 0);
    assert_eq!(world.iter_component_mut::<ComponentA>().count(), 0);
}