From 269686323ff77edbde182306733471172f31ef37 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Wed, 18 Dec 2024 17:01:21 +0200
Subject: [PATCH 01/16] feat(player): add ascension/descension

---
 src/floor/components.rs       | 14 ++++++++++++--
 src/floor/mod.rs              |  4 +++-
 src/floor/systems/mod.rs      |  2 ++
 src/maze/assets.rs            | 28 +++++++++++++++++++++++++---
 src/maze/triggers/spawn.rs    | 18 +++++++++++++++++-
 src/player/events.rs          | 10 ++++++++++
 src/player/mod.rs             |  4 +++-
 src/player/systems/ascend.rs  | 30 ++++++++++++++++++++++++++++++
 src/player/systems/descend.rs | 30 ++++++++++++++++++++++++++++++
 src/player/systems/mod.rs     |  9 ++++++---
 10 files changed, 138 insertions(+), 11 deletions(-)
 create mode 100644 src/player/systems/ascend.rs
 create mode 100644 src/player/systems/descend.rs

diff --git a/src/floor/components.rs b/src/floor/components.rs
index de73815..7f421d4 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -1,10 +1,10 @@
 use bevy::prelude::*;
 
-#[derive(Debug, Reflect, Component)]
+#[derive(Debug, Reflect, Component, Deref, DerefMut)]
 #[reflect(Component)]
 pub struct Floor(pub u8);
 
-#[derive(Debug, Reflect, Component)]
+#[derive(Debug, Reflect, Component, Deref, DerefMut)]
 #[reflect(Component)]
 pub struct TargetFloor(pub u8);
 
@@ -17,3 +17,13 @@ impl Default for Floor {
         Self(1)
     }
 }
+
+impl Floor {
+    pub fn increase(&self) -> Self {
+        Self(self.0.saturating_add(1))
+    }
+
+    pub fn decrease(&self) -> Self {
+        Self(self.0.saturating_sub(1).max(1))
+    }
+}
diff --git a/src/floor/mod.rs b/src/floor/mod.rs
index b071bcf..b0e8bc0 100644
--- a/src/floor/mod.rs
+++ b/src/floor/mod.rs
@@ -4,4 +4,6 @@ mod systems;
 
 use bevy::prelude::*;
 
-pub(super) fn plugin(_app: &mut App) {}
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins(systems::plugin);
+}
diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index 8b13789..5b1303d 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -1 +1,3 @@
+use bevy::prelude::*;
 
+pub(super) fn plugin(_app: &mut App) {}
diff --git a/src/maze/assets.rs b/src/maze/assets.rs
index 011d406..12d9872 100644
--- a/src/maze/assets.rs
+++ b/src/maze/assets.rs
@@ -1,5 +1,7 @@
+use crate::theme::palette::rose_pine::{LOVE, PINE};
+
 use super::resources::GlobalMazeConfig;
-use bevy::prelude::*;
+use bevy::{prelude::*, utils::HashMap};
 use std::f32::consts::FRAC_PI_2;
 
 const WALL_OVERLAP_MODIFIER: f32 = 1.25;
