(Feat) Item Dqta

Assets/GAME/Script/Inventory/InventorySlot.cs

@@ -1,31 +1,63 @@
 
 namespace Ashwild.Inventory
 {
+    /// <summary>
+    /// A single inventory cell: the item it holds, how many, and — for items that track uses
+    /// (tool durability, multi-bite food) — the remaining uses of this specific instance. Items
+    /// with uses never stack, so a slot's uses always describe one concrete instance.
+    /// </summary>
     [System.Serializable]
     public class InventorySlot
     {
         private ItemData itemData;
         private int quantity;
+        private int currentUses;
 
         public ItemData ItemData => itemData;
         public int Quantity => quantity;
+        public int CurrentUses => currentUses;
         public bool IsEmpty => itemData == null;
 
+        /// <summary>
+        /// Whether this slot holds a uses-tracked item whose uses have run out — kept in the
+        /// inventory (shown red and unusable) when the item is not destroyed on depletion.
+        /// </summary>
+        public bool IsDepleted => itemData != null && itemData.HasUses && currentUses <= 0;
+
+        /// <summary>
+        /// Places an item in the slot, resetting its uses to full for uses-tracked items.
+        /// </summary>
         public void Set(ItemData data, int qty)
         {
             itemData = data;
             quantity = qty;
+            currentUses = (data != null && data.HasUses) ? data.MaxUses : 0;
+        }
+
+        /// <summary>
+        /// Places an item with an explicit remaining-uses value, used when restoring a partially
+        /// used instance (e.g. picking a dropped tool back up). A negative value means "full".
+        /// </summary>
+        public void Set(ItemData data, int qty, int uses)
+        {
+            itemData = data;
+            quantity = qty;
+            if (data != null && data.HasUses)
+                currentUses = uses < 0 ? data.MaxUses : uses;
+            else
+                currentUses = 0;
         }
 
         public void Clear()
         {
             itemData = null;
             quantity = 0;
+            currentUses = 0;
         }
 
         public int AddQuantity(int amount)
         {
-            if (itemData == null || !itemData.IsStackable)
+            if (itemData == null || !itemData.IsStackable || itemData.HasUses)
                 return amount;
 
             int space = itemData.MaxStackSize - quantity;
@@ -41,9 +73,25 @@ namespace Ashwild.Inventory
                 Clear();
         }
 
+        /// <summary>
+        /// Spends uses on this instance (a tool hit, a food bite), clamped at 0. Has no effect on
+        /// items that do not track uses.
+        /// </summary>
+        public void ConsumeUse(int amount = 1)
+        {
+            if (itemData == null || !itemData.HasUses) return;
+            currentUses -= amount;
+            if (currentUses < 0) currentUses = 0;
+        }
+
+        /// <summary>
+        /// Uses-tracked items are non-stackable, so they never merge into an existing slot —
+        /// every instance keeps its own uses bar.
+        /// </summary>
         public bool CanAccept(ItemData data)
         {
             if (IsEmpty) return true;
+            if (data != null && data.HasUses) return false;
             return itemData == data && itemData.IsStackable && quantity < itemData.MaxStackSize;
         }
     }