First push

jamescarterbell · Dec 18, 2023 · 7ef94f4 · 7ef94f4
1 parent f8c5fa3
commit 7ef94f4
Show file tree

Hide file tree

Showing 47 changed files with 613 additions and 3,340 deletions.
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,6 @@
+{
+    "rust-analyzer.linkedProjects": [
+        ".\\crates\\bevy_tiles_render\\Cargo.toml",
+        ".\\crates\\bevy_tiles\\Cargo.toml"
+    ]
+}
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,11 +24,13 @@ opt-level = 3
 aery = "0.5.1"
 bevy = {version = "0.12", default-features = false}
 rstest = "0.18.2"
+regex = "1.10.2"
+bimap = "0.6.3"
 
 [workspace.lints.clippy]
 type_complexity = "allow"
 undocumented_unsafe_blocks = "deny"
 all = "deny"
 
 [workspace.lints.rust]
-unused_imports = "deny"
+unused_imports = "warn"
diff --git a/README.md b/README.md
@@ -2,6 +2,9 @@
 
 A suite of tilemap plugins for [`bevy`](https://bevyengine.org/), focusing on ergonomics and ease of use.
 
+Expect crates in this suite to move a little bit slower than other tilemap crates, I have a busy schedule and a lot of the work here
+is meant to be exploration of API design posibilities, rather than aiming for immediate use.
+
 # Crates
 * [`bevy_tiles`](crates/bevy_tiles)
 [![Crates.io](https://img.shields.io/crates/v/bevy_tiles)](https://crates.io/crates/bevy_tiles)

diff --git a/crates/bevy_tiles/Cargo.toml b/crates/bevy_tiles/Cargo.toml
@@ -17,7 +17,7 @@ opt-level = 3
 [dependencies]
 aery = {workspace = true}
 bevy = {workspace = true}
-bimap = "0.6.3"
+bimap = {workspace = true}
 
 [dev-dependencies]
 rstest = {workspace = true}

diff --git a/crates/bevy_tiles/src/chunks.rs b/crates/bevy_tiles/src/chunks.rs
@@ -10,7 +10,7 @@ pub use chunk_query::*;
 /// An aery relation on chunks that point towards the map they are a part of.
 #[derive(Relation)]
 #[aery(Recursive)]
-pub struct InMap<L, const N: usize>(std::marker::PhantomData<L>);
+pub struct InMap;
 
 /// The coordinate of a given chunk.
 /// # Note
@@ -49,4 +49,9 @@ impl Chunk {
             tiles: vec![None; chunk_size],
         }
     }
+
+    /// Gets the total number of tiles this chunk can hold.
+    pub fn total_size(&self) -> usize {
+        self.tiles.len()
+    }
 }
diff --git a/crates/bevy_tiles/src/chunks/chunk_query.rs b/crates/bevy_tiles/src/chunks/chunk_query.rs
@@ -12,7 +12,7 @@ use bevy::{
 
 use crate::{
     chunks::ChunkCoord,
-    maps::{MapLabel, TileMap, TileMapLabel},
+    maps::{MapLabel, TileMapLabel, Tilemap},
     prelude::{calculate_chunk_coordinate, Chunk, CoordIterator, InMap},
 };
 
@@ -26,8 +26,8 @@ where
     Q: WorldQuery + 'static,
     F: ReadOnlyWorldQuery + 'static,
 {
-    chunk_q: Query<'w, 's, Q, (F, Relations<InMap<L, N>>, With<Chunk>)>,
-    map_q: Query<'w, 's, &'static TileMap<N>, With<MapLabel<L>>>,
+    chunk_q: Query<'w, 's, Q, (F, Relations<InMap>, With<Chunk>, With<MapLabel<L>>)>,
+    map_q: Query<'w, 's, &'static Tilemap<N>, With<MapLabel<L>>>,
 }
 
 impl<'w, 's, L, Q, F, const N: usize> Deref for ChunkQuery<'w, 's, L, Q, F, N>
@@ -36,7 +36,7 @@ where
     Q: WorldQuery + 'static,
     F: ReadOnlyWorldQuery + 'static,
 {
-    type Target = Query<'w, 's, Q, (F, Relations<InMap<L, N>>, With<Chunk>)>;
+    type Target = Query<'w, 's, Q, (F, Relations<InMap>, With<Chunk>, With<MapLabel<L>>)>;
 
     #[inline]
     fn deref(&self) -> &Self::Target {

diff --git a/crates/bevy_tiles/src/commands.rs b/crates/bevy_tiles/src/commands.rs
@@ -8,8 +8,8 @@ use std::{
 use crate::{
     maps::MapLabel,
     prelude::{
-        calculate_chunk_coordinate, calculate_tile_index, Chunk, ChunkCoord, InMap, TileMap,
-        TileMapLabel,
+        calculate_chunk_coordinate, calculate_tile_index, Chunk, ChunkCoord, InMap, TileMapLabel,
+        Tilemap,
     },
     tiles::{InChunk, TileCoord, TileIndex},
 };
@@ -240,7 +240,7 @@ where
 #[inline]
 fn spawn_or_remove_chunk<L, const N: usize>(
     world: &mut World,
-    map: &mut TileMap<N>,
+    map: &mut Tilemap<N>,
     map_id: Entity,
     chunk_c: [isize; N],
 ) -> (Entity, Chunk)
@@ -252,7 +252,7 @@ where
     } else {
         let chunk_id = world.spawn(ChunkCoord::from(chunk_c)).id();
         map.chunks.insert(chunk_c.into(), chunk_id);
-        Set::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
+        Set::<InMap>::new(chunk_id, map_id).apply(world);
         (chunk_id, Chunk::new(L::CHUNK_SIZE.pow(N as u32)))
     }
 }
@@ -261,7 +261,7 @@ where
 #[inline]
 fn remove_chunk<const N: usize>(
     world: &mut World,
-    map: &mut TileMap<N>,
+    map: &mut Tilemap<N>,
     chunk_c: [isize; N],
 ) -> Option<(Entity, Chunk)> {
     map.chunks
@@ -273,7 +273,7 @@ fn remove_chunk<const N: usize>(
 
 /// Takes the map out of the world or spawns a new one and returns the entity id to return the map to.
 #[inline]
-fn spawn_or_remove_map<L, const N: usize>(world: &mut World) -> (Entity, TileMap<N>)
+fn spawn_or_remove_map<L, const N: usize>(world: &mut World) -> (Entity, Tilemap<N>)
 where
     L: TileMapLabel + Send + 'static,
 {
@@ -283,19 +283,19 @@ where
     } else {
         (
             world.spawn(MapLabel::<L>::default()).id(),
-            TileMap::<N>::default(),
+            Tilemap::<N>::default(),
         )
     }
 }
 
 /// Takes the map out of the world if it exists.
 #[inline]
-fn remove_map<L, const N: usize>(world: &mut World) -> Option<(Entity, TileMap<N>)>
+fn remove_map<L, const N: usize>(world: &mut World) -> Option<(Entity, Tilemap<N>)>
 where
     L: TileMapLabel + Send + 'static,
 {
     world
-        .query_filtered::<Entity, (With<TileMap<N>>, With<MapLabel<L>>)>()
+        .query_filtered::<Entity, (With<Tilemap<N>>, With<MapLabel<L>>)>()
         .get_single_mut(world)
         .ok()
         .map(|map_id| {
@@ -304,7 +304,7 @@ where
                 world
                     .get_entity_mut(map_id)
                     .unwrap()
-                    .take::<TileMap<N>>()
+                    .take::<Tilemap<N>>()
                     .unwrap(),
             )
         })
@@ -331,12 +331,13 @@ where
         }
     }
 
-    Set::<InChunk<L, N>>::new(tile_id, chunk_id).apply(world);
+    Set::<InChunk>::new(tile_id, chunk_id).apply(world);
 
-    world
-        .get_entity_mut(tile_id)
-        .unwrap()
-        .insert((TileIndex::from(tile_i), TileCoord::<N>::new(tile_c)));
+    world.get_entity_mut(tile_id).unwrap().insert((
+        TileIndex::from(tile_i),
+        TileCoord::<N>::new(tile_c),
+        MapLabel::<L>::default(),
+    ));
 
     world.get_entity_mut(chunk_id).unwrap().insert(chunk);
     world.get_entity_mut(map_id).unwrap().insert(map);
@@ -369,9 +370,9 @@ where
         .and_then(|tile| tile.take())
         .and_then(|tile_id| world.get_entity_mut(tile_id))
     {
-        tile_e.remove::<(TileIndex, TileCoord)>();
+        tile_e.remove::<(TileIndex, TileCoord, MapLabel<L>)>();
         let tile_id = tile_e.id();
-        Unset::<InChunk<L, N>>::new(tile_id, chunk_id).apply(world);
+        Unset::<InChunk>::new(tile_id, chunk_id).apply(world);
         Some(tile_id)
     } else {
         None
@@ -412,12 +413,13 @@ pub fn insert_tile_batch<L, const N: usize>(
                 }
             }
 
-            Set::<InChunk<L, N>>::new(tile_id, chunk_id).apply(world);
+            Set::<InChunk>::new(tile_id, chunk_id).apply(world);
 
-            world
-                .get_entity_mut(tile_id)
-                .unwrap()
-                .insert((TileIndex::from(tile_i), TileCoord::<N>::new(tile_c)));
+            world.get_entity_mut(tile_id).unwrap().insert((
+                TileIndex::from(tile_i),
+                TileCoord::<N>::new(tile_c),
+                MapLabel::<L>::default(),
+            ));
         }
 
         world.get_entity_mut(chunk_id).unwrap().insert(chunk);
@@ -473,9 +475,9 @@ where
                 .and_then(|tile| tile.take())
                 .and_then(|tile_id| world.get_entity_mut(tile_id))
             {
-                tile_e.remove::<(TileIndex, TileCoord)>();
+                tile_e.remove::<(TileIndex, TileCoord, MapLabel<L>)>();
                 let tile_id = tile_e.id();
-                Unset::<InChunk<L, N>>::new(tile_id, chunk_id).apply(world);
+                Unset::<InChunk>::new(tile_id, chunk_id).apply(world);
                 tile_ids.push((tile_c, tile_id));
             }
         }