@@ -11,6 +13,7 @@ pub(crate) struct MazeAssets {
     pub(crate) wall_mesh: Handle<Mesh>,
     pub(crate) hex_material: Handle<StandardMaterial>,
     pub(crate) wall_material: Handle<StandardMaterial>,
+    pub(crate) custom_materials: HashMap<String, Handle<StandardMaterial>>,
 }
 
 impl MazeAssets {
@@ -19,6 +22,11 @@ impl MazeAssets {
         materials: &mut ResMut<Assets<StandardMaterial>>,
         global_config: &GlobalMazeConfig,
     ) -> MazeAssets {
+        let mut custom_materials = HashMap::new();
+        custom_materials.extend(vec![
+            ("LOVE".to_string(), materials.add(red_material())),
+            ("PINE".to_string(), materials.add(blue_material())),
+        ]);
         MazeAssets {
             hex_mesh: meshes.add(generate_hex_mesh(
                 global_config.hex_size,
@@ -30,6 +38,7 @@ impl MazeAssets {
             )),
             hex_material: materials.add(white_material()),
             wall_material: materials.add(Color::BLACK),
+            custom_materials,
         }
     }
 }
@@ -53,9 +62,8 @@ fn generate_square_mesh(depth: f32, wall_size: f32) -> Mesh {
     Mesh::from(rectangular_prism).rotated_by(rotation)
 }
 
-fn white_material() -> StandardMaterial {
+pub(crate) fn white_material() -> StandardMaterial {
     StandardMaterial {
-        base_color: Color::WHITE,
         emissive: LinearRgba::new(
             WHITE_EMISSION_INTENSITY,
             WHITE_EMISSION_INTENSITY,
@@ -65,3 +73,17 @@ fn white_material() -> StandardMaterial {
         ..default()
     }
 }
+
+pub(crate) fn red_material() -> StandardMaterial {
+    StandardMaterial {
+        emissive: LOVE.to_linear(),
+        ..default()
+    }
+}
+
+pub(crate) fn blue_material() -> StandardMaterial {
+    StandardMaterial {
+        emissive: PINE.to_linear(),
+        ..default()
+    }
+}
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index af25d4a..e7ed398 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -81,12 +81,28 @@ pub(super) fn spawn_single_hex_tile(
         HexOrientation::Flat => Quat::from_rotation_y(FRAC_PI_6), // 30 degrees rotation
     };
 
+    let material = match tile.pos() {
+        pos if pos == maze_config.start_pos => assets
+            .custom_materials
+            .get("PINE")
+            .cloned()
+            .to_owned()
+            .unwrap(),
+        pos if pos == maze_config.end_pos => assets
+            .custom_materials
+            .get("LOVE")
+            .cloned()
+            .to_owned()
+            .unwrap(),
+        _ => assets.hex_material.clone(),
+    };
+
     parent
         .spawn((
             Name::new(format!("Hex {}", tile)),
             Tile,
             Mesh3d(assets.hex_mesh.clone()),
-            MeshMaterial3d(assets.hex_material.clone()),
+            MeshMaterial3d(material),
             Transform::from_translation(world_pos).with_rotation(rotation),
         ))
         .with_children(|parent| spawn_walls(parent, assets, tile.walls(), global_config));
diff --git a/src/player/events.rs b/src/player/events.rs
index 953c8c9..04ed340 100644
--- a/src/player/events.rs
+++ b/src/player/events.rs
@@ -8,3 +8,13 @@ pub struct RespawnPlayer;
 
 #[derive(Debug, Event)]
 pub struct DespawnPlayer;
+
+#[derive(Debug, Event)]
+pub struct AscendPlayer {
+    pub floor: u8,
+}
+
+#[derive(Debug, Event)]
+pub struct DescendPlayer {
+    pub floor: u8,
+}
diff --git a/src/player/mod.rs b/src/player/mod.rs
index 480168d..624c110 100644
--- a/src/player/mod.rs
+++ b/src/player/mod.rs
@@ -6,13 +6,15 @@ mod triggers;
 
 use bevy::{ecs::system::RunSystemOnce, prelude::*};
 use components::Player;
-use events::{DespawnPlayer, RespawnPlayer, SpawnPlayer};
+use events::{AscendPlayer, DescendPlayer, DespawnPlayer, RespawnPlayer, SpawnPlayer};
 
 pub(super) fn plugin(app: &mut App) {
     app.register_type::<Player>()
         .add_event::<SpawnPlayer>()
         .add_event::<RespawnPlayer>()
         .add_event::<DespawnPlayer>()
+        .add_event::<AscendPlayer>()
+        .add_event::<DescendPlayer>()
         .add_plugins((triggers::plugin, systems::plugin));
 }
 
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
new file mode 100644
index 0000000..c20f01a
--- /dev/null
+++ b/src/player/systems/ascend.rs
@@ -0,0 +1,30 @@
+use bevy::prelude::*;
+
+use crate::{
+    floor::components::{CurrentFloor, Floor},
+    maze::components::MazeConfig,
+    player::{
+        components::{CurrentPosition, Player},
+        events::AscendPlayer,
+    },
+};
+
+pub(super) fn ascend_player(
+    query: Query<&CurrentPosition, With<Player>>,
+    maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
+    mut event_writer: EventWriter<AscendPlayer>,
+) {
+    let Ok((config, floor)) = maze_config_query.get_single() else {
+        warn!("No current floor configuration found");
+        return;
+    };
+
+    for current_hex in query.iter() {
+        if current_hex.0 == config.end_pos {
+            event_writer.send(AscendPlayer {
+                floor: *floor.increase(),
+            });
+            return;
+        }
+    }
+}
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
new file mode 100644
index 0000000..d03b67e
--- /dev/null
+++ b/src/player/systems/descend.rs
@@ -0,0 +1,30 @@
+use bevy::prelude::*;
+
+use crate::{
+    floor::components::{CurrentFloor, Floor},
+    maze::components::MazeConfig,
+    player::{
+        components::{CurrentPosition, Player},
+        events::DescendPlayer,
+    },
+};
+
+pub(super) fn descend_player(
+    query: Query<&CurrentPosition, With<Player>>,
+    maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
+    mut event_writer: EventWriter<DescendPlayer>,
+) {
+    let Ok((config, floor)) = maze_config_query.get_single() else {
+        warn!("No current floor configuration found");
+        return;
+    };
+
+    for current_hex in query.iter() {
+        if current_hex.0 == config.start_pos {
+            event_writer.send(DescendPlayer {
+                floor: *floor.decrease(),
+            });
+            return;
+        }
+    }
+}
diff --git a/src/player/systems/mod.rs b/src/player/systems/mod.rs
index 7d69b84..df081cd 100644
--- a/src/player/systems/mod.rs
+++ b/src/player/systems/mod.rs
@@ -1,17 +1,20 @@
+mod ascend;
+mod descend;
 mod input;
 mod movement;
 pub mod setup;
 
+use crate::maze::MazePluginLoaded;
+use ascend::ascend_player;
 use bevy::prelude::*;
+use descend::descend_player;
 use input::player_input;
 use movement::player_movement;
 
-use crate::maze::MazePluginLoaded;
-
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         Update,
-        (player_input, player_movement)
+        (player_input, player_movement, ascend_player, descend_player)
             .chain()
             .run_if(resource_exists::<MazePluginLoaded>),
     );

From de4989ccfbce4a74f68014287d58832c9ea14a59 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Wed, 18 Dec 2024 17:11:02 +0200
Subject: [PATCH 02/16] test(floor): add min/max tests

---
 Cargo.lock              | 166 ++++++++++++++++++++++++++++++++++++++++
 Cargo.toml              |   6 ++
 src/floor/components.rs |  30 +++++++-
 3 files changed, 198 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index efe3c3f..bd6bacb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2299,6 +2299,21 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -2306,6 +2321,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
@@ -2314,6 +2330,17 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.31"
@@ -2333,6 +2360,53 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
 [[package]]
 name = "fuzzy-matcher"
 version = "0.3.7"
@@ -3093,6 +3167,9 @@ dependencies = [
  "hexx",
  "log",
  "rand",
+ "rstest",
+ "rstest_reuse",
+ "test-log",
  "thiserror 2.0.6",
  "tracing",
 ]
@@ -3749,6 +3826,12 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "piper"
 version = "0.2.4"
@@ -4032,6 +4115,12 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "renderdoc-sys"
 version = "1.1.0"
@@ -4067,12 +4156,62 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
+[[package]]
+name = "rstest"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a2c585be59b6b5dd66a9d2084aa1d8bd52fbdb806eafdeffb52791147862035"
+dependencies = [
+ "futures",
+ "futures-timer",
+ "rstest_macros",
+ "rustc_version",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "825ea780781b15345a146be27eaefb05085e337e869bff01b4306a4fd4a9ad5a"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn",
+ "unicode-ident",
+]
+
+[[package]]
+name = "rstest_reuse"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3a8fb4672e840a587a66fc577a5491375df51ddb88f2a2c2a792598c326fe14"
+dependencies = [
+ "quote",
+ "rand",
+ "syn",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustix"
 version = "0.38.42"
@@ -4158,6 +4297,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2fdfc24bc566f839a2da4c4295b82db7d25a24253867d5c64355abb5799bdbe"
 
+[[package]]
+name = "semver"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
+
 [[package]]
 name = "send_wrapper"
 version = "0.6.0"
@@ -4401,6 +4546,27 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "test-log"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93"
+dependencies = [
+ "test-log-macros",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "test-log-macros"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
diff --git a/Cargo.toml b/Cargo.toml
index ed2c0c4..44b271b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,12 @@ bevy_egui = { version = "0.31", optional = true }
 thiserror = "2.0"
 anyhow = "1"
 
+[dev-dependencies]
+rstest = "0.23"
+rstest_reuse = "0.7"
+test-log = { version = "0.2.16", default-features = false, features = [
+  "trace",
+] }
 
 [features]
 default = [
diff --git a/src/floor/components.rs b/src/floor/components.rs
index 7f421d4..a44f17b 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -4,10 +4,6 @@ use bevy::prelude::*;
 #[reflect(Component)]
 pub struct Floor(pub u8);
 
-#[derive(Debug, Reflect, Component, Deref, DerefMut)]
-#[reflect(Component)]
-pub struct TargetFloor(pub u8);
-
 #[derive(Debug, Reflect, Component)]
 #[reflect(Component)]
 pub struct CurrentFloor;
@@ -27,3 +23,29 @@ impl Floor {
         Self(self.0.saturating_sub(1).max(1))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rstest::rstest;
+
+    #[rstest]
+    #[case(0, 1)]
+    #[case(1, 2)]
+    #[case(254, 255)]
+    #[case(255, 255)]
+    fn increase(#[case] input: u8, #[case] expected: u8) {
+        let floor = Floor(input);
+        assert_eq!(*floor.increase(), expected);
+    }
+
+    #[rstest]
+    #[case(0, 1)] // clamps to 1
+    #[case(1, 1)] // clamps to 1
+    #[case(2, 1)]
+    #[case(255, 254)]
+    fn decrease(#[case] input: u8, #[case] expected: u8) {
+        let floor = Floor(input);
+        assert_eq!(*floor.decrease(), expected);
+    }
+}

From 86bbee8cb82ab69f064ff2848d3e5d85ec168cee Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Wed, 18 Dec 2024 19:15:57 +0200
Subject: [PATCH 03/16] feat(floor): spawn next floor

---
 src/floor/events.rs           |  5 +++++
 src/floor/mod.rs              |  4 +++-
 src/floor/systems/despawn.rs  |  3 +++
 src/floor/systems/mod.rs      | 15 +++++++++++++--
 src/floor/systems/spawn.rs    | 11 +++++++++++
 src/maze/events.rs            |  2 +-
 src/maze/triggers/spawn.rs    |  6 ++++--
 src/player/events.rs          | 10 ----------
 src/player/mod.rs             |  4 +---
 src/player/systems/ascend.rs  | 15 +++++++--------
 src/player/systems/descend.rs | 17 ++++++++---------
 11 files changed, 56 insertions(+), 36 deletions(-)
 create mode 100644 src/floor/systems/despawn.rs
 create mode 100644 src/floor/systems/spawn.rs

diff --git a/src/floor/events.rs b/src/floor/events.rs
index d9bd31c..8eb3b64 100644
--- a/src/floor/events.rs
+++ b/src/floor/events.rs
@@ -18,3 +18,8 @@ pub struct RespawnFloor {
 pub struct DespawnFloor {
     pub floor: u8,
 }
+
+#[derive(Debug, Reflect, Event)]
+pub struct TransitionFloor {
+    pub floor: u8,
+}
diff --git a/src/floor/mod.rs b/src/floor/mod.rs
index b0e8bc0..23e4944 100644
--- a/src/floor/mod.rs
+++ b/src/floor/mod.rs
@@ -3,7 +3,9 @@ pub mod events;
 mod systems;
 
 use bevy::prelude::*;
+use events::TransitionFloor;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_plugins(systems::plugin);
+    app.add_event::<TransitionFloor>()
+        .add_plugins(systems::plugin);
 }
diff --git a/src/floor/systems/despawn.rs b/src/floor/systems/despawn.rs
new file mode 100644
index 0000000..b66f570
--- /dev/null
+++ b/src/floor/systems/despawn.rs
@@ -0,0 +1,3 @@
+use bevy::prelude::*;
+
+pub(super) fn despawn_level(mut commands: Commands) {}
diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index 5b1303d..cfbd806 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -1,3 +1,14 @@
-use bevy::prelude::*;
+mod despawn;
+mod spawn;
 
-pub(super) fn plugin(_app: &mut App) {}
+use crate::maze::MazePluginLoaded;
+use bevy::prelude::*;
+use despawn::despawn_level;
+use spawn::spawn_floor;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_systems(
+        Update,
+        (spawn_floor, despawn_level).run_if(resource_exists::<MazePluginLoaded>),
+    );
+}
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
new file mode 100644
index 0000000..fa16052
--- /dev/null
+++ b/src/floor/systems/spawn.rs
@@ -0,0 +1,11 @@
+use bevy::prelude::*;
+
+use crate::{floor::events::TransitionFloor, maze::events::SpawnMaze};
+
+pub(super) fn spawn_floor(mut commands: Commands, mut event_reader: EventReader<TransitionFloor>) {
+    for event in event_reader.read() {
+        let floor = event.floor;
+        info!("Creating level for floor {}", floor);
+        commands.trigger(SpawnMaze { floor, ..default() });
+    }
+}
diff --git a/src/maze/events.rs b/src/maze/events.rs
index 24278ae..5686470 100644
--- a/src/maze/events.rs
+++ b/src/maze/events.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 use super::components::MazeConfig;
 
-#[derive(Debug, Reflect, Event)]
+#[derive(Debug, Reflect, Event, Default)]
 pub struct SpawnMaze {
     pub floor: u8,
     pub config: MazeConfig,
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index e7ed398..32e84e7 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -14,6 +14,8 @@ use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
 use super::common::generate_maze;
 
+const FLOOR_Y_OFFSET: u8 = 100;
+
 pub(super) fn spawn_maze(
     trigger: Trigger<SpawnMaze>,
     mut commands: Commands,
@@ -24,11 +26,11 @@ pub(super) fn spawn_maze(
 ) {
     let SpawnMaze { floor, config } = trigger.event();
     if maze_query.iter().any(|(_, f, _)| f.0 == *floor) {
-        warn!("Floor {} already exists, skipping creation", floor);
         return;
     }
 
     let maze = generate_maze(config).expect("Failed to generate maze during spawn");
+    let y_offset = (floor - 1) * FLOOR_Y_OFFSET;
 
     let entity = commands
         .spawn((
@@ -37,7 +39,7 @@ pub(super) fn spawn_maze(
             Floor(*floor),
             CurrentFloor, // TODO: remove
             config.clone(),
-            Transform::from_translation(Vec3::ZERO),
+            Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
             Visibility::Visible,
         ))
         .id();
diff --git a/src/player/events.rs b/src/player/events.rs
index 04ed340..953c8c9 100644
--- a/src/player/events.rs
+++ b/src/player/events.rs
@@ -8,13 +8,3 @@ pub struct RespawnPlayer;
 
 #[derive(Debug, Event)]
 pub struct DespawnPlayer;
-
-#[derive(Debug, Event)]
-pub struct AscendPlayer {
-    pub floor: u8,
-}
-
-#[derive(Debug, Event)]
-pub struct DescendPlayer {
-    pub floor: u8,
-}
diff --git a/src/player/mod.rs b/src/player/mod.rs
index 624c110..480168d 100644
--- a/src/player/mod.rs
+++ b/src/player/mod.rs
@@ -6,15 +6,13 @@ mod triggers;
 
 use bevy::{ecs::system::RunSystemOnce, prelude::*};
 use components::Player;
-use events::{AscendPlayer, DescendPlayer, DespawnPlayer, RespawnPlayer, SpawnPlayer};
+use events::{DespawnPlayer, RespawnPlayer, SpawnPlayer};
 
 pub(super) fn plugin(app: &mut App) {
     app.register_type::<Player>()
         .add_event::<SpawnPlayer>()
         .add_event::<RespawnPlayer>()
         .add_event::<DespawnPlayer>()
-        .add_event::<AscendPlayer>()
-        .add_event::<DescendPlayer>()
         .add_plugins((triggers::plugin, systems::plugin));
 }
 
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
index c20f01a..8c47742 100644
--- a/src/player/systems/ascend.rs
+++ b/src/player/systems/ascend.rs
@@ -1,27 +1,26 @@
 use bevy::prelude::*;
 
 use crate::{
-    floor::components::{CurrentFloor, Floor},
-    maze::components::MazeConfig,
-    player::{
-        components::{CurrentPosition, Player},
-        events::AscendPlayer,
+    floor::{
+        components::{CurrentFloor, Floor},
+        events::TransitionFloor,
     },
+    maze::components::MazeConfig,
+    player::components::{CurrentPosition, Player},
 };
 
 pub(super) fn ascend_player(
     query: Query<&CurrentPosition, With<Player>>,
     maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
-    mut event_writer: EventWriter<AscendPlayer>,
+    mut event_writer: EventWriter<TransitionFloor>,
 ) {
     let Ok((config, floor)) = maze_config_query.get_single() else {
-        warn!("No current floor configuration found");
         return;
     };
 
     for current_hex in query.iter() {
         if current_hex.0 == config.end_pos {
-            event_writer.send(AscendPlayer {
+            event_writer.send(TransitionFloor {
                 floor: *floor.increase(),
             });
             return;
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
index d03b67e..852a1ab 100644
--- a/src/player/systems/descend.rs
+++ b/src/player/systems/descend.rs
@@ -1,27 +1,26 @@
 use bevy::prelude::*;
 
 use crate::{
-    floor::components::{CurrentFloor, Floor},
-    maze::components::MazeConfig,
-    player::{
-        components::{CurrentPosition, Player},
-        events::DescendPlayer,
+    floor::{
+        components::{CurrentFloor, Floor},
+        events::TransitionFloor,
     },
+    maze::components::MazeConfig,
+    player::components::{CurrentPosition, Player},
 };
 
 pub(super) fn descend_player(
     query: Query<&CurrentPosition, With<Player>>,
     maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
-    mut event_writer: EventWriter<DescendPlayer>,
+    mut event_writer: EventWriter<TransitionFloor>,
 ) {
     let Ok((config, floor)) = maze_config_query.get_single() else {
-        warn!("No current floor configuration found");
         return;
     };
 
     for current_hex in query.iter() {
-        if current_hex.0 == config.start_pos {
-            event_writer.send(DescendPlayer {
+        if current_hex.0 == config.start_pos && floor.0 != 1 {
+            event_writer.send(TransitionFloor {
                 floor: *floor.decrease(),
             });
             return;

From f8ea1edd87a10d8baeed9ce900de13bcbbd725e1 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Thu, 19 Dec 2024 18:38:18 +0200
Subject: [PATCH 04/16] fix(floor): spawning

---
 src/floor/events.rs           |  8 +++++---
 src/floor/systems/spawn.rs    | 31 ++++++++++++++++++++++++++++---
 src/maze/events.rs            | 14 +++++++++++---
 src/maze/systems/setup.rs     |  5 ++---
 src/maze/triggers/spawn.rs    |  1 +
 src/player/systems/ascend.rs  | 14 +++++---------
 src/player/systems/descend.rs |  5 ++---
 src/player/systems/mod.rs     |  1 +
 8 files changed, 55 insertions(+), 24 deletions(-)

diff --git a/src/floor/events.rs b/src/floor/events.rs
index 8eb3b64..1f743c8 100644
--- a/src/floor/events.rs
+++ b/src/floor/events.rs
@@ -19,7 +19,9 @@ pub struct DespawnFloor {
     pub floor: u8,
 }
 
-#[derive(Debug, Reflect, Event)]
-pub struct TransitionFloor {
-    pub floor: u8,
+#[derive(Debug, Reflect, Event, Default)]
+pub enum TransitionFloor {
+    #[default]
+    Ascend,
+    Descent,
 }
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
index fa16052..91bfdc7 100644
--- a/src/floor/systems/spawn.rs
+++ b/src/floor/systems/spawn.rs
@@ -1,11 +1,36 @@
 use bevy::prelude::*;
 
-use crate::{floor::events::TransitionFloor, maze::events::SpawnMaze};
+use crate::{
+    floor::{
+        components::{CurrentFloor, Floor},
+        events::TransitionFloor,
+    },
+    maze::events::SpawnMaze,
+};
+
+pub(super) fn spawn_floor(
+    mut commands: Commands,
+    query: Query<(Entity, &Floor), With<CurrentFloor>>,
+    mut event_reader: EventReader<TransitionFloor>,
+) {
+    let Ok((entity, floor)) = query.get_single() else {
+        return;
+    };
 
-pub(super) fn spawn_floor(mut commands: Commands, mut event_reader: EventReader<TransitionFloor>) {
     for event in event_reader.read() {
-        let floor = event.floor;
+        dbg!(event);
+        let floor = match event {
+            TransitionFloor::Ascend => *floor.increase(),
+            TransitionFloor::Descent => *floor.decrease(),
+        };
+
+        if floor == 1 {
+            return;
+        }
+
         info!("Creating level for floor {}", floor);
+
+        commands.entity(entity).remove::<CurrentFloor>();
         commands.trigger(SpawnMaze { floor, ..default() });
     }
 }
diff --git a/src/maze/events.rs b/src/maze/events.rs
index 5686470..ead86a9 100644
--- a/src/maze/events.rs
+++ b/src/maze/events.rs
@@ -1,8 +1,7 @@
+use super::components::MazeConfig;
 use bevy::prelude::*;
 
-use super::components::MazeConfig;
-
-#[derive(Debug, Reflect, Event, Default)]
+#[derive(Debug, Reflect, Event)]
 pub struct SpawnMaze {
     pub floor: u8,
     pub config: MazeConfig,
@@ -18,3 +17,12 @@ pub struct RespawnMaze {
 pub struct DespawnMaze {
     pub floor: u8,
 }
+
+impl Default for SpawnMaze {
+    fn default() -> Self {
+        Self {
+            floor: 1,
+            config: MazeConfig::default(),
+        }
+    }
+}
diff --git a/src/maze/systems/setup.rs b/src/maze/systems/setup.rs
index c9dd708..b26c975 100644
--- a/src/maze/systems/setup.rs
+++ b/src/maze/systems/setup.rs
@@ -1,7 +1,6 @@
-use crate::maze::{components::MazeConfig, events::SpawnMaze};
+use crate::maze::events::SpawnMaze;
 use bevy::prelude::*;
 
 pub(crate) fn setup(mut commands: Commands) {
-    let config = MazeConfig::default();
-    commands.trigger(SpawnMaze { floor: 1, config });
+    commands.trigger(SpawnMaze::default());
 }
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index 32e84e7..bc03dcc 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -26,6 +26,7 @@ pub(super) fn spawn_maze(
 ) {
     let SpawnMaze { floor, config } = trigger.event();
     if maze_query.iter().any(|(_, f, _)| f.0 == *floor) {
+        warn!("Floor {} already exists, skipping creation", floor);
         return;
     }
 
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
index 8c47742..808120f 100644
--- a/src/player/systems/ascend.rs
+++ b/src/player/systems/ascend.rs
@@ -1,28 +1,24 @@
 use bevy::prelude::*;
 
 use crate::{
-    floor::{
-        components::{CurrentFloor, Floor},
-        events::TransitionFloor,
-    },
+    floor::{components::CurrentFloor, events::TransitionFloor},
     maze::components::MazeConfig,
     player::components::{CurrentPosition, Player},
 };
 
 pub(super) fn ascend_player(
     query: Query<&CurrentPosition, With<Player>>,
-    maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
+    maze_config_query: Query<&MazeConfig, With<CurrentFloor>>,
     mut event_writer: EventWriter<TransitionFloor>,
 ) {
-    let Ok((config, floor)) = maze_config_query.get_single() else {
+    let Ok(config) = maze_config_query.get_single() else {
+        warn!("Failed to get maze configuration for current floor - cannot ascend player");
         return;
     };
 
     for current_hex in query.iter() {
         if current_hex.0 == config.end_pos {
-            event_writer.send(TransitionFloor {
-                floor: *floor.increase(),
-            });
+            event_writer.send(TransitionFloor::Ascend);
             return;
         }
     }
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
index 852a1ab..3e72798 100644
--- a/src/player/systems/descend.rs
+++ b/src/player/systems/descend.rs
@@ -15,14 +15,13 @@ pub(super) fn descend_player(
     mut event_writer: EventWriter<TransitionFloor>,
 ) {
     let Ok((config, floor)) = maze_config_query.get_single() else {
+        warn!("Failed to get maze configuration for current floor - cannot descend player");
         return;
     };
 
     for current_hex in query.iter() {
         if current_hex.0 == config.start_pos && floor.0 != 1 {
-            event_writer.send(TransitionFloor {
-                floor: *floor.decrease(),
-            });
+            event_writer.send(TransitionFloor::Descent);
             return;
         }
     }
diff --git a/src/player/systems/mod.rs b/src/player/systems/mod.rs
index df081cd..647cfb8 100644
--- a/src/player/systems/mod.rs
+++ b/src/player/systems/mod.rs
@@ -3,6 +3,7 @@ mod descend;
 mod input;
 mod movement;
 pub mod setup;
+mod transition_floor;
 
 use crate::maze::MazePluginLoaded;
 use ascend::ascend_player;

From 6c07bc0670343cb613d6c6d94649ab507c699a36 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Sun, 22 Dec 2024 18:25:40 +0200
Subject: [PATCH 05/16] feat(floor): add NextFloor component

---
 src/floor/components.rs       | 12 ++++---
 src/floor/systems/despawn.rs  |  2 +-
 src/floor/systems/mod.rs      |  8 +++--
 src/floor/systems/movement.rs | 59 +++++++++++++++++++++++++++++++++++
 src/floor/systems/spawn.rs    | 14 ++++-----
 src/maze/systems/setup.rs     | 53 +++++++++++++++++++++++++++++--
 src/maze/triggers/mod.rs      |  2 +-
 src/maze/triggers/spawn.rs    |  8 ++---
 src/player/systems/ascend.rs  |  3 +-
 src/player/systems/mod.rs     |  1 -
 10 files changed, 136 insertions(+), 26 deletions(-)
 create mode 100644 src/floor/systems/movement.rs

diff --git a/src/floor/components.rs b/src/floor/components.rs
index a44f17b..b3e8adf 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -8,6 +8,10 @@ pub struct Floor(pub u8);
 #[reflect(Component)]
 pub struct CurrentFloor;
 
+#[derive(Debug, Reflect, Component)]
+#[reflect(Component)]
+pub struct NextFloor;
+
 impl Default for Floor {
     fn default() -> Self {
         Self(1)
@@ -15,11 +19,11 @@ impl Default for Floor {
 }
 
 impl Floor {
-    pub fn increase(&self) -> Self {
+    pub fn increased(&self) -> Self {
         Self(self.0.saturating_add(1))
     }
 
-    pub fn decrease(&self) -> Self {
+    pub fn decreased(&self) -> Self {
         Self(self.0.saturating_sub(1).max(1))
     }
 }
@@ -36,7 +40,7 @@ mod tests {
     #[case(255, 255)]
     fn increase(#[case] input: u8, #[case] expected: u8) {
         let floor = Floor(input);
-        assert_eq!(*floor.increase(), expected);
+        assert_eq!(*floor.increased(), expected);
     }
 
     #[rstest]
@@ -46,6 +50,6 @@ mod tests {
     #[case(255, 254)]
     fn decrease(#[case] input: u8, #[case] expected: u8) {
         let floor = Floor(input);
-        assert_eq!(*floor.decrease(), expected);
+        assert_eq!(*floor.decreased(), expected);
     }
 }
diff --git a/src/floor/systems/despawn.rs b/src/floor/systems/despawn.rs
index b66f570..2c77d52 100644
--- a/src/floor/systems/despawn.rs
+++ b/src/floor/systems/despawn.rs
@@ -1,3 +1,3 @@
 use bevy::prelude::*;
 
-pub(super) fn despawn_level(mut commands: Commands) {}
+pub(super) fn despawn_floor(mut commands: Commands) {}
diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index cfbd806..2c82479 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -1,14 +1,18 @@
 mod despawn;
+mod movement;
 mod spawn;
 
 use crate::maze::MazePluginLoaded;
 use bevy::prelude::*;
-use despawn::despawn_level;
+use despawn::despawn_floor;
+use movement::floor_movement;
 use spawn::spawn_floor;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         Update,
-        (spawn_floor, despawn_level).run_if(resource_exists::<MazePluginLoaded>),
+        (spawn_floor, despawn_floor, floor_movement)
+            .chain()
+            .run_if(resource_exists::<MazePluginLoaded>),
     );
 }
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
new file mode 100644
index 0000000..be94014
--- /dev/null
+++ b/src/floor/systems/movement.rs
@@ -0,0 +1,59 @@
+use bevy::prelude::*;
+
+use crate::{
+    floor::{
+        components::{CurrentFloor, NextFloor},
+        events::TransitionFloor,
+    },
+    maze::{components::Maze, GlobalMazeConfig},
+    player::components::{MovementSpeed, Player},
+};
+
+pub(super) fn floor_movement(
+    mut commands: Commands,
+    mut maze_transforms: Query<(Entity, &mut Transform), With<Maze>>,
+    current_floor: Query<Entity, With<CurrentFloor>>,
+    next_floor: Query<Entity, With<NextFloor>>,
+    player_query: Query<&MovementSpeed, With<Player>>,
+    time: Res<Time>,
+    global_config: Res<GlobalMazeConfig>,
+    mut event_reader: EventReader<TransitionFloor>,
+) {
+    let speed = player_query.get_single().map(|s| s.0).unwrap_or(100.);
+    let movement_distance = speed * time.delta_secs();
+
+    for event in event_reader.read() {
+        let (direction, target_y) = match event {
+            TransitionFloor::Ascend => (Vec3::Y, -global_config.height),
+            TransitionFloor::Descent => (Vec3::NEG_Y, global_config.height),
+        };
+
+        let movement = direction * movement_distance;
+
+        for (_, mut transform) in maze_transforms.iter_mut() {
+            transform.translation += movement;
+        }
+
+        let is_movement_complete = maze_transforms
+            .iter()
+            .any(|(_, t)| t.translation.y.abs() >= target_y.abs());
+
+        if is_movement_complete {
+            if let Ok(current_floor_entity) = current_floor.get_single() {
+                commands
+                    .entity(current_floor_entity)
+                    .remove::<CurrentFloor>();
+            }
+
+            if let Ok(next_floor_entity) = next_floor.get_single() {
+                if let Ok((entity, mut transform)) = maze_transforms.get_mut(next_floor_entity) {
+                    transform.translation.y = 0.;
+                    commands
+                        .entity(entity)
+                        .remove::<NextFloor>()
+                        .insert(CurrentFloor);
+                }
+            }
+        }
+    }
+}
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
index 91bfdc7..74dab98 100644
--- a/src/floor/systems/spawn.rs
+++ b/src/floor/systems/spawn.rs
@@ -1,5 +1,3 @@
-use bevy::prelude::*;
-
 use crate::{
     floor::{
         components::{CurrentFloor, Floor},
@@ -7,30 +5,30 @@ use crate::{
     },
     maze::events::SpawnMaze,
 };
+use bevy::prelude::*;
 
 pub(super) fn spawn_floor(
     mut commands: Commands,
-    query: Query<(Entity, &Floor), With<CurrentFloor>>,
+    query: Query<&mut Floor, With<CurrentFloor>>,
     mut event_reader: EventReader<TransitionFloor>,
 ) {
-    let Ok((entity, floor)) = query.get_single() else {
+    let Ok(floor) = query.get_single() else {
         return;
     };
 
     for event in event_reader.read() {
-        dbg!(event);
         let floor = match event {
-            TransitionFloor::Ascend => *floor.increase(),
-            TransitionFloor::Descent => *floor.decrease(),
+            TransitionFloor::Ascend => *floor.increased(),
+            TransitionFloor::Descent => *floor.decreased(),
         };
 
         if floor == 1 {
+            warn!("Cannot descend below floor 1");
             return;
         }
 
         info!("Creating level for floor {}", floor);
 
-        commands.entity(entity).remove::<CurrentFloor>();
         commands.trigger(SpawnMaze { floor, ..default() });
     }
 }
diff --git a/src/maze/systems/setup.rs b/src/maze/systems/setup.rs
index b26c975..5ceceb2 100644
--- a/src/maze/systems/setup.rs
+++ b/src/maze/systems/setup.rs
@@ -1,6 +1,53 @@
-use crate::maze::events::SpawnMaze;
+use crate::{
+    floor::components::{CurrentFloor, Floor},
+    maze::{
+        assets::MazeAssets,
+        components::Maze,
+        events::SpawnMaze,
+        triggers::{
+            common::generate_maze,
+            spawn::{spawn_maze_tiles, FLOOR_Y_OFFSET},
+        },
+        GlobalMazeConfig,
+    },
+};
 use bevy::prelude::*;
 
-pub(crate) fn setup(mut commands: Commands) {
-    commands.trigger(SpawnMaze::default());
+pub(crate) fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    maze_query: Query<(Entity, &Floor, &Maze)>,
+    global_config: Res<GlobalMazeConfig>,
+) {
+    let SpawnMaze { floor, config } = SpawnMaze::default();
+    if maze_query.iter().any(|(_, f, _)| f.0 == floor) {
+        warn!("Floor {} already exists, skipping creation", floor);
+        return;
+    }
+
+    let maze = generate_maze(&config).expect("Failed to generate maze during spawn");
+    let y_offset = (floor - 1) * FLOOR_Y_OFFSET;
+
+    let entity = commands
+        .spawn((
+            Name::new(format!("Floor {}", floor)),
+            Maze(maze.clone()),
+            Floor(floor),
+            CurrentFloor,
+            config.clone(),
+            Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
+            Visibility::Visible,
+        ))
+        .id();
+
+    let assets = MazeAssets::new(&mut meshes, &mut materials, &global_config);
+    spawn_maze_tiles(
+        &mut commands,
+        entity,
+        &maze,
+        &assets,
+        &config,
+        &global_config,
+    );
 }
diff --git a/src/maze/triggers/mod.rs b/src/maze/triggers/mod.rs
index 657f989..e7a2d2f 100644
--- a/src/maze/triggers/mod.rs
+++ b/src/maze/triggers/mod.rs
@@ -1,7 +1,7 @@
 pub mod common;
 mod despawn;
 mod respawn;
-mod spawn;
+pub mod spawn;
 
 use bevy::prelude::*;
 use despawn::despawn_maze;
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index bc03dcc..0b88662 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -1,5 +1,5 @@
 use crate::{
-    floor::components::{CurrentFloor, Floor},
+    floor::components::{CurrentFloor, Floor, NextFloor},
     maze::{
         assets::MazeAssets,
         components::{Maze, MazeConfig, Tile, Wall},
@@ -14,7 +14,7 @@ use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
 use super::common::generate_maze;
 
-const FLOOR_Y_OFFSET: u8 = 100;
+pub(crate) const FLOOR_Y_OFFSET: u8 = 100;
 
 pub(super) fn spawn_maze(
     trigger: Trigger<SpawnMaze>,
@@ -38,7 +38,7 @@ pub(super) fn spawn_maze(
             Name::new(format!("Floor {}", floor)),
             Maze(maze.clone()),
             Floor(*floor),
-            CurrentFloor, // TODO: remove
+            NextFloor,
             config.clone(),
             Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
             Visibility::Visible,
@@ -56,7 +56,7 @@ pub(super) fn spawn_maze(
     );
 }
 
-pub(super) fn spawn_maze_tiles(
+pub(crate) fn spawn_maze_tiles(
     commands: &mut Commands,
     parent_entity: Entity,
     maze: &HexMaze,
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
index 808120f..c46bf8c 100644
--- a/src/player/systems/ascend.rs
+++ b/src/player/systems/ascend.rs
@@ -1,10 +1,9 @@
-use bevy::prelude::*;
-
 use crate::{
     floor::{components::CurrentFloor, events::TransitionFloor},
     maze::components::MazeConfig,
     player::components::{CurrentPosition, Player},
 };
+use bevy::prelude::*;
 
 pub(super) fn ascend_player(
     query: Query<&CurrentPosition, With<Player>>,
diff --git a/src/player/systems/mod.rs b/src/player/systems/mod.rs
index 647cfb8..df081cd 100644
--- a/src/player/systems/mod.rs
+++ b/src/player/systems/mod.rs
@@ -3,7 +3,6 @@ mod descend;
 mod input;
 mod movement;
 pub mod setup;
-mod transition_floor;
 
 use crate::maze::MazePluginLoaded;
 use ascend::ascend_player;

From a76cbdc02b5443fd65d10773ac2f853db6c32360 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 12:46:32 +0200
Subject: [PATCH 06/16] fix: typo

---
 src/floor/events.rs           | 2 +-
 src/floor/systems/movement.rs | 2 +-
 src/floor/systems/spawn.rs    | 2 +-
 src/player/systems/descend.rs | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/floor/events.rs b/src/floor/events.rs
index 1f743c8..38e2988 100644
--- a/src/floor/events.rs
+++ b/src/floor/events.rs
@@ -23,5 +23,5 @@ pub struct DespawnFloor {
 pub enum TransitionFloor {
     #[default]
     Ascend,
-    Descent,
+    Descend,
 }
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index be94014..bb5c30f 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -25,7 +25,7 @@ pub(super) fn floor_movement(
     for event in event_reader.read() {
         let (direction, target_y) = match event {
             TransitionFloor::Ascend => (Vec3::Y, -global_config.height),
-            TransitionFloor::Descent => (Vec3::NEG_Y, global_config.height),
+            TransitionFloor::Descend => (Vec3::NEG_Y, global_config.height),
         };
 
         let movement = direction * movement_distance;
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
index 74dab98..083f61b 100644
--- a/src/floor/systems/spawn.rs
+++ b/src/floor/systems/spawn.rs
@@ -19,7 +19,7 @@ pub(super) fn spawn_floor(
     for event in event_reader.read() {
         let floor = match event {
             TransitionFloor::Ascend => *floor.increased(),
-            TransitionFloor::Descent => *floor.decreased(),
+            TransitionFloor::Descend => *floor.decreased(),
         };
 
         if floor == 1 {
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
index 3e72798..f885263 100644
--- a/src/player/systems/descend.rs
+++ b/src/player/systems/descend.rs
@@ -21,7 +21,7 @@ pub(super) fn descend_player(
 
     for current_hex in query.iter() {
         if current_hex.0 == config.start_pos && floor.0 != 1 {
-            event_writer.send(TransitionFloor::Descent);
+            event_writer.send(TransitionFloor::Descend);
             return;
         }
     }

From 45511e4d80f36e3053e2017a199a547c4280a9cd Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 13:39:06 +0200
Subject: [PATCH 07/16] fix(maze): spawning

---
 src/floor/systems/movement.rs | 57 +++++++++++++++--------------------
 src/maze/systems/setup.rs     | 53 ++------------------------------
 src/maze/triggers/spawn.rs    | 15 +++++++--
 3 files changed, 40 insertions(+), 85 deletions(-)

diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index bb5c30f..6a1e9e0 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -1,5 +1,3 @@
-use bevy::prelude::*;
-
 use crate::{
     floor::{
         components::{CurrentFloor, NextFloor},
@@ -8,12 +6,13 @@ use crate::{
     maze::{components::Maze, GlobalMazeConfig},
     player::components::{MovementSpeed, Player},
 };
+use bevy::prelude::*;
 
 pub(super) fn floor_movement(
     mut commands: Commands,
-    mut maze_transforms: Query<(Entity, &mut Transform), With<Maze>>,
-    current_floor: Query<Entity, With<CurrentFloor>>,
-    next_floor: Query<Entity, With<NextFloor>>,
+    mut maze_query: Query<(Entity, &mut Transform), With<Maze>>,
+    current_query: Query<Entity, With<CurrentFloor>>,
+    next_query: Query<Entity, With<NextFloor>>,
     player_query: Query<&MovementSpeed, With<Player>>,
     time: Res<Time>,
     global_config: Res<GlobalMazeConfig>,
@@ -23,37 +22,31 @@ pub(super) fn floor_movement(
     let movement_distance = speed * time.delta_secs();
 
     for event in event_reader.read() {
-        let (direction, target_y) = match event {
-            TransitionFloor::Ascend => (Vec3::Y, -global_config.height),
-            TransitionFloor::Descend => (Vec3::NEG_Y, global_config.height),
+        let y_offset = match event {
+            TransitionFloor::Ascend => -global_config.height,
+            TransitionFloor::Descend => global_config.height,
         };
 
-        let movement = direction * movement_distance;
-
-        for (_, mut transform) in maze_transforms.iter_mut() {
-            transform.translation += movement;
+        for (_, mut transforms) in maze_query.iter_mut() {
+            let target_y = transforms.translation.y + y_offset;
+            let delta = target_y - transforms.translation.y;
+            if delta.abs() > 0.001 {
+                let movement = delta.signum() * movement_distance.min(delta.abs());
+                transforms.translation.y += movement;
+            } else {
+                transforms.translation.y = target_y;
+            }
         }
 
-        let is_movement_complete = maze_transforms
-            .iter()
-            .any(|(_, t)| t.translation.y.abs() >= target_y.abs());
-
-        if is_movement_complete {
-            if let Ok(current_floor_entity) = current_floor.get_single() {
-                commands
-                    .entity(current_floor_entity)
-                    .remove::<CurrentFloor>();
-            }
-
-            if let Ok(next_floor_entity) = next_floor.get_single() {
-                if let Ok((entity, mut transform)) = maze_transforms.get_mut(next_floor_entity) {
-                    transform.translation.y = 0.;
-                    commands
-                        .entity(entity)
-                        .remove::<NextFloor>()
-                        .insert(CurrentFloor);
-                }
-            }
+        // Update current/next floor
+        if let (Ok(current_entity), Ok(next_entity)) =
+            (current_query.get_single(), next_query.get_single())
+        {
+            commands.entity(current_entity).remove::<CurrentFloor>();
+            commands
+                .entity(next_entity)
+                .remove::<NextFloor>()
+                .insert(CurrentFloor);
         }
     }
 }
diff --git a/src/maze/systems/setup.rs b/src/maze/systems/setup.rs
index 5ceceb2..b26c975 100644
--- a/src/maze/systems/setup.rs
+++ b/src/maze/systems/setup.rs
@@ -1,53 +1,6 @@
-use crate::{
-    floor::components::{CurrentFloor, Floor},
-    maze::{
-        assets::MazeAssets,
-        components::Maze,
-        events::SpawnMaze,
-        triggers::{
-            common::generate_maze,
-            spawn::{spawn_maze_tiles, FLOOR_Y_OFFSET},
-        },
-        GlobalMazeConfig,
-    },
-};
+use crate::maze::events::SpawnMaze;
 use bevy::prelude::*;
 
-pub(crate) fn setup(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-    maze_query: Query<(Entity, &Floor, &Maze)>,
-    global_config: Res<GlobalMazeConfig>,
-) {
-    let SpawnMaze { floor, config } = SpawnMaze::default();
-    if maze_query.iter().any(|(_, f, _)| f.0 == floor) {
-        warn!("Floor {} already exists, skipping creation", floor);
-        return;
-    }
-
-    let maze = generate_maze(&config).expect("Failed to generate maze during spawn");
-    let y_offset = (floor - 1) * FLOOR_Y_OFFSET;
-
-    let entity = commands
-        .spawn((
-            Name::new(format!("Floor {}", floor)),
-            Maze(maze.clone()),
-            Floor(floor),
-            CurrentFloor,
-            config.clone(),
-            Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
-            Visibility::Visible,
-        ))
-        .id();
-
-    let assets = MazeAssets::new(&mut meshes, &mut materials, &global_config);
-    spawn_maze_tiles(
-        &mut commands,
-        entity,
-        &maze,
-        &assets,
-        &config,
-        &global_config,
-    );
+pub(crate) fn setup(mut commands: Commands) {
+    commands.trigger(SpawnMaze::default());
 }
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index 0b88662..c92c50f 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -25,12 +25,20 @@ pub(super) fn spawn_maze(
     global_config: Res<GlobalMazeConfig>,
 ) {
     let SpawnMaze { floor, config } = trigger.event();
+
     if maze_query.iter().any(|(_, f, _)| f.0 == *floor) {
         warn!("Floor {} already exists, skipping creation", floor);
         return;
     }
 
-    let maze = generate_maze(config).expect("Failed to generate maze during spawn");
+    let maze = match generate_maze(&config) {
+        Ok(m) => m,
+        Err(e) => {
+            error!("Failed to generate maze for floor {floor}: {:?}", e);
+            return;
+        }
+    };
+
     let y_offset = (floor - 1) * FLOOR_Y_OFFSET;
 
     let entity = commands
@@ -38,11 +46,12 @@ pub(super) fn spawn_maze(
             Name::new(format!("Floor {}", floor)),
             Maze(maze.clone()),
             Floor(*floor),
-            NextFloor,
             config.clone(),
             Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
             Visibility::Visible,
         ))
+        .insert_if(CurrentFloor, || *floor == 1)
+        .insert_if(NextFloor, || *floor != 1)
         .id();
 
     let assets = MazeAssets::new(&mut meshes, &mut materials, &global_config);
@@ -51,7 +60,7 @@ pub(super) fn spawn_maze(
         entity,
         &maze,
         &assets,
-        config,
+        &config,
         &global_config,
     );
 }

From b966d38e945ce7f87431c322f1d266fad9b1efdc Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 13:53:53 +0200
Subject: [PATCH 08/16] fix: clippy warnings

---
 Cargo.toml                        |  2 ++
 src/asset_tracking.rs             |  7 ++++---
 src/dev_tools/ui/maze_controls.rs |  2 +-
 src/dev_tools/ui/mod.rs           |  2 +-
 src/floor/components.rs           |  2 +-
 src/floor/systems/despawn.rs      |  2 +-
 src/lib.rs                        |  6 +++---
 src/maze/assets.rs                | 24 ++++++++++++------------
 src/maze/errors.rs                |  2 +-
 src/maze/systems/setup.rs         |  2 +-
 src/maze/triggers/common.rs       |  2 +-
 src/maze/triggers/spawn.rs        | 17 +++++++----------
 src/player/systems/setup.rs       |  2 +-
 src/screens/loading.rs            |  2 +-
 src/screens/splash.rs             |  2 +-
 15 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 44b271b..bb788cf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,6 +60,8 @@ dev_native = [
 too_many_arguments = "allow"
 # Queries that access many components may trigger this lint.
 type_complexity = "allow"
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
 
 
 # Compile with Performance Optimizations:
diff --git a/src/asset_tracking.rs b/src/asset_tracking.rs
index f61992a..396ab1f 100644
--- a/src/asset_tracking.rs
+++ b/src/asset_tracking.rs
@@ -1,8 +1,7 @@
 //! A high-level way to load collections of asset handles as resources.
 
-use std::collections::VecDeque;
-
 use bevy::prelude::*;
+use std::collections::VecDeque;
 
 pub(super) fn plugin(app: &mut App) {
     app.init_resource::<ResourceHandles>();
@@ -51,7 +50,9 @@ fn load_resource_assets(world: &mut World) {
     world.resource_scope(|world, mut resource_handles: Mut<ResourceHandles>| {
         world.resource_scope(|world, assets: Mut<AssetServer>| {
             for _ in 0..resource_handles.waiting.len() {
-                let (handle, insert_fn) = resource_handles.waiting.pop_front().unwrap();
+                let Some((handle, insert_fn)) = resource_handles.waiting.pop_front() else {
+                    continue;
+                };
                 if assets.is_loaded_with_dependencies(&handle) {
                     insert_fn(world, &handle);
                     resource_handles.finished.push(handle);
diff --git a/src/dev_tools/ui/maze_controls.rs b/src/dev_tools/ui/maze_controls.rs
index 95002cb..6c94755 100644
--- a/src/dev_tools/ui/maze_controls.rs
+++ b/src/dev_tools/ui/maze_controls.rs
@@ -12,7 +12,7 @@ use hexx::{Hex, HexOrientation};
 use rand::{thread_rng, Rng};
 use std::ops::RangeInclusive;
 
-pub(crate) fn maze_controls_ui(world: &mut World) {
+pub fn maze_controls_ui(world: &mut World) {
     if world.get_resource::<MazePluginLoaded>().is_none() {
         return;
     }
diff --git a/src/dev_tools/ui/mod.rs b/src/dev_tools/ui/mod.rs
index 63c404f..4923190 100644
--- a/src/dev_tools/ui/mod.rs
+++ b/src/dev_tools/ui/mod.rs
@@ -1,3 +1,3 @@
 mod maze_controls;
 
-pub(crate) use maze_controls::maze_controls_ui;
+pub use maze_controls::maze_controls_ui;
diff --git a/src/floor/components.rs b/src/floor/components.rs
index b3e8adf..9a8e924 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -19,7 +19,7 @@ impl Default for Floor {
 }
 
 impl Floor {
-    pub fn increased(&self) -> Self {
+    pub const fn increased(&self) -> Self {
         Self(self.0.saturating_add(1))
     }
 
diff --git a/src/floor/systems/despawn.rs b/src/floor/systems/despawn.rs
index 2c77d52..3567c3b 100644
--- a/src/floor/systems/despawn.rs
+++ b/src/floor/systems/despawn.rs
@@ -1,3 +1,3 @@
 use bevy::prelude::*;
 
-pub(super) fn despawn_floor(mut commands: Commands) {}
+pub const fn despawn_floor(mut _commands: Commands) {}
diff --git a/src/lib.rs b/src/lib.rs
index 3dcce5c..94bbcf7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,11 +1,11 @@
-mod asset_tracking;
+pub mod asset_tracking;
 pub mod audio;
 #[cfg(feature = "dev")]
-mod dev_tools;
+pub mod dev_tools;
 pub mod floor;
 pub mod maze;
 pub mod player;
-mod screens;
+pub mod screens;
 pub mod theme;
 
 use bevy::{
diff --git a/src/maze/assets.rs b/src/maze/assets.rs
index 12d9872..f80519b 100644
--- a/src/maze/assets.rs
+++ b/src/maze/assets.rs
@@ -8,26 +8,26 @@ const WALL_OVERLAP_MODIFIER: f32 = 1.25;
 const HEX_SIDES: u32 = 6;
 const WHITE_EMISSION_INTENSITY: f32 = 10.;
 
-pub(crate) struct MazeAssets {
-    pub(crate) hex_mesh: Handle<Mesh>,
-    pub(crate) wall_mesh: Handle<Mesh>,
-    pub(crate) hex_material: Handle<StandardMaterial>,
-    pub(crate) wall_material: Handle<StandardMaterial>,
-    pub(crate) custom_materials: HashMap<String, Handle<StandardMaterial>>,
+pub struct MazeAssets {
+    pub hex_mesh: Handle<Mesh>,
+    pub wall_mesh: Handle<Mesh>,
+    pub hex_material: Handle<StandardMaterial>,
+    pub wall_material: Handle<StandardMaterial>,
+    pub custom_materials: HashMap<String, Handle<StandardMaterial>>,
 }
 
 impl MazeAssets {
-    pub(crate) fn new(
+    pub fn new(
         meshes: &mut ResMut<Assets<Mesh>>,
         materials: &mut ResMut<Assets<StandardMaterial>>,
         global_config: &GlobalMazeConfig,
-    ) -> MazeAssets {
+    ) -> Self {
         let mut custom_materials = HashMap::new();
         custom_materials.extend(vec![
             ("LOVE".to_string(), materials.add(red_material())),
             ("PINE".to_string(), materials.add(blue_material())),
         ]);
-        MazeAssets {
+        Self {
             hex_mesh: meshes.add(generate_hex_mesh(
                 global_config.hex_size,
                 global_config.height,
@@ -62,7 +62,7 @@ fn generate_square_mesh(depth: f32, wall_size: f32) -> Mesh {
     Mesh::from(rectangular_prism).rotated_by(rotation)
 }
 
-pub(crate) fn white_material() -> StandardMaterial {
+pub fn white_material() -> StandardMaterial {
     StandardMaterial {
         emissive: LinearRgba::new(
             WHITE_EMISSION_INTENSITY,
@@ -74,14 +74,14 @@ pub(crate) fn white_material() -> StandardMaterial {
     }
 }
 
-pub(crate) fn red_material() -> StandardMaterial {
+pub fn red_material() -> StandardMaterial {
     StandardMaterial {
         emissive: LOVE.to_linear(),
         ..default()
     }
 }
 
-pub(crate) fn blue_material() -> StandardMaterial {
+pub fn blue_material() -> StandardMaterial {
     StandardMaterial {
         emissive: PINE.to_linear(),
         ..default()
diff --git a/src/maze/errors.rs b/src/maze/errors.rs
index 005ff83..87e36a6 100644
--- a/src/maze/errors.rs
+++ b/src/maze/errors.rs
@@ -32,7 +32,7 @@ impl MazeError {
         Self::ConfigurationError(msg.into())
     }
 
-    pub fn generation_failed(radius: u32, seed: u64) -> Self {
+    pub const fn generation_failed(radius: u32, seed: u64) -> Self {
         Self::GenerationFailed { radius, seed }
     }
 }
diff --git a/src/maze/systems/setup.rs b/src/maze/systems/setup.rs
index b26c975..42fe9fe 100644
--- a/src/maze/systems/setup.rs
+++ b/src/maze/systems/setup.rs
@@ -1,6 +1,6 @@
 use crate::maze::events::SpawnMaze;
 use bevy::prelude::*;
 
-pub(crate) fn setup(mut commands: Commands) {
+pub fn setup(mut commands: Commands) {
     commands.trigger(SpawnMaze::default());
 }
diff --git a/src/maze/triggers/common.rs b/src/maze/triggers/common.rs
index 6716a09..c39b539 100644
--- a/src/maze/triggers/common.rs
+++ b/src/maze/triggers/common.rs
@@ -4,7 +4,7 @@ use crate::maze::{
 };
 use hexlab::{GeneratorType, HexMaze, MazeBuilder};
 
-pub(crate) fn generate_maze(config: &MazeConfig) -> MazeResult<HexMaze> {
+pub fn generate_maze(config: &MazeConfig) -> MazeResult<HexMaze> {
     MazeBuilder::new()
         .with_radius(config.radius)
         .with_seed(config.seed)
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index c92c50f..493fefe 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -1,3 +1,4 @@
+use super::common::generate_maze;
 use crate::{
     floor::components::{CurrentFloor, Floor, NextFloor},
     maze::{
@@ -12,9 +13,7 @@ use hexlab::prelude::*;
 use hexx::HexOrientation;
 use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
-use super::common::generate_maze;
-
-pub(crate) const FLOOR_Y_OFFSET: u8 = 100;
+pub const FLOOR_Y_OFFSET: u8 = 100;
 
 pub(super) fn spawn_maze(
     trigger: Trigger<SpawnMaze>,
@@ -31,7 +30,7 @@ pub(super) fn spawn_maze(
         return;
     }
 
-    let maze = match generate_maze(&config) {
+    let maze = match generate_maze(config) {
         Ok(m) => m,
         Err(e) => {
             error!("Failed to generate maze for floor {floor}: {:?}", e);
@@ -60,12 +59,12 @@ pub(super) fn spawn_maze(
         entity,
         &maze,
         &assets,
-        &config,
+        config,
         &global_config,
     );
 }
 
-pub(crate) fn spawn_maze_tiles(
+pub fn spawn_maze_tiles(
     commands: &mut Commands,
     parent_entity: Entity,
     maze: &HexMaze,
@@ -98,14 +97,12 @@ pub(super) fn spawn_single_hex_tile(
             .custom_materials
             .get("PINE")
             .cloned()
-            .to_owned()
-            .unwrap(),
+            .unwrap_or_default(),
         pos if pos == maze_config.end_pos => assets
             .custom_materials
             .get("LOVE")
             .cloned()
-            .to_owned()
-            .unwrap(),
+            .unwrap_or_default(),
         _ => assets.hex_material.clone(),
     };
 
diff --git a/src/player/systems/setup.rs b/src/player/systems/setup.rs
index 84d879c..12157dd 100644
--- a/src/player/systems/setup.rs
+++ b/src/player/systems/setup.rs
@@ -1,6 +1,6 @@
 use crate::player::events::SpawnPlayer;
 use bevy::prelude::*;
 
-pub(crate) fn setup(mut commands: Commands) {
+pub fn setup(mut commands: Commands) {
     commands.trigger(SpawnPlayer);
 }
diff --git a/src/screens/loading.rs b/src/screens/loading.rs
index a1cbccf..556c9a4 100644
--- a/src/screens/loading.rs
+++ b/src/screens/loading.rs
@@ -33,7 +33,7 @@ fn continue_to_title_screen(mut next_screen: ResMut<NextState<Screen>>) {
     next_screen.set(Screen::Title);
 }
 
-fn all_assets_loaded(
+const fn all_assets_loaded(
     interaction_assets: Option<Res<InteractionAssets>>,
     credits_music: Option<Res<CreditsMusic>>,
     gameplay_music: Option<Res<GameplayMusic>>,
diff --git a/src/screens/splash.rs b/src/screens/splash.rs
index 4c60199..3171d0f 100644
--- a/src/screens/splash.rs
+++ b/src/screens/splash.rs
@@ -101,7 +101,7 @@ impl UiImageFadeInOut {
         let fade = self.fade_duration / self.total_duration;
 
         // Regular trapezoid-shaped graph, flat at the top with alpha = 1.0.
-        ((1.0 - (2.0 * t - 1.0).abs()) / fade).min(1.0)
+        ((1.0 - 2.0f32.mul_add(t, -1.0).abs()) / fade).min(1.0)
     }
 }
 

From 8683f727f24f922f19cdc9af9f5aecea50e6e76d Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 13:55:56 +0200
Subject: [PATCH 09/16] chore: bump version number

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bd6bacb..636cb5a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3157,7 +3157,7 @@ dependencies = [
 
 [[package]]
 name = "maze-ascension"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "anyhow",
  "bevy",
diff --git a/Cargo.toml b/Cargo.toml
index bb788cf..0db5788 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "maze-ascension"
 authors = ["Kristofers Solo <dev@kristofers.xyz>"]
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 
 [dependencies]

From 3659ffa1a6efca886bc8ffee3952b5e3ebf0395a Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 14:48:46 +0200
Subject: [PATCH 10/16] fix: floor movement

---
 src/floor/components.rs        |  7 +++
 src/floor/systems/movement.rs  | 84 +++++++++++++++++++++++-----------
 src/player/systems/movement.rs |  4 +-
 3 files changed, 68 insertions(+), 27 deletions(-)

diff --git a/src/floor/components.rs b/src/floor/components.rs
index 9a8e924..570d919 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -12,6 +12,13 @@ pub struct CurrentFloor;
 #[reflect(Component)]
 pub struct NextFloor;
 
+#[derive(Debug, Reflect, Component)]
+#[reflect(Component)]
+pub struct MovementState {
+    pub target_y: f32,
+    pub direction: f32,
+}
+
 impl Default for Floor {
     fn default() -> Self {
         Self(1)
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index 6a1e9e0..7b7d113 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -1,6 +1,6 @@
 use crate::{
     floor::{
-        components::{CurrentFloor, NextFloor},
+        components::{CurrentFloor, MovementState, NextFloor},
         events::TransitionFloor,
     },
     maze::{components::Maze, GlobalMazeConfig},
@@ -8,45 +8,77 @@ use crate::{
 };
 use bevy::prelude::*;
 
+const MOVEMENT_THRESHOLD: f32 = 0.001;
+
 pub(super) fn floor_movement(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &mut Transform), With<Maze>>,
+    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
     current_query: Query<Entity, With<CurrentFloor>>,
     next_query: Query<Entity, With<NextFloor>>,
     player_query: Query<&MovementSpeed, With<Player>>,
     time: Res<Time>,
-    global_config: Res<GlobalMazeConfig>,
+    _global_config: Res<GlobalMazeConfig>,
     mut event_reader: EventReader<TransitionFloor>,
 ) {
-    let speed = player_query.get_single().map(|s| s.0).unwrap_or(100.);
-    let movement_distance = speed * time.delta_secs();
-
     for event in event_reader.read() {
-        let y_offset = match event {
-            TransitionFloor::Ascend => -global_config.height,
-            TransitionFloor::Descend => global_config.height,
+        let direction = match event {
+            TransitionFloor::Ascend => -1.,
+            TransitionFloor::Descend => 1.,
         };
 
-        for (_, mut transforms) in maze_query.iter_mut() {
-            let target_y = transforms.translation.y + y_offset;
-            let delta = target_y - transforms.translation.y;
-            if delta.abs() > 0.001 {
-                let movement = delta.signum() * movement_distance.min(delta.abs());
-                transforms.translation.y += movement;
-            } else {
-                transforms.translation.y = target_y;
+        let Some((current_entity, current_y)) = get_floor_info(&maze_query, &current_query) else {
+            continue;
+        };
+        let Some((next_entity, next_y)) = get_floor_info(&maze_query, &next_query) else {
+            continue;
+        };
+        let diff = (current_y - next_y).abs();
+
+        for (entity, transforms, movement_state) in maze_query.iter_mut() {
+            let target_y = diff.mul_add(direction, transforms.translation.y);
+            if movement_state.is_none() {
+                commands.entity(entity).insert(MovementState {
+                    target_y,
+                    direction,
+                });
             }
         }
 
-        // Update current/next floor
-        if let (Ok(current_entity), Ok(next_entity)) =
-            (current_query.get_single(), next_query.get_single())
-        {
-            commands.entity(current_entity).remove::<CurrentFloor>();
-            commands
-                .entity(next_entity)
-                .remove::<NextFloor>()
-                .insert(CurrentFloor);
+        update_current_next_floor(&mut commands, current_entity, next_entity);
+    }
+
+    let speed = player_query.get_single().map_or(100., |s| s.0);
+    let movement_distance = speed * time.delta_secs();
+    for (entity, mut transform, mut movement_state) in maze_query.iter_mut() {
+        if let Some(state) = movement_state.as_mut() {
+            let delta = state.target_y - transform.translation.y;
+            if delta.abs() > MOVEMENT_THRESHOLD {
+                let movement = delta.signum() * movement_distance.min(delta.abs());
+                transform.translation.y += movement;
+            } else {
+                transform.translation.y = state.target_y;
+                commands.entity(entity).remove::<MovementState>();
+            }
         }
     }
 }
+
+fn update_current_next_floor(commands: &mut Commands, current_entity: Entity, next_entity: Entity) {
+    commands.entity(current_entity).remove::<CurrentFloor>();
+    commands
+        .entity(next_entity)
+        .remove::<NextFloor>()
+        .insert(CurrentFloor);
+}
+
+fn get_floor_info(
+    maze_query: &Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
+    query: &Query<Entity, With<impl Component>>,
+) -> Option<(Entity, f32)> {
+    query.get_single().ok().and_then(|entity| {
+        maze_query
+            .get(entity)
+            .ok()
+            .map(|(_, transform, _)| (entity, transform.translation.y))
+    })
+}
diff --git a/src/player/systems/movement.rs b/src/player/systems/movement.rs
index 6815064..fba7989 100644
--- a/src/player/systems/movement.rs
+++ b/src/player/systems/movement.rs
@@ -6,6 +6,8 @@ use crate::{
 use bevy::prelude::*;
 use hexx::Hex;
 
+const MOVEMENT_THRESHOLD: f32 = 0.1;
+
 pub(super) fn player_movement(
     time: Res<Time>,
     mut query: Query<
@@ -48,7 +50,7 @@ pub(super) fn player_movement(
 }
 
 fn should_complete_movement(current_pos: Vec3, target_pos: Vec3) -> bool {
-    (target_pos - current_pos).length() < 0.1
+    (target_pos - current_pos).length() < MOVEMENT_THRESHOLD
 }
 
 fn update_position(

From 433a3ce5e80d517a896170570d01969eacf19d80 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 23 Dec 2024 14:55:27 +0200
Subject: [PATCH 11/16] refactor(floor): separate systems

---
 src/floor/systems/mod.rs      |  9 +++++--
 src/floor/systems/movement.rs | 44 +++++++++++++++++++----------------
 2 files changed, 31 insertions(+), 22 deletions(-)

diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index 2c82479..43c50b2 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -5,13 +5,18 @@ mod spawn;
 use crate::maze::MazePluginLoaded;
 use bevy::prelude::*;
 use despawn::despawn_floor;
-use movement::floor_movement;
+use movement::{handle_floor_transition_events, move_floors};
 use spawn::spawn_floor;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         Update,
-        (spawn_floor, despawn_floor, floor_movement)
+        (
+            spawn_floor,
+            despawn_floor,
+            handle_floor_transition_events,
+            move_floors,
+        )
             .chain()
             .run_if(resource_exists::<MazePluginLoaded>),
     );
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index 7b7d113..795e985 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -3,21 +3,40 @@ use crate::{
         components::{CurrentFloor, MovementState, NextFloor},
         events::TransitionFloor,
     },
-    maze::{components::Maze, GlobalMazeConfig},
+    maze::components::Maze,
     player::components::{MovementSpeed, Player},
 };
 use bevy::prelude::*;
 
 const MOVEMENT_THRESHOLD: f32 = 0.001;
 
-pub(super) fn floor_movement(
+pub(super) fn move_floors(
+    mut commands: Commands,
+    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
+    player_query: Query<&MovementSpeed, With<Player>>,
+    time: Res<Time>,
+) {
+    let speed = player_query.get_single().map_or(100., |s| s.0);
+    let movement_distance = speed * time.delta_secs();
+    for (entity, mut transform, mut movement_state) in maze_query.iter_mut() {
+        if let Some(state) = movement_state.as_mut() {
+            let delta = state.target_y - transform.translation.y;
+            if delta.abs() > MOVEMENT_THRESHOLD {
+                let movement = delta.signum() * movement_distance.min(delta.abs());
+                transform.translation.y += movement;
+            } else {
+                transform.translation.y = state.target_y;
+                commands.entity(entity).remove::<MovementState>();
+            }
+        }
+    }
+}
+
+pub(super) fn handle_floor_transition_events(
     mut commands: Commands,
     mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
     current_query: Query<Entity, With<CurrentFloor>>,
     next_query: Query<Entity, With<NextFloor>>,
-    player_query: Query<&MovementSpeed, With<Player>>,
-    time: Res<Time>,
-    _global_config: Res<GlobalMazeConfig>,
     mut event_reader: EventReader<TransitionFloor>,
 ) {
     for event in event_reader.read() {
@@ -46,21 +65,6 @@ pub(super) fn floor_movement(
 
         update_current_next_floor(&mut commands, current_entity, next_entity);
     }
-
-    let speed = player_query.get_single().map_or(100., |s| s.0);
-    let movement_distance = speed * time.delta_secs();
-    for (entity, mut transform, mut movement_state) in maze_query.iter_mut() {
-        if let Some(state) = movement_state.as_mut() {
-            let delta = state.target_y - transform.translation.y;
-            if delta.abs() > MOVEMENT_THRESHOLD {
-                let movement = delta.signum() * movement_distance.min(delta.abs());
-                transform.translation.y += movement;
-            } else {
-                transform.translation.y = state.target_y;
-                commands.entity(entity).remove::<MovementState>();
-            }
-        }
-    }
 }
 
 fn update_current_next_floor(commands: &mut Commands, current_entity: Entity, next_entity: Entity) {

From 4635b0f1345b227624ddac0ce1121bb99f6b3a14 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Fri, 27 Dec 2024 11:49:22 +0200
Subject: [PATCH 12/16] fix(floor): multiple floor create

---
 Cargo.lock                        |  8 +++--
 Cargo.toml                        |  2 +-
 justfile                          |  1 -
 src/floor/events.rs               | 56 ++++++++++++++++++++-----------
 src/floor/mod.rs                  |  3 ++
 src/floor/resources.rs            |  5 +++
 src/floor/systems/clear_events.rs |  0
 src/floor/systems/mod.rs          |  1 +
 src/floor/systems/movement.rs     | 14 +++++---
 src/floor/systems/spawn.rs        | 23 +++++++++----
 src/maze/components.rs            | 42 ++++++++++-------------
 src/maze/errors.rs                |  4 +--
 src/maze/triggers/spawn.rs        |  9 +++--
 src/player/systems/ascend.rs      |  5 +--
 src/player/systems/descend.rs     |  4 +--
 src/theme/palette/mod.rs          |  4 ++-
 16 files changed, 112 insertions(+), 69 deletions(-)
 create mode 100644 src/floor/resources.rs
 create mode 100644 src/floor/systems/clear_events.rs

diff --git a/Cargo.lock b/Cargo.lock
index 636cb5a..cbf1630 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2669,11 +2669,13 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
 name = "hexlab"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b912e78d292803bc279aec3a4e2a0cdd0e0ac1540bcdc5d0f32cbfe9e4d234dc"
+checksum = "94f91bb99b0ef58661cc4c18e9bab7bba9e66a3d3047fec9af76e31381647442"
 dependencies = [
- "bevy",
+ "bevy_reflect",
+ "bevy_utils",
+ "glam",
  "hexx",
  "rand",
  "thiserror 2.0.6",
diff --git a/Cargo.toml b/Cargo.toml
index 0db5788..63fcbd0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,7 @@ tracing = { version = "0.1", features = [
   "release_max_level_warn",
 ] }
 hexx = { version = "0.19", features = ["bevy_reflect", "grid"] }
-hexlab = { version = "0.3", features = ["bevy"] }
+hexlab = { version = "0.4", features = ["bevy_reflect"] }
 bevy-inspector-egui = { version = "0.28", optional = true }
 bevy_egui = { version = "0.31", optional = true }
 thiserror = "2.0"
diff --git a/justfile b/justfile
index 56e184f..2d1d43f 100644
--- a/justfile
+++ b/justfile
@@ -17,4 +17,3 @@ web-dev:
 # Run web release
 web-release:
     trunk serve --release --no-default-features
-
diff --git a/src/floor/events.rs b/src/floor/events.rs
index 38e2988..cae8f22 100644
--- a/src/floor/events.rs
+++ b/src/floor/events.rs
@@ -1,27 +1,45 @@
 use bevy::prelude::*;
 
-use crate::maze::components::MazeConfig;
+use super::components::Floor;
 
-#[derive(Debug, Reflect, Event)]
-pub struct SpawnFloor {
-    pub floor: u8,
-    pub config: MazeConfig,
-}
-
-#[derive(Debug, Reflect, Event)]
-pub struct RespawnFloor {
-    pub floor: u8,
-    pub config: MazeConfig,
-}
-
-#[derive(Debug, Reflect, Event)]
-pub struct DespawnFloor {
-    pub floor: u8,
-}
-
-#[derive(Debug, Reflect, Event, Default)]
+#[derive(Debug, Clone, Copy, Reflect, Event, Default, PartialEq, Eq)]
 pub enum TransitionFloor {
     #[default]
     Ascend,
     Descend,
 }
+
+impl TransitionFloor {
+    pub fn into_direction(&self) -> f32 {
+        self.into()
+    }
+
+    pub fn opposite(&self) -> Self {
+        match self {
+            Self::Ascend => Self::Descend,
+            Self::Descend => Self::Ascend,
+        }
+    }
+
+    pub fn next_floor_num(&self, floor: &Floor) -> u8 {
+        match self {
+            Self::Ascend => *floor.increased(),
+            Self::Descend => *floor.decreased(),
+        }
+    }
+}
+
+impl From<TransitionFloor> for f32 {
+    fn from(value: TransitionFloor) -> Self {
+        f32::from(&value)
+    }
+}
+
+impl From<&TransitionFloor> for f32 {
+    fn from(value: &TransitionFloor) -> Self {
+        match value {
+            TransitionFloor::Ascend => -1.,
+            TransitionFloor::Descend => 1.,
+        }
+    }
+}
diff --git a/src/floor/mod.rs b/src/floor/mod.rs
index 23e4944..7cb7527 100644
--- a/src/floor/mod.rs
+++ b/src/floor/mod.rs
@@ -1,11 +1,14 @@
 pub mod components;
 pub mod events;
+pub mod resources;
 mod systems;
 
 use bevy::prelude::*;
 use events::TransitionFloor;
+use resources::HighestFloor;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_event::<TransitionFloor>()
+        .insert_resource(HighestFloor(1))
         .add_plugins(systems::plugin);
 }
diff --git a/src/floor/resources.rs b/src/floor/resources.rs
new file mode 100644
index 0000000..80e447c
--- /dev/null
+++ b/src/floor/resources.rs
@@ -0,0 +1,5 @@
+use bevy::prelude::*;
+
+#[derive(Debug, Default, Reflect, Resource, PartialEq, Eq)]
+#[reflect(Resource)]
+pub struct HighestFloor(pub u8);
diff --git a/src/floor/systems/clear_events.rs b/src/floor/systems/clear_events.rs
new file mode 100644
index 0000000..e69de29
diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index 43c50b2..7bdf6e1 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -1,3 +1,4 @@
+mod clear_events;
 mod despawn;
 mod movement;
 mod spawn;
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index 795e985..1b57a67 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -39,11 +39,16 @@ pub(super) fn handle_floor_transition_events(
     next_query: Query<Entity, With<NextFloor>>,
     mut event_reader: EventReader<TransitionFloor>,
 ) {
+    let is_moving = maze_query
+        .iter()
+        .any(|(_, _, movement_state)| movement_state.is_some());
+
+    if is_moving {
+        return;
+    }
+
     for event in event_reader.read() {
-        let direction = match event {
-            TransitionFloor::Ascend => -1.,
-            TransitionFloor::Descend => 1.,
-        };
+        let direction = event.into();
 
         let Some((current_entity, current_y)) = get_floor_info(&maze_query, &current_query) else {
             continue;
@@ -64,6 +69,7 @@ pub(super) fn handle_floor_transition_events(
         }
 
         update_current_next_floor(&mut commands, current_entity, next_entity);
+        break;
     }
 }
 
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
index 083f61b..03d2721 100644
--- a/src/floor/systems/spawn.rs
+++ b/src/floor/systems/spawn.rs
@@ -1,7 +1,8 @@
 use crate::{
     floor::{
-        components::{CurrentFloor, Floor},
+        components::{CurrentFloor, Floor, MovementState},
         events::TransitionFloor,
+        resources::HighestFloor,
     },
     maze::events::SpawnMaze,
 };
@@ -10,23 +11,31 @@ use bevy::prelude::*;
 pub(super) fn spawn_floor(
     mut commands: Commands,
     query: Query<&mut Floor, With<CurrentFloor>>,
+    movement_state_query: Query<Option<&MovementState>>,
     mut event_reader: EventReader<TransitionFloor>,
+    mut highest_floor: ResMut<HighestFloor>,
 ) {
     let Ok(floor) = query.get_single() else {
         return;
     };
 
-    for event in event_reader.read() {
-        let floor = match event {
-            TransitionFloor::Ascend => *floor.increased(),
-            TransitionFloor::Descend => *floor.decreased(),
-        };
+    let is_moving = movement_state_query
+        .iter()
+        .any(|movement_state| movement_state.is_some());
+    if is_moving {
+        return;
+    }
 
-        if floor == 1 {
+    for event in event_reader.read() {
+        let floor = event.next_floor_num(floor);
+
+        if floor == 1 && *event == TransitionFloor::Descend {
             warn!("Cannot descend below floor 1");
             return;
         }
 
+        highest_floor.0 = highest_floor.0.max(floor);
+
         info!("Creating level for floor {}", floor);
 
         commands.trigger(SpawnMaze { floor, ..default() });
diff --git a/src/maze/components.rs b/src/maze/components.rs
index fccb97b..6dbb5d1 100644
--- a/src/maze/components.rs
+++ b/src/maze/components.rs
@@ -1,6 +1,6 @@
 use crate::floor::components::Floor;
 
-use super::{errors::MazeConfigError, GlobalMazeConfig};
+use super::GlobalMazeConfig;
 use bevy::prelude::*;
 use hexlab::HexMaze;
 use hexx::{Hex, HexLayout, HexOrientation};
@@ -22,7 +22,7 @@ pub struct Wall;
 #[derive(Debug, Reflect, Component, Clone)]
 #[reflect(Component)]
 pub struct MazeConfig {
-    pub radius: u32,
+    pub radius: u16,
     pub start_pos: Hex,
     pub end_pos: Hex,
     pub seed: u64,
@@ -31,19 +31,21 @@ pub struct MazeConfig {
 
 impl MazeConfig {
     fn new(
-        radius: u32,
+        radius: u16,
         orientation: HexOrientation,
         seed: Option<u64>,
         global_conig: &GlobalMazeConfig,
-    ) -> Result<Self, MazeConfigError> {
+    ) -> Self {
         let seed = seed.unwrap_or_else(|| thread_rng().gen());
         let mut rng = StdRng::seed_from_u64(seed);
 
-        let start_pos = generate_pos(radius, &mut rng)?;
-        let end_pos = generate_pos(radius, &mut rng)?;
+        let start_pos = generate_pos(radius, &mut rng);
+        let end_pos = generate_pos(radius, &mut rng);
 
-        info!("Start pos: (q={}, r={})", start_pos.x, start_pos.y);
-        info!("End pos: (q={}, r={})", end_pos.x, end_pos.y);
+        info!(
+            "Start pos: (q={}, r={}). End pos: (q={}, r={})",
+            start_pos.x, start_pos.y, end_pos.x, end_pos.y
+        );
 
         let layout = HexLayout {
             orientation,
@@ -51,23 +53,13 @@ impl MazeConfig {
             ..default()
         };
 
-        Ok(Self {
+        Self {
             radius,
             start_pos,
             end_pos,
             seed,
             layout,
-        })
-    }
-
-    pub fn new_unchecked(
-        radius: u32,
-        orientation: HexOrientation,
-        seed: Option<u64>,
-        global_conig: &GlobalMazeConfig,
-    ) -> Self {
-        Self::new(radius, orientation, seed, global_conig)
-            .expect("Failed to create MazeConfig with supposedly safe values")
+        }
     }
 
     pub fn update(&mut self, global_conig: &GlobalMazeConfig) {
@@ -77,14 +69,14 @@ impl MazeConfig {
 
 impl Default for MazeConfig {
     fn default() -> Self {
-        Self::new_unchecked(7, HexOrientation::Flat, None, &GlobalMazeConfig::default())
+        Self::new(8, HexOrientation::Flat, None, &GlobalMazeConfig::default())
     }
 }
 
-fn generate_pos<R: Rng>(radius: u32, rng: &mut R) -> Result<Hex, MazeConfigError> {
-    let radius = i32::try_from(radius)?;
-    Ok(Hex::new(
+fn generate_pos<R: Rng>(radius: u16, rng: &mut R) -> Hex {
+    let radius = radius as i32;
+    Hex::new(
         rng.gen_range(-radius..radius),
         rng.gen_range(-radius..radius),
-    ))
+    )
 }
diff --git a/src/maze/errors.rs b/src/maze/errors.rs
index 87e36a6..f287bdc 100644
--- a/src/maze/errors.rs
+++ b/src/maze/errors.rs
@@ -14,7 +14,7 @@ pub enum MazeError {
     #[error("Floor {0} not found")]
     FloorNotFound(u8),
     #[error("Failed to generate maze with config: {radius}, seed: {seed}")]
-    GenerationFailed { radius: u32, seed: u64 },
+    GenerationFailed { radius: u16, seed: u64 },
     #[error("Invalid tile entity: {0:?}")]
     TileNotFound(bevy::prelude::Entity),
     #[error("Failed to create maze assets")]
@@ -32,7 +32,7 @@ impl MazeError {
         Self::ConfigurationError(msg.into())
     }
 
-    pub const fn generation_failed(radius: u32, seed: u64) -> Self {
+    pub const fn generation_failed(radius: u16, seed: u64) -> Self {
         Self::GenerationFailed { radius, seed }
     }
 }
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index 493fefe..235025f 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -38,7 +38,12 @@ pub(super) fn spawn_maze(
         }
     };
 
-    let y_offset = (floor - 1) * FLOOR_Y_OFFSET;
+    let y_offset = match *floor {
+        1 => 0,
+        _ => FLOOR_Y_OFFSET,
+    } as f32;
+
+    // (floor - 1) * FLOOR_Y_OFFSET
 
     let entity = commands
         .spawn((
@@ -46,7 +51,7 @@ pub(super) fn spawn_maze(
             Maze(maze.clone()),
             Floor(*floor),
             config.clone(),
-            Transform::from_translation(Vec3::ZERO.with_y(y_offset as f32)),
+            Transform::from_translation(Vec3::ZERO.with_y(y_offset)),
             Visibility::Visible,
         ))
         .insert_if(CurrentFloor, || *floor == 1)
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
index c46bf8c..fd95198 100644
--- a/src/player/systems/ascend.rs
+++ b/src/player/systems/ascend.rs
@@ -7,16 +7,17 @@ use bevy::prelude::*;
 
 pub(super) fn ascend_player(
     query: Query<&CurrentPosition, With<Player>>,
-    maze_config_query: Query<&MazeConfig, With<CurrentFloor>>,
+    maze_config: Query<&MazeConfig, With<CurrentFloor>>,
     mut event_writer: EventWriter<TransitionFloor>,
 ) {
-    let Ok(config) = maze_config_query.get_single() else {
+    let Ok(config) = maze_config.get_single() else {
         warn!("Failed to get maze configuration for current floor - cannot ascend player");
         return;
     };
 
     for current_hex in query.iter() {
         if current_hex.0 == config.end_pos {
+            dbg!("Ascend");
             event_writer.send(TransitionFloor::Ascend);
             return;
         }
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
index f885263..be8b4f5 100644
--- a/src/player/systems/descend.rs
+++ b/src/player/systems/descend.rs
@@ -11,10 +11,10 @@ use crate::{
 
 pub(super) fn descend_player(
     query: Query<&CurrentPosition, With<Player>>,
-    maze_config_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
+    maze_config: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
     mut event_writer: EventWriter<TransitionFloor>,
 ) {
-    let Ok((config, floor)) = maze_config_query.get_single() else {
+    let Ok((config, floor)) = maze_config.get_single() else {
         warn!("Failed to get maze configuration for current floor - cannot descend player");
         return;
     };
diff --git a/src/theme/palette/mod.rs b/src/theme/palette/mod.rs
index 960cca2..8a3de0a 100644
--- a/src/theme/palette/mod.rs
+++ b/src/theme/palette/mod.rs
@@ -11,10 +11,12 @@ pub const HEADER_TEXT: Color = Color::srgb(0.867, 0.827, 0.412);
 
 pub const NODE_BACKGROUND: Color = Color::srgb(0.286, 0.478, 0.773);
 
+const MAX_COLOR_VALUE: f32 = 255.;
+
 pub(super) const fn rgb_u8(red: u8, green: u8, blue: u8) -> Color {
     Color::srgb(scale(red), scale(green), scale(blue))
 }
 
 const fn scale(value: u8) -> f32 {
-    value as f32 / 255.
+    value as f32 / MAX_COLOR_VALUE
 }

From 3b5c92e998f709c47d998a98f48a437829a41338 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Fri, 27 Dec 2024 14:01:52 +0200
Subject: [PATCH 13/16] refactor(colorscheme): add RosePine enum

---
 .github/workflows/ci.yaml      |   4 +-
 Cargo.lock                     |  41 ++++++++++++-
 Cargo.toml                     |   5 +-
 src/floor/events.rs            |   4 +-
 src/maze/assets.rs             |  28 ++-------
 src/maze/triggers/spawn.rs     |   5 +-
 src/player/assets.rs           |   8 ++-
 src/theme/colorscheme.rs       | 104 +++++++++++++++++++++++++++++++++
 src/theme/mod.rs               |   2 +
 src/theme/palette/rose_pine.rs |  57 +++++++++++++-----
 10 files changed, 206 insertions(+), 52 deletions(-)
 create mode 100644 src/theme/colorscheme.rs

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8957402..86db61e 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -27,9 +27,7 @@ jobs:
           sweep-cache: true
       - name: Run tests
         run: |
-          cargo test --locked --workspace --all-features --all-targets
-          # Workaround for https://github.com/rust-lang/cargo/issues/6669
-          cargo test --locked --workspace --all-features --doc
+          cargo test --locked --workspace --no-default-features
   # Run clippy lints.
   clippy:
     name: Clippy
diff --git a/Cargo.lock b/Cargo.lock
index cbf1630..6a0317f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2645,6 +2645,12 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.4.0"
@@ -2669,9 +2675,9 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
 name = "hexlab"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f91bb99b0ef58661cc4c18e9bab7bba9e66a3d3047fec9af76e31381647442"
+checksum = "f19ccfce524b2ad659c08508de50522933909ed9787e4c4001cf80d4d380e789"
 dependencies = [
  "bevy_reflect",
  "bevy_utils",
@@ -3159,7 +3165,7 @@ dependencies = [
 
 [[package]]
 name = "maze-ascension"
-version = "0.2.3"
+version = "0.3.0"
 dependencies = [
  "anyhow",
  "bevy",
@@ -3171,6 +3177,7 @@ dependencies = [
  "rand",
  "rstest",
  "rstest_reuse",
+ "strum",
  "test-log",
  "thiserror 2.0.6",
  "tracing",
@@ -4227,6 +4234,12 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"
+
 [[package]]
 name = "rustybuzz"
 version = "0.14.1"
@@ -4465,6 +4478,28 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
 
+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "svg_fmt"
 version = "0.4.4"
diff --git a/Cargo.toml b/Cargo.toml
index 63fcbd0..850f9e2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "maze-ascension"
 authors = ["Kristofers Solo <dev@kristofers.xyz>"]
-version = "0.2.3"
+version = "0.3.0"
 edition = "2021"
 
 [dependencies]
@@ -18,11 +18,12 @@ tracing = { version = "0.1", features = [
   "release_max_level_warn",
 ] }
 hexx = { version = "0.19", features = ["bevy_reflect", "grid"] }
-hexlab = { version = "0.4", features = ["bevy_reflect"] }
+hexlab = { version = "0.5", features = ["bevy_reflect"] }
 bevy-inspector-egui = { version = "0.28", optional = true }
 bevy_egui = { version = "0.31", optional = true }
 thiserror = "2.0"
 anyhow = "1"
+strum = { version = "0.26", features = ["derive"] }
 
 [dev-dependencies]
 rstest = "0.23"
diff --git a/src/floor/events.rs b/src/floor/events.rs
index cae8f22..11b79ab 100644
--- a/src/floor/events.rs
+++ b/src/floor/events.rs
@@ -14,7 +14,7 @@ impl TransitionFloor {
         self.into()
     }
 
-    pub fn opposite(&self) -> Self {
+    pub const fn opposite(&self) -> Self {
         match self {
             Self::Ascend => Self::Descend,
             Self::Descend => Self::Ascend,
@@ -31,7 +31,7 @@ impl TransitionFloor {
 
 impl From<TransitionFloor> for f32 {
     fn from(value: TransitionFloor) -> Self {
-        f32::from(&value)
+        Self::from(&value)
     }
 }
 
diff --git a/src/maze/assets.rs b/src/maze/assets.rs
index f80519b..98ea47c 100644
--- a/src/maze/assets.rs
+++ b/src/maze/assets.rs
@@ -1,8 +1,8 @@
-use crate::theme::palette::rose_pine::{LOVE, PINE};
-
 use super::resources::GlobalMazeConfig;
+use crate::theme::{palette::rose_pine::RosePine, prelude::ColorScheme};
 use bevy::{prelude::*, utils::HashMap};
 use std::f32::consts::FRAC_PI_2;
+use strum::IntoEnumIterator;
 
 const WALL_OVERLAP_MODIFIER: f32 = 1.25;
 const HEX_SIDES: u32 = 6;
@@ -13,7 +13,7 @@ pub struct MazeAssets {
     pub wall_mesh: Handle<Mesh>,
     pub hex_material: Handle<StandardMaterial>,
     pub wall_material: Handle<StandardMaterial>,
-    pub custom_materials: HashMap<String, Handle<StandardMaterial>>,
+    pub custom_materials: HashMap<RosePine, Handle<StandardMaterial>>,
 }
 
 impl MazeAssets {
@@ -22,11 +22,9 @@ impl MazeAssets {
         materials: &mut ResMut<Assets<StandardMaterial>>,
         global_config: &GlobalMazeConfig,
     ) -> Self {
-        let mut custom_materials = HashMap::new();
-        custom_materials.extend(vec![
-            ("LOVE".to_string(), materials.add(red_material())),
-            ("PINE".to_string(), materials.add(blue_material())),
-        ]);
+        let custom_materials = RosePine::iter()
+            .map(|color| (color, materials.add(color.to_standart_material())))
+            .collect();
         Self {
             hex_mesh: meshes.add(generate_hex_mesh(
                 global_config.hex_size,
@@ -73,17 +71,3 @@ pub fn white_material() -> StandardMaterial {
         ..default()
     }
 }
-
-pub fn red_material() -> StandardMaterial {
-    StandardMaterial {
-        emissive: LOVE.to_linear(),
-        ..default()
-    }
-}
-
-pub fn blue_material() -> StandardMaterial {
-    StandardMaterial {
-        emissive: PINE.to_linear(),
-        ..default()
-    }
-}
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index 235025f..93e2725 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -7,6 +7,7 @@ use crate::{
         events::SpawnMaze,
         resources::GlobalMazeConfig,
     },
+    theme::palette::rose_pine::RosePine,
 };
 use bevy::prelude::*;
 use hexlab::prelude::*;
@@ -100,12 +101,12 @@ pub(super) fn spawn_single_hex_tile(
     let material = match tile.pos() {
         pos if pos == maze_config.start_pos => assets
             .custom_materials
-            .get("PINE")
+            .get(&RosePine::Pine)
             .cloned()
             .unwrap_or_default(),
         pos if pos == maze_config.end_pos => assets
             .custom_materials
-            .get("LOVE")
+            .get(&RosePine::Love)
             .cloned()
             .unwrap_or_default(),
         _ => assets.hex_material.clone(),
diff --git a/src/player/assets.rs b/src/player/assets.rs
index f4be8fa..fe2c77a 100644
--- a/src/player/assets.rs
+++ b/src/player/assets.rs
@@ -1,6 +1,7 @@
-use crate::theme::palette::rose_pine::PINE;
 use bevy::prelude::*;
 
+use crate::theme::{palette::rose_pine::RosePine, prelude::ColorScheme};
+
 pub(super) fn generate_pill_mesh(radius: f32, half_length: f32) -> Mesh {
     Mesh::from(Capsule3d {
         radius,
@@ -9,9 +10,10 @@ pub(super) fn generate_pill_mesh(radius: f32, half_length: f32) -> Mesh {
 }
 
 pub(super) fn blue_material() -> StandardMaterial {
+    let color = RosePine::Pine;
     StandardMaterial {
-        base_color: PINE,
-        emissive: PINE.to_linear() * 3.,
+        base_color: color.to_color(),
+        emissive: color.to_linear_rgba() * 3.,
         ..default()
     }
 }
diff --git a/src/theme/colorscheme.rs b/src/theme/colorscheme.rs
new file mode 100644
index 0000000..2552fc4
--- /dev/null
+++ b/src/theme/colorscheme.rs
@@ -0,0 +1,104 @@
+use bevy::prelude::*;
+use std::ops::Deref;
+
+/// A trait for types that can be converted to a Bevy `Color`.
+///
+/// Implementing this trait allows a type to be easily converted to various Bevy color types.
+///
+/// # Examples
+///
+/// ```
+/// use bevy::prelude::*;
+/// use maze_ascension::theme::prelude::ColorScheme;
+///
+/// struct MyColor(u8, u8, u8);
+///
+/// impl ColorScheme for MyColor {
+///     fn to_color(&self) -> Color {
+///         Color::srgb(
+///             self.0 as f32 / 255.0,
+///             self.1 as f32 / 255.0,
+///             self.2 as f32 / 255.0
+///         )
+///     }
+/// }
+///
+/// let my_color = MyColor(255, 0, 0);
+/// let bevy_color: Color = my_color.to_color();
+/// assert_eq!(bevy_color, Color::srgb(1., 0., 0.));
+/// ```
+pub trait ColorScheme {
+    /// Converts the implementing type to a Bevy `Color`.
+    fn to_color(&self) -> Color;
+
+    /// Converts the implementing type to a Bevy `LinearRgba`.
+    ///
+    /// This method provides a default implementation based on `to_color()`.
+    fn to_linear_rgba(&self) -> LinearRgba {
+        self.to_color().to_linear()
+    }
+
+    /// Converts the implementing type to a Bevy `StandardMaterial`.
+    ///
+    /// This method provides a default implementation that sets the emissive color.
+    fn to_standart_material(&self) -> StandardMaterial {
+        StandardMaterial {
+            emissive: self.to_linear_rgba(),
+            ..default()
+        }
+    }
+}
+
+/// A wrapper type that implements `From` traits for types implementing `ColorScheme`.
+///
+/// This wrapper allows for easy conversion from `ColorScheme` types to Bevy color types.
+///
+/// # Examples
+///
+/// ```
+/// use bevy::prelude::*;
+/// use maze_ascension::theme::prelude::{ColorScheme, ColorSchemeWrapper};
+///
+/// struct MyColor(u8, u8, u8);
+///
+/// impl ColorScheme for MyColor {
+///     fn to_color(&self) -> Color {
+///         Color::srgb(
+///             self.0 as f32 / 255.0,
+///             self.1 as f32 / 255.0,
+///             self.2 as f32 / 255.0
+///         )
+///     }
+/// }
+///
+/// let my_color = MyColor(0, 255, 0);
+/// let wrapper = ColorSchemeWrapper(my_color);
+/// let bevy_color: Color = wrapper.into();
+/// assert_eq!(bevy_color, Color::srgb(0., 1., 0.));
+/// ```
+pub struct ColorSchemeWrapper<T: ColorScheme>(pub T);
+
+impl<T: ColorScheme> From<T> for ColorSchemeWrapper<T> {
+    fn from(value: T) -> Self {
+        Self(value)
+    }
+}
+
+impl<T: ColorScheme> Deref for ColorSchemeWrapper<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: ColorScheme> From<ColorSchemeWrapper<T>> for Color {
+    fn from(value: ColorSchemeWrapper<T>) -> Self {
+        value.to_color()
+    }
+}
+
+impl<T: ColorScheme> From<ColorSchemeWrapper<T>> for LinearRgba {
+    fn from(value: ColorSchemeWrapper<T>) -> Self {
+        value.to_linear_rgba()
+    }
+}
diff --git a/src/theme/mod.rs b/src/theme/mod.rs
index 1d0e466..86f1e5c 100644
--- a/src/theme/mod.rs
+++ b/src/theme/mod.rs
@@ -2,6 +2,7 @@
 
 // Unused utilities may trigger this lints undesirably.
 
+mod colorscheme;
 pub mod interaction;
 pub mod palette;
 mod widgets;
@@ -9,6 +10,7 @@ mod widgets;
 #[allow(unused_imports)]
 pub mod prelude {
     pub use super::{
+        colorscheme::{ColorScheme, ColorSchemeWrapper},
         interaction::{InteractionPalette, OnPress},
         palette as ui_palette,
         widgets::{Containers as _, Widgets as _},
diff --git a/src/theme/palette/rose_pine.rs b/src/theme/palette/rose_pine.rs
index e69a56b..5d1fa3e 100644
--- a/src/theme/palette/rose_pine.rs
+++ b/src/theme/palette/rose_pine.rs
@@ -1,18 +1,45 @@
 use super::rgb_u8;
+use crate::theme::prelude::ColorScheme;
 use bevy::prelude::*;
+use strum::EnumIter;
 
-pub const BASE: Color = rgb_u8(25, 23, 36);
-pub const SURFACE: Color = rgb_u8(31, 29, 46);
-pub const OVERLAY: Color = rgb_u8(38, 35, 58);
-pub const MUTED: Color = rgb_u8(110, 106, 134);
-pub const SUBTLE: Color = rgb_u8(144, 140, 170);
-pub const TEXT: Color = rgb_u8(224, 222, 244);
-pub const LOVE: Color = rgb_u8(235, 111, 146);
-pub const GOLD: Color = rgb_u8(246, 193, 119);
-pub const ROSE: Color = rgb_u8(235, 188, 186);
-pub const PINE: Color = rgb_u8(49, 116, 143);
-pub const FOAM: Color = rgb_u8(156, 207, 216);
-pub const IRIS: Color = rgb_u8(196, 167, 231);
-pub const HIGHLIGHT_LOW: Color = rgb_u8(33, 32, 46);
-pub const HIGHLIGHT_MED: Color = rgb_u8(64, 61, 82);
-pub const HIGHLIGHT_HIGH: Color = rgb_u8(82, 79, 103);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]
+pub enum RosePine {
+    Base,
+    Surface,
+    Overlay,
+    Muted,
+    Subtle,
+    Text,
+    Love,
+    Gold,
+    Rose,
+    Pine,
+    Foam,
+    Iris,
+    HighlightLow,
+    HighlightMed,
+    HighlightHigh,
+}
+
+impl ColorScheme for RosePine {
+    fn to_color(&self) -> Color {
+        match self {
+            Self::Base => rgb_u8(25, 23, 36),
+            Self::Surface => rgb_u8(31, 29, 46),
+            Self::Overlay => rgb_u8(38, 35, 58),
+            Self::Muted => rgb_u8(110, 106, 134),
+            Self::Subtle => rgb_u8(144, 140, 170),
+            Self::Text => rgb_u8(224, 222, 244),
+            Self::Love => rgb_u8(235, 111, 146),
+            Self::Gold => rgb_u8(246, 193, 119),
+            Self::Rose => rgb_u8(235, 188, 186),
+            Self::Pine => rgb_u8(49, 116, 143),
+            Self::Foam => rgb_u8(156, 207, 216),
+            Self::Iris => rgb_u8(196, 167, 231),
+            Self::HighlightLow => rgb_u8(33, 32, 46),
+            Self::HighlightMed => rgb_u8(64, 61, 82),
+            Self::HighlightHigh => rgb_u8(82, 79, 103),
+        }
+    }
+}

From 9e3538f57115453982454f8e0a28431a2262345c Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Sun, 29 Dec 2024 17:11:31 +0200
Subject: [PATCH 14/16] fix: hexlab changes

---
 Cargo.lock                  | 4 ++--
 src/maze/components.rs      | 2 +-
 src/maze/triggers/common.rs | 2 +-
 src/maze/triggers/spawn.rs  | 2 +-
 src/player/systems/input.rs | 3 ++-
 5 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6a0317f..f435802 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2675,9 +2675,9 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
 name = "hexlab"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f19ccfce524b2ad659c08508de50522933909ed9787e4c4001cf80d4d380e789"
+checksum = "7bd7c21f4e2c11d40473d1ae673905f4deae3b12104fa6d70eeef9ef385aceb6"
 dependencies = [
  "bevy_reflect",
  "bevy_utils",
diff --git a/src/maze/components.rs b/src/maze/components.rs
index 6dbb5d1..3aa83f8 100644
--- a/src/maze/components.rs
+++ b/src/maze/components.rs
@@ -2,7 +2,7 @@ use crate::floor::components::Floor;
 
 use super::GlobalMazeConfig;
 use bevy::prelude::*;
-use hexlab::HexMaze;
+use hexlab::Maze as HexMaze;
 use hexx::{Hex, HexLayout, HexOrientation};
 use rand::{rngs::StdRng, thread_rng, Rng, SeedableRng};
 
diff --git a/src/maze/triggers/common.rs b/src/maze/triggers/common.rs
index c39b539..67e2aa7 100644
--- a/src/maze/triggers/common.rs
+++ b/src/maze/triggers/common.rs
@@ -2,7 +2,7 @@ use crate::maze::{
     components::MazeConfig,
     errors::{MazeError, MazeResult},
 };
-use hexlab::{GeneratorType, HexMaze, MazeBuilder};
+use hexlab::prelude::{Maze as HexMaze, *};
 
 pub fn generate_maze(config: &MazeConfig) -> MazeResult<HexMaze> {
     MazeBuilder::new()
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index 93e2725..bb0cbc3 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -10,7 +10,7 @@ use crate::{
     theme::palette::rose_pine::RosePine,
 };
 use bevy::prelude::*;
-use hexlab::prelude::*;
+use hexlab::prelude::{Maze as HexMaze, Tile as HexTile, *};
 use hexx::HexOrientation;
 use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
diff --git a/src/player/systems/input.rs b/src/player/systems/input.rs
index f536e76..3482a3a 100644
--- a/src/player/systems/input.rs
+++ b/src/player/systems/input.rs
@@ -4,6 +4,7 @@ use crate::{
     player::components::{CurrentPosition, MovementTarget, Player},
 };
 use bevy::prelude::*;
+use hexlab::WallStorage;
 use hexx::{EdgeDirection, HexOrientation};
 
 pub(super) fn player_input(
@@ -24,7 +25,7 @@ pub(super) fn player_input(
             continue;
         };
 
-        let Some(tile) = maze.0.get_tile(current_pos) else {
+        let Some(tile) = maze.0.get(current_pos) else {
             continue;
         };
 

From 90f54438048cafa7c4af70fceb493d4f091d2cc4 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Mon, 30 Dec 2024 17:33:09 +0200
Subject: [PATCH 15/16] feat(hexlab): enable bevy feature

---
 Cargo.lock                    |  1 +
 Cargo.toml                    |  2 +-
 src/floor/systems/movement.rs |  8 ++++----
 src/maze/components.rs        |  6 +++---
 src/maze/mod.rs               |  4 ++--
 src/maze/triggers/common.rs   |  4 ++--
 src/maze/triggers/respawn.rs  | 10 ++++------
 src/maze/triggers/spawn.rs    |  9 +++++----
 src/player/systems/input.rs   |  6 +++---
 9 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f435802..80fa240 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2679,6 +2679,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7bd7c21f4e2c11d40473d1ae673905f4deae3b12104fa6d70eeef9ef385aceb6"
 dependencies = [
+ "bevy",
  "bevy_reflect",
  "bevy_utils",
  "glam",
diff --git a/Cargo.toml b/Cargo.toml
index 850f9e2..51fdb63 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,7 @@ tracing = { version = "0.1", features = [
   "release_max_level_warn",
 ] }
 hexx = { version = "0.19", features = ["bevy_reflect", "grid"] }
-hexlab = { version = "0.5", features = ["bevy_reflect"] }
+hexlab = { version = "0.5", features = ["bevy"] }
 bevy-inspector-egui = { version = "0.28", optional = true }
 bevy_egui = { version = "0.31", optional = true }
 thiserror = "2.0"
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index 1b57a67..c2d9252 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -3,7 +3,7 @@ use crate::{
         components::{CurrentFloor, MovementState, NextFloor},
         events::TransitionFloor,
     },
-    maze::components::Maze,
+    maze::components::HexMaze,
     player::components::{MovementSpeed, Player},
 };
 use bevy::prelude::*;
@@ -12,7 +12,7 @@ const MOVEMENT_THRESHOLD: f32 = 0.001;
 
 pub(super) fn move_floors(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
+    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
     player_query: Query<&MovementSpeed, With<Player>>,
     time: Res<Time>,
 ) {
@@ -34,7 +34,7 @@ pub(super) fn move_floors(
 
 pub(super) fn handle_floor_transition_events(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
+    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
     current_query: Query<Entity, With<CurrentFloor>>,
     next_query: Query<Entity, With<NextFloor>>,
     mut event_reader: EventReader<TransitionFloor>,
@@ -82,7 +82,7 @@ fn update_current_next_floor(commands: &mut Commands, current_entity: Entity, ne
 }
 
 fn get_floor_info(
-    maze_query: &Query<(Entity, &mut Transform, Option<&mut MovementState>), With<Maze>>,
+    maze_query: &Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
     query: &Query<Entity, With<impl Component>>,
 ) -> Option<(Entity, f32)> {
     query.get_single().ok().and_then(|entity| {
diff --git a/src/maze/components.rs b/src/maze/components.rs
index 3aa83f8..8cc9edc 100644
--- a/src/maze/components.rs
+++ b/src/maze/components.rs
@@ -2,14 +2,14 @@ use crate::floor::components::Floor;
 
 use super::GlobalMazeConfig;
 use bevy::prelude::*;
-use hexlab::Maze as HexMaze;
+use hexlab::Maze;
 use hexx::{Hex, HexLayout, HexOrientation};
 use rand::{rngs::StdRng, thread_rng, Rng, SeedableRng};
 
 #[derive(Debug, Reflect, Component)]
 #[reflect(Component)]
-#[require(MazeConfig, Floor)]
-pub struct Maze(pub HexMaze);
+#[require(MazeConfig, Floor, Maze)]
+pub struct HexMaze;
 
 #[derive(Debug, Reflect, Component)]
 #[reflect(Component)]
diff --git a/src/maze/mod.rs b/src/maze/mod.rs
index 16f2541..2e2a644 100644
--- a/src/maze/mod.rs
+++ b/src/maze/mod.rs
@@ -7,7 +7,7 @@ mod systems;
 mod triggers;
 
 use bevy::{ecs::system::RunSystemOnce, prelude::*};
-use components::Maze;
+use components::HexMaze;
 use events::{DespawnMaze, RespawnMaze, SpawnMaze};
 pub use resources::{GlobalMazeConfig, MazePluginLoaded};
 
@@ -16,7 +16,7 @@ pub(super) fn plugin(app: &mut App) {
         .add_event::<SpawnMaze>()
         .add_event::<RespawnMaze>()
         .add_event::<DespawnMaze>()
-        .register_type::<Maze>()
+        .register_type::<HexMaze>()
         .add_plugins((systems::plugin, triggers::plugin));
 }
 
diff --git a/src/maze/triggers/common.rs b/src/maze/triggers/common.rs
index 67e2aa7..378d6c8 100644
--- a/src/maze/triggers/common.rs
+++ b/src/maze/triggers/common.rs
@@ -2,9 +2,9 @@ use crate::maze::{
     components::MazeConfig,
     errors::{MazeError, MazeResult},
 };
-use hexlab::prelude::{Maze as HexMaze, *};
+use hexlab::prelude::*;
 
-pub fn generate_maze(config: &MazeConfig) -> MazeResult<HexMaze> {
+pub fn generate_maze(config: &MazeConfig) -> MazeResult<Maze> {
     MazeBuilder::new()
         .with_radius(config.radius)
         .with_seed(config.seed)
diff --git a/src/maze/triggers/respawn.rs b/src/maze/triggers/respawn.rs
index 5daf94a..fd8f957 100644
--- a/src/maze/triggers/respawn.rs
+++ b/src/maze/triggers/respawn.rs
@@ -1,12 +1,10 @@
 use super::{common::generate_maze, spawn::spawn_maze_tiles};
 use crate::{
     floor::components::Floor,
-    maze::{
-        assets::MazeAssets, components::Maze, errors::MazeError, events::RespawnMaze,
-        GlobalMazeConfig,
-    },
+    maze::{assets::MazeAssets, errors::MazeError, events::RespawnMaze, GlobalMazeConfig},
 };
 use bevy::prelude::*;
+use hexlab::Maze;
 
 pub(super) fn respawn_maze(
     trigger: Trigger<RespawnMaze>,
@@ -30,7 +28,7 @@ pub(super) fn respawn_maze(
         }
     };
 
-    maze.0 = match generate_maze(config) {
+    *maze = match generate_maze(config) {
         Ok(generated_maze) => generated_maze,
         Err(e) => {
             warn!("Failed to update floor ({floor}). {e}");
@@ -43,7 +41,7 @@ pub(super) fn respawn_maze(
     spawn_maze_tiles(
         &mut commands,
         entity,
-        &maze.0,
+        &maze,
         &assets,
         config,
         &global_config,
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index bb0cbc3..b982385 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -3,14 +3,14 @@ use crate::{
     floor::components::{CurrentFloor, Floor, NextFloor},
     maze::{
         assets::MazeAssets,
-        components::{Maze, MazeConfig, Tile, Wall},
+        components::{HexMaze, MazeConfig, Tile, Wall},
         events::SpawnMaze,
         resources::GlobalMazeConfig,
     },
     theme::palette::rose_pine::RosePine,
 };
 use bevy::prelude::*;
-use hexlab::prelude::{Maze as HexMaze, Tile as HexTile, *};
+use hexlab::prelude::{Tile as HexTile, *};
 use hexx::HexOrientation;
 use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
@@ -49,7 +49,8 @@ pub(super) fn spawn_maze(
     let entity = commands
         .spawn((
             Name::new(format!("Floor {}", floor)),
-            Maze(maze.clone()),
+            HexMaze,
+            maze.clone(),
             Floor(*floor),
             config.clone(),
             Transform::from_translation(Vec3::ZERO.with_y(y_offset)),
@@ -73,7 +74,7 @@ pub(super) fn spawn_maze(
 pub fn spawn_maze_tiles(
     commands: &mut Commands,
     parent_entity: Entity,
-    maze: &HexMaze,
+    maze: &Maze,
     assets: &MazeAssets,
     maze_config: &MazeConfig,
     global_config: &GlobalMazeConfig,
diff --git a/src/player/systems/input.rs b/src/player/systems/input.rs
index 3482a3a..0a87016 100644
--- a/src/player/systems/input.rs
+++ b/src/player/systems/input.rs
@@ -1,10 +1,10 @@
 use crate::{
     floor::components::CurrentFloor,
-    maze::components::{Maze, MazeConfig},
+    maze::components::MazeConfig,
     player::components::{CurrentPosition, MovementTarget, Player},
 };
 use bevy::prelude::*;
-use hexlab::WallStorage;
+use hexlab::prelude::*;
 use hexx::{EdgeDirection, HexOrientation};
 
 pub(super) fn player_input(
@@ -25,7 +25,7 @@ pub(super) fn player_input(
             continue;
         };
 
-        let Some(tile) = maze.0.get(current_pos) else {
+        let Some(tile) = maze.get(current_pos) else {
             continue;
         };
 

From e352b45401bb9c15c5b86d2d705321e6c65cc3e9 Mon Sep 17 00:00:00 2001
From: Kristofers Solo <dev@kristofers.xyz>
Date: Wed, 1 Jan 2025 22:53:57 +0200
Subject: [PATCH 16/16] chore: rename MovementState -> FloorYTarget

---
 src/constants.rs                          |  3 ++
 src/floor/components.rs                   |  7 +--
 src/floor/systems/mod.rs                  |  3 +-
 src/floor/systems/movement.rs             | 59 +++++++++--------------
 src/floor/systems/spawn.rs                | 12 +----
 src/lib.rs                                |  1 +
 src/maze/assets.rs                        |  6 ++-
 src/maze/triggers/spawn.rs                |  3 +-
 src/player/systems/ascend.rs              | 25 ----------
 src/player/systems/descend.rs             | 28 -----------
 src/player/systems/mod.rs                 | 13 ++---
 src/player/systems/movement.rs            |  3 +-
 src/player/systems/vertical_transition.rs | 37 ++++++++++++++
 13 files changed, 81 insertions(+), 119 deletions(-)
 create mode 100644 src/constants.rs
 delete mode 100644 src/player/systems/ascend.rs
 delete mode 100644 src/player/systems/descend.rs
 create mode 100644 src/player/systems/vertical_transition.rs

diff --git a/src/constants.rs b/src/constants.rs
new file mode 100644
index 0000000..5e5fb5b
--- /dev/null
+++ b/src/constants.rs
@@ -0,0 +1,3 @@
+pub const MOVEMENT_THRESHOLD: f32 = 0.01;
+pub const WALL_OVERLAP_MODIFIER: f32 = 1.25;
+pub const FLOOR_Y_OFFSET: u8 = 100;
diff --git a/src/floor/components.rs b/src/floor/components.rs
index 570d919..65ab700 100644
--- a/src/floor/components.rs
+++ b/src/floor/components.rs
@@ -12,12 +12,9 @@ pub struct CurrentFloor;
 #[reflect(Component)]
 pub struct NextFloor;
 
-#[derive(Debug, Reflect, Component)]
+#[derive(Debug, Reflect, Component, Deref, DerefMut)]
 #[reflect(Component)]
-pub struct MovementState {
-    pub target_y: f32,
-    pub direction: f32,
-}
+pub struct FloorYTarget(pub f32);
 
 impl Default for Floor {
     fn default() -> Self {
diff --git a/src/floor/systems/mod.rs b/src/floor/systems/mod.rs
index 7bdf6e1..2d424d4 100644
--- a/src/floor/systems/mod.rs
+++ b/src/floor/systems/mod.rs
@@ -16,9 +16,8 @@ pub(super) fn plugin(app: &mut App) {
             spawn_floor,
             despawn_floor,
             handle_floor_transition_events,
-            move_floors,
+            move_floors.after(handle_floor_transition_events),
         )
-            .chain()
             .run_if(resource_exists::<MazePluginLoaded>),
     );
 }
diff --git a/src/floor/systems/movement.rs b/src/floor/systems/movement.rs
index c2d9252..ec8ce20 100644
--- a/src/floor/systems/movement.rs
+++ b/src/floor/systems/movement.rs
@@ -1,40 +1,41 @@
 use crate::{
+    constants::{FLOOR_Y_OFFSET, MOVEMENT_THRESHOLD},
     floor::{
-        components::{CurrentFloor, MovementState, NextFloor},
+        components::{CurrentFloor, FloorYTarget, NextFloor},
         events::TransitionFloor,
     },
     maze::components::HexMaze,
     player::components::{MovementSpeed, Player},
 };
+
 use bevy::prelude::*;
 
-const MOVEMENT_THRESHOLD: f32 = 0.001;
-
-pub(super) fn move_floors(
+pub fn move_floors(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
+    mut maze_query: Query<
+        (Entity, &mut Transform, &FloorYTarget),
+        (With<HexMaze>, With<FloorYTarget>),
+    >,
     player_query: Query<&MovementSpeed, With<Player>>,
     time: Res<Time>,
 ) {
     let speed = player_query.get_single().map_or(100., |s| s.0);
     let movement_distance = speed * time.delta_secs();
-    for (entity, mut transform, mut movement_state) in maze_query.iter_mut() {
-        if let Some(state) = movement_state.as_mut() {
-            let delta = state.target_y - transform.translation.y;
-            if delta.abs() > MOVEMENT_THRESHOLD {
-                let movement = delta.signum() * movement_distance.min(delta.abs());
-                transform.translation.y += movement;
-            } else {
-                transform.translation.y = state.target_y;
-                commands.entity(entity).remove::<MovementState>();
-            }
+    for (entity, mut transform, movement_state) in maze_query.iter_mut() {
+        let delta = movement_state.0 - transform.translation.y;
+        if delta.abs() > MOVEMENT_THRESHOLD {
+            let movement = delta.signum() * movement_distance.min(delta.abs());
+            transform.translation.y += movement;
+        } else {
+            transform.translation.y = movement_state.0;
+            commands.entity(entity).remove::<FloorYTarget>();
         }
     }
 }
 
-pub(super) fn handle_floor_transition_events(
+pub fn handle_floor_transition_events(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
+    mut maze_query: Query<(Entity, &Transform, Option<&FloorYTarget>), With<HexMaze>>,
     current_query: Query<Entity, With<CurrentFloor>>,
     next_query: Query<Entity, With<NextFloor>>,
     mut event_reader: EventReader<TransitionFloor>,
@@ -50,21 +51,17 @@ pub(super) fn handle_floor_transition_events(
     for event in event_reader.read() {
         let direction = event.into();
 
-        let Some((current_entity, current_y)) = get_floor_info(&maze_query, &current_query) else {
+        let Some(current_entity) = current_query.get_single().ok() else {
             continue;
         };
-        let Some((next_entity, next_y)) = get_floor_info(&maze_query, &next_query) else {
+        let Some(next_entity) = next_query.get_single().ok() else {
             continue;
         };
-        let diff = (current_y - next_y).abs();
 
         for (entity, transforms, movement_state) in maze_query.iter_mut() {
-            let target_y = diff.mul_add(direction, transforms.translation.y);
+            let target_y = (FLOOR_Y_OFFSET as f32).mul_add(direction, transforms.translation.y);
             if movement_state.is_none() {
-                commands.entity(entity).insert(MovementState {
-                    target_y,
-                    direction,
-                });
+                commands.entity(entity).insert(FloorYTarget(target_y));
             }
         }
 
@@ -80,15 +77,3 @@ fn update_current_next_floor(commands: &mut Commands, current_entity: Entity, ne
         .remove::<NextFloor>()
         .insert(CurrentFloor);
 }
-
-fn get_floor_info(
-    maze_query: &Query<(Entity, &mut Transform, Option<&mut MovementState>), With<HexMaze>>,
-    query: &Query<Entity, With<impl Component>>,
-) -> Option<(Entity, f32)> {
-    query.get_single().ok().and_then(|entity| {
-        maze_query
-            .get(entity)
-            .ok()
-            .map(|(_, transform, _)| (entity, transform.translation.y))
-    })
-}
diff --git a/src/floor/systems/spawn.rs b/src/floor/systems/spawn.rs
index 03d2721..e2a143b 100644
--- a/src/floor/systems/spawn.rs
+++ b/src/floor/systems/spawn.rs
@@ -1,6 +1,6 @@
 use crate::{
     floor::{
-        components::{CurrentFloor, Floor, MovementState},
+        components::{CurrentFloor, Floor, FloorYTarget},
         events::TransitionFloor,
         resources::HighestFloor,
     },
@@ -10,8 +10,7 @@ use bevy::prelude::*;
 
 pub(super) fn spawn_floor(
     mut commands: Commands,
-    query: Query<&mut Floor, With<CurrentFloor>>,
-    movement_state_query: Query<Option<&MovementState>>,
+    query: Query<&mut Floor, (With<CurrentFloor>, Without<FloorYTarget>)>,
     mut event_reader: EventReader<TransitionFloor>,
     mut highest_floor: ResMut<HighestFloor>,
 ) {
@@ -19,13 +18,6 @@ pub(super) fn spawn_floor(
         return;
     };
 
-    let is_moving = movement_state_query
-        .iter()
-        .any(|movement_state| movement_state.is_some());
-    if is_moving {
-        return;
-    }
-
     for event in event_reader.read() {
         let floor = event.next_floor_num(floor);
 
diff --git a/src/lib.rs b/src/lib.rs
index 94bbcf7..ef7ecd9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod asset_tracking;
 pub mod audio;
+pub mod constants;
 #[cfg(feature = "dev")]
 pub mod dev_tools;
 pub mod floor;
diff --git a/src/maze/assets.rs b/src/maze/assets.rs
index 98ea47c..2548297 100644
--- a/src/maze/assets.rs
+++ b/src/maze/assets.rs
@@ -1,10 +1,12 @@
 use super::resources::GlobalMazeConfig;
-use crate::theme::{palette::rose_pine::RosePine, prelude::ColorScheme};
+use crate::{
+    constants::WALL_OVERLAP_MODIFIER,
+    theme::{palette::rose_pine::RosePine, prelude::ColorScheme},
+};
 use bevy::{prelude::*, utils::HashMap};
 use std::f32::consts::FRAC_PI_2;
 use strum::IntoEnumIterator;
 
-const WALL_OVERLAP_MODIFIER: f32 = 1.25;
 const HEX_SIDES: u32 = 6;
 const WHITE_EMISSION_INTENSITY: f32 = 10.;
 
diff --git a/src/maze/triggers/spawn.rs b/src/maze/triggers/spawn.rs
index b982385..afd3cb1 100644
--- a/src/maze/triggers/spawn.rs
+++ b/src/maze/triggers/spawn.rs
@@ -1,5 +1,6 @@
 use super::common::generate_maze;
 use crate::{
+    constants::FLOOR_Y_OFFSET,
     floor::components::{CurrentFloor, Floor, NextFloor},
     maze::{
         assets::MazeAssets,
@@ -14,8 +15,6 @@ use hexlab::prelude::{Tile as HexTile, *};
 use hexx::HexOrientation;
 use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_6};
 
-pub const FLOOR_Y_OFFSET: u8 = 100;
-
 pub(super) fn spawn_maze(
     trigger: Trigger<SpawnMaze>,
     mut commands: Commands,
diff --git a/src/player/systems/ascend.rs b/src/player/systems/ascend.rs
deleted file mode 100644
index fd95198..0000000
--- a/src/player/systems/ascend.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use crate::{
-    floor::{components::CurrentFloor, events::TransitionFloor},
-    maze::components::MazeConfig,
-    player::components::{CurrentPosition, Player},
-};
-use bevy::prelude::*;
-
-pub(super) fn ascend_player(
-    query: Query<&CurrentPosition, With<Player>>,
-    maze_config: Query<&MazeConfig, With<CurrentFloor>>,
-    mut event_writer: EventWriter<TransitionFloor>,
-) {
-    let Ok(config) = maze_config.get_single() else {
-        warn!("Failed to get maze configuration for current floor - cannot ascend player");
-        return;
-    };
-
-    for current_hex in query.iter() {
-        if current_hex.0 == config.end_pos {
-            dbg!("Ascend");
-            event_writer.send(TransitionFloor::Ascend);
-            return;
-        }
-    }
-}
diff --git a/src/player/systems/descend.rs b/src/player/systems/descend.rs
deleted file mode 100644
index be8b4f5..0000000
--- a/src/player/systems/descend.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use bevy::prelude::*;
-
-use crate::{
-    floor::{
-        components::{CurrentFloor, Floor},
-        events::TransitionFloor,
-    },
-    maze::components::MazeConfig,
-    player::components::{CurrentPosition, Player},
-};
-
-pub(super) fn descend_player(
-    query: Query<&CurrentPosition, With<Player>>,
-    maze_config: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
-    mut event_writer: EventWriter<TransitionFloor>,
-) {
-    let Ok((config, floor)) = maze_config.get_single() else {
-        warn!("Failed to get maze configuration for current floor - cannot descend player");
-        return;
-    };
-
-    for current_hex in query.iter() {
-        if current_hex.0 == config.start_pos && floor.0 != 1 {
-            event_writer.send(TransitionFloor::Descend);
-            return;
-        }
-    }
-}
diff --git a/src/player/systems/mod.rs b/src/player/systems/mod.rs
index df081cd..c71e33d 100644
--- a/src/player/systems/mod.rs
+++ b/src/player/systems/mod.rs
@@ -1,21 +1,22 @@
-mod ascend;
-mod descend;
 mod input;
 mod movement;
 pub mod setup;
+mod vertical_transition;
 
 use crate::maze::MazePluginLoaded;
-use ascend::ascend_player;
 use bevy::prelude::*;
-use descend::descend_player;
 use input::player_input;
 use movement::player_movement;
+use vertical_transition::handle_floor_transition;
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         Update,
-        (player_input, player_movement, ascend_player, descend_player)
-            .chain()
+        (
+            player_input,
+            player_movement.after(player_input),
+            handle_floor_transition,
+        )
             .run_if(resource_exists::<MazePluginLoaded>),
     );
 }
diff --git a/src/player/systems/movement.rs b/src/player/systems/movement.rs
index fba7989..d47b8dd 100644
--- a/src/player/systems/movement.rs
+++ b/src/player/systems/movement.rs
@@ -1,4 +1,5 @@
 use crate::{
+    constants::MOVEMENT_THRESHOLD,
     floor::components::CurrentFloor,
     maze::components::MazeConfig,
     player::components::{CurrentPosition, MovementSpeed, MovementTarget, Player},
@@ -6,8 +7,6 @@ use crate::{
 use bevy::prelude::*;
 use hexx::Hex;
 
-const MOVEMENT_THRESHOLD: f32 = 0.1;
-
 pub(super) fn player_movement(
     time: Res<Time>,
     mut query: Query<
diff --git a/src/player/systems/vertical_transition.rs b/src/player/systems/vertical_transition.rs
new file mode 100644
index 0000000..f56cc07
--- /dev/null
+++ b/src/player/systems/vertical_transition.rs
@@ -0,0 +1,37 @@
+use bevy::prelude::*;
+
+use crate::{
+    floor::{
+        components::{CurrentFloor, Floor},
+        events::TransitionFloor,
+    },
+    maze::components::MazeConfig,
+    player::components::{CurrentPosition, Player},
+};
+
+pub fn handle_floor_transition(
+    player_query: Query<&CurrentPosition, With<Player>>,
+    maze_query: Query<(&MazeConfig, &Floor), With<CurrentFloor>>,
+    mut event_writer: EventWriter<TransitionFloor>,
+) {
+    let Ok((config, floor)) = maze_query.get_single() else {
+        warn!("Failed to get maze configuration for current floor - cannot ascend/descend player.");
+        return;
+    };
+
+    for current_hex in player_query.iter() {
+        // Check for ascending
+        if current_hex.0 == config.end_pos {
+            dbg!("Ascending");
+            event_writer.send(TransitionFloor::Ascend);
+            return;
+        }
+
+        // Check for descending
+        if current_hex.0 == config.start_pos && floor.0 != 1 {
+            dbg!("Descending");
+            event_writer.send(TransitionFloor::Descend);
+            return;
+        }
+    }
+}