xanadu 0.0.5

A toy ECS 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
121
122
123
124
125
126
127
128
129
130
131

use std::{any::TypeId, collections::HashMap};

use crate::collections::{GenerationalId, GenerationalVec, SparseVec, TypeErasedSparseVec};

use super::{Component, Query, System};

pub struct WorldBuilder {
    world: World,
}

impl WorldBuilder {
    pub fn new() -> Self {
        Self {
            world: World::new(),
        }
    }

    pub fn register_component<T: Component>(mut self) -> Self {
        self.world.register_component::<T>();
        self
    }

    pub fn build(self) -> World {
        self.world
    }
}

impl Default for WorldBuilder {
    fn default() -> Self {
        Self::new()
    }
}

pub struct World {
    entities: GenerationalVec<()>,
    component_arrays: HashMap<TypeId, TypeErasedSparseVec>,
}

impl World {
    pub(self) fn new() -> Self {
        Self {
            entities: GenerationalVec::new(),
            component_arrays: HashMap::new(),
        }
    }

    pub(self) fn register_component<T: Component>(&mut self) {
        self.component_arrays
            .insert(TypeId::of::<T>(), SparseVec::<T>::new().into());
    }

    pub fn builder() -> WorldBuilder {
        WorldBuilder::new()
    }

    pub fn new_entity(&mut self) -> GenerationalId {
        self.entities.add(())
    }

    /// エンティティにコンポーネントを追加する
    ///
    ///
    /// ## Returns
    ///
    /// 以前のコンポーネントがあればそれを返す。なければNoneを返す
    pub fn attach_component<T: Component>(
        &mut self,
        entity: GenerationalId,
        component: T,
    ) -> Option<T> {
        if let Some(array) = self.component_arrays.get_mut(&TypeId::of::<T>()) {
            if let Some(array) = array.downcast_mut::<T>() {
                return array.replace(entity.index, component);
            }
        }
        None
    }

    pub fn get_component_array<T: Component>(&self) -> Option<&SparseVec<T>> {
        self.component_arrays
            .get(&TypeId::of::<T>())
            .and_then(|any_array| any_array.downcast::<T>())
    }

    pub fn get_component_array_mut<T: Component>(&mut self) -> Option<&mut SparseVec<T>> {
        self.component_arrays
            .get_mut(&TypeId::of::<T>())
            .and_then(|any_array| any_array.downcast_mut::<T>())
    }

    pub fn execute<'world, Q, T>(&'world mut self, system: &'world impl System<'world, Q, T>)
    where
        Q: Query<'world, T>,
    {
        system.execute(self);
    }
}

impl Default for World {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn new() {
        let world = World::new();
        assert!(world.entities.is_empty());
        assert!(world.component_arrays.is_empty());
    }

    #[test]
    fn new_entity() {
        let mut world = World::new();
        let entity = world.new_entity();
        assert_eq!(world.entities.len(), 1);
        assert_eq!(world.entities.get(entity), Some(&()));
    }

    #[test]
    fn attach_component_return_value() {
        let mut world = World::builder().register_component::<i32>().build();
        let entity = world.new_entity();
        assert_eq!(world.attach_component(entity, 42), None);
        assert_eq!(world.attach_component(entity, 43), Some(42));
    }
}