@@ -502,8 +504,9 @@ where
     world.get_entity_mut(chunk_id).unwrap().insert((
         Chunk::new(L::CHUNK_SIZE.pow(N as u32)),
         ChunkCoord::from(chunk_c),
+        MapLabel::<L>::default(),
     ));
-    Set::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
+    Set::<InMap>::new(chunk_id, map_id).apply(world);
     map.chunks.insert(chunk_c.into(), chunk_id);
 
     world.entity_mut(map_id).insert(map);
@@ -526,10 +529,10 @@ where
         .remove::<ChunkCoord<N>>(&chunk_c.into())
         .and_then(|chunk_id| world.get_entity_mut(chunk_id))
     {
-        chunk_e.remove::<(Chunk, ChunkCoord)>();
+        chunk_e.remove::<(Chunk, ChunkCoord, MapLabel<L>)>();
         let chunk_id = chunk_e.id();
-        Unset::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
-        Withdraw::<InChunk<L, N>>::new(chunk_id).apply(world);
+        Unset::<InMap>::new(chunk_id, map_id).apply(world);
+        Withdraw::<InChunk>::new(chunk_id).apply(world);
         Some(chunk_id)
     } else {
         None
@@ -557,13 +560,13 @@ where
         .remove::<ChunkCoord<N>>(&chunk_c.into())
         .and_then(|chunk_id| world.get_entity_mut(chunk_id))
     {
-        let (chunk, _) = chunk_e.take::<(Chunk, ChunkCoord)>().unwrap();
+        let (chunk, _, _) = chunk_e.take::<(Chunk, ChunkCoord, MapLabel<L>)>().unwrap();
         let chunk_id = chunk_e.id();
         for tile_id in chunk.tiles.into_iter().flatten() {
             world.despawn(tile_id);
         }
-        Unset::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
-        Withdraw::<InChunk<L, N>>::new(chunk_id).apply(world);
+        Unset::<InMap>::new(chunk_id, map_id).apply(world);
+        Withdraw::<InChunk>::new(chunk_id).apply(world);
         Some(chunk_id)
     } else {
         None
@@ -594,8 +597,9 @@ pub fn insert_chunk_batch<L, const N: usize>(
         world.get_entity_mut(chunk_id).unwrap().insert((
             Chunk::new(L::CHUNK_SIZE.pow(N as u32)),
             ChunkCoord::from(chunk_c),
+            MapLabel::<L>::default(),
         ));
-        Set::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
+        Set::<InMap>::new(chunk_id, map_id).apply(world);
         map.chunks.insert(chunk_c.into(), chunk_id);
     }
 
@@ -629,10 +633,10 @@ where
             .remove::<ChunkCoord<N>>(&chunk_c.into())
             .and_then(|chunk_id| world.get_entity_mut(chunk_id))
         {
-            chunk_e.remove::<(Chunk, ChunkCoord)>();
+            chunk_e.remove::<(Chunk, ChunkCoord, MapLabel<L>)>();
             let chunk_id = chunk_e.id();
-            Unset::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
-            Withdraw::<InChunk<L, N>>::new(chunk_id).apply(world);
+            Unset::<InMap>::new(chunk_id, map_id).apply(world);
+            Withdraw::<InChunk>::new(chunk_id).apply(world);
             chunk_ids.push((chunk_c, chunk_id));
         };
     }
@@ -666,13 +670,13 @@ where
             .remove::<ChunkCoord<N>>(&chunk_c.into())
             .and_then(|chunk_id| world.get_entity_mut(chunk_id))
         {
-            let (chunk, _) = chunk_e.take::<(Chunk, ChunkCoord)>().unwrap();
+            let (chunk, _, _) = chunk_e.take::<(Chunk, ChunkCoord, MapLabel<L>)>().unwrap();
             let chunk_id = chunk_e.id();
             for tile_id in chunk.tiles.into_iter().flatten() {
                 world.despawn(tile_id);
             }
-            Unset::<InMap<L, N>>::new(chunk_id, map_id).apply(world);
-            Withdraw::<InChunk<L, N>>::new(chunk_id).apply(world);
+            Unset::<InMap>::new(chunk_id, map_id).apply(world);
+            Withdraw::<InChunk>::new(chunk_id).apply(world);
             chunk_ids.push((chunk_c, chunk_id));
         };
     }

