edict 0.6.1

Experimental entity-component-system library
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

use edict::{
    component::Component,
    epoch::EpochId,
    query::Entities,
    relation::{Relates, Relation},
    world::WorldBuilder,
};

#[derive(Component)]
struct A;

#[derive(Component)]
struct B;

#[derive(Component)]
struct C;

#[derive(Clone, Copy, Relation)]
#[edict(exclusive, owned)]
struct ChildOf;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Relation)]
struct Likes;

#[derive(Clone, Copy, Debug, Relation)]
#[edict(symmetric)]
struct Enemy;

#[derive(Clone, Copy, Debug, Relation)]
#[edict(symmetric, owned)]
struct LifeBound;

fn main() {
    let mut world_builder = WorldBuilder::new();
    world_builder
        .register_component::<A>()
        .on_drop_fn(|a, entity, encoder| {
            a.on_drop(entity, encoder);
            println!("A dropped");
        });

    let mut world = world_builder.build();

    let a = world.spawn((A,)).id();
    let b = world.spawn(()).id();

    world.add_relation(a, ChildOf, b).unwrap();

    for (e, ChildOf) in world.view::<Entities>().relates_to::<ChildOf>(b).iter() {
        println!("{} is child of {}", e, b);
    }

    world.despawn(b).unwrap();

    assert_eq!(world.is_alive(a), false);

    let a = world.spawn(()).id();
    let b = world.spawn(()).id();
    let c = world.spawn(()).id();

    world.add_relation(a, Likes, b).unwrap();
    world.add_relation(a, Likes, c).unwrap();

    let mut view = world.get::<Relates<&Likes>>(a).unwrap();
    let first = view.next().unwrap();
    assert_eq!(first.1, b);
    let second = view.next().unwrap();
    assert_eq!(second.1, c);

    world.despawn(b).unwrap();

    let mut view = world.get::<Relates<&Likes>>(a).unwrap();
    let first = view.next().unwrap();
    assert_eq!(first.1, c);

    let b = world.spawn(()).id();

    world.add_relation(a, Enemy, b).unwrap();

    let q = world.view::<Entities>().relates::<Enemy>();
    for (e, enemies) in q.iter() {
        println!(
            "{} is enemy of {:?}",
            e,
            enemies.into_iter().collect::<Vec<_>>()
        );
    }
    drop(q);

    let _ = world.despawn(b);

    for (e, enemies) in world.view_mut::<Entities>().relates::<Enemy>() {
        println!(
            "{} is enemy of {:?}",
            e,
            enemies.into_iter().collect::<Vec<_>>()
        );
    }

    let since = EpochId::start();

    let view = world
        .view_mut::<(Entities, &A)>()
        .with::<B>()
        .modified::<&C>(since)
        .relates_to::<ChildOf>(b)
        .filter_relates_to::<Likes>(c);

    for ((e, a), c, child_of) in view {
        let _ = (e, a, c, child_of);
    }

    let a = world.spawn((A,)).id();
    let b = world.spawn((B,)).id();

    world.add_relation(a, LifeBound, b).unwrap();

    world.despawn(a).unwrap();
    assert_eq!(world.is_alive(b), false);
}