ecs 0.23.1

An Entity Component System (ECS) Framework
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143


#[macro_use]
extern crate ecs;

use ecs::{ModifyData};
use ecs::{World};
use ecs::{Process, System};
use ecs::system::{EntityProcess, EntitySystem};
use ecs::EntityIter;

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Position
{
    pub x: f32,
    pub y: f32,
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Team(u8);

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SomeFeature;

components! {
    #[builder(EntityInit)]
    struct TestComponents {
        #[hot] blank_data: (),
        #[hot] position: Position,
        #[cold] team: Team,
        #[hot] feature: SomeFeature,
    }
}

systems! {
    struct TestSystems<TestComponents, ()> {
        active: {
            hello_world: HelloWorld = HelloWorld("Hello, World!"),
        },
        passive: {
            print_position: EntitySystem<PrintPosition> = EntitySystem::new(PrintPosition,
                                                                            aspect!(<TestComponents>
                                                                                    all: [position, feature]
                                                                            )
            ),
        }
    }
}

pub type DataHelper = ecs::DataHelper<TestComponents, ()>;

pub struct HelloWorld(&'static str);
impl Process for HelloWorld
{
    fn process(&mut self, _: &mut DataHelper)
    {
        println!("{}", self.0);
    }
}
impl System for HelloWorld { type Components = TestComponents; type Services = (); }

pub struct PrintPosition;
impl EntityProcess for PrintPosition
{
    fn process(&mut self, en: EntityIter<TestComponents>, co: &mut DataHelper)
    {
        for e in en
        {
            println!("{:?}", co.position.borrow(&e));
        }
    }
}
impl System for PrintPosition {
    type Components = TestComponents;
    type Services = ();
}

#[test]
fn test_general_1()
{
    let mut world = World::<TestSystems>::new();

    // Test entity builders
    let entity = world.create_entity(EntityInit {
        position: Some(Position { x: 0.5, y: 0.7 }),
        team: Some(Team(4)),
        ..Default::default()
    });
    world.create_entity(EntityInit {
        position: Some(Position { x: 0.6, y: 0.8 }),
        team: Some(Team(3)),
        feature: Some(SomeFeature),
        ..Default::default()
    });

    // Finish adding new entities
    world.flush_queue();

    // Test passive systems
    process!(world, print_position);

    // Test entity modifiers
    world.modify_entity(entity, |e: ModifyData<TestComponents>, c: &mut TestComponents| {
        assert_eq!(Some(Position { x: 0.5, y: 0.7 }), c.position.insert(&e, Position { x: -2.5, y: 7.6 }));
        assert_eq!(Some(Team(4)), c.team.remove(&e));
        assert!(!c.feature.has(&e));
        assert!(c.feature.insert(&e, SomeFeature).is_none());
    });

    process!(world, print_position);

    world.modify_entity(entity, |e: ModifyData<TestComponents>, c: &mut TestComponents| {
        assert_eq!(Position { x: -2.5, y: 7.6 }, c.position[e]);
        assert_eq!(None, c.team.remove(&e));
        assert!(c.feature.insert(&e, SomeFeature).is_some());
    });

    // world.modify_entity(entity, EntityChange {
    //     position: Some(Some(Position { x: 0.5, y: 0.7 })), // Set
    //     team: Some(None), // Remove
    //     ..Default::default() // Ignore the rest (None)
    // });

    process!(world, print_position);

    // Test external entity iterator
    for e in world.entities()
    {
        assert!(world.position.has(&e));
    }

    // Test external entity iterator with aspect filtering
    for e in world.entities().filter(aspect!(<TestComponents> all: [team]), &world)
    {
        assert!(world.team.has(&e));
    }

    // Test active systems
    world.update();

    // Test system modification
    world.systems.hello_world.0 = "Goodbye, World!";
    world.update();
}