daedelecs 0.1.0

A Memory Safe, Type-Checked ECS System written 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
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

use crate::entity_builder::EntityBuilder;
use crate::Component;
use std::any::{Any, TypeId};
use std::cell::{Ref, RefCell, RefMut};
use std::collections::HashMap;
use std::ops::Deref;
use std::rc::Rc;

pub struct Entity {
    pub(crate) components: HashMap<TypeId, Rc<RefCell<dyn Component>>>,
    pub(crate) identifier: usize
}

impl Entity {

    /// Creates an `EntityBuilder` to construct an Entity.
    pub fn builder() -> EntityBuilder {
        EntityBuilder::new()
    }
    /// Attempts to get a reference to a component of a specified type from an entity.
    /// Will Return `None` if no such component is associated with the entity.
    /// Will Return `Some(&Entity)` if it does exist.
    /// Will never panic.
    pub fn get_component<C: Component>(&self) -> Option<Ref<C>> {
        if let Some(component_reference) = self.components.get(&TypeId::of::<C>()) {
            let borrowed = component_reference.borrow();
            if (borrowed.deref() as &dyn Any).is::<C>() {
                Some(Ref::map(borrowed, |comp| {
                    (comp as &dyn Any).downcast_ref::<C>().expect(&format!(
                        "Entity must have Component {:?}",
                        TypeId::of::<C>()
                    ))
                }))
            } else {
                None
            }
        } else {
            None
        }
    }
    /// Attempts to get a mutable reference to a component of a specified type from an entity.
    /// Will Return `None` if no such component is associated with the entity.
    /// Will Return `Some(&mut Entity)` if it does exist.
    /// Will never panic.
    pub fn get_mut_component<C: Component>(&mut self) -> Option<RefMut<C>> {
        if let Some(component_reference) = self.components.get_mut(&TypeId::of::<C>()) {
            let borrowed = component_reference.borrow_mut();
            if (borrowed.deref() as &dyn Any).is::<C>() {
                Some(RefMut::map(borrowed, |comp| {
                    (comp as &mut dyn Any).downcast_mut::<C>().expect(&format!(
                        "Trait must have Component {:?}",
                        TypeId::of::<C>()
                    ))
                }))
            } else {
                None
            }
        } else {
            None
        }
    }
    pub(crate) fn add_component<C: Component>(&mut self, component: C) {
        if let Some(_value) = self
            .components
            .insert(TypeId::of::<C>(), Rc::new(RefCell::new(component)))
        {
            panic!("Attempted to Overwrite a Component with another of the same type.");
        }
    }
}
impl PartialEq for Entity {
    fn eq(&self, other: &Self) -> bool {
        self.identifier == other.identifier
    }
}