Fix Incomplete Item Usage Logic in use_item

contract/src/models/inventory.cairo

@@ -79,6 +79,23 @@ pub impl InventoryImpl of InventoryTrait {
 
         found
     }
+
+    fn has_item(self: @Inventory, item_id: u32) -> bool {
+        let mut i = 0;
+        let mut found = false;
+
+        while i != self.items.len() {
+            let current_item = self.items.at(i);
+
+            if current_item.id == @item_id {
+                found = true;
+            }
+
+            i += 1;
+        };
+
+        found
+    }
 }
 
 #[generate_trait]
@@ -178,4 +195,38 @@ mod tests {
             inventory.available_space() == MAX_INVENTORY_CAPACITY - 1, 'Should have one less space',
         );
     }
+
+    #[test]
+    fn test_has_item_empty_inventory() {
+        let inventory = InventoryImpl::new(1);
+        assert!(!inventory.has_item(1), "Empty inventory should not have item");
+    }
+
+    #[test]
+    fn test_has_item_existing_item() {
+        let mut inventory = InventoryImpl::new(1);
+        let item = ItemImpl::new(1, "sword", "a basic sword", 100, ItemType::Upgrade, true);
+        inventory.add_item(item);
+        assert(inventory.has_item(1), 'Should find existing item');
+    }
+
+    #[test]
+    fn test_has_item_non_existing_item() {
+        let mut inventory = InventoryImpl::new(1);
+        let item = ItemImpl::new(1, "sword", "a basic sword", 100, ItemType::Upgrade, true);
+        inventory.add_item(item);
+        assert!(!inventory.has_item(2), "Should not find non-existing item");
+    }
+
+    #[test]
+    fn test_has_item_multiple_items() {
+        let mut inventory = InventoryImpl::new(1);
+        let item1 = ItemImpl::new(1, "sword", "a basic sword", 100, ItemType::Upgrade, true);
+        let item2 = ItemImpl::new(2, "potion", "healing potion", 50, ItemType::Consumable, true);
+        inventory.add_item(item1);
+        inventory.add_item(item2);
+        assert(inventory.has_item(1), 'Should find first item');
+        assert(inventory.has_item(2), 'Should find second item');
+        assert!(!inventory.has_item(3), "Should not find non-existing item");
+    }
 }

contract/src/systems/game.cairo

@@ -7,7 +7,7 @@ pub trait IBrawlGame<T> {
     fn take_damage(ref self: T, amount: u32);
     fn attack_enemy(ref self: T, enemy_id: u64, damage: u32);
     fn get_player_status(ref self: T) -> PlayerStatus;
-    fn use_item(ref self: T, item_id: u32);
+    fn use_item(ref self: T, item_id: u32, inventory_id: u32);
     fn create_ability(
         ref self: T,
         ability_id: u256,
@@ -42,7 +42,7 @@ pub mod brawl_game {
     use stark_brawl::models::player::{Player, PlayerTrait, spawn_player, ZeroablePlayerTrait};
 
     use stark_brawl::models::item::{Item, ItemType};
-    use stark_brawl::models::inventory::{Inventory};
+    use stark_brawl::models::inventory::{Inventory, InventoryTrait};
     use stark_brawl::models::enemy::{Enemy, EnemySystem};
     use stark_brawl::store::{Store, StoreImpl};
     use stark_brawl::systems::player::{IPlayerSystemDispatcher, IPlayerSystemDispatcherTrait};
@@ -182,22 +182,52 @@ pub mod brawl_game {
             }
         }
 
-        fn use_item(ref self: ContractState, item_id: u32) {
+        fn use_item(ref self: ContractState, item_id: u32, inventory_id: u32) {
             let mut world = self.world_default();
             let caller = get_caller_address();
 
-            let mut inventory: Inventory = world.read_model(caller);
-            let item: Item = world.read_model(item_id);
+            // Validate player exists
+            let player: Player = world.read_model(caller);
+            assert(!player.is_zero(), 'Player does not exist');
+
+            // Validate player is alive
             let player_system_dispatcher = self.player_system_dispatcher();
+            let is_player_alive = player_system_dispatcher.is_alive(caller);
+            assert(is_player_alive, 'Player not alive');
 
+            // Validate item exists
+            let item: Item = world.read_model(item_id);
+            assert(item.name.len() != 0, 'Item not found');
+            assert(item.usable, 'Item not usable');
+
+            // Validate item is in inventory
+            let mut inventory: Inventory = world.read_model(inventory_id);
+            assert(inventory.is_non_zero(), 'No inventory for player');
+            let has_item = inventory.has_item(item_id);
+            assert(has_item, 'Item not in inventory');
+
+            // Remove item from inventory
+            let removed = inventory.remove_item(item_id);
+            assert(removed, 'Failed to remove item');
+
+            // Apply item effects based on type
             match item.item_type {
-                ItemType::Trap => {},
+                ItemType::Trap => {
+                    // Apply trap effect: temporary defense boost
+                    // Assuming trap creates a temporary shield effect
+                    player_system_dispatcher.upgrade_max_hp(caller, item.value);
+                },
                 ItemType::Upgrade => {
+                    // Apply upgrade effect: permanent max HP increase
                     player_system_dispatcher.upgrade_max_hp(caller, item.value);
                 },
-                ItemType::Consumable => { player_system_dispatcher.heal(caller, item.value); },
+                ItemType::Consumable => {
+                    // Apply consumable effect: heal player
+                    player_system_dispatcher.heal(caller, item.value);
+                },
             }
 
+            // Update inventory in storage
             world.write_model(@inventory);
         }