fix: remove layers and pick uniform coordinate system (#56)

Author: ssouthcity

assets/sprites/logistics/porter.aseprite

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cf813c21d758de7bb0572d50c2023150e92d00a021e3c0e957f13cb640590d42
+oid sha256:9915c212d99d875deda657ca774e3206d96f1b7b5b638244643ddbac805e6d74
 size 3341

src/gameplay/logistics/path.rs

@@ -8,11 +8,7 @@ use crate::gameplay::{
     world::{
         construction::{Constructions, StructureConstructed},
         demolition::{Demolishable, Demolished},
-        tilemap::{
-            TILE_OFFSET,
-            coord::{Coord, CoordOffset},
-            map::TileClicked,
-        },
+        tilemap::{TILE_OFFSET, coord::Coord, map::TileClicked},
     },
 };
 
@@ -65,13 +61,12 @@ fn spawn_path(
             .spawn((
                 Name::new("Path"),
                 Pathable::walkable(),
+                Coord::new(coord.x, coord.y),
                 Sprite::sized(TILE_OFFSET),
                 AseSlice {
                     aseprite: asset_server.load("sprites/logistics/path_segments.aseprite"),
                     name: "C".into(),
                 },
-                Coord::new(coord.x, coord.y),
-                CoordOffset(Vec2::new(0.0, -32.0)),
                 YSortSprite,
                 ZIndexSprite(9),
                 Demolishable,

src/gameplay/logistics/porter.rs

@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, sprite::Anchor};
 use bevy_aseprite_ultra::prelude::{Animation, AseAnimation};
 
 use crate::gameplay::{
@@ -90,6 +90,7 @@ fn spawn_porter(
             Name::new("Porter"),
             *transform,
             Sprite::default(),
+            Anchor::BOTTOM_CENTER,
             AseAnimation {
                 aseprite: asset_server.load("sprites/logistics/porter.aseprite"),
                 animation: Animation::tag("idle"),

src/gameplay/world/construction.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use bevy::prelude::*;
+use bevy::{prelude::*, sprite::Anchor};
 use bevy_aseprite_ultra::prelude::*;
 use bevy_ecs_tilemap::tiles::TilePos;
 
@@ -175,6 +175,7 @@ fn construct(
             .spawn((
                 Name::new(structure.name.clone()),
                 Coord::new(tile_click.0.x, tile_click.0.y),
+                Anchor(Vec2::new(0.0, -0.25)),
                 Sprite::default(),
                 AseAnimation {
                     aseprite: asset_server

src/gameplay/world/deposit.rs

@@ -1,4 +1,4 @@
-use bevy::{asset::LoadedFolder, prelude::*};
+use bevy::{asset::LoadedFolder, prelude::*, sprite::Anchor};
 use bevy_ecs_tilemap::tiles::TilePos;
 use rand::Rng;
 use serde::Deserialize;
@@ -76,6 +76,7 @@ fn spawn_deposits(
                 .spawn((
                     Name::new(deposit.name.clone()),
                     Coord::new(tile_pos.x, tile_pos.y),
+                    Anchor(Vec2::new(0.0, -0.25)),
                     YSortSprite,
                     ZIndexSprite(10),
                     Sprite {

src/gameplay/world/tilemap/chunk.rs

@@ -2,12 +2,9 @@ use bevy::prelude::*;
 use bevy_ecs_tilemap::prelude::*;
 
 use crate::{
-    gameplay::{
-        sprite_sort::ZIndexSprite,
-        world::{
-            WorldSpawnSystems,
-            tilemap::{CHUNK_SIZE, TILE_OFFSET, TILE_SIZE},
-        },
+    gameplay::world::{
+        WorldSpawnSystems,
+        tilemap::{CHUNK_SIZE, TILE_OFFSET, TILE_SIZE},
     },
     screens::Screen,
 };
@@ -25,73 +22,45 @@ pub fn plugin(app: &mut App) {
 #[reflect(Component)]
 pub struct Chunk;
 
-#[derive(Component, Reflect, Debug)]
-#[reflect(Component)]
-#[relationship_target(relationship = LayerOf)]
-pub struct Layers(Vec<Entity>);
-
-#[derive(Component, Reflect, Debug)]
-#[reflect(Component)]
-#[relationship(relationship_target = Layers)]
-pub struct LayerOf(pub Entity);
-
 fn spawn_chunk(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let chunk_id = commands
-        .spawn((
-            Name::new("Chunk"),
-            Chunk,
-            Transform::default(),
-            Visibility::default(),
-        ))
-        .id();
+    let map_size = TilemapSize::from(CHUNK_SIZE);
+    let tile_size = TilemapTileSize::from(TILE_SIZE);
+    let grid_size = TilemapGridSize::from(TILE_OFFSET);
+    let storage = TileStorage::empty(map_size);
 
-    for i in 0..5 {
-        let map_size = TilemapSize::from(CHUNK_SIZE);
-        let tile_size = TilemapTileSize::from(TILE_SIZE);
-        let grid_size = TilemapGridSize::from(TILE_OFFSET);
-        let storage = TileStorage::empty(map_size);
-
-        commands.spawn((
-            Name::new(format!("Layer {i}")),
-            LayerOf(chunk_id),
-            ChildOf(chunk_id),
-            ZIndexSprite(i),
-            TilemapBundle {
-                transform: Transform::from_xyz(0.0, grid_size.y / 2.0 * i as f32, 0.0),
-                grid_size,
-                size: map_size,
-                storage,
-                texture: TilemapTexture::Single(asset_server.load("tiles/grass.png")),
-                tile_size,
-                map_type: TilemapType::Isometric(IsoCoordSystem::Diamond),
-                anchor: TilemapAnchor::Center,
-                render_settings: TilemapRenderSettings {
-                    render_chunk_size: UVec2::new(map_size.x, 1),
-                    y_sort: true,
-                },
-                ..default()
+    commands.spawn((
+        Name::new("Chunk"),
+        Chunk,
+        TilemapBundle {
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
+            grid_size,
+            size: map_size,
+            storage,
+            texture: TilemapTexture::Single(asset_server.load("tiles/grass.png")),
+            tile_size,
+            map_type: TilemapType::Isometric(IsoCoordSystem::Diamond),
+            anchor: TilemapAnchor::Center,
+            render_settings: TilemapRenderSettings {
+                render_chunk_size: UVec2::new(map_size.x, 1),
+                y_sort: true,
             },
-        ));
-    }
+            ..default()
+        },
+    ));
 }
 
 fn spawn_flat_ground(
     mut commands: Commands,
-    chunk_layers: Single<&Layers, With<Chunk>>,
-    mut tile_storage_query: Query<&mut TileStorage>,
+    chunk_query: Query<(Entity, &mut TileStorage), With<Chunk>>,
 ) {
-    for (i, layer) in chunk_layers.iter().enumerate().take(4) {
-        let Ok(mut tile_storage) = tile_storage_query.get_mut(layer) else {
-            continue;
-        };
-
+    for (chunk_entity, mut chunk_tile_storage) in chunk_query {
         fill_tilemap_rect(
             TileTextureIndex(0),
             TilePos::new(0, 0),
-            TilemapSize::from(CHUNK_SIZE / (i + 1) as u32),
-            TilemapId(layer),
+            TilemapSize::from(CHUNK_SIZE),
+            TilemapId(chunk_entity),
             &mut commands,
-            &mut tile_storage,
+            &mut chunk_tile_storage,
         );
     }
 }

src/gameplay/world/tilemap/coord.rs

@@ -1,10 +1,7 @@
 use bevy::prelude::*;
 use bevy_ecs_tilemap::prelude::*;
 
-use crate::gameplay::{
-    FactorySystems,
-    world::tilemap::chunk::{Chunk, Layers},
-};
+use crate::gameplay::{FactorySystems, world::tilemap::chunk::Chunk};
 
 pub fn plugin(app: &mut App) {
     app.add_systems(
@@ -17,10 +14,6 @@ pub fn plugin(app: &mut App) {
 #[reflect(Component)]
 pub struct Coord(pub UVec2);
 
-#[derive(Component, Reflect, Debug, Default, Deref, DerefMut)]
-#[reflect(Component)]
-pub struct CoordOffset(pub Vec2);
-
 impl Coord {
     pub fn new(x: u32, y: u32) -> Self {
         Self(UVec2 { x, y })
@@ -29,9 +22,8 @@ impl Coord {
 
 #[allow(clippy::type_complexity)]
 fn translate_coord_to_transform(
-    coord_query: Query<(&mut Transform, &Coord, Option<&CoordOffset>), Changed<Coord>>,
-    chunk_query: Single<&Layers, With<Chunk>>,
-    tile_storage_query: Query<&TileStorage>,
+    coord_query: Query<(&mut Transform, &Coord), Changed<Coord>>,
+    chunk_entity: Single<Entity, With<Chunk>>,
     tilemap_query: Query<
         (
             &Transform,
@@ -44,19 +36,11 @@ fn translate_coord_to_transform(
         Without<Coord>,
     >,
 ) {
-    for (mut transform, coord, coord_offset) in coord_query {
+    for (mut transform, coord) in coord_query {
         let tile_pos = TilePos::new(coord.x, coord.y);
 
-        let Some(layer) = chunk_query.iter().find(|layer| {
-            tile_storage_query
-                .get(*layer)
-                .is_ok_and(|storage| storage.get(&tile_pos).is_none())
-        }) else {
-            continue;
-        };
-
         let Ok((tilemap_transform, map_size, grid_size, tile_size, map_type, anchor)) =
-            tilemap_query.get(layer)
+            tilemap_query.get(*chunk_entity)
         else {
             continue;
         };
@@ -65,10 +49,7 @@ fn translate_coord_to_transform(
             .center_in_world(map_size, grid_size, tile_size, map_type, anchor)
             .extend(0.0);
 
-        let z = transform.translation.z;
-        transform.translation = tile_translation
-            + tilemap_transform.translation
-            + coord_offset.map(|co| co.0).unwrap_or_default().extend(0.0);
-        transform.translation.z = z;
+        transform.translation =
+            tile_translation.with_z(0.0) + tilemap_transform.translation.with_z(0.0);
     }
 }

src/gameplay/world/tilemap/map.rs

@@ -6,10 +6,7 @@ use crate::{
         FactorySystems,
         world::{
             construction::ValidPlacement,
-            tilemap::{
-                chunk::{Chunk, Layers},
-                coord::Coord,
-            },
+            tilemap::{chunk::Chunk, coord::Coord},
         },
     },
     input::cursor::CursorPosition,
@@ -48,7 +45,7 @@ impl Default for HoveredTile {
 fn mark_highlighted_tile(
     cursor_position: Res<CursorPosition>,
     mut hovered_tile: ResMut<HoveredTile>,
-    chunk_query: Single<&Layers, With<Chunk>>,
+    chunk_entity: Single<Entity, With<Chunk>>,
     tilemap_query: Query<(
         &TilemapSize,
         &TilemapGridSize,
@@ -59,37 +56,33 @@ fn mark_highlighted_tile(
         &TilemapAnchor,
     )>,
 ) {
-    for layer in chunk_query.iter().rev() {
-        let Ok((map_size, grid_size, tile_size, map_type, tile_storage, map_transform, anchor)) =
-            tilemap_query.get(layer)
-        else {
-            continue;
-        };
-
-        let cursor_in_map_pos = {
-            let cursor_pos = Vec4::from((cursor_position.0, 0.0, 1.0));
-            let cursor_in_map_pos = map_transform.to_matrix().inverse() * cursor_pos;
-            cursor_in_map_pos.xy()
-        };
-
-        let Some(tile_pos) = TilePos::from_world_pos(
-            &cursor_in_map_pos,
-            map_size,
-            grid_size,
-            tile_size,
-            map_type,
-            anchor,
-        ) else {
-            continue;
-        };
-
-        if let Some(tile_entity) = tile_storage.get(&tile_pos) {
-            hovered_tile.0 = tile_entity;
-            return;
-        }
-    }
+    let Ok((map_size, grid_size, tile_size, map_type, tile_storage, map_transform, anchor)) =
+        tilemap_query.get(*chunk_entity)
+    else {
+        return;
+    };
+
+    let cursor_in_map_pos = {
+        let cursor_pos = Vec4::from((cursor_position.0, 0.0, 1.0));
+        let cursor_in_map_pos = map_transform.to_matrix().inverse() * cursor_pos;
+        cursor_in_map_pos.xy()
+    };
 
-    hovered_tile.0 = Entity::PLACEHOLDER;
+    let Some(tile_pos) = TilePos::from_world_pos(
+        &cursor_in_map_pos,
+        map_size,
+        grid_size,
+        tile_size,
+        map_type,
+        anchor,
+    ) else {
+        hovered_tile.0 = Entity::PLACEHOLDER;
+        return;
+    };
+
+    if let Some(tile_entity) = tile_storage.get(&tile_pos) {
+        hovered_tile.0 = tile_entity;
+    }
 }
 
 fn highlight_hovered_tile(