conniecs 0.2.0

A simple ECS system based off of the `ecs` crate, but with some minor API adjustments and derive macros for implementing most of the boilerplate. Make sure to include the `conniecs-derive` crate as well.
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

//! TODO: Add documentation including describing how the derive macros work

use time;

use std::ops::{Deref, DerefMut};

use crate::entity::EntityData;
use crate::system::{Process, System};
use crate::world::DataHelper;

pub trait SystemInterval: System {
    fn create_interval() -> TickerState;
}

#[derive(Copy, Clone, Debug)]
pub struct IntervalSystem<T>
where
    T: SystemInterval,
{
    pub inner: T,
    pub ticker: TickerState,
}

impl<T> Deref for IntervalSystem<T>
where
    T: SystemInterval,
{
    type Target = T;
    fn deref(&self) -> &T {
        &self.inner
    }
}

impl<T> DerefMut for IntervalSystem<T>
where
    T: SystemInterval,
{
    fn deref_mut(&mut self) -> &mut T {
        &mut self.inner
    }
}

impl<T> System for IntervalSystem<T>
where
    T: SystemInterval,
{
    type Components = T::Components;
    type Services = T::Services;

    fn build_system() -> Self {
        IntervalSystem {
            inner: T::build_system(),
            ticker: T::create_interval(),
        }
    }

    fn activated(
        &mut self,
        entity: EntityData<T::Components>,
        components: &T::Components,
        services: &mut T::Services,
    ) {
        self.inner.activated(entity, components, services);
    }

    fn reactivated(
        &mut self,
        entity: EntityData<T::Components>,
        components: &T::Components,
        services: &mut T::Services,
    ) {
        self.inner.reactivated(entity, components, services);
    }

    fn deactivated(
        &mut self,
        entity: EntityData<T::Components>,
        components: &T::Components,
        services: &mut T::Services,
    ) {
        self.inner.deactivated(entity, components, services);
    }
}

impl<T> Process for IntervalSystem<T>
where
    T: Process + SystemInterval,
{
    fn process(&mut self, data: &mut DataHelper<T::Components, T::Services>) {
        if self.ticker.tick() {
            self.inner.process(data);
        }
    }
}

#[derive(Copy, Clone, Debug)]
pub enum TickerState {
    Frames {
        interval: u64,
        ticks: u64,
    },
    Timed {
        interval: u64,
        next_tick: Option<u64>,
    },
}

impl TickerState {
    pub fn tick(&mut self) -> bool {
        match *self {
            TickerState::Frames {
                interval,
                ref mut ticks,
            } => {
                *ticks += 1;
                if *ticks >= interval {
                    *ticks = 0;
                    true
                } else {
                    false
                }
            }
            TickerState::Timed {
                interval,
                ref mut next_tick,
            } => {
                let now = time::precise_time_ns();
                let next_tick = match next_tick {
                    &mut Some(ref mut tick) => tick,
                    next_tick => {
                        *next_tick = Some(now + interval);
                        return false;
                    }
                };

                if now >= *next_tick {
                    *next_tick += interval;
                    true
                } else {
                    false
                }
            }
        }
    }
}