bevy_sparse_tilemap 0.4.0

A Tilemap crate for the Bevy game engine with a focus on large map sizes and ECS sparse maps
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

use bevy::{math::IVec2, prelude::Component};
use lettuces::cell::Cell;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};

#[cfg(feature = "reflect")]
use bevy::ecs::reflect::ReflectMapEntities;
#[cfg(feature = "reflect")]
use bevy::prelude::{Reflect, ReflectComponent};

/// The position of a [`Chunk`](crate::map::chunk::Chunk) in the [`Tilemap`](crate::map::Tilemap)
///
/// A [`Cell`] can be converted into a [`ChunkPos`] using [`MapData::into_chunk_pos`](crate::map::MapData::into_chunk_pos())
/// The position of a tile in a [`Tilemap`](crate::map::Tilemap)
#[derive(Default, Eq, Hash, PartialEq, Copy, Clone, Debug, Component)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "reflect", derive(Reflect))]
#[cfg_attr(feature = "reflect", reflect(Component, Hash))]
pub struct ChunkPos(Cell);

impl ChunkPos {
    /// Constructs a new TilePos from the given x and y
    pub fn new(x: i32, y: i32) -> ChunkPos {
        Self(Cell { x, y })
    }
    /// Returns the x position of Self
    pub fn x(&self) -> i32 {
        self.0.x
    }
    /// Returns the y position of Self
    pub fn y(&self) -> i32 {
        self.0.y
    }
}

impl From<IVec2> for ChunkPos {
    fn from(value: IVec2) -> Self {
        Self(Cell {
            x: value.x,
            y: value.y,
        })
    }
}

impl From<(usize, usize)> for ChunkPos {
    fn from(value: (usize, usize)) -> Self {
        Self(Cell {
            x: value.0 as i32,
            y: value.1 as i32,
        })
    }
}

impl Display for ChunkPos {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("x:{}, y:{}", self.0.x, self.0.y))
    }
}