pkecs 9.0.0

Another ECS implementation.
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

//! Entity store tests.

use std::any::TypeId;
use pkecs_core::entity::Entities;

/// Asserts that [`None`] is returned from queries when there are no entities.
#[test]
fn empty_query() {
    let mut entities = Entities::default();

    let query_ref = entities.query::<Test>();
    let entity_ref = query_ref.first();
    assert!(entity_ref.is_none());

    let mut query_mut = entities.query_mut::<Test>();
    let entity_mut = query_mut.first_mut();
    assert!(entity_mut.is_none());

    let mut query_disjoint_mut = entities.query_disjoint_mut([&TypeId::of::<Test>()]);
    let entity_disjoint_mut = query_disjoint_mut.first_mut::<Test>();
    assert!(entity_disjoint_mut.is_none());
}

struct Test;

/// Asserts that entities can be created.
#[test]
fn can_spawn_entity() {
    let mut entities = Entities::default();
    entities.spawn(CanSpawn);

    let query_ref = entities.query::<CanSpawn>();
    let entity_ref = query_ref.first();

    assert!(entity_ref.is_some());
}

struct CanSpawn;

/// Asserts that entities can be mutated.
#[test]
fn can_mutate_entity() {
    const EXPECTED: i32 = 1;

    let mut entities = Entities::default();
    entities.spawn(CanMutate(0));

    let mut query_mut = entities.query_mut::<CanMutate>();
    let entity_mut = query_mut
        .first_mut()
        .unwrap();
    entity_mut.0 = EXPECTED;

    let query_ref = entities.query::<CanMutate>();
    let entity_ref = query_ref
        .first()
        .unwrap();

    assert_eq!(entity_ref.0, EXPECTED);
}

struct CanMutate(i32);

/// Asserts that a query and indexed query can be performed on the same component type.
#[test]
fn can_query_and_query_indexed() {
    let index = 1;

    let mut entities = Entities::default();
    entities.spawn(Test);
    entities.spawn_indexed(index, Test);

    let test_query = entities.query::<Test>();
    let test = test_query.first();
    assert!(test.is_some());

    let test_query_indexed = entities.query_indexed::<i32, Test>();
    let test_indexed = test_query_indexed.get(&index);
    assert!(test_indexed.is_some());
}