diff --git a/crates/bevy_tiles/src/commands/map.rs b/crates/bevy_tiles/src/commands/map.rs
@@ -2,7 +2,7 @@ use aery::edges::CheckedDespawn;
 use bevy::ecs::{entity::Entity, query::With, system::Command, world::World};
 
 use crate::{
-    maps::{MapLabel, TileMap},
+    maps::{MapLabel, Tilemap},
     prelude::TileMapLabel,
 };
 
@@ -16,7 +16,7 @@ where
 {
     fn apply(self, world: &mut World) {
         if let Ok(map_id) = world
-            .query_filtered::<Entity, (With<MapLabel<L>>, With<TileMap<N>>)>()
+            .query_filtered::<Entity, (With<MapLabel<L>>, With<Tilemap<N>>)>()
             .get_single(world)
         {
             CheckedDespawn(map_id).apply(world);

diff --git a/crates/bevy_tiles/src/lib.rs b/crates/bevy_tiles/src/lib.rs
@@ -22,7 +22,7 @@ pub mod maps;
 /// Provides tile level utilities.
 pub mod tiles;
 
-///
+/// Provides most of what you need to get started.
 pub mod prelude {
     pub use crate::commands::{TileCommandExt, TileCommands};
 

diff --git a/crates/bevy_tiles/src/maps.rs b/crates/bevy_tiles/src/maps.rs
@@ -13,8 +13,12 @@ pub trait TileMapLabel: Send + Sync + 'static {
     const CHUNK_SIZE: usize;
 }
 
+/// Marks an entity as being part of the tilemap.
+/// # Note
+/// Manually updating this value, adding it, or removing it from an entity may
+/// cause issues, please only mutate map information via commands.
 #[derive(Component)]
-pub(crate) struct MapLabel<L>(PhantomData<L>);
+pub struct MapLabel<L>(PhantomData<L>);
 
 impl<L> Default for MapLabel<L> {
     fn default() -> Self {
@@ -27,11 +31,11 @@ impl<L> Default for MapLabel<L> {
 /// Manually updating this value, adding it, or removing it from an entity may
 /// cause issues, please only mutate map information via commands.
 #[derive(Component)]
-pub struct TileMap<const N: usize = 2> {
+pub struct Tilemap<const N: usize = 2> {
     pub(crate) chunks: HashMap<ChunkCoord<N>, Entity>,
 }
 
-impl<const N: usize> Default for TileMap<N> {
+impl<const N: usize> Default for Tilemap<N> {
     fn default() -> Self {
         Self {
             chunks: Default::default(),

diff --git a/crates/bevy_tiles/src/tiles.rs b/crates/bevy_tiles/src/tiles.rs
@@ -40,6 +40,12 @@ impl<const N: usize> TileCoord<N> {
     }
 }
 
+impl<const N: usize> From<[isize; N]> for TileCoord<N> {
+    fn from(value: [isize; N]) -> Self {
+        Self(value)
+    }
+}
+
 impl<const N: usize> Deref for TileCoord<N> {
     type Target = [isize; N];
 
@@ -51,4 +57,4 @@ impl<const N: usize> Deref for TileCoord<N> {
 /// An aery relation on tiles that point towards the chunk they are a part of.
 #[derive(Relation)]
 #[aery(Recursive)]
-pub struct InChunk<L, const N: usize>(std::marker::PhantomData<L>);
+pub struct InChunk;