ecs/src/actions.rs


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

use std::any::Any;

use crate::component::{Component, Sequence as ComponentSequence};
use crate::system::{NoInitParamFlag, Param as SystemParam, System};
use crate::tuple::FilterExclude as TupleFilterExclude;
use crate::WorldData;

/// Used to to queue up actions for a [`World`] to perform.
#[derive(Debug)]
pub struct Actions<'world>
{
    world_data: &'world WorldData,
}

impl<'world> Actions<'world>
{
    /// Adds a spawning a new entity to the action queue.
    ///
    /// # Panics
    /// Will panic if a mutable internal lock cannot be acquired.
    pub fn spawn<Comps: ComponentSequence>(&mut self, components: Comps)
    {
        self.world_data
            .action_queue
            .write_nonblock()
            .expect("Failed to aquire read-write action queue lock")
            .push(Action::Spawn(components.into_vec()));
    }
}

unsafe impl<'world> SystemParam<'world> for Actions<'world>
{
    type Flags = NoInitParamFlag;
    type Input = TupleFilterExclude;

    fn initialize<SystemImpl>(
        _system: &mut impl System<'world, SystemImpl>,
        _input: Self::Input,
    )
    {
    }

    fn new<SystemImpl>(
        _system: &'world impl System<'world, SystemImpl>,
        world_data: &'world WorldData,
    ) -> Self
    {
        Self { world_data }
    }

    fn is_compatible<Other: SystemParam<'world>>() -> bool
    {
        let other_comparable = Other::get_comparable();

        other_comparable.downcast_ref::<Comparable>().is_none()
    }

    fn get_comparable() -> Box<dyn Any>
    {
        Box::new(())
    }
}

/// A action for a [`System`] to perform.
#[derive(Debug)]
pub(crate) enum Action
{
    Spawn(Vec<Box<dyn Component>>),
}

struct Comparable;