nya-ecs 0.2.0

nya 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
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

//! Query functions, "Systems"

use std::marker::PhantomData;

use crate::{
    World,
    query::{Query, Queryable, ToFilter},
};

use indexmap::IndexMap;
use nya_core::sparse_set::SparseSet;

/// System trait
pub trait System: 'static {
    /// Run the system on `world`
    fn run(&self, world: &mut World);
}

/// "Dyanmic" System trait
pub struct QuerySystem<F: ToFilter, C: Fn(Query, &mut World) = fn(Query, &mut World)> {
    callback: C,
    _marker: PhantomData<F>,
}

impl<F: ToFilter, C: Fn(Query, &mut World)> QuerySystem<F, C> {
    /// Create a new [QuerySystem]
    pub const fn new(callback: C) -> Self {
        Self {
            callback,
            _marker: PhantomData,
        }
    }
}

impl<F: ToFilter, C: Fn(Query, &mut World)> System for QuerySystem<F, C>
where
    Self: 'static,
{
    fn run(&self, world: &mut World) {
        let query = world.query::<F>();
        (self.callback)(query, world);
    }
}

/// Manages systems for a [World] in multiple runlevels
pub struct SystemManager {
    /// The World
    pub world: World,
    runlevels: IndexMap<usize, SparseSet<Box<dyn System>>>,
}

impl SystemManager {
    /// Create new [SystemManager]
    pub fn new(world: World) -> Self {
        SystemManager {
            world,
            runlevels: IndexMap::with_capacity(2),
        }
    }

    /// Return whether runlevel `level` exists
    pub fn has_runlevel(&self, level: usize) -> bool {
        self.runlevels.contains_key(&level)
    }

    /// Add a [System] to runlevel `level`, return the system id
    pub fn add_system<S: System>(&mut self, level: usize, system: S) -> usize {
        self.runlevels
            .entry(level)
            .or_default()
            .insert(Box::new(system))
    }

    /// Remove a [System] from runlevel `level`
    pub fn remove_system<S: System>(&mut self, level: usize, system: usize) {
        self.runlevels.entry(level).or_default().remove(system);
    }

    /// Run systems of in runlevel `level`
    pub fn run_systems(&mut self, level: usize) {
        if let Some(systems) = self.runlevels.get(&level) {
            for s in systems {
                s.value.run(&mut self.world);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        Exclude, World, component,
        system::{QuerySystem, SystemManager},
    };

    #[allow(dead_code)]
    struct Tag(i32);
    component!(Tag);

    struct Hello;
    component!(Hello);

    #[test]
    fn basic_query() {
        let mut manager = SystemManager::new(World::new());

        for i in 0..10 {
            let e = manager.world.spawn();
            manager.world.add(e, Tag(32));

            if i % 2 == 0 {
                manager.world.add(e, Hello);
            }
        }

        manager.add_system(
            0,
            QuerySystem::<(Tag, Exclude<(Hello,)>)>::new(|query, world| {
                let _ = world;
                println!("{:?}", query.entities());
            }),
        );

        manager.run_systems(0);
        manager.run_systems(1); // runlevel does not exist
    }
}