sillyecs 0.0.6

A silly little compile-time generated archetype ECS in Rust
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

use crate::Name;
use crate::system::{System, SystemNameRef};
use serde::{Deserialize, Deserializer, Serialize};
use std::hash::Hash;
use std::ops::Deref;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct State {
    pub name: StateName,
    #[serde(default)]
    pub description: Option<String>,
    #[serde(skip_deserializing)]
    pub systems: Vec<SystemNameRef>,
}

impl State {
    pub(crate) fn finish(&mut self, systems: &[System]) {
        for system in systems {
            if system.states.iter().any(|s| s.name.eq(&self.name)) {
                self.systems.push(system.name.clone());
            }
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
#[serde(transparent)]
pub struct StateName(pub(crate) Name);

pub type StateNameRef = StateName;

impl Deref for StateName {
    type Target = Name;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'de> Deserialize<'de> for StateName {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let type_name = String::deserialize(deserializer)?;
        Ok(Self(Name::new(type_name, "State")))
    }
}