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

use aery::prelude::*;
use bevy::prelude::*;
use std::collections::HashMap;
use std::ops::Deref;

pub mod cell_query;
pub mod chunk_query;
pub mod commands;
pub mod coords;

// ===============
// Cell Components
// ===============

#[derive(Component, Debug)]
pub struct CellIndex(usize);

impl From<usize> for CellIndex {
    fn from(value: usize) -> Self {
        Self(value)
    }
}

impl Deref for CellIndex {
    type Target = usize;

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

#[derive(Component, Debug)]
pub struct CellCoord<const N: usize = 2>([isize; N]);

impl<const N: usize> CellCoord<N> {
    pub(crate) fn new(value: [isize; N]) -> Self {
        Self(value)
    }
}

impl<const N: usize> Deref for CellCoord<N> {
    type Target = [isize; N];

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

#[derive(Relation)]
#[aery(Recursive)]
pub struct InChunk<L, const N: usize>(std::marker::PhantomData<L>);

// ================
// Chunk Components
// ================

#[derive(Component, Debug, PartialEq, Eq, Hash)]
pub struct ChunkCoord<const N: usize = 2>([isize; N]);

impl<const N: usize> From<[isize; N]> for ChunkCoord<N> {
    fn from(value: [isize; N]) -> Self {
        Self(value)
    }
}

impl<const N: usize> Deref for ChunkCoord<N> {
    type Target = [isize; N];

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

#[derive(Component)]
pub struct Chunk {
    pub(crate) cells: Vec<Option<Entity>>,
}

impl Chunk {
    pub(crate) fn new(chunk_size: usize) -> Self {
        Self {
            cells: vec![None; chunk_size],
        }
    }
}

#[derive(Relation)]
#[aery(Recursive)]
pub struct InMap<L, const N: usize>(std::marker::PhantomData<L>);

// ==============
// Map Components
// ==============

/// Adds type level info on how a Cell Map should be treated.
pub trait CellMapLabel: Send + Sync {
    /// How many cells per dimension a chunk in this map extends.
    const CHUNK_SIZE: usize;
}

#[derive(Component)]
pub struct CellMap<L, const N: usize = 2>
where
    L: CellMapLabel + 'static,
{
    pub(crate) chunks: HashMap<ChunkCoord<N>, Entity>,
    label: std::marker::PhantomData<L>,
}

impl<L, const N: usize> Default for CellMap<L, N>
where
    L: CellMapLabel + 'static,
{
    fn default() -> Self {
        Self {
            chunks: Default::default(),
            label: Default::default(),
        }
    }
}