bevy_cells 0.1.1

Bevy library for working with entities in grids.
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

use bevy::{
    ecs::{bundle::Bundle, entity::Entity, system::Command, world::World},
    utils::HashMap,
};
use bimap::BiMap;

use crate::prelude::{commands::insert_cell_batch, CellMapLabel};

use super::take_cell_batch;

pub struct SpawnCellBatch<L, F, B, IC, const N: usize = 2>
where
    L: CellMapLabel + Send + 'static,
    F: Fn([isize; N]) -> B + Send + 'static,
    B: Bundle + Send + 'static,
    IC: IntoIterator<Item = [isize; N]> + Send + 'static,
{
    pub cell_cs: IC,
    pub bundle_f: F,
    pub label: std::marker::PhantomData<L>,
}

impl<L, F, B, IC, const N: usize> Command for SpawnCellBatch<L, F, B, IC, N>
where
    L: CellMapLabel + Send + 'static,
    F: Fn([isize; N]) -> B + Send + 'static,
    B: Bundle + Send + 'static,
    IC: IntoIterator<Item = [isize; N]> + Send + 'static,
{
    fn apply(self, world: &mut World) {
        let (cell_cs, bundles): (Vec<[isize; N]>, Vec<B>) = self
            .cell_cs
            .into_iter()
            .map(|coord| (coord, (self.bundle_f)(coord)))
            .unzip();

        let cells = cell_cs
            .into_iter()
            .zip(world.spawn_batch(bundles))
            .collect::<Vec<([isize; N], Entity)>>();

        insert_cell_batch::<L, N>(world, cells);
    }
}

pub struct DespawnCellBatch<L, IC, const N: usize = 2>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = [isize; N]> + Send + 'static,
{
    pub cell_cs: IC,
    pub label: std::marker::PhantomData<L>,
}

impl<L, IC, const N: usize> Command for DespawnCellBatch<L, IC, N>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = [isize; N]> + Send + 'static,
{
    fn apply(self, world: &mut World) {
        for (_, cell_id) in take_cell_batch::<L, N>(world, self.cell_cs) {
            world.despawn(cell_id);
        }
    }
}

pub struct MoveCellBatch<L, IC, const N: usize = 2>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = ([isize; N], [isize; N])> + Send + 'static,
{
    pub cell_cs: IC,
    pub label: std::marker::PhantomData<L>,
}

impl<L, IC, const N: usize> Command for MoveCellBatch<L, IC, N>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = ([isize; N], [isize; N])> + Send + 'static,
{
    fn apply(self, world: &mut World) {
        const ERR_MESSAGE: &str =
            "Couldn't find cell coord in batch move.  Maybe repeated cell coord in command.";

        let mut cell_cs = self
            .cell_cs
            .into_iter()
            .collect::<HashMap<[isize; N], [isize; N]>>();

        let removed =
            take_cell_batch::<L, N>(world, cell_cs.keys().cloned().collect::<Vec<[isize; N]>>())
                .into_iter()
                .map(|(cell_c, cell_id)| (cell_cs.remove(&cell_c).expect(ERR_MESSAGE), cell_id));

        insert_cell_batch::<L, N>(world, removed);
    }
}

pub struct SwapCellBatch<L, IC, const N: usize = 2>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = ([isize; N], [isize; N])> + Send + 'static,
{
    pub cell_cs: IC,
    pub label: std::marker::PhantomData<L>,
}

impl<L, IC, const N: usize> Command for SwapCellBatch<L, IC, N>
where
    L: CellMapLabel + Send + 'static,
    IC: IntoIterator<Item = ([isize; N], [isize; N])> + Send + 'static,
{
    fn apply(self, world: &mut World) {
        const ERR_MESSAGE: &str =
            "Couldn't find cell coord in batch move.  Maybe repeated cell coord in command.";

        let cell_cs = self
            .cell_cs
            .into_iter()
            .collect::<BiMap<[isize; N], [isize; N]>>();

        let removed_left = take_cell_batch::<L, N>(
            world,
            cell_cs.left_values().cloned().collect::<Vec<[isize; N]>>(),
        )
        .into_iter()
        .map(|(cell_c, cell_id)| (*cell_cs.get_by_left(&cell_c).expect(ERR_MESSAGE), cell_id));

        let removed_right = take_cell_batch::<L, N>(
            world,
            cell_cs.right_values().cloned().collect::<Vec<[isize; N]>>(),
        )
        .into_iter()
        .map(|(cell_c, cell_id)| (*cell_cs.get_by_right(&cell_c).expect(ERR_MESSAGE), cell_id));

        insert_cell_batch::<L, N>(world, removed_left.chain(removed_right));
    }
}