diff --git a/README.md b/README.md
index d299d778..2c52de9c 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,14 @@
-Multiplayer turn based game in the spirit of For the King, Diablo and Final Fantasy.
+# Roguelike Racing
+
+A multiplayer turn based game in the spirit of For the King, Diablo and Final Fantasy.
 
 UI written with the Yew frontend framework, backend uses websockets via Actix.
 
 To compile tailwind:
-From the client directory run npx tailwindcss -i ./input.css -o ./style/output.css --watch
+From the client directory run `npx tailwindcss -i ./input.css -o ./style/output.css --watch`
 
 To run the server:
-From the server directory run cargo-watch -x run
+From the server directory run `cargo-watch -x run`
 
 To run the frontend:
-From the client directory run trunk serve
+From the client directory run `TRUNK_PROD=false trunk serve`
diff --git a/client/cypress/e2e/first-user.cy.ts b/client/cypress/e2e/first-user.cy.ts
index 058bc06d..3a5071a7 100644
--- a/client/cypress/e2e/first-user.cy.ts
+++ b/client/cypress/e2e/first-user.cy.ts
@@ -12,12 +12,12 @@ describe("a test test", () => {
     cy.findByRole("button", { name: "Create Character" }).focus();
     cy.findByRole("button", { name: "Create Character" }).click();
 
-    // cy.findByPlaceholderText("Character name...")
-    //   .click()
-    //   .clear()
-    //   .type("R. Chambers", { delay: 0 });
-    // cy.findByRole("button", { name: "Create Character" }).focus();
-    // cy.findByRole("button", { name: "Create Character" }).click();
+    cy.findByPlaceholderText("Character name...")
+      .click()
+      .clear()
+      .type("R. Chambers", { delay: 0 });
+    cy.findByRole("button", { name: "Create Character" }).focus();
+    cy.findByRole("button", { name: "Create Character" }).click();
 
     cy.task("checkpoint", "game created");
     cy.task("waitForCheckpoint", "second player character created");
@@ -25,9 +25,14 @@ describe("a test test", () => {
     cy.findByRole("button", { name: "Ready" }).click();
     // cy.findByText("Open Inventory").click();
     cy.findByText("Ready to explore").click();
-    cy.findByText("Attack").click();
-    cy.findByText("Execute").click();
-    cy.task("checkpoint", "first attack executed");
+    // cy.findByText("Attack").click();
+    // cy.findByText("Execute").click();
+
+    // cy.wait(2000);
+
+    // cy.findByText("Attack").click();
+    // cy.findByText("Execute").click();
+    // cy.task("checkpoint", "first attack executed");
 
     // cy.findAllByText("Take").first().click({ force: true });
     // cy.findAllByText("Take").first().click({ force: true });
diff --git a/client/cypress/e2e/second-user.cy.ts b/client/cypress/e2e/second-user.cy.ts
index 91ecdb05..ba042f95 100644
--- a/client/cypress/e2e/second-user.cy.ts
+++ b/client/cypress/e2e/second-user.cy.ts
@@ -15,10 +15,10 @@ describe("a test test", () => {
     cy.findByRole("button", { name: "Ready" }).click();
     cy.findByText("Ready to explore").click();
 
-    cy.task("waitForCheckpoint", "first attack executed");
+    // cy.task("waitForCheckpoint", "first attack executed");
 
-    cy.findByText("Attack").click();
-    cy.findByText("Execute").click();
+    // cy.findByText("Attack").click();
+    // cy.findByText("Execute").click();
 
     // cy.findAllByText("Take").first().click({ force: true });
     // cy.findAllByText("Take").first().click({ force: true });
diff --git a/client/deployment-notes.md b/client/deployment-notes.md
new file mode 100644
index 00000000..19ffdf86
--- /dev/null
+++ b/client/deployment-notes.md
@@ -0,0 +1,22 @@
+# both
+
+-   check the dockerfile to see how dummy directories are used to cache dependencies before
+    actually building
+
+# client
+
+-   set env variables in trunk like TRUNK_PROD=true trunk build --release
+-   access env variables in Yew like :
+    let in_production = std::env!("TRUNK_PROD");
+-   websocket address should be in the format wss://domainname.com/ws
+
+# server
+
+-   actix address must be changed to 0.0.0.0:port in order to serve from inside
+    a docker container
+-   nginx should be configured like shown in the config file in same directory
+-   in order to ensure the docker container exits on panic set
+    RUST_BACKTRACE=1 env to in server dockerfile and make sure the s
+    erver Cargo.toml sets the behavior of :
+    [profile.release]
+    panic = 'abort'
diff --git a/client/dist/index.html b/client/dist/index.html
index 8c2c4d6c..52c38a7f 100644
--- a/client/dist/index.html
+++ b/client/dist/index.html
@@ -1,15 +1,15 @@
 <!DOCTYPE html><html><head>
     <meta charset="utf-8">
     <title>Roguelike Racing</title>
-    <link rel="stylesheet" href="/output-577bfbea865325fb.css">
+    <link rel="stylesheet" href="/output-24b437c61eec847e.css">
     
     <base href="/">
   
-<link rel="preload" href="/roguelike-racing-client-715bddf21eeeb498_bg.wasm" as="fetch" type="application/wasm" crossorigin="">
-<link rel="modulepreload" href="/roguelike-racing-client-715bddf21eeeb498.js"></head>
+<link rel="preload" href="/roguelike-racing-client-8b44f5306eb3adda_bg.wasm" as="fetch" type="application/wasm" crossorigin="">
+<link rel="modulepreload" href="/roguelike-racing-client-8b44f5306eb3adda.js"></head>
   <body>
 
-<script type="module">import init from '/roguelike-racing-client-715bddf21eeeb498.js';init('/roguelike-racing-client-715bddf21eeeb498_bg.wasm');</script><script>(function () {
+<script type="module">import init from '/roguelike-racing-client-8b44f5306eb3adda.js';init('/roguelike-racing-client-8b44f5306eb3adda_bg.wasm');</script><script>(function () {
     var protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
     var url = protocol + '//' + window.location.host + '/_trunk/ws';
     var poll_interval = 5000;
diff --git a/client/dist/public/code_meme.jpg b/client/dist/public/code_meme.jpg
deleted file mode 100644
index 0d86aeda..00000000
Binary files a/client/dist/public/code_meme.jpg and /dev/null differ
diff --git a/client/public/code_meme.jpg b/client/public/code_meme.jpg
deleted file mode 100644
index 0d86aeda..00000000
Binary files a/client/public/code_meme.jpg and /dev/null differ
diff --git a/client/public/img/door.png b/client/public/img/door.png
new file mode 100644
index 00000000..543f5dba
Binary files /dev/null and b/client/public/img/door.png differ
diff --git a/client/public/img/stairs-down.png b/client/public/img/stairs-down.png
new file mode 100644
index 00000000..a851a079
Binary files /dev/null and b/client/public/img/stairs-down.png differ
diff --git a/client/src/components/game/action_menu/action_handlers/handle_cycle_targeting_schemes.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targeting_schemes.rs
similarity index 100%
rename from client/src/components/game/action_menu/action_handlers/handle_cycle_targeting_schemes.rs
rename to client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targeting_schemes.rs
diff --git a/client/src/components/game/action_menu/action_handlers/handle_cycle_targets.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targets.rs
similarity index 100%
rename from client/src/components/game/action_menu/action_handlers/handle_cycle_targets.rs
rename to client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targets.rs
diff --git a/client/src/components/game/action_menu/action_handlers/handle_select_ability.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs
similarity index 100%
rename from client/src/components/game/action_menu/action_handlers/handle_select_ability.rs
rename to client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs
diff --git a/client/src/components/game/action_menu/create_action_handler.rs b/client/src/components/game/action_menu/action_button_click_handlers/mod.rs
similarity index 86%
rename from client/src/components/game/action_menu/create_action_handler.rs
rename to client/src/components/game/action_menu/action_button_click_handlers/mod.rs
index 771d9c6c..a4d82d57 100644
--- a/client/src/components/game/action_menu/create_action_handler.rs
+++ b/client/src/components/game/action_menu/action_button_click_handlers/mod.rs
@@ -1,11 +1,11 @@
-use super::action_handlers::handle_cycle_targeting_schemes::handle_cycle_targeting_schemes;
-use super::action_handlers::handle_cycle_targets::handle_cycle_targets;
-use super::available_actions::GameActions;
-use super::get_character_owned_item_by_id::get_character_owned_item_by_id;
-use crate::components::game::action_menu::action_handlers::handle_select_ability::handle_select_ability;
+pub mod handle_cycle_targeting_schemes;
+pub mod handle_cycle_targets;
+pub mod handle_select_ability;
+use super::enums::GameActions;
 use crate::components::websocket_manager::send_client_input::send_client_input;
 use crate::store::alert_store::AlertStore;
 use crate::store::game_store::get_focused_character;
+use crate::store::game_store::get_item_owned_by_focused_character;
 use crate::store::game_store::select_item;
 use crate::store::game_store::GameStore;
 use crate::store::ui_store::UIStore;
@@ -18,7 +18,7 @@ use common::packets::CharacterAndSlot;
 use std::rc::Rc;
 use yewdux::prelude::Dispatch;
 
-pub fn create_action_handler<'a>(
+pub fn create_action_button_click_handler<'a>(
     game_action: GameActions,
     game_dispatch: Dispatch<GameStore>,
     game_state: Rc<GameStore>,
@@ -61,7 +61,7 @@ pub fn create_action_handler<'a>(
             });
         }),
         GameActions::SelectItem(id) => Box::new(move || {
-            let item = get_character_owned_item_by_id(&id, game_state.clone())
+            let item = get_item_owned_by_focused_character(&id, game_state.clone())
                 .expect("a character should only be able to select their own items");
             let cloned_dispatch = game_dispatch.clone();
             select_item(cloned_dispatch, Some(item));
@@ -100,7 +100,7 @@ pub fn create_action_handler<'a>(
         GameActions::SelectAbility(ability_name) => Box::new(move || {
             let cloned_dispatch = game_dispatch.clone();
             let cloned_alert_dispatch = alert_dispatch.clone();
-            handle_select_ability(
+            handle_select_ability::handle_select_ability(
                 cloned_dispatch,
                 cloned_alert_dispatch,
                 &websocket_state.websocket,
@@ -125,7 +125,7 @@ pub fn create_action_handler<'a>(
         }),
         GameActions::CycleTargets(next_or_previous) => Box::new(move || {
             let cloned_dispatch = game_dispatch.clone();
-            handle_cycle_targets(
+            handle_cycle_targets::handle_cycle_targets(
                 cloned_dispatch,
                 &websocket_state.websocket,
                 &next_or_previous,
@@ -133,7 +133,10 @@ pub fn create_action_handler<'a>(
         }),
         GameActions::CycleTargetingScheme => Box::new(move || {
             game_dispatch.reduce_mut(|store| {
-                handle_cycle_targeting_schemes(store, &websocket_state.websocket)
+                handle_cycle_targeting_schemes::handle_cycle_targeting_schemes(
+                    store,
+                    &websocket_state.websocket,
+                )
             })
         }),
         GameActions::UseSelectedAbility => Box::new(move || {
@@ -187,13 +190,12 @@ pub fn create_action_handler<'a>(
                 store.detailed_entity = None;
             });
         }),
-        _ => Box::new(|| ()), // GameActions::OpenTreasureChest => || (),
-                              // GameActions::TakeItem => || (),
-                              // GameActions::DropItem => || (),
-                              // GameActions::ShardItem => || (),
-                              // GameActions::Attack => || (),
-                              // GameActions::LevelUpAbility(_) => || (),
-                              // GameActions::SetAssignAttributePointsMenuOpen(_) => || (),
-                              // GameActions::AssignAttributePoint(_) => || (),
+        GameActions::ToggleReadyToDescend => Box::new(move || {
+            send_client_input(
+                &websocket_state.websocket,
+                PlayerInputs::ToggleReadyToGoDownStairs,
+            );
+        }),
+        _ => Box::new(|| ()),
     }
 }
diff --git a/client/src/components/game/action_menu/action_button_hover_handlers/mod.rs b/client/src/components/game/action_menu/action_button_hover_handlers/mod.rs
new file mode 100644
index 00000000..9a2feb24
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_hover_handlers/mod.rs
@@ -0,0 +1,35 @@
+use super::enums::GameActions;
+use crate::store::game_store::get_item_owned_by_focused_character;
+use crate::store::game_store::DetailableEntities;
+use crate::store::game_store::GameStore;
+use std::rc::Rc;
+use yewdux::prelude::Dispatch;
+
+pub fn create_action_mouse_enter_handler(
+    action: GameActions,
+    game_dispatch: Dispatch<GameStore>,
+    game_state: Rc<GameStore>,
+) -> Box<dyn Fn()> {
+    match action {
+        GameActions::SelectItem(id) => Box::new(move || {
+            let item = get_item_owned_by_focused_character(&id, game_state.clone())
+                .expect("a character should only be able to select their own items");
+            game_dispatch
+                .reduce_mut(|store| store.hovered_entity = Some(DetailableEntities::Item(item)));
+        }),
+        _ => Box::new(|| ()),
+    }
+}
+
+pub fn create_action_mouse_leave_handler(
+    action: GameActions,
+    game_dispatch: Dispatch<GameStore>,
+    _game_state: Rc<GameStore>,
+) -> Box<dyn Fn()> {
+    match action {
+        GameActions::SelectItem(_id) => Box::new(move || {
+            game_dispatch.reduce_mut(|store| store.hovered_entity = None);
+        }),
+        _ => Box::new(|| ()),
+    }
+}
diff --git a/client/src/components/game/action_menu/action_handlers/mod.rs b/client/src/components/game/action_menu/action_handlers/mod.rs
deleted file mode 100644
index a69bc45c..00000000
--- a/client/src/components/game/action_menu/action_handlers/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod handle_cycle_targeting_schemes;
-pub mod handle_cycle_targets;
-pub mod handle_select_ability;
diff --git a/client/src/components/game/action_menu/generate_button_text.rs b/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
similarity index 85%
rename from client/src/components/game/action_menu/generate_button_text.rs
rename to client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
index 9356f737..d4139050 100644
--- a/client/src/components/game/action_menu/generate_button_text.rs
+++ b/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
@@ -1,11 +1,19 @@
-use super::available_actions::GameActions;
+use crate::components::game::action_menu::enums::GameActions;
 use crate::store::game_store::GameStore;
 use common::game::getters::get_party;
 use std::rc::Rc;
 
-pub fn generate_button_text(action: GameActions, game_state: Rc<GameStore>) -> String {
+pub fn determine_action_button_text(action: GameActions, game_state: Rc<GameStore>) -> String {
     match action {
-        GameActions::ToggleReadyToExplore => "Ready to explore".to_string(),
+        GameActions::ToggleReadyToExplore => {
+            let party = game_state
+                .get_current_party()
+                .expect("to be in a party when showing this button");
+            match party.current_room.room_type {
+                common::dungeon_rooms::DungeonRoomTypes::Stairs => "Vote to stay".to_string(),
+                _ => "Ready to explore".to_string(),
+            }
+        }
         GameActions::SetInventoryOpen(open_status) => {
             if open_status {
                 "Open inventory".to_string()
@@ -48,6 +56,7 @@ pub fn generate_button_text(action: GameActions, game_state: Rc<GameStore>) -> S
         GameActions::CycleTargetingScheme => "Targeting scheme".to_string(),
         GameActions::DeselectAbility => "Cancel".to_string(),
         GameActions::UseSelectedAbility => "Execute".to_string(),
+        GameActions::ToggleReadyToDescend => "Vote to descend".to_string(),
     }
 }
 
diff --git a/client/src/components/game/action_menu/action_menu_button.rs b/client/src/components/game/action_menu/action_menu_button/mod.rs
similarity index 91%
rename from client/src/components/game/action_menu/action_menu_button.rs
rename to client/src/components/game/action_menu/action_menu_button/mod.rs
index e551dc12..0d7e9c9f 100644
--- a/client/src/components/game/action_menu/action_menu_button.rs
+++ b/client/src/components/game/action_menu/action_menu_button/mod.rs
@@ -1,4 +1,5 @@
-use super::set_up_actions::ActionMenuButtonProperties;
+pub mod determine_action_button_text;
+use super::build_action_button_properties::ActionMenuButtonProperties;
 use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
diff --git a/client/src/components/game/action_menu/action_menu_change_detection_manager.rs b/client/src/components/game/action_menu/action_menu_change_detection_manager.rs
new file mode 100644
index 00000000..e5fd4aa6
--- /dev/null
+++ b/client/src/components/game/action_menu/action_menu_change_detection_manager.rs
@@ -0,0 +1,136 @@
+use crate::components::game::action_menu::build_action_button_properties::build_action_button_properties;
+use crate::components::game::action_menu::build_action_button_properties::ActionMenuButtonProperties;
+use crate::store::alert_store::AlertStore;
+use crate::store::game_store::get_active_combatant;
+use crate::store::game_store::GameStore;
+use crate::store::lobby_store::LobbyStore;
+use crate::store::ui_store::UIStore;
+use crate::store::websocket_store::WebsocketStore;
+use yew::prelude::*;
+use yewdux::use_store;
+
+#[derive(Properties, PartialEq)]
+pub struct Props {
+    pub action_menu_button_properties: UseStateHandle<Vec<ActionMenuButtonProperties>>,
+}
+
+#[function_component(ActionMenuChangeDetectionManager)]
+pub fn action_menu_change_detection_manager(props: &Props) -> Html {
+    let (game_state, game_dispatch) = use_store::<GameStore>();
+    let (ui_state, _) = use_store::<UIStore>();
+    let (lobby_state, _) = use_store::<LobbyStore>();
+    let (websocket_state, _) = use_store::<WebsocketStore>();
+    let (_, alert_dspatch) = use_store::<AlertStore>();
+    let cloned_game_state = game_state.clone();
+
+    let active_combatant_result = get_active_combatant(&game_state);
+    let active_combatant_id_option = match active_combatant_result {
+        Ok(combatant_option) => match combatant_option {
+            Some((entity_properties, _)) => Some(entity_properties.id),
+            None => None,
+        },
+        Err(_) => None,
+    };
+    let party = game_state.get_current_party().expect("to be in a party");
+    let room_type = party.current_room.room_type;
+    let num_items_on_ground = party.current_room.items.len();
+    let battle_id = party.battle_id;
+    let focused_character_option = party.characters.get(&game_state.focused_character_id);
+    let focused_character_equipment_ids = match focused_character_option {
+        Some(focused_character) => Some(
+            focused_character
+                .combatant_properties
+                .equipment
+                .iter()
+                .map(|(_slot, item)| item.entity_properties.id)
+                .collect::<Vec<u32>>(),
+        ),
+        None => None,
+    };
+    let selected_item_id = match &game_state.selected_item {
+        Some(item) => Some(item.entity_properties.id),
+        None => None,
+    };
+
+    let num_items_in_focused_character_inventory = match focused_character_option {
+        Some(focused_character) => Some(focused_character.inventory.items.len()),
+        None => None,
+    };
+    let ability_targets = match focused_character_option {
+        Some(focused_character) => focused_character
+            .combatant_properties
+            .ability_targets
+            .clone(),
+
+        None => None,
+    };
+    let focused_character_selected_ability_option = match focused_character_option {
+        Some(focused_character) => focused_character
+            .combatant_properties
+            .selected_ability_name
+            .clone(),
+        None => None,
+    };
+
+    let focused_character_current_animation_processing_option = match focused_character_option {
+        Some(focused_character) => game_state
+            .action_results_manager
+            .combantant_event_managers
+            .get(&focused_character.entity_properties.id)
+            .expect("to have an event queue for every combatant entity")
+            .animation_queue
+            .front(),
+        None => None,
+    };
+
+    let cloned_focused_character_current_animation_processing_option =
+        match focused_character_current_animation_processing_option {
+            Some(action_result) => Some(action_result.clone()),
+            None => None,
+        };
+
+    let cloned_ui_state = ui_state.clone();
+    let cloned_game_dispatch = game_dispatch.clone();
+    let cloned_alert_dispatch = alert_dspatch.clone();
+    let cloned_action_menu_button_properties = props.action_menu_button_properties.clone();
+    use_effect_with(
+        (
+            active_combatant_id_option,
+            cloned_game_state.focused_character_id,
+            cloned_game_state.viewing_inventory,
+            cloned_game_state.viewing_equipped_items,
+            ability_targets,
+            (
+                room_type,
+                num_items_in_focused_character_inventory,
+                num_items_on_ground,
+                selected_item_id,
+                focused_character_selected_ability_option,
+                cloned_focused_character_current_animation_processing_option,
+            ),
+            cloned_game_state.viewing_items_on_ground,
+            cloned_game_state.viewing_skill_level_up_menu,
+            cloned_game_state.viewing_attribute_point_assignment_menu,
+            battle_id,
+            cloned_ui_state.mod_key_held,
+            focused_character_equipment_ids,
+        ),
+        move |_| {
+            let re_cloned_game_state = cloned_game_state.clone();
+            let party = re_cloned_game_state
+                .get_current_party()
+                .expect("to be in a party");
+            let actions = build_action_button_properties(
+                websocket_state.clone(),
+                cloned_game_state,
+                cloned_game_dispatch,
+                cloned_alert_dispatch,
+                cloned_ui_state,
+                lobby_state,
+                party,
+            );
+            cloned_action_menu_button_properties.set(actions);
+        },
+    );
+    html!()
+}
diff --git a/client/src/components/game/action_menu/action_menu_page_manager/mod.rs b/client/src/components/game/action_menu/action_menu_page_manager/mod.rs
new file mode 100644
index 00000000..adff2ac0
--- /dev/null
+++ b/client/src/components/game/action_menu/action_menu_page_manager/mod.rs
@@ -0,0 +1,35 @@
+use yew::prelude::*;
+use yewdux::use_store;
+
+use crate::store::game_store::GameStore;
+
+#[derive(Properties, Eq, PartialEq)]
+pub struct Props {}
+
+#[function_component(ActionMenuPageManager)]
+pub fn action_menu_page_manager(_: &Props) -> Html {
+    // let (game_state, game_dispatch) = use_store::<GameStore>();
+
+    // let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
+    // let cloned_action_button_properties = action_button_properties.clone();
+    // let cloned_button_props_on_current_page = button_props_on_current_page.clone();
+    // use_effect_with(
+    //     (
+    //         game_state.action_menu_current_page_number,
+    //         action_button_properties.clone(),
+    //     ),
+    //     move |_| {
+    //         let min_index = cloned_current_page_number * PAGE_SIZE;
+    //         let max_index = cloned_current_page_number * PAGE_SIZE + PAGE_SIZE - 1;
+    //         let filtered_actions = cloned_action_button_properties
+    //             .deref()
+    //             .iter()
+    //             .enumerate()
+    //             .filter(|(i, _)| *i as u8 >= min_index && *i as u8 <= max_index)
+    //             .map(|(_, item)| item.clone())
+    //             .collect::<Vec<ActionMenuButtonProperties>>();
+    //         cloned_button_props_on_current_page.set(filtered_actions);
+    //     },
+    // );
+    html!()
+}
diff --git a/client/src/components/game/action_menu/set_up_actions.rs b/client/src/components/game/action_menu/build_action_button_properties.rs
similarity index 86%
rename from client/src/components/game/action_menu/set_up_actions.rs
rename to client/src/components/game/action_menu/build_action_button_properties.rs
index 0e28d0e1..a017b56f 100644
--- a/client/src/components/game/action_menu/set_up_actions.rs
+++ b/client/src/components/game/action_menu/build_action_button_properties.rs
@@ -1,9 +1,9 @@
-use super::create_action_handler::create_action_handler;
-use super::create_action_mouse_enter_handler::create_action_mouse_enter_handler;
-use super::create_action_mouse_leave_handler::create_action_mouse_leave_handler;
+use super::action_button_click_handlers::create_action_button_click_handler;
+use super::action_button_hover_handlers::create_action_mouse_enter_handler;
+use super::action_button_hover_handlers::create_action_mouse_leave_handler;
+use super::action_menu_button::determine_action_button_text::determine_action_button_text;
 use super::determine_action_menu_buttons_disabled::determine_action_menu_buttons_disabled;
-use super::generate_action_menu_items;
-use super::generate_button_text::generate_button_text;
+use super::determine_menu_actions::determine_menu_actions;
 use crate::store::alert_store::AlertStore;
 use crate::store::game_store::GameStore;
 use crate::store::lobby_store::LobbyStore;
@@ -27,7 +27,7 @@ pub struct ActionMenuButtonProperties {
     pub should_be_disabled: bool,
 }
 
-pub fn set_up_actions(
+pub fn build_action_button_properties(
     websocket_state: Rc<WebsocketStore>,
     game_state: Rc<GameStore>,
     game_dispatch: Dispatch<GameStore>,
@@ -36,8 +36,7 @@ pub fn set_up_actions(
     lobby_state: Rc<LobbyStore>,
     party: &AdventuringParty,
 ) -> Vec<ActionMenuButtonProperties> {
-    let new_actions =
-        generate_action_menu_items::generate_action_menu_items(&game_state, &lobby_state, party);
+    let new_actions = determine_menu_actions(&game_state, &lobby_state, party);
     let mut button_properties = Vec::new();
 
     for action in new_actions {
@@ -48,7 +47,7 @@ pub fn set_up_actions(
         let cloned_ui_state = ui_state.clone();
         let cloned_alert_dispatch = alert_dispatch.clone();
         let click_handler = Callback::from(move |_| {
-            create_action_handler(
+            create_action_button_click_handler(
                 cloned_action.clone(),
                 cloned_game_dispatch.clone(),
                 cloned_game_state.clone(),
@@ -98,7 +97,7 @@ pub fn set_up_actions(
             )()
         });
         let cloned_game_state = game_state.clone();
-        let text = generate_button_text(action.clone(), cloned_game_state);
+        let text = determine_action_button_text(action.clone(), cloned_game_state);
 
         let should_be_disabled =
             determine_action_menu_buttons_disabled(&action, &game_state, &lobby_state);
diff --git a/client/src/components/game/action_menu/create_action_mouse_enter_handler.rs b/client/src/components/game/action_menu/create_action_mouse_enter_handler.rs
deleted file mode 100644
index 8d683253..00000000
--- a/client/src/components/game/action_menu/create_action_mouse_enter_handler.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use super::{
-    available_actions::GameActions, get_character_owned_item_by_id::get_character_owned_item_by_id,
-};
-use crate::store::game_store::{DetailableEntities, GameStore};
-use std::rc::Rc;
-use yewdux::prelude::Dispatch;
-
-pub fn create_action_mouse_enter_handler(
-    action: GameActions,
-    game_dispatch: Dispatch<GameStore>,
-    game_state: Rc<GameStore>,
-) -> Box<dyn Fn()> {
-    match action {
-            GameActions::SelectItem(id) => Box::new(move || {
-                let item = get_character_owned_item_by_id(&id, game_state.clone())
-                    .expect("a character should only be able to select their own items");
-                game_dispatch.reduce_mut(|store| store.hovered_entity = Some(DetailableEntities::Item(item)));
-            }),
-            _ => Box::new(||())
-            // GameActions::OpenTreasureChest => || (),
-            // GameActions::TakeItem => || (),
-            // GameActions::UseItem => || (),
-            // GameActions::DropItem => || (),
-            // GameActions::ShardItem => || (),
-            // GameActions::Attack => || (),
-            // GameActions::LevelUpAbility(_) => || (),
-            // GameActions::SetAssignAttributePointsMenuOpen(_) => || (),
-            // GameActions::AssignAttributePoint(_) => || (),
-        }
-}
diff --git a/client/src/components/game/action_menu/create_action_mouse_leave_handler.rs b/client/src/components/game/action_menu/create_action_mouse_leave_handler.rs
deleted file mode 100644
index e8a389a9..00000000
--- a/client/src/components/game/action_menu/create_action_mouse_leave_handler.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use super::available_actions::GameActions;
-use crate::store::game_store::GameStore;
-use std::rc::Rc;
-use yewdux::prelude::Dispatch;
-
-pub fn create_action_mouse_leave_handler(
-    action: GameActions,
-    game_dispatch: Dispatch<GameStore>,
-    _game_state: Rc<GameStore>,
-) -> Box<dyn Fn()> {
-    match action {
-            GameActions::SelectItem(_id) => Box::new(move || {
-                game_dispatch.reduce_mut(|store| store.hovered_entity = None);
-            }),
-            _ => Box::new(||())
-            // GameActions::OpenTreasureChest => || (),
-            // GameActions::TakeItem => || (),
-            // GameActions::UseItem => || (),
-            // GameActions::DropItem => || (),
-            // GameActions::ShardItem => || (),
-            // GameActions::Attack => || (),
-            // GameActions::LevelUpAbility(_) => || (),
-            // GameActions::SetAssignAttributePointsMenuOpen(_) => || (),
-            // GameActions::AssignAttributePoint(_) => || (),
-        }
-}
diff --git a/client/src/components/game/action_menu/determine_action_menu_buttons_disabled.rs b/client/src/components/game/action_menu/determine_action_menu_buttons_disabled.rs
index 0dc7262a..fd1032f9 100644
--- a/client/src/components/game/action_menu/determine_action_menu_buttons_disabled.rs
+++ b/client/src/components/game/action_menu/determine_action_menu_buttons_disabled.rs
@@ -1,4 +1,4 @@
-use super::available_actions::GameActions;
+use super::enums::GameActions;
 use crate::store::game_store::get_current_battle_option;
 use crate::store::game_store::GameStore;
 use crate::store::lobby_store::LobbyStore;
diff --git a/client/src/components/game/action_menu/generate_action_menu_items.rs b/client/src/components/game/action_menu/determine_menu_actions.rs
similarity index 79%
rename from client/src/components/game/action_menu/generate_action_menu_items.rs
rename to client/src/components/game/action_menu/determine_menu_actions.rs
index da65c293..0ecd6687 100644
--- a/client/src/components/game/action_menu/generate_action_menu_items.rs
+++ b/client/src/components/game/action_menu/determine_menu_actions.rs
@@ -1,13 +1,16 @@
-use super::available_actions::GameActions;
-use super::available_actions::MenuTypes;
+use super::enums::GameActions;
+use super::enums::MenuTypes;
 use crate::store::game_store::GameStore;
 use crate::store::lobby_store::LobbyStore;
 use common::adventuring_party::AdventuringParty;
 use common::combatants::abilities::get_combatant_ability_attributes::AbilityUsableContext;
 use common::combatants::abilities::CombatantAbilityNames;
+use common::dungeon_rooms::DungeonRoomTypes;
+use gloo::console::log;
 use std::rc::Rc;
 
-pub fn generate_action_menu_items(
+// determine menu actions
+pub fn determine_menu_actions(
     game_state: &Rc<GameStore>,
     lobby_state: &Rc<LobbyStore>,
     party: &AdventuringParty,
@@ -31,12 +34,12 @@ pub fn generate_action_menu_items(
 
     if game_state.viewing_items_on_ground {
         menu_types.push(MenuTypes::ItemsOnGround);
-        new_actions = MenuTypes::get_menu(&menu_types, None, None);
+        new_actions = MenuTypes::get_actions(&menu_types, None, None);
         //
     } else if let Some(selected_item) = &game_state.selected_item {
         let id = selected_item.clone().entity_properties.id;
         menu_types.push(MenuTypes::ItemSelected(id));
-        new_actions = MenuTypes::get_menu(&menu_types, None, None);
+        new_actions = MenuTypes::get_actions(&menu_types, None, None);
         //
     } else if game_state.viewing_equipped_items {
         menu_types.push(MenuTypes::ViewingEquipedItems);
@@ -46,7 +49,7 @@ pub fn generate_action_menu_items(
             for (_slot, item) in &character.combatant_properties.equipment {
                 ids.push(item.entity_properties.id);
             }
-            new_actions = MenuTypes::get_menu(&menu_types, Some(ids), None)
+            new_actions = MenuTypes::get_actions(&menu_types, Some(ids), None)
         }
     } else if game_state.viewing_inventory {
         menu_types.push(MenuTypes::InventoryOpen);
@@ -55,7 +58,7 @@ pub fn generate_action_menu_items(
             for item in &character.inventory.items {
                 ids.push(item.entity_properties.id);
             }
-            new_actions = MenuTypes::get_menu(&menu_types, Some(ids), None);
+            new_actions = MenuTypes::get_actions(&menu_types, Some(ids), None);
         }
         //
     } else if game_state.viewing_skill_level_up_menu
@@ -65,7 +68,7 @@ pub fn generate_action_menu_items(
         let mut ability_names =
             get_ability_menu_names(&party, game_state.focused_character_id, None);
         ability_names.sort_by(|a, b| a.partial_cmp(&b).unwrap());
-        new_actions = MenuTypes::get_menu(&menu_types, None, Some(ability_names));
+        new_actions = MenuTypes::get_actions(&menu_types, None, Some(ability_names));
         //
     } else if party.battle_id.is_none() {
         menu_types.push(MenuTypes::OutOfCombat);
@@ -81,11 +84,19 @@ pub fn generate_action_menu_items(
         if party.current_room.items.len() > 0 {
             menu_types.push(MenuTypes::ItemsOnGround);
         }
-        new_actions = MenuTypes::get_menu(&menu_types, None, Some(ability_names));
-        //
+        log!(format!(
+            "current room type: {}",
+            party.current_room.room_type
+        ));
+
+        if party.current_room.room_type == DungeonRoomTypes::Stairs {
+            log!("pushing staircase menu");
+            menu_types.push(MenuTypes::Staircase)
+        }
+        new_actions = MenuTypes::get_actions(&menu_types, None, Some(ability_names));
     } else if focused_character_is_selecting_ability && player_owns_character {
         menu_types.push(MenuTypes::AbilitySelected);
-        new_actions = MenuTypes::get_menu(&menu_types, None, None);
+        new_actions = MenuTypes::get_actions(&menu_types, None, None);
     } else {
         menu_types.push(MenuTypes::InCombat);
         let mut ability_names = get_ability_menu_names(
@@ -94,7 +105,7 @@ pub fn generate_action_menu_items(
             Some(AbilityUsableContext::OutOfCombat),
         );
         ability_names.sort_by(|a, b| a.partial_cmp(&b).unwrap());
-        new_actions = MenuTypes::get_menu(&menu_types, None, Some(ability_names));
+        new_actions = MenuTypes::get_actions(&menu_types, None, Some(ability_names));
     }
     new_actions
 }
diff --git a/client/src/components/game/action_menu/enums.rs b/client/src/components/game/action_menu/enums.rs
new file mode 100644
index 00000000..130efb0b
--- /dev/null
+++ b/client/src/components/game/action_menu/enums.rs
@@ -0,0 +1,45 @@
+#![allow(unused, dead_code)]
+use common::combatants::abilities::CombatantAbilityNames;
+use common::combatants::combat_attributes::CombatAttributes;
+use common::primatives::NextOrPrevious;
+
+pub enum MenuTypes {
+    InCombat,
+    AbilitySelected,
+    OutOfCombat,
+    LevelUpAbilities,
+    AttributePointAssignment,
+    InventoryOpen,
+    ViewingEquipedItems,
+    ItemSelected(u32),
+    ItemsOnGround,
+    UnopenedChest,
+    Staircase,
+}
+
+#[derive(Hash, Eq, PartialEq, Clone)]
+pub enum GameActions {
+    ToggleReadyToExplore,
+    ToggleReadyToDescend,
+    SetInventoryOpen(bool),
+    ToggleInventoryOpen,
+    ToggleViewingEquipedItems,
+    UseAutoinjector,
+    SelectItem(u32),
+    OpenTreasureChest,
+    TakeItem,
+    // Item Selected
+    UseItem(u32),
+    DropItem(u32),
+    ShardItem(u32),
+    DeselectItem,
+    // InCombat
+    SelectAbility(CombatantAbilityNames),
+    DeselectAbility,
+    CycleTargets(NextOrPrevious),
+    CycleTargetingScheme,
+    UseSelectedAbility,
+    LevelUpAbility(CombatantAbilityNames),
+    SetAssignAttributePointsMenuOpen(bool),
+    AssignAttributePoint(CombatAttributes),
+}
diff --git a/client/src/components/game/action_menu/get_character_owned_item_by_id.rs b/client/src/components/game/action_menu/get_character_owned_item_by_id.rs
deleted file mode 100644
index 481e95cf..00000000
--- a/client/src/components/game/action_menu/get_character_owned_item_by_id.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::rc::Rc;
-use crate::store::game_store::GameStore;
-use common::{app_consts::error_messages, errors::AppError, game::getters::get_party, items::Item};
-
-pub fn get_character_owned_item_by_id(
-    id: &u32,
-    game_state: Rc<GameStore>,
-) -> Result<Item, AppError> {
-    let party_id = game_state
-        .current_party_id
-        .expect("only call this fn if char is in a party");
-    let game = game_state
-        .game
-        .as_ref()
-        .expect("only should be called in a game");
-    let party = get_party(&game, party_id).expect("only should be called when in a party");
-    let character = party
-        .characters
-        .get(&game_state.focused_character_id)
-        .expect("only should be called in a game");
-
-    for (_, item) in &character.combatant_properties.equipment {
-        if item.entity_properties.id == *id {
-            return Ok(item.clone());
-        }
-    }
-
-    for item in &character.inventory.items {
-        if item.entity_properties.id == *id {
-            return Ok(item.clone());
-        }
-    }
-
-    return Err(AppError {
-        error_type: common::errors::AppErrorTypes::ClientError,
-        message: error_messages::INVALID_ITEM_ID.to_string(),
-    });
-}
diff --git a/client/src/components/game/action_menu/available_actions.rs b/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
similarity index 78%
rename from client/src/components/game/action_menu/available_actions.rs
rename to client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
index 0d3250fd..2898400d 100644
--- a/client/src/components/game/action_menu/available_actions.rs
+++ b/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
@@ -1,51 +1,10 @@
-#![allow(dead_code, unused)]
+use super::enums::GameActions;
+use super::enums::MenuTypes;
 use common::combatants::abilities::CombatantAbilityNames;
-use common::combatants::combat_attributes::CombatAttributes;
-use common::items::Item;
 use common::primatives::NextOrPrevious;
-use gloo::console::log;
-
-pub enum MenuTypes {
-    InCombat,
-    AbilitySelected,
-    OutOfCombat,
-    LevelUpAbilities,
-    AttributePointAssignment,
-    InventoryOpen,
-    ViewingEquipedItems,
-    ItemSelected(u32),
-    ItemsOnGround,
-    UnopenedChest,
-}
-
-#[derive(Hash, Eq, PartialEq, Clone)]
-pub enum GameActions {
-    ToggleReadyToExplore,
-    SetInventoryOpen(bool),
-    ToggleInventoryOpen,
-    ToggleViewingEquipedItems,
-    UseAutoinjector,
-    SelectItem(u32),
-    OpenTreasureChest,
-    TakeItem,
-    // Item Selected
-    UseItem(u32),
-    DropItem(u32),
-    ShardItem(u32),
-    DeselectItem,
-    // InCombat
-    SelectAbility(CombatantAbilityNames),
-    DeselectAbility,
-    CycleTargets(NextOrPrevious),
-    CycleTargetingScheme,
-    UseSelectedAbility,
-    LevelUpAbility(CombatantAbilityNames),
-    SetAssignAttributePointsMenuOpen(bool),
-    AssignAttributePoint(CombatAttributes),
-}
 
 impl MenuTypes {
-    pub fn get_menu(
+    pub fn get_actions(
         menu_types: &Vec<MenuTypes>,
         item_ids: Option<Vec<u32>>,
         abilities: Option<Vec<CombatantAbilityNames>>,
@@ -106,6 +65,7 @@ impl MenuTypes {
                 MenuTypes::AttributePointAssignment => {
                     menu_items.push(GameActions::SetAssignAttributePointsMenuOpen(false));
                 }
+                MenuTypes::Staircase => menu_items.push(GameActions::ToggleReadyToDescend),
             }
         }
 
diff --git a/client/src/components/game/action_menu/mod.rs b/client/src/components/game/action_menu/mod.rs
index 938e98ce..054ad583 100644
--- a/client/src/components/game/action_menu/mod.rs
+++ b/client/src/components/game/action_menu/mod.rs
@@ -1,21 +1,20 @@
-pub mod action_handlers;
-mod action_menu_button;
+pub mod action_button_click_handlers;
+pub mod action_button_hover_handlers;
+pub mod action_menu_button;
+mod action_menu_change_detection_manager;
+mod action_menu_page_manager;
 mod action_page_buttons;
-mod available_actions;
-mod create_action_handler;
-mod create_action_mouse_enter_handler;
-mod create_action_mouse_leave_handler;
+mod build_action_button_properties;
 mod determine_action_menu_buttons_disabled;
-mod generate_action_menu_items;
-mod generate_button_text;
-mod get_character_owned_item_by_id;
+mod determine_menu_actions;
+pub mod enums;
+mod get_game_actions_by_menu_type;
 mod set_keyup_listeners;
-mod set_up_actions;
 use crate::components::game::action_menu::action_menu_button::ActionMenuButton;
+use crate::components::game::action_menu::action_menu_change_detection_manager::ActionMenuChangeDetectionManager;
 use crate::components::game::action_menu::action_page_buttons::ActionPageButtons;
-use crate::components::game::action_menu::set_up_actions::ActionMenuButtonProperties;
+use crate::components::game::action_menu::build_action_button_properties::ActionMenuButtonProperties;
 use crate::store::alert_store::AlertStore;
-use crate::store::game_store::get_active_combatant;
 use crate::store::game_store::GameStore;
 use crate::store::lobby_store::LobbyStore;
 use crate::store::ui_store::UIStore;
@@ -37,16 +36,16 @@ pub fn action_menu(_: &Props) -> Html {
     let (lobby_state, _) = use_store::<LobbyStore>();
     let (websocket_state, _) = use_store::<WebsocketStore>();
     let (_, alert_dspatch) = use_store::<AlertStore>();
-    let action_button_properties = use_state(|| Vec::<ActionMenuButtonProperties>::new());
+    let action_menu_button_properties = use_state(|| Vec::<ActionMenuButtonProperties>::new());
     let button_props_on_current_page = use_state(|| Vec::<ActionMenuButtonProperties>::new());
 
     let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
-    let cloned_action_button_properties = action_button_properties.clone();
+    let cloned_action_button_properties = action_menu_button_properties.clone();
     let cloned_button_props_on_current_page = button_props_on_current_page.clone();
     use_effect_with(
         (
             game_state.action_menu_current_page_number,
-            action_button_properties.clone(),
+            action_menu_button_properties.clone(),
         ),
         move |_| {
             let min_index = cloned_current_page_number * PAGE_SIZE;
@@ -62,118 +61,6 @@ pub fn action_menu(_: &Props) -> Html {
         },
     );
 
-    let cloned_action_button_properties = action_button_properties.clone();
-    let cloned_game_state = game_state.clone();
-    let selected_item_id = match &game_state.selected_item {
-        Some(item) => Some(item.entity_properties.id),
-        None => None,
-    };
-
-    let party = game_state.get_current_party().expect("to be in a party");
-    let num_items_on_ground = party.current_room.items.len();
-    let battle_id = party.battle_id;
-    let focused_character_option = party.characters.get(&game_state.focused_character_id);
-    let focused_character_equipment_ids = match focused_character_option {
-        Some(focused_character) => Some(
-            focused_character
-                .combatant_properties
-                .equipment
-                .iter()
-                .map(|(_slot, item)| item.entity_properties.id)
-                .collect::<Vec<u32>>(),
-        ),
-        None => None,
-    };
-
-    let num_items_in_focused_character_inventory = match focused_character_option {
-        Some(focused_character) => Some(focused_character.inventory.items.len()),
-        None => None,
-    };
-    let focused_character_selected_ability_option = match focused_character_option {
-        Some(focused_character) => focused_character
-            .combatant_properties
-            .selected_ability_name
-            .clone(),
-        None => None,
-    };
-
-    let focused_character_current_animation_processing_option = match focused_character_option {
-        Some(focused_character) => game_state
-            .action_results_manager
-            .combantant_event_managers
-            .get(&focused_character.entity_properties.id)
-            .expect("to have an event queue for every combatant entity")
-            .animation_queue
-            .front(),
-        None => None,
-    };
-
-    let cloned_focused_character_current_animation_processing_option =
-        match focused_character_current_animation_processing_option {
-            Some(action_result) => Some(action_result.clone()),
-            None => None,
-        };
-
-    let ability_targets = match focused_character_option {
-        Some(focused_character) => focused_character
-            .combatant_properties
-            .ability_targets
-            .clone(),
-
-        None => None,
-    };
-
-    let active_combatant_result = get_active_combatant(&game_state);
-    let active_combatant_id_option = match active_combatant_result {
-        Ok(combatant_option) => match combatant_option {
-            Some((entity_properties, _)) => Some(entity_properties.id),
-            None => None,
-        },
-        Err(_) => None,
-    };
-
-    let cloned_ui_state = ui_state.clone();
-    let cloned_game_dispatch = game_dispatch.clone();
-    let cloned_alert_dispatch = alert_dspatch.clone();
-    use_effect_with(
-        (
-            active_combatant_id_option,
-            cloned_game_state.focused_character_id,
-            cloned_game_state.viewing_inventory,
-            cloned_game_state.viewing_equipped_items,
-            ability_targets,
-            (
-                num_items_in_focused_character_inventory,
-                num_items_on_ground,
-                selected_item_id,
-                focused_character_selected_ability_option,
-                cloned_focused_character_current_animation_processing_option,
-            ),
-            cloned_game_state.viewing_items_on_ground,
-            cloned_game_state.viewing_skill_level_up_menu,
-            cloned_game_state.viewing_attribute_point_assignment_menu,
-            battle_id,
-            cloned_ui_state.mod_key_held,
-            focused_character_equipment_ids,
-        ),
-        move |_| {
-            let re_cloned_game_state = cloned_game_state.clone();
-            let party = re_cloned_game_state
-                .get_current_party()
-                .expect("to be in a party");
-            let actions = set_up_actions::set_up_actions(
-                websocket_state.clone(),
-                cloned_game_state,
-                cloned_game_dispatch,
-                cloned_alert_dispatch,
-                cloned_ui_state,
-                lobby_state,
-                party,
-            );
-            cloned_action_button_properties.set(actions);
-        },
-    );
-
     let keyup_listener_state = use_state(|| None::<EventListener>);
     let cloned_button_props_on_current_page = button_props_on_current_page.clone();
     let cloned_button_props_on_current_page_for_effect_change =
@@ -189,13 +76,14 @@ pub fn action_menu(_: &Props) -> Html {
     );
 
     let cloned_button_props_on_current_page = button_props_on_current_page.clone();
-    let cloned_action_button_properties = action_button_properties.clone();
+    let cloned_action_button_properties = action_menu_button_properties.clone();
     let num_actions = cloned_action_button_properties.len();
     let number_of_pages = calculate_number_of_pages(PAGE_SIZE as usize, num_actions);
 
     html!(
         <section class="min-w-[350px] w-[350px] border border-slate-400 bg-slate-700 mr-4 overflow-y-auto
         flex flex-col justify-between">
+        <ActionMenuChangeDetectionManager action_menu_button_properties={action_menu_button_properties} />
             <div>
                 {cloned_button_props_on_current_page.deref().iter().enumerate().map(|(i, action)| {
                       html!(
diff --git a/client/src/components/game/action_menu/set_keyup_listeners.rs b/client/src/components/game/action_menu/set_keyup_listeners.rs
index 7da80183..88db3efa 100644
--- a/client/src/components/game/action_menu/set_keyup_listeners.rs
+++ b/client/src/components/game/action_menu/set_keyup_listeners.rs
@@ -1,7 +1,8 @@
-use super::set_up_actions::ActionMenuButtonProperties;
+use super::build_action_button_properties::ActionMenuButtonProperties;
 use gloo::events::EventListener;
 use gloo_utils::window;
-use wasm_bindgen::{JsCast, UnwrapThrowExt};
+use wasm_bindgen::JsCast;
+use wasm_bindgen::UnwrapThrowExt;
 use web_sys::MouseEvent;
 use yew::UseStateHandle;
 
diff --git a/client/src/components/game/combatant/value_bar.rs b/client/src/components/game/combatant/value_bar.rs
index d1f947e6..a34bda00 100644
--- a/client/src/components/game/combatant/value_bar.rs
+++ b/client/src/components/game/combatant/value_bar.rs
@@ -23,7 +23,7 @@ pub fn value_bar(props: &Props) -> Html {
     html!(
     <div class={container_styles}>
         <div class={inner_bar_styles} style={format!("width: {percent_of_max}%;")} />
-        <div class="text-white absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2" >{format!("{curr} / {max}")}</div>
+        <div class="text-xs text-white absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2" >{format!("{curr} / {max}")}</div>
     </div>
     )
 }
diff --git a/client/src/components/game/dungeon_room/empty_room.rs b/client/src/components/game/dungeon_room/empty_room.rs
new file mode 100644
index 00000000..03937c40
--- /dev/null
+++ b/client/src/components/game/dungeon_room/empty_room.rs
@@ -0,0 +1,18 @@
+use yew::prelude::*;
+use yew::Html;
+
+#[function_component(EmptyRoom)]
+pub fn empty_room() -> Html {
+    html!(
+    <div class="h-full w-full flex flex-col justify-center items-center ">
+        <h3 class="mb-4" >
+            {"The room is empty except for a door..."}
+        </h3>
+        <img
+            class="max-h-full max-w-full"
+            src="public/img/door.png"
+            alt="door to next room"
+        />
+    </div>
+    )
+}
diff --git a/client/src/components/game/dungeon_room/mod.rs b/client/src/components/game/dungeon_room/mod.rs
index 9247d62b..50acaf42 100644
--- a/client/src/components/game/dungeon_room/mod.rs
+++ b/client/src/components/game/dungeon_room/mod.rs
@@ -1,11 +1,14 @@
 use crate::components::common_components::atoms::button_basic::ButtonBasic;
-use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::components::game::dungeon_room::empty_room::EmptyRoom;
+use crate::components::game::dungeon_room::stairs::Stairs;
 use crate::store::websocket_store::WebsocketStore;
 use common::character::Character;
-use common::packets::client_to_server::PlayerInputs;
+use common::dungeon_rooms::DungeonRoomTypes;
+mod empty_room;
 mod enemy_battle_group;
 mod items_on_ground;
 mod players_ready_to_explore;
+mod stairs;
 use crate::components::game::combatant::Combatant;
 use crate::components::game::dungeon_room::enemy_battle_group::EnemyBattleGroup;
 use crate::components::game::dungeon_room::items_on_ground::ItemsOnGround;
@@ -55,6 +58,12 @@ pub fn dungeon_room(props: &Props) -> Html {
         let leave_game = Callback::from(move |_| {
             game_dispatch.set(GameStore::default());
         });
+        let players_ready_to_descend_option =
+            if party.current_room.room_type == DungeonRoomTypes::Stairs {
+                Some(party.players_ready_to_descend.clone())
+            } else {
+                None
+            };
 
         // used to determine which battle group is the enemy
         let ally_combatant_id = characters.first().expect("party to have characters").0;
@@ -72,7 +81,8 @@ pub fn dungeon_room(props: &Props) -> Html {
                     </div>
                     if party.current_room.monsters.is_none() {
                         <PlayersReadyToExplore
-                            players_ready={party.players_ready_to_explore.clone()}
+                            players_ready_to_explore={party.players_ready_to_explore.clone()}
+                            players_ready_to_descend_option={players_ready_to_descend_option}
                             players={party.player_usernames.clone()}
                         />
                     }
@@ -90,6 +100,12 @@ pub fn dungeon_room(props: &Props) -> Html {
                             </ButtonBasic>
                         </div>
                     }
+                    if party.current_room.room_type == DungeonRoomTypes::Stairs {
+                        <Stairs />
+                    }
+                    if party.current_room.room_type == DungeonRoomTypes::Empty {
+                        <EmptyRoom />
+                    }
                     if let Some(battle_id) = game_state.current_battle_id {
                         <EnemyBattleGroup battle_id={battle_id} ally_combatant_id={ally_combatant_id} />
                     } else {
diff --git a/client/src/components/game/dungeon_room/players_ready_to_explore.rs b/client/src/components/game/dungeon_room/players_ready_to_explore.rs
index f42d21bb..fdcc1752 100644
--- a/client/src/components/game/dungeon_room/players_ready_to_explore.rs
+++ b/client/src/components/game/dungeon_room/players_ready_to_explore.rs
@@ -3,22 +3,65 @@ use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
 pub struct Props {
-    pub players_ready: HashSet<String>,
+    pub players_ready_to_explore: HashSet<String>,
+    pub players_ready_to_descend_option: Option<HashSet<String>>,
     pub players: HashSet<String>,
 }
 
 #[function_component(PlayersReadyToExplore)]
 pub fn players_ready_to_explore(props: &Props) -> Html {
-    let awaiting_readies = props.players_ready.len() != props.players.len();
+    let mut players_ready_to_descend_list = html!();
+    let mut ready_to_explore_waiting_message = AttrValue::from("Wating for players to ready up...");
+    let mut ready_to_explore_title = AttrValue::from("Players ready to explore next room");
+    if let Some(players_ready_to_descend) = props.players_ready_to_descend_option.clone() {
+        ready_to_explore_waiting_message = AttrValue::from("Wating for players to vote...");
+        ready_to_explore_title = AttrValue::from("Votes to continue exploring current floor");
+        players_ready_to_descend_list = html!(
+            <PlayersIncludedInList
+                title={AttrValue::from("Votes to descend stairs")}
+                waiting_message={AttrValue::from("Wating for players to vote...")}
+                players={props.players.clone()}
+                list_to_check={players_ready_to_descend}
+            />
+        );
+    }
     html!(
-        <div class="p-2 border border-slate-400">
+    <div class="flex flex-col flex-1">
+        <PlayersIncludedInList
+            title={ready_to_explore_title}
+            waiting_message={ready_to_explore_waiting_message}
+            players={props.players.clone()}
+            list_to_check={props.players_ready_to_explore.clone()}
+        />
+        {players_ready_to_descend_list}
+    </div>
+    )
+}
+
+#[derive(Properties, PartialEq)]
+pub struct PlayersIncludedInListProps {
+    title: AttrValue,
+    waiting_message: AttrValue,
+    players: HashSet<String>,
+    list_to_check: HashSet<String>,
+}
+
+#[function_component(PlayersIncludedInList)]
+fn players_included_in_list(props: &PlayersIncludedInListProps) -> Html {
+    let awaiting_readies = props.list_to_check.len() != props.players.len();
+
+    html!(
+        <div class="flex-1 p-2 border border-slate-400 mb-2 last:mb-0">
+            <h3 class="mb-2" >
+                {props.title.clone()}
+            </h3>
             if awaiting_readies {
                 <div>
-                    {"Waiting for players to ready up"}
+                    {props.waiting_message.clone()}
                 </div>
             }
             {props.players.iter().map(|username| {
-                 let is_ready = props.players_ready.contains(username);
+                 let is_ready = props.list_to_check.contains(username);
                  let mut ready_class = "";
                  if is_ready {
                      ready_class = "text-green-400"
diff --git a/client/src/components/game/dungeon_room/stairs.rs b/client/src/components/game/dungeon_room/stairs.rs
new file mode 100644
index 00000000..9994bd42
--- /dev/null
+++ b/client/src/components/game/dungeon_room/stairs.rs
@@ -0,0 +1,18 @@
+use yew::prelude::*;
+use yew::Html;
+
+#[function_component(Stairs)]
+pub fn stairs() -> Html {
+    html!(
+    <div class="h-full w-full flex flex-col justify-center items-center ">
+        <h3 class="mb-4" >
+            {"You find a staircase leading down..."}
+        </h3>
+        <img
+            class="max-h-full max-w-full"
+            src="public/img/stairs-down.png"
+            alt="stairs down"
+        />
+    </div>
+    )
+}
diff --git a/client/src/components/game/mod.rs b/client/src/components/game/mod.rs
index fb41e627..1bc11dc2 100644
--- a/client/src/components/game/mod.rs
+++ b/client/src/components/game/mod.rs
@@ -12,7 +12,6 @@ pub mod turn_order_bar;
 use crate::components::game::action_menu::ActionMenu;
 use crate::components::game::character_autofocus_manager::CharacterAutofocusManager;
 use crate::components::game::character_sheet::CharacterSheet;
-use crate::components::game::debug::GameDebug;
 use crate::components::game::dungeon_room::DungeonRoom;
 use crate::components::game::tabbed_display::TabbedDisplay;
 use crate::components::game::top_info_bar::TopInfoBar;
@@ -72,15 +71,14 @@ pub fn game() -> Html {
 
     let focused_character = party.characters.get(&game_state.focused_character_id);
 
+
     html!(
         <main class="h-screen w-screen p-4 bg-gray-600 text-zinc-300 flex flex-col relative">
-            <GameDebug />
+            // <GameDebug />
             <CharacterAutofocusManager />
-            <div class="absolute top-0 left-1/2 -translate-x-1/2 z-40 bg-slate-700" >
             if !game_state.viewing_inventory {
                 <TopInfoBar />
             }
-            </div>
             <div class="h-1/2 flex mb-4" >
                 <DungeonRoom party_id={party_id} />
                 if game_state.viewing_inventory && focused_character.is_some(){
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/mod.rs b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/mod.rs
index 39c43d21..c2c79d70 100644
--- a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/mod.rs
+++ b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/mod.rs
@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-
 use self::armor::*;
 use self::unmet_requirements_calculator::UnmetRequirementsCalculator;
 use crate::{
diff --git a/client/src/components/game/top_info_bar/mod.rs b/client/src/components/game/top_info_bar/mod.rs
index adca413f..efe74c05 100644
--- a/client/src/components/game/top_info_bar/mod.rs
+++ b/client/src/components/game/top_info_bar/mod.rs
@@ -2,6 +2,7 @@ use crate::components::game::turn_order_bar::TurnOrderBar;
 use crate::store::game_store::get_current_battle_option;
 use crate::store::game_store::get_current_party_option;
 use crate::store::game_store::GameStore;
+use gloo::console::log;
 use yew::prelude::*;
 use yewdux::prelude::use_store;
 
@@ -11,12 +12,57 @@ pub fn game() -> Html {
     let battle_option = get_current_battle_option(&game_state);
     let party_option = get_current_party_option(&game_state);
 
+    let top_bar_display_state = use_state(|| 1);
+    let cloned_top_bar_display_state = top_bar_display_state.clone();
+    let on_click_top_bar = Callback::from(move |_| {
+        if *cloned_top_bar_display_state == 1 {
+            cloned_top_bar_display_state.set(2)
+        } else if *cloned_top_bar_display_state == 2 {
+            cloned_top_bar_display_state.set(0)
+        } else {
+            cloned_top_bar_display_state.set(1)
+        }
+    });
+
+    let top_bar_display_class = match *top_bar_display_state {
+        2 => "top-0 left-0",
+        0 => "bottom-0 right-0 ",
+        _ => "top-0 left-1/2 -translate-x-1/2",
+    };
+
     html!(
-    <div class="border-b border-r border-l border-slate-400 bg-slate-700 w-full text-center" >
+    <button
+        onclick={on_click_top_bar}
+        class={ format!( "absolute z-40 bg-slate-700 {top_bar_display_class}" )}
+    >
+    <div class="border-b border-r border-l border-slate-400 bg-slate-700 w-full text-center " >
         if battle_option.is_some() {
                 <TurnOrderBar />
-            } else if let Some(party) =party_option{
-                <div class="m-2">
+            } else if let Some(party) = party_option {
+                <ul class="w-full list-none flex justify-center border-b border-slate-400" >
+                    {party.client_current_floor_rooms_list
+                        .iter()
+                        .enumerate()
+                        .map(|(i, room_type_option )| {
+                            log!(format!("room box index: {i} explored on current floor: {}", party.rooms_explored.on_current_floor));
+                            let current_room_class = if party.rooms_explored.on_current_floor == ( i + 1 ) as u16 {
+                                "border-yellow-400"
+                            } else {
+                                "border-slate-400"
+                            };
+
+                            html!(
+                                <li class={ format!("p-2 border {}", current_room_class) }>
+                                {match room_type_option {
+                                    Some(room_type) => {format!("{room_type}")},
+                                    None => { "?".to_string() },
+                                }}
+                                </li>
+                                )
+                        })
+                        .collect::<Html>()}
+                </ul>
+                <div class="p-2" >
                     {"Floor "}{party.current_floor}{", room "}{party.rooms_explored.on_current_floor}
                     {": "}
                     {format!("{}", party.current_room.room_type)}
@@ -25,5 +71,6 @@ pub fn game() -> Html {
                 <div>{"Error - no party found"}</div>
             }
     </div>
+    </button>
     )
 }
diff --git a/client/src/components/lobby/game_list.rs b/client/src/components/lobby/game_list.rs
index 01dd1db3..8cf0ccf3 100644
--- a/client/src/components/lobby/game_list.rs
+++ b/client/src/components/lobby/game_list.rs
@@ -1,4 +1,5 @@
-use crate::{components::lobby::game_list_item::GameListItem, store::lobby_store::LobbyStore};
+use crate::components::lobby::game_list_item::GameListItem;
+use crate::store::lobby_store::LobbyStore;
 use yew::prelude::*;
 use yewdux::prelude::use_store;
 
@@ -7,7 +8,7 @@ pub fn game_list() -> Html {
     let (lobby_state, _) = use_store::<LobbyStore>();
 
     html!(
-        <section class="flex-1 p-4 mr-4 bg-slate-700 border border-slate-400" id="game_list">
+        <section class="flex-1 p-4 mr-4 bg-slate-700 border border-slate-400 overflow-y-scroll" id="game_list">
             <h2 class="text-slate-200 text-l mb-2">{ "Games" }</h2>
             <ul class="list-none">
                 {lobby_state.game_list.iter().map(|game|
diff --git a/client/src/components/lobby/mod.rs b/client/src/components/lobby/mod.rs
index 1aa487c1..43a8ce81 100644
--- a/client/src/components/lobby/mod.rs
+++ b/client/src/components/lobby/mod.rs
@@ -3,17 +3,23 @@ pub mod game_list_item;
 pub mod game_setup;
 pub mod lobby_menu;
 pub mod user_list;
+mod welcome_info;
+use crate::components::lobby::game_list::GameList;
+use crate::components::lobby::lobby_menu::LobbyMenu;
+use crate::components::lobby::user_list::UserList;
+use crate::components::lobby::welcome_info::WelcomeInfo;
 use yew::prelude::*;
 
-use crate::components::lobby::{game_list::GameList, lobby_menu::LobbyMenu, user_list::UserList};
-
 #[function_component(Lobby)]
 pub fn lobby() -> Html {
     html!(
         <main class="min-h-screen w-screen p-4 bg-slate-800 text-zinc-300 flex flex-col">
             <LobbyMenu/>
-            <div class="w-full flex flex-1">
-                <GameList/>
+            <div class="w-full flex flex-1" >
+                <div class="w-full flex flex-col" >
+                    <WelcomeInfo />
+                    <GameList/>
+                </div>
                 <UserList/>
             </div>
         </main>
diff --git a/client/src/components/lobby/welcome_info.rs b/client/src/components/lobby/welcome_info.rs
new file mode 100644
index 00000000..8ed592ce
--- /dev/null
+++ b/client/src/components/lobby/welcome_info.rs
@@ -0,0 +1,29 @@
+use yew::prelude::*;
+
+#[function_component(WelcomeInfo)]
+pub fn welcome_info() -> Html {
+    html!(
+        <section class="flex-1 p-4 mb-4 mr-4 bg-slate-700 border border-slate-400 overflow-y-scroll">
+            <h3 class="text-lg">{"Roguelike Racing"}</h3>
+            <h5 class="mb-2">
+            {"alpha 0.2.0"}
+            </h5>
+            <p class="mb-2">
+            {"Welcome to the early alpha of Roguelike Racing, a multiplayer turn based
+            RPG in the spirit of For the King, Diablo and Final Fantasy. All layout and graphics are placeholders.
+            There is a minimum playable game in which you can do the following:"}
+            </p>
+            <ul class="list-disc list-inside" >
+                <li>{"Create and join games which consist of one or more adventuring parties"}</li>
+                <li>{"Create a party with one or more players each controlling one or more characters"}</li>
+                <li>{"Explore rooms of the dungeon which may contain monsters"}</li>
+                <li>{"Battle monsters and receive randomly generated equipment"}</li>
+                <li>{"Equip, trade and discard equipment"}</li>
+                <li>{"Try to reach the lowest floor of the dungeon by descending the stairs"}</li>
+            </ul>
+            <p>
+                {"a lot is not implemented, balanced or at all good, but if anything is severely broken you can report it at https://github.com/SnowdenWintermute/roguelike-racing/issues"}
+            </p>
+        </section>
+    )
+}
diff --git a/client/src/components/websocket_manager/dungeon_floor_number_changed_handler.rs b/client/src/components/websocket_manager/dungeon_floor_number_changed_handler.rs
new file mode 100644
index 00000000..7460a41d
--- /dev/null
+++ b/client/src/components/websocket_manager/dungeon_floor_number_changed_handler.rs
@@ -0,0 +1,15 @@
+use crate::store::game_store::GameStore;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use yewdux::Dispatch;
+
+pub fn dungeon_floor_number_changed_handler(
+    game_dispatch: Dispatch<GameStore>,
+    packet: u8,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|store| {
+        let party = store.get_current_party_mut()?;
+        party.current_floor = packet;
+        Ok(())
+    })
+}
diff --git a/client/src/components/websocket_manager/handle_packet.rs b/client/src/components/websocket_manager/handle_packet.rs
index ea957da1..cb7e2c5f 100644
--- a/client/src/components/websocket_manager/handle_packet.rs
+++ b/client/src/components/websocket_manager/handle_packet.rs
@@ -3,6 +3,7 @@ use super::adventuring_party_update_handlers::handle_adventuring_party_created;
 use super::adventuring_party_update_handlers::handle_character_creation;
 use super::adventuring_party_update_handlers::handle_character_deletion;
 use super::adventuring_party_update_handlers::handle_player_changed_adventuring_party;
+use super::dungeon_floor_number_changed_handler::dungeon_floor_number_changed_handler;
 use super::game_full_update_handler::game_full_update_handler;
 use super::handle_battle_victory_report::handle_battle_end_report;
 use super::handle_character_dropped_equipped_item::handle_character_dropped_equipped_item;
@@ -13,7 +14,9 @@ use super::in_game_party_update_handlers::handle_battle_full_update;
 use super::in_game_party_update_handlers::handle_character_ability_selection;
 use super::in_game_party_update_handlers::handle_character_changed_targets;
 use super::in_game_party_update_handlers::handle_new_dungeon_room;
+use super::in_game_party_update_handlers::handle_player_toggled_ready_to_descend;
 use super::in_game_party_update_handlers::handle_player_toggled_ready_to_explore;
+use super::in_game_party_update_handlers::new_dungeon_room_types_on_current_floor;
 use super::inventory_management_update_handlers::handle_character_equipped_item;
 use super::inventory_management_update_handlers::handle_character_unequipped_slot;
 use super::lobby_update_handlers::handle_game_started;
@@ -49,9 +52,13 @@ pub fn handle_packet(
             Ok(set_alert(alert_dispatch, message))
         }
         GameServerUpdatePackets::ClientUserName(username) => {
-            Ok(lobby_dispatch.reduce_mut(|store| {
-                store.username = username;
-            }))
+            lobby_dispatch.reduce_mut(|store| {
+                store.username = username.clone();
+            });
+            log!(format!("set username to : {username}"));
+            log!(format!("username is : {:?}", lobby_state.username));
+
+            Ok(())
         }
         GameServerUpdatePackets::FullUpdate(update) => {
             lobby_dispatch.reduce_mut(|store| {
@@ -103,15 +110,16 @@ pub fn handle_packet(
             game_dispatch.reduce_mut(move |store| handle_game_started(store, timestamp))
         }
         GameServerUpdatePackets::CharacterEquippedItem(packet) => {
-            game_dispatch.reduce_mut(|store| {
-                handle_character_equipped_item(store, packet, &lobby_state.username)
-            })
+            let username = lobby_dispatch.reduce_mut(|store| store.username.clone());
+            game_dispatch
+                .reduce_mut(|store| handle_character_equipped_item(store, packet, &username))
         }
         GameServerUpdatePackets::CharacterUnequippedSlot(packet) => {
             game_dispatch.reduce_mut(|store| handle_character_unequipped_slot(store, packet))
         }
-        GameServerUpdatePackets::PlayerToggledReadyToExplore(username) => game_dispatch
-            .reduce_mut(|store| handle_player_toggled_ready_to_explore(store, username)),
+        GameServerUpdatePackets::PlayerToggledReadyToExplore(username) => {
+            handle_player_toggled_ready_to_explore(game_dispatch, username)
+        }
         GameServerUpdatePackets::DungeonRoomUpdate(new_room) => {
             game_dispatch.reduce_mut(|store| handle_new_dungeon_room(store, new_room))
         }
@@ -140,6 +148,15 @@ pub fn handle_packet(
         GameServerUpdatePackets::CharacterDroppedEquippedItem(packet) => {
             handle_character_dropped_equipped_item(game_dispatch, websocket_dispatch, packet)
         }
+        GameServerUpdatePackets::PlayerToggledReadyToDescend(packet) => {
+            handle_player_toggled_ready_to_descend(game_dispatch, packet)
+        }
+        GameServerUpdatePackets::DungeonFloorNumber(packet) => {
+            dungeon_floor_number_changed_handler(game_dispatch, packet)
+        }
+        GameServerUpdatePackets::DungeonRoomTypesOnCurrentFloor(packet) => {
+            new_dungeon_room_types_on_current_floor(game_dispatch, packet)
+        }
         _ => {
             log!(format!("unhandled packet: {:#?}", data));
             Err(AppError {
diff --git a/client/src/components/websocket_manager/in_game_party_update_handlers.rs b/client/src/components/websocket_manager/in_game_party_update_handlers.rs
index 98285d8f..a7725fa2 100644
--- a/client/src/components/websocket_manager/in_game_party_update_handlers.rs
+++ b/client/src/components/websocket_manager/in_game_party_update_handlers.rs
@@ -3,27 +3,63 @@ use crate::store::game_store::GameStore;
 use common::app_consts::error_messages;
 use common::combat::battle::Battle;
 use common::dungeon_rooms::DungeonRoom;
+use common::dungeon_rooms::DungeonRoomTypes;
 use common::errors::AppError;
 use common::game::getters::get_mut_party;
 use common::packets::client_to_server::ChangeTargetsPacket;
 use common::packets::server_to_client::CharacterSelectedAbilityPacket;
 use gloo::console::log;
 use std::collections::HashMap;
+use std::collections::VecDeque;
+use yewdux::Dispatch;
+
+pub fn new_dungeon_room_types_on_current_floor(
+    game_dispatch: Dispatch<GameStore>,
+    packet: VecDeque<Option<DungeonRoomTypes>>,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|store| {
+        let party = store.get_current_party_mut()?;
+        party.client_current_floor_rooms_list = packet;
+        party.rooms_explored.on_current_floor = 0;
+        Ok(())
+    })
+}
 
 pub fn handle_player_toggled_ready_to_explore(
-    game_store: &mut GameStore,
+    game_dispatch: Dispatch<GameStore>,
     username: String,
 ) -> Result<(), AppError> {
     log!("player toggled ready to explore");
-    let party = game_store.get_current_party_mut()?;
-
-    if party.players_ready_to_explore.contains(&username) {
-        party.players_ready_to_explore.remove(&username);
-    } else {
-        party.players_ready_to_explore.insert(username.clone());
-    };
+    game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+        let party = store.get_current_party_mut()?;
+        if party.players_ready_to_descend.contains(&username) {
+            party.players_ready_to_descend.remove(&username);
+        }
+        if party.players_ready_to_explore.contains(&username) {
+            party.players_ready_to_explore.remove(&username);
+        } else {
+            party.players_ready_to_explore.insert(username.clone());
+        };
+        Ok(())
+    })
+}
 
-    Ok(())
+pub fn handle_player_toggled_ready_to_descend(
+    game_dispatch: Dispatch<GameStore>,
+    username: String,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+        let party = store.get_current_party_mut()?;
+        if party.players_ready_to_explore.contains(&username) {
+            party.players_ready_to_explore.remove(&username);
+        }
+        if party.players_ready_to_descend.contains(&username) {
+            party.players_ready_to_descend.remove(&username);
+        } else {
+            party.players_ready_to_descend.insert(username.clone());
+        };
+        Ok(())
+    })
 }
 
 pub fn handle_new_dungeon_room(
@@ -41,9 +77,20 @@ pub fn handle_new_dungeon_room(
     }
     let party = game_store.get_current_party_mut()?;
     party.players_ready_to_explore.clear();
+    party.players_ready_to_descend.clear();
+    let current_room_type = packet.room_type;
     party.current_room = packet;
     party.rooms_explored.on_current_floor += 1;
+    let num_rooms_explored_on_current_floor = party.rooms_explored.on_current_floor;
     party.rooms_explored.total += 1;
+    let room_to_reveal = party
+        .client_current_floor_rooms_list
+        .get_mut((num_rooms_explored_on_current_floor - 1).into())
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CLIENT_LIST_MISSING_ROOM_TYPE.to_string(),
+        })?;
+    *room_to_reveal = Some(current_room_type);
 
     Ok(())
 }
diff --git a/client/src/components/websocket_manager/inventory_management_update_handlers.rs b/client/src/components/websocket_manager/inventory_management_update_handlers.rs
index a0901c9e..d7e81463 100644
--- a/client/src/components/websocket_manager/inventory_management_update_handlers.rs
+++ b/client/src/components/websocket_manager/inventory_management_update_handlers.rs
@@ -9,6 +9,7 @@ use common::game::getters::get_party;
 use common::game::RoguelikeRacerGame;
 use common::packets::server_to_client::CharacterEquippedItemPacket;
 use common::packets::CharacterAndSlot;
+use gloo::console::log;
 
 pub fn handle_character_equipped_item(
     game_store: &mut GameStore,
@@ -20,12 +21,18 @@ pub fn handle_character_equipped_item(
         item_id,
         alt_slot,
     } = packet;
+    log!(format!("player username: {player_username}"));
     let player_owns_character = game_store
         .get_current_party_mut()?
         .player_owns_character(player_username, character_id);
     let character = game_store.get_mut_character(character_id)?;
+    log!(format!(
+        "character controller username: {}",
+        character.name_of_controlling_user
+    ));
 
     let unequipped_item_ids = character.equip_item(item_id, alt_slot)?;
+    log!(format!("unequipped {:?}", unequipped_item_ids));
     let item_to_select = match unequipped_item_ids.get(0) {
         Some(id) => {
             let mut item = None;
@@ -39,9 +46,16 @@ pub fn handle_character_equipped_item(
         None => None,
     };
 
+    log!(format!("item to select {:#?}", item_to_select));
+    log!(format!("player owns character {player_owns_character}"));
+
     if player_owns_character {
         match item_to_select {
             Some(item) => {
+                log!(format!(
+                    "player owns character, setting selected item to {:#?}",
+                    item
+                ));
                 game_store.selected_item = Some(item.clone());
                 game_store.detailed_entity = Some(DetailableEntities::Item(item.clone()));
                 game_store.hovered_entity = None;
diff --git a/client/src/components/websocket_manager/mod.rs b/client/src/components/websocket_manager/mod.rs
index 555247f2..267890ee 100644
--- a/client/src/components/websocket_manager/mod.rs
+++ b/client/src/components/websocket_manager/mod.rs
@@ -11,6 +11,7 @@ mod inventory_management_update_handlers;
 mod lobby_update_handlers;
 pub mod send_client_input;
 mod websocket_channel_packet_handlers;
+mod dungeon_floor_number_changed_handler;
 use crate::components::alerts::set_alert;
 use crate::store::alert_store::AlertStore;
 use crate::store::game_store::GameStore;
@@ -41,10 +42,10 @@ pub fn websocket_manager(props: &Props) -> Html {
     let (_, game_dispatch) = use_store::<GameStore>();
     let (_, alert_dispatch) = use_store::<AlertStore>();
     let server_url = props.server_url.clone();
-    log!(format!(
-        "attempting connection to websocket server: {}",
-        props.server_url
-    ));
+    // log!(format!(
+    //     "attempting connection to websocket server: {}",
+    //     props.server_url
+    // ));
 
     use_effect_with((), move |_| {
         let websocket = WebSocket::new(&server_url);
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 76fd7133..fd2d772d 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -17,12 +17,12 @@ pub fn app() -> Html {
     let (game_state, _) = use_store::<GameStore>();
     let game = game_state.game.clone();
     let in_production = std::env!("TRUNK_PROD");
-    log!(format!("in production: {in_production}"));
+    // log!(format!("in production: {in_production}"));
     let websocket_server_url = if in_production == "true" {
         "wss://roguelikeracing.com/ws"
     } else {
         // "wss://roguelikeracing.com/ws"
-        "127.0.0.1:8082/ws"
+        "ws://127.0.0.1:8082/ws"
     };
 
     html! {
diff --git a/client/src/store/game_store.rs b/client/src/store/game_store.rs
index 72ff5daf..51a33a06 100644
--- a/client/src/store/game_store.rs
+++ b/client/src/store/game_store.rs
@@ -14,6 +14,7 @@ use common::items::Item;
 use common::packets::server_to_client::BattleEndReportPacket;
 use common::primatives::EntityProperties;
 use std::collections::HashSet;
+use std::rc::Rc;
 use yew::AttrValue;
 use yewdux::prelude::*;
 
@@ -281,3 +282,27 @@ pub fn set_compared_item<'a>(
         }
     });
 }
+
+pub fn get_item_owned_by_focused_character(
+    id: &u32,
+    game_state: Rc<GameStore>,
+) -> Result<Item, AppError> {
+    let character = get_focused_character(&game_state)?;
+
+    for (_, item) in &character.combatant_properties.equipment {
+        if item.entity_properties.id == *id {
+            return Ok(item.clone());
+        }
+    }
+
+    for item in &character.inventory.items {
+        if item.entity_properties.id == *id {
+            return Ok(item.clone());
+        }
+    }
+
+    return Err(AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::INVALID_ITEM_ID.to_string(),
+    });
+}
diff --git a/client/style/output.css b/client/style/output.css
index d48a628d..8666cf54 100644
--- a/client/style/output.css
+++ b/client/style/output.css
@@ -578,6 +578,18 @@ video {
   top: -1.5rem;
 }
 
+.bottom-0 {
+  bottom: 0px;
+}
+
+.left-0 {
+  left: 0px;
+}
+
+.right-0 {
+  right: 0px;
+}
+
 .z-10 {
   z-index: 10;
 }
@@ -650,6 +662,10 @@ video {
   display: flex;
 }
 
+.list-item {
+  display: list-item;
+}
+
 .h-0 {
   height: 0px;
 }
@@ -690,6 +706,10 @@ video {
   max-height: 453px;
 }
 
+.max-h-full {
+  max-height: 100%;
+}
+
 .min-h-screen {
   min-height: 100vh;
 }
@@ -763,10 +783,6 @@ video {
   flex: 1 1 0%;
 }
 
-.flex-auto {
-  flex: 1 1 auto;
-}
-
 .flex-shrink {
   flex-shrink: 1;
 }
@@ -823,10 +839,18 @@ video {
   cursor: pointer;
 }
 
+.list-inside {
+  list-style-position: inside;
+}
+
 .list-none {
   list-style-type: none;
 }
 
+.list-disc {
+  list-style-type: disc;
+}
+
 .flex-col {
   flex-direction: column;
 }
@@ -863,6 +887,10 @@ video {
   overflow-y: auto;
 }
 
+.overflow-y-scroll {
+  overflow-y: scroll;
+}
+
 .overflow-ellipsis {
   text-overflow: ellipsis;
 }
@@ -965,11 +993,6 @@ video {
   border-color: rgb(212 212 216 / var(--tw-border-opacity));
 }
 
-.border-slate-100 {
-  --tw-border-opacity: 1;
-  border-color: rgb(241 245 249 / var(--tw-border-opacity));
-}
-
 .border-l-transparent {
   border-left-color: transparent;
 }
@@ -1130,6 +1153,11 @@ video {
   line-height: 1.75rem;
 }
 
+.text-xs {
+  font-size: 0.75rem;
+  line-height: 1rem;
+}
+
 .font-bold {
   font-weight: 700;
 }
diff --git a/common/src/adventuring_party/generate_next_room.rs b/common/src/adventuring_party/generate_next_room.rs
deleted file mode 100644
index 4f25362f..00000000
--- a/common/src/adventuring_party/generate_next_room.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use super::AdventuringParty;
-use crate::{
-    dungeon_rooms::{DungeonRoom, DungeonRoomTypes},
-    game::id_generator::IdGenerator,
-};
-
-impl AdventuringParty {
-    pub fn generate_next_room(&mut self, id_generator: &mut IdGenerator) {
-        let next_room = DungeonRoom::generate(
-            id_generator,
-            self.current_floor,
-            false,
-            Some(DungeonRoomTypes::MonsterLair),
-        );
-        self.current_room = next_room
-    }
-}
diff --git a/common/src/adventuring_party/generate_unexplored_rooms_queue.rs b/common/src/adventuring_party/generate_unexplored_rooms_queue.rs
new file mode 100644
index 00000000..3ecf37b6
--- /dev/null
+++ b/common/src/adventuring_party/generate_unexplored_rooms_queue.rs
@@ -0,0 +1,35 @@
+use super::AdventuringParty;
+use crate::dungeon_rooms::DungeonRoomTypes;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+
+impl AdventuringParty {
+    /// create a list of DungeonRoomTypes to generate when players vote to explore the next room in
+    /// their dungeon
+    pub fn generate_unexplored_rooms_queue(&mut self) {
+        let monster_lairs_per_floor = 1;
+        let empty_rooms_per_floor = 1;
+
+        self.unexplored_rooms.clear();
+        self.rooms_explored.on_current_floor += 1;
+
+        let mut rooms_vec = vec![];
+        for _ in 0..monster_lairs_per_floor {
+            rooms_vec.push(DungeonRoomTypes::MonsterLair)
+        }
+        for _ in 0..empty_rooms_per_floor {
+            rooms_vec.push(DungeonRoomTypes::Empty)
+        }
+
+        rooms_vec.shuffle(&mut thread_rng());
+        for room_type in rooms_vec {
+            self.unexplored_rooms.push_back(room_type);
+        }
+
+        if self.current_floor == 1 && self.rooms_explored.total == 0 {
+            self.unexplored_rooms.push_front(DungeonRoomTypes::Empty);
+        }
+
+        self.unexplored_rooms.push_back(DungeonRoomTypes::Stairs);
+    }
+}
diff --git a/common/src/adventuring_party/mod.rs b/common/src/adventuring_party/mod.rs
index f9a97955..57645822 100644
--- a/common/src/adventuring_party/mod.rs
+++ b/common/src/adventuring_party/mod.rs
@@ -1,6 +1,5 @@
-mod generate_next_room;
+mod generate_unexplored_rooms_queue;
 use crate::app_consts::error_messages;
-use crate::app_consts::error_messages::INVALID_ITEM_ID;
 use crate::character::Character;
 use crate::combatants::CombatantProperties;
 use crate::dungeon_rooms::DungeonRoom;
@@ -13,6 +12,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::collections::VecDeque;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct RoomsExplored {
@@ -27,11 +27,14 @@ pub struct AdventuringParty {
     pub websocket_channel_name: String,
     pub player_usernames: HashSet<String>,
     pub players_ready_to_explore: HashSet<String>,
+    pub players_ready_to_descend: HashSet<String>,
     pub characters: HashMap<u32, Character>,
     pub character_positions: Vec<u32>,
     pub current_floor: u8,
     pub rooms_explored: RoomsExplored,
     pub current_room: DungeonRoom,
+    pub unexplored_rooms: VecDeque<DungeonRoomTypes>,
+    pub client_current_floor_rooms_list: VecDeque<Option<DungeonRoomTypes>>,
     pub battle_id: Option<u32>,
     pub time_of_wipe: Option<u64>,
     pub time_of_escape: Option<u64>,
@@ -46,12 +49,13 @@ impl AdventuringParty {
             websocket_channel_name,
             player_usernames: HashSet::new(),
             players_ready_to_explore: HashSet::new(),
+            players_ready_to_descend: HashSet::new(),
             characters: HashMap::new(),
             character_positions: Vec::new(),
             current_floor: 1,
             rooms_explored: RoomsExplored {
-                total: 1,
-                on_current_floor: 1,
+                total: 0,
+                on_current_floor: 0,
             },
             current_room: DungeonRoom {
                 room_type: DungeonRoomTypes::Empty,
@@ -59,6 +63,8 @@ impl AdventuringParty {
                 items: Vec::new(),
                 monsters: None,
             },
+            unexplored_rooms: VecDeque::new(),
+            client_current_floor_rooms_list: VecDeque::new(),
             battle_id: None,
             time_of_wipe: None,
             time_of_escape: None,
diff --git a/common/src/app_consts/error_messages.rs b/common/src/app_consts/error_messages.rs
index 6fb23f75..80b37c16 100644
--- a/common/src/app_consts/error_messages.rs
+++ b/common/src/app_consts/error_messages.rs
@@ -1,5 +1,6 @@
 pub const UNRECOGNIZED_PACKET: &str = "An unrecognized packet was received";
 pub const USER_NOT_FOUND: &str = "The game server couldn't find a user with the provided actor id";
+pub const ACTOR_ID_NOT_FOUND: &str = "The actor id for that player is missing";
 pub const GAME_NOT_FOUND: &str = "No game found by the provided name";
 pub const MISSING_GAME_REFERENCE: &str = "Missing reference to current game";
 pub const ALREADY_IN_GAME: &str = "You are already in a game";
@@ -26,8 +27,8 @@ pub const INVALID_ITEM_ID: &str = "No valid item with the provided id was found"
 pub const ITEM_REQUIREMENTS_NOT_MET: &str =
     "You do not meet the requirements to equip or use that item";
 pub const CANT_EQUIP_NON_EQUIPMENT: &str = "Only equipment items may be equipped";
-pub const INVALID_EQUIPMENT_EQUIPPEND: &str =
-    "An invalid item was found in a character's equippment sloty";
+pub const INVALID_EQUIPMENT_EQUIPPED: &str =
+    "An invalid item was found in a character's equippment slot";
 pub const ITEM_NOT_YET_AVAILABLE: &str = "That item's data is still being sent to other clients";
 pub const ITEM_ON_GROUND_ACKNOWLEDGEMENT_SENT_BEFORE_ITEM_EXISTED: &str =
 "A client sent acknowledgement of receipt of an item on the ground before a registry was created for that item";
@@ -71,3 +72,8 @@ pub const EVENT_MANAGER_MISSING_ACTION_RESULT: &str =
 // EXPLORATION
 pub const CANT_EXPLORE_WHEN_MONSTERS_ARE_PRESENT: &str =
     "Defeat the monsters before exploring the next room";
+pub const CANT_DESCEND_IF_NO_STAIRS_ARE_PRESENT: &str =
+    "You can't go down the stairs if there are no stairs to go down";
+pub const MISSING_ROOM_TYPE_TO_GENERATE: &str =
+    "Tried to generate a new room but the party's list of rooms to generate was empty";
+pub const CLIENT_LIST_MISSING_ROOM_TYPE: &str = "The client's list of room types on the current floor didn't contain a room type at the specified index";
diff --git a/common/src/character/equip_item.rs b/common/src/character/equip_item.rs
index 275298d9..ee85512b 100644
--- a/common/src/character/equip_item.rs
+++ b/common/src/character/equip_item.rs
@@ -1,5 +1,7 @@
 use super::Character;
-use crate::{app_consts::error_messages, errors::AppError, items::equipment::EquipmentSlots};
+use crate::app_consts::error_messages;
+use crate::errors::AppError;
+use crate::items::equipment::EquipmentSlots;
 
 impl Character {
     pub fn slot_item_is_equipped(&self, item_id: &u32) -> Option<EquipmentSlots> {
@@ -10,6 +12,7 @@ impl Character {
         }
         return None;
     }
+
     /// returns list of ids of any items which were unequipped
     pub fn equip_item(&mut self, item_id: u32, alt_slot: bool) -> Result<Vec<u32>, AppError> {
         let mut item_and_index_option = None;
diff --git a/common/src/character/outfit_new_warrior.rs b/common/src/character/outfit_new_warrior.rs
index 0fd85f70..78f17c4f 100644
--- a/common/src/character/outfit_new_warrior.rs
+++ b/common/src/character/outfit_new_warrior.rs
@@ -18,18 +18,18 @@ pub fn outfit_new_warrior(game: &mut RoguelikeRacerGame, character: &mut Charact
     inherent_attributes.insert(CombatAttributes::Agility, 1);
 
     // ABILITIES
-    combatant_properties.abilities.insert(
-        CombatantAbilityNames::Fire,
-        CombatantAbility::new(CombatantAbilityNames::Fire),
-    );
-    combatant_properties.abilities.insert(
-        CombatantAbilityNames::Heal,
-        CombatantAbility::new(CombatantAbilityNames::Heal),
-    );
-    combatant_properties.abilities.insert(
-        CombatantAbilityNames::RainStorm,
-        CombatantAbility::new(CombatantAbilityNames::RainStorm),
-    );
+    // combatant_properties.abilities.insert(
+    //     CombatantAbilityNames::Fire,
+    //     CombatantAbility::new(CombatantAbilityNames::Fire),
+    // );
+    // combatant_properties.abilities.insert(
+    //     CombatantAbilityNames::Heal,
+    //     CombatantAbility::new(CombatantAbilityNames::Heal),
+    // );
+    // combatant_properties.abilities.insert(
+    //     CombatantAbilityNames::RainStorm,
+    //     CombatantAbility::new(CombatantAbilityNames::RainStorm),
+    // );
 
     // TEST INVENTORY ITEMS
     // for _ in 0..8 {
diff --git a/common/src/combat/ability_handlers/attack.rs b/common/src/combat/ability_handlers/attack.rs
index 8ade8663..7513b0de 100644
--- a/common/src/combat/ability_handlers/attack.rs
+++ b/common/src/combat/ability_handlers/attack.rs
@@ -39,59 +39,84 @@ impl RoguelikeRacerGame {
         let user_total_attributes = user_combatant_properties.get_total_attributes();
         let target_total_attributes = target_combatant_properties.get_total_attributes();
 
-        let mh_weapon_option =
+        let mh_equipment_option =
             user_combatant_properties.get_equipped_item(&EquipmentSlots::MainHand);
-        let oh_weapon_option =
+        let oh_equipment_option =
             user_combatant_properties.get_equipped_item(&EquipmentSlots::OffHand);
+        let mh_weapon_option = match mh_equipment_option {
+            Some(equipment_properties) => match equipment_properties.is_weapon() {
+                true => Some(equipment_properties),
+                false => None,
+            },
+            None => None,
+        };
+        let oh_weapon_option = match oh_equipment_option {
+            Some(equipment_properties) => match equipment_properties.is_weapon() {
+                true => Some(equipment_properties),
+                false => None,
+            },
+            None => None,
+        };
 
         if mh_weapon_option.is_some() || oh_weapon_option.is_some() {
             let mh_swing_ends_turn = oh_weapon_option.is_none();
-            if let Some(mh_equipment_properties) = mh_weapon_option {
+            println!("main hand swing ends turn ARMED: {mh_swing_ends_turn}");
+            if let Some(mh_weapon_properties) = mh_weapon_option {
                 action_results.push(calculate_weapon_swing_result(
                     ability_user_id,
                     ability_target,
                     *target_entity_id,
                     &user_total_attributes,
                     &target_total_attributes,
-                    mh_equipment_properties,
+                    mh_weapon_properties,
                     false,
                     mh_swing_ends_turn,
                 )?);
             };
-            if let Some(oh_equipment_properties) = oh_weapon_option {
+            if let Some(oh_weapon_properties) = oh_weapon_option {
                 action_results.push(calculate_weapon_swing_result(
                     ability_user_id,
                     ability_target,
                     *target_entity_id,
                     &user_total_attributes,
                     &target_total_attributes,
-                    oh_equipment_properties,
+                    oh_weapon_properties,
                     true,
                     true,
                 )?);
             };
         } else {
-            // UNARMED
-            action_results.push(calculate_weapon_swing_result(
-                ability_user_id,
-                ability_target,
-                *target_entity_id,
-                &user_total_attributes,
-                &target_total_attributes,
-                &FIST,
-                false,
-                false,
-            )?);
-            action_results.push(calculate_weapon_swing_result(
-                ability_user_id,
-                ability_target,
-                *target_entity_id,
-                &user_total_attributes,
-                &target_total_attributes,
-                &FIST,
-                true,
-                true,
-            )?);
+            // UNARMED (on)
+            let mh_swing_ends_turn = oh_equipment_option.is_some();
+            println!("oh equipment option: {:#?}", oh_equipment_option);
+            println!("unarmed mh swing ends turn: {:#?}", mh_swing_ends_turn);
+            if mh_equipment_option.is_none() {
+                action_results.push(calculate_weapon_swing_result(
+                    ability_user_id,
+                    ability_target,
+                    *target_entity_id,
+                    &user_total_attributes,
+                    &target_total_attributes,
+                    &FIST,
+                    false,
+                    mh_swing_ends_turn,
+                )?);
+            }
+            if !mh_swing_ends_turn {
+                println!("calculating oh unarmed swing: ");
+                if oh_equipment_option.is_none() {
+                    action_results.push(calculate_weapon_swing_result(
+                        ability_user_id,
+                        ability_target,
+                        *target_entity_id,
+                        &user_total_attributes,
+                        &target_total_attributes,
+                        &FIST,
+                        true,
+                        true,
+                    )?);
+                }
+            }
         }
 
         Ok(action_results)
diff --git a/common/src/combatants/get_weapon_properties_traits_and_base_bonus_damage.rs b/common/src/combatants/get_weapon_properties_traits_and_base_bonus_damage.rs
index a6acfaf0..19469bc2 100644
--- a/common/src/combatants/get_weapon_properties_traits_and_base_bonus_damage.rs
+++ b/common/src/combatants/get_weapon_properties_traits_and_base_bonus_damage.rs
@@ -42,7 +42,7 @@ pub fn get_weapon_properties_traits_and_base_bonus_damage<'a>(
         _ => {
             return Err(AppError {
                 error_type: crate::errors::AppErrorTypes::Generic,
-                message: error_messages::INVALID_EQUIPMENT_EQUIPPEND.to_string(),
+                message: error_messages::INVALID_EQUIPMENT_EQUIPPED.to_string(),
             })
         }
     }
diff --git a/common/src/dungeon_rooms/mod.rs b/common/src/dungeon_rooms/mod.rs
index 7255ad2d..06595e98 100644
--- a/common/src/dungeon_rooms/mod.rs
+++ b/common/src/dungeon_rooms/mod.rs
@@ -68,7 +68,7 @@ impl DungeonRoom {
         if room_type == DungeonRoomTypes::MonsterLair {
             let mut new_monsters = HashMap::new();
             for _ in 0..3 {
-                let new_monster = Monster::generate(id_generator, floor, 10);
+                let new_monster = Monster::generate(id_generator, floor, 10 * floor as u16);
                 new_monsters.insert(new_monster.entity_properties.id, new_monster);
             }
             monsters = Some(new_monsters);
diff --git a/common/src/items/equipment/equipment_generation/create_starting_equipment.rs b/common/src/items/equipment/equipment_generation/create_starting_equipment.rs
index 70956d1a..a15e99d6 100644
--- a/common/src/items/equipment/equipment_generation/create_starting_equipment.rs
+++ b/common/src/items/equipment/equipment_generation/create_starting_equipment.rs
@@ -1,19 +1,24 @@
 use crate::combatants::combat_attributes::CombatAttributes;
-use crate::{
-    game::id_generator::IdGenerator,
-    items::{
-        equipment::{
-            armor_properties::{ArmorCategories, ArmorProperties},
-            body_armors::BodyArmors,
-            head_gears::HeadGears,
-            one_handed_melee_weapons::OneHandedMeleeWeapons,
-            weapon_properties::{DamageClassifications, DamageTypes, WeaponProperties},
-            EquipmentProperties, EquipmentSlots, EquipmentTypes,
-        },
-        Item, ItemProperties,
-    },
-    primatives::{EntityProperties, MaxAndCurrent, Range},
-};
+use crate::game::id_generator::IdGenerator;
+use crate::items::equipment::armor_properties::ArmorCategories;
+use crate::items::equipment::armor_properties::ArmorProperties;
+use crate::items::equipment::body_armors::BodyArmors;
+use crate::items::equipment::head_gears::HeadGears;
+use crate::items::equipment::one_handed_melee_weapons::OneHandedMeleeWeapons;
+use crate::items::equipment::shield_properties::ShieldProperties;
+use crate::items::equipment::shield_properties::ShieldSizes;
+use crate::items::equipment::shields::Shields;
+use crate::items::equipment::weapon_properties::DamageClassifications;
+use crate::items::equipment::weapon_properties::DamageTypes;
+use crate::items::equipment::weapon_properties::WeaponProperties;
+use crate::items::equipment::EquipmentProperties;
+use crate::items::equipment::EquipmentSlots;
+use crate::items::equipment::EquipmentTypes;
+use crate::items::Item;
+use crate::items::ItemProperties;
+use crate::primatives::EntityProperties;
+use crate::primatives::MaxAndCurrent;
+use crate::primatives::Range;
 use std::collections::HashMap;
 
 pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<EquipmentSlots, Item> {
@@ -97,19 +102,32 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
         name: "Mud Soaked Branch".to_string(),
     };
 
-    let main_hand = Item {
+    let _main_hand = Item {
         entity_properties: main_hand_entity_properties,
         item_level: 0,
         requirements: None,
         item_properties: ItemProperties::Equipment(main_hand_properties),
     };
 
+    // let off_hand_properties = EquipmentProperties {
+    //     equipment_type: EquipmentTypes::OneHandedMeleeWeapon(
+    //         OneHandedMeleeWeapons::Stick,
+    //         WeaponProperties {
+    //             damage_classifications: vec![DamageClassifications::Physical(DamageTypes::Blunt)],
+    //             damage: Range::new(1, 4),
+    //         },
+    //     ),
+    //     durability: Some(MaxAndCurrent::new(2, 2)),
+    //     attributes: HashMap::new(),
+    //     affixes: vec![],
+    //     traits: None,
+    // };
     let off_hand_properties = EquipmentProperties {
-        equipment_type: EquipmentTypes::OneHandedMeleeWeapon(
-            OneHandedMeleeWeapons::Stick,
-            WeaponProperties {
-                damage_classifications: vec![DamageClassifications::Physical(DamageTypes::Blunt)],
-                damage: Range::new(1, 4),
+        equipment_type: EquipmentTypes::Shield(
+            Shields::MakeshiftBuckler,
+            ShieldProperties {
+                size: ShieldSizes::Small,
+                armor_class: 100,
             },
         ),
         durability: Some(MaxAndCurrent::new(2, 2)),
@@ -204,7 +222,7 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
 
     // starting_equipment.insert(EquipmentSlots::Body, chest);
     starting_equipment.insert(EquipmentSlots::Head, head);
-    starting_equipment.insert(EquipmentSlots::MainHand, main_hand);
+    // starting_equipment.insert(EquipmentSlots::MainHand, main_hand);
     starting_equipment.insert(EquipmentSlots::OffHand, off_hand);
     starting_equipment.insert(EquipmentSlots::RightRing, right_ring);
     starting_equipment.insert(EquipmentSlots::LeftRing, left_ring);
diff --git a/common/src/items/equipment/mod.rs b/common/src/items/equipment/mod.rs
index 211027a4..5abf1463 100644
--- a/common/src/items/equipment/mod.rs
+++ b/common/src/items/equipment/mod.rs
@@ -107,17 +107,6 @@ pub struct EquipmentProperties {
     pub traits: Option<Vec<EquipmentTraits>>,
 }
 
-impl EquipmentProperties {
-    pub fn get_base_armor_class(&self) -> u8 {
-        match &self.equipment_type {
-            EquipmentTypes::BodyArmor(_, armor_properties) => armor_properties.armor_class,
-            EquipmentTypes::HeadGear(_, armor_properties) => armor_properties.armor_class,
-            EquipmentTypes::Shield(_, shield_properties) => shield_properties.armor_class,
-            _ => 0,
-        }
-    }
-}
-
 #[derive(PartialEq, Clone, Debug)]
 pub struct EquipableSlots {
     pub main: EquipmentSlots,
@@ -131,6 +120,15 @@ impl EquipableSlots {
 }
 
 impl EquipmentProperties {
+    pub fn get_base_armor_class(&self) -> u8 {
+        match &self.equipment_type {
+            EquipmentTypes::BodyArmor(_, armor_properties) => armor_properties.armor_class,
+            EquipmentTypes::HeadGear(_, armor_properties) => armor_properties.armor_class,
+            EquipmentTypes::Shield(_, shield_properties) => shield_properties.armor_class,
+            _ => 0,
+        }
+    }
+
     pub fn get_equippable_slots(&self) -> EquipableSlots {
         match self.equipment_type {
             EquipmentTypes::BodyArmor(_, _) => EquipableSlots::new(EquipmentSlots::Body, None),
@@ -154,6 +152,15 @@ impl EquipmentProperties {
         }
     }
 
+    pub fn is_weapon(&self) -> bool {
+        match self.equipment_type {
+            EquipmentTypes::OneHandedMeleeWeapon(_, _) |
+            EquipmentTypes::TwoHandedMeleeWeapon(_, _) |
+            EquipmentTypes::TwoHandedRangedWeapon(_, _) => true,
+            _ => false
+        }
+    }
+
     pub fn is_two_handed(&self) -> bool {
         match self.equipment_type {
             EquipmentTypes::TwoHandedMeleeWeapon(_, _)
diff --git a/common/src/packets/server_to_client.rs b/common/src/packets/server_to_client.rs
index 8d92cce9..c8dfdaff 100644
--- a/common/src/packets/server_to_client.rs
+++ b/common/src/packets/server_to_client.rs
@@ -11,11 +11,13 @@ use crate::combatants::abilities::AbilityTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::CombatantClass;
 use crate::dungeon_rooms::DungeonRoom;
+use crate::dungeon_rooms::DungeonRoomTypes;
 use crate::game::RoguelikeRacerGame;
 use crate::items::Item;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashSet;
+use std::collections::VecDeque;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum GameServerUpdatePackets {
@@ -48,6 +50,7 @@ pub enum GameServerUpdatePackets {
     CharacterEquippedItem(CharacterEquippedItemPacket),
     CharacterUnequippedSlot(CharacterAndSlot),
     PlayerToggledReadyToExplore(String),
+    PlayerToggledReadyToDescend(String),
     DungeonRoomUpdate(DungeonRoom),
     CharacterSelectedAbility(CharacterSelectedAbilityPacket),
     CharacterChangedTargets(ChangeTargetsPacket),
@@ -58,6 +61,8 @@ pub enum GameServerUpdatePackets {
     CharacterPickedUpItem(CharacterAndItem),
     CharacterDroppedItem(CharacterAndItem),
     CharacterDroppedEquippedItem(CharacterAndSlot),
+    DungeonFloorNumber(u8),
+    DungeonRoomTypesOnCurrentFloor(VecDeque<Option<DungeonRoomTypes>>),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default)]
diff --git a/dockerfiles/server.Dockerfile b/dockerfiles/server.Dockerfile
index 8757e420..f897ef58 100644
--- a/dockerfiles/server.Dockerfile
+++ b/dockerfiles/server.Dockerfile
@@ -32,4 +32,5 @@ COPY --from=builder /app/server/target .
 RUN ls -a
 WORKDIR /
 EXPOSE 8082
+ENV RUST_BACKTRACE=1
 CMD ["./app/release/server"]
diff --git a/server/Cargo.toml b/server/Cargo.toml
index e67b2526..1d6b8dca 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -16,3 +16,7 @@ log = "0.4"
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 serde_cbor = "0.10"
+
+[profile.release]
+panic = 'abort'
+
diff --git a/server/src/websocket_server/game_server/mod.rs b/server/src/websocket_server/game_server/mod.rs
index 2f7b9528..3cf50429 100644
--- a/server/src/websocket_server/game_server/mod.rs
+++ b/server/src/websocket_server/game_server/mod.rs
@@ -131,6 +131,9 @@ impl Handler<ClientBinaryMessage> for GameServer {
             Ok(PlayerInputs::ToggleReadyToExplore) => {
                 self.toggle_ready_to_explore_handler(message.actor_id)
             }
+            Ok(PlayerInputs::ToggleReadyToGoDownStairs) => {
+                self.toggle_ready_to_descend_handler(message.actor_id)
+            }
             Ok(PlayerInputs::SelectAbility(packet)) => {
                 self.character_selects_ability_handler(message.actor_id, packet)
             }
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/mod.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/mod.rs
index 2d1600a8..2335485b 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/mod.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/mod.rs
@@ -135,7 +135,8 @@ impl GameServer {
         let loot_option = if in_monster_lair && all_opponents_are_dead {
             let mut loot = vec![];
             println!("creating loot for dlvl {dlvl}");
-            for _ in 0..num_opponents {
+            // for _ in 0..num_opponents {
+            for _ in 0..30 {
                 loot.push(Item::generate(&mut game.id_generator, dlvl))
             }
             Some(loot)
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/mod.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/mod.rs
index 9a666e30..ed3e5a96 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/mod.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/mod.rs
@@ -7,5 +7,6 @@ mod character_selects_ability_handler;
 mod character_uses_selected_ability_handler;
 mod client_acknowledges_receipt_of_item_on_ground_handler;
 mod equip_item_handler;
+mod toggle_ready_to_descend_handler;
 mod toggle_ready_to_explore_handler;
 mod unequip_slot_handler;
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_descend_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_descend_handler.rs
new file mode 100644
index 00000000..5832e1df
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_descend_handler.rs
@@ -0,0 +1,104 @@
+use crate::websocket_server::game_server::getters::get_mut_game;
+use crate::websocket_server::game_server::getters::get_mut_user;
+use crate::websocket_server::game_server::GameServer;
+use common::app_consts::error_messages;
+use common::dungeon_rooms::DungeonRoomTypes;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::game::getters::get_mut_player;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+
+impl GameServer {
+    pub fn toggle_ready_to_descend_handler(&mut self, actor_id: u32) -> Result<(), AppError> {
+        let user = get_mut_user(&mut self.sessions, actor_id)?;
+        let username = user.username.clone();
+        let game_name = user.current_game_name.clone().ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ServerError,
+            message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+        })?;
+        let game = get_mut_game(&mut self.games, &game_name)?;
+        let player = get_mut_player(game, &username)?;
+        let party_id = player.party_id.ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ServerError,
+            message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+        })?;
+        let party = get_mut_party(game, party_id)?;
+        let party_websocket_channel_name = party.websocket_channel_name.clone();
+
+        if party.current_room.room_type != DungeonRoomTypes::Stairs {
+            return Err(AppError {
+                error_type: common::errors::AppErrorTypes::InvalidInput,
+                message: error_messages::CANT_DESCEND_IF_NO_STAIRS_ARE_PRESENT.to_string(),
+            });
+        }
+
+        // can't be trying to explore and descend at the same time
+        if party.players_ready_to_explore.contains(&username) {
+            party.players_ready_to_explore.remove(&username);
+        }
+        if party.players_ready_to_descend.contains(&username) {
+            party.players_ready_to_descend.remove(&username);
+        } else {
+            party.players_ready_to_descend.insert(username.clone());
+        }
+
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::PlayerToggledReadyToDescend(username),
+            None,
+        )?;
+
+        let game = get_mut_game(&mut self.games, &game_name)?;
+        let party = get_mut_party(game, party_id)?;
+        // if all players names are in the ready to explore list, generate the next room and remove
+        // them all from the ready list
+        let mut all_players_ready_to_descend = true;
+        for username in &party.player_usernames {
+            if party.players_ready_to_descend.contains(username) {
+                continue;
+            } else {
+                all_players_ready_to_descend = false;
+                break;
+            }
+        }
+
+        if all_players_ready_to_descend {
+            // increase the floor count
+            party.current_floor += 1;
+            party.generate_unexplored_rooms_queue();
+            let current_floor = party.current_floor;
+            party.players_ready_to_descend.clear();
+            let player_usernames = party.player_usernames.clone();
+            let mut actor_ids = vec![];
+            for username in player_usernames {
+                let player = game.players.get(&username).ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ServerError,
+                    message: error_messages::PLAYER_NOT_FOUND.to_string(),
+                })?;
+                let player_actor_id = player.actor_id.ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ServerError,
+                    message: error_messages::ACTOR_ID_NOT_FOUND.to_string(),
+                })?;
+                actor_ids.push(player_actor_id.clone())
+            }
+            // tell clients their floor number increased
+            self.emit_packet(
+                &party_websocket_channel_name,
+                &WebsocketChannelNamespace::Party,
+                &GameServerUpdatePackets::DungeonFloorNumber(current_floor),
+                None,
+            )?;
+            for player_actor_id in actor_ids {
+                self.toggle_ready_to_explore_handler(player_actor_id)?;
+            }
+            //
+            // @TODO - if next room would be stairs and the party is on the final floor, set their
+            // time of escape
+            // @TODO - if current room is stairs, reset the room order on the current floor
+        }
+
+        Ok(())
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_explore_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_explore_handler.rs
index a039c614..59ae74e9 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_explore_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_explore_handler.rs
@@ -1,3 +1,5 @@
+use std::collections::VecDeque;
+
 use crate::websocket_server::game_server::getters::get_mut_game;
 use crate::websocket_server::game_server::getters::get_mut_user;
 use crate::websocket_server::game_server::GameServer;
@@ -11,7 +13,6 @@ use common::game::getters::get_mut_party;
 use common::game::getters::get_mut_player;
 use common::packets::server_to_client::GameServerUpdatePackets;
 use common::packets::WebsocketChannelNamespace;
-use std::collections::HashSet;
 
 impl GameServer {
     pub fn toggle_ready_to_explore_handler(&mut self, actor_id: u32) -> Result<(), AppError> {
@@ -38,7 +39,10 @@ impl GameServer {
         }
 
         let current_floor = party.current_floor;
-        //
+        // can't be trying to explore and descend at the same time
+        if party.players_ready_to_descend.contains(&username) {
+            party.players_ready_to_descend.remove(&username);
+        }
         if party.players_ready_to_explore.contains(&username) {
             party.players_ready_to_explore.remove(&username);
         } else {
@@ -65,23 +69,58 @@ impl GameServer {
                 break;
             }
         }
-        println!(
-            "all players ready to explore: {}",
-            all_players_ready_to_explore
-        );
 
         let mut new_room = None;
         if all_players_ready_to_explore {
-            party.players_ready_to_explore = HashSet::new();
+            // @TODO - if next room would be stairs and the party is on the final floor, set their
+            // time of escape
+            // @TODO - if current room is stairs, reset the room order on the current floor
+
+            party.players_ready_to_explore.clear();
+            let room_type_to_generate_option = party.unexplored_rooms.pop_front();
+            let mut new_room_types_list_for_client_option = None;
+            let room_type_to_generate = match room_type_to_generate_option {
+                Some(room_type_to_generate) => room_type_to_generate,
+                None => {
+                    party.generate_unexplored_rooms_queue();
+                    new_room_types_list_for_client_option = Some(party.unexplored_rooms.clone());
+                    party.unexplored_rooms.pop_front().ok_or_else(|| AppError {
+                        error_type: common::errors::AppErrorTypes::ServerError,
+                        message: error_messages::MISSING_ROOM_TYPE_TO_GENERATE.to_string(),
+                    })?
+                }
+            };
+
             new_room = Some(DungeonRoom::generate(
                 &mut game.id_generator,
                 current_floor,
                 false,
-                Some(DungeonRoomTypes::MonsterLair),
+                Some(room_type_to_generate),
             ));
             //
+            if let Some(new_room_types_list_for_client) = new_room_types_list_for_client_option {
+                let new_room_types_list_for_client = new_room_types_list_for_client
+                    .into_iter()
+                    .map(|item| {
+                        if item == DungeonRoomTypes::MonsterLair {
+                            Some(DungeonRoomTypes::MonsterLair)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<VecDeque<Option<DungeonRoomTypes>>>();
+                self.emit_packet(
+                    &party_websocket_channel_name,
+                    &WebsocketChannelNamespace::Party,
+                    &GameServerUpdatePackets::DungeonRoomTypesOnCurrentFloor(
+                        new_room_types_list_for_client,
+                    ),
+                    None,
+                )?;
+            }
         }
 
+        let game = get_mut_game(&mut self.games, &game_name)?;
         let party = get_mut_party(game, party_id)?;
         if let Some(room) = new_room {
             party.current_room = room.clone();
diff --git a/server/src/websocket_server/game_server/player_input_handlers/toggle_ready_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/toggle_ready_handler.rs
index 94af67a3..3f988008 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/toggle_ready_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/toggle_ready_handler.rs
@@ -2,10 +2,12 @@ use crate::websocket_server::game_server::getters::get_mut_game;
 use crate::websocket_server::game_server::getters::get_mut_user;
 use crate::websocket_server::game_server::GameServer;
 use common::app_consts::error_messages;
+use common::dungeon_rooms::DungeonRoomTypes;
 use common::errors::AppError;
 use common::game::getters::get_mut_player;
 use common::packets::server_to_client::GameServerUpdatePackets;
 use common::packets::WebsocketChannelNamespace;
+use std::collections::VecDeque;
 use std::time::SystemTime;
 use std::time::UNIX_EPOCH;
 
@@ -53,6 +55,18 @@ impl GameServer {
         println!("all players readied: {}", all_players_ready);
         // if all players have their name in the readied list, start the game
         if all_players_ready {
+            let actor_ids: Vec<Option<u32>> = game
+                .players
+                .iter()
+                .map(|(_, player)| player.actor_id)
+                .collect();
+            for actor_id in actor_ids {
+                self.toggle_ready_to_explore_handler(actor_id.ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ServerError,
+                    message: error_messages::ACTOR_ID_NOT_FOUND.to_string(),
+                })?)?;
+            }
+            let game = get_mut_game(&mut self.games, &game_name)?;
             game.time_started = Some(
                 SystemTime::now()
                     .duration_since(UNIX_EPOCH)