fix(floor): descend

src/floor/components.rs

@@ -8,10 +8,6 @@ pub struct Floor(pub u8);
 #[reflect(Component)]
 pub struct CurrentFloor;
 
-#[derive(Debug, Reflect, Component)]
-#[reflect(Component)]
-pub struct NextFloor;
-
 #[derive(Debug, Reflect, Component, Deref, DerefMut)]
 #[reflect(Component)]
 pub struct FloorYTarget(pub f32);

src/floor/events.rs

@@ -38,8 +38,8 @@ impl From<TransitionFloor> for f32 {
 impl From<&TransitionFloor> for f32 {
     fn from(value: &TransitionFloor) -> Self {
         match value {
-            TransitionFloor::Ascend => -1.,
+            TransitionFloor::Ascend => -1., // When ascending, floors move down
-            TransitionFloor::Descend => 1.,
+            TransitionFloor::Descend => 1., // When descending, floors move up
         }
     }
 }

src/floor/systems/clear_events.rs

@@ -1 +0,0 @@
-

src/floor/systems/mod.rs

@@ -1,4 +1,3 @@
-mod clear_events;
 mod despawn;
 mod movement;
 mod spawn;

src/floor/systems/movement.rs

@@ -1,7 +1,7 @@
 use crate::{
     constants::{FLOOR_Y_OFFSET, MOVEMENT_THRESHOLD},
     floor::{
-        components::{CurrentFloor, FloorYTarget, NextFloor},
+        components::{CurrentFloor, Floor, FloorYTarget},
         events::TransitionFloor,
     },
     maze::components::HexMaze,
@@ -35,45 +35,52 @@ pub fn move_floors(
 
 pub fn handle_floor_transition_events(
     mut commands: Commands,
-    mut maze_query: Query<(Entity, &Transform, Option<&FloorYTarget>), With<HexMaze>>,
+    mut maze_query: Query<(Entity, &Transform, &Floor, Option<&FloorYTarget>), With<HexMaze>>,
-    current_query: Query<Entity, With<CurrentFloor>>,
+    current_query: Query<(Entity, &Floor), With<CurrentFloor>>,
-    next_query: Query<Entity, With<NextFloor>>,
     mut event_reader: EventReader<TransitionFloor>,
 ) {
     let is_moving = maze_query
         .iter()
-        .any(|(_, _, movement_state)| movement_state.is_some());
+        .any(|(_, _, _, movement_state)| movement_state.is_some());
 
     if is_moving {
         return;
     }
 
     for event in event_reader.read() {
+        dbg!(&event);
+        let Some((current_entity, current_floor)) = current_query.get_single().ok() else {
+            continue;
+        };
+
+        let target_floor_num = event.next_floor_num(current_floor);
+
+        let target_entity = maze_query
+            .iter()
+            .find(|(_, _, floor, _)| floor.0 == target_floor_num)
+            .map(|(entity, ..)| entity);
+
+        let Some(target_entity) = target_entity else {
+            continue;
+        };
+
         let direction = event.into();
 
-        let Some(current_entity) = current_query.get_single().ok() else {
+        for (entity, transforms, _, movement_state) in maze_query.iter_mut() {
-            continue;
-        };
-        let Some(next_entity) = next_query.get_single().ok() else {
-            continue;
-        };
-
-        for (entity, transforms, movement_state) in maze_query.iter_mut() {
             let target_y = (FLOOR_Y_OFFSET as f32).mul_add(direction, transforms.translation.y);
+            dbg!(movement_state, target_y);
             if movement_state.is_none() {
                 commands.entity(entity).insert(FloorYTarget(target_y));
             }
         }
 
-        update_current_next_floor(&mut commands, current_entity, next_entity);
+        update_current_next_floor(&mut commands, current_entity, target_entity);
         break;
     }
+    event_reader.clear();
 }
 
-fn update_current_next_floor(commands: &mut Commands, current_entity: Entity, next_entity: Entity) {
+fn update_current_next_floor(commands: &mut Commands, current: Entity, target: Entity) {
-    commands.entity(current_entity).remove::<CurrentFloor>();
+    commands.entity(current).remove::<CurrentFloor>();
-    commands
+    commands.entity(target).insert(CurrentFloor);
-        .entity(next_entity)
-        .remove::<NextFloor>()
-        .insert(CurrentFloor);
 }

src/floor/systems/spawn.rs

@@ -14,22 +14,24 @@ pub(super) fn spawn_floor(
     mut event_reader: EventReader<TransitionFloor>,
     mut highest_floor: ResMut<HighestFloor>,
 ) {
-    let Ok(floor) = query.get_single() else {
+    let Ok(current_floor) = query.get_single() else {
         return;
     };
 
     for event in event_reader.read() {
-        let floor = event.next_floor_num(floor);
+        if current_floor.0 == 0 && *event == TransitionFloor::Descend {
-
-        if floor == 1 && *event == TransitionFloor::Descend {
             warn!("Cannot descend below floor 1");
             return;
         }
 
-        highest_floor.0 = highest_floor.0.max(floor);
+        let next_floor = event.next_floor_num(current_floor);
+        highest_floor.0 = highest_floor.0.max(next_floor);
 
-        info!("Creating level for floor {}", floor);
+        info!("Creating level for floor {}", next_floor);
 
-        commands.trigger(SpawnMaze { floor, ..default() });
+        commands.trigger(SpawnMaze {
+            floor: next_floor,
+            ..default()
+        });
     }
 }

src/maze/triggers/spawn.rs

@@ -1,7 +1,7 @@
 use super::common::generate_maze;
 use crate::{
     constants::FLOOR_Y_OFFSET,
-    floor::components::{CurrentFloor, Floor, NextFloor},
+    floor::components::{CurrentFloor, Floor},
     maze::{
         assets::MazeAssets,
         components::{HexMaze, MazeConfig, Tile, Wall},
@@ -56,7 +56,6 @@ pub(super) fn spawn_maze(
             Visibility::Visible,
         ))
         .insert_if(CurrentFloor, || *floor == 1)
-        .insert_if(NextFloor, || *floor != 1)
         .id();
 
     let assets = MazeAssets::new(&mut meshes, &mut materials, &global_config);

src/player/systems/vertical_transition.rs

@@ -22,16 +22,14 @@ pub fn handle_floor_transition(
     for current_hex in player_query.iter() {
         // Check for ascending
         if current_hex.0 == config.end_pos {
-            dbg!("Ascending");
+            info!("Ascending");
             event_writer.send(TransitionFloor::Ascend);
-            return;
         }
 
         // Check for descending
         if current_hex.0 == config.start_pos && floor.0 != 1 {
-            dbg!("Descending");
+            info!("Descending");
             event_writer.send(TransitionFloor::Descend);
-            return;
         }
     }
 }