diff --git a/client/cypress/e2e/first-user.cy.ts b/client/cypress/e2e/first-user.cy.ts
index 3a5071a7..813a332b 100644
--- a/client/cypress/e2e/first-user.cy.ts
+++ b/client/cypress/e2e/first-user.cy.ts
@@ -23,15 +23,20 @@ describe("a test test", () => {
     cy.task("waitForCheckpoint", "second player character created");
 
     cy.findByRole("button", { name: "Ready" }).click();
-    // cy.findByText("Open Inventory").click();
+    cy.findByText("Open Inventory").click();
+    cy.findAllByText("HP Autoinjector").first().click();
+    cy.findByText("Use").click();
+    cy.findByText("Execute").click();
+    cy.findByText("Close Inventory").click();
+
     cy.findByText("Ready to explore").click();
-    // cy.findByText("Attack").click();
-    // cy.findByText("Execute").click();
+    cy.findByText("Attack").click();
+    cy.findByText("Execute").click();
 
-    // cy.wait(2000);
+    cy.wait(2000);
 
-    // cy.findByText("Attack").click();
-    // cy.findByText("Execute").click();
+    cy.findByText("Attack").click();
+    cy.findByText("Execute").click();
     // cy.task("checkpoint", "first attack executed");
 
     // 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 ba042f95..f980f895 100644
--- a/client/cypress/e2e/second-user.cy.ts
+++ b/client/cypress/e2e/second-user.cy.ts
@@ -13,6 +13,13 @@ describe("a test test", () => {
     cy.findByRole("button", { name: "Create Character" }).click();
     cy.task("checkpoint", "second player character created");
     cy.findByRole("button", { name: "Ready" }).click();
+
+    cy.findByText("Open Inventory").click();
+    cy.findAllByText("HP Autoinjector").first().click();
+    cy.findByText("Use").click();
+    cy.findByText("Execute").click();
+    cy.findByText("Close Inventory").click();
+
     cy.findByText("Ready to explore").click();
 
     // cy.task("waitForCheckpoint", "first attack executed");
diff --git a/client/cypress/e2e/test.cy.ts b/client/cypress/e2e/test.cy.ts
index 5cfaedd7..86c3fbed 100644
--- a/client/cypress/e2e/test.cy.ts
+++ b/client/cypress/e2e/test.cy.ts
@@ -12,22 +12,31 @@ 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("Rebecca Chambers", { delay: 0 });
-    // cy.findByRole("button", { name: "Create Character" }).focus();
-    // cy.findByRole("button", { name: "Create Character" }).click();
+    cy.findByPlaceholderText("Character name...")
+      .click()
+      .clear()
+      .type("Rebecca Chambers", { delay: 0 });
+    cy.findByRole("button", { name: "Create Character" }).focus();
+    cy.findByRole("button", { name: "Create Character" }).click();
 
-    // cy.findByPlaceholderText("Character name...")
-    //   .click()
-    //   .clear()
-    //   .type("character 3", { delay: 0 });
-    // cy.findByRole("button", { name: "Create Character" }).focus();
-    // cy.findByRole("button", { name: "Create Character" }).click();
+    cy.findByPlaceholderText("Character name...")
+      .click()
+      .clear()
+      .type("character 3", { delay: 0 });
+    cy.findByRole("button", { name: "Create Character" }).focus();
+    cy.findByRole("button", { name: "Create Character" }).click();
 
     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.wait(1200);
+    // cy.findByText("Attack").click();
+    // cy.findByText("Execute").click();
+    // cy.wait(1200);
+    // cy.findByText("Attack").click();
+    // cy.findByText("Execute").click();
   });
 });
diff --git a/client/dist/index.html b/client/dist/index.html
index 2fdace13..d367b43c 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-c24bce4d664576cf.css">
+    <link rel="stylesheet" href="/output-3a7d22295aa4068d.css">
     
     <base href="/">
   
-<link rel="preload" href="/roguelike-racing-client-a1f8a7222ed7da46_bg.wasm" as="fetch" type="application/wasm" crossorigin="">
-<link rel="modulepreload" href="/roguelike-racing-client-a1f8a7222ed7da46.js"></head>
+<link rel="preload" href="/roguelike-racing-client-1290ce234f6245d9_bg.wasm" as="fetch" type="application/wasm" crossorigin="">
+<link rel="modulepreload" href="/roguelike-racing-client-1290ce234f6245d9.js"></head>
   <body>
 
-<script type="module">import init from '/roguelike-racing-client-a1f8a7222ed7da46.js';init('/roguelike-racing-client-a1f8a7222ed7da46_bg.wasm');</script><script>(function () {
+<script type="module">import init from '/roguelike-racing-client-1290ce234f6245d9.js';init('/roguelike-racing-client-1290ce234f6245d9_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/src/components/common_components/atoms/button_basic.rs b/client/src/components/common_components/atoms/button_basic.rs
index 63d8edf5..311aad8d 100644
--- a/client/src/components/common_components/atoms/button_basic.rs
+++ b/client/src/components/common_components/atoms/button_basic.rs
@@ -6,6 +6,10 @@ use crate::components::common_components::atoms::button_blank::ButtonBlank;
 pub struct Props {
     #[prop_or(Callback::from(|_e: MouseEvent|()))]
     pub onclick: Callback<MouseEvent>,
+    #[prop_or(Callback::from(|_e: FocusEvent|()))]
+    pub onfocus: Callback<FocusEvent>,
+    #[prop_or(Callback::from(|_e: FocusEvent|()))]
+    pub onblur: Callback<FocusEvent>,
     #[prop_or(false)]
     pub disabled: bool,
     #[prop_or_default]
@@ -27,6 +31,8 @@ pub fn button_basic(props: &Props) -> Html {
                 )
             }
             onclick={props.onclick.clone()}
+            onfocus={props.onfocus.clone()}
+            onblur={props.onblur.clone()}
             disabled={props.disabled}
             button_type={props.button_type.clone()}
         >
diff --git a/client/src/components/common_components/atoms/targeting_indicator.rs b/client/src/components/common_components/atoms/targeting_indicator.rs
index e9f61cee..34d852da 100644
--- a/client/src/components/common_components/atoms/targeting_indicator.rs
+++ b/client/src/components/common_components/atoms/targeting_indicator.rs
@@ -1,13 +1,28 @@
+use common::combatants::abilities::CombatantAbilityNames;
+use common::items::consumables::ConsumableProperties;
+use common::items::consumables::ConsumableTypes;
 use yew::prelude::*;
 
 #[derive(Properties, PartialEq)]
-pub struct Props {}
+pub struct Props {
+    pub ability_name_option: Option<CombatantAbilityNames>,
+    pub consumable_option: Option<ConsumableProperties>,
+}
 
 #[function_component(TargetingIndicator)]
-pub fn targeting_indicator(_: &Props) -> Html {
+pub fn targeting_indicator(props: &Props) -> Html {
+    let mut color = "yellow-700";
+
+    if let Some(consumable) = &props.consumable_option {
+        match consumable.consumable_type {
+            ConsumableTypes::HpAutoinjector => color = "green-600",
+            ConsumableTypes::Grenade => (),
+            ConsumableTypes::SmokeBomb => color = "gray-700",
+        }
+    }
     html!(
-        <div class="w-0 h-0 border-t-[1.5rem] border-t-yellow-700
-        border-r-[1.5rem] border-r-transparent border-l-[1.5rem] border-l-transparent
-        " />
+        <div class={format!("w-0 h-0 border-t-[1.5rem] border-t-{color}
+                            border-r-[1.5rem] border-r-transparent border-l-[1.5rem] border-l-transparent
+        ")} />
     )
 }
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targeting_schemes.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targeting_schemes.rs
new file mode 100644
index 00000000..d594e305
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targeting_schemes.rs
@@ -0,0 +1,74 @@
+use super::handle_cycle_combat_action_targeting_schemes::handle_cycle_combat_action_targeting_schemes;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ChangeTargetsPacket;
+use common::packets::client_to_server::PlayerInputs;
+use gloo::console::log;
+use web_sys::WebSocket;
+use yewdux::Dispatch;
+
+pub fn handle_cycle_ability_targeting_schemes(
+    game_dispatch: Dispatch<GameStore>,
+    websocket_option: &Option<WebSocket>,
+) {
+    let result = move || -> Result<(), AppError> {
+        game_dispatch.reduce_mut(|game_store| {
+            let game = game_store.game.as_mut().ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+            })?;
+            let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+            })?;
+            let party = get_mut_party(game, party_id)?;
+            let focused_character = party
+                .characters
+                .get(&game_store.focused_character_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+                })?;
+            let focused_character_id = focused_character.entity_properties.id;
+            let current_targets = focused_character
+                .combatant_properties
+                .combat_action_targets
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::Generic,
+                    message: error_messages::TRIED_TO_CYCLE_TARGETS_WHEN_NO_TARGETS.to_string(),
+                })
+                .cloned()?;
+            let ability_name = focused_character
+                .combatant_properties
+                .selected_ability_name
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
+                })?;
+            // if only one targeting scheme, return early
+            let ability_attributes = ability_name.get_attributes();
+            let combat_action_properties = ability_attributes.combat_action_properties;
+            let new_targets = handle_cycle_combat_action_targeting_schemes(
+                game_store,
+                combat_action_properties,
+                current_targets,
+            )?;
+
+            log!(format!("sending new ability targets {:#?}", new_targets));
+            send_client_input(
+                &websocket_option,
+                PlayerInputs::ChangeAbilityTargets(ChangeTargetsPacket {
+                    character_id: focused_character_id,
+                    new_targets,
+                }),
+            );
+            Ok(())
+        })
+    };
+    let _ = result();
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targets.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targets.rs
new file mode 100644
index 00000000..5377cc10
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_ability_targets.rs
@@ -0,0 +1,72 @@
+use super::handle_cycle_combat_action_targets::handle_cycle_combat_action_targets;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ChangeTargetsPacket;
+use common::packets::client_to_server::PlayerInputs;
+use common::primatives::NextOrPrevious;
+use gloo::console::log;
+use web_sys::WebSocket;
+use yewdux::prelude::Dispatch;
+
+pub fn handle_cycle_ability_targets(
+    game_dispatch: Dispatch<GameStore>,
+    websocket_option: &Option<WebSocket>,
+    direction: &NextOrPrevious,
+) {
+    game_dispatch.reduce_mut(|game_store| {
+        let mut closure = move || -> Result<(), AppError> {
+            let game = game_store.game.as_mut().ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+            })?;
+            let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+            })?;
+            let party = get_mut_party(game, party_id)?;
+            let focused_character = party
+                .characters
+                .get(&game_store.focused_character_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+                })?;
+            let focused_character_id = focused_character.entity_properties.id;
+            let ability_name = focused_character
+                .combatant_properties
+                .selected_ability_name
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
+                })?;
+            let ability_name = ability_name.clone();
+            let ability_attributes = ability_name.get_attributes();
+            let combat_action_properties = ability_attributes.combat_action_properties;
+            let new_targets = handle_cycle_combat_action_targets(
+                game_store,
+                combat_action_properties,
+                direction,
+            )?;
+
+            send_client_input(
+                &websocket_option,
+                PlayerInputs::ChangeAbilityTargets(ChangeTargetsPacket {
+                    character_id: focused_character_id,
+                    new_targets,
+                }),
+            );
+            Ok(())
+        };
+        let result = closure();
+        if result.is_ok() {
+            ()
+        } else {
+            log!("an unhandled client error occured");
+            log!(format!("{:#?}", result.err()))
+        }
+    });
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targeting_schemes.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targeting_schemes.rs
new file mode 100644
index 00000000..7f1b19ac
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targeting_schemes.rs
@@ -0,0 +1,132 @@
+use crate::store::game_store::get_cloned_current_battle_option;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::CombatActionProperties;
+use common::combat::combat_actions::CombatActionTarget;
+use common::errors::AppError;
+use common::game::getters::get_ally_ids_and_opponent_ids_option;
+use common::game::getters::get_mut_party;
+use gloo::console::log;
+
+pub fn handle_cycle_combat_action_targeting_schemes(
+    game_store: &mut GameStore,
+    combat_action_properties: CombatActionProperties,
+    current_targets: CombatActionTarget,
+) -> Result<CombatActionTarget, AppError> {
+    if combat_action_properties.targeting_schemes.len() < 2 {
+        log!("only one targeting scheme available for that action");
+        return Ok(current_targets);
+    }
+    let battle_option = get_cloned_current_battle_option(&game_store);
+    let game = game_store.game.as_mut().ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+    })?;
+    let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+    })?;
+    let party = get_mut_party(game, party_id)?;
+    let cloned_character_positions = party.character_positions.clone();
+    let focused_character = party
+        .characters
+        .get(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+
+    let last_used_targeting_scheme = &focused_character
+        .combatant_properties
+        .combat_action_target_preferences
+        .targeting_scheme_preference;
+
+    let new_targeting_scheme = if !combat_action_properties
+        .targeting_schemes
+        .contains(last_used_targeting_scheme)
+    {
+        combat_action_properties
+            .targeting_schemes
+            .first()
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
+            })?
+    } else {
+        let last_used_targeting_scheme_index = combat_action_properties
+            .targeting_schemes
+            .iter()
+            .position(|scheme| scheme == last_used_targeting_scheme)
+            .expect("checked it contains above");
+        let new_scheme_index = if last_used_targeting_scheme_index
+            == combat_action_properties.targeting_schemes.len() - 1
+        {
+            0
+        } else {
+            last_used_targeting_scheme_index + 1
+        };
+        combat_action_properties
+            .targeting_schemes
+            .get(new_scheme_index)
+            .expect("a valid index")
+    };
+
+    let focused_character = party
+        .characters
+        .get_mut(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+
+    focused_character
+        .combatant_properties
+        .combat_action_target_preferences
+        .targeting_scheme_preference = new_targeting_scheme.clone();
+
+    let focused_character = party
+        .characters
+        .get(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+
+    let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
+        &cloned_character_positions,
+        battle_option.as_ref(),
+        focused_character.entity_properties.id,
+    )?;
+
+    let new_targets = combat_action_properties.targets_by_saved_preference_or_default(
+        focused_character.entity_properties.id,
+        &focused_character
+            .combatant_properties
+            .combat_action_target_preferences,
+        ally_ids.clone(),
+        opponent_ids_option.clone(),
+    )?;
+
+    let new_preferences = focused_character
+        .combatant_properties
+        .combat_action_target_preferences
+        .get_updated_preferences(
+            &combat_action_properties,
+            &new_targets,
+            ally_ids,
+            opponent_ids_option,
+        );
+    let focused_character = party
+        .characters
+        .get_mut(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+
+    focused_character
+        .combatant_properties
+        .combat_action_target_preferences = new_preferences;
+
+    Ok(new_targets)
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targets.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targets.rs
new file mode 100644
index 00000000..4a76870a
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_combat_action_targets.rs
@@ -0,0 +1,94 @@
+use crate::store::game_store::get_cloned_current_battle_option;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::combat::combat_actions::CombatActionProperties;
+use common::combat::combat_actions::CombatActionTarget;
+use common::errors::AppError;
+use common::game::getters::get_ally_ids_and_opponent_ids_option;
+use common::game::getters::get_mut_party;
+use common::primatives::NextOrPrevious;
+
+pub fn handle_cycle_combat_action_targets(
+    game_store: &mut GameStore,
+    combat_action_properties: CombatActionProperties,
+    direction: &NextOrPrevious,
+) -> Result<CombatActionTarget, AppError> {
+    let battle_option = get_cloned_current_battle_option(&game_store);
+    let game = game_store.game.as_mut().ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+    })?;
+    let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+    })?;
+    let party = get_mut_party(game, party_id)?;
+    let cloned_character_positions = party.character_positions.clone();
+    let focused_character = party
+        .characters
+        .get(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+    let focused_character_id = focused_character.entity_properties.id;
+    let prohibited_target_combatant_states = combat_action_properties
+        .prohibited_target_combatant_states
+        .clone();
+
+    let current_targets = focused_character
+        .combatant_properties
+        .combat_action_targets
+        .as_ref()
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::TRIED_TO_CYCLE_TARGETS_WHEN_NO_TARGETS.to_string(),
+        })?;
+    let current_targets = current_targets.clone();
+
+    let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
+        &cloned_character_positions,
+        battle_option.as_ref(),
+        focused_character_id,
+    )?;
+
+    let (ally_ids, opponent_ids_option) =
+        filter_possible_target_ids_by_prohibited_combatant_states(
+            game,
+            &prohibited_target_combatant_states,
+            ally_ids,
+            opponent_ids_option,
+        )?;
+
+    let new_targets = combat_action_properties.get_next_or_previous_targets(
+        &current_targets,
+        direction,
+        &focused_character_id,
+        &ally_ids,
+        &opponent_ids_option,
+    )?;
+
+    let party = get_mut_party(game, party_id)?;
+    let focused_character = party
+        .characters
+        .get_mut(&game_store.focused_character_id)
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+        })?;
+    let new_preferences = focused_character
+        .combatant_properties
+        .combat_action_target_preferences
+        .get_updated_preferences(
+            &combat_action_properties,
+            &new_targets,
+            ally_ids,
+            opponent_ids_option,
+        );
+    focused_character
+        .combatant_properties
+        .combat_action_target_preferences = new_preferences;
+
+    Ok(new_targets)
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targeting_schemes.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targeting_schemes.rs
new file mode 100644
index 00000000..6db443f5
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targeting_schemes.rs
@@ -0,0 +1,78 @@
+use super::handle_cycle_combat_action_targeting_schemes::handle_cycle_combat_action_targeting_schemes;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ChangeTargetsPacket;
+use common::packets::client_to_server::PlayerInputs;
+use gloo::console::log;
+use web_sys::WebSocket;
+use yewdux::Dispatch;
+
+pub fn handle_cycle_consumable_targeting_schemes(
+    game_dispatch: Dispatch<GameStore>,
+    websocket_option: &Option<WebSocket>,
+) {
+    let result = move || -> Result<(), AppError> {
+        game_dispatch.reduce_mut(|game_store| {
+            let game = game_store.game.as_mut().ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+            })?;
+            let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+            })?;
+            let party = get_mut_party(game, party_id)?;
+            let focused_character = party
+                .characters
+                .get(&game_store.focused_character_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+                })?;
+            let focused_character_id = focused_character.entity_properties.id;
+            let current_targets = focused_character
+                .combatant_properties
+                .combat_action_targets
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::Generic,
+                    message: error_messages::TRIED_TO_CYCLE_TARGETS_WHEN_NO_TARGETS.to_string(),
+                })
+                .cloned()?;
+            let selected_consumable_id = focused_character
+                .combatant_properties
+                .selected_consumable
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::NO_CONSUMABLE_SELECTED.to_string(),
+                })?;
+
+            let consumable_properties = focused_character
+                .combatant_properties
+                .inventory
+                .get_consumable(&selected_consumable_id)?;
+            let combat_action_properties = consumable_properties
+                .consumable_type
+                .get_combat_action_properties();
+            let new_targets = handle_cycle_combat_action_targeting_schemes(
+                game_store,
+                combat_action_properties,
+                current_targets,
+            )?;
+
+            log!(format!("sending new consumable targets {:#?}", new_targets));
+            send_client_input(
+                &websocket_option,
+                PlayerInputs::ChangeConsumableTargets(ChangeTargetsPacket {
+                    character_id: focused_character_id,
+                    new_targets,
+                }),
+            );
+            Ok(())
+        })
+    };
+    let _ = result();
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targets.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targets.rs
new file mode 100644
index 00000000..1e00b12b
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_consumable_targets.rs
@@ -0,0 +1,74 @@
+use super::handle_cycle_combat_action_targets::handle_cycle_combat_action_targets;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ChangeTargetsPacket;
+use common::packets::client_to_server::PlayerInputs;
+use common::primatives::NextOrPrevious;
+use gloo::console::log;
+use web_sys::WebSocket;
+use yewdux::prelude::Dispatch;
+
+pub fn handle_cycle_consumable_targets(
+    game_dispatch: Dispatch<GameStore>,
+    websocket_option: &Option<WebSocket>,
+    direction: &NextOrPrevious,
+) {
+    game_dispatch.reduce_mut(|game_store| {
+        let mut closure = move || -> Result<(), AppError> {
+            let game = game_store.game.as_mut().ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+            })?;
+            let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+            })?;
+            let party = get_mut_party(game, party_id)?;
+            let focused_character = party
+                .characters
+                .get(&game_store.focused_character_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+                })?;
+            let focused_character_id = focused_character.entity_properties.id;
+            let selected_consumable_id = focused_character
+                .combatant_properties
+                .selected_consumable
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::Generic,
+                    message: error_messages::NO_CONSUMABLE_SELECTED.to_string(),
+                })?;
+            let consumable = focused_character
+                .combatant_properties
+                .inventory
+                .get_consumable(&selected_consumable_id)?;
+            let combat_action_properties =
+                consumable.consumable_type.get_combat_action_properties();
+            let new_targets = handle_cycle_combat_action_targets(
+                game_store,
+                combat_action_properties,
+                direction,
+            )?;
+
+            send_client_input(
+                &websocket_option,
+                PlayerInputs::ChangeConsumableTargets(ChangeTargetsPacket {
+                    character_id: focused_character_id,
+                    new_targets,
+                }),
+            );
+            Ok(())
+        };
+        let result = closure();
+        if result.is_ok() {
+            ()
+        } else {
+            log!("an unhandled client error occured");
+            log!(format!("{:#?}", result.err()))
+        }
+    });
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targeting_schemes.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targeting_schemes.rs
deleted file mode 100644
index 35d44154..00000000
--- a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targeting_schemes.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-use crate::components::websocket_manager::send_client_input::send_client_input;
-use crate::store::game_store::get_cloned_current_battle_option;
-use crate::store::game_store::GameStore;
-use common::app_consts::error_messages;
-use common::errors::AppError;
-use common::game::getters::get_ally_ids_and_opponent_ids_option;
-use common::game::getters::get_mut_party;
-use common::packets::client_to_server::ChangeTargetsPacket;
-use common::packets::client_to_server::PlayerInputs;
-use gloo::console::log;
-use web_sys::WebSocket;
-
-pub fn handle_cycle_targeting_schemes(
-    game_store: &mut GameStore,
-    websocket_option: &Option<WebSocket>,
-) {
-    let mut closure = move || -> Result<(), AppError> {
-        let battle_option = get_cloned_current_battle_option(&game_store);
-        let game = game_store.game.as_mut().ok_or_else(|| AppError {
-            error_type: common::errors::AppErrorTypes::ClientError,
-            message: error_messages::MISSING_GAME_REFERENCE.to_string(),
-        })?;
-        let party_id = game_store.current_party_id.ok_or_else(|| AppError {
-            error_type: common::errors::AppErrorTypes::ClientError,
-            message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
-        })?;
-        let party = get_mut_party(game, party_id)?;
-        let cloned_character_positions = party.character_positions.clone();
-        let focused_character = party
-            .characters
-            .get(&game_store.focused_character_id)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-            })?;
-        let ability_name = focused_character
-            .combatant_properties
-            .selected_ability_name
-            .as_ref()
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
-            })?;
-        // if only one targeting scheme, return early
-        let ability_attributes = ability_name.get_attributes();
-        if ability_attributes.targeting_schemes.len() < 2 {
-            return Ok(());
-        }
-
-        let last_used_targeting_scheme = &focused_character
-            .combatant_properties
-            .ability_target_preferences
-            .targeting_scheme_preference;
-
-        let new_targeting_scheme = if !ability_attributes
-            .targeting_schemes
-            .contains(last_used_targeting_scheme)
-        {
-            ability_attributes
-                .targeting_schemes
-                .first()
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ClientError,
-                    message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
-                })?
-        } else {
-            let last_used_targeting_scheme_index = ability_attributes
-                .targeting_schemes
-                .iter()
-                .position(|scheme| scheme == last_used_targeting_scheme)
-                .expect("checked it contains above");
-            let new_scheme_index = if last_used_targeting_scheme_index
-                == ability_attributes.targeting_schemes.len() - 1
-            {
-                0
-            } else {
-                last_used_targeting_scheme_index + 1
-            };
-            ability_attributes
-                .targeting_schemes
-                .get(new_scheme_index)
-                .expect("a valid index")
-        };
-
-        let focused_character = party
-            .characters
-            .get_mut(&game_store.focused_character_id)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-            })?;
-
-        focused_character
-            .combatant_properties
-            .ability_target_preferences
-            .targeting_scheme_preference = new_targeting_scheme.clone();
-
-        let focused_character = party
-            .characters
-            .get(&game_store.focused_character_id)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-            })?;
-        let ability_name = focused_character
-            .combatant_properties
-            .selected_ability_name
-            .as_ref()
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
-            })?;
-
-        let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
-            &cloned_character_positions,
-            battle_option.as_ref(),
-            focused_character.entity_properties.id,
-        )?;
-
-        let new_targets = ability_name.targets_by_saved_preference_or_default(
-            focused_character.entity_properties.id,
-            &focused_character
-                .combatant_properties
-                .ability_target_preferences,
-            ally_ids.clone(),
-            opponent_ids_option.clone(),
-        )?;
-
-        let new_preferences = focused_character
-            .combatant_properties
-            .ability_target_preferences
-            .get_updated_preferences(ability_name, &new_targets, ally_ids, opponent_ids_option);
-        let focused_character = party
-            .characters
-            .get_mut(&game_store.focused_character_id)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-            })?;
-
-        focused_character
-            .combatant_properties
-            .ability_target_preferences = new_preferences;
-
-        send_client_input(
-            &websocket_option,
-            PlayerInputs::ChangeTargets(ChangeTargetsPacket {
-                character_id: focused_character.entity_properties.id,
-                new_targets,
-            }),
-        );
-        Ok(())
-    };
-    let result = closure();
-    if result.is_ok() {
-        ()
-    } else {
-        log!("an unhandled client error occured");
-    }
-}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targets.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targets.rs
deleted file mode 100644
index 494c6532..00000000
--- a/client/src/components/game/action_menu/action_button_click_handlers/handle_cycle_targets.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use crate::components::websocket_manager::send_client_input::send_client_input;
-use crate::store::game_store::get_cloned_current_battle_option;
-use crate::store::game_store::GameStore;
-use common::app_consts::error_messages;
-use common::combatants::abilities::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
-use common::errors::AppError;
-use common::game::getters::get_ally_ids_and_opponent_ids_option;
-use common::game::getters::get_mut_party;
-use common::packets::client_to_server::ChangeTargetsPacket;
-use common::packets::client_to_server::PlayerInputs;
-use common::primatives::NextOrPrevious;
-use gloo::console::log;
-use web_sys::WebSocket;
-use yewdux::prelude::Dispatch;
-
-pub fn handle_cycle_targets(
-    game_dispatch: Dispatch<GameStore>,
-    websocket_option: &Option<WebSocket>,
-    direction: &NextOrPrevious,
-) {
-    game_dispatch.reduce_mut(|game_store| {
-        let mut closure = move || -> Result<(), AppError> {
-            let battle_option = get_cloned_current_battle_option(&game_store);
-            let game = game_store.game.as_mut().ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::MISSING_GAME_REFERENCE.to_string(),
-            })?;
-            let party_id = game_store.current_party_id.ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
-            })?;
-            let party = get_mut_party(game, party_id)?;
-            let cloned_character_positions = party.character_positions.clone();
-            let focused_character = party
-                .characters
-                .get(&game_store.focused_character_id)
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ClientError,
-                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-                })?;
-            let focused_character_id = focused_character.entity_properties.id;
-            let ability_name = focused_character
-                .combatant_properties
-                .selected_ability_name
-                .as_ref()
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ClientError,
-                    message: error_messages::MISSING_ABILITY_REFERENCE.to_string(),
-                })?;
-            let ability_name = ability_name.clone();
-            let prohibited_target_combatant_states = ability_name
-                .get_attributes()
-                .prohibited_target_combatant_states;
-
-            let current_targets = focused_character
-                .combatant_properties
-                .ability_targets
-                .as_ref()
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ClientError,
-                    message: error_messages::TRIED_TO_CYCLE_TARGETS_WHEN_NO_TARGETS.to_string(),
-                })?;
-            let current_targets = current_targets.clone();
-
-            let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
-                &cloned_character_positions,
-                battle_option.as_ref(),
-                focused_character.entity_properties.id,
-            )?;
-
-            let (ally_ids, opponent_ids_option) =
-                filter_possible_target_ids_by_prohibited_combatant_states(
-                    game,
-                    prohibited_target_combatant_states,
-                    ally_ids,
-                    opponent_ids_option,
-                )?;
-
-            let new_targets = ability_name.clone().get_next_or_previous_targets(
-                &current_targets,
-                direction,
-                &focused_character_id,
-                &ally_ids,
-                &opponent_ids_option,
-            )?;
-
-            let party = get_mut_party(game, party_id)?;
-            let focused_character = party
-                .characters
-                .get_mut(&game_store.focused_character_id)
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ClientError,
-                    message: error_messages::CHARACTER_NOT_FOUND.to_string(),
-                })?;
-            let new_preferences = focused_character
-                .combatant_properties
-                .ability_target_preferences
-                .get_updated_preferences(
-                    &ability_name,
-                    &new_targets,
-                    ally_ids,
-                    opponent_ids_option,
-                );
-            focused_character
-                .combatant_properties
-                .ability_target_preferences = new_preferences;
-
-            send_client_input(
-                &websocket_option,
-                PlayerInputs::ChangeTargets(ChangeTargetsPacket {
-                    character_id: focused_character.entity_properties.id,
-                    new_targets,
-                }),
-            );
-            Ok(())
-        };
-        let result = closure();
-        if result.is_ok() {
-            ()
-        } else {
-            log!("an unhandled client error occured");
-        }
-    });
-}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_deselect_consumable.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_deselect_consumable.rs
new file mode 100644
index 00000000..2dac2606
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_deselect_consumable.rs
@@ -0,0 +1,33 @@
+use crate::components::alerts::set_alert;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::alert_store::AlertStore;
+use crate::store::game_store::GameStore;
+use common::errors::AppError;
+use common::packets::client_to_server::ClientSelectConsumablePacket;
+use common::packets::client_to_server::PlayerInputs;
+use web_sys::WebSocket;
+use yewdux::prelude::Dispatch;
+
+pub fn handle_deselect_consumable(
+    game_dispatch: Dispatch<GameStore>,
+    alert_dispatch: Dispatch<AlertStore>,
+    websocket_option: &Option<WebSocket>,
+) {
+    let result = game_dispatch.reduce_mut(|game_store| -> Result<(), AppError> {
+        let focused_character: _ = game_store.get_mut_character(game_store.focused_character_id)?;
+        focused_character.combatant_properties.selected_consumable = None;
+        focused_character.combatant_properties.combat_action_targets = None;
+        send_client_input(
+            websocket_option,
+            PlayerInputs::SelectConsumable(ClientSelectConsumablePacket {
+                character_id: focused_character.entity_properties.id,
+                consumable_id_option: None,
+            }),
+        );
+        Ok(())
+    });
+
+    if let Some(err) = result.err() {
+        set_alert(alert_dispatch, err.message)
+    }
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs
index 19519889..86f6cca1 100644
--- a/client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_select_ability.rs
@@ -4,7 +4,7 @@ use crate::store::alert_store::AlertStore;
 use crate::store::game_store::get_cloned_current_battle_option;
 use crate::store::game_store::GameStore;
 use common::app_consts::error_messages;
-use common::combatants::abilities::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
 use common::combatants::abilities::CombatantAbilityNames;
 use common::errors::AppError;
 use common::game::getters::get_ally_ids_and_opponent_ids_option;
@@ -42,7 +42,7 @@ pub fn handle_select_ability(
 
         let target_preferences = &focused_character
             .combatant_properties
-            .ability_target_preferences
+            .combat_action_target_preferences
             .clone();
 
         let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
@@ -51,27 +51,32 @@ pub fn handle_select_ability(
             focused_character_id,
         )?;
 
-        let prohibited_target_combatant_states = ability_name
-            .get_attributes()
-            .prohibited_target_combatant_states;
+        let ability_attributes = ability_name.get_attributes();
+
+        let prohibited_target_combatant_states = ability_attributes
+            .combat_action_properties
+            .prohibited_target_combatant_states
+            .clone();
 
         let (ally_ids, opponent_ids_option) =
             filter_possible_target_ids_by_prohibited_combatant_states(
                 game,
-                prohibited_target_combatant_states,
+                &prohibited_target_combatant_states,
                 ally_ids,
                 opponent_ids_option,
             )?;
 
-        let targets = ability_name.targets_by_saved_preference_or_default(
-            focused_character_id,
-            &target_preferences,
-            ally_ids.clone(),
-            opponent_ids_option.clone(),
-        )?;
+        let targets = ability_attributes
+            .combat_action_properties
+            .targets_by_saved_preference_or_default(
+                focused_character_id,
+                &target_preferences,
+                ally_ids.clone(),
+                opponent_ids_option.clone(),
+            )?;
 
         let new_target_preferences = target_preferences.get_updated_preferences(
-            &ability_name,
+            &ability_attributes.combat_action_properties,
             &targets,
             ally_ids,
             opponent_ids_option,
@@ -87,10 +92,10 @@ pub fn handle_select_ability(
                 message: error_messages::CHARACTER_NOT_FOUND.to_string(),
             })?;
         focused_character.combatant_properties.selected_ability_name = Some(ability_name.clone());
-        focused_character.combatant_properties.ability_targets = Some(targets.clone());
+        focused_character.combatant_properties.combat_action_targets = Some(targets.clone());
         focused_character
             .combatant_properties
-            .ability_target_preferences = new_target_preferences;
+            .combat_action_target_preferences = new_target_preferences;
 
         send_client_input(
             websocket_option,
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/handle_select_consumable.rs b/client/src/components/game/action_menu/action_button_click_handlers/handle_select_consumable.rs
new file mode 100644
index 00000000..c24f6228
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/handle_select_consumable.rs
@@ -0,0 +1,114 @@
+use crate::components::alerts::set_alert;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::alert_store::AlertStore;
+use crate::store::game_store::get_cloned_current_battle_option;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::errors::AppError;
+use common::game::getters::get_ally_ids_and_opponent_ids_option;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ClientSelectConsumablePacket;
+use common::packets::client_to_server::PlayerInputs;
+use web_sys::WebSocket;
+use yewdux::prelude::Dispatch;
+
+pub fn handle_select_consumable(
+    game_dispatch: Dispatch<GameStore>,
+    alert_dispatch: Dispatch<AlertStore>,
+    websocket_option: &Option<WebSocket>,
+    item_id: &u32,
+) {
+    let result = game_dispatch.reduce_mut(|game_store| -> Result<(), AppError> {
+        let battle_option = get_cloned_current_battle_option(&game_store);
+        let game = game_store.game.as_mut().ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+        })?;
+        let party_id = game_store.current_party_id.ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ClientError,
+            message: error_messages::MISSING_PARTY_REFERENCE.to_string(),
+        })?;
+        let party = get_mut_party(game, party_id)?;
+        let focused_character = party
+            .characters
+            .get(&game_store.focused_character_id)
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+            })?;
+        let focused_character_id = focused_character.entity_properties.id;
+
+        let target_preferences = &focused_character
+            .combatant_properties
+            .combat_action_target_preferences
+            .clone();
+
+        let (ally_ids, opponent_ids_option) = get_ally_ids_and_opponent_ids_option(
+            &party.character_positions,
+            battle_option.as_ref(),
+            focused_character_id,
+        )?;
+
+        let consumable_properties = focused_character.combatant_properties.inventory.get_consumable(&item_id)?;
+        let combat_action_properties = consumable_properties
+            .consumable_type
+            .get_combat_action_properties();
+
+        let prohibited_target_combatant_states = combat_action_properties
+            .prohibited_target_combatant_states
+            .clone();
+
+        let (ally_ids, opponent_ids_option) =
+            filter_possible_target_ids_by_prohibited_combatant_states(
+                game,
+                &prohibited_target_combatant_states,
+                ally_ids,
+                opponent_ids_option,
+            )?;
+
+        let targets = combat_action_properties.targets_by_saved_preference_or_default(
+            focused_character_id,
+            &target_preferences,
+            ally_ids.clone(),
+            opponent_ids_option.clone(),
+        )?;
+
+        let new_target_preferences = target_preferences.get_updated_preferences(
+            &combat_action_properties,
+            &targets,
+            ally_ids,
+            opponent_ids_option,
+        );
+
+        let party = get_mut_party(game, party_id)?;
+
+        let focused_character = party
+            .characters
+            .get_mut(&game_store.focused_character_id)
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::CHARACTER_NOT_FOUND.to_string(),
+            })?;
+
+        focused_character.combatant_properties.selected_consumable = Some(item_id.clone());
+        focused_character.combatant_properties.combat_action_targets = Some(targets.clone());
+        focused_character
+            .combatant_properties
+            .combat_action_target_preferences = new_target_preferences;
+
+        send_client_input(
+            websocket_option,
+            PlayerInputs::SelectConsumable(ClientSelectConsumablePacket {
+                character_id: focused_character.entity_properties.id,
+                consumable_id_option: Some(*item_id),
+            }),
+        );
+
+        Ok(())
+    });
+
+    if let Some(err) = result.err() {
+        set_alert(alert_dispatch, err.message)
+    }
+}
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/mod.rs b/client/src/components/game/action_menu/action_button_click_handlers/mod.rs
index 6c07e526..15b38400 100644
--- a/client/src/components/game/action_menu/action_button_click_handlers/mod.rs
+++ b/client/src/components/game/action_menu/action_button_click_handlers/mod.rs
@@ -1,6 +1,17 @@
-pub mod handle_cycle_targeting_schemes;
-pub mod handle_cycle_targets;
+pub mod handle_cycle_ability_targeting_schemes;
+pub mod handle_cycle_ability_targets;
+pub mod handle_cycle_combat_action_targeting_schemes;
+pub mod handle_cycle_combat_action_targets;
+pub mod handle_cycle_consumable_targeting_schemes;
+mod handle_cycle_consumable_targets;
+pub mod handle_deselect_consumable;
 pub mod handle_select_ability;
+pub mod handle_select_consumable;
+mod use_item_handler;
+use self::handle_cycle_ability_targeting_schemes::handle_cycle_ability_targeting_schemes;
+use self::handle_cycle_ability_targets::handle_cycle_ability_targets;
+use self::handle_cycle_consumable_targeting_schemes::handle_cycle_consumable_targeting_schemes;
+use self::handle_cycle_consumable_targets::handle_cycle_consumable_targets;
 use super::enums::GameActions;
 use crate::components::websocket_manager::send_client_input::send_client_input;
 use crate::store::alert_store::AlertStore;
@@ -11,11 +22,12 @@ use crate::store::game_store::GameStore;
 use crate::store::ui_store::UIStore;
 use crate::store::websocket_store::WebsocketStore;
 use common::packets::client_to_server::ClientSelectAbilityPacket;
-use common::packets::client_to_server::EquipItemRequest;
 use common::packets::client_to_server::PlayerInputs;
 use common::packets::CharacterAndItem;
 use common::packets::CharacterAndSlot;
+use gloo::console::log;
 use std::rc::Rc;
+use use_item_handler::use_item_handler;
 use yewdux::prelude::Dispatch;
 
 pub fn create_action_button_click_handler<'a>(
@@ -33,9 +45,6 @@ pub fn create_action_button_click_handler<'a>(
                 PlayerInputs::ToggleReadyToExplore,
             )
         }),
-        GameActions::UseAutoinjector => Box::new(move || {
-            //
-        }),
         GameActions::SetInventoryOpen(status) => Box::new(move || {
             game_dispatch.reduce_mut(|game_state| game_state.viewing_inventory = status.clone());
         }),
@@ -56,7 +65,13 @@ pub fn create_action_button_click_handler<'a>(
                 let parent_page_number = store.parent_menu_pages.pop();
                 if let Some(page_number) = parent_page_number {
                     store.action_menu_current_page_number = page_number;
-                }
+                } else {
+                    store.action_menu_current_page_number = 0
+                };
+                log!(format!(
+                    "setting page number to :{} after deselecting item",
+                    store.action_menu_current_page_number
+                ));
                 store.detailed_entity = None;
             });
         }),
@@ -66,36 +81,30 @@ pub fn create_action_button_click_handler<'a>(
             let cloned_dispatch = game_dispatch.clone();
             select_item(cloned_dispatch, Some(item));
         }),
-        GameActions::UseItem(_id) => Box::new(move || {
-            let item_option = &game_state.selected_item;
-            let character_id = game_state.focused_character_id;
-            let alt_slot = ui_state.mod_key_held;
-            if let Some(item) = item_option {
-                game_dispatch.reduce_mut(|game_store| {
-                    let focused_character =
-                        get_focused_character(game_store).expect("to be in game");
-                    let slot_item_is_equipped =
-                        focused_character.slot_item_is_equipped(&item.entity_properties.id);
-                    if let Some(slot) = slot_item_is_equipped {
-                        send_client_input(
-                            &websocket_state.websocket,
-                            PlayerInputs::UnequipEquipmentSlot(CharacterAndSlot {
-                                character_id,
-                                slot,
-                            }),
-                        )
-                    } else {
-                        send_client_input(
-                            &websocket_state.websocket,
-                            PlayerInputs::EquipInventoryItem(EquipItemRequest {
-                                character_id,
-                                item_id: item.entity_properties.id,
-                                alt_slot,
-                            }),
-                        )
-                    }
-                });
-            }
+        GameActions::UseItem(id) => Box::new(move || {
+            let cloned_game_state = game_state.clone();
+            let cloned_game_dispatch = game_dispatch.clone();
+            let cloned_ui_state = ui_state.clone();
+            let cloned_websocket_state = websocket_state.clone();
+            let cloned_alert_dispatch = alert_dispatch.clone();
+            use_item_handler(
+                cloned_game_dispatch,
+                cloned_game_state,
+                cloned_ui_state,
+                cloned_websocket_state,
+                cloned_alert_dispatch,
+                &id,
+            )
+        }),
+        GameActions::DeselectConsumable => Box::new(move || {
+            let cloned_game_dispatch = game_dispatch.clone();
+            let cloned_websocket_state = websocket_state.clone();
+            let cloned_alert_dispatch = alert_dispatch.clone();
+            handle_deselect_consumable::handle_deselect_consumable(
+                cloned_game_dispatch,
+                cloned_alert_dispatch,
+                &cloned_websocket_state.websocket,
+            );
         }),
         GameActions::SelectAbility(ability_name) => Box::new(move || {
             let cloned_dispatch = game_dispatch.clone();
@@ -113,7 +122,7 @@ pub fn create_action_button_click_handler<'a>(
                     .get_mut_character(game_store.focused_character_id)
                     .expect("to have a valid focused character");
                 focused_character.combatant_properties.selected_ability_name = None;
-                focused_character.combatant_properties.ability_targets = None;
+                focused_character.combatant_properties.combat_action_targets = None;
                 send_client_input(
                     &websocket_state.websocket,
                     PlayerInputs::SelectAbility(ClientSelectAbilityPacket {
@@ -123,40 +132,59 @@ pub fn create_action_button_click_handler<'a>(
                 )
             });
         }),
-        GameActions::CycleTargets(next_or_previous) => Box::new(move || {
+        GameActions::CycleAbilityTargets(next_or_previous) => Box::new(move || {
             let cloned_dispatch = game_dispatch.clone();
-            handle_cycle_targets::handle_cycle_targets(
+            handle_cycle_ability_targets(
                 cloned_dispatch,
                 &websocket_state.websocket,
                 &next_or_previous,
             )
         }),
-        GameActions::CycleTargetingScheme => Box::new(move || {
-            game_dispatch.reduce_mut(|store| {
-                handle_cycle_targeting_schemes::handle_cycle_targeting_schemes(
-                    store,
-                    &websocket_state.websocket,
-                )
-            })
+        GameActions::CycleConsumableTargets(next_or_previous) => Box::new(move || {
+            let cloned_dispatch = game_dispatch.clone();
+            handle_cycle_consumable_targets(
+                cloned_dispatch,
+                &websocket_state.websocket,
+                &next_or_previous,
+            )
+        }),
+        GameActions::CycleAbilityTargetingScheme => Box::new(move || {
+            let cloned_dispatch = game_dispatch.clone();
+            handle_cycle_ability_targeting_schemes(cloned_dispatch, &websocket_state.websocket)
+        }),
+        GameActions::CycleConsumableTargetingScheme => Box::new(move || {
+            let cloned_dispatch = game_dispatch.clone();
+            handle_cycle_consumable_targeting_schemes(cloned_dispatch, &websocket_state.websocket)
         }),
         GameActions::UseSelectedAbility => Box::new(move || {
+            send_client_input(
+                &websocket_state.websocket,
+                PlayerInputs::UseSelectedAbility(game_state.focused_character_id),
+            );
+        }),
+        GameActions::UseSelectedConsumable => Box::new(move || {
             game_dispatch.reduce_mut(|store| {
-                let focused_character_id = store.focused_character_id;
-                let focused_character = store
-                    .get_mut_character(focused_character_id)
-                    .expect("to have a valid focused character");
-                focused_character.combatant_properties.selected_ability_name = None;
-                focused_character.combatant_properties.ability_targets = None;
+                store.selected_item = None;
+                store.detailed_entity = None;
+                let parent_page_number = store.parent_menu_pages.pop();
+                log!(format!("parent page number: {:?}", parent_page_number));
+                if let Some(page_number) = parent_page_number {
+                    store.action_menu_current_page_number = page_number;
+                } else {
+                    store.action_menu_current_page_number = 0
+                };
                 send_client_input(
                     &websocket_state.websocket,
-                    PlayerInputs::UseSelectedAbility(game_state.focused_character_id),
+                    PlayerInputs::UseSelectedConsumable(game_state.focused_character_id),
                 );
-            });
+            })
         }),
         GameActions::DropItem(item_id) => Box::new(move || {
             game_dispatch.reduce_mut(|store| {
                 let focused_character = get_focused_character(store).expect("to be in game");
-                let slot_item_is_equipped = focused_character.slot_item_is_equipped(&item_id);
+                let slot_item_is_equipped = focused_character
+                    .combatant_properties
+                    .slot_item_is_equipped(&item_id);
                 if let Some(slot) = slot_item_is_equipped {
                     send_client_input(
                         &websocket_state.websocket,
@@ -180,6 +208,12 @@ pub fn create_action_button_click_handler<'a>(
                 }
                 store.selected_item = None;
                 store.detailed_entity = None;
+                let parent_page_number = store.parent_menu_pages.pop();
+                if let Some(page_number) = parent_page_number {
+                    store.action_menu_current_page_number = page_number;
+                } else {
+                    store.action_menu_current_page_number = 0
+                };
             });
         }),
         GameActions::ToggleReadyToDescend => Box::new(move || {
diff --git a/client/src/components/game/action_menu/action_button_click_handlers/use_item_handler.rs b/client/src/components/game/action_menu/action_button_click_handlers/use_item_handler.rs
new file mode 100644
index 00000000..d7b5c9ec
--- /dev/null
+++ b/client/src/components/game/action_menu/action_button_click_handlers/use_item_handler.rs
@@ -0,0 +1,69 @@
+use super::handle_select_consumable::handle_select_consumable;
+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::GameStore;
+use crate::store::ui_store::UIStore;
+use crate::store::websocket_store::WebsocketStore;
+use common::items::Item;
+use common::packets::client_to_server::EquipItemRequest;
+use common::packets::client_to_server::PlayerInputs;
+use common::packets::CharacterAndSlot;
+use std::rc::Rc;
+use yewdux::Dispatch;
+
+pub fn use_item_handler(
+    game_dispatch: Dispatch<GameStore>,
+    game_state: Rc<GameStore>,
+    ui_state: Rc<UIStore>,
+    websocket_state: Rc<WebsocketStore>,
+    alert_dispatch: Dispatch<AlertStore>,
+    item_id: &u32,
+) {
+    let item_option = &game_state.selected_item;
+    let character_id = game_state.focused_character_id;
+    let alt_slot = ui_state.mod_key_held;
+    if let Some(item) = item_option {
+        match item.item_properties {
+            common::items::ItemProperties::Consumable(_) => handle_select_consumable(
+                game_dispatch,
+                alert_dispatch,
+                &websocket_state.websocket,
+                item_id,
+            ),
+            common::items::ItemProperties::Equipment(_) => {
+                use_equipment_handler(game_dispatch, websocket_state, character_id, item, alt_slot)
+            }
+        }
+    }
+}
+
+fn use_equipment_handler(
+    game_dispatch: Dispatch<GameStore>,
+    websocket_state: Rc<WebsocketStore>,
+    character_id: u32,
+    item: &Item,
+    alt_slot: bool,
+) {
+    game_dispatch.reduce_mut(|game_store| {
+        let focused_character = get_focused_character(game_store).expect("to be in game");
+        let slot_item_is_equipped = focused_character
+            .combatant_properties
+            .slot_item_is_equipped(&item.entity_properties.id);
+        if let Some(slot) = slot_item_is_equipped {
+            send_client_input(
+                &websocket_state.websocket,
+                PlayerInputs::UnequipEquipmentSlot(CharacterAndSlot { character_id, slot }),
+            )
+        } else {
+            send_client_input(
+                &websocket_state.websocket,
+                PlayerInputs::EquipInventoryItem(EquipItemRequest {
+                    character_id,
+                    item_id: item.entity_properties.id,
+                    alt_slot,
+                }),
+            )
+        }
+    });
+}
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
index 9a2feb24..0f352c5f 100644
--- 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
@@ -1,4 +1,5 @@
 use super::enums::GameActions;
+use crate::store::game_store::get_item_on_ground;
 use crate::store::game_store::get_item_owned_by_focused_character;
 use crate::store::game_store::DetailableEntities;
 use crate::store::game_store::GameStore;
@@ -12,10 +13,19 @@ pub fn create_action_mouse_enter_handler(
 ) -> 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)));
+            let item_result = get_item_owned_by_focused_character(&id, game_state.clone());
+            if let Ok(item) = item_result {
+                game_dispatch.reduce_mut(|store| {
+                    store.hovered_entity = Some(DetailableEntities::Item(item))
+                });
+            } else {
+                let item_on_ground_result = get_item_on_ground(&id, game_state.clone());
+                if let Ok(item) = item_on_ground_result {
+                    game_dispatch.reduce_mut(|store| {
+                        store.hovered_entity = Some(DetailableEntities::Item(item))
+                    });
+                }
+            }
         }),
         _ => Box::new(|| ()),
     }
@@ -24,7 +34,6 @@ pub fn create_action_mouse_enter_handler(
 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 || {
diff --git a/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs b/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
index d4139050..17cdeaf6 100644
--- a/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
+++ b/client/src/components/game/action_menu/action_menu_button/determine_action_button_text.rs
@@ -35,7 +35,6 @@ pub fn determine_action_button_text(action: GameActions, game_state: Rc<GameStor
                 "View Equipment".to_string()
             }
         }
-        GameActions::UseAutoinjector => "Use autoinjector".to_string(),
         GameActions::SelectItem(id) => determine_select_item_text(&id, game_state),
         GameActions::OpenTreasureChest => "Open treasure chest".to_string(),
         GameActions::TakeItem => "Pick up item".to_string(),
@@ -49,13 +48,18 @@ pub fn determine_action_button_text(action: GameActions, game_state: Rc<GameStor
             "Assign attributes".to_string()
         }
         GameActions::AssignAttributePoint(_attribute) => "Increase attribute".to_string(),
-        GameActions::CycleTargets(direction) => match direction {
+        GameActions::CycleAbilityTargets(direction)
+        | GameActions::CycleConsumableTargets(direction) => match direction {
             common::primatives::NextOrPrevious::Next => "Next target".to_string(),
             common::primatives::NextOrPrevious::Previous => "Prev target".to_string(),
         },
-        GameActions::CycleTargetingScheme => "Targeting scheme".to_string(),
-        GameActions::DeselectAbility => "Cancel".to_string(),
-        GameActions::UseSelectedAbility => "Execute".to_string(),
+        GameActions::CycleAbilityTargetingScheme | GameActions::CycleConsumableTargetingScheme => {
+            "Targeting scheme".to_string()
+        }
+        GameActions::DeselectAbility | GameActions::DeselectConsumable => "Cancel".to_string(),
+        GameActions::UseSelectedAbility | GameActions::UseSelectedConsumable => {
+            "Execute".to_string()
+        }
         GameActions::ToggleReadyToDescend => "Vote to descend".to_string(),
     }
 }
@@ -77,7 +81,7 @@ fn determine_use_item_text<'a>(id: &u32, game_state: Rc<GameStore>) -> &'a str {
         }
     }
 
-    for item in &character.inventory.items {
+    for item in &character.combatant_properties.inventory.items {
         if item.entity_properties.id == *id {
             match item.item_properties {
                 common::items::ItemProperties::Consumable(_) => return "Use",
@@ -105,7 +109,7 @@ fn determine_select_item_text(id: &u32, game_state: Rc<GameStore>) -> String {
         }
     }
 
-    for item in &character.inventory.items {
+    for item in &character.combatant_properties.inventory.items {
         if item.entity_properties.id == *id {
             return item.entity_properties.name.clone();
         }
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
index e5fd4aa6..5c836cab 100644
--- 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
@@ -22,6 +22,7 @@ pub fn action_menu_change_detection_manager(props: &Props) -> Html {
     let (websocket_state, _) = use_store::<WebsocketStore>();
     let (_, alert_dspatch) = use_store::<AlertStore>();
     let cloned_game_state = game_state.clone();
+    let previously_focused_character_id_state = use_state(|| game_state.focused_character_id);
 
     let active_combatant_result = get_active_combatant(&game_state);
     let active_combatant_id_option = match active_combatant_result {
@@ -53,13 +54,15 @@ pub fn action_menu_change_detection_manager(props: &Props) -> Html {
     };
 
     let num_items_in_focused_character_inventory = match focused_character_option {
-        Some(focused_character) => Some(focused_character.inventory.items.len()),
+        Some(focused_character) => {
+            Some(focused_character.combatant_properties.inventory.items.len())
+        }
         None => None,
     };
     let ability_targets = match focused_character_option {
         Some(focused_character) => focused_character
             .combatant_properties
-            .ability_targets
+            .combat_action_targets
             .clone(),
 
         None => None,
@@ -93,10 +96,11 @@ pub fn action_menu_change_detection_manager(props: &Props) -> Html {
     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();
+    let focused_character_id = game_state.focused_character_id;
     use_effect_with(
         (
             active_combatant_id_option,
-            cloned_game_state.focused_character_id,
+            focused_character_id,
             cloned_game_state.viewing_inventory,
             cloned_game_state.viewing_equipped_items,
             ability_targets,
@@ -116,6 +120,10 @@ pub fn action_menu_change_detection_manager(props: &Props) -> Html {
             focused_character_equipment_ids,
         ),
         move |_| {
+            if *previously_focused_character_id_state != focused_character_id {
+                cloned_game_dispatch.reduce_mut(|store| store.action_menu_current_page_number = 0);
+            }
+            previously_focused_character_id_state.set(focused_character_id);
             let re_cloned_game_state = cloned_game_state.clone();
             let party = re_cloned_game_state
                 .get_current_party()
diff --git a/client/src/components/game/action_menu/action_menu_page_buttons/mod.rs b/client/src/components/game/action_menu/action_menu_page_buttons/mod.rs
new file mode 100644
index 00000000..14095b95
--- /dev/null
+++ b/client/src/components/game/action_menu/action_menu_page_buttons/mod.rs
@@ -0,0 +1,79 @@
+pub mod page_turning;
+use crate::components::game::action_menu::action_menu_page_buttons::page_turning::next_page;
+use crate::components::game::action_menu::action_menu_page_buttons::page_turning::prev_page;
+use crate::store::game_store::GameStore;
+use gloo::events::EventListener;
+use gloo_utils::window;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::UnwrapThrowExt;
+use yew::prelude::*;
+use yewdux::prelude::use_store;
+
+#[derive(Properties, PartialEq)]
+pub struct Props {
+    pub number_of_pages: usize,
+}
+
+#[function_component(ActionPageButtons)]
+pub fn action_page_buttons(props: &Props) -> Html {
+    let (game_state, game_dispatch) = use_store::<GameStore>();
+    let cloned_game_dispatch = game_dispatch.clone();
+
+    let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
+    let cloned_number_of_pages = props.number_of_pages.clone();
+    let next_page_callback = Callback::from(move |_| {
+        next_page(
+            cloned_game_dispatch.clone(),
+            cloned_current_page_number,
+            cloned_number_of_pages,
+        )
+    });
+    let cloned_game_dispatch = game_dispatch.clone();
+    let prev_page_callback = Callback::from(move |_| {
+        prev_page(
+            cloned_game_dispatch.clone(),
+            cloned_current_page_number,
+            cloned_number_of_pages,
+        )
+    });
+
+    let keyup_listener_state = use_state(|| None::<EventListener>);
+    use_effect_with(game_state.action_menu_current_page_number, move |_| {
+        let listener = EventListener::new(&window(), "keypress", move |event| {
+            let event = event.dyn_ref::<web_sys::KeyboardEvent>().unwrap_throw();
+            if event.code() == "KeyW" {
+                prev_page(
+                    game_dispatch.clone(),
+                    cloned_current_page_number,
+                    cloned_number_of_pages,
+                )
+            }
+            if event.code() == "KeyE" {
+                next_page(
+                    game_dispatch.clone(),
+                    cloned_current_page_number,
+                    cloned_number_of_pages,
+                )
+            }
+        });
+        keyup_listener_state.set(Some(listener));
+    });
+
+    html!(
+        <div class="h-10 min-h-[2.5rem] border-t border-slate-400 flex">
+            <button
+                onclick={prev_page_callback}
+                class="h-full w-[40%] flex items-center justify-center">
+                    {"Prev"}
+            </button >
+            <div class="h-full w-[20%] border-r border-l border-slate-400 flex items-center justify-center">
+                {(cloned_current_page_number + 1).to_string()}{"/"}{cloned_number_of_pages.to_string()}
+            </div>
+            <button
+                onclick={next_page_callback}
+                class="h-full w-[40%]">
+                    {"Next"}
+            </button>
+        </div>
+    )
+}
diff --git a/client/src/components/game/action_menu/action_menu_page_buttons/page_turning.rs b/client/src/components/game/action_menu/action_menu_page_buttons/page_turning.rs
new file mode 100644
index 00000000..232abc54
--- /dev/null
+++ b/client/src/components/game/action_menu/action_menu_page_buttons/page_turning.rs
@@ -0,0 +1,30 @@
+use crate::store::game_store::GameStore;
+use yewdux::Dispatch;
+
+pub fn next_page(
+    game_dispatch: Dispatch<GameStore>,
+    current_page_number: u8,
+    number_of_pages: usize,
+) {
+    if current_page_number as usize >= number_of_pages - 1 {
+        game_dispatch.reduce_mut(|store| store.action_menu_current_page_number = 0)
+    } else {
+        game_dispatch
+            .reduce_mut(|store| store.action_menu_current_page_number = current_page_number + 1)
+    }
+}
+
+pub fn prev_page(
+    game_dispatch: Dispatch<GameStore>,
+    current_page_number: u8,
+    number_of_pages: usize,
+) {
+    if current_page_number as usize == 0 {
+        let new_page_number = number_of_pages - 1;
+        game_dispatch
+            .reduce_mut(|store| store.action_menu_current_page_number = new_page_number as u8)
+    } else {
+        game_dispatch
+            .reduce_mut(|store| store.action_menu_current_page_number = current_page_number - 1)
+    }
+}
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
index adff2ac0..a54f75c5 100644
--- 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
@@ -1,7 +1,4 @@
 use yew::prelude::*;
-use yewdux::use_store;
-
-use crate::store::game_store::GameStore;
 
 #[derive(Properties, Eq, PartialEq)]
 pub struct Props {}
diff --git a/client/src/components/game/action_menu/action_page_buttons.rs b/client/src/components/game/action_menu/action_page_buttons.rs
deleted file mode 100644
index 93ea5ef0..00000000
--- a/client/src/components/game/action_menu/action_page_buttons.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use crate::store::game_store::GameStore;
-use gloo::events::EventListener;
-use gloo_utils::window;
-use wasm_bindgen::JsCast;
-use wasm_bindgen::UnwrapThrowExt;
-use yew::prelude::*;
-use yewdux::prelude::use_store;
-
-#[derive(Properties, PartialEq)]
-pub struct Props {
-    pub number_of_pages: usize,
-}
-
-#[function_component(ActionPageButtons)]
-pub fn action_page_buttons(props: &Props) -> Html {
-    let (game_state, game_dispatch) = use_store::<GameStore>();
-
-    let cloned_game_dispatch = game_dispatch.clone();
-    let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
-    let cloned_number_of_pages = props.number_of_pages.clone();
-    let next_page = move || {
-        if cloned_current_page_number as usize == cloned_number_of_pages - 1 {
-            cloned_game_dispatch.reduce_mut(|store| store.action_menu_current_page_number = 0)
-        } else {
-            cloned_game_dispatch.reduce_mut(|store| {
-                store.action_menu_current_page_number = cloned_current_page_number + 1
-            })
-        }
-    };
-
-    let cloned_game_dispatch = game_dispatch.clone();
-    let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
-    let cloned_number_of_pages = props.number_of_pages.clone();
-    let prev_page = move || {
-        if cloned_current_page_number as usize == 0 {
-            let new_page_number = cloned_number_of_pages - 1;
-            cloned_game_dispatch
-                .reduce_mut(|store| store.action_menu_current_page_number = new_page_number as u8)
-        } else {
-            cloned_game_dispatch.reduce_mut(|store| {
-                store.action_menu_current_page_number = cloned_current_page_number - 1
-            })
-        }
-    };
-
-    let cloned_prev_page = prev_page.clone();
-    let cloned_next_page = next_page.clone();
-    let next_page_callback = Callback::from(move |_| cloned_next_page());
-    let prev_page_callback = Callback::from(move |_| cloned_prev_page());
-
-    let keyup_listener_state = use_state(|| None::<EventListener>);
-    let cloned_prev_page = prev_page.clone();
-    let cloned_next_page = next_page.clone();
-    use_effect_with(game_state.action_menu_current_page_number, move |_| {
-        let listener = EventListener::new(&window(), "keypress", move |event| {
-            let event = event.dyn_ref::<web_sys::KeyboardEvent>().unwrap_throw();
-            if event.code() == "KeyW" {
-                cloned_prev_page();
-            }
-            if event.code() == "KeyR" {
-                cloned_next_page();
-            }
-        });
-        keyup_listener_state.set(Some(listener));
-    });
-
-    html!(
-        <div class="h-10 border-t border-slate-400 flex">
-            <button
-                onclick={prev_page_callback}
-                class="h-full w-1/2 flex items-center justify-center">
-                    {"Prev"}
-            </button >
-            <div class="h-full w-[1px] bg-slate-400"/>
-            <button
-                onclick={next_page_callback}
-                class="h-full w-1/2">
-                    {"Next"}
-            </button>
-        </div>
-    )
-}
diff --git a/client/src/components/game/action_menu/build_action_button_properties.rs b/client/src/components/game/action_menu/build_action_button_properties.rs
index a017b56f..aa673471 100644
--- a/client/src/components/game/action_menu/build_action_button_properties.rs
+++ b/client/src/components/game/action_menu/build_action_button_properties.rs
@@ -67,14 +67,9 @@ pub fn build_action_button_properties(
             )()
         });
         let cloned_action = action.clone();
-        let cloned_game_state = game_state.clone();
         let cloned_game_dispatch = game_dispatch.clone();
         let mouse_leave_handler = Callback::from(move |_| {
-            create_action_mouse_leave_handler(
-                cloned_action.clone(),
-                cloned_game_dispatch.clone(),
-                cloned_game_state.clone(),
-            )()
+            create_action_mouse_leave_handler(cloned_action.clone(), cloned_game_dispatch.clone())()
         });
         let cloned_action = action.clone();
         let cloned_game_state = game_state.clone();
@@ -87,14 +82,9 @@ pub fn build_action_button_properties(
             )()
         });
         let cloned_action = action.clone();
-        let cloned_game_state = game_state.clone();
         let cloned_game_dispatch = game_dispatch.clone();
         let blur_handler = Callback::from(move |_| {
-            create_action_mouse_leave_handler(
-                cloned_action.clone(),
-                cloned_game_dispatch.clone(),
-                cloned_game_state.clone(),
-            )()
+            create_action_mouse_leave_handler(cloned_action.clone(), cloned_game_dispatch.clone())()
         });
         let cloned_game_state = game_state.clone();
         let text = determine_action_button_text(action.clone(), cloned_game_state);
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 fd1032f9..866e267b 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
@@ -49,6 +49,7 @@ pub fn determine_action_menu_buttons_disabled(
                 .expect("button should only be shown when item is selected");
             if !focused_character.combatant_properties.can_use_item(&item)
                 && focused_character
+                    .combatant_properties
                     .slot_item_is_equipped(&item.entity_properties.id)
                     .is_none()
             {
@@ -56,7 +57,7 @@ pub fn determine_action_menu_buttons_disabled(
             }
             false
         }
-        GameActions::TakeItem => {
+        GameActions::TakeItem | GameActions::DropItem(_) => {
             if !player_owns_character {
                 return true;
             }
@@ -76,12 +77,6 @@ pub fn determine_action_menu_buttons_disabled(
             }
             false
         }
-        GameActions::UseAutoinjector => {
-            if !player_owns_character {
-                return true;
-            }
-            false
-        }
         GameActions::ShardItem(_) => !player_owns_character,
 
         _ => false,
diff --git a/client/src/components/game/action_menu/determine_menu_actions.rs b/client/src/components/game/action_menu/determine_menu_actions.rs
index 0ecd6687..37d80d68 100644
--- a/client/src/components/game/action_menu/determine_menu_actions.rs
+++ b/client/src/components/game/action_menu/determine_menu_actions.rs
@@ -3,10 +3,9 @@ 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::combat::combat_actions::AbilityUsableContext;
 use common::combatants::abilities::CombatantAbilityNames;
 use common::dungeon_rooms::DungeonRoomTypes;
-use gloo::console::log;
 use std::rc::Rc;
 
 // determine menu actions
@@ -21,18 +20,21 @@ pub fn determine_menu_actions(
     let focused_character_option = party.characters.get(&game_state.focused_character_id);
     let player_owns_character =
         party.player_owns_character(&lobby_state.username, game_state.focused_character_id);
-    let focused_character_is_selecting_ability = {
-        if let Some(character) = focused_character_option {
+    let focused_character_is_selecting_ability = focused_character_option
+        .map(|character| {
             character
                 .combatant_properties
                 .selected_ability_name
                 .is_some()
-        } else {
-            false
-        }
-    };
-
-    if game_state.viewing_items_on_ground {
+        })
+        .unwrap_or(false);
+    let focused_character_is_selecting_consumable = focused_character_option
+        .map(|character| character.combatant_properties.selected_consumable.is_some())
+        .unwrap_or(false);
+    if focused_character_is_selecting_consumable && player_owns_character {
+        menu_types.push(MenuTypes::ConsumableSelected);
+        new_actions = MenuTypes::get_actions(&menu_types, None, None);
+    } else if game_state.viewing_items_on_ground {
         menu_types.push(MenuTypes::ItemsOnGround);
         new_actions = MenuTypes::get_actions(&menu_types, None, None);
         //
@@ -55,7 +57,7 @@ pub fn determine_menu_actions(
         menu_types.push(MenuTypes::InventoryOpen);
         if let Some(character) = focused_character_option {
             let mut ids = Vec::new();
-            for item in &character.inventory.items {
+            for item in &character.combatant_properties.inventory.items {
                 ids.push(item.entity_properties.id);
             }
             new_actions = MenuTypes::get_actions(&menu_types, Some(ids), None);
@@ -84,13 +86,7 @@ pub fn determine_menu_actions(
         if party.current_room.items.len() > 0 {
             menu_types.push(MenuTypes::ItemsOnGround);
         }
-        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));
@@ -120,7 +116,13 @@ fn get_ability_menu_names(
     if let Some(character) = focused_character {
         for (ability_name, ability) in &character.combatant_properties.abilities {
             if let Some(excluded_context) = &excluded_usable_context {
-                if &ability.ability_name.get_attributes().usability_context != excluded_context {
+                if &ability
+                    .ability_name
+                    .get_attributes()
+                    .combat_action_properties
+                    .usability_context
+                    != excluded_context
+                {
                     ability_names.push(ability_name.clone());
                 }
             }
diff --git a/client/src/components/game/action_menu/enums.rs b/client/src/components/game/action_menu/enums.rs
index 130efb0b..cdb7d937 100644
--- a/client/src/components/game/action_menu/enums.rs
+++ b/client/src/components/game/action_menu/enums.rs
@@ -6,6 +6,7 @@ use common::primatives::NextOrPrevious;
 pub enum MenuTypes {
     InCombat,
     AbilitySelected,
+    ConsumableSelected,
     OutOfCombat,
     LevelUpAbilities,
     AttributePointAssignment,
@@ -24,7 +25,6 @@ pub enum GameActions {
     SetInventoryOpen(bool),
     ToggleInventoryOpen,
     ToggleViewingEquipedItems,
-    UseAutoinjector,
     SelectItem(u32),
     OpenTreasureChest,
     TakeItem,
@@ -33,12 +33,16 @@ pub enum GameActions {
     DropItem(u32),
     ShardItem(u32),
     DeselectItem,
+    DeselectConsumable,
     // InCombat
     SelectAbility(CombatantAbilityNames),
     DeselectAbility,
-    CycleTargets(NextOrPrevious),
-    CycleTargetingScheme,
+    CycleAbilityTargets(NextOrPrevious),
+    CycleConsumableTargets(NextOrPrevious),
+    CycleAbilityTargetingScheme,
+    CycleConsumableTargetingScheme,
     UseSelectedAbility,
+    UseSelectedConsumable,
     LevelUpAbility(CombatantAbilityNames),
     SetAssignAttributePointsMenuOpen(bool),
     AssignAttributePoint(CombatAttributes),
diff --git a/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs b/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
index 2898400d..0f9fbd43 100644
--- a/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
+++ b/client/src/components/game/action_menu/get_game_actions_by_menu_type.rs
@@ -16,7 +16,6 @@ impl MenuTypes {
                 MenuTypes::OutOfCombat => {
                     menu_items.push(GameActions::ToggleInventoryOpen);
                     menu_items.push(GameActions::ToggleReadyToExplore);
-                    menu_items.push(GameActions::UseAutoinjector);
                     add_abilities_to_menu(&abilities, &mut menu_items);
                     menu_items.push(GameActions::SetAssignAttributePointsMenuOpen(true))
                 }
@@ -24,15 +23,23 @@ impl MenuTypes {
                 MenuTypes::ItemsOnGround => menu_items.push(GameActions::TakeItem),
                 MenuTypes::InCombat => {
                     add_abilities_to_menu(&abilities, &mut menu_items);
-                    menu_items.push(GameActions::UseAutoinjector);
                     menu_items.push(GameActions::ToggleInventoryOpen);
                 }
                 MenuTypes::AbilitySelected => {
                     menu_items.push(GameActions::DeselectAbility);
-                    menu_items.push(GameActions::CycleTargets(NextOrPrevious::Next));
-                    menu_items.push(GameActions::CycleTargets(NextOrPrevious::Previous));
+                    menu_items.push(GameActions::CycleAbilityTargets(NextOrPrevious::Next));
+                    menu_items.push(GameActions::CycleAbilityTargets(NextOrPrevious::Previous));
                     menu_items.push(GameActions::UseSelectedAbility);
-                    menu_items.push(GameActions::CycleTargetingScheme);
+                    menu_items.push(GameActions::CycleAbilityTargetingScheme);
+                }
+                MenuTypes::ConsumableSelected => {
+                    menu_items.push(GameActions::DeselectConsumable);
+                    menu_items.push(GameActions::CycleConsumableTargets(NextOrPrevious::Next));
+                    menu_items.push(GameActions::CycleConsumableTargets(
+                        NextOrPrevious::Previous,
+                    ));
+                    menu_items.push(GameActions::UseSelectedConsumable);
+                    menu_items.push(GameActions::CycleConsumableTargetingScheme);
                 }
                 MenuTypes::LevelUpAbilities => {
                     menu_items.push(GameActions::SetAssignAttributePointsMenuOpen(true));
diff --git a/client/src/components/game/action_menu/mod.rs b/client/src/components/game/action_menu/mod.rs
index 054ad583..64be8ce0 100644
--- a/client/src/components/game/action_menu/mod.rs
+++ b/client/src/components/game/action_menu/mod.rs
@@ -2,8 +2,8 @@ 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_buttons;
 mod action_menu_page_manager;
-mod action_page_buttons;
 mod build_action_button_properties;
 mod determine_action_menu_buttons_disabled;
 mod determine_menu_actions;
@@ -12,16 +12,15 @@ mod get_game_actions_by_menu_type;
 mod set_keyup_listeners;
 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::action_menu_page_buttons::page_turning::next_page;
+use crate::components::game::action_menu::action_menu_page_buttons::page_turning::prev_page;
+use crate::components::game::action_menu::action_menu_page_buttons::ActionPageButtons;
 use crate::components::game::action_menu::build_action_button_properties::ActionMenuButtonProperties;
-use crate::store::alert_store::AlertStore;
 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 common::utils::calculate_number_of_pages;
 use gloo::events::EventListener;
 use std::ops::Deref;
+use web_sys::HtmlElement;
 use yew::prelude::*;
 use yewdux::prelude::use_store;
 
@@ -32,16 +31,16 @@ const PAGE_SIZE: u8 = 6;
 #[function_component(ActionMenu)]
 pub fn action_menu(_: &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 action_menu_button_properties = use_state(|| Vec::<ActionMenuButtonProperties>::new());
     let button_props_on_current_page = use_state(|| Vec::<ActionMenuButtonProperties>::new());
+    let last_page_number_filtered = use_state(|| 0);
+    let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
 
     let cloned_current_page_number = game_state.action_menu_current_page_number.clone();
     let cloned_action_button_properties = action_menu_button_properties.clone();
     let cloned_button_props_on_current_page = button_props_on_current_page.clone();
+    let cloned_game_dispatch = game_dispatch.clone();
+    let cloned_last_page_number_filtered = last_page_number_filtered.clone();
     use_effect_with(
         (
             game_state.action_menu_current_page_number,
@@ -57,7 +56,19 @@ pub fn action_menu(_: &Props) -> Html {
                 .filter(|(i, _)| *i as u8 >= min_index && *i as u8 <= max_index)
                 .map(|(_, item)| item.clone())
                 .collect::<Vec<ActionMenuButtonProperties>>();
+            let num_actions = filtered_actions.len();
             cloned_button_props_on_current_page.set(filtered_actions);
+
+            if cloned_current_page_number != 0
+                && num_actions == 0
+                && cloned_action_button_properties.len() != 0
+                && cloned_current_page_number == *cloned_last_page_number_filtered
+            {
+                cloned_game_dispatch.reduce_mut(|store| {
+                    store.action_menu_current_page_number -= 1;
+                });
+            }
+            cloned_last_page_number_filtered.set(cloned_current_page_number);
         },
     );
 
@@ -80,11 +91,41 @@ pub fn action_menu(_: &Props) -> Html {
     let num_actions = cloned_action_button_properties.len();
     let number_of_pages = calculate_number_of_pages(PAGE_SIZE as usize, num_actions);
 
+    let action_menu_node_ref = use_node_ref();
+    let cloned_action_menu_node_ref = action_menu_node_ref.clone();
+    let handle_wheel = Callback::from(move |e: WheelEvent| {
+        let element_option = cloned_action_menu_node_ref.cast::<HtmlElement>();
+        if let Some(element) = element_option {
+            let scroll_height = element.scroll_height();
+            let client_height = element.client_height();
+            if scroll_height != client_height {
+                return;
+            }
+        }
+        if e.delta_y() > 0.0 {
+            prev_page(
+                game_dispatch.clone(),
+                cloned_current_page_number,
+                number_of_pages,
+            )
+        } else if e.delta_y() < 0.0 {
+            next_page(
+                game_dispatch.clone(),
+                cloned_current_page_number,
+                number_of_pages,
+            )
+        }
+    });
+
     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">
+        <section class="w-[22rem] 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>
+            <div class="overflow-y-auto flex-grow"
+                ref={action_menu_node_ref}
+                onwheel={handle_wheel}
+            >
                 {cloned_button_props_on_current_page.deref().iter().enumerate().map(|(i, action)| {
                       html!(
                           <ActionMenuButton
@@ -104,3 +145,4 @@ pub fn action_menu(_: &Props) -> Html {
         </section>
     )
 }
+
diff --git a/client/src/components/game/character_autofocus_manager/mod.rs b/client/src/components/game/character_autofocus_manager/mod.rs
index 008c2d8f..6f1a92c2 100644
--- a/client/src/components/game/character_autofocus_manager/mod.rs
+++ b/client/src/components/game/character_autofocus_manager/mod.rs
@@ -11,7 +11,7 @@ use yewdux::prelude::use_store;
 pub fn character_autofocus_manager() -> Html {
     let (game_state, game_dispatch) = use_store::<GameStore>();
     let (lobby_state, _) = use_store::<LobbyStore>();
-    let prev_active_combatant_id_option = use_state(|| None);
+    let prev_active_combatant_id_option: UseStateHandle<Option<u32>> = use_state(|| None);
     let focused_character_id = game_state.focused_character_id;
     let active_combatant_result = get_active_combatant(&game_state);
     let active_combatant_id_option = match active_combatant_result {
@@ -42,6 +42,12 @@ pub fn character_autofocus_manager() -> Html {
                                     && !game_state.viewing_inventory
                                 {
                                     store.focused_character_id = new_active_combatant_id
+                                } else if !party
+                                    .character_positions
+                                    .contains(&prev_active_combatant_id)
+                                    && !game_state.viewing_inventory
+                                {
+                                    store.focused_character_id = new_active_combatant_id
                                 }
                             }
                         }
diff --git a/client/src/components/game/character_sheet/paper_doll/mod.rs b/client/src/components/game/character_sheet/paper_doll/mod.rs
index 8a45a0ad..3c08c068 100644
--- a/client/src/components/game/character_sheet/paper_doll/mod.rs
+++ b/client/src/components/game/character_sheet/paper_doll/mod.rs
@@ -24,18 +24,18 @@ pub fn paper_doll(props: &Props) -> Html {
                         item_option={equipment.remove(&EquipmentSlots::RightRing)}
                         character_attributes={props.attributes.clone()}
                         slot={EquipmentSlots::RightRing}
-                        class=" h-10 w-10" />
+                        class=" h-10 max-h-10 w-10 max-w-10" />
                     <PaperDollSlot
                         item_option={equipment.remove(&EquipmentSlots::LeftRing)}
                         character_attributes={props.attributes.clone()}
                         slot={EquipmentSlots::LeftRing}
-                        class=" h-10 w-10" />
+                        class=" h-10 max-h-10 w-10 max-w-10" />
                 </div>
                 <PaperDollSlot
                     item_option={equipment.remove(&EquipmentSlots::MainHand)}
                     character_attributes={props.attributes.clone()}
                     slot={EquipmentSlots::MainHand}
-                    class="h-40 w-full " />
+                    class="h-40 max-h-40 w-full " />
             </div>
             <div class="w-1/3 mr-2 ml-2" >
                 <PaperDollSlot
diff --git a/client/src/components/game/combatant/combatant_is_targeted.rs b/client/src/components/game/combatant/combatant_is_targeted.rs
index 8b65dabc..7d2b81d4 100644
--- a/client/src/components/game/combatant/combatant_is_targeted.rs
+++ b/client/src/components/game/combatant/combatant_is_targeted.rs
@@ -1,42 +1,68 @@
-use crate::store::game_store::get_active_combatant;
 use crate::store::game_store::get_current_party_option;
 use crate::store::game_store::GameStore;
-use common::combatants::abilities::AbilityTarget;
-use common::combatants::abilities::FriendOrFoe;
+use common::combat::combat_actions::CombatActionTarget;
+use common::combat::combat_actions::FriendOrFoe;
+use common::combatants::abilities::CombatantAbilityNames;
+use common::items::consumables::ConsumableProperties;
 use std::rc::Rc;
 
-pub fn combatant_is_targeted(game_state: Rc<GameStore>, combatant_id: &u32) -> bool {
+pub fn combatant_targeted_by(
+    game_state: Rc<GameStore>,
+    combatant_id: &u32,
+) -> Vec<(
+    u32,
+    Option<CombatantAbilityNames>,
+    Option<ConsumableProperties>,
+)> {
+    // check if any entity in own party targeting
+    // return vec of entities targeting and the ability name
+    let mut to_return: Vec<(
+        u32,
+        Option<CombatantAbilityNames>,
+        Option<ConsumableProperties>,
+    )> = Vec::new();
     let party_option = get_current_party_option(&game_state);
     if party_option.is_none() {
-        return false;
+        return Vec::new();
     }
     let party = party_option.expect("is_none checked");
-    let active_character_result = get_active_combatant(&game_state);
-    if let Ok(active_character_option) = active_character_result {
-        if let Some(active_character) = active_character_option {
-            let targets_option = &active_character.1.ability_targets;
-            if let Some(targets) = targets_option {
-                match targets {
-                    AbilityTarget::Single(targeted_id) => combatant_id == targeted_id,
-                    AbilityTarget::Group(category) => match category {
-                        FriendOrFoe::Friendly => party.character_positions.contains(combatant_id),
-                        FriendOrFoe::Hostile => {
-                            if let Ok(monster_ids) = party.get_monster_ids() {
-                                monster_ids.contains(combatant_id)
-                            } else {
-                                false
-                            }
+
+    for (id, character) in party.characters.iter() {
+        if let Some(targets) = &character.combatant_properties.combat_action_targets {
+            let is_targeted_by_this_character = match targets {
+                CombatActionTarget::Single(targeted_id) => combatant_id == targeted_id,
+                CombatActionTarget::Group(category) => match category {
+                    FriendOrFoe::Friendly => party.character_positions.contains(combatant_id),
+                    FriendOrFoe::Hostile => {
+                        if let Ok(monster_ids) = party.get_monster_ids() {
+                            monster_ids.contains(combatant_id)
+                        } else {
+                            false
                         }
-                    },
-                    AbilityTarget::All => true,
-                }
-            } else {
-                false
+                    }
+                },
+                CombatActionTarget::All => true,
+            };
+            let consumable_type_option =
+                if let Some(consumable_id) = character.combatant_properties.selected_consumable {
+                    character
+                        .combatant_properties
+                        .inventory
+                        .get_consumable(&consumable_id)
+                        .cloned()
+                        .ok()
+                } else {
+                    None
+                };
+            if is_targeted_by_this_character {
+                to_return.push((
+                    *id,
+                    character.combatant_properties.selected_ability_name.clone(),
+                    consumable_type_option,
+                ))
             }
-        } else {
-            false
         }
-    } else {
-        false
     }
+
+    to_return
 }
diff --git a/client/src/components/game/combatant/focus_character_button.rs b/client/src/components/game/combatant/focus_character_button.rs
index f5d5ff1b..2d7c46b6 100644
--- a/client/src/components/game/combatant/focus_character_button.rs
+++ b/client/src/components/game/combatant/focus_character_button.rs
@@ -25,8 +25,12 @@ pub fn focus_character_button(props: &Props) -> Html {
     };
 
     let id = props.id;
-    let handle_click =
-        Callback::from(move |_| game_dispatch.reduce_mut(|store| store.focused_character_id = id));
+    let handle_click = Callback::from(move |_| {
+        game_dispatch.reduce_mut(|store| {
+            store.selected_item = None;
+            store.focused_character_id = id;
+        })
+    });
     let conditional_styles = if is_focused_character {
         "bg-green-700"
     } else {
diff --git a/client/src/components/game/combatant/mod.rs b/client/src/components/game/combatant/mod.rs
index f946491b..b432f6aa 100644
--- a/client/src/components/game/combatant/mod.rs
+++ b/client/src/components/game/combatant/mod.rs
@@ -48,7 +48,7 @@ pub fn combatant(props: &Props) -> Html {
 
     let is_ally = combatant_is_ally::combatant_is_ally(game_state.clone(), id);
     let is_selected = combatant_is_selected::combatant_is_selected(game_state.clone(), id);
-    let is_targeted = combatant_is_targeted::combatant_is_targeted(game_state.clone(), &id);
+    let targeted_by = combatant_is_targeted::combatant_targeted_by(game_state.clone(), &id);
     let battle_option = get_current_battle_option(&game_state);
     let is_active_combatant = match battle_option {
         Some(battle) => battle.combatant_is_first_in_turn_order(id),
@@ -58,7 +58,7 @@ pub fn combatant(props: &Props) -> Html {
     let selected_style = if is_selected { "border-yellow-400" } else { "" };
 
     let styles = format!(
-        "flex border border-slate-400 mb-2 last:mb-0 w-40 relative {}",
+        "flex border border-slate-400 mb-2 w-40 relative {}",
         selected_style
     );
 
@@ -74,19 +74,23 @@ pub fn combatant(props: &Props) -> Html {
 
     html!(
         <div class={styles}>
-            if is_targeted{
+            if targeted_by.len() > 0{
                 <div class="absolute top-[-1.5rem] left-1/2 -translate-x-1/2 z-20
-                    " >
-                    <TargetingIndicator />
+                            flex" >
+                            {targeted_by.iter().map(|combatant_id_and_with_what| html!(
+                                        <TargetingIndicator
+                                        ability_name_option={combatant_id_and_with_what.1.clone()}
+                                        consumable_option={combatant_id_and_with_what.2.clone()} />
+                            )).collect::<Html>()}
                     </div>
             }
             if is_active_combatant {
-                <div class={format!("absolute top-1/2 -translate-y-1/2 {}
+                <div class={format!("absolute z-50 top-1/2 -translate-y-1/2 {}
                                     pr-2 pl-2 border border-slate-400 bg-slate-700", turn_indicator_style)} >
                     {"active"}
                 </div>
             }
-            <button class={"flex flex-col
+            <button class={"flex flex-col bg-slate-700
                 text-left p-2 cursor-help w-full overflow-hidden"} onclick={handle_click} id={format!("combatant-{}", id)} >
                 <div class="pointer-events-none" >
                     {name}
diff --git a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/mod.rs b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/mod.rs
index 3a6864c3..389a49f9 100644
--- a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/mod.rs
+++ b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/mod.rs
@@ -1,10 +1,14 @@
 mod queue_attack_animations;
+mod queue_consumable_use_animations;
 mod queue_melee_ability_animations;
 mod queue_return_to_home_position_animations;
 use self::queue_attack_animations::queue_attack_animations;
+use self::queue_consumable_use_animations::queue_consumable_use_animations;
+use self::queue_melee_ability_animations::queue_melee_ability_animations;
 use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::CombatAction;
 use common::combat::ActionResult;
-use common::combat::CombatAction;
 use common::combatants::abilities::CombatantAbilityNames;
 use common::errors::AppError;
 use yewdux::Dispatch;
@@ -15,10 +19,31 @@ pub fn process_next_action_result_in_combatant_event_queue(
     combatant_id: u32,
 ) -> Result<(), AppError> {
     if let Some(new_action_result) = &current_action_processing {
+        game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+            let event_manager = store
+                .action_results_manager
+                .combantant_event_managers
+                .get_mut(&combatant_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
+                })?;
+            event_manager.last_processed_action_ended_turn = new_action_result.ends_turn;
+
+            let game = store.get_current_game_mut()?;
+            let (_, action_user_combatant_properties) =
+                game.get_mut_combatant_by_id(&combatant_id)?;
+            action_user_combatant_properties.selected_consumable = None;
+            action_user_combatant_properties.selected_ability_name = None;
+            action_user_combatant_properties.combat_action_targets = None;
+
+            Ok(())
+        })?;
+
         match &new_action_result.action {
             CombatAction::AbilityUsed(ability_name) => {
                 match ability_name.get_attributes().is_melee {
-                    true => queue_melee_ability_animations::queue_melee_ability_animations(
+                    true => queue_melee_ability_animations(
                         game_dispatch.clone(),
                         combatant_id,
                         new_action_result,
@@ -32,14 +57,46 @@ pub fn process_next_action_result_in_combatant_event_queue(
                     _ => Ok(()),
                 }
             }
-            CombatAction::ItemUsed(_) => {
-                todo!()
+            CombatAction::ConsumableUsed(item_id) => {
+                queue_consumable_use_animations(
+                    game_dispatch.clone(),
+                    combatant_id,
+                    new_action_result,
+                )?;
+                game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+                    let game = store.get_current_game_mut()?;
+                    let (_, action_user_combatant_properties) =
+                        game.get_mut_combatant_by_id(&combatant_id)?;
+                    let consumable = action_user_combatant_properties
+                        .inventory
+                        .get_consumable_mut(&item_id)?;
+                    consumable.uses_remaining -= 1;
+                    let should_be_removed_from_inventory = consumable.uses_remaining == 0;
+                    if should_be_removed_from_inventory {
+                        action_user_combatant_properties
+                            .inventory
+                            .remove_item(*item_id)?;
+                    }
+                    Ok(())
+                })
             }
         }
     } else {
+        let ends_turn = game_dispatch.reduce_mut(|store| -> Result<bool, AppError> {
+            let event_manager = store
+                .action_results_manager
+                .combantant_event_managers
+                .get_mut(&combatant_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
+                })?;
+            Ok(event_manager.last_processed_action_ended_turn)
+        })?;
         queue_return_to_home_position_animations::queue_return_to_home_position_animations(
             game_dispatch,
             combatant_id,
+            ends_turn,
         )
     }
 }
diff --git a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_attack_animations.rs b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_attack_animations.rs
index 6fbcb2ed..4867cbac 100644
--- a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_attack_animations.rs
+++ b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_attack_animations.rs
@@ -1,8 +1,6 @@
 use crate::components::mesh_manager::CombatantAnimation;
 use crate::store::game_store::GameStore;
-use common::app_consts::error_messages;
 use common::combat::ActionResult;
-use common::combatants::abilities::AbilityTarget;
 use common::errors::AppError;
 use std::collections::VecDeque;
 use yewdux::Dispatch;
@@ -19,16 +17,7 @@ pub fn queue_attack_animations(
             .get_mut(&combatant_id)
             .expect("none checked");
 
-        let target_id = match action_result.targets {
-            AbilityTarget::Single(id) => id,
-            _ => {
-                return Err(AppError {
-                    error_type: common::errors::AppErrorTypes::Generic,
-                    message: error_messages::INVALID_TARGETING_SCHEME.to_string(),
-                })
-            }
-        };
-
+        let target_id = action_result.targets.get_single_target_id()?;
         let hp_change_option =
             if let Some(hp_changes_by_entity) = &action_result.hp_changes_by_entity_id {
                 hp_changes_by_entity.get(&target_id)
diff --git a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_consumable_use_animations.rs b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_consumable_use_animations.rs
new file mode 100644
index 00000000..72259fa4
--- /dev/null
+++ b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_consumable_use_animations.rs
@@ -0,0 +1,74 @@
+use crate::components::mesh_manager::AutoinjectorTypes;
+use crate::components::mesh_manager::CombatantAnimation;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::CombatAction;
+use common::combat::ActionResult;
+use common::errors::AppError;
+use common::items::consumables::ConsumableTypes;
+use std::collections::VecDeque;
+use yewdux::Dispatch;
+
+pub fn queue_consumable_use_animations(
+    game_dispatch: Dispatch<GameStore>,
+    combatant_id: u32,
+    action_result: &ActionResult,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|game_store| -> Result<(), AppError> {
+        let game = game_store.get_current_game()?;
+        let (_, consumable_user_combatant_properties) = game.get_combatant_by_id(&combatant_id)?;
+
+        let item_id = match action_result.action {
+            CombatAction::AbilityUsed(_) => {
+                return Err(AppError {
+                    error_type: common::errors::AppErrorTypes::Generic,
+                    message: error_messages::INVALID_ACTION_TYPE.to_string(),
+                })
+            }
+            CombatAction::ConsumableUsed(id) => id,
+        };
+        let consumable = consumable_user_combatant_properties
+            .inventory
+            .get_consumable(&item_id)?;
+        let target_id = action_result.targets.get_single_target_id()?;
+
+        match consumable.consumable_type {
+            ConsumableTypes::HpAutoinjector => {
+                let hp_changes =
+                    &action_result
+                        .hp_changes_by_entity_id
+                        .as_ref()
+                        .ok_or_else(|| AppError {
+                            error_type: common::errors::AppErrorTypes::Generic,
+                            message: error_messages::MISSING_EXPECTED_ACTION_RESULT_DATA
+                                .to_string(),
+                        })?;
+                let hp_change = hp_changes.get(&target_id).ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::Generic,
+                    message: error_messages::MISSING_EXPECTED_ACTION_RESULT_DATA.to_string(),
+                })?;
+                let hp_change = *hp_change;
+
+                let event_manager = game_store
+                    .action_results_manager
+                    .combantant_event_managers
+                    .get_mut(&combatant_id)
+                    .ok_or_else(|| AppError {
+                        error_type: common::errors::AppErrorTypes::ClientError,
+                        message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
+                    })?;
+
+                event_manager.animation_queue.append(&mut VecDeque::from([
+                    CombatantAnimation::UseAutoinjector(
+                        AutoinjectorTypes::Hp,
+                        target_id,
+                        hp_change,
+                    ),
+                ]));
+                Ok(())
+            }
+            ConsumableTypes::Grenade => todo!(),
+            ConsumableTypes::SmokeBomb => todo!(),
+        }
+    })
+}
diff --git a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_melee_ability_animations.rs b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_melee_ability_animations.rs
index 1658c7d9..a557d5e5 100644
--- a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_melee_ability_animations.rs
+++ b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_melee_ability_animations.rs
@@ -2,8 +2,8 @@ use crate::components::mesh_manager::CombatantAnimation;
 use crate::components::mesh_manager::CombatantVisualLocation;
 use crate::store::game_store::GameStore;
 use common::app_consts::error_messages;
+use common::combat::combat_actions::CombatActionTarget;
 use common::combat::ActionResult;
-use common::combatants::abilities::AbilityTarget;
 use common::errors::AppError;
 use std::collections::VecDeque;
 use yewdux::Dispatch;
@@ -14,9 +14,9 @@ pub fn queue_melee_ability_animations(
     action_result: &ActionResult,
 ) -> Result<(), AppError> {
     let target_id = match action_result.targets {
-        AbilityTarget::Single(id) => id,
-        AbilityTarget::Group(_) => combatant_id, // @TODO
-        AbilityTarget::All => combatant_id,
+        CombatActionTarget::Single(id) => id,
+        CombatActionTarget::Group(_) => combatant_id, // @TODO
+        CombatActionTarget::All => combatant_id,
     };
     game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
         let event_manager = store
diff --git a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_return_to_home_position_animations.rs b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_return_to_home_position_animations.rs
index 8af8067b..ded6fc32 100644
--- a/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_return_to_home_position_animations.rs
+++ b/client/src/components/game/combatant/process_next_action_result_in_combatant_event_queue/queue_return_to_home_position_animations.rs
@@ -7,6 +7,7 @@ use yewdux::Dispatch;
 pub fn queue_return_to_home_position_animations(
     game_dispatch: Dispatch<GameStore>,
     combatant_id: u32,
+    ends_turn: bool,
 ) -> Result<(), AppError> {
     game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
         let event_manager = store
@@ -20,7 +21,7 @@ pub fn queue_return_to_home_position_animations(
 
         event_manager
             .animation_queue
-            .push_back(CombatantAnimation::ReturnToReadyPosition);
+            .push_back(CombatantAnimation::ReturnToReadyPosition(ends_turn));
 
         Ok(())
     })
diff --git a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/autoinjector_use_animation_finished_handler.rs b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/autoinjector_use_animation_finished_handler.rs
new file mode 100644
index 00000000..8df7ee48
--- /dev/null
+++ b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/autoinjector_use_animation_finished_handler.rs
@@ -0,0 +1,54 @@
+use crate::components::game::combat_log::combat_log_message::CombatLogMessage;
+use crate::components::game::combat_log::combat_log_message::CombatLogMessageStyle;
+use crate::components::mesh_manager::AutoinjectorTypes;
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use yew::AttrValue;
+use yewdux::Dispatch;
+
+pub fn autoinjector_use_animation_finished_handler(
+    game_dispatch: Dispatch<GameStore>,
+    autoinjector_type: AutoinjectorTypes,
+    value_change: i16,
+    user_id: u32,
+    target_id: u32,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|store| {
+        let game = store.get_current_game_mut()?;
+        let (user_entity_properties, _) = game.get_mut_combatant_by_id(&user_id)?;
+        let user_name = user_entity_properties.name.clone();
+        let (target_entity_properties, target_combatant_properties) =
+            game.get_mut_combatant_by_id(&target_id)?;
+        let target_name = target_entity_properties.name.clone();
+        match autoinjector_type {
+            AutoinjectorTypes::Hp => {
+                let _ = target_combatant_properties.change_hp(value_change);
+                let target_text = if user_id == target_id {
+                    "themselves".to_string()
+                } else {
+                    format!("{} ({target_id})", target_name)
+                };
+                store.combat_log.push(CombatLogMessage::new(
+                    AttrValue::from(format!(
+                        "{} ({user_id}) injected {} for {value_change} HP",
+                        user_name, target_text
+                    )),
+                    CombatLogMessageStyle::Basic,
+                    0,
+                ));
+            }
+        }
+
+        let event_manager = store
+            .action_results_manager
+            .combantant_event_managers
+            .get_mut(&user_id)
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::ClientError,
+                message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
+            })?;
+        event_manager.action_result_queue.pop_front();
+        Ok(())
+    })
+}
diff --git a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/handle_animation_finished.rs b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/handle_animation_finished.rs
index 2a306196..98cd52fe 100644
--- a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/handle_animation_finished.rs
+++ b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/handle_animation_finished.rs
@@ -7,6 +7,7 @@ use crate::store::game_store::GameStore;
 use common::app_consts::error_messages;
 use common::errors::AppError;
 use yewdux::Dispatch;
+use super::autoinjector_use_animation_finished_handler::autoinjector_use_animation_finished_handler;
 
 pub fn handle_animation_finished(
     game_dispatch: Dispatch<GameStore>,
@@ -28,8 +29,12 @@ pub fn handle_animation_finished(
             follow_through_swing_animation_finished_handler(game_dispatch.clone(), combatant_id)
         }
         CombatantAnimation::OffHandFollowThroughSwing => todo!(),
-        CombatantAnimation::ReturnToReadyPosition => {
-            return_to_ready_position_animation_finished_handler(game_dispatch.clone(), combatant_id)
+        CombatantAnimation::ReturnToReadyPosition(ends_turn) => {
+            return_to_ready_position_animation_finished_handler(
+                game_dispatch.clone(),
+                combatant_id,
+                ends_turn,
+            )
         }
         CombatantAnimation::HitRecovery(_) => Ok(()),
         CombatantAnimation::Death(_) => Ok(()),
@@ -42,6 +47,15 @@ pub fn handle_animation_finished(
             )
         }
         CombatantAnimation::Evasion => Ok(()),
+        CombatantAnimation::UseAutoinjector(autoinjector_type, target_id, value_change) => {
+            autoinjector_use_animation_finished_handler(
+                game_dispatch.clone(),
+                autoinjector_type,
+                value_change,
+                combatant_id,
+                target_id,
+            )
+        }
     }?;
 
     game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
@@ -53,7 +67,7 @@ pub fn handle_animation_finished(
                 error_type: common::errors::AppErrorTypes::ClientError,
                 message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
             })?;
-        event_manager.animation_queue.pop_front();
+        let _ = event_manager.animation_queue.pop_front();
 
         Ok(())
     })
diff --git a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/mod.rs b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/mod.rs
index e9e60b24..e24046c8 100644
--- a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/mod.rs
+++ b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/mod.rs
@@ -1,4 +1,5 @@
 mod approach_combatant_animation_finished_handler;
+mod autoinjector_use_animation_finished_handler;
 mod follow_through_swing_animation_finished_handler;
 mod handle_animation_finished;
 mod return_to_ready_position_animation_finished_handler;
@@ -18,12 +19,16 @@ pub fn process_next_animation_in_combatant_animation_queue(
 ) {
     if let Some(animation) = animation_queue.front() {
         let cloned_animation = animation.clone();
-        timer_state.set(Some(gloo::timers::callback::Timeout::new(100, move || {
-            let _result = handle_animation_finished::handle_animation_finished(
-                game_dispatch,
-                cloned_animation,
-                combatant_id,
-            );
-        })));
+        let animation_duration = 100;
+        timer_state.set(Some(gloo::timers::callback::Timeout::new(
+            animation_duration,
+            move || {
+                let _result = handle_animation_finished::handle_animation_finished(
+                    game_dispatch,
+                    cloned_animation,
+                    combatant_id,
+                );
+            },
+        )));
     }
 }
diff --git a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/return_to_ready_position_animation_finished_handler.rs b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/return_to_ready_position_animation_finished_handler.rs
index 96b5add4..c72b028b 100644
--- a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/return_to_ready_position_animation_finished_handler.rs
+++ b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/return_to_ready_position_animation_finished_handler.rs
@@ -8,6 +8,7 @@ use yewdux::Dispatch;
 pub fn return_to_ready_position_animation_finished_handler(
     game_dispatch: Dispatch<GameStore>,
     combatant_id: u32,
+    ends_turn: bool,
 ) -> Result<(), AppError> {
     // if in battle, call for next turn result to be passed to it's enitity
     let battle_id_option = game_dispatch.reduce_mut(|store| -> Result<Option<u32>, AppError> {
@@ -25,15 +26,18 @@ pub fn return_to_ready_position_animation_finished_handler(
     });
 
     if let Ok(Some(battle_id)) = battle_id_option {
-        game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
-            let game = store.game.as_mut().ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ClientError,
-                message: error_messages::GAME_NOT_FOUND.to_string(),
+        if ends_turn {
+            game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+                let game = store.game.as_mut().ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::GAME_NOT_FOUND.to_string(),
+                })?;
+                game.end_active_combatant_turn(battle_id)?;
+                Ok(())
             })?;
-            game.end_active_combatant_turn(battle_id)?;
-            Ok(())
-        })?;
-        send_next_turn_result_to_combatant_event_manager(game_dispatch)
+            send_next_turn_result_to_combatant_event_manager(game_dispatch)?
+        }
+        Ok(())
     } else {
         Ok(())
     }
diff --git a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/swing_to_hit_animation_finished_handler.rs b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/swing_to_hit_animation_finished_handler.rs
index 8a236751..f760651b 100644
--- a/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/swing_to_hit_animation_finished_handler.rs
+++ b/client/src/components/game/combatant/process_next_animation_in_combatant_animation_queue/swing_to_hit_animation_finished_handler.rs
@@ -17,10 +17,13 @@ pub fn swing_to_hit_animation_finished_handler(
     combatant_id: u32,
 ) -> Result<(), AppError> {
     game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
+        let party = store.get_current_party_mut()?;
+        let battle_id_option = party.battle_id;
         let game = store.get_current_game_mut()?;
         let (attacker_entity_properties, _) = game.get_mut_combatant_by_id(&combatant_id)?;
         let attacker_name = attacker_entity_properties.name.clone();
         let (entity_properties, combatant_properties) = game.get_mut_combatant_by_id(&target_id)?;
+        let entity_id = entity_properties.id;
         let target_name = entity_properties.name.clone();
         let new_hp = if let Some(hp_change) = hp_change_option {
             let new_hp = combatant_properties.change_hp(hp_change);
@@ -37,6 +40,26 @@ pub fn swing_to_hit_animation_finished_handler(
             combatant_properties.hit_points
         };
 
+        // REMOVE THEIR TURN TRACKER
+        if new_hp == 0 {
+            let game = store.get_current_game_mut()?;
+            if let Some(battle_id) = battle_id_option {
+                let battle = game.battles.get_mut(&battle_id).ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                })?;
+                let mut index_to_remove_option = None;
+                for (i, turn_tracker) in battle.combatant_turn_trackers.iter().enumerate() {
+                    if turn_tracker.entity_id == entity_id {
+                        index_to_remove_option = Some(i)
+                    }
+                }
+                if let Some(index_to_remove) = index_to_remove_option {
+                    let _ = battle.combatant_turn_trackers.remove(index_to_remove);
+                }
+            }
+        }
+
         let target_event_manager = store
             .action_results_manager
             .combantant_event_managers
@@ -67,8 +90,7 @@ pub fn swing_to_hit_animation_finished_handler(
                     value: hp_change,
                     color: AttrValue::from("rgba(255,255,255,0)"),
                 });
-            // don't animate hit recovery if they hit themselves during an
-            // action of their own doing
+
             if target_event_manager.action_result_queue.front().is_none() {
                 if new_hp == 0 {
                     target_event_manager.animation_queue =
@@ -78,7 +100,9 @@ pub fn swing_to_hit_animation_finished_handler(
                         CombatLogMessageStyle::Basic,
                         0,
                     ));
-                } else {
+                } else if combatant_id != target_id {
+                    // don't hit recovery if attacking self or else return to home animation won't
+                    // play and trigger next
                     target_event_manager.animation_queue =
                         VecDeque::from([CombatantAnimation::HitRecovery(hp_change)])
                 }
diff --git a/client/src/components/game/dungeon_room/items_on_ground.rs b/client/src/components/game/dungeon_room/items_on_ground.rs
index f8efab57..e15fcb00 100644
--- a/client/src/components/game/dungeon_room/items_on_ground.rs
+++ b/client/src/components/game/dungeon_room/items_on_ground.rs
@@ -1,4 +1,6 @@
-use crate::components::common_components::atoms::button_basic::ButtonBasic;
+use crate::components::game::action_menu::action_button_hover_handlers::create_action_mouse_enter_handler;
+use crate::components::game::action_menu::action_button_hover_handlers::create_action_mouse_leave_handler;
+use crate::components::game::action_menu::enums::GameActions;
 use crate::components::websocket_manager::send_client_input::send_client_input;
 use crate::store::game_store::get_current_party_option;
 use crate::store::game_store::GameStore;
@@ -50,7 +52,7 @@ pub struct ItemOnGroundProps {
 
 #[function_component(ItemOnGround)]
 pub fn item_on_ground(props: &ItemOnGroundProps) -> Html {
-    let (game_state, _) = use_store::<GameStore>();
+    let (game_state, game_dispatch) = use_store::<GameStore>();
     let (websocket_state, _) = use_store::<WebsocketStore>();
 
     let cloned_websocket_state = websocket_state.clone();
@@ -65,17 +67,59 @@ pub fn item_on_ground(props: &ItemOnGroundProps) -> Html {
             }),
         )
     });
+    let cloned_game_state = game_state.clone();
+    let cloned_game_dispatch = game_dispatch.clone();
+    let mouse_enter_handler = Callback::from(move |_| {
+        create_action_mouse_enter_handler(
+            GameActions::SelectItem(item_id),
+            cloned_game_dispatch.clone(),
+            cloned_game_state.clone(),
+        )()
+    });
+    let cloned_game_dispatch = game_dispatch.clone();
+    let mouse_leave_handler = Callback::from(move |_| {
+        create_action_mouse_leave_handler(
+            GameActions::SelectItem(item_id),
+            cloned_game_dispatch.clone(),
+        )()
+    });
+    let cloned_game_state = game_state.clone();
+    let cloned_game_dispatch = game_dispatch.clone();
+    let focus_handler = Callback::from(move |_| {
+        create_action_mouse_enter_handler(
+            GameActions::SelectItem(item_id),
+            cloned_game_dispatch.clone(),
+            cloned_game_state.clone(),
+        )()
+    });
+    let cloned_game_dispatch = game_dispatch.clone();
+    let blur_handler = Callback::from(move |_| {
+        create_action_mouse_leave_handler(
+            GameActions::SelectItem(item_id),
+            cloned_game_dispatch.clone(),
+        )()
+    });
 
     html!(
-    <li class="h-10 w-full max-w-full flex border border-slate-400 mb-2 last:mb-0 whitespace-nowrap text-ellipsis overflow-hidden" >
-        <ButtonBasic
-            extra_styles="border-0 border-r hover:bg-slate-950 h-full"
+    <li class="h-10 w-full max-w-full flex border-r border-l border-b border-slate-400 first:border-t
+    hover:border-yellow-400 hover:border-t box-border
+    whitespace-nowrap text-ellipsis overflow-hidden cursor-default"
+        onmouseenter={mouse_enter_handler}
+        onmouseleave={mouse_leave_handler}
+        >
+        <button
+            class="cursor-pointer pr-4 pl-4 box-border
+            flex justify-center items-center disabled:opacity-50 disabled:cursor-auto
+            border-slate-400 border-r h-full"
             onclick={take_item}
+            onfocus={focus_handler}
+            onblur={blur_handler}
             disabled={props.disabled}
         >
             {"Take"}
-        </ButtonBasic>
-        <div class="flex items-center h-full w-full ">
+        </button>
+        <div class="flex items-center h-full w-full "
+        >
             <div class="pl-2 overflow-hidden whitespace-nowrap text-ellipsis ">
                 {&props.name}{" "}{&props.id}
             </div>
diff --git a/client/src/components/game/dungeon_room/mod.rs b/client/src/components/game/dungeon_room/mod.rs
index 56a443bf..39369055 100644
--- a/client/src/components/game/dungeon_room/mod.rs
+++ b/client/src/components/game/dungeon_room/mod.rs
@@ -1,7 +1,6 @@
 use crate::components::common_components::atoms::button_basic::ButtonBasic;
 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::dungeon_rooms::DungeonRoomTypes;
 mod empty_room;
@@ -24,7 +23,6 @@ pub struct Props {
 
 #[function_component(DungeonRoom)]
 pub fn dungeon_room(props: &Props) -> Html {
-    let (websocket_state, _) = use_store::<WebsocketStore>();
     let (game_state, game_dispatch) = use_store::<GameStore>();
     let game_result = game_state.get_current_game();
     if let Ok(game) = game_result {
@@ -46,12 +44,12 @@ pub fn dungeon_room(props: &Props) -> Html {
         });
 
         let conditional_styles = match game_state.viewing_inventory {
-            true => "min-w-[350px] w-[350px] mr-4",
+            true => "w-[22rem] mr-4",
             false => "w-full",
         };
 
         let time_of_death_option = if let Some(time_of_wipe) = party.time_of_wipe {
-            Some("now")
+            Some(format!("unix timestamp ({})", time_of_wipe))
         } else {
             None
         };
@@ -70,8 +68,8 @@ pub fn dungeon_room(props: &Props) -> Html {
 
         html!(
             <section class={format!("h-full border border-slate-400 bg-slate-700 flex {}", conditional_styles)} >
-                <div class="w-1/2 flex p-2" >
-                    <div class="flex flex-col mr-2" >
+                <div class="w-1/2 flex p-2 h-full" >
+                    <div class="flex flex-col mr-4 h-full flex-grow" >
                         {characters.iter().map(|(_id, character)|
                             html!{<Combatant
                                 entity_properties={character.entity_properties.clone()}
@@ -79,7 +77,7 @@ pub fn dungeon_room(props: &Props) -> Html {
                                 />}).collect::<Html>()
                         }
                     </div>
-                    if party.current_room.monsters.is_none() {
+                    if party.current_room.monsters.is_none() && !game_state.viewing_inventory {
                         <PlayersReadyToExplore
                             players_ready_to_explore={party.players_ready_to_explore.clone()}
                             players_ready_to_descend_option={players_ready_to_descend_option}
@@ -87,7 +85,6 @@ pub fn dungeon_room(props: &Props) -> Html {
                         />
                     }
                 </div>
-                // if !game_state.viewing_inventory {
                 <div class="w-1/2 border-l border-slate-400 p-2 flex flex-col" >
                     if let Some(time_of_death) = time_of_death_option {
                         <div class=" border border-slate-400 bg-slate-700 p-4
@@ -100,10 +97,10 @@ pub fn dungeon_room(props: &Props) -> Html {
                             </ButtonBasic>
                         </div>
                     }
-                    if party.current_room.room_type == DungeonRoomTypes::Stairs {
+                    if party.current_room.room_type == DungeonRoomTypes::Stairs && !game_state.viewing_inventory {
                         <Stairs />
                     }
-                    if party.current_room.room_type == DungeonRoomTypes::Empty {
+                    if party.current_room.room_type == DungeonRoomTypes::Empty && !game_state.viewing_inventory {
                         <EmptyRoom />
                     }
                     if let Some(battle_id) = game_state.current_battle_id {
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 6dde1756..5b0afe94 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
@@ -26,7 +26,7 @@ pub fn players_ready_to_explore(props: &Props) -> Html {
         );
     }
     html!(
-    <div class="flex flex-col flex-1">
+    <div class="flex flex-col flex-grow max-h-full overflow-y-auto">
         <PlayersIncludedInList
             title={ready_to_explore_title}
             waiting_message={ready_to_explore_waiting_message}
@@ -51,7 +51,7 @@ 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">
+        <div class="flex-1 p-2  mb-2 last:mb-0">
             <h3 class="mb-2" >
                 {props.title.clone()}
             </h3>
diff --git a/client/src/components/game/mod.rs b/client/src/components/game/mod.rs
index fdde5bc9..43b2556e 100644
--- a/client/src/components/game/mod.rs
+++ b/client/src/components/game/mod.rs
@@ -1,4 +1,4 @@
-mod action_menu;
+pub mod action_menu;
 mod character_autofocus_manager;
 mod character_sheet;
 pub mod combat_log;
@@ -72,21 +72,23 @@ 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 />
-            <CharacterAutofocusManager />
-            if !game_state.viewing_inventory {
-                <TopInfoBar />
-            }
-            <div class="h-1/2 flex mb-4" >
-                <DungeonRoom party_id={party_id} />
-                if game_state.viewing_inventory && focused_character.is_some(){
-                    <CharacterSheet character={focused_character.as_deref().expect("is_some checked").clone()} />
-                }
-            </div>
-            <div class="flex h-1/2 max-h-[453px]" >
-                <ActionMenu />
-                <TabbedDisplay />
+        <main class="h-screen w-screen bg-slate-800 flex justify-center relative overflow-y-auto">
+            <div class="w-full h-full max-w-[80rem] max-h-[67.5rem] pr-4 pl-4 text-zinc-300 flex flex-col" >
+                // <GameDebug />
+                <CharacterAutofocusManager />
+                <div class="flex-1 flex flex-col mb-2 mt-4 h-[60%] max-h-1/2 overflow-y-auto" >
+                    <TopInfoBar />
+                    <div class="flex flex-grow">
+                        <DungeonRoom party_id={party_id} />
+                        if game_state.viewing_inventory && focused_character.is_some(){
+                            <CharacterSheet character={focused_character.as_deref().expect("is_some checked").clone()} />
+                        }
+                    </div>
+                </div>
+                <div class="flex max-h-1/2 h-[40%] mt-2 mb-4 overflow-y-auto" >
+                    <ActionMenu />
+                    <TabbedDisplay />
+                </div>
             </div>
         </main>
     )
diff --git a/client/src/components/game/tabbed_display/item_details_tab/consumable_details/mod.rs b/client/src/components/game/tabbed_display/item_details_tab/consumable_details/mod.rs
new file mode 100644
index 00000000..99a9f833
--- /dev/null
+++ b/client/src/components/game/tabbed_display/item_details_tab/consumable_details/mod.rs
@@ -0,0 +1,56 @@
+use crate::components::game::tabbed_display::item_details_tab::requirements::requirements;
+use crate::components::game::tabbed_display::item_details_tab::unmet_requirements_calculator::UnmetRequirementsCalculator;
+use crate::store::game_store::GameStore;
+use common::combatants::combat_attributes::CombatAttributes;
+use common::items::consumables::ConsumableProperties;
+use std::collections::HashMap;
+use yew::prelude::*;
+use yewdux::prelude::use_store;
+
+#[derive(Properties, PartialEq)]
+pub struct Props {
+    pub consumable_properties: ConsumableProperties,
+    pub requirements: Option<HashMap<CombatAttributes, u8>>,
+    pub entity_id: u32,
+}
+
+#[function_component(ConsumableDetails)]
+pub fn consumable_details(props: &Props) -> Html {
+    let (game_state, _) = use_store::<GameStore>();
+
+    let cloned_game_state = game_state.clone();
+    let combat_action_properties = props
+        .consumable_properties
+        .consumable_type
+        .get_combat_action_properties();
+    let mut targeting_schemes_text = String::from("");
+    for (i, targeting_scheme) in combat_action_properties
+        .targeting_schemes
+        .iter()
+        .enumerate()
+    {
+        targeting_schemes_text.push_str(&format!("{}", targeting_scheme));
+        if i != combat_action_properties.targeting_schemes.len() - 1 {
+            targeting_schemes_text.push_str(", ");
+        }
+    }
+
+    html!(
+            <div>
+                <div>
+                    {"Valid targets: "}{combat_action_properties.valid_target_categories}
+                </div>
+                <div>
+                    {"Targeting schemes: "}{targeting_schemes_text}
+                </div>
+                <div>
+                    {"Usable "}{format!("{}", combat_action_properties.usability_context)}
+                </div>
+                {requirements(&props.requirements, cloned_game_state)}
+                <UnmetRequirementsCalculator
+                    equipment_requirements={props.requirements.clone()}
+                    entity_id={props.entity_id}
+                />
+            </div>
+    )
+}
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes.rs b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes.rs
deleted file mode 100644
index 84e89f98..00000000
--- a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use common::combatants::combat_attributes::CombatAttributes;
-use common::combatants::combat_attributes::CORE_ATTRIBUTES;
-use common::items::equipment::affixes::Affix;
-use common::items::equipment::EquipmentProperties;
-use yew::html;
-use yew::virtual_dom::VNode;
-
-fn attribute_bonus_text(name: &str, value: u16) -> String {
-    format!("+{value} {name}")
-}
-
-pub fn combat_attributes(equipment_properties: &EquipmentProperties) -> Vec<VNode> {
-    let mut displayed_attributes = Vec::new();
-
-    let mut attributes_as_vec = equipment_properties
-        .attributes
-        .clone()
-        .into_iter()
-        .collect::<Vec<(CombatAttributes, u16)>>();
-    attributes_as_vec.sort_by(move |a, b| a.0.partial_cmp(&b.0).unwrap());
-
-    // DISPLAY CORE CORE_ATTRIBUTES AS ONE LINE
-    // find out if it has all core attributes affix
-    if has_base_stats_affix(&equipment_properties.affixes) {
-        let mut cloned_attributes = equipment_properties.attributes.clone();
-        let cloned_attributes_as_vec = cloned_attributes
-            .clone()
-            .into_iter()
-            .collect::<Vec<(CombatAttributes, u16)>>();
-        let mut core_attribute_values = Vec::new();
-        for (attribute, value) in &cloned_attributes_as_vec {
-            for core_attribute in CORE_ATTRIBUTES {
-                if attribute == &core_attribute {
-                    core_attribute_values.push((attribute, value))
-                }
-            }
-        }
-        // calculate the lowest number of dex int str vit resil
-        let mut lowest_core_attribute_value = None;
-        for (_attribute, value) in &core_attribute_values {
-            if lowest_core_attribute_value.is_none() {
-                lowest_core_attribute_value = Some(value)
-            } else if lowest_core_attribute_value.expect("is_none checked") > value {
-                lowest_core_attribute_value = Some(value)
-            }
-        }
-        let lowest_core_attribute_value =
-            **lowest_core_attribute_value.expect("should be calculated above");
-
-        for (attribute, value) in core_attribute_values {
-            // if any number higher than the lowest, subtract the lowest from it
-            if value > &lowest_core_attribute_value {
-                let value_to_modify = cloned_attributes.get(&attribute).expect("");
-                let new_value = value_to_modify - lowest_core_attribute_value;
-                cloned_attributes.insert(*attribute, new_value);
-            }
-            // remove all base stats that tied for lowest
-            else {
-                cloned_attributes.remove(&attribute);
-            }
-        }
-        let mut cloned_attributes_as_vec = cloned_attributes
-            .clone()
-            .into_iter()
-            .collect::<Vec<(CombatAttributes, u16)>>();
-        cloned_attributes_as_vec.sort_by(move |a, b| a.0.partial_cmp(&b.0).unwrap());
-        for (attribute, value) in cloned_attributes_as_vec {
-            displayed_attributes.push(html!(
-            <div>
-            {attribute_bonus_text(&attribute.to_string(), value)}
-            </div>
-            ))
-        }
-        displayed_attributes.push(html!(
-        <div>
-            {attribute_bonus_text("to All Core Attributes", lowest_core_attribute_value)}
-        </div>
-        ))
-        // push "all base" and the lowest
-    } else {
-        attributes_as_vec = equipment_properties
-            .attributes
-            .clone()
-            .into_iter()
-            .collect::<Vec<(CombatAttributes, u16)>>();
-        attributes_as_vec.sort_by(move |a, b| a.0.partial_cmp(&b.0).unwrap());
-        for (attribute, value) in attributes_as_vec {
-            displayed_attributes.push(html!(
-            <div>
-            {attribute_bonus_text(&attribute.to_string(), value)}
-            </div>
-            ))
-        }
-    }
-
-    displayed_attributes
-}
-
-fn has_base_stats_affix(affixes: &Vec<Affix>) -> bool {
-    for affix in affixes {
-        match affix {
-            Affix::Suffix(affix_type, _) => match affix_type {
-                common::items::equipment::affixes::SuffixTypes::AllBase => return true,
-                _ => (),
-            },
-            _ => (),
-        }
-    }
-    false
-}
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes_and_traits.rs b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes_and_traits.rs
new file mode 100644
index 00000000..fc1552cd
--- /dev/null
+++ b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/combat_attributes_and_traits.rs
@@ -0,0 +1,227 @@
+use common::combatants::combat_attributes::CombatAttributes;
+use common::combatants::combat_attributes::CORE_ATTRIBUTES;
+use common::items::equipment::affixes::Affix;
+use common::items::equipment::affixes::PrefixTypes;
+use common::items::equipment::affixes::SuffixTypes;
+use common::items::equipment::EquipmentProperties;
+use common::items::equipment::EquipmentTraits;
+use gloo::console::log;
+use std::collections::VecDeque;
+use yew::html;
+use yew::virtual_dom::VNode;
+use yew::Html;
+
+pub fn combat_attributes_and_traits(equipment_properties: &EquipmentProperties) -> Vec<VNode> {
+    let mut equipment_mods_displays_in_prefix_suffix_order = VecDeque::new();
+    let lowest_core_attribute_value_option = get_lowest_core_attribute_value(equipment_properties);
+    let has_base_stats_affix = has_base_stats_affix(&equipment_properties.affixes);
+
+    for affix in &equipment_properties.affixes {
+        let text = match affix {
+            Affix::Prefix(prefix_type, tier) => match prefix_type {
+                PrefixTypes::Mp => format_bonus(equipment_properties, &CombatAttributes::Mp),
+                PrefixTypes::Accuracy => {
+                    format_bonus(equipment_properties, &CombatAttributes::Accuracy)
+                }
+                PrefixTypes::PercentDamage | PrefixTypes::LifeSteal => {
+                    log!(format!(
+                        "calling format trait for prefix type :{:?}",
+                        prefix_type
+                    ));
+                    format_trait(equipment_properties, affix).expect("to have this trait")
+                }
+                PrefixTypes::ArmorClass => format!("{}% increased armor class", tier * 10),
+                PrefixTypes::Resilience => {
+                    format_bonus(equipment_properties, &CombatAttributes::Resilience)
+                }
+                PrefixTypes::Evasion => {
+                    format_bonus(equipment_properties, &CombatAttributes::Evasion)
+                }
+                PrefixTypes::Obscurity => {
+                    format_bonus(equipment_properties, &CombatAttributes::Obscurity)
+                }
+                PrefixTypes::ArmorPenetration => {
+                    format_bonus(equipment_properties, &CombatAttributes::ArmorPenetration)
+                }
+                PrefixTypes::Agility => {
+                    format_bonus(equipment_properties, &CombatAttributes::Agility)
+                }
+            },
+            Affix::Suffix(_, _) => "".to_string(),
+        };
+        if text != "".to_string() {
+            equipment_mods_displays_in_prefix_suffix_order.push_back(text);
+        }
+    }
+    for affix in &equipment_properties.affixes {
+        let text = match affix {
+            Affix::Prefix(_, _) => "".to_string(),
+            Affix::Suffix(suffix_type, _) => match suffix_type {
+                SuffixTypes::Strength => format_core_attribute_bonus(
+                    equipment_properties,
+                    &CombatAttributes::Strength,
+                    has_base_stats_affix,
+                    lowest_core_attribute_value_option,
+                ),
+                SuffixTypes::Intelligence => format_core_attribute_bonus(
+                    equipment_properties,
+                    &CombatAttributes::Intelligence,
+                    has_base_stats_affix,
+                    lowest_core_attribute_value_option,
+                ),
+                SuffixTypes::Dexterity => format_core_attribute_bonus(
+                    equipment_properties,
+                    &CombatAttributes::Dexterity,
+                    has_base_stats_affix,
+                    lowest_core_attribute_value_option,
+                ),
+                SuffixTypes::Vitality => format_core_attribute_bonus(
+                    equipment_properties,
+                    &CombatAttributes::Vitality,
+                    has_base_stats_affix,
+                    lowest_core_attribute_value_option,
+                ),
+                SuffixTypes::AllBase => format!(
+                    "+{} to all core attributes",
+                    lowest_core_attribute_value_option.expect("to have core attribute bonuses")
+                ),
+                SuffixTypes::Hp => format_bonus(equipment_properties, &CombatAttributes::Hp),
+                SuffixTypes::Focus => format_bonus(equipment_properties, &CombatAttributes::Focus),
+                SuffixTypes::Damage => {
+                    format_bonus(equipment_properties, &CombatAttributes::Damage)
+                }
+                SuffixTypes::Durability => {
+                    format_trait(equipment_properties, affix).expect("to have this trait")
+                }
+            },
+        };
+        if text != "".to_string() {
+            equipment_mods_displays_in_prefix_suffix_order.push_back(text);
+        }
+    }
+
+    let mut displays: Vec<Html> = Vec::new();
+    while equipment_mods_displays_in_prefix_suffix_order.len() > 0 {
+        let display_text = equipment_mods_displays_in_prefix_suffix_order
+            .pop_front()
+            .expect("length checked above");
+        displays.push(html!(
+        <div>
+            {display_text}
+        </div>
+        ))
+    }
+
+    displays
+}
+
+fn format_bonus(
+    equipment_properties: &EquipmentProperties,
+    attribute: &CombatAttributes,
+) -> String {
+    let bonus = equipment_properties
+        .attributes
+        .get(attribute)
+        .expect("to have the attribute");
+    format!("+{bonus} {}", attribute)
+}
+
+fn format_core_attribute_bonus(
+    equipment_properties: &EquipmentProperties,
+    attribute: &CombatAttributes,
+    has_base_stats_affix: bool,
+    lowest_core_attribute_value_option: Option<u16>,
+) -> String {
+    let total_value = equipment_properties
+        .attributes
+        .get(attribute)
+        .expect("to have the attribute");
+    let value_not_including_all_base = if has_base_stats_affix {
+        if let Some(lowest_core_attribute_value) = lowest_core_attribute_value_option {
+            *total_value - lowest_core_attribute_value
+        } else {
+            *total_value
+        }
+    } else {
+        *total_value
+    };
+
+    format!("+{value_not_including_all_base} {}", attribute)
+}
+
+fn get_lowest_core_attribute_value(equipment_properties: &EquipmentProperties) -> Option<u16> {
+    let mut core_attribute_values = Vec::new();
+    for (attribute, value) in &equipment_properties.attributes {
+        for core_attribute in CORE_ATTRIBUTES {
+            if attribute == &core_attribute {
+                core_attribute_values.push((attribute, value))
+            }
+        }
+    }
+    let mut lowest_core_attribute_value_option = None;
+    for (_, value) in &core_attribute_values {
+        if let Some(lowest_value) = lowest_core_attribute_value_option {
+            if lowest_value > **value {
+                lowest_core_attribute_value_option = Some(**value)
+            }
+        } else {
+            lowest_core_attribute_value_option = Some(**value)
+        }
+    }
+    lowest_core_attribute_value_option
+}
+
+fn format_trait(equipment_properties: &EquipmentProperties, affix: &Affix) -> Option<String> {
+    for equipment_trait in equipment_properties
+        .traits
+        .as_ref()
+        .expect("to have traits")
+    {
+        match &affix {
+            Affix::Prefix(affix_type, _) => match affix_type {
+                PrefixTypes::PercentDamage => match equipment_trait {
+                    EquipmentTraits::DamagePercentage(_) => {
+                        return Some(format!("{}", equipment_trait))
+                    }
+                    _ => (),
+                },
+                PrefixTypes::LifeSteal => match equipment_trait {
+                    EquipmentTraits::LifeStealPercentage(_) => {
+                        return Some(format!("{}", equipment_trait))
+                    }
+                    _ => (),
+                },
+                PrefixTypes::ArmorClass => match equipment_trait {
+                    EquipmentTraits::ArmorClassPercentage(_) => {
+                        return Some(format!("{}", equipment_trait))
+                    }
+                    _ => (),
+                },
+                _ => (),
+            },
+            Affix::Suffix(affix_type, _) => match affix_type {
+                SuffixTypes::Durability => match equipment_trait {
+                    EquipmentTraits::DurabilityBonus(_) => {
+                        return Some(format!("{}", equipment_trait))
+                    }
+                    _ => (),
+                },
+                _ => (),
+            },
+        }
+    }
+    None
+}
+
+fn has_base_stats_affix(affixes: &Vec<Affix>) -> bool {
+    for affix in affixes {
+        match affix {
+            Affix::Suffix(affix_type, _) => match affix_type {
+                SuffixTypes::AllBase => return true,
+                _ => (),
+            },
+            _ => (),
+        }
+    }
+    false
+}
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 c2c79d70..48cf7ea3 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,21 +1,18 @@
-use std::collections::HashMap;
+use crate::components::game::tabbed_display::item_details_tab::equipment_details::equipment_durability::EquipmentDurability;
+use crate::components::game::tabbed_display::item_details_tab::requirements::requirements;
+use crate::components::game::tabbed_display::item_details_tab::unmet_requirements_calculator::UnmetRequirementsCalculator;
+use crate::store::game_store::GameStore;
 use self::armor::*;
-use self::unmet_requirements_calculator::UnmetRequirementsCalculator;
-use crate::{
-    components::game::tabbed_display::item_details_tab::equipment_details::equipment_durability::EquipmentDurability,
-    store::game_store::GameStore,
-};
 use common::combatants::combat_attributes::CombatAttributes;
 use common::items::equipment::EquipmentProperties;
+use std::collections::HashMap;
 use yew::prelude::*;
 use yewdux::prelude::use_store;
 mod armor;
-mod combat_attributes;
+mod combat_attributes_and_traits;
 mod equipment_durability;
-mod requirements;
-mod traits;
-mod unmet_requirements_calculator;
 mod weapon_damage;
+use self::combat_attributes_and_traits::combat_attributes_and_traits;
 
 #[derive(Properties, PartialEq)]
 pub struct Props {
@@ -49,9 +46,8 @@ pub fn equipment_details(props: &Props) -> Html {
                     durability_option={props.equipment_properties.durability.clone()}
                     equipment_type={props.equipment_properties.equipment_type.clone()}
                 />
-                {combat_attributes::combat_attributes(&props.equipment_properties)}
-                {traits::traits(&props.equipment_properties.traits)}
-                {requirements::requirements(&props.requirements, cloned_game_state)}
+                {combat_attributes_and_traits(&props.equipment_properties)}
+                {requirements(&props.requirements, cloned_game_state)}
                 {
                     if !props.is_compared_item {
                         html!(
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/traits.rs b/client/src/components/game/tabbed_display/item_details_tab/equipment_details/traits.rs
deleted file mode 100644
index 19234eb9..00000000
--- a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/traits.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use common::items::equipment::EquipmentTraits;
-use yew::{html, virtual_dom::VNode};
-
-pub fn traits(equipment_traits: &Option<Vec<EquipmentTraits>>) -> Vec<VNode> {
-    let mut trait_displays = Vec::new();
-    if let Some(traits) = equipment_traits {
-        for equipment_trait in traits {
-            let text = match equipment_trait {
-                EquipmentTraits::LifeStealPercentage(value) => {
-                    format!("Lifesteal: {value}%")
-                }
-                EquipmentTraits::DurabilityBonus(_) => format!("Increased durability"),
-                EquipmentTraits::ArmorClassPercentage(value) => format!("+{value}% Armor Class"),
-                EquipmentTraits::DamagePercentage(value) => format!("+{value}% Weapon damage"),
-                EquipmentTraits::RandomDamageTypeSelection => {
-                    format!("Damage type selected randomly")
-                }
-            };
-
-            trait_displays.push(html!(
-            <div>
-                {text}
-            </div>
-            ))
-        }
-    }
-
-    trait_displays
-}
diff --git a/client/src/components/game/tabbed_display/item_details_tab/mod.rs b/client/src/components/game/tabbed_display/item_details_tab/mod.rs
index 756076ae..a073c151 100644
--- a/client/src/components/game/tabbed_display/item_details_tab/mod.rs
+++ b/client/src/components/game/tabbed_display/item_details_tab/mod.rs
@@ -1,12 +1,16 @@
+mod consumable_details;
 mod equipment_details;
-use crate::{
-    components::game::tabbed_display::item_details_tab::equipment_details::EquipmentDetails,
-    store::{
-        game_store::{set_compared_item, GameStore},
-        ui_store::UIStore,
-    },
-};
-use common::items::{equipment::EquipmentSlots, Item};
+mod requirements;
+mod unmet_requirements_calculator;
+use crate::components::game::tabbed_display::item_details_tab::consumable_details::ConsumableDetails;
+use crate::components::game::tabbed_display::item_details_tab::equipment_details::EquipmentDetails;
+use crate::store::game_store::set_compared_item;
+use crate::store::game_store::GameStore;
+use crate::store::ui_store::UIStore;
+use common::items::equipment::EquipmentSlots;
+use common::items::equipment::EquipmentTypes;
+use common::items::Item;
+use common::items::ItemProperties;
 use std::rc::Rc;
 use yew::prelude::*;
 use yewdux::prelude::use_store;
@@ -49,15 +53,28 @@ pub fn item_details_tab(props: &Props) -> Html {
     };
 
     let display = match &props.item.item_properties {
-        common::items::ItemProperties::Consumable(_) => html!({ "Consumable item" }),
-        common::items::ItemProperties::Equipment(properties) => {
-            html!(<EquipmentDetails
-                  equipment_properties={properties.clone()}
-                  requirements={props.item.requirements.clone()}
-                  entity_id={item_id}
-                  is_compared_item={false}
-                  />)
+        ItemProperties::Consumable(properties) => html!(
+        <ConsumableDetails
+            consumable_properties={properties.clone()}
+            requirements={props.item.requirements.clone()}
+            entity_id={item_id}
+        />
+        ),
+        ItemProperties::Equipment(properties) => html!(
+        <EquipmentDetails
+              equipment_properties={properties.clone()}
+              requirements={props.item.requirements.clone()}
+              entity_id={item_id}
+              is_compared_item={false}
+        />
+              ),
+    };
+
+    let consumable_description_option = match &props.item.item_properties {
+        ItemProperties::Consumable(properties) => {
+            Some(properties.consumable_type.get_description())
         }
+        ItemProperties::Equipment(_) => None,
     };
 
     let compared_item_name = match &compared_item {
@@ -65,17 +82,20 @@ pub fn item_details_tab(props: &Props) -> Html {
         None => "",
     };
 
-    let compared_display_option = match &compared_item {
-        Some(compared_item) => match &compared_item.item_properties {
-            common::items::ItemProperties::Consumable(_) => None,
-            common::items::ItemProperties::Equipment(properties) => Some(html!(<EquipmentDetails
+    let compared_display_option = match props.item.item_properties {
+        ItemProperties::Consumable(_) => None,
+        ItemProperties::Equipment(_) => match &compared_item {
+            Some(compared_item) => match &compared_item.item_properties {
+                ItemProperties::Consumable(_) => None,
+                ItemProperties::Equipment(properties) => Some(html!(<EquipmentDetails
                       equipment_properties={properties.clone()}
                       requirements={compared_item.requirements.clone()}
                       entity_id={compared_item.entity_properties.id}
                       is_compared_item={true}
                       />)),
+            },
+            None => None,
         },
-        None => None,
     };
 
     html!(
@@ -103,6 +123,14 @@ pub fn item_details_tab(props: &Props) -> Html {
                 <div class="opacity-50 fill-slate-400 h-40 absolute bottom-5 right-3">
                     <img src="public/img/equipment-icons/1h-sword-a.svg" class="h-40 filter" />
                 </div>
+            } else if let Some(consumable_description) = consumable_description_option{
+                <div class="flex justify-between pr-2">
+                    {"Description"}
+                </div>
+                <div class="mr-2 mb-1 mt-1 h-[1px] bg-slate-400" />
+                <div>
+                    {consumable_description}
+                </div>
             }
             </div>
         </div>
@@ -114,11 +142,11 @@ fn should_display_mod_tooltip(game_state: &Rc<GameStore>, equipped_item: &Item)
         || game_state.compared_slot == Some(EquipmentSlots::MainHand)
     {
         match &equipped_item.item_properties {
-            common::items::ItemProperties::Consumable(_) => false,
-            common::items::ItemProperties::Equipment(equipment_properties) => {
+            ItemProperties::Consumable(_) => false,
+            ItemProperties::Equipment(equipment_properties) => {
                 match equipment_properties.equipment_type {
-                    common::items::equipment::EquipmentTypes::Ring => true,
-                    common::items::equipment::EquipmentTypes::OneHandedMeleeWeapon(_, _) => true,
+                    EquipmentTypes::Ring => true,
+                    EquipmentTypes::OneHandedMeleeWeapon(_, _) => true,
 
                     _ => false,
                 }
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/requirements.rs b/client/src/components/game/tabbed_display/item_details_tab/requirements.rs
similarity index 100%
rename from client/src/components/game/tabbed_display/item_details_tab/equipment_details/requirements.rs
rename to client/src/components/game/tabbed_display/item_details_tab/requirements.rs
diff --git a/client/src/components/game/tabbed_display/item_details_tab/equipment_details/unmet_requirements_calculator.rs b/client/src/components/game/tabbed_display/item_details_tab/unmet_requirements_calculator.rs
similarity index 100%
rename from client/src/components/game/tabbed_display/item_details_tab/equipment_details/unmet_requirements_calculator.rs
rename to client/src/components/game/tabbed_display/item_details_tab/unmet_requirements_calculator.rs
diff --git a/client/src/components/game/top_info_bar/mod.rs b/client/src/components/game/top_info_bar/mod.rs
index b5f97206..a17e13c9 100644
--- a/client/src/components/game/top_info_bar/mod.rs
+++ b/client/src/components/game/top_info_bar/mod.rs
@@ -2,7 +2,6 @@ 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;
 
@@ -12,64 +11,53 @@ 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)
+    html!(
+    <div class="h-10 w-full mb-4 border border-slate-400 bg-slate-700 flex justify-between" >
+    if let Some(party) = party_option {
+        <div class="p-2" >
+            {"Floor "}{party.current_floor}{", room "}{party.rooms_explored.on_current_floor}
+            {": "}
+            {format!("{}", party.current_room.room_type)}
+        </div>
+        if battle_option.is_some() { <TurnOrderBar /> }
+            else { <RoomExplorationTracker /> }
         } else {
-            cloned_top_bar_display_state.set(1)
+            <div>{"Error - no party found"}</div>
         }
-    });
-
-    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!(
-    <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 {
-                <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 )| {
-                            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)}
-                </div>
-            } else {
-                <div>{"Error - no party found"}</div>
-            }
     </div>
-    </button>
     )
 }
+
+#[function_component(RoomExplorationTracker)]
+fn room_exploration_tracker() -> Html {
+    let (game_state, _) = use_store::<GameStore>();
+    let party_option = get_current_party_option(&game_state);
+    if let Some(party) = party_option {
+        html!(
+        <ul class="list-none flex border-l border-slate-400" >
+            {party.client_current_floor_rooms_list
+                .iter()
+                .enumerate()
+                .map(|(i, room_type_option )| {
+                    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>
+        )
+    } else {
+        html!()
+    }
+}
diff --git a/client/src/components/game/turn_order_bar/mod.rs b/client/src/components/game/turn_order_bar/mod.rs
index 1ced74ca..d4a5ef97 100644
--- a/client/src/components/game/turn_order_bar/mod.rs
+++ b/client/src/components/game/turn_order_bar/mod.rs
@@ -32,8 +32,14 @@ pub fn turn_order_bar() -> Html {
     };
 
     html!(
-    <ul class="list-none flex" >
-        {bar_content}
-    </ul>
+        <div class="flex">
+            <div class="mr-4 flex justify-center items-center pr-2 pl-2 border-slate-400" >
+            {"Turn order: "}
+            </div>
+            <ul class="list-none flex border-l border-slate-400" >
+                {bar_content}
+            </ul>
+        </div>
+
     )
 }
diff --git a/client/src/components/lobby/game_list.rs b/client/src/components/lobby/game_list.rs
index 3eef7b71..ccd96d46 100644
--- a/client/src/components/lobby/game_list.rs
+++ b/client/src/components/lobby/game_list.rs
@@ -8,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 overflow-y-auto" id="game_list">
+        <section class="p-4 mr-4 bg-slate-700 border border-slate-400 overflow-y-auto flex-grow" 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/game_list_item.rs b/client/src/components/lobby/game_list_item.rs
index 99b4a4a9..7b2dd626 100644
--- a/client/src/components/lobby/game_list_item.rs
+++ b/client/src/components/lobby/game_list_item.rs
@@ -1,11 +1,8 @@
-use crate::{
-    components::{
-        common_components::atoms::button_basic::ButtonBasic,
-        websocket_manager::send_client_input::send_client_input,
-    },
-    store::websocket_store::WebsocketStore,
-};
-use common::packets::{client_to_server::PlayerInputs, server_to_client::GameListEntry};
+use crate::components::common_components::atoms::button_basic::ButtonBasic;
+use crate::components::websocket_manager::send_client_input::send_client_input;
+use crate::store::websocket_store::WebsocketStore;
+use common::packets::client_to_server::PlayerInputs;
+use common::packets::server_to_client::GameListEntry;
 use yew::prelude::*;
 use yewdux::prelude::*;
 
@@ -26,7 +23,7 @@ pub fn game_list_item(props: &GameListItemProps) -> Html {
     html!(
         <li class="w-full flex border border-slate-400 mb-4 justify-between">
             <div class="flex">
-                <div class="h-10 flex items-center w-20 border-r border-slate-400 pl-4">
+                <div class="h-10 flex items-center w-40 border-r border-slate-400 pl-4">
                     <div class="overflow-hidden whitespace-nowrap overflow-ellipsis">
                         {props.game.game_name.clone()}
                     </div>
diff --git a/client/src/components/lobby/game_setup/mod.rs b/client/src/components/lobby/game_setup/mod.rs
index e2b8774e..48337824 100644
--- a/client/src/components/lobby/game_setup/mod.rs
+++ b/client/src/components/lobby/game_setup/mod.rs
@@ -5,21 +5,20 @@ pub mod character_lobby_card;
 pub mod game_setup_menu;
 use yew::prelude::*;
 
-use crate::components::lobby::{
-    game_setup::{
-        character_and_party_selection::CharacterAndPartySelection, game_setup_menu::GameSetupMenu,
-    },
-    user_list::UserList,
-};
+use crate::components::lobby::game_setup::character_and_party_selection::CharacterAndPartySelection;
+use crate::components::lobby::game_setup::game_setup_menu::GameSetupMenu;
+use crate::components::lobby::user_list::UserList;
 
 #[function_component(GameSetup)]
 pub fn game_setup() -> Html {
     html!(
-        <main class="min-h-screen w-screen p-4 bg-teal-950 text-zinc-300 flex flex-col">
-            <GameSetupMenu/>
-            <div class="w-full flex flex-1">
-                <CharacterAndPartySelection />
-                <UserList/>
+        <main class="min-h-screen w-screen bg-slate-800 flex justify-center">
+            <div class="w-full max-w-[80rem] p-4 text-zinc-300 flex flex-col" >
+                <GameSetupMenu/>
+                <div class="w-full flex flex-1">
+                    <CharacterAndPartySelection />
+                    <UserList/>
+                </div>
             </div>
         </main>
     )
diff --git a/client/src/components/lobby/mod.rs b/client/src/components/lobby/mod.rs
index 43a8ce81..de926c21 100644
--- a/client/src/components/lobby/mod.rs
+++ b/client/src/components/lobby/mod.rs
@@ -13,14 +13,16 @@ use yew::prelude::*;
 #[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" >
-                <div class="w-full flex flex-col" >
-                    <WelcomeInfo />
-                    <GameList/>
+        <main class="min-h-screen max-h-screen w-screen bg-slate-800 text-zinc-300 justify-center overflow-y-auto">
+            <div class="p-4 h-screen max-h-screen max-w-[80rem] mx-auto flex flex-col" >
+                <LobbyMenu />
+                <div class="flex flex-grow" >
+                    <div class="flex flex-col" >
+                        <WelcomeInfo />
+                        <GameList/>
+                    </div>
+                    <UserList />
                 </div>
-                <UserList/>
             </div>
         </main>
     )
diff --git a/client/src/components/lobby/user_list.rs b/client/src/components/lobby/user_list.rs
index 7510e726..0b0f6aa9 100644
--- a/client/src/components/lobby/user_list.rs
+++ b/client/src/components/lobby/user_list.rs
@@ -8,7 +8,7 @@ pub fn user_list() -> Html {
     let lobby_channel = &websocket_state.websocket_channels.main;
 
     html!(
-        <section class="w-[16rem] bg-slate-700 border border-slate-400 p-4">
+        <section class="min-w-[16rem] w-[16rem] bg-slate-700 border border-slate-400 p-4">
             <h2 class="text-slate-200 text-l mb-2">
                 {"Channel: "} {lobby_channel.name.clone()}
             </h2>
diff --git a/client/src/components/lobby/welcome_info.rs b/client/src/components/lobby/welcome_info.rs
index 7f68abbd..6696e56a 100644
--- a/client/src/components/lobby/welcome_info.rs
+++ b/client/src/components/lobby/welcome_info.rs
@@ -9,10 +9,10 @@ pub fn welcome_info() -> Html {
         cloned_show_patch_notes_state.set(new_state);
     });
     html!(
-        <section class="flex-1 p-4 mb-4 mr-4 bg-slate-700 border border-slate-400 overflow-y-auto">
+        <section class="h-72 max-h-72 p-4 mb-4 mr-4 bg-slate-700 border border-slate-400 overflow-y-auto">
         <h3 class="text-lg">{"Roguelike Racing"}</h3>
         <button onclick={handle_show_patch_notes_click} class="mb-2">
-            {"alpha 0.3.0 ⓘ"}
+            {"alpha 0.4.0 ⓘ"}
         </button>
         if *show_patch_notes_state == false {
             <WelcomeMessage />
@@ -27,30 +27,53 @@ pub fn welcome_info() -> Html {
 fn welcome_message() -> Html {
     html!(
         <>
-    <p>{"0.3.0 1/26/2024"}</p>
-    <p>{"Fixed bugs:"}</p>
+    <p class="font-bold" >{"0.4.0 2/4/2024"}</p>
+    <p class="underline" >{"Fixed bugs:"}</p>
+    <ul class="list-disc list-inside mb-1">
+        <li>{"The info bar now has a proper home and does not block other UI elements"}</li>
+        <li>{"Dead combatants no longer attack"}</li>
+        <li>{"Maximum UI dimensions set to 1280px x 1080px relative to root element"}</li>
+        <li>{"UI elements should no longer resize their neighbors in strange ways"}</li>
+        <li>{"Changing focused character with inventory open sets page to 0 to avoid viewing empty pages"}</li>
+        <li>{"Focus should properly switch to the active character when the active status was previously held by a monster"}</li>
+        <li>{"Equipment properties are now displayed in order of prefix first, suffix second"}</li>
+    </ul>
+    <p class="underline" >{"Added features:"}</p>
+    <ul class="list-disc list-inside mb-2">
+        <li>{"A system for using consumable items"}</li>
+        <li>{"A system for using actions out of combat"}</li>
+        <li>{"New consumable, 'HP Autoinjector'"}</li>
+        <li>{"Combatants may now evade attacks based on their evasion vs. the attacker's accuracy"}</li>
+        <li>{"Items on the ground may now be hovered to view their details"}</li>
+        <li>{"Turn order system rebuilt"}</li>
+        <li>{"Page numbers now show in the action menu"}</li>
+        <li>{"The action menu is now scrollable with mousewheel action if the element is not overflowing"}</li>
+        <li>{"The party may now be defeated if monsters go first in combat and kill the last party member"}</li>
+    </ul>
+    <p class="font-bold" >{"0.3.0 1/26/2024"}</p>
+    <p class="underline" >{"Fixed bugs:"}</p>
     <ul class="list-disc list-inside mb-1">
         <li>{"Opening the inventory while combat animations were playing would cause the client to desync"}</li>
         <li>{"Focus now shifts to the active character at the beginning of combat if not in the inventory"}</li>
     </ul>
-    <p>{"Added features:"}</p>
+    <p class="underline" >{"Added features:"}</p>
     <ul class="list-disc list-inside mb-1">
         <li>{"Color coded messages now display in the combat log when any party in a game descends to a new floor, escapes the dungeon or wipes"}</li>
         <li>{"Version history now shows dates"}</li>
     </ul>
-    <p>{"0.2.1 1/25/2024"}</p>
-    <ul class="list-disc list-inside mb-1">
+    <p class="font-bold" >{"0.2.1 1/25/2024"}</p>
+    <ul class="list-disc list-inside mb-2">
         <li>{"Added patch notes section to welcome info"}</li>
         <li>{"Fixed a bug where the room exploration tracker wouldn't work on any floor except the first"}</li>
     </ul>
-    <p>{"0.2.0 1/24/2024"}</p>
-    <p>{"Fixed bugs:"}</p>
+    <p class="font-bold" >{"0.2.0 1/24/2024"}</p>
+    <p class="underline" >{"Fixed bugs:"}</p>
     <ul class="list-disc list-inside mb-1">
         <li>{"Players couldn't attack while wearing a shield"}</li>
         <li>{"Unequipping an item would not change focus to the unequipped item"}</li>
     </ul>
-    <p>{"Added features:"}</p>
-    <ul class="list-disc list-inside mb-1">
+    <p class="underline" >{"Added features:"}</p>
+    <ul class="list-disc list-inside mb-2">
         <li>{"Stairs down now appear in the dungeon and players can vote to keep exploring the current floor or descend to the next one"}</li>
         <li>{"An explored rooms tracker now appears as part of the top info bar"}</li>
         <li>{"The top info bar can be re positioned by clicking on it"}</li>
diff --git a/client/src/components/mesh_manager/mod.rs b/client/src/components/mesh_manager/mod.rs
index c1a05006..b3c95925 100644
--- a/client/src/components/mesh_manager/mod.rs
+++ b/client/src/components/mesh_manager/mod.rs
@@ -6,6 +6,19 @@ use std::collections::VecDeque;
 use std::fmt::Display;
 use yew::AttrValue;
 
+#[derive(PartialEq, Clone, Debug)]
+pub enum AutoinjectorTypes {
+    Hp,
+}
+
+impl Display for AutoinjectorTypes {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        match self {
+            AutoinjectorTypes::Hp => write!(f, "HP"),
+        }
+    }
+}
+
 #[derive(PartialEq, Clone, Debug)]
 pub enum CombatantAnimation {
     TurnToFaceCombatant(u32),
@@ -14,10 +27,11 @@ pub enum CombatantAnimation {
     SwingOffHandToHit,
     MainHandFollowThroughSwing,
     OffHandFollowThroughSwing,
-    ReturnToReadyPosition,
+    ReturnToReadyPosition(bool), // Ends turn
     HitRecovery(i16),
     Death(Option<i16>),
     Evasion,
+    UseAutoinjector(AutoinjectorTypes, u32, i16),
 }
 
 impl Display for CombatantAnimation {
@@ -34,10 +48,15 @@ impl Display for CombatantAnimation {
             CombatantAnimation::SwingOffHandToHit => format!("swung offhand to hit"),
             CombatantAnimation::MainHandFollowThroughSwing => format!("main hand follow through"),
             CombatantAnimation::OffHandFollowThroughSwing => format!("off hand follow through"),
-            CombatantAnimation::ReturnToReadyPosition => format!("returing to ready position"),
+            CombatantAnimation::ReturnToReadyPosition(_ends_turn) => {
+                format!("returing to ready position")
+            }
             CombatantAnimation::HitRecovery(hp_change) => format!("hit recovery {hp_change}"),
             CombatantAnimation::Death(hp_change) => format!("death {:?}", hp_change),
             CombatantAnimation::Evasion => format!("evaded"),
+            CombatantAnimation::UseAutoinjector(autoinjector_type, _user_id, hp_change) => {
+                format!("using autoinjector ({autoinjector_type}, {hp_change})")
+            }
         };
         write!(f, "{:?}", to_write)
     }
@@ -56,6 +75,7 @@ pub struct CombatantEventManager {
     pub animation_queue: VecDeque<CombatantAnimation>,
     pub floating_numbers_queue: VecDeque<FloatingNumber>,
     pub visual_location: CombatantVisualLocation,
+    pub last_processed_action_ended_turn: bool,
 }
 
 #[derive(PartialEq, Clone)]
@@ -72,6 +92,7 @@ impl CombatantEventManager {
             animation_queue: vec![].into(),
             floating_numbers_queue: vec![].into(),
             visual_location: CombatantVisualLocation::HomePosition,
+            last_processed_action_ended_turn: false,
         }
     }
 }
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
index 7460a41d..b016ae96 100644
--- a/client/src/components/websocket_manager/dungeon_floor_number_changed_handler.rs
+++ b/client/src/components/websocket_manager/dungeon_floor_number_changed_handler.rs
@@ -1,6 +1,5 @@
 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(
diff --git a/client/src/components/websocket_manager/handle_character_dropped_item.rs b/client/src/components/websocket_manager/handle_character_dropped_item.rs
index 07183f75..d74468a4 100644
--- a/client/src/components/websocket_manager/handle_character_dropped_item.rs
+++ b/client/src/components/websocket_manager/handle_character_dropped_item.rs
@@ -21,7 +21,7 @@ pub fn handle_character_dropped_item(
 
     game_dispatch.reduce_mut(|store| -> Result<(), AppError> {
         let character = store.get_mut_character(packet.character_id)?;
-        let item = character.inventory.remove_item(packet.item_id)?;
+        let item = character.combatant_properties.inventory.remove_item(packet.item_id)?;
         let party = store.get_current_party_mut()?;
         party.current_room.items.push(item);
         Ok(())
diff --git a/client/src/components/websocket_manager/handle_character_picked_up_item.rs b/client/src/components/websocket_manager/handle_character_picked_up_item.rs
index 828f8594..4e4e761e 100644
--- a/client/src/components/websocket_manager/handle_character_picked_up_item.rs
+++ b/client/src/components/websocket_manager/handle_character_picked_up_item.rs
@@ -11,7 +11,7 @@ pub fn handle_character_picked_up_item(
         let party = store.get_current_party_mut()?;
         let item_picked_up = party.remove_item_from_ground(packet.item_id)?;
         let character = store.get_mut_character(packet.character_id)?;
-        character.inventory.items.push(item_picked_up);
+        character.combatant_properties.inventory.items.push(item_picked_up);
 
         Ok(())
     })
diff --git a/client/src/components/websocket_manager/handle_packet.rs b/client/src/components/websocket_manager/handle_packet.rs
index 1c075541..a73b7914 100644
--- a/client/src/components/websocket_manager/handle_packet.rs
+++ b/client/src/components/websocket_manager/handle_packet.rs
@@ -10,9 +10,11 @@ use super::handle_character_dropped_equipped_item::handle_character_dropped_equi
 use super::handle_character_dropped_item::handle_character_dropped_item;
 use super::handle_character_picked_up_item::handle_character_picked_up_item;
 use super::handle_combat_turn_results::handle_combat_turn_results;
+use super::handle_raw_action_results::handle_raw_action_results;
 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_character_consumable_selection;
 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;
@@ -36,17 +38,16 @@ use common::app_consts::error_messages;
 use common::errors::AppError;
 use common::packets::server_to_client::GameServerUpdatePackets;
 use gloo::console::log;
-use std::rc::Rc;
 use yewdux::prelude::Dispatch;
 
 pub fn handle_packet(
     data: GameServerUpdatePackets,
     alert_dispatch: Dispatch<AlertStore>,
     lobby_dispatch: Dispatch<LobbyStore>,
-    lobby_state: Rc<LobbyStore>,
     game_dispatch: Dispatch<GameStore>,
     websocket_dispatch: Dispatch<WebsocketStore>,
 ) -> Result<(), AppError> {
+    // log!(format!("data from server: {:#?}", data));
     match data {
         GameServerUpdatePackets::Error(message) => {
             log!(format!("received error from server: {message}"));
@@ -56,9 +57,6 @@ pub fn handle_packet(
             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) => {
@@ -127,10 +125,15 @@ pub fn handle_packet(
         GameServerUpdatePackets::CharacterSelectedAbility(packet) => {
             game_dispatch.reduce_mut(|store| handle_character_ability_selection(store, packet))
         }
+        GameServerUpdatePackets::CharacterSelectedConsumable(packet) => {
+            handle_character_consumable_selection(game_dispatch, packet)
+        }
         GameServerUpdatePackets::CharacterChangedTargets(packet) => {
             game_dispatch.reduce_mut(|store| handle_character_changed_targets(store, packet))
         }
-        GameServerUpdatePackets::ActionResults(_) => todo!(),
+        GameServerUpdatePackets::ActionResults(packet) => {
+            handle_raw_action_results(game_dispatch, packet)
+        }
         GameServerUpdatePackets::CombatTurnResults(packet) => {
             handle_combat_turn_results(game_dispatch, packet.turn_results)
         }
diff --git a/client/src/components/websocket_manager/handle_raw_action_results.rs b/client/src/components/websocket_manager/handle_raw_action_results.rs
new file mode 100644
index 00000000..59506b7a
--- /dev/null
+++ b/client/src/components/websocket_manager/handle_raw_action_results.rs
@@ -0,0 +1,26 @@
+use crate::store::game_store::GameStore;
+use common::app_consts::error_messages;
+use common::errors::AppError;
+use common::packets::server_to_client::ActionResultsPacket;
+use yewdux::Dispatch;
+
+pub fn handle_raw_action_results(
+    game_dispatch: Dispatch<GameStore>,
+    packet: ActionResultsPacket,
+) -> Result<(), AppError> {
+    game_dispatch.reduce_mut(|store| {
+        for action_result in packet.action_results {
+            store
+                .action_results_manager
+                .combantant_event_managers
+                .get_mut(&packet.action_taker_id)
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ClientError,
+                    message: error_messages::COMBANTANT_EVENT_MANAGER_NOT_FOUND.to_string(),
+                })?
+                .action_result_queue
+                .push_back(action_result);
+        }
+        Ok(())
+    })
+}
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 655892dc..d6d8fa98 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
@@ -8,6 +8,7 @@ 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 common::packets::server_to_client::CharacterSelectedConsumablePacket;
 use gloo::console::log;
 use std::collections::HashMap;
 use std::collections::VecDeque;
@@ -131,10 +132,32 @@ pub fn handle_character_ability_selection(
 
     let character = game_store.get_mut_character(character_id)?;
     character.combatant_properties.selected_ability_name = ability_name_option;
-    character.combatant_properties.ability_targets = targets_option;
+    character.combatant_properties.combat_action_targets = targets_option;
     Ok(())
 }
 
+pub fn handle_character_consumable_selection(
+    game_dispatch: Dispatch<GameStore>,
+    packet: CharacterSelectedConsumablePacket,
+) -> Result<(), AppError> {
+    log!(format!(
+        "selected consumable packet received {:#?}",
+        &packet
+    ));
+    let CharacterSelectedConsumablePacket {
+        character_id,
+        targets_option,
+        consumable_id_option,
+    } = packet;
+
+    game_dispatch.reduce_mut(|store| {
+        let character = store.get_mut_character(character_id)?;
+        character.combatant_properties.selected_consumable = consumable_id_option;
+        character.combatant_properties.combat_action_targets = targets_option;
+        Ok(())
+    })
+}
+
 pub fn handle_character_changed_targets(
     game_store: &mut GameStore,
     packet: ChangeTargetsPacket,
@@ -144,7 +167,7 @@ pub fn handle_character_changed_targets(
         new_targets,
     } = packet;
     let character = game_store.get_mut_character(character_id)?;
-    character.combatant_properties.ability_targets = Some(new_targets.clone());
+    character.combatant_properties.combat_action_targets = Some(new_targets.clone());
 
     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 d7e81463..a76122a9 100644
--- a/client/src/components/websocket_manager/inventory_management_update_handlers.rs
+++ b/client/src/components/websocket_manager/inventory_management_update_handlers.rs
@@ -9,7 +9,6 @@ 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,
@@ -21,22 +20,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 unequipped_item_ids = character
+        .combatant_properties
+        .equip_item(item_id, alt_slot)?;
     let item_to_select = match unequipped_item_ids.get(0) {
         Some(id) => {
             let mut item = None;
-            for item_in_inventory in &character.inventory.items {
+            for item_in_inventory in &character.combatant_properties.inventory.items {
                 if item_in_inventory.entity_properties.id == *id {
                     item = Some(item_in_inventory.clone())
                 }
@@ -46,16 +41,9 @@ 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;
@@ -73,7 +61,9 @@ pub fn handle_character_unequipped_slot(
 ) -> Result<(), AppError> {
     let CharacterAndSlot { character_id, slot } = packet;
     let character = game_store.get_mut_character(character_id)?;
-    character.unequip_slots(&vec![slot], false);
+    character
+        .combatant_properties
+        .unequip_slots(&vec![slot], false);
     Ok(())
 }
 
diff --git a/client/src/components/websocket_manager/mod.rs b/client/src/components/websocket_manager/mod.rs
index c97511ed..ca760af5 100644
--- a/client/src/components/websocket_manager/mod.rs
+++ b/client/src/components/websocket_manager/mod.rs
@@ -7,6 +7,7 @@ mod handle_character_dropped_item;
 mod handle_character_picked_up_item;
 pub mod handle_combat_turn_results;
 mod handle_packet;
+mod handle_raw_action_results;
 mod in_game_party_update_handlers;
 mod inventory_management_update_handlers;
 mod lobby_update_handlers;
@@ -39,7 +40,7 @@ pub struct CustomFormData {}
 #[function_component(WebsocketManager)]
 pub fn websocket_manager(props: &Props) -> Html {
     let (_, websocket_dispatch) = use_store::<WebsocketStore>();
-    let (lobby_state, lobby_dispatch) = use_store::<LobbyStore>();
+    let (_, lobby_dispatch) = use_store::<LobbyStore>();
     let (_, game_dispatch) = use_store::<GameStore>();
     let (_, alert_dispatch) = use_store::<AlertStore>();
     let server_url = props.server_url.clone();
@@ -66,7 +67,6 @@ pub fn websocket_manager(props: &Props) -> Html {
                             if let Ok(data) = deserialized {
                                 let cloned_alert_dispatch = alert_dispatch.clone();
                                 let cloned_lobby_dispatch = lobby_dispatch.clone();
-                                let cloned_lobby_state = lobby_state.clone();
                                 let cloned_game_dispatch = game_dispatch.clone();
                                 let cloned_websocket_dispatch = cloned_websocket_dispatch.clone();
 
@@ -74,7 +74,6 @@ pub fn websocket_manager(props: &Props) -> Html {
                                     data,
                                     cloned_alert_dispatch,
                                     cloned_lobby_dispatch,
-                                    cloned_lobby_state,
                                     cloned_game_dispatch,
                                     cloned_websocket_dispatch,
                                 )?
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 6721a09a..ba80f4be 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -9,7 +9,6 @@ use crate::components::lobby::game_setup::GameSetup;
 use crate::components::lobby::Lobby;
 use crate::components::websocket_manager::WebsocketManager;
 use crate::store::game_store::GameStore;
-use gloo::console::log;
 use yew::prelude::*;
 use yewdux::prelude::*;
 
diff --git a/client/src/store/game_store.rs b/client/src/store/game_store.rs
index b3fb75f9..37c7b38a 100644
--- a/client/src/store/game_store.rs
+++ b/client/src/store/game_store.rs
@@ -14,6 +14,7 @@ use common::items::equipment::EquipmentSlots;
 use common::items::Item;
 use common::packets::server_to_client::BattleEndReportPacket;
 use common::primatives::EntityProperties;
+use gloo::console::log;
 use std::collections::HashSet;
 use std::rc::Rc;
 use yewdux::prelude::*;
@@ -217,6 +218,10 @@ pub fn select_item(game_dispatch: Dispatch<GameStore>, item_option: Option<Item>
         store
             .parent_menu_pages
             .push(store.action_menu_current_page_number);
+        log!(format!(
+            "pushed to parent page number {:?}",
+            store.parent_menu_pages
+        ));
         store.action_menu_current_page_number = 0;
     })
 }
@@ -295,7 +300,25 @@ pub fn get_item_owned_by_focused_character(
         }
     }
 
-    for item in &character.inventory.items {
+    for item in &character.combatant_properties.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(),
+    });
+}
+
+pub fn get_item_on_ground(id: &u32, game_state: Rc<GameStore>) -> Result<Item, AppError> {
+    let party = get_current_party_option(&game_state).ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::ClientError,
+        message: error_messages::PARTY_NOT_FOUND.to_string(),
+    })?;
+
+    for item in &party.current_room.items {
         if item.entity_properties.id == *id {
             return Ok(item.clone());
         }
diff --git a/client/style/output.css b/client/style/output.css
index 4ae118f1..582e8c7d 100644
--- a/client/style/output.css
+++ b/client/style/output.css
@@ -554,14 +554,26 @@ video {
   right: -0.5rem;
 }
 
+.bottom-0 {
+  bottom: 0px;
+}
+
 .bottom-5 {
   bottom: 1.25rem;
 }
 
+.left-0 {
+  left: 0px;
+}
+
 .left-1\/2 {
   left: 50%;
 }
 
+.right-0 {
+  right: 0px;
+}
+
 .right-3 {
   right: 0.75rem;
 }
@@ -578,16 +590,8 @@ video {
   top: -1.5rem;
 }
 
-.bottom-0 {
-  bottom: 0px;
-}
-
-.left-0 {
-  left: 0px;
-}
-
-.right-0 {
-  right: 0px;
+.bottom-\[-1\.5rem\] {
+  bottom: -1.5rem;
 }
 
 .z-10 {
@@ -610,8 +614,9 @@ video {
   margin: 0px;
 }
 
-.m-2 {
-  margin: 0.5rem;
+.mx-auto {
+  margin-left: auto;
+  margin-right: auto;
 }
 
 .mb-1 {
@@ -654,6 +659,22 @@ video {
   margin-top: 0.5rem;
 }
 
+.mt-4 {
+  margin-top: 1rem;
+}
+
+.mb-\[1px\] {
+  margin-bottom: 1px;
+}
+
+.box-border {
+  box-sizing: border-box;
+}
+
+.block {
+  display: block;
+}
+
 .inline-block {
   display: inline-block;
 }
@@ -662,18 +683,10 @@ video {
   display: flex;
 }
 
-.list-item {
-  display: list-item;
-}
-
 .h-0 {
   height: 0px;
 }
 
-.h-1\/2 {
-  height: 50%;
-}
-
 .h-10 {
   height: 2.5rem;
 }
@@ -694,6 +707,14 @@ video {
   height: 1px;
 }
 
+.h-\[40\%\] {
+  height: 40%;
+}
+
+.h-\[60\%\] {
+  height: 60%;
+}
+
 .h-full {
   height: 100%;
 }
@@ -702,18 +723,54 @@ video {
   height: 100vh;
 }
 
-.max-h-\[453px\] {
-  max-height: 453px;
+.h-1\/2 {
+  height: 50%;
+}
+
+.h-72 {
+  height: 18rem;
 }
 
 .max-h-full {
   max-height: 100%;
 }
 
+.max-h-\[45rem\] {
+  max-height: 45rem;
+}
+
+.max-h-\[67\.5rem\] {
+  max-height: 67.5rem;
+}
+
+.max-h-10 {
+  max-height: 2.5rem;
+}
+
+.max-h-40 {
+  max-height: 10rem;
+}
+
+.max-h-\[50\%\] {
+  max-height: 50%;
+}
+
+.max-h-screen {
+  max-height: 100vh;
+}
+
+.max-h-72 {
+  max-height: 18rem;
+}
+
 .min-h-screen {
   min-height: 100vh;
 }
 
+.min-h-\[2\.5rem\] {
+  min-height: 2.5rem;
+}
+
 .w-0 {
   width: 0px;
 }
@@ -746,12 +803,16 @@ video {
   width: 16rem;
 }
 
-.w-\[1px\] {
-  width: 1px;
+.w-\[20\%\] {
+  width: 20%;
+}
+
+.w-\[22rem\] {
+  width: 22rem;
 }
 
-.w-\[350px\] {
-  width: 350px;
+.w-\[40\%\] {
+  width: 40%;
 }
 
 .w-full {
@@ -766,8 +827,12 @@ video {
   min-width: 2.5rem !important;
 }
 
-.min-w-\[350px\] {
-  min-width: 350px;
+.min-w-\[16rem\] {
+  min-width: 16rem;
+}
+
+.max-w-\[80rem\] {
+  max-width: 80rem;
 }
 
 .max-w-fit {
@@ -779,6 +844,10 @@ video {
   max-width: 100%;
 }
 
+.max-w-\[50\%\] {
+  max-width: 50%;
+}
+
 .flex-1 {
   flex: 1 1 0%;
 }
@@ -831,6 +900,10 @@ video {
   animation: slide-left-appear-keyframes .3s linear;
 }
 
+.cursor-default {
+  cursor: default;
+}
+
 .cursor-help {
   cursor: help;
 }
@@ -839,18 +912,22 @@ video {
   cursor: pointer;
 }
 
-.list-inside {
-  list-style-position: inside;
+.resize {
+  resize: both;
 }
 
-.list-none {
-  list-style-type: none;
+.list-inside {
+  list-style-position: inside;
 }
 
 .list-disc {
   list-style-type: disc;
 }
 
+.list-none {
+  list-style-type: none;
+}
+
 .flex-col {
   flex-direction: column;
 }
@@ -879,6 +956,10 @@ video {
   justify-content: space-between;
 }
 
+.overflow-auto {
+  overflow: auto;
+}
+
 .overflow-hidden {
   overflow: hidden;
 }
@@ -887,10 +968,6 @@ video {
   overflow-y: auto;
 }
 
-.overflow-y-scroll {
-  overflow-y: scroll;
-}
-
 .overflow-ellipsis {
   text-overflow: ellipsis;
 }
@@ -993,6 +1070,16 @@ video {
   border-color: rgb(212 212 216 / var(--tw-border-opacity));
 }
 
+.border-blue-700 {
+  --tw-border-opacity: 1;
+  border-color: rgb(29 78 216 / var(--tw-border-opacity));
+}
+
+.border-green-700 {
+  --tw-border-opacity: 1;
+  border-color: rgb(21 128 61 / var(--tw-border-opacity));
+}
+
 .border-l-transparent {
   border-left-color: transparent;
 }
@@ -1001,6 +1088,11 @@ video {
   border-right-color: transparent;
 }
 
+.border-t-green-600 {
+  --tw-border-opacity: 1;
+  border-top-color: rgb(22 163 74 / var(--tw-border-opacity));
+}
+
 .border-t-yellow-700 {
   --tw-border-opacity: 1;
   border-top-color: rgb(161 98 7 / var(--tw-border-opacity));
@@ -1026,11 +1118,6 @@ video {
   background-color: rgb(173 37 47 / var(--tw-bg-opacity));
 }
 
-.bg-gray-600 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(75 85 99 / var(--tw-bg-opacity));
-}
-
 .bg-green-700 {
   --tw-bg-opacity: 1;
   background-color: rgb(21 128 61 / var(--tw-bg-opacity));
@@ -1076,11 +1163,6 @@ video {
   background-color: rgb(30 41 59 / var(--tw-bg-opacity));
 }
 
-.bg-teal-950 {
-  --tw-bg-opacity: 1;
-  background-color: rgb(4 47 46 / var(--tw-bg-opacity));
-}
-
 .bg-waterblue {
   --tw-bg-opacity: 1;
   background-color: rgb(51 46 146 / var(--tw-bg-opacity));
@@ -1096,6 +1178,11 @@ video {
   background-color: rgb(212 212 216 / var(--tw-bg-opacity));
 }
 
+.bg-blue-700 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(29 78 216 / var(--tw-bg-opacity));
+}
+
 .fill-red-500 {
   fill: #ef4444;
 }
@@ -1172,9 +1259,9 @@ video {
   color: rgb(37 99 235 / var(--tw-text-opacity));
 }
 
-.text-green-400 {
+.text-green-600 {
   --tw-text-opacity: 1;
-  color: rgb(74 222 128 / var(--tw-text-opacity));
+  color: rgb(22 163 74 / var(--tw-text-opacity));
 }
 
 .text-red-400 {
@@ -1202,24 +1289,18 @@ video {
   color: rgb(47 170 54 / var(--tw-text-opacity));
 }
 
-.text-zinc-300 {
-  --tw-text-opacity: 1;
-  color: rgb(212 212 216 / var(--tw-text-opacity));
-}
-
 .text-yellow-400 {
   --tw-text-opacity: 1;
   color: rgb(250 204 21 / var(--tw-text-opacity));
 }
 
-.text-green-700 {
+.text-zinc-300 {
   --tw-text-opacity: 1;
-  color: rgb(21 128 61 / var(--tw-text-opacity));
+  color: rgb(212 212 216 / var(--tw-text-opacity));
 }
 
-.text-green-600 {
-  --tw-text-opacity: 1;
-  color: rgb(22 163 74 / var(--tw-text-opacity));
+.underline {
+  text-decoration-line: underline;
 }
 
 .opacity-50 {
@@ -1230,6 +1311,14 @@ video {
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
 
+.first\:border-t:first-child {
+  border-top-width: 1px;
+}
+
+.first\:border-l:first-child {
+  border-left-width: 1px;
+}
+
 .last\:mb-0:last-child {
   margin-bottom: 0px;
 }
@@ -1242,6 +1331,15 @@ video {
   border-right-width: 0px;
 }
 
+.hover\:border-t:hover {
+  border-top-width: 1px;
+}
+
+.hover\:border-yellow-400:hover {
+  --tw-border-opacity: 1;
+  border-color: rgb(250 204 21 / var(--tw-border-opacity));
+}
+
 .hover\:bg-slate-950:hover {
   --tw-bg-opacity: 1;
   background-color: rgb(2 6 23 / var(--tw-bg-opacity));
diff --git a/common/src/adventuring_party/generate_unexplored_rooms_queue.rs b/common/src/adventuring_party/generate_unexplored_rooms_queue.rs
index 3ecf37b6..8cec4205 100644
--- a/common/src/adventuring_party/generate_unexplored_rooms_queue.rs
+++ b/common/src/adventuring_party/generate_unexplored_rooms_queue.rs
@@ -7,8 +7,8 @@ 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;
+        let monster_lairs_per_floor = 3;
+        let empty_rooms_per_floor = 0;
 
         self.unexplored_rooms.clear();
         self.rooms_explored.on_current_floor += 1;
diff --git a/common/src/adventuring_party/mod.rs b/common/src/adventuring_party/mod.rs
index 57645822..7010c6d8 100644
--- a/common/src/adventuring_party/mod.rs
+++ b/common/src/adventuring_party/mod.rs
@@ -79,7 +79,7 @@ impl AdventuringParty {
                     return Some(item);
                 }
             }
-            for item in &character.inventory.items {
+            for item in &character.combatant_properties.inventory.items {
                 if item.entity_properties.id == id {
                     return Some(item);
                 }
diff --git a/common/src/app_consts/error_messages.rs b/common/src/app_consts/error_messages.rs
index 80b37c16..67716476 100644
--- a/common/src/app_consts/error_messages.rs
+++ b/common/src/app_consts/error_messages.rs
@@ -27,6 +27,7 @@ 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 CANT_CONSUME_NON_CONSUMABLE_ITEM: &str = "Only consumable items may be consumed";
 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";
@@ -37,6 +38,7 @@ pub const TRIED_TO_DROP_ITEM_FROM_AN_EMPTY_SLOT: &str =
 pub const DROP_EQUIPPED_ITEM_SERVER_PACKET_MISMATCH: &str =
     "Received a packet telling a character to drop an equipped item but the item wasn't found";
 pub const NO_BASE_EQUIPMENT_FOUND: &str = "No base equipment was provided";
+pub const NO_CONSUMABLE_SELECTED: &str = "No consumable is selected";
 // COMBATANTS
 pub const ENEMY_COMBATANTS_NOT_FOUND: &str = "No enemy combatants found";
 pub const ALLY_COMBATANTS_NOT_FOUND: &str = "No allied combatants found";
@@ -47,15 +49,21 @@ pub const NO_ABILITY_SELECTED: &str = "No ability is selected";
 pub const MISSING_ABILITY_REFERENCE: &str = "The character has no ability selected";
 pub const ABILITY_HAS_NO_TARGETING_SCHEME: &str = "The selected ability has no targeting scheme";
 pub const INVALID_ABILITY_CONTEXT: &str = "The selected ability can not be used in this context";
+pub const ALREADY_FULL_HP: &str = "The target is already at full HP";
+// COMBAT ACTIONS
+pub const INVALID_ACTION_TYPE: &str = "Invalid action type";
+pub const MISSING_EXPECTED_ACTION_RESULT_DATA: &str = "An action result missing expected data";
+pub const CANT_BE_USED_ON_DEAD_TARGET: &str =
+    "The selected target is beyond the help of this ability";
 // TARGETING
 pub const NO_POSSIBLE_TARGETS_PROVIDED: &str =
-    "No possible targets were found for the selected ability";
+    "No possible targets were found for the selected action";
 pub const TRIED_TO_CYCLE_TARGETS_WHEN_NO_TARGETS: &str =
     "Client tried to cycle targets but they weren't targeting anything";
-pub const NO_TARGETING_SCHEMES: &str = "The selected ability has no targeting schemes";
+pub const NO_TARGETING_SCHEMES: &str = "The selected action has no targeting schemes";
 pub const INVALID_TARGETING_SCHEME: &str = "An invalid targeting scheme was selected";
-pub const INVALID_TARGETS_SELECTED: &str = "Invalid ability targets provided";
-pub const NO_VALID_TARGETS_FOUND: &str = "No valid targets exist for that ability";
+pub const INVALID_TARGETS_SELECTED: &str = "Invalid targets provided";
+pub const NO_VALID_TARGETS_FOUND: &str = "No valid targets exist for that action";
 // BATTLES
 pub const MISSING_BATTLE_REFERENCE: &str = "Missing a battle reference";
 pub const BATTLE_NOT_FOUND: &str = "No battle was found by the provided ID";
@@ -64,6 +72,7 @@ pub const COMBATANT_BATTLE_MISMATCH: &str =
 pub const TURN_TRACKERS_EMPTY: &str = "The battle has no turn trackers in the turn order list";
 pub const NOT_THIS_COMBATANTS_TURN: &str =
     "A combatant tried to use an ability when it was not their turn";
+pub const NOT_ENOUGH_MOVEMENT: &str = "Tried to end a turn for a combatant without enough movement";
 // EVENT PROCESSING
 pub const COMBANTANT_MESH_MANAGER_NOT_FOUND: &str = "No mesh manager was found by that id";
 pub const COMBANTANT_EVENT_MANAGER_NOT_FOUND: &str = "No event manager was found by that id";
diff --git a/common/src/app_consts/mod.rs b/common/src/app_consts/mod.rs
index 38681ff3..63fbbe12 100644
--- a/common/src/app_consts/mod.rs
+++ b/common/src/app_consts/mod.rs
@@ -2,7 +2,7 @@ pub mod error_messages;
 
 pub const CHARACTER_INVENTORY_DEFAULT_CAPACITY: u8 = 3;
 pub const DEEPEST_FLOOR: u8 = 10;
-pub const LEVEL_TO_REACH_FOR_ESCAPE: u8 = 3;
+pub const LEVEL_TO_REACH_FOR_ESCAPE: u8 = 6;
 pub const MAX_PARTY_SIZE: u8 = 3;
 pub const MAIN_CHAT_CHANNEL: &str = "chat-main";
 pub const LOBBY_CHANNEL: &str = "lobby";
diff --git a/common/src/character/inventory.rs b/common/src/character/inventory.rs
deleted file mode 100644
index 52c1cc29..00000000
--- a/common/src/character/inventory.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::app_consts::CHARACTER_INVENTORY_DEFAULT_CAPACITY;
-use crate::errors::AppError;
-use crate::items::Item;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct CharacterInventory {
-    pub items: Vec<Item>,
-    pub capacity: u8,
-    pub shards: u16,
-    pub autoinjectors: u16,
-}
-
-impl CharacterInventory {
-    pub fn new() -> CharacterInventory {
-        CharacterInventory {
-            items: Vec::new(),
-            capacity: CHARACTER_INVENTORY_DEFAULT_CAPACITY as u8,
-            shards: 0,
-            autoinjectors: 0,
-        }
-    }
-
-    pub fn remove_item(&mut self, item_id: u32) -> Result<Item, AppError> {
-        Item::remove_item_from_vec(&mut self.items, item_id)
-    }
-}
diff --git a/common/src/character/mod.rs b/common/src/character/mod.rs
index 44f13e05..22284bdf 100644
--- a/common/src/character/mod.rs
+++ b/common/src/character/mod.rs
@@ -1,4 +1,3 @@
-use self::inventory::CharacterInventory;
 use self::outfit_new_warrior::outfit_new_warrior;
 use crate::combatants::abilities::CombatantAbility;
 use crate::combatants::abilities::CombatantAbilityNames;
@@ -10,17 +9,13 @@ use crate::primatives::EntityProperties;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
-mod equip_item;
-pub mod inventory;
 pub mod outfit_new_warrior;
-mod unequip_item;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Character {
     pub name_of_controlling_user: String,
     pub entity_properties: EntityProperties,
     pub combatant_properties: CombatantProperties,
-    pub inventory: CharacterInventory,
     pub unspent_ability_points: u8,
     pub actions_taken: u8,
 }
@@ -43,7 +38,6 @@ impl Character {
                 HashMap::new(),
                 CombatantControlledBy::Player(name_of_controlling_user),
             ),
-            inventory: CharacterInventory::new(),
             unspent_ability_points: 1,
             actions_taken: 0,
         };
diff --git a/common/src/character/outfit_new_warrior.rs b/common/src/character/outfit_new_warrior.rs
index 86f35688..e40881ef 100644
--- a/common/src/character/outfit_new_warrior.rs
+++ b/common/src/character/outfit_new_warrior.rs
@@ -1,21 +1,21 @@
 use super::Character;
-use crate::combatants::abilities::CombatantAbility;
-use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::combat_attributes::CombatAttributes;
 use crate::game::RoguelikeRacerGame;
 use crate::items::equipment::equipment_generation::create_starting_equipment::create_starting_equipment;
+use crate::items::Item;
+use crate::items::ItemCategories;
 
 pub fn outfit_new_warrior(game: &mut RoguelikeRacerGame, character: &mut Character) {
     let combatant_properties = &mut character.combatant_properties;
     let inherent_attributes = &mut combatant_properties.inherent_attributes;
     inherent_attributes.insert(CombatAttributes::Hp, 30);
     inherent_attributes.insert(CombatAttributes::Damage, 1);
-    inherent_attributes.insert(CombatAttributes::Strength, 20);
+    inherent_attributes.insert(CombatAttributes::Strength, 2);
     inherent_attributes.insert(CombatAttributes::Dexterity, 1);
     inherent_attributes.insert(CombatAttributes::Vitality, 2);
     inherent_attributes.insert(CombatAttributes::Resilience, 2);
     inherent_attributes.insert(CombatAttributes::Accuracy, 75);
-    inherent_attributes.insert(CombatAttributes::Agility, 1);
+    inherent_attributes.insert(CombatAttributes::Speed, 1);
 
     // ABILITIES
     // combatant_properties.abilities.insert(
@@ -32,21 +32,23 @@ pub fn outfit_new_warrior(game: &mut RoguelikeRacerGame, character: &mut Charact
     // );
 
     // TEST INVENTORY ITEMS
-    // for _ in 0..8 {
-    //     let random_equipment = Item::generate(&mut game.id_generator, 5);
-    //     character.inventory.items.push(random_equipment);
-    // }
-    // for _ in 0..8 {
-    //     let random_equipment = Item::generate(&mut game.id_generator, 7);
-    //     character.inventory.items.push(random_equipment);
+    for _ in 0..2 {
+        let random_consumable =
+            Item::generate(&mut game.id_generator, 5, Some(ItemCategories::Consumable));
+        combatant_properties.inventory.items.push(random_consumable);
+    }
+    // for _ in 0..6 {
+    //     let random_equipment =
+    //         Item::generate(&mut game.id_generator, 1, Some(ItemCategories::Equipment));
+    //     combatant_properties.inventory.items.push(random_equipment);
     // }
     // for _ in 0..8 {
     //     let random_equipment = Item::generate(&mut game.id_generator, 8);
-    //     character.inventory.items.push(random_equipment);
+    //     character.combatant_properties.inventory.items.push(random_equipment);
     // }
     // for _ in 0..8 {
     //     let random_equipment = Item::generate(&mut game.id_generator, 10);
-    //     character.inventory.items.push(random_equipment);
+    //     character.combatant_properties.inventory.items.push(random_equipment);
     // }
 
     // STARTING EQUIPMENT
@@ -58,7 +60,7 @@ pub fn outfit_new_warrior(game: &mut RoguelikeRacerGame, character: &mut Charact
     let total_attributes = combatant_properties.get_total_attributes();
     let max_hp_option = total_attributes.get(&CombatAttributes::Hp);
     if let Some(max_hp) = max_hp_option {
-        combatant_properties.hit_points = *max_hp
+        combatant_properties.hit_points = *max_hp;
     }
     let max_mana_option = total_attributes.get(&CombatAttributes::Mp);
     if let Some(max_mana) = max_mana_option {
diff --git a/common/src/combat/ability_handlers/ability_resolution_calculators/calculate_weapon_swing_result.rs b/common/src/combat/ability_handlers/ability_resolution_calculators/calculate_weapon_swing_result.rs
index 83e09aa2..26e21b85 100644
--- a/common/src/combat/ability_handlers/ability_resolution_calculators/calculate_weapon_swing_result.rs
+++ b/common/src/combat/ability_handlers/ability_resolution_calculators/calculate_weapon_swing_result.rs
@@ -1,8 +1,8 @@
 use super::physical_attack_evaded::physical_attack_evaded;
 use super::physical_damage_after_defense::physical_damage_after_defense;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::combat::ActionResult;
 use crate::combat::CombatAction;
-use crate::combatants::abilities::AbilityTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::combat_attributes::CombatAttributes;
 use crate::combatants::get_weapon_properties_traits_and_base_bonus_damage::get_weapon_properties_traits_and_base_bonus_damage;
@@ -15,7 +15,7 @@ use std::collections::HashSet;
 
 pub fn calculate_weapon_swing_result(
     ability_user_id: u32,
-    ability_target: &AbilityTarget,
+    ability_target: &CombatActionTarget,
     target_entity_id: u32,
     user_total_attributes: &HashMap<CombatAttributes, u16>,
     target_total_attributes: &HashMap<CombatAttributes, u16>,
diff --git a/common/src/combat/ability_handlers/ability_resolution_calculators/physical_attack_evaded.rs b/common/src/combat/ability_handlers/ability_resolution_calculators/physical_attack_evaded.rs
index cca8b0ee..211bf1ce 100644
--- a/common/src/combat/ability_handlers/ability_resolution_calculators/physical_attack_evaded.rs
+++ b/common/src/combat/ability_handlers/ability_resolution_calculators/physical_attack_evaded.rs
@@ -19,7 +19,7 @@ pub fn physical_attack_evaded(
     };
 
     let mut rng = rand::thread_rng();
-    // let evaded = rng.gen_range(1..=100) > chance_to_hit;
-    // evaded
-    false
+    let evaded = rng.gen_range(1..=100) > chance_to_hit;
+    evaded
+    // false
 }
diff --git a/common/src/combat/ability_handlers/ability_resolution_calculators/physical_damage_after_defense.rs b/common/src/combat/ability_handlers/ability_resolution_calculators/physical_damage_after_defense.rs
index 1104c55e..e7e23f35 100644
--- a/common/src/combat/ability_handlers/ability_resolution_calculators/physical_damage_after_defense.rs
+++ b/common/src/combat/ability_handlers/ability_resolution_calculators/physical_damage_after_defense.rs
@@ -14,10 +14,11 @@ pub fn physical_damage_after_defense(
         .get(&CombatAttributes::ArmorPenetration)
         .unwrap_or_else(|| &0);
     let penetrated_ac = target_ac.saturating_sub(*user_armor_pen) as u32;
-    println!("rolled damage: {rolled_damage}, penetrated_ac: {penetrated_ac}");
+    // println!("rolled damage: {rolled_damage}, penetrated_ac: {penetrated_ac}");
     let rolled_damage_squared = rolled_damage.pow(2);
-    println!("rolled damage squared: {rolled_damage_squared}");
+    // println!("rolled damage squared: {rolled_damage_squared}");
     let damage_after_ac = (5 * rolled_damage_squared) / (penetrated_ac + 5 * rolled_damage);
+    // println!("damage_after_ac: {rolled_damage_squared}");
 
     let physical_damage_reduction = cmp::min(
         user_total_attributes
@@ -26,9 +27,13 @@ pub fn physical_damage_after_defense(
         &100,
     );
 
-    let max_u16_value: u32 = u16::MAX as u32;
+    let max_i16_value: u32 = i16::MAX as u32;
+    // println!(
+    //     "damage after reduction: {}",
+    //     damage_after_ac * (*physical_damage_reduction as u32 / 100)
+    // );
     let damage_after_damage_reduction =
         damage_after_ac - damage_after_ac * (*physical_damage_reduction as u32 / 100);
-    let final_damage: u16 = damage_after_damage_reduction.clamp(0, max_u16_value) as u16;
+    let final_damage: u16 = damage_after_damage_reduction.clamp(0, max_i16_value) as u16;
     final_damage
 }
diff --git a/common/src/combat/ability_handlers/attack.rs b/common/src/combat/ability_handlers/attack.rs
index 7513b0de..9853d59c 100644
--- a/common/src/combat/ability_handlers/attack.rs
+++ b/common/src/combat/ability_handlers/attack.rs
@@ -2,7 +2,7 @@ use crate::combat::ability_handlers::ability_resolution_calculators::calculate_w
 use crate::combat::battle::Battle;
 use crate::app_consts::error_messages;
 use crate::combat::ActionResult;
-use crate::combatants::abilities::AbilityTarget;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::errors::AppError;
 use crate::game::RoguelikeRacerGame;
 use crate::items::equipment::EquipmentSlots;
@@ -10,9 +10,9 @@ use crate::items::equipment::unarmed::FIST;
 
 impl RoguelikeRacerGame {
     pub fn attack_handler(
-        &mut self,
+        &self,
         ability_user_id: u32,
-        ability_target: &AbilityTarget,
+        ability_target: &CombatActionTarget,
         battle_option: Option<&Battle>,
     ) -> Result<Vec<ActionResult>, AppError> {
         let mut action_results = vec![];
@@ -22,7 +22,7 @@ impl RoguelikeRacerGame {
         })?;
 
         let target_entity_id = match ability_target {
-            AbilityTarget::Single(id) => id,
+            CombatActionTarget::Single(id) => id,
             _ => {
                 return Err(AppError {
                     error_type: crate::errors::AppErrorTypes::InvalidInput,
@@ -43,6 +43,7 @@ impl RoguelikeRacerGame {
             user_combatant_properties.get_equipped_item(&EquipmentSlots::MainHand);
         let oh_equipment_option =
             user_combatant_properties.get_equipped_item(&EquipmentSlots::OffHand);
+        // check for sheilds since they can't be used to attack
         let mh_weapon_option = match mh_equipment_option {
             Some(equipment_properties) => match equipment_properties.is_weapon() {
                 true => Some(equipment_properties),
@@ -58,9 +59,9 @@ impl RoguelikeRacerGame {
             None => None,
         };
 
+        // WEILDING WEAPON(S)
         if mh_weapon_option.is_some() || oh_weapon_option.is_some() {
             let mh_swing_ends_turn = oh_weapon_option.is_none();
-            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,
@@ -86,10 +87,8 @@ impl RoguelikeRacerGame {
                 )?);
             };
         } else {
-            // UNARMED (on)
+            // UNARMED
             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,
diff --git a/common/src/combat/ability_handlers/mod.rs b/common/src/combat/ability_handlers/mod.rs
index ba6ab60b..5d80a846 100644
--- a/common/src/combat/ability_handlers/mod.rs
+++ b/common/src/combat/ability_handlers/mod.rs
@@ -1,30 +1,29 @@
 use super::battle::Battle;
 use super::ActionResult;
-use crate::combatants::abilities::AbilityTarget;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::errors::AppError;
 use crate::game::RoguelikeRacerGame;
 mod ability_resolution_calculators;
 pub mod attack;
-pub mod validate_ability_use;
 
 impl RoguelikeRacerGame {
     pub fn get_ability_results(
-        &mut self,
+        &self,
         ability_user_id: u32,
         ability_name: &CombatantAbilityNames,
-        ability_target: &AbilityTarget,
+        ability_target: &CombatActionTarget,
         battle_option: Option<&Battle>,
     ) -> Result<Vec<ActionResult>, AppError> {
         match ability_name {
             CombatantAbilityNames::Attack => {
                 self.attack_handler(ability_user_id, ability_target, battle_option)
             }
-            CombatantAbilityNames::ArmorBreak => todo!(),
-            CombatantAbilityNames::HeatLance => todo!(),
-            CombatantAbilityNames::Fire => todo!(),
-            CombatantAbilityNames::RainStorm => todo!(),
-            CombatantAbilityNames::Heal => todo!(),
+            _ => Ok(Vec::new()), // CombatantAbilityNames::ArmorBreak => todo!(),
+                                 // CombatantAbilityNames::HeatLance => todo!(),
+                                 // CombatantAbilityNames::Fire => todo!(),
+                                 // CombatantAbilityNames::RainStorm => todo!(),
+                                 // CombatantAbilityNames::Heal => todo!(),
         }
 
         // Ok(effects)
diff --git a/common/src/combat/ability_handlers/validate_ability_use.rs b/common/src/combat/ability_handlers/validate_ability_use.rs
deleted file mode 100644
index 907f12df..00000000
--- a/common/src/combat/ability_handlers/validate_ability_use.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use crate::app_consts::error_messages;
-use crate::combat::battle::Battle;
-use crate::combatants::abilities::get_combatant_ability_attributes::AbilityUsableContext;
-use crate::combatants::abilities::get_combatant_ability_attributes::CombatantAbilityAttributes;
-use crate::combatants::abilities::AbilityTarget;
-use crate::combatants::abilities::CombatantAbilityNames;
-use crate::errors::AppError;
-use crate::errors::AppErrorTypes;
-
-pub fn validate_character_ability_use(
-    ability_name: &CombatantAbilityNames,
-    ability_attributes: &CombatantAbilityAttributes,
-    battle_option: Option<&Battle>,
-    ally_ids: &Vec<u32>,
-    targets: &AbilityTarget,
-    character_id: u32,
-) -> Result<(), AppError> {
-    let (ally_ids, opponent_ids_option) = if let Some(battle) = battle_option {
-        // check if character is first in turn order
-        if !battle.combatant_is_first_in_turn_order(character_id) {
-            return Err(AppError {
-                error_type: AppErrorTypes::InvalidInput,
-                message: error_messages::NOT_THIS_COMBATANTS_TURN.to_string(),
-            });
-        }
-        // check if ability is usable in combat
-        if ability_attributes.usability_context == AbilityUsableContext::OutOfCombat {
-            return Err(AppError {
-                error_type: AppErrorTypes::InvalidInput,
-                message: error_messages::INVALID_ABILITY_CONTEXT.to_string(),
-            });
-        };
-        battle.get_ally_ids_and_opponent_ids_option(character_id)?
-    } else {
-        (ally_ids.clone(), None)
-    };
-
-    // check if targets are valid
-    let targets_are_valid =
-        ability_name.targets_are_valid(character_id, &targets, &ally_ids, &opponent_ids_option);
-
-    if !targets_are_valid {
-        return Err(AppError {
-            error_type: AppErrorTypes::InvalidInput,
-            message: error_messages::INVALID_TARGETS_SELECTED.to_string(),
-        });
-    }
-
-    Ok(())
-}
diff --git a/common/src/combat/ai_behavior/select_ability_and_targets/mod.rs b/common/src/combat/ai_behavior/select_ability_and_targets/mod.rs
index 3ce9afc7..dd6b5a12 100644
--- a/common/src/combat/ai_behavior/select_ability_and_targets/mod.rs
+++ b/common/src/combat/ai_behavior/select_ability_and_targets/mod.rs
@@ -1,6 +1,6 @@
 use crate::app_consts::error_messages;
 use crate::combat::battle::BattleGroup;
-use crate::combatants::abilities::AbilityTarget;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::errors::AppError;
 use crate::game::RoguelikeRacerGame;
@@ -15,24 +15,31 @@ impl RoguelikeRacerGame {
         _ability_user_id: u32,
         _ally_battle_group: BattleGroup,
         enemy_battle_group: BattleGroup,
-    ) -> Result<(CombatantAbilityNames, AbilityTarget), AppError> {
-        let random_enemy_id = {
-            let max = enemy_battle_group.combatant_ids.len() - 1;
-            let min = 0;
-            let mut rng = thread_rng();
-            let random_index = rng.gen_range(min..=max);
-            enemy_battle_group
-                .combatant_ids
-                .get(random_index)
-                .ok_or_else(|| AppError {
-                    error_type: crate::errors::AppErrorTypes::Generic,
-                    message: error_messages::NO_POSSIBLE_TARGETS_PROVIDED.to_string(),
-                })?
-        };
+    ) -> Result<(CombatantAbilityNames, CombatActionTarget), AppError> {
+        let mut random_enemy_id = get_random_enemy_id(&enemy_battle_group)?;
+        let mut combatant = self.get_combatant_by_id(random_enemy_id)?;
+        while combatant.1.hit_points == 0 {
+            random_enemy_id = get_random_enemy_id(&enemy_battle_group)?;
+            combatant = self.get_combatant_by_id(random_enemy_id)?;
+        }
 
         Ok((
             CombatantAbilityNames::Attack,
-            AbilityTarget::Single(*random_enemy_id),
+            CombatActionTarget::Single(*random_enemy_id),
         ))
     }
 }
+
+fn get_random_enemy_id<'a>(enemy_battle_group: &'a BattleGroup) -> Result<&'a u32, AppError> {
+    let max = enemy_battle_group.combatant_ids.len() - 1;
+    let min = 0;
+    let mut rng = thread_rng();
+    let random_index = rng.gen_range(min..=max);
+    enemy_battle_group
+        .combatant_ids
+        .get(random_index)
+        .ok_or_else(|| AppError {
+            error_type: crate::errors::AppErrorTypes::Generic,
+            message: error_messages::NO_POSSIBLE_TARGETS_PROVIDED.to_string(),
+        })
+}
diff --git a/common/src/combat/battle.rs b/common/src/combat/battle.rs
index fd0b97fb..5157425a 100644
--- a/common/src/combat/battle.rs
+++ b/common/src/combat/battle.rs
@@ -104,7 +104,7 @@ impl RoguelikeRacerGame {
         group_a: BattleGroup,
         group_b: BattleGroup,
     ) -> Result<u32, AppError> {
-        let turn_trackers = self.get_battle_turn_order(&group_a, &group_b)?;
+        let turn_trackers = self.create_turn_trackers(&group_a, &group_b)?;
         let battle = Battle {
             id: self.id_generator.get_next_entity_id(),
             group_a,
diff --git a/common/src/combatants/abilities/filter_possible_target_ids_by_prohibited_combatant_states.rs b/common/src/combat/combat_actions/filter_possible_target_ids_by_prohibited_combatant_states.rs
similarity index 93%
rename from common/src/combatants/abilities/filter_possible_target_ids_by_prohibited_combatant_states.rs
rename to common/src/combat/combat_actions/filter_possible_target_ids_by_prohibited_combatant_states.rs
index 05d11b1e..2edbb040 100644
--- a/common/src/combatants/abilities/filter_possible_target_ids_by_prohibited_combatant_states.rs
+++ b/common/src/combat/combat_actions/filter_possible_target_ids_by_prohibited_combatant_states.rs
@@ -1,10 +1,10 @@
-use super::get_combatant_ability_attributes::ProhibitedTargetCombatantStates;
+use super::ProhibitedTargetCombatantStates;
 use crate::errors::AppError;
 use crate::game::RoguelikeRacerGame;
 
 pub fn filter_possible_target_ids_by_prohibited_combatant_states(
     game: &RoguelikeRacerGame,
-    prohibited_combatant_states_option: Option<Vec<ProhibitedTargetCombatantStates>>,
+    prohibited_combatant_states_option: &Option<Vec<ProhibitedTargetCombatantStates>>,
     ally_ids: Vec<u32>,
     opponent_ids_option: Option<Vec<u32>>,
 ) -> Result<(Vec<u32>, Option<Vec<u32>>), AppError> {
diff --git a/common/src/combat/combat_actions/get_default_targets.rs b/common/src/combat/combat_actions/get_default_targets.rs
new file mode 100644
index 00000000..e9f4d583
--- /dev/null
+++ b/common/src/combat/combat_actions/get_default_targets.rs
@@ -0,0 +1,64 @@
+use super::CombatActionProperties;
+use super::CombatActionTarget;
+use super::FriendOrFoe;
+use super::TargetCategories;
+use super::TargetingScheme;
+use crate::app_consts::error_messages;
+use crate::errors::AppError;
+
+impl CombatActionProperties {
+    pub fn get_default_targets(
+        &self,
+        ability_user_id: u32,
+        ally_ids: &Vec<u32>,
+        opponent_ids_option: &Option<Vec<u32>>,
+    ) -> Result<CombatActionTarget, AppError> {
+        let default_targeting_scheme = self.targeting_schemes.first().ok_or_else(|| AppError {
+            error_type: crate::errors::AppErrorTypes::ClientError,
+            message: error_messages::ABILITY_HAS_NO_TARGETING_SCHEME.to_string(),
+        })?;
+
+        match default_targeting_scheme {
+            TargetingScheme::Single => match self.valid_target_categories {
+                TargetCategories::Opponent => {
+                    let opponent_ids = opponent_ids_option.as_ref().ok_or_else(|| AppError {
+                        error_type: crate::errors::AppErrorTypes::Generic,
+                        message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
+                    })?;
+                    let default_target = opponent_ids.first().ok_or_else(|| AppError {
+                        error_type: crate::errors::AppErrorTypes::ServerError,
+                        message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
+                    })?;
+                    Ok(CombatActionTarget::Single(*default_target))
+                }
+                TargetCategories::User => Ok(CombatActionTarget::Single(ability_user_id)),
+                TargetCategories::Friendly => {
+                    let default_target = ability_user_id;
+                    Ok(CombatActionTarget::Single(default_target))
+                }
+                TargetCategories::Any => {
+                    if let Some(opponent_ids) = opponent_ids_option {
+                        let default_target = opponent_ids.first().ok_or_else(|| AppError {
+                            error_type: crate::errors::AppErrorTypes::ServerError,
+                            message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
+                        })?;
+                        Ok(CombatActionTarget::Single(*default_target))
+                    } else {
+                        let default_target = ally_ids.first().ok_or_else(|| AppError {
+                            error_type: crate::errors::AppErrorTypes::ServerError,
+                            message: error_messages::ALLY_COMBATANTS_NOT_FOUND.to_string(),
+                        })?;
+                        Ok(CombatActionTarget::Single(*default_target))
+                    }
+                }
+            },
+            TargetingScheme::Area => match self.valid_target_categories {
+                TargetCategories::Opponent => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
+                TargetCategories::User => Ok(CombatActionTarget::Single(ability_user_id)),
+                TargetCategories::Friendly => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
+                TargetCategories::Any => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
+            },
+            TargetingScheme::All => Ok(CombatActionTarget::All),
+        }
+    }
+}
diff --git a/common/src/combatants/abilities/get_next_or_previous_targets.rs b/common/src/combat/combat_actions/get_next_or_previous_targets.rs
similarity index 71%
rename from common/src/combatants/abilities/get_next_or_previous_targets.rs
rename to common/src/combat/combat_actions/get_next_or_previous_targets.rs
index c46d9301..fe65ccfd 100644
--- a/common/src/combatants/abilities/get_next_or_previous_targets.rs
+++ b/common/src/combat/combat_actions/get_next_or_previous_targets.rs
@@ -1,24 +1,22 @@
-use super::get_combatant_ability_attributes::TargetCategories;
-use super::AbilityTarget;
-use super::CombatantAbilityNames;
+use super::CombatActionProperties;
+use super::CombatActionTarget;
 use super::FriendOrFoe;
+use super::TargetCategories;
 use crate::app_consts::error_messages;
 use crate::errors::AppError;
 use crate::primatives::NextOrPrevious;
 
-impl CombatantAbilityNames {
+impl CombatActionProperties {
     pub fn get_next_or_previous_targets(
         &self,
-        current_targets: &AbilityTarget,
+        current_targets: &CombatActionTarget,
         direction: &NextOrPrevious,
         ability_user_id: &u32,
         ally_ids: &Vec<u32>,
         opponent_ids_option: &Option<Vec<u32>>,
-    ) -> Result<AbilityTarget, AppError> {
-        let ability_attributes = self.get_attributes();
-
+    ) -> Result<CombatActionTarget, AppError> {
         match current_targets {
-            AbilityTarget::Single(id) => match ability_attributes.valid_target_categories {
+            CombatActionTarget::Single(id) => match self.valid_target_categories {
                 TargetCategories::Opponent => {
                     let possible_target_ids =
                         opponent_ids_option.clone().ok_or_else(|| AppError {
@@ -30,13 +28,13 @@ impl CombatantAbilityNames {
                         *id,
                         &direction,
                     )?;
-                    Ok(AbilityTarget::Single(new_target_id))
+                    Ok(CombatActionTarget::Single(new_target_id))
                 }
-                TargetCategories::User => Ok(AbilityTarget::Single(*ability_user_id)),
+                TargetCategories::User => Ok(CombatActionTarget::Single(*ability_user_id)),
                 TargetCategories::Friendly => {
                     let new_target_id =
                         get_next_or_prev_id_from_ordered_id_list(&ally_ids, *id, &direction)?;
-                    Ok(AbilityTarget::Single(new_target_id))
+                    Ok(CombatActionTarget::Single(new_target_id))
                 }
                 TargetCategories::Any => {
                     let mut possible_target_ids = vec![];
@@ -49,19 +47,19 @@ impl CombatantAbilityNames {
                         *id,
                         &direction,
                     )?;
-                    Ok(AbilityTarget::Single(new_target_id))
+                    Ok(CombatActionTarget::Single(new_target_id))
                 }
             },
-            AbilityTarget::Group(category) => match ability_attributes.valid_target_categories {
-                TargetCategories::Opponent => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
-                TargetCategories::User => Ok(AbilityTarget::Single(*ability_user_id)),
-                TargetCategories::Friendly => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
+            CombatActionTarget::Group(category) => match self.valid_target_categories {
+                TargetCategories::Opponent => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
+                TargetCategories::User => Ok(CombatActionTarget::Single(*ability_user_id)),
+                TargetCategories::Friendly => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
                 TargetCategories::Any => match category {
-                    FriendOrFoe::Friendly => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
-                    FriendOrFoe::Hostile => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
+                    FriendOrFoe::Friendly => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
+                    FriendOrFoe::Hostile => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
                 },
             },
-            AbilityTarget::All => Ok(AbilityTarget::All),
+            CombatActionTarget::All => Ok(CombatActionTarget::All),
         }
     }
 }
diff --git a/common/src/combat/combat_actions/mod.rs b/common/src/combat/combat_actions/mod.rs
new file mode 100644
index 00000000..b59eb252
--- /dev/null
+++ b/common/src/combat/combat_actions/mod.rs
@@ -0,0 +1,138 @@
+pub mod filter_possible_target_ids_by_prohibited_combatant_states;
+pub mod get_default_targets;
+pub mod get_next_or_previous_targets;
+pub mod targets_are_valid;
+pub mod targets_by_saved_preference_or_default;
+pub mod validate_use;
+use crate::app_consts::error_messages;
+use crate::combatants::abilities::CombatantAbilityNames;
+use crate::errors::AppError;
+use crate::errors::AppErrorTypes;
+use serde::Deserialize;
+use serde::Serialize;
+use std::fmt::Display;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum FriendOrFoe {
+    Friendly,
+    Hostile,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum CombatActionTarget {
+    Single(u32),
+    Group(FriendOrFoe),
+    All,
+}
+
+impl CombatActionTarget {
+    pub fn get_single_target_id(&self) -> Result<u32, AppError> {
+        match self {
+            CombatActionTarget::Single(id) => Ok(*id),
+            _ => Err(AppError {
+                error_type: AppErrorTypes::Generic,
+                message: error_messages::INVALID_TARGETING_SCHEME.to_string(),
+            }),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TargetingScheme {
+    Single,
+    Area,
+    All,
+}
+
+impl Display for TargetingScheme {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let to_write = match self {
+            TargetingScheme::Single => "Single",
+            TargetingScheme::Area => "Area",
+            TargetingScheme::All => "All",
+        };
+        write!(f, "{}", to_write)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TargetCategories {
+    Opponent,
+    User,
+    Friendly,
+    Any,
+}
+
+impl Display for TargetCategories {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let to_write = match self {
+            TargetCategories::Opponent => "Enemy",
+            TargetCategories::User => "Self",
+            TargetCategories::Friendly => "Friendly",
+            TargetCategories::Any => "Any",
+        };
+        write!(f, "{}", to_write)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum ProhibitedTargetCombatantStates {
+    Dead,
+    Alive,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum AbilityUsableContext {
+    All,
+    InCombat,
+    OutOfCombat,
+}
+
+impl Display for AbilityUsableContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let to_write = match self {
+            AbilityUsableContext::All => "any time",
+            AbilityUsableContext::InCombat => "in combat",
+            AbilityUsableContext::OutOfCombat => "out of combat",
+        };
+        write!(f, "{}", to_write)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub enum CombatAction {
+    AbilityUsed(CombatantAbilityNames),
+    ConsumableUsed(u32),
+}
+
+pub struct CombatActionProperties {
+    pub targeting_schemes: Vec<TargetingScheme>,
+    pub valid_target_categories: TargetCategories,
+    pub usability_context: AbilityUsableContext,
+    pub prohibited_target_combatant_states: Option<Vec<ProhibitedTargetCombatantStates>>,
+    pub requires_combat_turn: bool,
+}
+
+impl Default for CombatActionProperties {
+    fn default() -> Self {
+        CombatActionProperties {
+            targeting_schemes: vec![TargetingScheme::Single],
+            valid_target_categories: TargetCategories::Opponent,
+            usability_context: AbilityUsableContext::InCombat,
+            prohibited_target_combatant_states: None,
+            requires_combat_turn: true,
+        }
+    }
+}
+
+impl Display for CombatAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let to_write = match self {
+            CombatAction::AbilityUsed(ability_name) => format!("ability {ability_name}"),
+            CombatAction::ConsumableUsed(consumable_id) => {
+                format!("consumable used {consumable_id}")
+            }
+        };
+        write!(f, "{to_write}")
+    }
+}
diff --git a/common/src/combatants/abilities/targets_are_valid.rs b/common/src/combat/combat_actions/targets_are_valid.rs
similarity index 65%
rename from common/src/combatants/abilities/targets_are_valid.rs
rename to common/src/combat/combat_actions/targets_are_valid.rs
index c8216a65..42562fa6 100644
--- a/common/src/combatants/abilities/targets_are_valid.rs
+++ b/common/src/combat/combat_actions/targets_are_valid.rs
@@ -1,20 +1,19 @@
-use super::get_combatant_ability_attributes::TargetCategories;
-use super::get_combatant_ability_attributes::TargetingScheme;
-use super::AbilityTarget;
-use super::CombatantAbilityNames;
+use super::CombatActionProperties;
+use super::CombatActionTarget;
 use super::FriendOrFoe;
+use super::TargetCategories;
+use super::TargetingScheme;
 
-impl CombatantAbilityNames {
+impl CombatActionProperties {
     pub fn targets_are_valid(
         &self,
         ability_user_id: u32,
-        targets: &AbilityTarget,
+        targets: &CombatActionTarget,
         ally_ids: &Vec<u32>,
         opponent_ids_option: &Option<Vec<u32>>,
     ) -> bool {
-        let ability_attributes = self.get_attributes();
         match targets {
-            AbilityTarget::Single(id) => match ability_attributes.valid_target_categories {
+            CombatActionTarget::Single(id) => match self.valid_target_categories {
                 TargetCategories::Opponent => {
                     if let Some(opponent_ids) = opponent_ids_option {
                         opponent_ids.contains(id)
@@ -34,12 +33,9 @@ impl CombatantAbilityNames {
                     }
                 }
             },
-            AbilityTarget::Group(category) => {
-                if ability_attributes
-                    .targeting_schemes
-                    .contains(&TargetingScheme::Area)
-                {
-                    match ability_attributes.valid_target_categories {
+            CombatActionTarget::Group(category) => {
+                if self.targeting_schemes.contains(&TargetingScheme::Area) {
+                    match self.valid_target_categories {
                         TargetCategories::Opponent => category == &FriendOrFoe::Hostile,
                         TargetCategories::User => false,
                         TargetCategories::Friendly => category == &FriendOrFoe::Friendly,
@@ -51,9 +47,7 @@ impl CombatantAbilityNames {
                     false
                 }
             }
-            AbilityTarget::All => ability_attributes
-                .targeting_schemes
-                .contains(&TargetingScheme::All),
+            CombatActionTarget::All => self.targeting_schemes.contains(&TargetingScheme::All),
         }
     }
 }
diff --git a/common/src/combatants/abilities/targets_by_saved_preference_or_default.rs b/common/src/combat/combat_actions/targets_by_saved_preference_or_default.rs
similarity index 64%
rename from common/src/combatants/abilities/targets_by_saved_preference_or_default.rs
rename to common/src/combat/combat_actions/targets_by_saved_preference_or_default.rs
index 880ecd0f..4aaa122d 100644
--- a/common/src/combatants/abilities/targets_by_saved_preference_or_default.rs
+++ b/common/src/combat/combat_actions/targets_by_saved_preference_or_default.rs
@@ -1,44 +1,41 @@
-use super::get_combatant_ability_attributes::TargetCategories;
-use super::get_combatant_ability_attributes::TargetingScheme;
-use super::AbilityTarget;
-use super::CombatantAbilityNames;
+use super::CombatActionProperties;
+use super::CombatActionTarget;
 use super::FriendOrFoe;
+use super::TargetCategories;
+use super::TargetingScheme;
 use crate::app_consts::error_messages;
-use crate::combatants::AbilityTargetPreferences;
+use crate::combatants::CombatActionTargetPreferences;
 use crate::errors::AppError;
 
-impl CombatantAbilityNames {
+impl CombatActionProperties {
     pub fn targets_by_saved_preference_or_default(
         &self,
         character_id: u32,
-        target_preferences: &AbilityTargetPreferences,
+        target_preferences: &CombatActionTargetPreferences,
         ally_ids: Vec<u32>,
         opponent_ids_option: Option<Vec<u32>>,
-    ) -> Result<AbilityTarget, AppError> {
-        let ability_attributes = self.get_attributes();
-        if ability_attributes
+    ) -> Result<CombatActionTarget, AppError> {
+        if self
             .targeting_schemes
             .contains(&target_preferences.targeting_scheme_preference)
         {
             targeting_scheme_targets_or_defaults(
                 &target_preferences.targeting_scheme_preference,
-                &ability_attributes.valid_target_categories,
+                &self.valid_target_categories,
                 target_preferences,
                 character_id,
                 ally_ids,
                 opponent_ids_option,
             )
         } else {
-            let default_targeting_scheme = ability_attributes
-                .targeting_schemes
-                .first()
-                .ok_or_else(|| AppError {
+            let default_targeting_scheme =
+                self.targeting_schemes.first().ok_or_else(|| AppError {
                     error_type: crate::errors::AppErrorTypes::ClientError,
                     message: error_messages::ABILITY_HAS_NO_TARGETING_SCHEME.to_string(),
                 })?;
             targeting_scheme_targets_or_defaults(
                 &default_targeting_scheme,
-                &ability_attributes.valid_target_categories,
+                &self.valid_target_categories,
                 target_preferences,
                 character_id,
                 ally_ids,
@@ -51,23 +48,25 @@ impl CombatantAbilityNames {
 fn targeting_scheme_targets_or_defaults(
     targeting_scheme: &TargetingScheme,
     valid_target_categories: &TargetCategories,
-    target_preferences: &AbilityTargetPreferences,
+    target_preferences: &CombatActionTargetPreferences,
     character_id: u32,
     ally_ids: Vec<u32>,
     opponent_ids_option: Option<Vec<u32>>,
-) -> Result<AbilityTarget, AppError> {
+) -> Result<CombatActionTarget, AppError> {
     match targeting_scheme {
         TargetingScheme::Single => match valid_target_categories {
             TargetCategories::Opponent => preferred_single_target_or_default(
                 FriendOrFoe::Hostile,
                 &target_preferences,
+                character_id,
                 ally_ids,
                 opponent_ids_option,
             ),
-            TargetCategories::User => Ok(AbilityTarget::Single(character_id)),
+            TargetCategories::User => Ok(CombatActionTarget::Single(character_id)),
             TargetCategories::Friendly => preferred_single_target_or_default(
                 FriendOrFoe::Friendly,
                 &target_preferences,
+                character_id,
                 ally_ids,
                 opponent_ids_option,
             ),
@@ -76,61 +75,61 @@ fn targeting_scheme_targets_or_defaults(
                     FriendOrFoe::Friendly => preferred_single_target_or_default(
                         FriendOrFoe::Friendly,
                         &target_preferences,
+                        character_id,
                         ally_ids,
                         opponent_ids_option,
                     ),
                     FriendOrFoe::Hostile => preferred_single_target_or_default(
                         FriendOrFoe::Hostile,
                         &target_preferences,
+                        character_id,
                         ally_ids,
                         opponent_ids_option,
                     ),
                 },
                 None => {
                     if let Some(opponent_ids) = opponent_ids_option {
-                        Ok(AbilityTarget::Single(opponent_ids[0]))
+                        Ok(CombatActionTarget::Single(opponent_ids[0]))
                     } else {
-                        Ok(AbilityTarget::Single(ally_ids[0]))
+                        Ok(CombatActionTarget::Single(ally_ids[0]))
                     }
                 }
             },
         },
         TargetingScheme::Area => match valid_target_categories {
-            TargetCategories::Opponent => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
-            TargetCategories::User => Ok(AbilityTarget::Single(character_id)),
-            TargetCategories::Friendly => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
+            TargetCategories::Opponent => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
+            TargetCategories::User => Ok(CombatActionTarget::Single(character_id)),
+            TargetCategories::Friendly => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
             TargetCategories::Any => match &target_preferences.category_of_last_target {
                 Some(category) => match category {
-                    FriendOrFoe::Friendly => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
-                    FriendOrFoe::Hostile => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
+                    FriendOrFoe::Friendly => Ok(CombatActionTarget::Group(FriendOrFoe::Friendly)),
+                    FriendOrFoe::Hostile => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
                 },
-                None => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
+                None => Ok(CombatActionTarget::Group(FriendOrFoe::Hostile)),
             },
         },
-        TargetingScheme::All => Ok(AbilityTarget::All),
+        TargetingScheme::All => Ok(CombatActionTarget::All),
     }
 }
 
 fn preferred_single_target_or_default(
     category: FriendOrFoe,
-    target_preferences: &AbilityTargetPreferences,
+    target_preferences: &CombatActionTargetPreferences,
+    character_id: u32,
     ally_ids: Vec<u32>,
     opponent_ids_option: Option<Vec<u32>>,
-) -> Result<AbilityTarget, AppError> {
+) -> Result<CombatActionTarget, AppError> {
     match category {
         FriendOrFoe::Friendly => {
-            let default_ally_id = ally_ids.first().ok_or_else(|| AppError {
-                error_type: crate::errors::AppErrorTypes::ClientError,
-                message: error_messages::NO_VALID_TARGETS_FOUND.to_string(),
-            })?;
+            let default_ally_id = character_id;
             if let Some(previously_targeted_id) = target_preferences.friendly_single {
                 if ally_ids.contains(&previously_targeted_id) {
-                    Ok(AbilityTarget::Single(previously_targeted_id))
+                    Ok(CombatActionTarget::Single(previously_targeted_id))
                 } else {
-                    Ok(AbilityTarget::Single(*default_ally_id))
+                    Ok(CombatActionTarget::Single(default_ally_id))
                 }
             } else {
-                Ok(AbilityTarget::Single(*default_ally_id))
+                Ok(CombatActionTarget::Single(default_ally_id))
             }
         }
         FriendOrFoe::Hostile => {
@@ -144,12 +143,12 @@ fn preferred_single_target_or_default(
             })?;
             if let Some(previously_targeted_id) = target_preferences.hostile_single {
                 if opponent_ids.contains(&previously_targeted_id) {
-                    Ok(AbilityTarget::Single(previously_targeted_id))
+                    Ok(CombatActionTarget::Single(previously_targeted_id))
                 } else {
-                    Ok(AbilityTarget::Single(*default_opponent_id))
+                    Ok(CombatActionTarget::Single(*default_opponent_id))
                 }
             } else {
-                Ok(AbilityTarget::Single(*default_opponent_id))
+                Ok(CombatActionTarget::Single(*default_opponent_id))
             }
         }
     }
diff --git a/common/src/combat/combat_actions/validate_use.rs b/common/src/combat/combat_actions/validate_use.rs
new file mode 100644
index 00000000..06f13270
--- /dev/null
+++ b/common/src/combat/combat_actions/validate_use.rs
@@ -0,0 +1,50 @@
+use crate::app_consts::error_messages;
+use crate::combat::battle::Battle;
+use crate::combat::combat_actions::AbilityUsableContext;
+use crate::combat::combat_actions::CombatActionProperties;
+use crate::combat::combat_actions::CombatActionTarget;
+use crate::errors::AppError;
+use crate::errors::AppErrorTypes;
+
+impl CombatActionProperties {
+    pub fn validate_use(
+        &self,
+        battle_option: Option<&Battle>,
+        ally_ids: &Vec<u32>,
+        targets: &CombatActionTarget,
+        character_id: u32,
+    ) -> Result<(), AppError> {
+        let (ally_ids, opponent_ids_option) = if let Some(battle) = battle_option {
+            // check if character is first in turn order
+            if !battle.combatant_is_first_in_turn_order(character_id) {
+                return Err(AppError {
+                    error_type: AppErrorTypes::InvalidInput,
+                    message: error_messages::NOT_THIS_COMBATANTS_TURN.to_string(),
+                });
+            }
+            // check if ability is usable in combat
+            if self.usability_context == AbilityUsableContext::OutOfCombat {
+                return Err(AppError {
+                    error_type: AppErrorTypes::InvalidInput,
+                    message: error_messages::INVALID_ABILITY_CONTEXT.to_string(),
+                });
+            };
+            battle.get_ally_ids_and_opponent_ids_option(character_id)?
+        } else {
+            (ally_ids.clone(), None)
+        };
+
+        // check if targets are valid
+        let targets_are_valid =
+            self.targets_are_valid(character_id, &targets, &ally_ids, &opponent_ids_option);
+
+        if !targets_are_valid {
+            return Err(AppError {
+                error_type: AppErrorTypes::InvalidInput,
+                message: error_messages::INVALID_TARGETS_SELECTED.to_string(),
+            });
+        }
+
+        Ok(())
+    }
+}
diff --git a/common/src/combat/consumable_use_handlers/hp_autoinjector_use_result.rs b/common/src/combat/consumable_use_handlers/hp_autoinjector_use_result.rs
new file mode 100644
index 00000000..be259b85
--- /dev/null
+++ b/common/src/combat/consumable_use_handlers/hp_autoinjector_use_result.rs
@@ -0,0 +1,70 @@
+use crate::app_consts::error_messages;
+use crate::combat::combat_actions::CombatAction;
+use crate::combat::combat_actions::CombatActionTarget;
+use crate::combat::ActionResult;
+use crate::combatants::combat_attributes::CombatAttributes;
+use crate::combatants::combatant_traits::CombatantTraits;
+use crate::errors::AppError;
+use crate::game::RoguelikeRacerGame;
+use rand::Rng;
+use std::collections::HashMap;
+
+pub fn hp_autoinjector_use_result(
+    game: &RoguelikeRacerGame,
+    user_id: u32,
+    consumable_item_id: u32,
+    target: &CombatActionTarget,
+) -> Result<Vec<ActionResult>, AppError> {
+    let target_id = match target {
+        CombatActionTarget::Single(id) => id,
+        CombatActionTarget::Group(_) | CombatActionTarget::All => {
+            return Err(AppError {
+                error_type: crate::errors::AppErrorTypes::InvalidInput,
+                message: error_messages::INVALID_TARGETS_SELECTED.to_string(),
+            })
+        }
+    };
+    let (_, target_combatant_properties) = game.get_combatant_by_id(&target_id)?;
+
+    if target_combatant_properties.hit_points == 0 {
+        return Err(AppError {
+            error_type: crate::errors::AppErrorTypes::InvalidInput,
+            message: error_messages::CANT_BE_USED_ON_DEAD_TARGET.to_string(),
+        });
+    }
+
+    let bonus_multiplier = *target_combatant_properties
+        .traits
+        .get(&CombatantTraits::HpBioavailability)
+        .unwrap_or_else(|| &1) as f32;
+    let max_hp = *target_combatant_properties
+        .get_total_attributes()
+        .get(&CombatAttributes::Hp)
+        .unwrap_or_else(|| &0) as f32;
+    // don't allow healing full hp target
+    if max_hp as u16 == target_combatant_properties.hit_points {
+        return Err(AppError {
+            error_type: crate::errors::AppErrorTypes::InvalidInput,
+            message: error_messages::ALREADY_FULL_HP.to_string(),
+        });
+    }
+    // calculate healing amount
+    let min_healing = bonus_multiplier * max_hp / 8.0;
+    let max_healing = bonus_multiplier * 3.0 * max_hp / 8.0;
+    let mut rng = rand::thread_rng();
+    let rolled_healing = rng.gen_range(min_healing..=max_healing);
+    let final_healing = rolled_healing.clamp(0.0, i16::MAX as f32) as i16;
+
+    Ok(vec![ActionResult {
+        user_id,
+        action: CombatAction::ConsumableUsed(consumable_item_id),
+        targets: target.clone(),
+        hp_changes_by_entity_id: Some(HashMap::from([(*target_id, final_healing)])),
+        mp_changes_by_entity_id: None,
+        misses_by_entity_id: None,
+        resists_by_entity_id: None,
+        is_crit: false,
+        status_effect_changes_by_entity_id: None,
+        ends_turn: false,
+    }])
+}
diff --git a/common/src/combat/consumable_use_handlers/mod.rs b/common/src/combat/consumable_use_handlers/mod.rs
new file mode 100644
index 00000000..a0b9e0f3
--- /dev/null
+++ b/common/src/combat/consumable_use_handlers/mod.rs
@@ -0,0 +1,31 @@
+mod hp_autoinjector_use_result;
+use self::hp_autoinjector_use_result::hp_autoinjector_use_result;
+use super::battle::Battle;
+use super::combat_actions::CombatActionTarget;
+use super::ActionResult;
+use crate::errors::AppError;
+use crate::game::RoguelikeRacerGame;
+use crate::items::consumables::ConsumableTypes;
+
+impl RoguelikeRacerGame {
+    pub fn get_consumable_use_results(
+        &self,
+        user_id: u32,
+        consumable_item_id: u32,
+        target: &CombatActionTarget,
+        _battle_option: Option<&Battle>,
+    ) -> Result<Vec<ActionResult>, AppError> {
+        let (_, user_combatant_properties) = self.get_combatant_by_id(&user_id)?;
+        let consumable_properties = user_combatant_properties
+            .inventory
+            .get_consumable(&consumable_item_id)?;
+        let results = match consumable_properties.consumable_type {
+            ConsumableTypes::HpAutoinjector => {
+                hp_autoinjector_use_result(self, user_id, consumable_item_id, target)?
+            }
+            ConsumableTypes::Grenade => todo!(),
+            ConsumableTypes::SmokeBomb => todo!(),
+        };
+        Ok(results)
+    }
+}
diff --git a/common/src/combat/mod.rs b/common/src/combat/mod.rs
index 836a52c0..383f4c5a 100644
--- a/common/src/combat/mod.rs
+++ b/common/src/combat/mod.rs
@@ -2,38 +2,21 @@ pub mod ability_handlers;
 pub mod ai_behavior;
 pub mod all_combatants_in_group_are_dead;
 pub mod battle;
+pub mod combat_actions;
+pub mod consumable_use_handlers;
 mod get_combatant_by_id;
 mod turn_order;
 use self::battle::BattleGroup;
-use crate::combatants::abilities::AbilityTarget;
+use self::combat_actions::CombatAction;
+use self::combat_actions::CombatActionTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::items::consumables::ConsumableTypes;
-use crate::items::Item;
 use crate::primatives::GainedOrLost;
 use crate::status_effects::StatusEffects;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::fmt::Display;
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub enum CombatAction {
-    AbilityUsed(CombatantAbilityNames),
-    ItemUsed(Item),
-}
-
-impl Display for CombatAction {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        let to_write = match self {
-            CombatAction::AbilityUsed(ability_name) => format!("ability {ability_name}"),
-            CombatAction::ItemUsed(consumable) => {
-                format!("item {}", consumable.entity_properties.name)
-            }
-        };
-        write!(f, "{to_write}")
-    }
-}
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub struct CombatTurnResult {
@@ -49,7 +32,7 @@ pub struct ActionResult {
     pub action: CombatAction,
     // Used to modify the animation and direction character faces when
     // using ability
-    pub targets: AbilityTarget,
+    pub targets: CombatActionTarget,
     // used to display floating text and reduce/add to the value
     pub hp_changes_by_entity_id: Option<HashMap<u32, i16>>,
     pub mp_changes_by_entity_id: Option<HashMap<u32, i16>>,
diff --git a/common/src/combat/turn_order.rs b/common/src/combat/turn_order.rs
index 36629ea3..78e45169 100644
--- a/common/src/combat/turn_order.rs
+++ b/common/src/combat/turn_order.rs
@@ -1,60 +1,55 @@
 use super::BattleGroup;
 use crate::app_consts::error_messages;
-use crate::app_consts::TURN_TIME;
 use crate::combatants::combat_attributes::CombatAttributes;
-use crate::combatants::CombatantProperties;
 use crate::errors::AppError;
 use crate::game::getters::get_party;
 use crate::game::RoguelikeRacerGame;
 use serde::Deserialize;
 use serde::Serialize;
+use std::cmp::Reverse;
+
+const SPEED_MODIFIER: u32 = 10;
+const REQUIRED_MOVEMENT_TO_MOVE: u32 = 999;
+const MAX_TICKS_TO_FILL_MOVEMENT: u32 = 10;
+const MIN_TICKS_TO_FILL_MOVEMENT: u32 = 5;
+const MIN_MOVEMENT_PER_TICK: u32 = REQUIRED_MOVEMENT_TO_MOVE / MAX_TICKS_TO_FILL_MOVEMENT;
+const MAX_MOVEMENT_PER_TICK: u32 = REQUIRED_MOVEMENT_TO_MOVE / MIN_TICKS_TO_FILL_MOVEMENT;
+const MOVEMENT_RANGE: u32 = MAX_MOVEMENT_PER_TICK - MIN_MOVEMENT_PER_TICK;
+const MAX_SPEED: u32 = MIN_MOVEMENT_PER_TICK * 10;
+const MIN_SPEED: u32 = MIN_MOVEMENT_PER_TICK * 10 / REQUIRED_MOVEMENT_TO_MOVE * 10;
+const SPEED_RANGE: u32 = MAX_SPEED - MIN_SPEED;
 
 #[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug)]
 pub struct CombatantTurnTracker {
     pub entity_id: u32,
-    pub movement: i16,
+    pub movement: u16,
 }
 
-pub fn get_turn_tracker_from_combatant(
-    combatant_properties: &CombatantProperties,
-    id: u32,
-) -> CombatantTurnTracker {
-    let speed = combatant_properties
-        .get_total_attributes()
-        .get(&CombatAttributes::Speed)
-        .unwrap_or_else(|| &0)
-        .clone();
-
+pub fn get_turn_tracker_from_combatant(id: u32) -> CombatantTurnTracker {
     CombatantTurnTracker {
         entity_id: id,
-        movement: speed as i16,
+        movement: 0,
     }
 }
 
 impl RoguelikeRacerGame {
-    pub fn get_battle_turn_order(
+    pub fn create_turn_trackers(
         &self,
         group_a: &BattleGroup,
         group_b: &BattleGroup,
     ) -> Result<Vec<CombatantTurnTracker>, AppError> {
         let mut combatant_turn_trackers = vec![];
 
-        let party_a = get_party(self, group_a.party_id)?;
         for entity_id in &group_a.combatant_ids {
-            let (_, combatant_properties) = party_a.get_combatant_by_id(entity_id)?;
-            let turn_tracker = get_turn_tracker_from_combatant(&combatant_properties, *entity_id);
+            let turn_tracker = get_turn_tracker_from_combatant(*entity_id);
             combatant_turn_trackers.push(turn_tracker);
         }
 
-        let party_b = get_party(self, group_b.party_id)?;
         for entity_id in &group_b.combatant_ids {
-            let (_, combatant_properties) = party_b.get_combatant_by_id(entity_id)?;
-            let turn_tracker = get_turn_tracker_from_combatant(&combatant_properties, *entity_id);
+            let turn_tracker = get_turn_tracker_from_combatant(*entity_id);
             combatant_turn_trackers.push(turn_tracker);
         }
 
-        combatant_turn_trackers.sort_by(|a, b| b.movement.partial_cmp(&a.movement).unwrap());
-
         Ok(combatant_turn_trackers)
     }
 
@@ -62,41 +57,76 @@ impl RoguelikeRacerGame {
         &mut self,
         battle_id: u32,
     ) -> Result<&CombatantTurnTracker, AppError> {
+        self.tick_combat_until_next_combatant_is_active(battle_id)?;
         let battle = self.battles.get_mut(&battle_id).ok_or_else(|| AppError {
             error_type: crate::errors::AppErrorTypes::Generic,
             message: error_messages::BATTLE_NOT_FOUND.to_string(),
         })?;
-        let mut turn_trackers = battle.combatant_turn_trackers.clone();
-        let active_combatant_turn_tracker = turn_trackers.first_mut().ok_or_else(|| AppError {
+        let active_combatant_turn_tracker =
+            battle
+                .combatant_turn_trackers
+                .first_mut()
+                .ok_or_else(|| AppError {
+                    error_type: crate::errors::AppErrorTypes::Generic,
+                    message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+                })?;
+        active_combatant_turn_tracker.movement -= REQUIRED_MOVEMENT_TO_MOVE as u16;
+
+        battle
+            .combatant_turn_trackers
+            .sort_by_key(|item| (Reverse(item.movement), item.entity_id));
+
+        let new_active_combatant_turn_tracker =
+            battle
+                .combatant_turn_trackers
+                .first()
+                .ok_or_else(|| AppError {
+                    error_type: crate::errors::AppErrorTypes::Generic,
+                    message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+                })?;
+
+        Ok(new_active_combatant_turn_tracker)
+    }
+
+    pub fn tick_combat_until_next_combatant_is_active(
+        &mut self,
+        battle_id: u32,
+    ) -> Result<(), AppError> {
+        let battle = self.battles.get_mut(&battle_id).ok_or_else(|| AppError {
             error_type: crate::errors::AppErrorTypes::Generic,
-            message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+            message: error_messages::BATTLE_NOT_FOUND.to_string(),
         })?;
+        let mut cloned_turn_trackers = battle.combatant_turn_trackers.clone();
 
-        active_combatant_turn_tracker.movement -= TURN_TIME;
-        turn_trackers.sort_by(|a, b| b.movement.partial_cmp(&a.movement).unwrap());
+        cloned_turn_trackers.sort_by_key(|item| (Reverse(item.movement), item.entity_id));
 
         let mut active_combatant_turn_tracker =
-            turn_trackers.first_mut().ok_or_else(|| AppError {
+            cloned_turn_trackers.first_mut().ok_or_else(|| AppError {
                 error_type: crate::errors::AppErrorTypes::Generic,
                 message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
             })?;
 
-        while active_combatant_turn_tracker.movement < TURN_TIME {
+        while active_combatant_turn_tracker.movement < REQUIRED_MOVEMENT_TO_MOVE as u16 {
             // tick the time and refill all movement
-            for tracker in &mut turn_trackers {
+            for tracker in &mut cloned_turn_trackers {
                 let (_, combatant_properties) = self.get_combatant_by_id(&tracker.entity_id)?;
                 let entity_speed = *combatant_properties
                     .get_total_attributes()
                     .get(&CombatAttributes::Speed)
-                    .unwrap_or_else(|| &0) as i16;
-                tracker.movement += entity_speed;
+                    .unwrap_or_else(|| &0);
+                let adjusted_speed = entity_speed as u32 * SPEED_MODIFIER;
+                let movement_to_add = ((((adjusted_speed - MIN_SPEED) * MOVEMENT_RANGE)
+                    / SPEED_RANGE)
+                    + MIN_MOVEMENT_PER_TICK) as u16;
+                tracker.movement += movement_to_add;
             }
 
-            turn_trackers.sort_by(|a, b| b.movement.partial_cmp(&a.movement).unwrap());
-            active_combatant_turn_tracker = turn_trackers.first_mut().ok_or_else(|| AppError {
-                error_type: crate::errors::AppErrorTypes::Generic,
-                message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
-            })?;
+            cloned_turn_trackers.sort_by_key(|item| (Reverse(item.movement), item.entity_id));
+            active_combatant_turn_tracker =
+                cloned_turn_trackers.first_mut().ok_or_else(|| AppError {
+                    error_type: crate::errors::AppErrorTypes::Generic,
+                    message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+                })?;
         }
 
         let battle = self.battles.get_mut(&battle_id).ok_or_else(|| AppError {
@@ -104,16 +134,7 @@ impl RoguelikeRacerGame {
             message: error_messages::BATTLE_NOT_FOUND.to_string(),
         })?;
 
-        battle.combatant_turn_trackers = turn_trackers;
-        let new_active_combatant_turn_tracker =
-            battle
-                .combatant_turn_trackers
-                .first()
-                .ok_or_else(|| AppError {
-                    error_type: crate::errors::AppErrorTypes::Generic,
-                    message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
-                })?;
-
-        Ok(new_active_combatant_turn_tracker)
+        battle.combatant_turn_trackers = cloned_turn_trackers;
+        Ok(())
     }
 }
diff --git a/common/src/combat/turn_time_scratch_paper.rs b/common/src/combat/turn_time_scratch_paper.rs
index 8d58de53..68fd293b 100644
--- a/common/src/combat/turn_time_scratch_paper.rs
+++ b/common/src/combat/turn_time_scratch_paper.rs
@@ -1,61 +1,111 @@
-#[derive(Debug)]
-pub struct Character {
-    pub speed: u8,
-    pub movement: i16,
-    pub name: String,
+use std::cmp::Reverse;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+use rand::Rng;
+
+#[derive(Debug, Clone)]
+struct Combatant {
+    speed: u16,
+    movement: u16,
+    num_turns: u16,
+    id: u8,
 }
 
-impl Character {
-    pub fn new(speed: u8, name: String) -> Self {
-        Character {
+const REQUIRED_MOVEMENT_TO_MOVE: u16 = 999;
+const MAX_TICKS_TO_FILL_MOVEMENT: u16 = 10;
+const MIN_TICKS_TO_FILL_MOVEMENT: u16 = 5;
+const MIN_MOVEMENT_PER_TICK: u16 = REQUIRED_MOVEMENT_TO_MOVE / MAX_TICKS_TO_FILL_MOVEMENT;
+const MAX_MOVEMENT_PER_TICK: u16 = REQUIRED_MOVEMENT_TO_MOVE / MIN_TICKS_TO_FILL_MOVEMENT;
+const MOVEMENT_RANGE: u16 = MAX_MOVEMENT_PER_TICK - MIN_MOVEMENT_PER_TICK;
+const MAX_SPEED: u16 = MIN_MOVEMENT_PER_TICK * 10;
+const MIN_SPEED: u16 = MIN_MOVEMENT_PER_TICK * 10 / REQUIRED_MOVEMENT_TO_MOVE * 10;
+const SPEED_RANGE: u16 = MAX_SPEED - MIN_SPEED;
+// (((OldValue - OldMin) * NewRange) / OldRange) + NewMin
+
+impl Combatant {
+    fn tick_movement(&mut self) {
+        let adjusted_speed = self.speed * 10;
+        let movement_to_add =
+            (((adjusted_speed - MIN_SPEED) * MOVEMENT_RANGE) / SPEED_RANGE) + MIN_MOVEMENT_PER_TICK;
+        // println!("{} added {} movement", self.id, movement_to_add);
+        self.movement += movement_to_add;
+        // println!("{:?}", self.movement)
+    }
+
+    fn new(speed: u16, id: u8) -> Self {
+        let mut rng = rand::thread_rng();
+
+        Combatant {
             speed,
-            movement: speed as i16,
-            name,
+            movement: 0,
+            num_turns: 0,
+            id, // id: rng.gen::<u8>(),
         }
     }
 }
-static TURN_TIME: i16 = 35;
+
+pub struct IdGenerator {
+    pub last_generated: u8,
+}
+
+impl IdGenerator {
+    fn get_next_id(&mut self) -> u8 {
+        let next_id = self.last_generated + 1;
+        self.last_generated = next_id;
+        next_id
+    }
+}
+
 fn main() {
-    let mut characters = vec![
-        Character::new(40, "A".to_string()),
-        Character::new(35, "B".to_string()),
-        Character::new(30, "C".to_string()),
+    let mut id_generator = IdGenerator { last_generated: 0 };
+    let mut combatants = vec![
+        Combatant::new(0, id_generator.get_next_id()),
+        Combatant::new(1, id_generator.get_next_id()),
+        Combatant::new(1, id_generator.get_next_id()),
+        Combatant::new(1, id_generator.get_next_id()),
+        Combatant::new(1, id_generator.get_next_id()),
+        Combatant::new(3, id_generator.get_next_id()),
+        Combatant::new(2, id_generator.get_next_id()),
+        Combatant::new(5, id_generator.get_next_id()),
+        Combatant::new(8, id_generator.get_next_id()),
+        Combatant::new(12, id_generator.get_next_id()),
+        Combatant::new(15, id_generator.get_next_id()),
+        // Combatant::new(20, id_generator.get_next_id()),
+        // Combatant::new(25, id_generator.get_next_id()),
+        // Combatant::new(50, id_generator.get_next_id()),
+        // Combatant::new(100, id_generator.get_next_id()),
+        Combatant::new(120, id_generator.get_next_id()),
     ];
 
-    let mut a_turns = 0;
-    let mut b_turns = 0;
-    let mut c_turns = 0;
-
-    for _i in 0..20 {
-        characters.sort_by(|a, b| b.movement.partial_cmp(&a.movement).unwrap());
-        if characters[0].movement >= TURN_TIME {
-            println!("{}: {}", characters[0].name, characters[0].movement);
-            take_turn(&mut characters[0]);
-            if characters[0].name == "A".to_string() {
-                a_turns += 1;
-            } else if characters[0].name == "B".to_string() {
-                b_turns += 1;
-            } else {
-                c_turns += 1;
-            }
-        } else {
-            for character in characters.iter_mut() {
-                character.movement += character.speed as i16;
+    let mut num_turns_in_battle_remaining = 180;
+
+    while num_turns_in_battle_remaining > 0 {
+        combatants.sort_by_key(|item| Reverse((item.movement, item.id)));
+        // let first_combatant_movement = combatants[0].movement;
+        // let second_combatant_movement = combatants[1].movement;
+        // let next_combatant_equal_movement = first_combatant_movement == second_combatant_movement;
+        let first_combatant = &mut combatants[0];
+        // println!("first combatant movement: {}", first_combatant.movement);
+
+        if first_combatant.movement >= REQUIRED_MOVEMENT_TO_MOVE {
+            println!(
+                "{} with speed {} moving with movement {}",
+                first_combatant.id, first_combatant.speed, first_combatant.movement
+            );
+            first_combatant.movement -= REQUIRED_MOVEMENT_TO_MOVE;
+            first_combatant.num_turns += 1;
+            num_turns_in_battle_remaining -= 1;
+        }
+
+        for combatant in &mut combatants {
+            if combatant.speed > 0 {
+                combatant.tick_movement();
             }
         }
     }
-    println!("a turns: {a_turns} b turns: {b_turns}");
-    let total = a_turns + b_turns;
-    println!("total: {total}");
-    let a_perc = a_turns as f32 / total as f32;
-    let b_perc = b_turns as f32 / total as f32;
-    let c_perc = c_turns as f32 / total as f32;
-    println!(
-        "a turns: %{:?} b turns: %{b_perc}, c turns: ${c_perc}",
-        a_perc
-    );
-}
 
-fn take_turn(character: &mut Character) {
-    character.movement -= TURN_TIME;
+    combatants.sort_by(|a, b| b.num_turns.partial_cmp(&a.num_turns).unwrap());
+    println!("{:#?}", combatants);
 }
+
diff --git a/common/src/combatants/abilities/get_combatant_ability_attributes.rs b/common/src/combatants/abilities/get_combatant_ability_attributes.rs
index 03dc7ba8..9765c202 100644
--- a/common/src/combatants/abilities/get_combatant_ability_attributes.rs
+++ b/common/src/combatants/abilities/get_combatant_ability_attributes.rs
@@ -1,59 +1,24 @@
 use super::CombatantAbilityNames;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum TargetingScheme {
-    Single,
-    Area,
-    All,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum TargetCategories {
-    Opponent,
-    User,
-    Friendly,
-    Any,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum ProhibitedTargetCombatantStates {
-    Dead,
-    Alive,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum AbilityUsableContext {
-    All,
-    InCombat,
-    OutOfCombat,
-}
+use crate::combat::combat_actions::CombatActionProperties;
+use crate::combat::combat_actions::ProhibitedTargetCombatantStates;
+use crate::combat::combat_actions::TargetingScheme;
 
 pub struct CombatantAbilityAttributes {
-    pub targeting_schemes: Vec<TargetingScheme>,
-    pub valid_target_categories: TargetCategories,
-    pub usability_context: AbilityUsableContext,
-    pub prohibited_target_combatant_states: Option<Vec<ProhibitedTargetCombatantStates>>,
+    pub combat_action_properties: CombatActionProperties,
     pub is_melee: bool,
     pub mana_cost: u8,
     pub mana_cost_level_multiplier: u8,
     pub shard_cost: u8,
-    pub requires_combat_turn: bool,
 }
 
 impl Default for CombatantAbilityAttributes {
     fn default() -> Self {
         CombatantAbilityAttributes {
-            targeting_schemes: vec![TargetingScheme::Single],
-            valid_target_categories: TargetCategories::Opponent,
-            usability_context: AbilityUsableContext::InCombat,
-            prohibited_target_combatant_states: None,
+            combat_action_properties: CombatActionProperties::default(),
             is_melee: false,
             mana_cost: 1,
             mana_cost_level_multiplier: 1,
             shard_cost: 0,
-            requires_combat_turn: true,
         }
     }
 }
@@ -64,9 +29,12 @@ impl CombatantAbilityNames {
             CombatantAbilityNames::Attack => CombatantAbilityAttributes {
                 mana_cost: 0,
                 is_melee: true,
-                prohibited_target_combatant_states: Some(vec![
-                    ProhibitedTargetCombatantStates::Dead,
-                ]),
+                combat_action_properties: CombatActionProperties {
+                    prohibited_target_combatant_states: Some(vec![
+                        ProhibitedTargetCombatantStates::Dead,
+                    ]),
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             CombatantAbilityNames::ArmorBreak => CombatantAbilityAttributes {
@@ -77,22 +45,16 @@ impl CombatantAbilityNames {
                 ..Default::default()
             },
             CombatantAbilityNames::Fire => CombatantAbilityAttributes {
-                targeting_schemes: vec![TargetingScheme::Single, TargetingScheme::Area],
-                valid_target_categories: TargetCategories::Any,
+                combat_action_properties: CombatActionProperties {
+                    targeting_schemes: vec![TargetingScheme::Area, TargetingScheme::Single],
+                    ..Default::default()
+                },
                 ..Default::default()
             },
             CombatantAbilityNames::Heal => CombatantAbilityAttributes {
-                targeting_schemes: vec![TargetingScheme::Single, TargetingScheme::Area],
-                valid_target_categories: TargetCategories::Friendly,
                 ..Default::default()
             },
             CombatantAbilityNames::RainStorm => CombatantAbilityAttributes {
-                targeting_schemes: vec![
-                    TargetingScheme::Single,
-                    TargetingScheme::Area,
-                    TargetingScheme::All,
-                ],
-                valid_target_categories: TargetCategories::Any,
                 ..Default::default()
             },
         }
diff --git a/common/src/combatants/abilities/get_default_targets.rs b/common/src/combatants/abilities/get_default_targets.rs
deleted file mode 100644
index 8c58f598..00000000
--- a/common/src/combatants/abilities/get_default_targets.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use super::get_combatant_ability_attributes::TargetCategories;
-use super::get_combatant_ability_attributes::TargetingScheme;
-use super::AbilityTarget;
-use super::CombatantAbilityNames;
-use super::FriendOrFoe;
-use crate::app_consts::error_messages;
-use crate::errors::AppError;
-
-impl CombatantAbilityNames {
-    pub fn get_default_targets(
-        &self,
-        ability_user_id: u32,
-        ally_ids: &Vec<u32>,
-        opponent_ids_option: &Option<Vec<u32>>,
-    ) -> Result<AbilityTarget, AppError> {
-        let ability_attributes = self.get_attributes();
-        let default_targeting_scheme =
-            ability_attributes
-                .targeting_schemes
-                .first()
-                .ok_or_else(|| AppError {
-                    error_type: crate::errors::AppErrorTypes::ClientError,
-                    message: error_messages::ABILITY_HAS_NO_TARGETING_SCHEME.to_string(),
-                })?;
-
-        match default_targeting_scheme {
-            TargetingScheme::Single => match ability_attributes.valid_target_categories {
-                TargetCategories::Opponent => {
-                    let opponent_ids = opponent_ids_option.as_ref().ok_or_else(|| AppError {
-                        error_type: crate::errors::AppErrorTypes::Generic,
-                        message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
-                    })?;
-                    let default_target = opponent_ids.first().ok_or_else(|| AppError {
-                        error_type: crate::errors::AppErrorTypes::ServerError,
-                        message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
-                    })?;
-                    Ok(AbilityTarget::Single(*default_target))
-                }
-                TargetCategories::User => Ok(AbilityTarget::Single(ability_user_id)),
-                TargetCategories::Friendly => {
-                    let default_target = ally_ids.first().ok_or_else(|| AppError {
-                        error_type: crate::errors::AppErrorTypes::ServerError,
-                        message: error_messages::ALLY_COMBATANTS_NOT_FOUND.to_string(),
-                    })?;
-                    Ok(AbilityTarget::Single(*default_target))
-                }
-                TargetCategories::Any => {
-                    if let Some(opponent_ids) = opponent_ids_option {
-                        let default_target = opponent_ids.first().ok_or_else(|| AppError {
-                            error_type: crate::errors::AppErrorTypes::ServerError,
-                            message: error_messages::ENEMY_COMBATANTS_NOT_FOUND.to_string(),
-                        })?;
-                        Ok(AbilityTarget::Single(*default_target))
-                    } else {
-                        let default_target = ally_ids.first().ok_or_else(|| AppError {
-                            error_type: crate::errors::AppErrorTypes::ServerError,
-                            message: error_messages::ALLY_COMBATANTS_NOT_FOUND.to_string(),
-                        })?;
-                        Ok(AbilityTarget::Single(*default_target))
-                    }
-                }
-            },
-            TargetingScheme::Area => match ability_attributes.valid_target_categories {
-                TargetCategories::Opponent => Ok(AbilityTarget::Group(FriendOrFoe::Hostile)),
-                TargetCategories::User => Ok(AbilityTarget::Single(ability_user_id)),
-                TargetCategories::Friendly => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
-                TargetCategories::Any => Ok(AbilityTarget::Group(FriendOrFoe::Friendly)),
-            },
-            TargetingScheme::All => Ok(AbilityTarget::All),
-        }
-    }
-}
diff --git a/common/src/combatants/abilities/mod.rs b/common/src/combatants/abilities/mod.rs
index 0f054f04..9d729ef4 100644
--- a/common/src/combatants/abilities/mod.rs
+++ b/common/src/combatants/abilities/mod.rs
@@ -1,26 +1,8 @@
-pub mod filter_possible_target_ids_by_prohibited_combatant_states;
 pub mod get_combatant_ability_attributes;
-mod get_default_targets;
-mod get_next_or_previous_targets;
-mod targets_are_valid;
-pub mod targets_by_saved_preference_or_default;
 use serde::Deserialize;
 use serde::Serialize;
 use std::fmt::Display;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum FriendOrFoe {
-    Friendly,
-    Hostile,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub enum AbilityTarget {
-    Single(u32),
-    Group(FriendOrFoe),
-    All,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct CombatantAbility {
     pub ability_name: CombatantAbilityNames,
diff --git a/common/src/combatants/combatant_traits.rs b/common/src/combatants/combatant_traits.rs
new file mode 100644
index 00000000..73e9014b
--- /dev/null
+++ b/common/src/combatants/combatant_traits.rs
@@ -0,0 +1,7 @@
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Eq, Hash, PartialEq, Clone, Debug, Serialize, Deserialize)]
+pub enum CombatantTraits {
+    HpBioavailability,
+}
diff --git a/common/src/character/equip_item.rs b/common/src/combatants/equip_item.rs
similarity index 86%
rename from common/src/character/equip_item.rs
rename to common/src/combatants/equip_item.rs
index ee85512b..88a2808c 100644
--- a/common/src/character/equip_item.rs
+++ b/common/src/combatants/equip_item.rs
@@ -1,11 +1,11 @@
-use super::Character;
+use super::CombatantProperties;
 use crate::app_consts::error_messages;
 use crate::errors::AppError;
 use crate::items::equipment::EquipmentSlots;
 
-impl Character {
+impl CombatantProperties {
     pub fn slot_item_is_equipped(&self, item_id: &u32) -> Option<EquipmentSlots> {
-        for (slot, equipped_item) in &self.combatant_properties.equipment {
+        for (slot, equipped_item) in &self.equipment {
             if &equipped_item.entity_properties.id == item_id {
                 return Some(slot.clone());
             }
@@ -35,7 +35,7 @@ impl Character {
 
         let (item, item_inventory_index) = item_and_index;
 
-        if !self.combatant_properties.can_use_item(&item) {
+        if !self.can_use_item(&item) {
             return Err(AppError {
                 error_type: crate::errors::AppErrorTypes::InvalidInput,
                 message: error_messages::ITEM_REQUIREMENTS_NOT_MET.to_string(),
@@ -69,10 +69,7 @@ impl Character {
                 }
             }
             EquipmentSlots::OffHand => {
-                if let Some(equipment_in_main_hand) = self
-                    .combatant_properties
-                    .equipment
-                    .get(&EquipmentSlots::MainHand)
+                if let Some(equipment_in_main_hand) = self.equipment.get(&EquipmentSlots::MainHand)
                 {
                     if equipment_in_main_hand
                         .get_equipment_properties()?
@@ -93,11 +90,10 @@ impl Character {
         // remove item to equip from inventory
         let item_to_equip = self.inventory.items.remove(item_inventory_index);
         // add newly equipped item to equipment hashmap
-        self.combatant_properties
-            .equipment
-            .insert(slot, item_to_equip);
+        self.equipment.insert(slot, item_to_equip);
 
-        self.combatant_properties.clamp_curr_hp_to_max();
+        self.clamp_curr_hp_to_max();
+        self.clamp_curr_mp_to_max();
 
         Ok(ids_of_unequipped_items)
     }
diff --git a/common/src/combatants/get_weapon_damage_and_hit_chance.rs b/common/src/combatants/get_weapon_damage_and_hit_chance.rs
index 51a24c52..81b9107f 100644
--- a/common/src/combatants/get_weapon_damage_and_hit_chance.rs
+++ b/common/src/combatants/get_weapon_damage_and_hit_chance.rs
@@ -1,12 +1,10 @@
 use super::CombatantProperties;
-use crate::{
-    app_consts::{OFF_HAND_ACCURACY_MODIFIER, OFF_HAND_DAMAGE_MODIFIER},
-    items::equipment::{
-        trait_effects::get_weapon_percent_damage_increase_trait_damage_modifier::get_weapon_percent_damage_increase_trait_damage_modifier,
-        weapon_properties::WeaponProperties, EquipmentTraits,
-    },
-    primatives::Range,
-};
+use crate::app_consts::OFF_HAND_ACCURACY_MODIFIER;
+use crate::app_consts::OFF_HAND_DAMAGE_MODIFIER;
+use crate::items::equipment::trait_effects::get_weapon_percent_damage_increase_trait_damage_modifier::get_weapon_percent_damage_increase_trait_damage_modifier;
+use crate::items::equipment::weapon_properties::WeaponProperties;
+use crate::items::equipment::EquipmentTraits;
+use crate::primatives::Range;
 
 impl CombatantProperties {
     pub fn get_weapon_damage_and_hit_chance(
diff --git a/common/src/combatants/inventory.rs b/common/src/combatants/inventory.rs
new file mode 100644
index 00000000..c19ed4ba
--- /dev/null
+++ b/common/src/combatants/inventory.rs
@@ -0,0 +1,84 @@
+use crate::app_consts::error_messages;
+use crate::app_consts::CHARACTER_INVENTORY_DEFAULT_CAPACITY;
+use crate::errors::AppError;
+use crate::errors::AppErrorTypes;
+use crate::items::consumables::ConsumableProperties;
+use crate::items::Item;
+use crate::items::ItemProperties;
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct Inventory {
+    pub items: Vec<Item>,
+    pub capacity: u8,
+    pub shards: u16,
+    pub autoinjectors: u16,
+}
+
+impl Inventory {
+    pub fn new() -> Inventory {
+        Inventory {
+            items: Vec::new(),
+            capacity: CHARACTER_INVENTORY_DEFAULT_CAPACITY as u8,
+            shards: 0,
+            autoinjectors: 0,
+        }
+    }
+
+    pub fn remove_item(&mut self, item_id: u32) -> Result<Item, AppError> {
+        Item::remove_item_from_vec(&mut self.items, item_id)
+    }
+
+    pub fn get_item<'a>(&'a self, item_id: &u32) -> Result<&'a Item, AppError> {
+        for item in &self.items {
+            if item.entity_properties.id == *item_id {
+                return Ok(&item);
+            }
+        }
+        Err(AppError {
+            error_type: crate::errors::AppErrorTypes::Generic,
+            message: error_messages::INVALID_ITEM_ID.to_string(),
+        })
+    }
+
+    pub fn get_item_mut<'a>(&'a mut self, item_id: &u32) -> Result<&'a mut Item, AppError> {
+        for item in &mut self.items {
+            if item.entity_properties.id == *item_id {
+                return Ok(item);
+            }
+        }
+        Err(AppError {
+            error_type: crate::errors::AppErrorTypes::Generic,
+            message: error_messages::INVALID_ITEM_ID.to_string(),
+        })
+    }
+
+    pub fn get_consumable<'a>(
+        &'a self,
+        item_id: &u32,
+    ) -> Result<&'a ConsumableProperties, AppError> {
+        let consumable_in_inventory = self.get_item(&item_id)?;
+        match &consumable_in_inventory.item_properties {
+            ItemProperties::Consumable(conumable_properties) => Ok(conumable_properties),
+            ItemProperties::Equipment(_) => Err(AppError {
+                error_type: AppErrorTypes::InvalidInput,
+                message: error_messages::CANT_CONSUME_NON_CONSUMABLE_ITEM.to_string(),
+            }),
+        }
+    }
+
+    pub fn get_consumable_mut<'a>(
+        &'a mut self,
+        item_id: &u32,
+    ) -> Result<&'a mut ConsumableProperties, AppError> {
+        let consumable_in_inventory = self.get_item_mut(&item_id)?;
+        match &mut consumable_in_inventory.item_properties {
+            ItemProperties::Consumable(conumable_properties) => Ok(conumable_properties),
+            ItemProperties::Equipment(_) => Err(AppError {
+                error_type: AppErrorTypes::InvalidInput,
+                message: error_messages::CANT_CONSUME_NON_CONSUMABLE_ITEM.to_string(),
+            }),
+        }
+    }
+}
diff --git a/common/src/combatants/mod.rs b/common/src/combatants/mod.rs
index 1bed23fb..8fff8a6c 100644
--- a/common/src/combatants/mod.rs
+++ b/common/src/combatants/mod.rs
@@ -1,18 +1,24 @@
 pub mod abilities;
 pub mod combat_attributes;
+pub mod combatant_traits;
+mod equip_item;
 pub mod get_base_ability_damage_bonus;
+use self::combatant_traits::CombatantTraits;
 mod get_equipped_item;
 mod get_equipped_weapon_properties;
 mod get_total_attributes;
 mod get_weapon_damage_and_hit_chance;
+pub mod inventory;
+mod unequip_item;
+use crate::combat::combat_actions::CombatActionTarget;
+use crate::combat::combat_actions::FriendOrFoe;
+use crate::combat::combat_actions::TargetingScheme;
 pub mod get_weapon_properties_traits_and_base_bonus_damage;
 mod set_new_ability_target_preferences;
-use self::abilities::get_combatant_ability_attributes::TargetingScheme;
-use self::abilities::AbilityTarget;
 use self::abilities::CombatantAbility;
 use self::abilities::CombatantAbilityNames;
-use self::abilities::FriendOrFoe;
 use self::combat_attributes::CombatAttributes;
+use self::inventory::Inventory;
 use crate::app_consts::error_messages;
 use crate::errors::AppError;
 use crate::items::equipment::EquipmentSlots;
@@ -44,7 +50,7 @@ impl fmt::Display for CombatantClass {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct AbilityTargetPreferences {
+pub struct CombatActionTargetPreferences {
     pub friendly_single: Option<u32>,
     pub hostile_single: Option<u32>,
     pub category_of_last_target: Option<FriendOrFoe>,
@@ -52,9 +58,9 @@ pub struct AbilityTargetPreferences {
     pub targeting_scheme_preference: TargetingScheme,
 }
 
-impl Default for AbilityTargetPreferences {
+impl Default for CombatActionTargetPreferences {
     fn default() -> Self {
-        AbilityTargetPreferences {
+        CombatActionTargetPreferences {
             friendly_single: None,
             hostile_single: None,
             category_of_last_target: None,
@@ -78,12 +84,13 @@ pub struct CombatantProperties {
     pub mana: u16,
     pub status_effects: Vec<StatusEffects>,
     pub equipment: HashMap<EquipmentSlots, Item>,
+    pub inventory: Inventory,
     pub abilities: HashMap<CombatantAbilityNames, CombatantAbility>,
-    // pub traits: HashSet<CombatantTraits>
-    pub selected_item_slot: Option<u8>,
+    pub traits: HashMap<CombatantTraits, u8>,
+    pub selected_consumable: Option<u32>,
     pub selected_ability_name: Option<CombatantAbilityNames>,
-    pub ability_targets: Option<AbilityTarget>,
-    pub ability_target_preferences: AbilityTargetPreferences,
+    pub combat_action_targets: Option<CombatActionTarget>,
+    pub combat_action_target_preferences: CombatActionTargetPreferences,
     pub controlled_by: CombatantControlledBy,
 }
 
@@ -100,11 +107,13 @@ impl CombatantProperties {
             mana: 0,
             status_effects: vec![],
             equipment: HashMap::new(),
+            inventory: Inventory::new(),
             abilities,
-            selected_item_slot: None,
+            traits: HashMap::new(),
+            selected_consumable: None,
             selected_ability_name: None,
-            ability_targets: None,
-            ability_target_preferences: AbilityTargetPreferences::default(),
+            combat_action_targets: None,
+            combat_action_target_preferences: CombatActionTargetPreferences::default(),
             controlled_by,
         }
     }
@@ -126,6 +135,18 @@ impl CombatantProperties {
             None => (),
         }
     }
+    pub fn clamp_curr_mp_to_max(&mut self) {
+        // @TODO optimize to only add up HP
+        let total_attributes = self.get_total_attributes();
+        match total_attributes.get(&CombatAttributes::Mp) {
+            Some(max_mp) => {
+                if max_mp < &self.mana {
+                    self.mana = *max_mp
+                }
+            }
+            None => (),
+        }
+    }
 
     pub fn get_mut_ability_if_owned<'a>(
         &'a mut self,
diff --git a/common/src/combatants/set_new_ability_target_preferences.rs b/common/src/combatants/set_new_ability_target_preferences.rs
index fae5a82f..06d2156f 100644
--- a/common/src/combatants/set_new_ability_target_preferences.rs
+++ b/common/src/combatants/set_new_ability_target_preferences.rs
@@ -1,21 +1,20 @@
-use super::abilities::get_combatant_ability_attributes::TargetingScheme;
-use super::abilities::AbilityTarget;
-use super::abilities::CombatantAbilityNames;
-use super::abilities::FriendOrFoe;
-use super::AbilityTargetPreferences;
+use super::CombatActionTargetPreferences;
+use crate::combat::combat_actions::CombatActionProperties;
+use crate::combat::combat_actions::CombatActionTarget;
+use crate::combat::combat_actions::FriendOrFoe;
+use crate::combat::combat_actions::TargetingScheme;
 
-impl AbilityTargetPreferences {
+impl CombatActionTargetPreferences {
     pub fn get_updated_preferences(
         &self,
-        selected_ability_name: &CombatantAbilityNames,
-        new_targets: &AbilityTarget,
+        combat_action_properties: &CombatActionProperties,
+        new_targets: &CombatActionTarget,
         ally_ids: Vec<u32>,
         opponent_ids_option: Option<Vec<u32>>,
-    ) -> AbilityTargetPreferences {
+    ) -> CombatActionTargetPreferences {
         let mut new_preferences = self.clone();
-        let ability_attributes = selected_ability_name.get_attributes();
         match new_targets {
-            AbilityTarget::Single(id) => {
+            CombatActionTarget::Single(id) => {
                 let is_opponent_id = {
                     if let Some(opponent_ids) = opponent_ids_option {
                         opponent_ids.contains(id)
@@ -31,16 +30,16 @@ impl AbilityTargetPreferences {
                     new_preferences.category_of_last_target = Some(FriendOrFoe::Friendly);
                 }
             }
-            AbilityTarget::Group(category) => {
-                if ability_attributes.targeting_schemes.len() > 1 {
+            CombatActionTarget::Group(category) => {
+                if combat_action_properties.targeting_schemes.len() > 1 {
                     new_preferences.category_of_last_target = Some(category.clone());
                     new_preferences.targeting_scheme_preference = TargetingScheme::Area;
                 } else {
                     // they had no choice, don't update prefs
                 }
             }
-            AbilityTarget::All => {
-                if ability_attributes.targeting_schemes.len() > 1 {
+            CombatActionTarget::All => {
+                if combat_action_properties.targeting_schemes.len() > 1 {
                     new_preferences.targeting_scheme_preference = TargetingScheme::All;
                 } else {
                     // they had no choice, don't update prefs
diff --git a/common/src/character/unequip_item.rs b/common/src/combatants/unequip_item.rs
similarity index 76%
rename from common/src/character/unequip_item.rs
rename to common/src/combatants/unequip_item.rs
index c28c8089..506eed3e 100644
--- a/common/src/character/unequip_item.rs
+++ b/common/src/combatants/unequip_item.rs
@@ -1,7 +1,7 @@
-use super::Character;
+use super::CombatantProperties;
 use crate::items::equipment::EquipmentSlots;
 
-impl Character {
+impl CombatantProperties {
     pub fn unequip_slots(
         &mut self,
         slots_to_unequip: &Vec<EquipmentSlots>,
@@ -9,7 +9,7 @@ impl Character {
     ) -> Vec<u32> {
         let mut unequipped_item_options = Vec::new();
         for slot in slots_to_unequip {
-            unequipped_item_options.push(self.combatant_properties.equipment.remove(&slot))
+            unequipped_item_options.push(self.equipment.remove(&slot))
         }
         let mut ids_of_unequipped_items = Vec::new();
         for item_option in unequipped_item_options {
@@ -20,7 +20,8 @@ impl Character {
         }
 
         if !is_due_to_equipment_swap {
-            self.combatant_properties.clamp_curr_hp_to_max();
+            self.clamp_curr_hp_to_max();
+            self.clamp_curr_mp_to_max();
         }
 
         ids_of_unequipped_items
diff --git a/common/src/game/getters.rs b/common/src/game/getters.rs
index fb0c828a..8a1c0a33 100644
--- a/common/src/game/getters.rs
+++ b/common/src/game/getters.rs
@@ -4,8 +4,8 @@ use crate::adventuring_party::AdventuringParty;
 use crate::app_consts::error_messages;
 use crate::character::Character;
 use crate::combat::battle::Battle;
-use crate::combatants::abilities::AbilityTarget;
-use crate::combatants::abilities::FriendOrFoe;
+use crate::combat::combat_actions::CombatActionTarget;
+use crate::combat::combat_actions::FriendOrFoe;
 use crate::errors::AppError;
 use crate::errors::AppErrorTypes;
 
@@ -104,16 +104,34 @@ pub fn get_ally_ids_and_opponent_ids_option(
 }
 
 impl RoguelikeRacerGame {
+    pub fn get_battle_option(
+        &self,
+        battle_id_option: &Option<u32>,
+    ) -> Result<Option<Battle>, AppError> {
+        if let Some(battle_id) = battle_id_option {
+            Ok(Some(
+                self.battles
+                    .get(&battle_id)
+                    .ok_or_else(|| AppError {
+                        error_type: AppErrorTypes::ServerError,
+                        message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                    })?
+                    .clone(),
+            ))
+        } else {
+            Ok(None)
+        }
+    }
     pub fn get_ids_from_ability_target(
         &self,
         party_id: u32,
         battle_option: Option<&Battle>,
-        ability_target: &AbilityTarget,
+        ability_target: &CombatActionTarget,
         ability_user_id: u32,
     ) -> Result<Vec<u32>, AppError> {
         let ids = match ability_target {
-            AbilityTarget::Single(id) => vec![*id],
-            AbilityTarget::Group(friend_or_foe) => match friend_or_foe {
+            CombatActionTarget::Single(id) => vec![*id],
+            CombatActionTarget::Group(friend_or_foe) => match friend_or_foe {
                 FriendOrFoe::Friendly => {
                     if let Some(battle) = battle_option {
                         let (ally_battle_group, _) =
@@ -134,7 +152,7 @@ impl RoguelikeRacerGame {
                     enemy_battle_group.combatant_ids
                 }
             },
-            AbilityTarget::All => {
+            CombatActionTarget::All => {
                 if let Some(battle) = battle_option {
                     let (ally_battle_group, enemy_battle_group) =
                         battle.get_ally_and_enemy_battle_groups(&ability_user_id)?;
diff --git a/common/src/game/mod.rs b/common/src/game/mod.rs
index d28e22ea..ba561d35 100644
--- a/common/src/game/mod.rs
+++ b/common/src/game/mod.rs
@@ -15,7 +15,6 @@ use std::time::UNIX_EPOCH;
 pub mod add_character_to_adventuring_party;
 pub mod getters;
 pub mod id_generator;
-pub mod player_actions;
 pub mod player_input_handlers;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
diff --git a/common/src/game/player_actions.rs b/common/src/game/player_actions.rs
deleted file mode 100644
index f9820f17..00000000
--- a/common/src/game/player_actions.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use super::RoguelikeRacerGame;
-use crate::app_consts::error_messages;
-use crate::errors::AppError;
-use crate::game::player_input_handlers::open_treasure_chest;
-use crate::game::player_input_handlers::use_selected_consumable;
-use crate::packets::client_to_server::PlayerInputRequest;
-use crate::packets::client_to_server::PlayerInputs;
-
-impl RoguelikeRacerGame {
-    pub fn process_player_input(
-        &mut self,
-        player_input_request: PlayerInputRequest,
-    ) -> Result<(), AppError> {
-        let PlayerInputRequest {
-            party_id,
-            player_character_id,
-            player_input,
-        } = player_input_request;
-
-        let adventuring_party =
-            self.adventuring_parties
-                .get_mut(&party_id)
-                .ok_or_else(|| AppError {
-                    error_type: crate::errors::AppErrorTypes::InvalidInput,
-                    message: error_messages::PARTY_NOT_FOUND.to_string(),
-                })?;
-
-        // let player_character = adventuring_party
-        //     .characters
-        //     .get_mut(&player_character_id)
-        //     .ok_or_else(|| AppError {
-        //         error_type: crate::errors::AppErrorTypes::InvalidInput,
-        //         message: "tried to process player input but couldn't find the player character"
-        //             .to_string(),
-        //     })?;
-
-        match player_input {
-            PlayerInputs::SelectConsumable(_inventory_slot) => {
-                // select_consumable::select_consumable(player_character, inventory_slot)?
-            }
-            PlayerInputs::UseSelectedConsumable => {
-                use_selected_consumable::use_selected_consumable(
-                    adventuring_party,
-                    player_character_id,
-                )?
-            }
-            PlayerInputs::OpenTreasureChest => {
-                open_treasure_chest::open_treasure_chest(&mut self.id_generator, adventuring_party)?
-            }
-            _ => (),
-        }
-
-        println!("{:#?}", self);
-
-        Ok(())
-    }
-}
diff --git a/common/src/game/player_input_handlers/mod.rs b/common/src/game/player_input_handlers/mod.rs
index da6bdd78..523ec0dd 100644
--- a/common/src/game/player_input_handlers/mod.rs
+++ b/common/src/game/player_input_handlers/mod.rs
@@ -1,3 +1 @@
 pub mod open_treasure_chest;
-pub mod select_consumable;
-pub mod use_selected_consumable;
diff --git a/common/src/game/player_input_handlers/open_treasure_chest.rs b/common/src/game/player_input_handlers/open_treasure_chest.rs
index bf4af2e7..9996510a 100644
--- a/common/src/game/player_input_handlers/open_treasure_chest.rs
+++ b/common/src/game/player_input_handlers/open_treasure_chest.rs
@@ -1,11 +1,7 @@
-use crate::adventuring_party::AdventuringParty;
 use crate::errors::AppError;
-use crate::game::id_generator::IdGenerator;
-use crate::items::Item;
 
-pub fn open_treasure_chest(
-    id_generator: &mut IdGenerator,
-    adventuring_party: &mut AdventuringParty,
+pub fn open_treasure_chest(// id_generator: &mut IdGenerator,
+    // adventuring_party: &mut AdventuringParty,
 ) -> Result<(), AppError> {
     // let current_room = &mut adventuring_party.current_room;
 
diff --git a/common/src/game/player_input_handlers/select_consumable.rs b/common/src/game/player_input_handlers/select_consumable.rs
deleted file mode 100644
index f0ce896a..00000000
--- a/common/src/game/player_input_handlers/select_consumable.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// use crate::character::Character;
-use crate::errors::AppError;
-
-pub fn select_consumable(// player_character: &mut Character,
-    // inventory_slot: u8,
-) -> Result<(), AppError> {
-    // let selected_consumable = player_character
-    //     .inventory
-    //     .items
-    //     .get(inventory_slot as usize)
-    //     .ok_or_else(|| AppError {
-    //         error_type: crate::errors::AppErrorTypes::InvalidInput,
-    //         message: "Tried to select an item but no item found in the inventory slot".to_string(),
-    //     })?;
-
-    // if selected_consumable.item_category != ItemCategories::Consumable {
-    //     return Err(AppError {
-    //         error_type: crate::errors::AppErrorTypes::InvalidInput,
-    //         message: "Can't select a non-consumable item".to_string(),
-    //     });
-    // }
-    // player_character.combatant_properties.selected_item_slot = Some(inventory_slot);
-
-    Ok(())
-}
diff --git a/common/src/game/player_input_handlers/use_selected_consumable.rs b/common/src/game/player_input_handlers/use_selected_consumable.rs
deleted file mode 100644
index d669f486..00000000
--- a/common/src/game/player_input_handlers/use_selected_consumable.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use crate::adventuring_party::AdventuringParty;
-use crate::errors::AppError;
-
-pub fn use_selected_consumable(
-    adventuring_party: &mut AdventuringParty,
-    player_character_id: u32,
-) -> Result<(), AppError> {
-    let player_character = adventuring_party
-        .characters
-        .get(&player_character_id)
-        .ok_or_else(|| AppError {
-            error_type: crate::errors::AppErrorTypes::InvalidInput,
-            message: "tried to process player input but couldn't find the player character"
-                .to_string(),
-        })?;
-
-    let selected_item_slot = player_character
-        .combatant_properties
-        .selected_item_slot
-        .ok_or_else(|| AppError {
-            error_type: crate::errors::AppErrorTypes::InvalidInput,
-            message: "Tried to use the selected item but no item was selected".to_string(),
-        })?;
-
-    let _selected_consumable = player_character
-        .inventory
-        .items
-        .get(selected_item_slot as usize)
-        .ok_or_else(|| AppError {
-            error_type: crate::errors::AppErrorTypes::InvalidInput,
-            message: "Tried to select an item but no item found in the inventory slot".to_string(),
-        })?;
-    // based on targets and consumable type, do something complicated
-    Ok(())
-}
diff --git a/common/src/items/consumables.rs b/common/src/items/consumables.rs
deleted file mode 100644
index 0bf1fd29..00000000
--- a/common/src/items/consumables.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::combatants::abilities::get_combatant_ability_attributes::TargetCategories;
-use crate::combatants::abilities::get_combatant_ability_attributes::TargetingScheme;
-use serde::Deserialize;
-use serde::Serialize;
-use strum_macros::EnumIter;
-
-#[derive(Debug, EnumIter, Clone, Copy, PartialEq, Serialize, Deserialize, Eq)]
-pub enum ConsumableTypes {
-    RoomFinder,
-    RepairKit,
-    UpgradeKit,
-    SmokeBomb,
-    MilkDrink,
-    FruitDrink,
-    MonsterScanner,
-    Antidote,
-    Grenade,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct ConsumableProperties {
-    pub consumable_type: ConsumableTypes,
-    pub uses_remaining: u8,
-    pub combat_use_only: bool,
-    pub requires_combat_turn: bool,
-    pub targeting_schemes: Vec<TargetingScheme>,
-    pub valid_targets: TargetCategories,
-}
diff --git a/common/src/items/consumables/get_consumable_properties.rs b/common/src/items/consumables/get_consumable_properties.rs
new file mode 100644
index 00000000..991e876a
--- /dev/null
+++ b/common/src/items/consumables/get_consumable_properties.rs
@@ -0,0 +1,37 @@
+use super::ConsumableTypes;
+use crate::combat::combat_actions::AbilityUsableContext;
+use crate::combat::combat_actions::CombatActionProperties;
+use crate::combat::combat_actions::ProhibitedTargetCombatantStates;
+use crate::combat::combat_actions::TargetCategories;
+use crate::combat::combat_actions::TargetingScheme;
+
+impl ConsumableTypes {
+    pub fn get_combat_action_properties(&self) -> CombatActionProperties {
+        match self {
+            ConsumableTypes::HpAutoinjector => CombatActionProperties {
+                targeting_schemes: vec![TargetingScheme::Single, TargetingScheme::Area],
+                valid_target_categories: TargetCategories::Friendly,
+                usability_context: AbilityUsableContext::All,
+                prohibited_target_combatant_states: Some(vec![
+                    ProhibitedTargetCombatantStates::Dead,
+                ]),
+                requires_combat_turn: false,
+            },
+            ConsumableTypes::Grenade => CombatActionProperties {
+                targeting_schemes: vec![TargetingScheme::Area],
+                valid_target_categories: TargetCategories::Opponent,
+                usability_context: AbilityUsableContext::InCombat,
+                prohibited_target_combatant_states: None,
+                requires_combat_turn: true,
+            },
+            ConsumableTypes::SmokeBomb => CombatActionProperties {
+                targeting_schemes: vec![TargetingScheme::Area],
+                valid_target_categories: TargetCategories::Friendly,
+                usability_context: AbilityUsableContext::InCombat,
+                prohibited_target_combatant_states: None,
+                requires_combat_turn: false,
+            },
+            // _ => CombatActionProperties::default(),
+        }
+    }
+}
diff --git a/common/src/items/consumables/get_consumable_requirements.rs b/common/src/items/consumables/get_consumable_requirements.rs
new file mode 100644
index 00000000..34be244e
--- /dev/null
+++ b/common/src/items/consumables/get_consumable_requirements.rs
@@ -0,0 +1,18 @@
+use super::ConsumableTypes;
+use crate::combatants::combat_attributes::CombatAttributes;
+use std::collections::HashMap;
+
+impl ConsumableTypes {
+    pub fn get_requirements(&self, item_level: u8) -> Option<HashMap<CombatAttributes, u8>> {
+        match self {
+            ConsumableTypes::HpAutoinjector => None,
+            ConsumableTypes::Grenade => Some(HashMap::from([(
+                CombatAttributes::Intelligence,
+                item_level,
+            )])),
+            ConsumableTypes::SmokeBomb => {
+                Some(HashMap::from([(CombatAttributes::Dexterity, item_level)]))
+            }
+        }
+    }
+}
diff --git a/common/src/items/consumables/mod.rs b/common/src/items/consumables/mod.rs
new file mode 100644
index 00000000..45d4643c
--- /dev/null
+++ b/common/src/items/consumables/mod.rs
@@ -0,0 +1,57 @@
+mod get_consumable_properties;
+mod get_consumable_requirements;
+use std::fmt::Display;
+
+use rand::seq::SliceRandom;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::IntoEnumIterator;
+use strum_macros::EnumIter;
+
+#[derive(Debug, EnumIter, Clone, Copy, PartialEq, Serialize, Deserialize, Eq)]
+pub enum ConsumableTypes {
+    HpAutoinjector,
+    Grenade,
+    SmokeBomb,
+    // RoomFinder,
+    // RepairKit,
+    // UpgradeKit,
+    // MilkDrink,
+    // FruitDrink,
+    // MonsterScanner,
+    // Antidote,
+}
+
+impl Display for ConsumableTypes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let to_write = match self {
+            ConsumableTypes::HpAutoinjector => "HP Autoinjector",
+            ConsumableTypes::Grenade => "Grenade",
+            ConsumableTypes::SmokeBomb => "Smoke Bomb",
+        };
+        write!(f, "{}", to_write)
+    }
+}
+
+impl ConsumableTypes {
+    pub fn random() -> Self {
+        let vec: Vec<_> = ConsumableTypes::iter().collect();
+        *vec.choose(&mut rand::thread_rng()).unwrap()
+    }
+
+    pub fn get_description(&self) -> &str {
+        match self {
+            ConsumableTypes::HpAutoinjector => "Heal a friendly target.",
+            ConsumableTypes::Grenade => "Damage a group of hostile targets.",
+            ConsumableTypes::SmokeBomb => {
+                "Apply a temporary Evasion bonus to a group of friendly targets."
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ConsumableProperties {
+    pub consumable_type: ConsumableTypes,
+    pub uses_remaining: u8,
+}
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 a15e99d6..65ac9b11 100644
--- a/common/src/items/equipment/equipment_generation/create_starting_equipment.rs
+++ b/common/src/items/equipment/equipment_generation/create_starting_equipment.rs
@@ -1,5 +1,8 @@
 use crate::combatants::combat_attributes::CombatAttributes;
 use crate::game::id_generator::IdGenerator;
+use crate::items::equipment::affixes::Affix;
+use crate::items::equipment::affixes::PrefixTypes;
+use crate::items::equipment::affixes::SuffixTypes;
 use crate::items::equipment::armor_properties::ArmorCategories;
 use crate::items::equipment::armor_properties::ArmorProperties;
 use crate::items::equipment::body_armors::BodyArmors;
@@ -60,7 +63,7 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
         ),
         durability: Some(MaxAndCurrent::new(2, 2)),
         attributes: HashMap::new(),
-        affixes: vec![],
+        affixes: vec![Affix::Suffix(SuffixTypes::Intelligence, 1)],
         traits: None,
     };
 
@@ -102,7 +105,7 @@ 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,
@@ -122,12 +125,16 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
     //     affixes: vec![],
     //     traits: None,
     // };
+    // let off_hand_entity_properties = EntityProperties {
+    //     id: id_generator.get_next_entity_id(),
+    //     name: "Rotted Stick".to_string(),
+    // };
     let off_hand_properties = EquipmentProperties {
         equipment_type: EquipmentTypes::Shield(
             Shields::MakeshiftBuckler,
             ShieldProperties {
                 size: ShieldSizes::Small,
-                armor_class: 100,
+                armor_class: 5,
             },
         ),
         durability: Some(MaxAndCurrent::new(2, 2)),
@@ -138,7 +145,7 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
 
     let off_hand_entity_properties = EntityProperties {
         id: id_generator.get_next_entity_id(),
-        name: "Rotted Stick".to_string(),
+        name: "Pot Lid".to_string(),
     };
 
     let off_hand = Item {
@@ -152,13 +159,13 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
         equipment_type: EquipmentTypes::Ring,
         durability: None,
         attributes: HashMap::new(),
-        affixes: vec![],
+        affixes: vec![Affix::Prefix(PrefixTypes::Mp, 1)],
         traits: None,
     };
 
     right_ring_properties
         .attributes
-        .insert(CombatAttributes::Hp, 2);
+        .insert(CombatAttributes::Mp, 2);
 
     let right_ring_entity_properties = EntityProperties {
         id: id_generator.get_next_entity_id(),
@@ -176,7 +183,7 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
         equipment_type: EquipmentTypes::Ring,
         durability: None,
         attributes: HashMap::new(),
-        affixes: vec![],
+        affixes: vec![Affix::Suffix(SuffixTypes::Hp, 1)],
         traits: None,
     };
 
@@ -200,7 +207,7 @@ pub fn create_starting_equipment(id_generator: &mut IdGenerator) -> HashMap<Equi
         equipment_type: EquipmentTypes::Amulet,
         durability: None,
         attributes: HashMap::new(),
-        affixes: vec![],
+        affixes: vec![Affix::Prefix(PrefixTypes::Evasion, 1)],
         traits: None,
     };
 
@@ -222,11 +229,11 @@ 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);
-    starting_equipment.insert(EquipmentSlots::Amulet, amulet);
+    // starting_equipment.insert(EquipmentSlots::RightRing, right_ring);
+    // starting_equipment.insert(EquipmentSlots::LeftRing, left_ring);
+    // starting_equipment.insert(EquipmentSlots::Amulet, amulet);
 
     starting_equipment
 }
diff --git a/common/src/items/equipment/equipment_generation/print_random_equipments.rs b/common/src/items/equipment/equipment_generation/print_random_equipments.rs
index b20f661f..6362d0b0 100644
--- a/common/src/items/equipment/equipment_generation/print_random_equipments.rs
+++ b/common/src/items/equipment/equipment_generation/print_random_equipments.rs
@@ -1,14 +1,18 @@
-use crate::{
-    app_consts::DEEPEST_FLOOR,
-    game::RoguelikeRacerGame,
-    items::{equipment::equipment_generation::name_equipment::name_equipment, Item},
-};
+use crate::app_consts::DEEPEST_FLOOR;
+use crate::game::RoguelikeRacerGame;
+use crate::items::equipment::equipment_generation::name_equipment::name_equipment;
+use crate::items::Item;
+use crate::items::ItemCategories;
 
 pub fn print_random_equipments(game: &mut RoguelikeRacerGame) {
     for _i in 1..=10 {
         for j in 1..=DEEPEST_FLOOR {
             let level = j;
-            let item = Item::generate(&mut game.id_generator, level);
+            let item = Item::generate(
+                &mut game.id_generator,
+                level,
+                Some(ItemCategories::Equipment),
+            );
             let item_name = match &item.item_properties {
                 crate::items::ItemProperties::Consumable(_) => todo!(),
                 crate::items::ItemProperties::Equipment(equipment_properties) => {
diff --git a/common/src/items/equipment/mod.rs b/common/src/items/equipment/mod.rs
index 5abf1463..fefb6814 100644
--- a/common/src/items/equipment/mod.rs
+++ b/common/src/items/equipment/mod.rs
@@ -81,18 +81,14 @@ pub enum EquipmentTraits {
 impl fmt::Display for EquipmentTraits {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            EquipmentTraits::LifeStealPercentage(number) => {
-                write!(f, "Life steal percentage: {}", number)
-            }
-            EquipmentTraits::DurabilityBonus(number) => write!(f, "Durability bonus: {}", number),
-            EquipmentTraits::ArmorClassPercentage(number) => {
-                write!(f, "Bonus armor class percentage: {}", number)
-            }
-            EquipmentTraits::DamagePercentage(number) => {
-                write!(f, "Bonus damage percentage: {}", number)
+            EquipmentTraits::LifeStealPercentage(value) => {
+                write!(f, "{value}% lifesteal")
             }
+            EquipmentTraits::DurabilityBonus(_) => write!(f, "Increased durability"),
+            EquipmentTraits::ArmorClassPercentage(value) => write!(f, "+{value}% armor class"),
+            EquipmentTraits::DamagePercentage(value) => write!(f, "+{value}% weapon damage"),
             EquipmentTraits::RandomDamageTypeSelection => {
-                write!(f, "Damage classification selected randomly")
+                write!(f, "Damage type selected randomly")
             }
         }
     }
@@ -154,10 +150,10 @@ impl EquipmentProperties {
 
     pub fn is_weapon(&self) -> bool {
         match self.equipment_type {
-            EquipmentTypes::OneHandedMeleeWeapon(_, _) |
-            EquipmentTypes::TwoHandedMeleeWeapon(_, _) |
-            EquipmentTypes::TwoHandedRangedWeapon(_, _) => true,
-            _ => false
+            EquipmentTypes::OneHandedMeleeWeapon(_, _)
+            | EquipmentTypes::TwoHandedMeleeWeapon(_, _)
+            | EquipmentTypes::TwoHandedRangedWeapon(_, _) => true,
+            _ => false,
         }
     }
 
diff --git a/common/src/items/generate_consumable_properties.rs b/common/src/items/generate_consumable_properties.rs
deleted file mode 100644
index 8b27180a..00000000
--- a/common/src/items/generate_consumable_properties.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use super::consumables::ConsumableTypes;
-use super::ConsumableProperties;
-use super::Item;
-use super::ItemProperties;
-use crate::combatants::abilities::get_combatant_ability_attributes::TargetCategories;
-use crate::combatants::abilities::get_combatant_ability_attributes::TargetingScheme;
-use rand::prelude::*;
-use std::vec;
-use strum::IntoEnumIterator;
-
-impl Item {
-    pub fn generate_consumable_properties(_level: u16) -> ItemProperties {
-        let consumable_types: Vec<_> = ConsumableTypes::iter().collect();
-        let consumable_type = *consumable_types.choose(&mut rand::thread_rng()).unwrap();
-        let uses_remaining = 1;
-
-        ItemProperties::Consumable(ConsumableProperties {
-            consumable_type,
-            uses_remaining,
-            combat_use_only: true,
-            requires_combat_turn: true,
-            targeting_schemes: vec![TargetingScheme::Single],
-            valid_targets: TargetCategories::Friendly,
-        })
-    }
-}
diff --git a/common/src/items/mod.rs b/common/src/items/mod.rs
index 2a12dc18..294d6309 100644
--- a/common/src/items/mod.rs
+++ b/common/src/items/mod.rs
@@ -2,6 +2,7 @@ pub mod consumables;
 pub mod equipment;
 pub mod items_by_level;
 use self::consumables::ConsumableProperties;
+use self::consumables::ConsumableTypes;
 use self::equipment::equipment_generation::generate_equipment_properties_from_base_item;
 use self::equipment::equipment_generation::name_equipment::name_equipment;
 use self::equipment::equipment_generation::EquipmentPropertiesAndRequirements;
@@ -11,11 +12,16 @@ use crate::combatants::combat_attributes::CombatAttributes;
 use crate::errors::AppError;
 use crate::game::id_generator::IdGenerator;
 use crate::primatives::EntityProperties;
+use rand::Rng;
 use serde::Deserialize;
 use serde::Serialize;
-mod generate_consumable_properties;
 use std::collections::HashMap;
 
+pub enum ItemCategories {
+    Equipment,
+    Consumable,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum ItemProperties {
     Consumable(ConsumableProperties),
@@ -33,22 +39,59 @@ pub struct Item {
 // const CHANCE_OF_CONSUMABLE_DROP: u16 = 20;
 
 impl Item {
-    pub fn generate(id_generator: &mut IdGenerator, level: u8) -> Item {
-        let EquipmentPropertiesAndRequirements {
-            equipment_properties,
-            requirements,
-        } = generate_equipment_properties_from_base_item(level);
-        let item_name = name_equipment(&equipment_properties);
-        println!("generated item: {item_name}");
+    pub fn generate(
+        id_generator: &mut IdGenerator,
+        item_level: u8,
+        forced_type_option: Option<ItemCategories>,
+    ) -> Item {
+        let item_type = match forced_type_option {
+            Some(forced_type) => forced_type,
+            None => {
+                let mut rng = rand::thread_rng();
+                let category_roll = rng.gen_range(0..=4);
+                if category_roll > 0 {
+                    ItemCategories::Equipment
+                } else {
+                    ItemCategories::Consumable
+                }
+            }
+        };
+        match item_type {
+            ItemCategories::Equipment => {
+                let EquipmentPropertiesAndRequirements {
+                    equipment_properties,
+                    requirements,
+                } = generate_equipment_properties_from_base_item(item_level);
+                let item_name = name_equipment(&equipment_properties);
+                println!("generated item: {item_name}");
 
-        Item {
-            entity_properties: EntityProperties {
-                id: id_generator.get_next_entity_id(),
-                name: item_name,
-            },
-            item_level: level as u8,
-            requirements,
-            item_properties: ItemProperties::Equipment(equipment_properties),
+                Item {
+                    entity_properties: EntityProperties {
+                        id: id_generator.get_next_entity_id(),
+                        name: item_name,
+                    },
+                    item_level,
+                    requirements,
+                    item_properties: ItemProperties::Equipment(equipment_properties),
+                }
+            }
+            ItemCategories::Consumable => {
+                // let consumable_type = ConsumableTypes::random();
+                let consumable_type = ConsumableTypes::HpAutoinjector;
+                let item_name = format!("{}", consumable_type);
+                Item {
+                    entity_properties: EntityProperties {
+                        id: id_generator.get_next_entity_id(),
+                        name: item_name,
+                    },
+                    item_level,
+                    requirements: consumable_type.get_requirements(item_level),
+                    item_properties: ItemProperties::Consumable(ConsumableProperties {
+                        consumable_type,
+                        uses_remaining: 1,
+                    }),
+                }
+            }
         }
     }
 
diff --git a/common/src/monsters/mod.rs b/common/src/monsters/mod.rs
index 8cf31d0c..c8ae0c0b 100644
--- a/common/src/monsters/mod.rs
+++ b/common/src/monsters/mod.rs
@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 mod random_monster_names;
-
+use self::random_monster_names::MONSTER_FIRST_NAMES;
+use self::random_monster_names::MONSTER_LAST_NAMES;
 use crate::combatants::abilities::CombatantAbility;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::combat_attributes::CombatAttributes;
@@ -12,12 +13,10 @@ use crate::primatives::EntityProperties;
 use rand::seq::SliceRandom;
 use serde::Deserialize;
 use serde::Serialize;
+use std::cmp;
 use std::collections::HashMap;
 use strum_macros::EnumIter;
 
-use self::random_monster_names::MONSTER_FIRST_NAMES;
-use self::random_monster_names::MONSTER_LAST_NAMES;
-
 #[derive(Debug, EnumIter, Clone, Copy, PartialEq)]
 pub enum MonsterTraits {
     ManaShield,
@@ -49,7 +48,7 @@ pub fn generate_random_monster_name() -> String {
 }
 
 impl Monster {
-    pub fn generate(id_generator: &mut IdGenerator, _level: u8, hp: u16) -> Monster {
+    pub fn generate(id_generator: &mut IdGenerator, level: u8, hp: u16) -> Monster {
         let mut monster = Monster {
             entity_properties: EntityProperties {
                 id: id_generator.get_next_entity_id(),
@@ -65,11 +64,15 @@ impl Monster {
         let inherent_attributes = &mut monster.combatant_properties.inherent_attributes;
         inherent_attributes.insert(CombatAttributes::Hp, hp);
         inherent_attributes.insert(CombatAttributes::Damage, 1);
-        inherent_attributes.insert(CombatAttributes::Strength, 15);
-        inherent_attributes.insert(CombatAttributes::Dexterity, 1);
-        inherent_attributes.insert(CombatAttributes::Vitality, 2);
-        inherent_attributes.insert(CombatAttributes::Resilience, 2);
-        inherent_attributes.insert(CombatAttributes::Agility, 1);
+        inherent_attributes.insert(CombatAttributes::Strength, 3 * level as u16);
+        inherent_attributes.insert(CombatAttributes::Dexterity, 1 * level as u16);
+        inherent_attributes.insert(CombatAttributes::Vitality, 1 * level as u16);
+        inherent_attributes.insert(CombatAttributes::Resilience, 1 * level as u16);
+        inherent_attributes.insert(CombatAttributes::ArmorClass, 10 * (level - 1) as u16);
+        inherent_attributes.insert(
+            CombatAttributes::Agility,
+            cmp::max(1, 1 * (level as u16 / 4)),
+        );
         inherent_attributes.insert(CombatAttributes::Accuracy, 75);
 
         let total_attributes = monster.combatant_properties.get_total_attributes();
diff --git a/common/src/monsters/random_monster_names.rs b/common/src/monsters/random_monster_names.rs
index a968c26c..64bcebd3 100644
--- a/common/src/monsters/random_monster_names.rs
+++ b/common/src/monsters/random_monster_names.rs
@@ -1,5 +1,3 @@
-use once_cell::unsync::Lazy;
-
 pub static MONSTER_FIRST_NAMES: [&str; 9] = [
     "rock",
     "ghost",
diff --git a/common/src/packets/client_to_server.rs b/common/src/packets/client_to_server.rs
index ae8b0ca4..bb3ef6ec 100644
--- a/common/src/packets/client_to_server.rs
+++ b/common/src/packets/client_to_server.rs
@@ -1,6 +1,6 @@
 use super::CharacterAndItem;
 use super::CharacterAndSlot;
-use crate::combatants::abilities::AbilityTarget;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::CombatantClass;
 use crate::items::equipment::EquipmentSlots;
@@ -22,11 +22,12 @@ pub enum PlayerInputs {
     DeleteCharacter(u32),
     ToggleReady,
     // use items and abilities
-    SelectConsumable(u8),
-    UseSelectedConsumable,
+    UseSelectedConsumable(u32), // character_id
     SelectAbility(ClientSelectAbilityPacket),
-    UseSelectedAbility(u32),
-    ChangeTargets(ChangeTargetsPacket),
+    SelectConsumable(ClientSelectConsumablePacket),
+    UseSelectedAbility(u32), // character_id
+    ChangeAbilityTargets(ChangeTargetsPacket),
+    ChangeConsumableTargets(ChangeTargetsPacket),
     ClearConsumableAndAbilitySelections,
     // manage equipment and items
     UnequipEquipmentSlot(CharacterAndSlot),
@@ -92,8 +93,14 @@ pub struct ClientSelectAbilityPacket {
     pub ability_name_option: Option<CombatantAbilityNames>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ClientSelectConsumablePacket {
+    pub character_id: u32,
+    pub consumable_id_option: Option<u32>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ChangeTargetsPacket {
     pub character_id: u32,
-    pub new_targets: AbilityTarget,
+    pub new_targets: CombatActionTarget,
 }
diff --git a/common/src/packets/server_to_client.rs b/common/src/packets/server_to_client.rs
index 86b0207c..1212f384 100644
--- a/common/src/packets/server_to_client.rs
+++ b/common/src/packets/server_to_client.rs
@@ -6,9 +6,9 @@ use super::WebsocketChannelNamespace;
 use crate::app_consts::LOBBY_CHANNEL;
 use crate::character::Character;
 use crate::combat::battle::Battle;
+use crate::combat::combat_actions::CombatActionTarget;
 use crate::combat::ActionResult;
 use crate::combat::CombatTurnResult;
-use crate::combatants::abilities::AbilityTarget;
 use crate::combatants::abilities::CombatantAbilityNames;
 use crate::combatants::CombatantClass;
 use crate::dungeon_rooms::DungeonRoom;
@@ -54,8 +54,9 @@ pub enum GameServerUpdatePackets {
     PlayerToggledReadyToDescend(String),
     DungeonRoomUpdate(DungeonRoom),
     CharacterSelectedAbility(CharacterSelectedAbilityPacket),
+    CharacterSelectedConsumable(CharacterSelectedConsumablePacket),
     CharacterChangedTargets(ChangeTargetsPacket),
-    ActionResults(Vec<ActionResult>),
+    ActionResults(ActionResultsPacket),
     CombatTurnResults(CombatTurnResultsPacket),
     BattleFullUpdate(Option<Battle>),
     BattleEndReport(BattleEndReportPacket),
@@ -179,7 +180,14 @@ pub struct CharacterEquippedItemPacket {
 pub struct CharacterSelectedAbilityPacket {
     pub character_id: u32,
     pub ability_name_option: Option<CombatantAbilityNames>,
-    pub targets_option: Option<AbilityTarget>,
+    pub targets_option: Option<CombatActionTarget>,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+pub struct CharacterSelectedConsumablePacket {
+    pub character_id: u32,
+    pub consumable_id_option: Option<u32>,
+    pub targets_option: Option<CombatActionTarget>,
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
@@ -187,6 +195,12 @@ pub struct CombatTurnResultsPacket {
     pub turn_results: Vec<CombatTurnResult>,
 }
 
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+pub struct ActionResultsPacket {
+    pub action_taker_id: u32,
+    pub action_results: Vec<ActionResult>,
+}
+
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
 pub enum BattleConclusion {
     Victory,
diff --git a/rustc-ice-2024-01-10T13_40_56-6194.txt b/rustc-ice-2024-01-10T13_40_56-6194.txt
deleted file mode 100644
index d10c3608..00000000
--- a/rustc-ice-2024-01-10T13_40_56-6194.txt
+++ /dev/null
@@ -1,72 +0,0 @@
-thread 'rustc' panicked at compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs:206:1:
-DefId(2:10129 ~ core[be13]::slice::sort::merge_sort::{impl#3}::RunDeallocF) does not have a "codegen_fn_attrs"
-stack backtrace:
-   0:     0x7fec34b73a41 - std::backtrace_rs::backtrace::libunwind::trace::h6d90fa0094086b5c
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/../../backtrace/src/backtrace/libunwind.rs:104:5
-   1:     0x7fec34b73a41 - std::backtrace_rs::backtrace::trace_unsynchronized::h8fb92949d42e0fa9
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/../../backtrace/src/backtrace/mod.rs:66:5
-   2:     0x7fec34b73a41 - std::backtrace::Backtrace::create::h1766762112653ae9
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/backtrace.rs:332:13
-   3:     0x7fec34b73990 - std::backtrace::Backtrace::force_capture::hac5e57de6e01a314
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/backtrace.rs:313:9
-   4:     0x7fec378ee3cc - std[4cb60fd801078bdf]::panicking::update_hook::<alloc[df4418b9fd506964]::boxed::Box<rustc_driver_impl[d84bb1f35ddd583b]::install_ice_hook::{closure#0}>>::{closure#0}
-   5:     0x7fec34b8eb48 - <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call::ha4f1e8ac23a95a60
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/alloc/src/boxed.rs:2021:9
-   6:     0x7fec34b8eb48 - std::panicking::rust_panic_with_hook::h5b02200e0a5b55a6
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/panicking.rs:783:13
-   7:     0x7fec34b8e89e - std::panicking::begin_panic_handler::{{closure}}::h495108432d2bb510
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/panicking.rs:657:13
-   8:     0x7fec34b8be56 - std::sys_common::backtrace::__rust_end_short_backtrace::h84cced95050bc7e7
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/sys_common/backtrace.rs:171:18
-   9:     0x7fec34b8e602 - rust_begin_unwind
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/panicking.rs:645:5
-  10:     0x7fec34bdb0a5 - core::panicking::panic_fmt::he8f6e27cba479969
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/core/src/panicking.rs:72:14
-  11:     0x7fec37d04772 - rustc_metadata[2c08148afcbcfe08]::rmeta::decoder::cstore_impl::provide_extern::codegen_fn_attrs::{closure#2}
-  12:     0x7fec38c48024 - rustc_metadata[2c08148afcbcfe08]::rmeta::decoder::cstore_impl::provide_extern::codegen_fn_attrs
-  13:     0x7fec38c4654d - rustc_query_impl[22e04eec66359a]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[22e04eec66359a]::query_impl::codegen_fn_attrs::dynamic_query::{closure#2}::{closure#0}, rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 8usize]>>
-  14:     0x7fec38f1a134 - rustc_query_system[6e01c034ad58b08d]::query::plumbing::try_execute_query::<rustc_query_impl[22e04eec66359a]::DynamicConfig<rustc_query_system[6e01c034ad58b08d]::query::caches::DefaultCache<rustc_span[64fea803d0599ae5]::def_id::DefId, rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 8usize]>>, false, false, false>, rustc_query_impl[22e04eec66359a]::plumbing::QueryCtxt, true>
-  15:     0x7fec38f197c9 - rustc_query_impl[22e04eec66359a]::query_impl::codegen_fn_attrs::get_query_incr::__rust_end_short_backtrace
-  16:     0x7fec38c49b96 - <rustc_middle[36fd5bbd7bf4e42c]::mir::mono::MonoItem>::instantiation_mode
-  17:     0x7fec38c48b30 - rustc_monomorphize[7c6bd8c869eb35e]::partitioning::place_mono_items::get_reachable_inlined_items
-  18:     0x7fec39b0432b - rustc_monomorphize[7c6bd8c869eb35e]::partitioning::partition::<core[2f0726d93b49423]::iter::adapters::copied::Copied<std[4cb60fd801078bdf]::collections::hash::set::Iter<rustc_middle[36fd5bbd7bf4e42c]::mir::mono::MonoItem>>>
-  19:     0x7fec39b01282 - rustc_monomorphize[7c6bd8c869eb35e]::partitioning::collect_and_partition_mono_items::{closure#0}::{closure#0}
-  20:     0x7fec39b5cb35 - rustc_monomorphize[7c6bd8c869eb35e]::partitioning::collect_and_partition_mono_items
-  21:     0x7fec39b5bca4 - rustc_query_impl[22e04eec66359a]::plumbing::__rust_begin_short_backtrace::<rustc_query_impl[22e04eec66359a]::query_impl::collect_and_partition_mono_items::dynamic_query::{closure#2}::{closure#0}, rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 24usize]>>
-  22:     0x7fec39b5bc89 - <rustc_query_impl[22e04eec66359a]::query_impl::collect_and_partition_mono_items::dynamic_query::{closure#2} as core[2f0726d93b49423]::ops::function::FnOnce<(rustc_middle[36fd5bbd7bf4e42c]::ty::context::TyCtxt, ())>>::call_once
-  23:     0x7fec39b5a577 - rustc_query_system[6e01c034ad58b08d]::query::plumbing::try_execute_query::<rustc_query_impl[22e04eec66359a]::DynamicConfig<rustc_query_system[6e01c034ad58b08d]::query::caches::SingleCache<rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 24usize]>>, false, false, false>, rustc_query_impl[22e04eec66359a]::plumbing::QueryCtxt, true>
-  24:     0x7fec39c7c5bd - rustc_query_impl[22e04eec66359a]::plumbing::force_from_dep_node::<rustc_query_impl[22e04eec66359a]::DynamicConfig<rustc_query_system[6e01c034ad58b08d]::query::caches::SingleCache<rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 24usize]>>, false, false, false>>
-  25:     0x7fec39c4d0c9 - <rustc_query_impl[22e04eec66359a]::plumbing::query_callback<rustc_query_impl[22e04eec66359a]::query_impl::collect_and_partition_mono_items::QueryType>::{closure#0} as core[2f0726d93b49423]::ops::function::FnOnce<(rustc_middle[36fd5bbd7bf4e42c]::ty::context::TyCtxt, rustc_query_system[6e01c034ad58b08d]::dep_graph::dep_node::DepNode)>>::call_once
-  26:     0x7fec38c3fe2d - <rustc_query_system[6e01c034ad58b08d]::dep_graph::graph::DepGraphData<rustc_middle[36fd5bbd7bf4e42c]::dep_graph::DepsType>>::try_mark_previous_green::<rustc_query_impl[22e04eec66359a]::plumbing::QueryCtxt>
-  27:     0x7fec38c3f3df - <rustc_query_system[6e01c034ad58b08d]::dep_graph::graph::DepGraphData<rustc_middle[36fd5bbd7bf4e42c]::dep_graph::DepsType>>::try_mark_green::<rustc_query_impl[22e04eec66359a]::plumbing::QueryCtxt>
-  28:     0x7fec39776e38 - rustc_query_system[6e01c034ad58b08d]::query::plumbing::try_execute_query::<rustc_query_impl[22e04eec66359a]::DynamicConfig<rustc_query_system[6e01c034ad58b08d]::query::caches::VecCache<rustc_span[64fea803d0599ae5]::def_id::CrateNum, rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 16usize]>>, false, false, false>, rustc_query_impl[22e04eec66359a]::plumbing::QueryCtxt, true>
-  29:     0x7fec39777e7d - rustc_query_impl[22e04eec66359a]::query_impl::exported_symbols::get_query_incr::__rust_end_short_backtrace
-  30:     0x7fec397781cb - rustc_middle[36fd5bbd7bf4e42c]::query::plumbing::query_get_at::<rustc_query_system[6e01c034ad58b08d]::query::caches::VecCache<rustc_span[64fea803d0599ae5]::def_id::CrateNum, rustc_middle[36fd5bbd7bf4e42c]::query::erase::Erased<[u8; 16usize]>>>
-  31:     0x7fec39bb341d - <rustc_metadata[2c08148afcbcfe08]::rmeta::encoder::EncodeContext>::encode_crate_root
-  32:     0x7fec39bc8e3d - rustc_metadata[2c08148afcbcfe08]::rmeta::encoder::encode_metadata::{closure#0}
-  33:     0x7fec39bc7694 - rustc_metadata[2c08148afcbcfe08]::rmeta::encoder::encode_metadata
-  34:     0x7fec39bc6a1f - rustc_metadata[2c08148afcbcfe08]::fs::encode_and_write_metadata
-  35:     0x7fec395905c0 - rustc_interface[e1187cb3f5edab83]::passes::start_codegen
-  36:     0x7fec3958fdf1 - <rustc_interface[e1187cb3f5edab83]::queries::Queries>::codegen_and_build_linker
-  37:     0x7fec39722a9c - rustc_interface[e1187cb3f5edab83]::interface::run_compiler::<core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>, rustc_driver_impl[d84bb1f35ddd583b]::run_compiler::{closure#0}>::{closure#0}
-  38:     0x7fec39b7ddd4 - std[4cb60fd801078bdf]::sys_common::backtrace::__rust_begin_short_backtrace::<rustc_interface[e1187cb3f5edab83]::util::run_in_thread_with_globals<rustc_interface[e1187cb3f5edab83]::util::run_in_thread_pool_with_globals<rustc_interface[e1187cb3f5edab83]::interface::run_compiler<core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>, rustc_driver_impl[d84bb1f35ddd583b]::run_compiler::{closure#0}>::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>
-  39:     0x7fec39b7dbfd - <<std[4cb60fd801078bdf]::thread::Builder>::spawn_unchecked_<rustc_interface[e1187cb3f5edab83]::util::run_in_thread_with_globals<rustc_interface[e1187cb3f5edab83]::util::run_in_thread_pool_with_globals<rustc_interface[e1187cb3f5edab83]::interface::run_compiler<core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>, rustc_driver_impl[d84bb1f35ddd583b]::run_compiler::{closure#0}>::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[2f0726d93b49423]::result::Result<(), rustc_span[64fea803d0599ae5]::ErrorGuaranteed>>::{closure#1} as core[2f0726d93b49423]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
-  40:     0x7fec34b989e5 - <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once::h9084c9953d3a76cd
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/alloc/src/boxed.rs:2007:9
-  41:     0x7fec34b989e5 - <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once::h2281f6351bcdd799
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/alloc/src/boxed.rs:2007:9
-  42:     0x7fec34b989e5 - std::sys::unix::thread::Thread::new::thread_start::h291842fe43c3f6cd
-                               at /rustc/37b2813a7be580ef59048a6bd08444c79e5cc97f/library/std/src/sys/unix/thread.rs:108:17
-  43:     0x7fec349899eb - <unknown>
-  44:     0x7fec34a0d7cc - <unknown>
-  45:                0x0 - <unknown>
-
-
-rustc version: 1.76.0-nightly (37b2813a7 2023-11-24)
-platform: x86_64-unknown-linux-gnu
-
-query stack during panic:
-#0 [codegen_fn_attrs] computing codegen attributes of `<core::slice::sort::merge_sort::RunVec<RunAllocF, RunDeallocF> as core::ops::index::Index<usize>>::RunDeallocF`
-#1 [collect_and_partition_mono_items] collect_and_partition_mono_items
-#2 [exported_symbols] collecting exported symbols for crate `0`
-end of query stack
diff --git a/server/src/main.rs b/server/src/main.rs
index 509fabae..63ccd324 100644
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -9,8 +9,6 @@ use actix_web::HttpServer;
 use actix_web::Responder;
 use actix_web_actors::ws;
 use rand::Rng;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
 use std::time::Instant;
 use websocket_server::websocket_actor::WebsocketActor;
 mod random_names;
diff --git a/server/src/random_names.rs b/server/src/random_names.rs
index 946b66ff..60bd9c9a 100644
--- a/server/src/random_names.rs
+++ b/server/src/random_names.rs
@@ -18,3 +18,36 @@ pub static PLAYER_LAST_NAMES: [&str; 14] = [
     "dixon",
     "peletier",
 ];
+
+pub static RANDOM_GAME_NAMES_FIRST: [&str; 10] = [
+    "strange",
+    "silent",
+    "dark",
+    "eerie",
+    "spooky",
+    "creaky",
+    "rotten",
+    "forgotten",
+    "unsettling",
+    "uncanny",
+];
+
+pub static RANDOM_GAME_NAMES_LAST: [&str; 17] = [
+    "ravine",
+    "cave",
+    "hill",
+    "valley",
+    "tunnel",
+    "sewer",
+    "underground",
+    "descent",
+    "catacomb",
+    "rift",
+    "cellar",
+    "mine",
+    "nest",
+    "tomb",
+    "crypt",
+    "canyon",
+    "forest",
+];
diff --git a/server/src/utils.rs b/server/src/utils.rs
index 04f4b413..4e3d29e3 100644
--- a/server/src/utils.rs
+++ b/server/src/utils.rs
@@ -2,6 +2,8 @@ use rand::seq::SliceRandom;
 
 use crate::random_names::PLAYER_FIRST_NAMES;
 use crate::random_names::PLAYER_LAST_NAMES;
+use crate::random_names::RANDOM_GAME_NAMES_FIRST;
+use crate::random_names::RANDOM_GAME_NAMES_LAST;
 
 pub fn generate_random_username() -> String {
     let mut rng = rand::thread_rng();
@@ -9,3 +11,10 @@ pub fn generate_random_username() -> String {
     let last_name = PLAYER_LAST_NAMES.choose(&mut rng).unwrap();
     format!("{first_name} {last_name}").to_string()
 }
+
+pub fn generate_random_game_name() -> String {
+    let mut rng = rand::thread_rng();
+    let first_name = RANDOM_GAME_NAMES_FIRST.choose(&mut rng).unwrap();
+    let last_name = RANDOM_GAME_NAMES_LAST.choose(&mut rng).unwrap();
+    format!("{first_name} {last_name}").to_string()
+}
diff --git a/server/src/websocket_server/game_server/mod.rs b/server/src/websocket_server/game_server/mod.rs
index d433a4c7..5cbc939f 100644
--- a/server/src/websocket_server/game_server/mod.rs
+++ b/server/src/websocket_server/game_server/mod.rs
@@ -138,9 +138,18 @@ impl Handler<ClientBinaryMessage> for GameServer {
             Ok(PlayerInputs::SelectAbility(packet)) => {
                 self.character_selects_ability_handler(message.actor_id, packet)
             }
-            Ok(PlayerInputs::ChangeTargets(packet)) => {
+            Ok(PlayerInputs::SelectConsumable(packet)) => {
+                self.character_selects_consumable_handler(message.actor_id, packet)
+            }
+            Ok(PlayerInputs::UseSelectedConsumable(character_id)) => {
+                self.character_uses_selected_consumable_handler(message.actor_id, character_id)
+            }
+            Ok(PlayerInputs::ChangeAbilityTargets(packet)) => {
                 self.character_changes_ability_targets_handler(message.actor_id, packet)
             }
+            Ok(PlayerInputs::ChangeConsumableTargets(packet)) => {
+                self.character_changes_consumable_targets_handler(message.actor_id, packet)
+            }
             Ok(PlayerInputs::UseSelectedAbility(character_id)) => {
                 self.character_uses_selected_ability_handler(message.actor_id, character_id)
             }
diff --git a/server/src/websocket_server/game_server/player_input_handlers/create_game_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/create_game_handler.rs
index e65aa8e7..bfbe8d2b 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/create_game_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/create_game_handler.rs
@@ -1,3 +1,4 @@
+use crate::utils::generate_random_game_name;
 use crate::websocket_server::game_server::getters::get_mut_user;
 use crate::websocket_server::game_server::GameServer;
 use common::app_consts::error_messages;
@@ -23,7 +24,11 @@ impl GameServer {
                 message: error_messages::ALREADY_IN_GAME.to_string(),
             });
         }
-        if self.games.get(game_name).is_some() {
+        let mut game_name = game_name.clone();
+        if game_name == "" {
+            game_name = generate_random_game_name().to_string();
+        }
+        if self.games.get(&game_name).is_some() {
             return Err(AppError {
                 error_type: common::errors::AppErrorTypes::InvalidInput,
                 message: error_messages::GAME_ALREADY_EXISTS.to_string(),
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/apply_action_results.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/apply_action_results.rs
index 15a007ea..490e8592 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/apply_action_results.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/apply_action_results.rs
@@ -1,3 +1,5 @@
+use common::app_consts::error_messages;
+use common::combat::combat_actions::CombatAction;
 use common::combat::ActionResult;
 use common::errors::AppError;
 use common::game::RoguelikeRacerGame;
@@ -5,9 +7,10 @@ use common::game::RoguelikeRacerGame;
 pub fn apply_action_results(
     game: &mut RoguelikeRacerGame,
     action_results: &Vec<ActionResult>,
+    battle_id_option: Option<u32>,
 ) -> Result<(), AppError> {
     for action_result in action_results {
-        apply_action_result(game, &action_result)?;
+        apply_action_result(game, &action_result, battle_id_option)?;
     }
 
     Ok(())
@@ -16,11 +19,52 @@ pub fn apply_action_results(
 pub fn apply_action_result(
     game: &mut RoguelikeRacerGame,
     action_result: &ActionResult,
+    battle_id_option: Option<u32>,
 ) -> Result<(), AppError> {
+    let user_id = action_result.user_id;
+    let (_, user_combatant_properties) = game.get_mut_combatant_by_id(&user_id)?;
+    user_combatant_properties.selected_ability_name = None;
+    user_combatant_properties.selected_consumable = None;
+    user_combatant_properties.combat_action_targets = None;
+
+    match action_result.action {
+        CombatAction::AbilityUsed(_) => (),
+        CombatAction::ConsumableUsed(item_id) => {
+            let consumable = user_combatant_properties
+                .inventory
+                .get_consumable_mut(&item_id)?;
+            consumable.uses_remaining -= 1;
+            let should_be_removed_from_inventory = consumable.uses_remaining == 0;
+            if should_be_removed_from_inventory {
+                user_combatant_properties.inventory.remove_item(item_id)?;
+            }
+        }
+    }
+
     if let Some(hp_changes) = &action_result.hp_changes_by_entity_id {
         for (entity_id, hp_change) in hp_changes.iter() {
-            let (_, combatant_properties) = game.get_mut_combatant_by_id(entity_id)?;
+            let (entity_properties, combatant_properties) =
+                game.get_mut_combatant_by_id(entity_id)?;
+            let entity_id = entity_properties.id;
             combatant_properties.change_hp(*hp_change);
+
+            if combatant_properties.hit_points == 0 {
+                if let Some(battle_id) = battle_id_option {
+                    let battle = game.battles.get_mut(&battle_id).ok_or_else(|| AppError {
+                        error_type: common::errors::AppErrorTypes::ServerError,
+                        message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                    })?;
+                    let mut index_to_remove_option = None;
+                    for (i, turn_tracker) in battle.combatant_turn_trackers.iter().enumerate() {
+                        if turn_tracker.entity_id == entity_id {
+                            index_to_remove_option = Some(i)
+                        }
+                    }
+                    if let Some(index_to_remove) = index_to_remove_option {
+                        let _ = battle.combatant_turn_trackers.remove(index_to_remove);
+                    }
+                }
+            }
         }
     }
 
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_ability_targets_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_ability_targets_handler.rs
index fb39b0d1..d4b7fcae 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_ability_targets_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_ability_targets_handler.rs
@@ -1,10 +1,10 @@
+use super::character_changes_combat_action_targets_handler::character_changes_combat_action_targets_handler;
 use crate::websocket_server::game_server::getters::get_mut_game;
 use crate::websocket_server::game_server::getters::get_mut_party_game_name_and_character_ids_from_actor_id;
 use crate::websocket_server::game_server::getters::get_user;
 use crate::websocket_server::game_server::getters::ActorIdAssociatedPartyData;
 use crate::websocket_server::game_server::GameServer;
 use common::app_consts::error_messages::{self};
-use common::combatants::abilities::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
 use common::errors::AppError;
 use common::errors::AppErrorTypes;
 use common::game::getters::get_mut_party;
@@ -24,6 +24,10 @@ impl GameServer {
             new_targets,
         } = packet;
 
+        let ActorIdAssociatedPartyData {
+            player_character_ids_option,
+            ..
+        } = get_mut_party_game_name_and_character_ids_from_actor_id(self, actor_id)?;
         let connected_user = get_user(&self.sessions, actor_id)?;
         let username = connected_user.username.clone();
         let current_game_name =
@@ -53,62 +57,30 @@ impl GameServer {
                 error_type: AppErrorTypes::Generic,
                 message: error_messages::NO_ABILITY_SELECTED.to_string(),
             })?;
-        let ability = combatant.get_ability_if_owned(&ability_name)?;
-        let ability_name = ability.ability_name.clone();
-
-        let (ally_ids, opponent_ids_option) = if let Some(battle_id) = battle_id_option {
-            let battle = game.battles.get(&battle_id).ok_or_else(|| AppError {
-                error_type: AppErrorTypes::Generic,
-                message: error_messages::BATTLE_NOT_FOUND.to_string(),
-            })?;
-
-            battle.get_ally_ids_and_opponent_ids_option(character_id)?
-        } else {
-            (character_positions.clone(), None)
-        };
+        let _ = combatant.get_ability_if_owned(&ability_name)?;
+        let ability_attributes = ability_name.get_attributes();
+        let combat_action_properties = ability_attributes.combat_action_properties;
 
-        let prohibited_target_combatant_states = ability_name
-            .get_attributes()
-            .prohibited_target_combatant_states;
-        let (ally_ids, opponent_ids_option) =
-            filter_possible_target_ids_by_prohibited_combatant_states(
+        let (new_targets, new_target_preferences) =
+            character_changes_combat_action_targets_handler(
                 game,
-                prohibited_target_combatant_states,
-                ally_ids,
-                opponent_ids_option,
+                new_targets,
+                combat_action_properties,
+                character_id,
+                battle_id_option,
+                character_positions,
+                player_character_ids_option.clone(),
+                party_id,
             )?;
 
-        let new_targets = if ability_name.targets_are_valid(
-            character_id,
-            &new_targets,
-            &ally_ids,
-            &opponent_ids_option,
-        ) {
-            new_targets
-        } else {
-            ability_name.get_default_targets(character_id, &ally_ids, &opponent_ids_option)?
-        };
-
-        let ActorIdAssociatedPartyData {
-            party,
-            player_character_ids_option,
-            ..
-        } = get_mut_party_game_name_and_character_ids_from_actor_id(self, actor_id)?;
-        let character =
-            party.get_character_if_owned(player_character_ids_option.clone(), character_id)?;
-
-        let target_preferences = &character.combatant_properties.ability_target_preferences;
-        let new_target_preferences = target_preferences.get_updated_preferences(
-            &ability_name,
-            &new_targets,
-            ally_ids,
-            opponent_ids_option,
-        );
+        let party = get_mut_party(game, party_id)?;
         let character =
             party.get_mut_character_if_owned(player_character_ids_option, character_id)?;
 
-        character.combatant_properties.ability_target_preferences = new_target_preferences;
-        character.combatant_properties.ability_targets = Some(new_targets.clone());
+        character
+            .combatant_properties
+            .combat_action_target_preferences = new_target_preferences;
+        character.combatant_properties.combat_action_targets = Some(new_targets.clone());
 
         self.emit_packet(
             &party_websocket_channel_name,
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_combat_action_targets_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_combat_action_targets_handler.rs
new file mode 100644
index 00000000..93abbaa6
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_combat_action_targets_handler.rs
@@ -0,0 +1,79 @@
+use common::app_consts::error_messages;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::combat::combat_actions::CombatActionProperties;
+use common::combat::combat_actions::CombatActionTarget;
+use common::combatants::CombatActionTargetPreferences;
+use common::errors::AppError;
+use common::errors::AppErrorTypes;
+use common::game::RoguelikeRacerGame;
+use std::collections::HashSet;
+
+pub fn character_changes_combat_action_targets_handler(
+    game: &mut RoguelikeRacerGame,
+    new_targets: CombatActionTarget,
+    combat_action_properties: CombatActionProperties,
+    character_id: u32,
+    battle_id_option: Option<u32>,
+    character_positions: Vec<u32>,
+    player_character_ids_option: Option<HashSet<u32>>,
+    party_id: u32,
+) -> Result<(CombatActionTarget, CombatActionTargetPreferences), AppError> {
+    let (ally_ids, opponent_ids_option) = if let Some(battle_id) = battle_id_option {
+        let battle = game.battles.get(&battle_id).ok_or_else(|| AppError {
+            error_type: AppErrorTypes::Generic,
+            message: error_messages::BATTLE_NOT_FOUND.to_string(),
+        })?;
+
+        battle.get_ally_ids_and_opponent_ids_option(character_id)?
+    } else {
+        (character_positions.clone(), None)
+    };
+
+    let prohibited_target_combatant_states = combat_action_properties
+        .prohibited_target_combatant_states
+        .clone();
+    let (ally_ids, opponent_ids_option) =
+        filter_possible_target_ids_by_prohibited_combatant_states(
+            game,
+            &prohibited_target_combatant_states,
+            ally_ids,
+            opponent_ids_option,
+        )?;
+
+    let new_targets = if combat_action_properties.targets_are_valid(
+        character_id,
+        &new_targets,
+        &ally_ids,
+        &opponent_ids_option,
+    ) {
+        new_targets
+    } else {
+        combat_action_properties.get_default_targets(
+            character_id,
+            &ally_ids,
+            &opponent_ids_option,
+        )?
+    };
+
+    let party = game
+        .adventuring_parties
+        .get(&party_id)
+        .ok_or_else(|| AppError {
+            error_type: AppErrorTypes::ServerError,
+            message: error_messages::PARTY_NOT_FOUND.to_string(),
+        })?;
+    let character =
+        party.get_character_if_owned(player_character_ids_option.clone(), character_id)?;
+
+    let target_preferences = &character
+        .combatant_properties
+        .combat_action_target_preferences;
+    let new_target_preferences = target_preferences.get_updated_preferences(
+        &combat_action_properties,
+        &new_targets,
+        ally_ids,
+        opponent_ids_option,
+    );
+
+    Ok((new_targets, new_target_preferences))
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_consumable_targets_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_consumable_targets_handler.rs
new file mode 100644
index 00000000..2e094ce5
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_changes_consumable_targets_handler.rs
@@ -0,0 +1,101 @@
+use super::character_changes_combat_action_targets_handler::character_changes_combat_action_targets_handler;
+use crate::websocket_server::game_server::getters::get_mut_game;
+use crate::websocket_server::game_server::getters::get_mut_party_game_name_and_character_ids_from_actor_id;
+use crate::websocket_server::game_server::getters::get_user;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedPartyData;
+use crate::websocket_server::game_server::GameServer;
+use common::app_consts::error_messages::{self};
+use common::errors::AppError;
+use common::errors::AppErrorTypes;
+use common::game::getters::get_mut_party;
+use common::game::getters::get_mut_player;
+use common::packets::client_to_server::ChangeTargetsPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+
+impl GameServer {
+    pub fn character_changes_consumable_targets_handler(
+        &mut self,
+        actor_id: u32,
+        packet: ChangeTargetsPacket,
+    ) -> Result<(), AppError> {
+        let ChangeTargetsPacket {
+            character_id,
+            new_targets,
+        } = packet;
+
+        let ActorIdAssociatedPartyData {
+            player_character_ids_option,
+            ..
+        } = get_mut_party_game_name_and_character_ids_from_actor_id(self, actor_id)?;
+        let connected_user = get_user(&self.sessions, actor_id)?;
+        let username = connected_user.username.clone();
+        let current_game_name =
+            connected_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, &current_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();
+        let battle_id_option = party.battle_id.clone();
+        let character_positions = party.character_positions.clone();
+        let (_, combatant) = party.get_mut_combatant_by_id(&character_id)?;
+        let consumable_id = combatant
+            .selected_consumable
+            .clone()
+            .ok_or_else(|| AppError {
+                error_type: AppErrorTypes::Generic,
+                message: error_messages::NO_CONSUMABLE_SELECTED.to_string(),
+            })?;
+        let character =
+            party.get_character_if_owned(player_character_ids_option.clone(), character_id)?;
+        let conusmable_properties = character
+            .combatant_properties
+            .inventory
+            .get_consumable(&consumable_id)?;
+        let combat_action_properties = conusmable_properties
+            .consumable_type
+            .get_combat_action_properties();
+
+        let (new_targets, new_target_preferences) =
+            character_changes_combat_action_targets_handler(
+                game,
+                new_targets,
+                combat_action_properties,
+                character_id,
+                battle_id_option,
+                character_positions,
+                player_character_ids_option.clone(),
+                party_id,
+            )?;
+
+        let party = get_mut_party(game, party_id)?;
+        let character =
+            party.get_mut_character_if_owned(player_character_ids_option, character_id)?;
+
+        character
+            .combatant_properties
+            .combat_action_target_preferences = new_target_preferences;
+        character.combatant_properties.combat_action_targets = Some(new_targets.clone());
+
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::CharacterChangedTargets(ChangeTargetsPacket {
+                character_id,
+                new_targets,
+            }),
+            None,
+        )
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_drops_item.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_drops_item.rs
index 46cf7626..4b7af0a4 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_drops_item.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_drops_item.rs
@@ -26,7 +26,7 @@ impl GameServer {
             .get_mut_character_if_owned(player_character_ids_option.clone(), packet.character_id)?;
         let character_id = character.entity_properties.id;
 
-        let item = character.inventory.remove_item(packet.item_id)?;
+        let item = character.combatant_properties.inventory.remove_item(packet.item_id)?;
         let item_id = item.entity_properties.id;
         party.current_room.items.push(item);
 
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_picks_up_item_from_ground_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_picks_up_item_from_ground_handler.rs
index 44f3cc50..e162122b 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_picks_up_item_from_ground_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_picks_up_item_from_ground_handler.rs
@@ -45,7 +45,7 @@ impl GameServer {
         let character = party
             .get_mut_character_if_owned(player_character_ids_option.clone(), packet.character_id)?;
         let character_id = character.entity_properties.id;
-        character.inventory.items.push(item);
+        character.combatant_properties.inventory.items.push(item);
         println!("character picked up item");
         self.emit_packet(
             &party_websocket_channel_name,
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_ability_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_ability_handler.rs
index 036e1f5e..89f6f7ec 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_ability_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_ability_handler.rs
@@ -1,12 +1,11 @@
-use crate::websocket_server::game_server::getters::get_mut_game;
-use crate::websocket_server::game_server::getters::get_user;
+use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
 use crate::websocket_server::game_server::GameServer;
 use common::app_consts::error_messages;
-use common::combatants::abilities::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
 use common::errors::AppError;
 use common::errors::AppErrorTypes;
 use common::game::getters::get_mut_party;
-use common::game::getters::get_mut_player;
 use common::packets::client_to_server::ClientSelectAbilityPacket;
 use common::packets::server_to_client::CharacterSelectedAbilityPacket;
 use common::packets::server_to_client::GameServerUpdatePackets;
@@ -18,24 +17,12 @@ impl GameServer {
         actor_id: u32,
         packet: ClientSelectAbilityPacket,
     ) -> Result<(), AppError> {
-        let connected_user = get_user(&self.sessions, actor_id)?;
-        let username = connected_user.username.clone();
-        let current_game_name =
-            connected_user
-                .current_game_name
-                .as_ref()
-                .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, &current_game_name)?;
-        let player = get_mut_player(game, &username)?;
-        let player_character_ids_option = player.character_ids.clone();
-        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 ActorIdAssociatedGameData {
+            game,
+            party_id,
+            player_character_ids_option,
+            ..
+        } = get_mut_game_data_from_actor_id(self, actor_id)?;
         let party = get_mut_party(game, party_id)?;
         let party_websocket_channel_name = party.websocket_channel_name.clone();
 
@@ -43,7 +30,7 @@ impl GameServer {
             let character = party
                 .get_mut_character_if_owned(player_character_ids_option, packet.character_id)?;
             character.combatant_properties.selected_ability_name = None;
-            character.combatant_properties.ability_targets = None;
+            character.combatant_properties.combat_action_targets = None;
             None
         } else {
             let battle_id_option = party.battle_id;
@@ -58,10 +45,12 @@ impl GameServer {
             )?;
             let target_preferences = character
                 .combatant_properties
-                .ability_target_preferences
+                .combat_action_target_preferences
                 .clone();
 
             let ability_name = packet.ability_name_option.clone().expect("is_none checked");
+            let ability_attributes = ability_name.get_attributes();
+            let combat_action_properties = ability_attributes.combat_action_properties;
             // don't allow selection of unowned ability
             let _ = character
                 .combatant_properties
@@ -78,14 +67,14 @@ impl GameServer {
                 (character_positions, None)
             };
 
-            let prohibited_target_combatant_states = ability_name
-                .get_attributes()
-                .prohibited_target_combatant_states;
+            let prohibited_target_combatant_states = combat_action_properties
+                .prohibited_target_combatant_states
+                .clone();
 
             let (ally_ids, opponent_ids_option) =
                 filter_possible_target_ids_by_prohibited_combatant_states(
                     game,
-                    prohibited_target_combatant_states,
+                    &prohibited_target_combatant_states,
                     ally_ids,
                     opponent_ids_option,
                 )?;
@@ -96,7 +85,7 @@ impl GameServer {
                 packet.character_id,
             )?;
 
-            let new_targets = ability_name.targets_by_saved_preference_or_default(
+            let new_targets = combat_action_properties.targets_by_saved_preference_or_default(
                 character.entity_properties.id,
                 &target_preferences,
                 ally_ids.clone(),
@@ -104,7 +93,7 @@ impl GameServer {
             )?;
 
             let new_target_preferences = target_preferences.get_updated_preferences(
-                &ability_name,
+                &combat_action_properties,
                 &new_targets,
                 ally_ids,
                 opponent_ids_option,
@@ -113,8 +102,10 @@ impl GameServer {
             let character = party
                 .get_mut_character_if_owned(player_character_ids_option, packet.character_id)?;
             character.combatant_properties.selected_ability_name = Some(ability_name);
-            character.combatant_properties.ability_target_preferences = new_target_preferences;
-            character.combatant_properties.ability_targets = Some(new_targets.clone());
+            character
+                .combatant_properties
+                .combat_action_target_preferences = new_target_preferences;
+            character.combatant_properties.combat_action_targets = Some(new_targets.clone());
             Some(new_targets)
         };
 
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_consumable_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_consumable_handler.rs
new file mode 100755
index 00000000..98fe8b5b
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_selects_consumable_handler.rs
@@ -0,0 +1,120 @@
+use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
+use crate::websocket_server::game_server::GameServer;
+use common::app_consts::error_messages;
+use common::combat::combat_actions::filter_possible_target_ids_by_prohibited_combatant_states::filter_possible_target_ids_by_prohibited_combatant_states;
+use common::errors::AppError;
+use common::errors::AppErrorTypes;
+use common::game::getters::get_mut_party;
+use common::packets::client_to_server::ClientSelectConsumablePacket;
+use common::packets::server_to_client::CharacterSelectedConsumablePacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+
+impl GameServer {
+    pub fn character_selects_consumable_handler(
+        &mut self,
+        actor_id: u32,
+        packet: ClientSelectConsumablePacket,
+    ) -> Result<(), AppError> {
+        let ActorIdAssociatedGameData {
+            game,
+            party_id,
+            player_character_ids_option,
+            ..
+        } = get_mut_game_data_from_actor_id(self, actor_id)?;
+
+        let party = get_mut_party(game, party_id)?;
+        let party_websocket_channel_name = party.websocket_channel_name.clone();
+
+        let new_targets_option = if let Some(item_id) = packet.consumable_id_option {
+            let battle_id_option = party.battle_id;
+            let character_positions = party.character_positions.clone();
+            let character = party.get_mut_character_if_owned(
+                player_character_ids_option.clone(),
+                packet.character_id,
+            )?;
+            let target_preferences = character
+                .combatant_properties
+                .combat_action_target_preferences
+                .clone();
+
+            let consumable_properties = character.combatant_properties.inventory.get_consumable(&item_id)?;
+
+            let combat_action_properties = consumable_properties
+                .consumable_type
+                .get_combat_action_properties();
+
+            let (ally_ids, opponent_ids_option) = if let Some(battle_id) = battle_id_option {
+                let battle = game.battles.get(&battle_id).ok_or_else(|| AppError {
+                    error_type: AppErrorTypes::Generic,
+                    message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                })?;
+
+                battle.get_ally_ids_and_opponent_ids_option(packet.character_id)?
+            } else {
+                (character_positions, None)
+            };
+
+            let prohibited_target_combatant_states = combat_action_properties
+                .prohibited_target_combatant_states
+                .clone();
+
+            let (ally_ids, opponent_ids_option) =
+                filter_possible_target_ids_by_prohibited_combatant_states(
+                    game,
+                    &prohibited_target_combatant_states,
+                    ally_ids,
+                    opponent_ids_option,
+                )?;
+
+            let party = get_mut_party(game, party_id)?;
+            let character = party.get_mut_character_if_owned(
+                player_character_ids_option.clone(),
+                packet.character_id,
+            )?;
+
+            let new_targets = combat_action_properties.targets_by_saved_preference_or_default(
+                character.entity_properties.id,
+                &target_preferences,
+                ally_ids.clone(),
+                opponent_ids_option.clone(),
+            )?;
+
+            let new_target_preferences = target_preferences.get_updated_preferences(
+                &combat_action_properties,
+                &new_targets,
+                ally_ids,
+                opponent_ids_option,
+            );
+            let party = get_mut_party(game, party_id)?;
+            let character = party
+                .get_mut_character_if_owned(player_character_ids_option, packet.character_id)?;
+            character.combatant_properties.selected_consumable = Some(item_id);
+            character
+                .combatant_properties
+                .combat_action_target_preferences = new_target_preferences;
+            character.combatant_properties.combat_action_targets = Some(new_targets.clone());
+            Some(new_targets)
+        } else {
+            let character = party
+                .get_mut_character_if_owned(player_character_ids_option, packet.character_id)?;
+            character.combatant_properties.selected_consumable = None;
+            character.combatant_properties.combat_action_targets = None;
+            None
+        };
+
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::CharacterSelectedConsumable(
+                CharacterSelectedConsumablePacket {
+                    character_id: packet.character_id,
+                    consumable_id_option: packet.consumable_id_option,
+                    targets_option: new_targets_option,
+                },
+            ),
+            Some(actor_id),
+        )
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/get_ability_action_results.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/get_ability_action_results.rs
new file mode 100644
index 00000000..2139c174
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/get_ability_action_results.rs
@@ -0,0 +1,97 @@
+use crate::websocket_server::game_server::getters::get_game;
+use crate::websocket_server::game_server::getters::get_user;
+use crate::websocket_server::game_server::GameServer;
+use common::app_consts::error_messages;
+use common::combat::ActionResult;
+use common::errors::AppError;
+use common::game::getters::get_party;
+use common::game::getters::get_player;
+
+impl GameServer {
+    pub fn get_ability_action_results(
+        &self,
+        actor_id: u32,
+        character_id: u32,
+    ) -> Result<Vec<ActionResult>, AppError> {
+        let connected_user = get_user(&self.sessions, actor_id)?;
+        let username = connected_user.username.clone();
+        let current_game_name =
+            connected_user
+                .current_game_name
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ServerError,
+                    message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+                })?;
+        let game = get_game(&self.games, current_game_name.clone())?;
+        let player = get_player(game, username)?;
+        let player_character_ids_option = player.character_ids.clone();
+        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_id = party_id.clone();
+        let party = get_party(game, party_id)?;
+        let battle_id_option = party.battle_id;
+        let character_positions = party.character_positions.clone();
+        let character = party.get_character_if_owned(player_character_ids_option, character_id)?;
+        let ability_name = character
+            .combatant_properties
+            .selected_ability_name
+            .clone()
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::InvalidInput,
+                message: error_messages::NO_ABILITY_SELECTED.to_string(),
+            })?;
+        let ability_attributes = ability_name.get_attributes();
+        // check if they own the ability
+        let _ = character
+            .combatant_properties
+            .get_ability_if_owned(&ability_name)?;
+
+        let targets = character
+            .combatant_properties
+            .combat_action_targets
+            .clone()
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::InvalidInput,
+                message: error_messages::NO_POSSIBLE_TARGETS_PROVIDED.to_string(),
+            })?;
+
+        let battle_option = if let Some(battle_id) = battle_id_option {
+            Some(
+                game.battles
+                    .get(&battle_id)
+                    .ok_or_else(|| AppError {
+                        error_type: common::errors::AppErrorTypes::ServerError,
+                        message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                    })?
+                    .clone(),
+            )
+        } else {
+            None
+        };
+
+        let ally_ids = if let Some(battle) = &battle_option {
+            let (ally_ids, _) = battle.get_ally_ids_and_opponent_ids_option(character_id)?;
+            ally_ids
+        } else {
+            character_positions.clone()
+        };
+
+        ability_attributes.combat_action_properties.validate_use(
+            battle_option.as_ref(),
+            &ally_ids,
+            &targets,
+            character_id,
+        )?;
+
+        game.get_ability_results(
+            character_id,
+            &ability_name,
+            &targets,
+            battle_option.as_ref(),
+        )
+    }
+}
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 5a82699d..bb854bbc 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
@@ -1,23 +1,7 @@
-mod take_next_ai_turn;
-use self::take_next_ai_turn::take_ai_controlled_turns;
-use super::apply_action_results::apply_action_results;
-use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
-use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
+mod get_ability_action_results;
+pub mod take_next_ai_turn;
 use crate::websocket_server::game_server::GameServer;
-use common::app_consts::error_messages;
-use common::combat::ability_handlers::validate_ability_use::validate_character_ability_use;
-use common::combat::CombatTurnResult;
-use common::dungeon_rooms::DungeonRoomTypes;
 use common::errors::AppError;
-use common::game::getters::get_mut_party;
-use common::items::Item;
-use common::packets::server_to_client::BattleConclusion;
-use common::packets::server_to_client::BattleEndReportPacket;
-use common::packets::server_to_client::CombatTurnResultsPacket;
-use common::packets::server_to_client::GameServerUpdatePackets;
-use common::packets::WebsocketChannelNamespace;
-use std::time::SystemTime;
-use std::time::UNIX_EPOCH;
 
 impl GameServer {
     pub fn character_uses_selected_ability_handler(
@@ -25,300 +9,7 @@ impl GameServer {
         actor_id: u32,
         character_id: u32,
     ) -> Result<(), AppError> {
-        let ActorIdAssociatedGameData {
-            game,
-            party_id,
-            player_character_ids_option,
-            current_game_name,
-            ..
-        } = get_mut_game_data_from_actor_id(self, actor_id)?;
-        let party_id = party_id.clone();
-        let current_game_name = current_game_name.clone();
-        let party = get_mut_party(game, party_id)?;
-        let party_name = party.name.clone();
-        let in_monster_lair = { party.current_room.room_type == DungeonRoomTypes::MonsterLair };
-        let dlvl = party.current_floor;
-        let battle_id_option = party.battle_id;
-        let character_positions = party.character_positions.clone();
-        let party_websocket_channel_name = party.websocket_channel_name.clone();
-        let character =
-            party.get_mut_character_if_owned(player_character_ids_option, character_id)?;
-        let ability_name = character
-            .combatant_properties
-            .selected_ability_name
-            .clone()
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::InvalidInput,
-                message: error_messages::NO_ABILITY_SELECTED.to_string(),
-            })?;
-        let ability_attributes = ability_name.get_attributes();
-        // check if they own the ability
-        let _ = character
-            .combatant_properties
-            .get_ability_if_owned(&ability_name)?;
-
-        let targets = character
-            .combatant_properties
-            .ability_targets
-            .clone()
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::InvalidInput,
-                message: error_messages::NO_POSSIBLE_TARGETS_PROVIDED.to_string(),
-            })?;
-
-        let battle_option = if let Some(battle_id) = battle_id_option {
-            Some(
-                game.battles
-                    .get(&battle_id)
-                    .ok_or_else(|| AppError {
-                        error_type: common::errors::AppErrorTypes::ServerError,
-                        message: error_messages::BATTLE_NOT_FOUND.to_string(),
-                    })?
-                    .clone(),
-            )
-        } else {
-            None
-        };
-
-        let ally_ids = if let Some(battle) = &battle_option {
-            let (ally_ids, _) = battle.get_ally_ids_and_opponent_ids_option(character_id)?;
-            ally_ids
-        } else {
-            character_positions.clone()
-        };
-
-        validate_character_ability_use(
-            &ability_name,
-            &ability_attributes,
-            battle_option.as_ref(),
-            &ally_ids,
-            &targets,
-            character_id,
-        )?;
-
-        let action_results = game.get_ability_results(
-            character_id,
-            &ability_name,
-            &targets,
-            battle_option.as_ref(),
-        )?;
-
-        apply_action_results(game, &action_results)?;
-
-        // check if all enemies/allies are dead
-        let all_opponents_are_dead = if let Some(battle) = &battle_option {
-            let (_, opponent_ids_option) =
-                battle.get_ally_ids_and_opponent_ids_option(character_id)?;
-            if let Some(opponent_ids) = opponent_ids_option {
-                game.all_combatants_in_group_are_dead(opponent_ids)?
-            } else {
-                false
-            }
-        } else {
-            false
-        };
-
-        let all_allies_are_dead = game.all_combatants_in_group_are_dead(ally_ids.clone())?;
-
-        let num_opponents = if let Some(battle) = &battle_option {
-            let (_, opponent_ids_option) =
-                battle.get_ally_ids_and_opponent_ids_option(character_id)?;
-            opponent_ids_option.unwrap_or_else(|| vec![]).len()
-        } else {
-            0
-        };
-
-        let game = self
-            .games
-            .get_mut(&current_game_name)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ServerError,
-                message: error_messages::GAME_NOT_FOUND.to_string(),
-            })?;
-        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..30 {
-                loot.push(Item::generate(&mut game.id_generator, dlvl))
-            }
-            Some(loot)
-        } else {
-            None
-        };
-        let party = get_mut_party(game, party_id)?;
-        if all_opponents_are_dead {
-            println!("all opponents defeated, concluding battle as victory");
-            // delete the battle
-            party.battle_id = None;
-            if in_monster_lair {
-                party.current_room.monsters = None;
-                party.current_room.items = loot_option.clone().unwrap_or_default();
-            }
-            if let Some(battle_id) = battle_id_option {
-                game.battles.remove(&battle_id);
-            }
-        }
-
-        // if in combat
-        let used_turn_ending_ability_in_battle = if battle_id_option.is_some() {
-            let mut should_end = false;
-            for action_result in &action_results {
-                if action_result.ends_turn {
-                    should_end = true;
-                    break;
-                }
-            }
-            should_end
-        } else {
-            false
-        };
-
-        if used_turn_ending_ability_in_battle {
-            let mut turns: Vec<CombatTurnResult> = vec![];
-            let player_turn = CombatTurnResult {
-                combatant_id: character_id,
-                action_results,
-            };
-            turns.push(player_turn);
-
-            if !all_opponents_are_dead && !all_allies_are_dead {
-                let active_combatant_turn_tracker =
-                    game.end_active_combatant_turn(battle_id_option.expect("checked above"))?;
-                let active_combatant_id = active_combatant_turn_tracker.entity_id;
-
-                let mut ai_controlled_turn_results = take_ai_controlled_turns(
-                    game,
-                    battle_id_option.expect("checked above"),
-                    active_combatant_id,
-                )?;
-                turns.append(&mut ai_controlled_turn_results);
-            }
-
-            // Send turn result packets
-            self.emit_packet(
-                &party_websocket_channel_name,
-                &WebsocketChannelNamespace::Party,
-                &GameServerUpdatePackets::CombatTurnResults(CombatTurnResultsPacket {
-                    turn_results: turns,
-                }),
-                None,
-            )?;
-        } else {
-            self.emit_packet(
-                &party_websocket_channel_name,
-                &WebsocketChannelNamespace::Party,
-                &GameServerUpdatePackets::ActionResults(action_results),
-                None,
-            )?;
-        }
-
-        let game = self
-            .games
-            .get_mut(&current_game_name)
-            .ok_or_else(|| AppError {
-                error_type: common::errors::AppErrorTypes::ServerError,
-                message: error_messages::GAME_NOT_FOUND.to_string(),
-            })?;
-        let all_players_in_game = game.players.clone();
-        let all_allies_are_dead = game.all_combatants_in_group_are_dead(ally_ids)?;
-        let party = get_mut_party(game, party_id)?;
-        let player_usernames_in_party = party.player_usernames.clone();
-        if all_allies_are_dead {
-            println!(
-                "all allies are dead, ending game for party named '{}'",
-                party.name
-            );
-            party.battle_id = None;
-            if let Some(battle_id) = battle_id_option {
-                game.battles.remove(&battle_id);
-            }
-            let mut actor_ids_of_players_in_other_parties = Vec::new();
-            for (username, player) in &all_players_in_game {
-                if !player_usernames_in_party.contains(username) {
-                    actor_ids_of_players_in_other_parties.push(player.actor_id)
-                }
-            }
-            for actor_id_option in actor_ids_of_players_in_other_parties {
-                if let Some(actor_id) = actor_id_option {
-                    self.send_packet(
-                        &GameServerUpdatePackets::GameMessage(
-                            common::packets::GameMessages::PartyWipe(
-                                party_name.clone(),
-                                dlvl,
-                                SystemTime::now()
-                                    .duration_since(UNIX_EPOCH)
-                                    .expect("time went backwards")
-                                    .as_secs(),
-                            ),
-                        ),
-                        actor_id,
-                    )?;
-                }
-            }
-
-            self.emit_packet(
-                &party_websocket_channel_name,
-                &WebsocketChannelNamespace::Party,
-                &GameServerUpdatePackets::BattleEndReport(BattleEndReportPacket {
-                    conclusion: BattleConclusion::Defeat,
-                    loot: None,
-                }),
-                None,
-            )?;
-
-            let game = self
-                .games
-                .get_mut(&current_game_name)
-                .ok_or_else(|| AppError {
-                    error_type: common::errors::AppErrorTypes::ServerError,
-                    message: error_messages::GAME_NOT_FOUND.to_string(),
-                })?;
-            for username in player_usernames_in_party {
-                println!("attempting to remove username {} from party", username);
-                game.remove_player_from_adventuring_party(username)?;
-            }
-
-            if game.adventuring_parties.len() == 0 {
-                for (_, player) in all_players_in_game {
-                    if let Some(actor_id) = player.actor_id {
-                        println!("attempting to remove actor id {} from game", actor_id);
-                        let result = self.remove_player_from_game(actor_id);
-                        if let Some(err) = result.err() {
-                            println!("error removing player from game {}", err.message)
-                        }
-                    }
-                }
-            }
-        } else if in_monster_lair && all_opponents_are_dead {
-            if let Some(loot) = loot_option.clone() {
-                // make sure all clients receive the item's existance or else one client can take
-                // the item before another client sees it leading to desync
-                let game = self
-                    .games
-                    .get_mut(&current_game_name)
-                    .ok_or_else(|| AppError {
-                        error_type: common::errors::AppErrorTypes::ServerError,
-                        message: error_messages::GAME_NOT_FOUND.to_string(),
-                    })?;
-                let party = get_mut_party(game, party_id)?;
-                for item in loot {
-                    party
-                        .items_on_ground_not_yet_received_by_all_clients
-                        .insert(item.entity_properties.id, vec![]);
-                }
-            };
-            self.emit_packet(
-                &party_websocket_channel_name,
-                &WebsocketChannelNamespace::Party,
-                &GameServerUpdatePackets::BattleEndReport(BattleEndReportPacket {
-                    conclusion: BattleConclusion::Victory,
-                    loot: loot_option,
-                }),
-                None,
-            )?;
-        }
-
-        Ok(())
+        let action_results = self.get_ability_action_results(actor_id, character_id)?;
+        self.handle_new_combat_action_results(actor_id, action_results, character_id)
     }
 }
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/take_next_ai_turn.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/take_next_ai_turn.rs
index 00730c08..5ae473ed 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/take_next_ai_turn.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_ability_handler/take_next_ai_turn.rs
@@ -1,3 +1,4 @@
+#![allow(unused_assignments)]
 use crate::websocket_server::game_server::player_input_handlers::in_game::apply_action_results::apply_action_results;
 use common::app_consts::error_messages;
 use common::combat::CombatTurnResult;
@@ -5,16 +6,27 @@ use common::combatants::CombatantControlledBy;
 use common::errors::AppError;
 use common::game::RoguelikeRacerGame;
 
-pub fn take_ai_controlled_turns(
+pub fn take_ai_controlled_turns_if_appropriate(
     game: &mut RoguelikeRacerGame,
     battle_id: u32,
-    active_combatant_id: u32,
 ) -> Result<Vec<CombatTurnResult>, AppError> {
     let mut ai_turn_results = vec![];
+    let battle = game.battles.get(&battle_id).ok_or_else(|| AppError {
+        error_type: common::errors::AppErrorTypes::Generic,
+        message: error_messages::BATTLE_NOT_FOUND.to_string(),
+    })?;
+    let turn_trackers = &battle.combatant_turn_trackers;
+    println!("turn trackers at start of take_ai: {:#?}", turn_trackers);
+    let mut active_combatant_id = turn_trackers
+        .first()
+        .ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::Generic,
+            message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+        })?
+        .entity_id;
 
     let (mut active_combatant_entity_properties, mut active_combatant_properties) =
         game.get_combatant_by_id(&active_combatant_id)?;
-    let mut active_combatant_entity_id = active_combatant_entity_properties.id;
     let mut active_combatant_is_ai_controlled =
         active_combatant_properties.controlled_by == CombatantControlledBy::AI;
     let mut active_combatant_turn_action_results = vec![];
@@ -26,10 +38,10 @@ pub fn take_ai_controlled_turns(
             message: error_messages::BATTLE_NOT_FOUND.to_string(),
         })?;
         let (ally_battle_group, enemy_battle_group) =
-            battle.get_ally_and_enemy_battle_groups(&active_combatant_entity_id)?;
+            battle.get_ally_and_enemy_battle_groups(&active_combatant_id)?;
         let enemy_ids = enemy_battle_group.combatant_ids.clone();
         let (ability_name, targets) = game.ai_select_ability_and_targets(
-            active_combatant_entity_id,
+            active_combatant_id,
             ally_battle_group,
             enemy_battle_group,
         )?;
@@ -39,37 +51,59 @@ pub fn take_ai_controlled_turns(
             message: error_messages::BATTLE_NOT_FOUND.to_string(),
         })?;
         let mut action_results = game.get_ability_results(
-            active_combatant_entity_id,
+            active_combatant_id,
             &ability_name,
             &targets,
             Some(&battle.clone()),
         )?;
         // process result
-        apply_action_results(game, &action_results)?;
+        apply_action_results(game, &action_results, Some(battle.id))?;
         let party_defeated = game.all_combatants_in_group_are_dead(enemy_ids)?;
-        println!("party defeated by ai ability: {party_defeated}");
+        // println!("party defeated by ai ability: {party_defeated}");
 
         active_combatant_turn_action_results.append(&mut action_results);
+        let ability_attributes = ability_name.get_attributes();
+        let combat_action_properties = ability_attributes.combat_action_properties;
 
-        if ability_name.get_attributes().requires_combat_turn {
+        let battle = game.battles.get(&battle_id).ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::Generic,
+            message: error_messages::BATTLE_NOT_FOUND.to_string(),
+        })?;
+        let turn_trackers = &battle.combatant_turn_trackers;
+        let first_tracker = turn_trackers.first().ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::Generic,
+            message: error_messages::TURN_TRACKERS_EMPTY.to_string(),
+        })?;
+
+        println!(
+            "ai id {} took turn action {} with movement {}",
+            active_combatant_id,
+            combat_action_properties.requires_combat_turn,
+            first_tracker.movement
+        );
+
+        if combat_action_properties.requires_combat_turn {
             ai_turn_results.push(CombatTurnResult {
-                combatant_id: active_combatant_entity_id,
+                combatant_id: active_combatant_id,
                 action_results: active_combatant_turn_action_results.clone(),
             });
             active_combatant_turn_action_results = vec![];
 
-            // end the active_combatant's turn and check if new active combatant
-            // is a player or AI
             let new_active_combatant_turn_tracker = game.end_active_combatant_turn(battle_id)?;
-            active_combatant_entity_id = new_active_combatant_turn_tracker.entity_id.clone();
+            active_combatant_id = new_active_combatant_turn_tracker.entity_id.clone();
+            println!(
+                "active combatant id:{:#?} turn tracker: {:#?}",
+                active_combatant_id, new_active_combatant_turn_tracker
+            );
             (
                 active_combatant_entity_properties,
                 active_combatant_properties,
-            ) = game.get_combatant_by_id(&active_combatant_entity_id)?;
-            active_combatant_entity_id = active_combatant_entity_properties.id;
+            ) = game.get_combatant_by_id(&active_combatant_id)?;
+            active_combatant_id = active_combatant_entity_properties.id;
             active_combatant_is_ai_controlled =
                 active_combatant_properties.controlled_by == CombatantControlledBy::AI;
         }
+
         if party_defeated {
             return Ok(ai_turn_results);
         }
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/get_used_consumable_action_results.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/get_used_consumable_action_results.rs
new file mode 100644
index 00000000..16131c62
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/get_used_consumable_action_results.rs
@@ -0,0 +1,96 @@
+use crate::websocket_server::game_server::getters::get_game;
+use crate::websocket_server::game_server::getters::get_user;
+use crate::websocket_server::game_server::GameServer;
+use common::app_consts::error_messages;
+use common::combat::ActionResult;
+use common::errors::AppError;
+use common::game::getters::get_party;
+use common::game::getters::get_player;
+
+impl GameServer {
+    pub fn get_used_consumable_action_results(
+        &self,
+        actor_id: u32,
+        character_id: u32,
+    ) -> Result<Vec<ActionResult>, AppError> {
+        let connected_user = get_user(&self.sessions, actor_id)?;
+        let username = connected_user.username.clone();
+        let current_game_name =
+            connected_user
+                .current_game_name
+                .as_ref()
+                .ok_or_else(|| AppError {
+                    error_type: common::errors::AppErrorTypes::ServerError,
+                    message: error_messages::MISSING_GAME_REFERENCE.to_string(),
+                })?;
+        let game = get_game(&self.games, current_game_name.clone())?;
+        let player = get_player(game, username)?;
+        let player_character_ids_option = player.character_ids.clone();
+        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_id = party_id.clone();
+        let party = get_party(game, party_id)?;
+        let battle_id_option = party.battle_id;
+        let character_positions = party.character_positions.clone();
+        let character = party.get_character_if_owned(player_character_ids_option, character_id)?;
+        let consumable_id = character
+            .combatant_properties
+            .selected_consumable
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::Generic,
+                message: error_messages::NO_CONSUMABLE_SELECTED.to_string(),
+            })?;
+        let consumable = character
+            .combatant_properties
+            .inventory
+            .get_consumable(&consumable_id)?;
+        let combat_action_properties = consumable.consumable_type.get_combat_action_properties();
+
+        let targets = character
+            .combatant_properties
+            .combat_action_targets
+            .clone()
+            .ok_or_else(|| AppError {
+                error_type: common::errors::AppErrorTypes::InvalidInput,
+                message: error_messages::NO_POSSIBLE_TARGETS_PROVIDED.to_string(),
+            })?;
+
+        let battle_option = if let Some(battle_id) = battle_id_option {
+            Some(
+                game.battles
+                    .get(&battle_id)
+                    .ok_or_else(|| AppError {
+                        error_type: common::errors::AppErrorTypes::ServerError,
+                        message: error_messages::BATTLE_NOT_FOUND.to_string(),
+                    })?
+                    .clone(),
+            )
+        } else {
+            None
+        };
+
+        let ally_ids = if let Some(battle) = &battle_option {
+            let (ally_ids, _) = battle.get_ally_ids_and_opponent_ids_option(character_id)?;
+            ally_ids
+        } else {
+            character_positions.clone()
+        };
+
+        combat_action_properties.validate_use(
+            battle_option.as_ref(),
+            &ally_ids,
+            &targets,
+            character_id,
+        )?;
+
+        game.get_consumable_use_results(
+            character_id,
+            consumable_id,
+            &targets,
+            battle_option.as_ref(),
+        )
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/mod.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/mod.rs
new file mode 100644
index 00000000..66e1cee5
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/character_uses_selected_consumable_handler/mod.rs
@@ -0,0 +1,14 @@
+mod get_used_consumable_action_results;
+use crate::websocket_server::game_server::GameServer;
+use common::errors::AppError;
+
+impl GameServer {
+    pub fn character_uses_selected_consumable_handler(
+        &mut self,
+        actor_id: u32,
+        character_id: u32,
+    ) -> Result<(), AppError> {
+        let action_results = self.get_used_consumable_action_results(actor_id, character_id)?;
+        self.handle_new_combat_action_results(actor_id, action_results, character_id)
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/equip_item_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/equip_item_handler.rs
index b42a6200..4706de27 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/equip_item_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/equip_item_handler.rs
@@ -40,7 +40,9 @@ impl GameServer {
                 message: error_messages::CHARACTER_NOT_OWNED.to_string(),
             }),
         }?;
-        character.equip_item(item_id, alt_slot)?;
+        character
+            .combatant_properties
+            .equip_item(item_id, alt_slot)?;
 
         self.emit_packet(
             &party_websocket_channel_name,
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/action_result_ended_turn.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/action_result_ended_turn.rs
new file mode 100644
index 00000000..f3ae333c
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/action_result_ended_turn.rs
@@ -0,0 +1,19 @@
+use common::combat::ActionResult;
+
+pub fn action_result_ended_turn(
+    battle_id_option: Option<u32>,
+    action_results: &Vec<ActionResult>,
+) -> bool {
+    if battle_id_option.is_some() {
+        let mut should_end = false;
+        for action_result in action_results {
+            if action_result.ends_turn {
+                should_end = true;
+                break;
+            }
+        }
+        should_end
+    } else {
+        false
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/generate_loot_if_appropriate.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/generate_loot_if_appropriate.rs
new file mode 100644
index 00000000..d08e64cf
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/generate_loot_if_appropriate.rs
@@ -0,0 +1,12 @@
+use common::game::RoguelikeRacerGame;
+use common::items::Item;
+
+pub fn generate_loot(game: &mut RoguelikeRacerGame, num_opponents: u8, dlvl: u8) -> Vec<Item> {
+    let mut loot = vec![];
+    println!("creating loot for dlvl {dlvl} num num_opponents {num_opponents}");
+    for _ in 0..num_opponents {
+        loot.push(Item::generate(&mut game.id_generator, dlvl, None))
+    }
+    println!("generated loot: {:#?}", loot);
+    loot
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_character_ally_ids.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_character_ally_ids.rs
new file mode 100644
index 00000000..48ac5814
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_character_ally_ids.rs
@@ -0,0 +1,16 @@
+use common::combat::battle::Battle;
+use common::errors::AppError;
+
+pub fn get_character_ally_ids(
+    battle_option: &Option<Battle>,
+    party_member_ids: &Vec<u32>,
+    action_taker_character_id: &u32,
+) -> Result<Vec<u32>, AppError> {
+    if let Some(battle) = &battle_option {
+        let (ally_ids, _) =
+            battle.get_ally_ids_and_opponent_ids_option(*action_taker_character_id)?;
+        Ok(ally_ids)
+    } else {
+        Ok(party_member_ids.clone())
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_number_of_opponents.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_number_of_opponents.rs
new file mode 100644
index 00000000..b51cb7c3
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/get_number_of_opponents.rs
@@ -0,0 +1,14 @@
+use common::combat::battle::Battle;
+use common::errors::AppError;
+
+pub fn get_number_of_opponents(
+    battle_option: &Option<Battle>,
+    character_id: u32,
+) -> Result<u8, AppError> {
+    if let Some(battle) = &battle_option {
+        let (_, opponent_ids_option) = battle.get_ally_ids_and_opponent_ids_option(character_id)?;
+        Ok(opponent_ids_option.unwrap_or_else(|| vec![]).len() as u8)
+    } else {
+        Ok(0)
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_end_of_player_character_turn.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_end_of_player_character_turn.rs
new file mode 100644
index 00000000..92cd5418
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_end_of_player_character_turn.rs
@@ -0,0 +1,51 @@
+use common::app_consts::error_messages;
+use common::combat::ActionResult;
+use common::combat::CombatTurnResult;
+use common::errors::AppError;
+use common::packets::server_to_client::CombatTurnResultsPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+use crate::websocket_server::game_server::GameServer;
+use crate::websocket_server::game_server::player_input_handlers::in_game::character_uses_selected_ability_handler::take_next_ai_turn::take_ai_controlled_turns_if_appropriate;
+
+impl GameServer {
+    pub fn handle_end_of_player_character_turn(
+        &mut self,
+        game_name: &String,
+        action_taker_character_id: u32,
+        action_results: Vec<ActionResult>,
+        all_opponents_are_dead: bool,
+        all_allies_are_dead: bool,
+        battle_id: u32,
+        party_websocket_channel_name: &String,
+    ) -> Result<(), AppError> {
+        let game = self.games.get_mut(game_name).ok_or_else(|| AppError {
+            error_type: common::errors::AppErrorTypes::ServerError,
+            message: error_messages::GAME_NOT_FOUND.to_string(),
+        })?;
+        let mut turns: Vec<CombatTurnResult> = vec![];
+        let player_turn = CombatTurnResult {
+            combatant_id: action_taker_character_id,
+            action_results,
+        };
+        turns.push(player_turn);
+
+        if !all_opponents_are_dead && !all_allies_are_dead {
+            let _ = game.end_active_combatant_turn(battle_id)?;
+
+            let mut ai_controlled_turn_results =
+                take_ai_controlled_turns_if_appropriate(game, battle_id)?;
+            turns.append(&mut ai_controlled_turn_results);
+        }
+
+        // Send turn result packets
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::CombatTurnResults(CombatTurnResultsPacket {
+                turn_results: turns,
+            }),
+            None,
+        )
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_battle_victory.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_battle_victory.rs
new file mode 100644
index 00000000..b7f7b1f1
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_battle_victory.rs
@@ -0,0 +1,53 @@
+use crate::websocket_server::game_server::GameServer;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
+use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
+use crate::websocket_server::game_server::player_input_handlers::in_game::handle_new_combat_action_results::generate_loot_if_appropriate::generate_loot;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::server_to_client::BattleConclusion;
+use common::packets::server_to_client::BattleEndReportPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+
+impl GameServer {
+    pub fn handle_party_battle_victory(
+        &mut self,
+        actor_id: u32,
+        battle_id: u32,
+        num_opponents: u8,
+    ) -> Result<(), AppError> {
+        let ActorIdAssociatedGameData { game, party_id, .. } =
+            get_mut_game_data_from_actor_id(self, actor_id)?;
+        let party = get_mut_party(game, party_id)?;
+        let party_websocket_channel_name = party.websocket_channel_name.clone();
+        let dlvl = party.current_floor;
+        let loot = generate_loot(game, num_opponents, dlvl);
+
+        let party = get_mut_party(game, party_id)?;
+        // make sure all clients receive the item's existance or else one client can take
+        // the item before another client sees it leading to desync
+        for item in &loot {
+            party
+                .items_on_ground_not_yet_received_by_all_clients
+                .insert(item.entity_properties.id, vec![]);
+        }
+
+        // REMOVE THE BATTLE
+        println!("all opponents defeated, concluding battle as victory");
+        party.battle_id = None;
+        party.current_room.monsters = None;
+        party.current_room.items.append(&mut loot.clone());
+        println!("new party items on floor: {:#?}", party.current_room.items);
+        game.battles.remove(&battle_id);
+
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::BattleEndReport(BattleEndReportPacket {
+                conclusion: BattleConclusion::Victory,
+                loot: Some(loot),
+            }),
+            None,
+        )
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_wipe.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_wipe.rs
new file mode 100644
index 00000000..ad01682e
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/handle_party_wipe.rs
@@ -0,0 +1,85 @@
+use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
+use crate::websocket_server::game_server::GameServer;
+use common::errors::AppError;
+use common::game::getters::get_mut_party;
+use common::packets::server_to_client::BattleConclusion;
+use common::packets::server_to_client::BattleEndReportPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+use std::time::SystemTime;
+use std::time::UNIX_EPOCH;
+
+impl GameServer {
+    pub fn handle_party_wipe(
+        &mut self,
+        actor_id: u32,
+        party_websocket_channel_name: &String,
+        battle_id_option: &Option<u32>,
+    ) -> Result<(), AppError> {
+        let ActorIdAssociatedGameData { game, party_id, .. } =
+            get_mut_game_data_from_actor_id(self, actor_id)?;
+        let all_players_in_game = game.players.clone();
+        let party = get_mut_party(game, party_id)?;
+        let party_name = party.name.clone();
+        let dlvl = party.current_floor;
+        let player_usernames_in_party = party.player_usernames.clone();
+        party.battle_id = None;
+        if let Some(battle_id) = battle_id_option {
+            game.battles.remove(&battle_id);
+        }
+
+        let mut actor_ids_of_players_in_other_parties = Vec::new();
+        for (username, player) in &all_players_in_game {
+            if !player_usernames_in_party.contains(username) {
+                actor_ids_of_players_in_other_parties.push(player.actor_id)
+            }
+        }
+
+        for actor_id_option in actor_ids_of_players_in_other_parties {
+            if let Some(actor_id) = actor_id_option {
+                self.send_packet(
+                    &GameServerUpdatePackets::GameMessage(
+                        common::packets::GameMessages::PartyWipe(
+                            party_name.clone(),
+                            dlvl,
+                            SystemTime::now()
+                                .duration_since(UNIX_EPOCH)
+                                .expect("time went backwards")
+                                .as_secs(),
+                        ),
+                    ),
+                    actor_id,
+                )?;
+            }
+        }
+
+        self.emit_packet(
+            &party_websocket_channel_name,
+            &WebsocketChannelNamespace::Party,
+            &GameServerUpdatePackets::BattleEndReport(BattleEndReportPacket {
+                conclusion: BattleConclusion::Defeat,
+                loot: None,
+            }),
+            None,
+        )?;
+
+        let ActorIdAssociatedGameData { game, .. } =
+            get_mut_game_data_from_actor_id(self, actor_id)?;
+        for username in player_usernames_in_party {
+            game.remove_player_from_adventuring_party(username)?;
+        }
+
+        if game.adventuring_parties.len() == 0 {
+            for (_, player) in all_players_in_game {
+                if let Some(actor_id) = player.actor_id {
+                    let result = self.remove_player_from_game(actor_id);
+                    if let Some(err) = result.err() {
+                        println!("error removing player from game {}", err.message)
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/mod.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/mod.rs
new file mode 100644
index 00000000..24db44b3
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/mod.rs
@@ -0,0 +1,112 @@
+mod action_result_ended_turn;
+mod generate_loot_if_appropriate;
+mod get_character_ally_ids;
+mod get_number_of_opponents;
+mod handle_end_of_player_character_turn;
+mod handle_party_battle_victory;
+mod handle_party_wipe;
+mod take_ai_turns_at_battle_start;
+use self::action_result_ended_turn::action_result_ended_turn;
+use self::get_character_ally_ids::get_character_ally_ids;
+use self::get_number_of_opponents::get_number_of_opponents;
+use super::apply_action_results::apply_action_results;
+use crate::websocket_server::game_server::getters::get_mut_game_data_from_actor_id;
+use crate::websocket_server::game_server::getters::ActorIdAssociatedGameData;
+use crate::websocket_server::game_server::GameServer;
+use common::combat::ActionResult;
+use common::dungeon_rooms::DungeonRoomTypes;
+use common::errors::AppError;
+use common::game::getters::get_party;
+use common::packets::server_to_client::ActionResultsPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+
+impl GameServer {
+    pub fn handle_new_combat_action_results(
+        &mut self,
+        actor_id: u32,
+        action_results: Vec<ActionResult>,
+        action_taker_id: u32,
+    ) -> Result<(), AppError> {
+        let ActorIdAssociatedGameData {
+            game,
+            party_id,
+            current_game_name,
+            ..
+        } = get_mut_game_data_from_actor_id(self, actor_id)?;
+
+        let party = get_party(game, party_id)?;
+        let battle_id_option = party.battle_id;
+        apply_action_results(game, &action_results, battle_id_option)?;
+
+        let party_id = party_id.clone();
+        let current_game_name = current_game_name.clone();
+        let party = get_party(game, party_id)?;
+        let in_monster_lair = { party.current_room.room_type == DungeonRoomTypes::MonsterLair };
+        let battle_id_option = party.battle_id;
+        let character_positions = party.character_positions.clone();
+        let party_websocket_channel_name = party.websocket_channel_name.clone();
+        let battle_option = game.get_battle_option(&battle_id_option)?;
+        let ally_ids =
+            get_character_ally_ids(&battle_option, &character_positions, &action_taker_id)?;
+        let ActorIdAssociatedGameData { game, .. } =
+            get_mut_game_data_from_actor_id(self, actor_id)?;
+
+        // check if all enemies/allies are dead
+        let all_opponents_are_dead = if let Some(battle) = &battle_option {
+            let (_, opponent_ids_option) =
+                battle.get_ally_ids_and_opponent_ids_option(action_taker_id)?;
+            if let Some(opponent_ids) = opponent_ids_option {
+                game.all_combatants_in_group_are_dead(opponent_ids)?
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+
+        let all_allies_are_dead = game.all_combatants_in_group_are_dead(ally_ids.clone())?;
+        let num_opponents = get_number_of_opponents(&battle_option, action_taker_id)?;
+
+        // let party = get_mut_party(game, party_id)?;
+
+        let action_result_ended_turn = action_result_ended_turn(battle_id_option, &action_results);
+        if action_result_ended_turn {
+            self.handle_end_of_player_character_turn(
+                &current_game_name,
+                action_taker_id,
+                action_results,
+                all_opponents_are_dead,
+                all_allies_are_dead,
+                battle_id_option.expect("checked in action_result_ended_turn fn"),
+                &party_websocket_channel_name,
+            )?;
+        } else {
+            self.emit_packet(
+                &party_websocket_channel_name,
+                &WebsocketChannelNamespace::Party,
+                &GameServerUpdatePackets::ActionResults(ActionResultsPacket {
+                    action_taker_id,
+                    action_results,
+                }),
+                None,
+            )?;
+        }
+
+        let ActorIdAssociatedGameData { game, .. } =
+            get_mut_game_data_from_actor_id(self, actor_id)?;
+        let all_allies_are_dead = game.all_combatants_in_group_are_dead(ally_ids)?;
+
+        if all_allies_are_dead {
+            self.handle_party_wipe(actor_id, &party_websocket_channel_name, &battle_id_option)?;
+        } else if in_monster_lair && all_opponents_are_dead {
+            self.handle_party_battle_victory(
+                actor_id,
+                battle_id_option.expect("to be in a battle"),
+                num_opponents,
+            )?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/take_ai_turns_at_battle_start.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/take_ai_turns_at_battle_start.rs
new file mode 100644
index 00000000..cf1db17b
--- /dev/null
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/handle_new_combat_action_results/take_ai_turns_at_battle_start.rs
@@ -0,0 +1,41 @@
+use common::app_consts::error_messages;
+use common::combat::CombatTurnResult;
+use common::errors::AppError;
+use common::errors::AppErrorTypes;
+use common::packets::server_to_client::CombatTurnResultsPacket;
+use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::WebsocketChannelNamespace;
+use crate::websocket_server::game_server::GameServer;
+use crate::websocket_server::game_server::player_input_handlers::in_game::character_uses_selected_ability_handler::take_next_ai_turn::take_ai_controlled_turns_if_appropriate;
+
+impl GameServer {
+    pub fn take_ai_turns_at_battle_start(
+        &mut self,
+        game_name: &String,
+        battle_id: u32,
+        party_websocket_channel_name: &String,
+    ) -> Result<(), AppError> {
+        let mut turns: Vec<CombatTurnResult> = vec![];
+
+        let game = self.games.get_mut(game_name).ok_or_else(|| AppError {
+            error_type: AppErrorTypes::ServerError,
+            message: error_messages::GAME_NOT_FOUND.to_string(),
+        })?;
+
+        let mut ai_controlled_turn_results =
+            take_ai_controlled_turns_if_appropriate(game, battle_id)?;
+        turns.append(&mut ai_controlled_turn_results);
+        // Send turn result packets
+        if turns.len() > 0 {
+            self.emit_packet(
+                &party_websocket_channel_name,
+                &WebsocketChannelNamespace::Party,
+                &GameServerUpdatePackets::CombatTurnResults(CombatTurnResultsPacket {
+                    turn_results: turns,
+                }),
+                None,
+            )?;
+        }
+        Ok(())
+    }
+}
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 ed3e5a96..ca797c32 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
@@ -1,12 +1,17 @@
 mod apply_action_results;
 mod character_changes_ability_targets_handler;
+mod character_changes_combat_action_targets_handler;
+mod character_changes_consumable_targets_handler;
 mod character_drops_equipped_item;
 mod character_drops_item;
 mod character_picks_up_item_from_ground_handler;
 mod character_selects_ability_handler;
+mod character_selects_consumable_handler;
 mod character_uses_selected_ability_handler;
+mod character_uses_selected_consumable_handler;
 mod client_acknowledges_receipt_of_item_on_ground_handler;
 mod equip_item_handler;
+mod handle_new_combat_action_results;
 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_explore_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/toggle_ready_to_explore_handler.rs
index 59ae74e9..b08cfa22 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
@@ -127,6 +127,16 @@ impl GameServer {
             party.rooms_explored.on_current_floor += 1;
             party.rooms_explored.total += 1;
 
+            self.emit_packet(
+                &party_websocket_channel_name,
+                &WebsocketChannelNamespace::Party,
+                &GameServerUpdatePackets::DungeonRoomUpdate(room.clone()),
+                None,
+            )?;
+
+            let game = get_mut_game(&mut self.games, &game_name)?;
+            let party = get_mut_party(game, party_id)?;
+
             if room.monsters.is_some() {
                 let group_a = BattleGroup {
                     name: format!("{}", party.name).to_string(),
@@ -143,6 +153,8 @@ impl GameServer {
                     group_type: BattleGroupTypes::ComputerControlled,
                 };
                 let battle_id = game.initiate_battle(group_a, group_b)?;
+                println!("ticking combat at battle start");
+                game.tick_combat_until_next_combatant_is_active(battle_id)?;
                 let party = get_mut_party(game, party_id)?;
                 party.battle_id = Some(battle_id);
                 let battle = game.battles.get(&battle_id).clone().expect("just inserted");
@@ -156,12 +168,28 @@ impl GameServer {
                 )?;
             }
 
-            self.emit_packet(
-                &party_websocket_channel_name,
-                &WebsocketChannelNamespace::Party,
-                &GameServerUpdatePackets::DungeonRoomUpdate(room),
-                None,
-            )?;
+            let game = get_mut_game(&mut self.games, &game_name)?;
+            let party = get_mut_party(game, party_id)?;
+            let battle_id_option = party.battle_id;
+            if let Some(battle_id) = party.battle_id {
+                self.take_ai_turns_at_battle_start(
+                    &game_name,
+                    battle_id,
+                    &party_websocket_channel_name,
+                )?;
+                let game = get_mut_game(&mut self.games, &game_name)?;
+                let party = get_mut_party(game, party_id)?;
+                let character_positions = party.character_positions.clone();
+                let all_allies_are_dead =
+                    game.all_combatants_in_group_are_dead(character_positions)?;
+                if all_allies_are_dead {
+                    self.handle_party_wipe(
+                        actor_id,
+                        &party_websocket_channel_name,
+                        &battle_id_option,
+                    )?;
+                }
+            }
         }
         Ok(())
     }
diff --git a/server/src/websocket_server/game_server/player_input_handlers/in_game/unequip_slot_handler.rs b/server/src/websocket_server/game_server/player_input_handlers/in_game/unequip_slot_handler.rs
index d7297065..f86eab44 100644
--- a/server/src/websocket_server/game_server/player_input_handlers/in_game/unequip_slot_handler.rs
+++ b/server/src/websocket_server/game_server/player_input_handlers/in_game/unequip_slot_handler.rs
@@ -4,8 +4,8 @@ use crate::websocket_server::game_server::GameServer;
 use common::app_consts::error_messages;
 use common::errors::AppError;
 use common::items::equipment::EquipmentSlots;
-use common::packets::CharacterAndSlot;
 use common::packets::server_to_client::GameServerUpdatePackets;
+use common::packets::CharacterAndSlot;
 use common::packets::WebsocketChannelNamespace;
 
 impl GameServer {
@@ -41,7 +41,9 @@ impl GameServer {
             }),
         }?;
 
-        character.unequip_slots(&vec![slot.clone()], false);
+        character
+            .combatant_properties
+            .unequip_slots(&vec![slot.clone()], false);
 
         self.emit_packet(
             &party_websocket_channel_name,
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 3f988008..2e96eda9 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,12 +2,10 @@ 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;
 
diff --git a/server/src/websocket_server/game_server/send_messages.rs b/server/src/websocket_server/game_server/send_messages.rs
index df598297..22ae3c72 100644
--- a/server/src/websocket_server/game_server/send_messages.rs
+++ b/server/src/websocket_server/game_server/send_messages.rs
@@ -30,6 +30,10 @@ impl GameServer {
         packet: &GameServerUpdatePackets,
         skip_id: Option<u32>,
     ) -> Result<(), AppError> {
+        // println!(
+        //     "emitting packet on channel :{websocket_channel} in namespace: {:?} packet: {:#?}",
+        //     channel_namespace, packet
+        // );
         let channels_in_namespace =
             self.websocket_channels
                 .get(channel_namespace)