archetype_ecs 1.2.0

Archetype ECS - High-performance Entity Component System with parallel execution
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
144
145
146
147
148
149
150
151
152
153

use crate::entity::EntityId;
use serde::{Deserialize, Serialize};

/// Parent relationship component
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Parent(pub EntityId);

impl Parent {
    pub fn new(parent_id: EntityId) -> Self {
        Self(parent_id)
    }

    pub fn entity_id(&self) -> EntityId {
        self.0
    }
}

/// Children relationship component
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Children {
    children: Vec<EntityId>,
}

impl Children {
    pub fn new() -> Self {
        Self {
            children: Vec::new(),
        }
    }

    pub fn add_child(&mut self, child: EntityId) {
        if !self.children.contains(&child) {
            self.children.push(child);
        }
    }

    pub fn remove_child(&mut self, child: EntityId) -> bool {
        if let Some(pos) = self.children.iter().position(|&c| c == child) {
            self.children.remove(pos);
            true
        } else {
            false
        }
    }

    pub fn contains(&self, child: EntityId) -> bool {
        self.children.contains(&child)
    }

    pub fn iter(&self) -> impl Iterator<Item = &EntityId> {
        self.children.iter()
    }

    pub fn len(&self) -> usize {
        self.children.len()
    }

    pub fn is_empty(&self) -> bool {
        self.children.is_empty()
    }

    pub fn clear(&mut self) {
        self.children.clear();
    }

    pub fn get_children(&self) -> Vec<EntityId> {
        self.children.clone()
    }
}

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

/// Tracks if transform changed (for dirty propagation)
#[derive(Clone, Copy, Debug)]
pub struct TransformChanged {
    pub changed: bool,
}

impl TransformChanged {
    pub fn new(changed: bool) -> Self {
        Self { changed }
    }

    pub fn mark_changed(&mut self) {
        self.changed = true;
    }

    pub fn clear(&mut self) {
        self.changed = false;
    }

    pub fn is_changed(&self) -> bool {
        self.changed
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::world::World;

    #[test]
    fn test_children_management() {
        let mut world = World::new();
        let id1 = world.spawn_entity((crate::transform::LocalTransform::identity(),));
        let id2 = world.spawn_entity((crate::transform::LocalTransform::identity(),));

        let mut children = Children::new();
        children.add_child(id1);
        assert!(children.contains(id1));
        assert_eq!(children.len(), 1);

        children.add_child(id2);
        assert_eq!(children.len(), 2);

        children.remove_child(id1);
        assert!(!children.contains(id1));
        assert_eq!(children.len(), 1);
    }

    #[test]
    fn test_children_no_duplicates() {
        let mut world = World::new();
        let id = world.spawn_entity((crate::transform::LocalTransform::identity(),));

        let mut children = Children::new();
        children.add_child(id);
        children.add_child(id); // Add same child twice
        assert_eq!(children.len(), 1); // Should still be 1
    }

    #[test]
    fn test_transform_changed() {
        let mut changed = TransformChanged::new(false);
        assert!(!changed.is_changed());

        changed.mark_changed();
        assert!(changed.is_changed());

        changed.clear();
        assert!(!changed.is_changed());
    }
}