Rework interactables into a flatter hierarchy, reenable puzzles as well

Assets/Scripts/Interactions/ItemSlot.cs

@@ -0,0 +1,145 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Interactions
+{
+    /// <summary>
+    /// Interaction requirement that allows slotting, swapping, or picking up items in a slot.
+    /// </summary>
+    [RequireComponent(typeof(Interactable))]
+    public class ItemSlot : Pickup
+    {
+        private PickupItemData _currentlySlottedItemData;
+        public SpriteRenderer slottedItemRenderer;
+        private GameObject _currentlySlottedItemObject = null;
+       
+        
+        public GameObject GetSlottedObject()
+        {
+            return _currentlySlottedItemObject;
+        }
+
+        public void SetSlottedObject(GameObject obj)
+        {
+            _currentlySlottedItemObject = obj;
+            if (_currentlySlottedItemObject != null)
+            {
+                _currentlySlottedItemObject.SetActive(false);
+            }
+        }
+
+        protected override void OnCharacterArrived()
+        {
+            var heldItemData = FollowerController.CurrentlyHeldItemData;
+            var heldItemObj = FollowerController.GetHeldPickupObject();
+            var pickup = GetComponent<Pickup>();
+            var slotItem = pickup != null ? pickup.itemData : null;
+            var config = GameManager.Instance.GetSlotItemConfig(slotItem);
+            var allowed = config?.allowedItems ?? new List<PickupItemData>();
+            var forbidden = config?.forbiddenItems ?? new List<PickupItemData>();
+
+            if ((heldItemData == null && _currentlySlottedItemObject != null) 
+                || (heldItemData != null && _currentlySlottedItemObject != null))
+            {
+                FollowerController.TryPickupItem(_currentlySlottedItemObject, _currentlySlottedItemData);
+                _currentlySlottedItemObject = null;
+                _currentlySlottedItemData = null;
+                UpdateSlottedSprite();
+                return;
+            }
+            
+            // // CASE 1: No held item, slot has item -> pick up slotted item
+            // if (heldItemData == null && _cachedSlottedObject != null)
+            // {
+            //     InteractionOrchestrator.Instance.PickupItem(FollowerController, _cachedSlottedObject);
+            //     _cachedSlottedObject = null;
+            //     currentlySlottedItem = null;
+            //     UpdateSlottedSprite();
+            //     Interactable.BroadcastInteractionComplete(false);
+            //     return;
+            // }
+            // // CASE 2: Held item, slot has item -> swap
+            // if 
+            // {
+            //     InteractionOrchestrator.Instance.SwapItems(FollowerController, this);
+            //     currentlySlottedItem = heldItemData;
+            //     UpdateSlottedSprite();
+            //     return;
+            // }
+            // CASE 3: Held item, slot empty -> slot the held item
+            if (heldItemData != null && _currentlySlottedItemObject == null)
+            {
+                if (forbidden.Contains(heldItemData))
+                {
+                    DebugUIMessage.Show("Can't place that here.");
+                    Interactable.BroadcastInteractionComplete(false);
+                    return;
+                }
+
+                SlotItem(heldItemObj, heldItemData);
+                if (allowed.Contains(heldItemData))
+                {
+                    Interactable.BroadcastInteractionComplete(true);
+                    return;
+                }
+                else
+                {
+                    DebugUIMessage.Show("I'm not sure this works.");
+                    Interactable.BroadcastInteractionComplete(false);
+                    return;
+                }
+            }
+            
+            // CASE 4: No held item, slot empty -> show warning
+            if (heldItemData == null && _currentlySlottedItemObject == null)
+            {
+                DebugUIMessage.Show("This requires an item.");
+                return;
+            }
+            return;
+        }
+
+        /// <summary>
+        /// Updates the sprite and scale for the currently slotted item.
+        /// </summary>
+        private void UpdateSlottedSprite()
+        {
+            if (slottedItemRenderer != null && _currentlySlottedItemData != null && _currentlySlottedItemData.mapSprite != null)
+            {
+                slottedItemRenderer.sprite = _currentlySlottedItemData.mapSprite;
+                // Scale sprite to desired height, preserve aspect ratio, compensate for parent scale
+                float desiredHeight = GameManager.Instance.HeldIconDisplayHeight;
+                var sprite = _currentlySlottedItemData.mapSprite;
+                float spriteHeight = sprite.bounds.size.y;
+                float spriteWidth = sprite.bounds.size.x;
+                Vector3 parentScale = slottedItemRenderer.transform.parent != null
+                    ? slottedItemRenderer.transform.parent.localScale
+                    : Vector3.one;
+                if (spriteHeight > 0f)
+                {
+                    float uniformScale = desiredHeight / spriteHeight;
+                    float scale = uniformScale / Mathf.Max(parentScale.x, parentScale.y);
+                    slottedItemRenderer.transform.localScale = new Vector3(scale, scale, 1f);
+                }
+            }
+            else if (slottedItemRenderer != null)
+            {
+                slottedItemRenderer.sprite = null;
+            }
+        }
+        
+        public void SlotItem(GameObject itemToSlot, PickupItemData itemToSlotData)
+        {
+            if (itemToSlot == null) 
+                return;
+            
+            itemToSlot.SetActive(false);
+            itemToSlot.transform.SetParent(null);
+            SetSlottedObject(itemToSlot);
+            
+            _currentlySlottedItemData = itemToSlotData;
+            UpdateSlottedSprite();
+            FollowerController.ClearHeldItem();
+        }
+    }
+}