cement daddy

Assets/Prefabs/Environment/LureSpotA.prefab

@@ -262,7 +262,7 @@ MonoBehaviour:
       m_Calls: []
   itemData: {fileID: 11400000, guid: aaf36cd26cf74334e9c7db6c1b03b3fb, type: 2}
   iconRenderer: {fileID: 6258593095132504700}
-  slottedItemRenderer: {fileID: 4110666412151536905}
+  slottedItemRenderers: []
   onItemSlotted:
     m_PersistentCalls:
       m_Calls: []

Assets/Prefabs/Environment/LuringSpotB.prefab

@@ -1170,7 +1170,7 @@ MonoBehaviour:
       m_Calls: []
   itemData: {fileID: 11400000, guid: f97b9e24d6dceb145b56426c1152ebeb, type: 2}
   iconRenderer: {fileID: 2343214996212089369}
-  slottedItemRenderer: {fileID: 7990414055343410434}
+  slottedItemRenderers: []
   onItemSlotted:
     m_PersistentCalls:
       m_Calls: []

Assets/Prefabs/Environment/LuringSpotC.prefab

@@ -348,7 +348,7 @@ MonoBehaviour:
       m_Calls: []
   itemData: {fileID: 11400000, guid: c68dea945fecbf44094359769db04f31, type: 2}
   iconRenderer: {fileID: 2825253017896168654}
-  slottedItemRenderer: {fileID: 3806274462998212361}
+  slottedItemRenderers: []
   onItemSlotted:
     m_PersistentCalls:
       m_Calls: []

Assets/Prefabs/Environment/SoundBird.prefab

@@ -203,7 +203,7 @@ MonoBehaviour:
       m_Calls: []
   itemData: {fileID: 11400000, guid: d28f5774afad9d14f823601707150700, type: 2}
   iconRenderer: {fileID: 8875860401447896107}
-  slottedItemRenderer: {fileID: 6941190210788968874}
+  slottedItemRenderers: []
   onItemSlotted:
     m_PersistentCalls:
       m_Calls: []

Assets/Scenes/Levels/Quarry.unity

@@ -465965,7 +465965,8 @@ MonoBehaviour:
       m_Calls: []
   itemData: {fileID: 11400000, guid: d28f5774afad9d14f823601707150700, type: 2}
   iconRenderer: {fileID: 1399567344}
-  slottedItemRenderer: {fileID: 1707349194}
+  slottedItemRenderers:
+  - {fileID: 1707349194}
   onItemSlotted:
     m_PersistentCalls:
       m_Calls: []
@@ -471861,6 +471862,14 @@ PrefabInstance:
       propertyPath: bushAnimator
       value: 
       objectReference: {fileID: 1476225951}
+    - target: {fileID: 3093816592344978065, guid: 3346526f3046f424196615241a307104, type: 3}
+      propertyPath: slottedItemRenderers.Array.size
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 3093816592344978065, guid: 3346526f3046f424196615241a307104, type: 3}
+      propertyPath: 'slottedItemRenderers.Array.data[0]'
+      value: 
+      objectReference: {fileID: 3708074769586677214}
     - target: {fileID: 3093816592344978065, guid: 3346526f3046f424196615241a307104, type: 3}
       propertyPath: onCorrectItemSlotted.m_PersistentCalls.m_Calls.Array.data[1].m_Target
       value: 
@@ -471939,6 +471948,11 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 95e46aacea5b42888ee7881894193c11, type: 3}
   m_Name: 
   m_EditorClassIdentifier: AppleHillsScripts::Core.SaveLoad.AppleState
+--- !u!212 &3708074769586677214 stripped
+SpriteRenderer:
+  m_CorrespondingSourceObject: {fileID: 7990414055343410434, guid: 3346526f3046f424196615241a307104, type: 3}
+  m_PrefabInstance: {fileID: 3708074769586677211}
+  m_PrefabAsset: {fileID: 0}
 --- !u!1001 &3917799031583628180
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -472016,6 +472030,14 @@ PrefabInstance:
     serializedVersion: 3
     m_TransformParent: {fileID: 1007550749}
     m_Modifications:
+    - target: {fileID: 106497079666291966, guid: df01157608cce6447b7ccde0bfa290e1, type: 3}
+      propertyPath: slottedItemRenderers.Array.size
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 106497079666291966, guid: df01157608cce6447b7ccde0bfa290e1, type: 3}
+      propertyPath: 'slottedItemRenderers.Array.data[0]'
+      value: 
+      objectReference: {fileID: 3978117984697153446}
     - target: {fileID: 106497079666291966, guid: df01157608cce6447b7ccde0bfa290e1, type: 3}
       propertyPath: onCorrectItemSlotted.m_PersistentCalls.m_Calls.Array.data[1].m_Target
       value: 
@@ -472081,6 +472103,11 @@ PrefabInstance:
     m_AddedGameObjects: []
     m_AddedComponents: []
   m_SourcePrefab: {fileID: 100100000, guid: df01157608cce6447b7ccde0bfa290e1, type: 3}
+--- !u!212 &3978117984697153446 stripped
+SpriteRenderer:
+  m_CorrespondingSourceObject: {fileID: 3806274462998212361, guid: df01157608cce6447b7ccde0bfa290e1, type: 3}
+  m_PrefabInstance: {fileID: 3978117984697153445}
+  m_PrefabAsset: {fileID: 0}
 --- !u!1001 &4596770314561390347
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -472839,6 +472866,22 @@ PrefabInstance:
       propertyPath: playerToPlaceDistance
       value: 30
       objectReference: {fileID: 0}
+    - target: {fileID: 4110666412151536905, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: m_Size.x
+      value: 5.75
+      objectReference: {fileID: 0}
+    - target: {fileID: 4110666412151536905, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: m_Size.y
+      value: 2.78
+      objectReference: {fileID: 0}
+    - target: {fileID: 4110666412151536905, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: m_Sprite
+      value: 
+      objectReference: {fileID: 0}
+    - target: {fileID: 4110666412151536905, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: m_WasSpriteAssigned
+      value: 0
+      objectReference: {fileID: 0}
     - target: {fileID: 5375394469162727687, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
       propertyPath: m_LocalPosition.x
       value: 5.28
@@ -472911,6 +472954,18 @@ PrefabInstance:
       propertyPath: m_Name
       value: LureSpotA_Slot
       objectReference: {fileID: 0}
+    - target: {fileID: 8578055200319571631, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: iconRenderer
+      value: 
+      objectReference: {fileID: 8013274907828598646}
+    - target: {fileID: 8578055200319571631, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: slottedItemRenderers.Array.size
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8578055200319571631, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+      propertyPath: 'slottedItemRenderers.Array.data[0]'
+      value: 
+      objectReference: {fileID: 8013274907828598645}
     - target: {fileID: 8578055200319571631, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
       propertyPath: onCorrectItemSlotted.m_PersistentCalls.m_Calls.Array.size
       value: 2
@@ -472965,6 +473020,16 @@ Transform:
   m_CorrespondingSourceObject: {fileID: 2045549771447434109, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
   m_PrefabInstance: {fileID: 8013274907828598643}
   m_PrefabAsset: {fileID: 0}
+--- !u!212 &8013274907828598645 stripped
+SpriteRenderer:
+  m_CorrespondingSourceObject: {fileID: 4110666412151536905, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+  m_PrefabInstance: {fileID: 8013274907828598643}
+  m_PrefabAsset: {fileID: 0}
+--- !u!212 &8013274907828598646 stripped
+SpriteRenderer:
+  m_CorrespondingSourceObject: {fileID: 6258593095132504700, guid: 3144c6bbac26fbd49a1608152821cc5f, type: 3}
+  m_PrefabInstance: {fileID: 8013274907828598643}
+  m_PrefabAsset: {fileID: 0}
 --- !u!1001 &8058740013708592448
 PrefabInstance:
   m_ObjectHideFlags: 0

Assets/Scripts/Core/Settings/ItemConfigTypes.cs

@@ -23,5 +23,8 @@ namespace AppleHills.Core.Settings
         public PickupItemData slotItem; // The slot object (SO reference)
         public List<PickupItemData> allowedItems;
         public List<PickupItemData> forbiddenItems; // Items that cannot be placed in this slot
+        
+        [Tooltip("Number of items required to complete this slot. If 0, requires ALL allowed items.")]
+        public int requiredItemCount; // 0 = require all allowed items (backward compatible)
     }
 }

Assets/Scripts/Interactions/ItemSlot.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq; // for Count() on List<bool>
 using UnityEngine;
 using UnityEngine.Events;
 using System; // for Action<T>
@@ -23,8 +24,9 @@ namespace Interactions
     public class ItemSlotSaveData
     {
         public ItemSlotState slotState;
-        public string slottedItemSaveId;
-        public string slottedItemDataId; // ItemId of the PickupItemData (for verification)
+        public List<string> slottedItemSaveIds = new List<string>(); // Changed to list for multi-slot support
+        public List<string> slottedItemDataIds = new List<string>(); // Changed to list for multi-slot support
+        public bool isLocked; // Track if slot is completed and locked
     }
 
     /// <summary>
@@ -37,13 +39,17 @@ namespace Interactions
         public PickupItemData itemData;
         public SpriteRenderer iconRenderer;
         
-        // Slotted item tracking
-        private PickupItemData currentlySlottedItemData;
-        public SpriteRenderer slottedItemRenderer;
-        private GameObject currentlySlottedItemObject;
+        // Multi-slot item tracking
+        private List<PickupItemData> slottedItemsData = new List<PickupItemData>();
+        public SpriteRenderer[] slottedItemRenderers; // Array of renderers for multiple items
+        private List<GameObject> slottedItemObjects = new List<GameObject>();
+        private List<bool> slottedItemCorrectness = new List<bool>(); // Track which items are correct
         
-        // Tracks the current state of the slotted item
+        // Tracks the current state of the slotted item(s)
         private ItemSlotState currentState = ItemSlotState.None;
+        
+        // Lock flag to prevent removal after successful completion
+        private bool isLockedAfterCompletion;
 
         // Settings reference
         private IInteractionSettings interactionSettings;
@@ -53,10 +59,53 @@ namespace Interactions
         /// Read-only access to the current slotted item state.
         /// </summary>
         public ItemSlotState CurrentSlottedState => currentState;
+        
+        /// <summary>
+        /// Number of items currently slotted (correct or incorrect)
+        /// </summary>
+        public int CurrentSlottedCount => slottedItemObjects.Count;
+        
+        /// <summary>
+        /// Number of CORRECT items currently slotted
+        /// </summary>
+        public int CurrentCorrectCount => slottedItemCorrectness.Count(correct => correct);
+        
+        /// <summary>
+        /// Number of items required to complete this slot
+        /// </summary>
+        public int RequiredItemCount
+        {
+            get
+            {
+                var config = interactionSettings?.GetSlotItemConfig(itemData);
+                if (config != null)
+                {
+                    // If requiredItemCount is set (> 0), use it; otherwise require all allowed items
+                    return config.requiredItemCount > 0 ? config.requiredItemCount : (config.allowedItems?.Count ?? 0);
+                }
+                return 1; // Default to 1 for backward compatibility
+            }
+        }
+        
+        /// <summary>
+        /// Whether this slot has all required CORRECT items
+        /// </summary>
+        public bool IsComplete => CurrentCorrectCount >= RequiredItemCount && RequiredItemCount > 0;
+        
+        /// <summary>
+        /// Whether this slot has space for more items
+        /// </summary>
+        public bool HasSpace => slottedItemRenderers != null && CurrentSlottedCount < slottedItemRenderers.Length;
+        
+        /// <summary>
+        /// Whether this is a multi-slot (more than one renderer)
+        /// </summary>
+        private bool IsMultiSlot => slottedItemRenderers != null && slottedItemRenderers.Length > 1;
 
         public UnityEvent onItemSlotted;
         public UnityEvent onItemSlotRemoved;
-        // Native C# event alternative for code-only subscribers
+        // Native C# event alternatives for code-only subscribers
+        public event Action<PickupItemData, PickupItemData> OnItemSlotted; // (slotData, slottedItemData)
         public event Action<PickupItemData> OnItemSlotRemoved;
 
         public UnityEvent onCorrectItemSlotted;
@@ -69,17 +118,30 @@ namespace Interactions
 
         public UnityEvent onForbiddenItemSlotted;
         
+        /// <summary>
+        /// Get the first (or only) slotted object - for backward compatibility
+        /// </summary>
         public GameObject GetSlottedObject()
         {
-            return currentlySlottedItemObject;
+            return slottedItemObjects.Count > 0 ? slottedItemObjects[0] : null;
         }
 
+        /// <summary>
+        /// Set a slotted object - for backward compatibility, replaces first item or adds
+        /// </summary>
         public void SetSlottedObject(GameObject obj)
         {
-            currentlySlottedItemObject = obj;
-            if (currentlySlottedItemObject != null)
+            if (obj != null)
             {
-                currentlySlottedItemObject.SetActive(false);
+                if (slottedItemObjects.Count == 0)
+                {
+                    slottedItemObjects.Add(obj);
+                }
+                else
+                {
+                    slottedItemObjects[0] = obj;
+                }
+                obj.SetActive(false);
             }
         }
 
@@ -134,12 +196,32 @@ namespace Interactions
         {
             var heldItem = FollowerController?.CurrentlyHeldItemData;
             
+            // Check if slot is locked after completion
+            if (isLockedAfterCompletion)
+            {
+                if (heldItem != null)
+                    return (false, "This is already complete.");
+                else
+                    return (false, "I can't remove these items.");
+            }
+            
             // Scenario: Nothing held + Empty slot = Error
-            if (heldItem == null && currentlySlottedItemObject == null)
+            if (heldItem == null && CurrentSlottedCount == 0)
                 return (false, "This requires an item.");
             
-            // Check forbidden items if trying to slot into empty slot
-            if (heldItem != null && currentlySlottedItemObject == null)
+            // If holding an item and slot is full but not complete, allow swap
+            if (heldItem != null && !HasSpace)
+            {
+                // Allow swap for fixing mistakes (single-slot or multi-slot not complete)
+                if (!IsMultiSlot || !IsComplete)
+                    return (true, null); // Allow swap
+                
+                // Multi-slot is complete - can't swap
+                return (false, "This slot is full.");
+            }
+            
+            // Check forbidden items if trying to slot
+            if (heldItem != null)
             {
                 var config = interactionSettings?.GetSlotItemConfig(itemData);
                 var forbidden = config?.forbiddenItems ?? new List<PickupItemData>();
@@ -153,7 +235,7 @@ namespace Interactions
 
         /// <summary>
         /// Main interaction logic: Slot, pickup, swap, or combine items.
-        /// Returns true only if correct item was slotted.
+        /// Returns true only if correct item was slotted AND slot is now complete.
         /// </summary>
         protected override bool DoInteraction()
         {
@@ -162,24 +244,33 @@ namespace Interactions
             var heldItemData = FollowerController.CurrentlyHeldItemData;
             var heldItemObj = FollowerController.GetHeldPickupObject();
             
-            // Scenario 1: Held item + Empty slot = Slot it
-            if (heldItemData != null && currentlySlottedItemObject == null)
+            // Scenario 1: Held item + Has space = Slot it
+            if (heldItemData != null && HasSpace)
             {
                 SlotItem(heldItemObj, heldItemData);
                 FollowerController.ClearHeldItem(); // Clear follower's hand after slotting
-                return IsSlottedItemCorrect();
+                
+                // Check if we completed the slot
+                if (IsComplete)
+                {
+                    isLockedAfterCompletion = true;
+                    currentState = ItemSlotState.Correct;
+                    return true; // Completed!
+                }
+                
+                return false; // Slotted but not complete yet
             }
             
             // Scenario 2 & 3: Slot is full
-            if (currentlySlottedItemObject != null)
+            if (CurrentSlottedCount > 0)
             {
-                // Try combination if both items present
-                if (heldItemData != null)
+                // Try combination if both items present (only for single slots)
+                if (heldItemData != null && !IsMultiSlot)
                 {
-                    var slottedPickup = currentlySlottedItemObject.GetComponent<Pickup>();
+                    var slottedPickup = slottedItemObjects[0].GetComponent<Pickup>();
                     if (slottedPickup != null)
                     {
-                        var comboResult = FollowerController.TryCombineItems(slottedPickup, out var combinationResultItem);
+                        var comboResult = FollowerController.TryCombineItems(slottedPickup, out _);
                         
                         if (comboResult == FollowerController.CombinationResult.Successful)
                         {
@@ -190,55 +281,88 @@ namespace Interactions
                     }
                 }
                 
-                // No combination or unsuccessful - perform swap
-                // Step 1: Pickup from slot (follower now holds the old slotted item)
-                FollowerController.TryPickupItem(currentlySlottedItemObject, currentlySlottedItemData, dropItem: false);
-                ClearSlot();
-                
-                // Step 2: If we had a held item, slot it (follower already holding picked up item, don't clear!)
-                if (heldItemData != null)
+                // Swap behavior when slot is full (single slots OR multi-slots that aren't complete)
+                if (heldItemData != null && !HasSpace)
                 {
-                    SlotItem(heldItemObj, heldItemData);
-                    // Don't clear follower - they're holding the item they picked up from the slot
-                    return IsSlottedItemCorrect();
+                    // For single slots: always allow swap
+                    // For multi-slots: only allow swap if not complete yet (allows fixing mistakes)
+                    if (!IsMultiSlot || !IsComplete)
+                    {
+                        // LIFO swap - swap with the last item
+                        int lastIndex = CurrentSlottedCount - 1;
+                        var itemToReturn = slottedItemObjects[lastIndex];
+                        var itemDataToReturn = slottedItemsData[lastIndex];
+                        
+                        // Step 1: Give old item to follower
+                        FollowerController.TryPickupItem(itemToReturn, itemDataToReturn, dropItem: false);
+                        
+                        // Step 2: Remove old item from slot
+                        RemoveItemAtIndex(lastIndex);
+                        
+                        // Step 3: Slot the new item
+                        SlotItem(heldItemObj, heldItemData);
+                        
+                        // Check if we completed the slot with this swap
+                        if (IsComplete)
+                        {
+                            isLockedAfterCompletion = true;
+                            currentState = ItemSlotState.Correct;
+                            return true; // Completed!
+                        }
+                        
+                        return false; // Swapped but not complete
+                    }
                 }
                 
-                // Just picked up from slot - not a success
-                return false;
+                // Pickup from slot (empty hands) - LIFO removal
+                if (heldItemData == null)
+                {
+                    int lastIndex = CurrentSlottedCount - 1;
+                    var itemToPickup = slottedItemObjects[lastIndex];
+                    var itemDataToPickup = slottedItemsData[lastIndex];
+                    
+                    // Try to give item to follower
+                    FollowerController.TryPickupItem(itemToPickup, itemDataToPickup, dropItem: false);
+                    
+                    // Remove from slot
+                    RemoveItemAtIndex(lastIndex);
+                    
+                    // Just picked up from slot - not a success
+                    return false;
+                }
             }
             
             // Shouldn't reach here (validation prevents empty + no held)
             return false;
         }
         
-        /// <summary>
-        /// Helper: Check if the currently slotted item is correct.
-        /// </summary>
-        private bool IsSlottedItemCorrect()
-        {
-            return currentState == ItemSlotState.Correct;
-        }
+
         
         /// <summary>
         /// Helper: Clear the slot and fire removal events.
         /// </summary>
         private void ClearSlot()
         {
-            var previousData = currentlySlottedItemData;
+            var previousData = slottedItemsData.Count > 0 ? slottedItemsData[0] : null;
             
-            // Clear the pickup's OwningSlot reference
-            if (currentlySlottedItemObject != null)
+            // Clear all pickup's OwningSlot references
+            foreach (var itemObj in slottedItemObjects)
             {
-                var pickup = currentlySlottedItemObject.GetComponent<Pickup>();
-                if (pickup != null)
+                if (itemObj != null)
                 {
-                    pickup.OwningSlot = null;
+                    var pickup = itemObj.GetComponent<Pickup>();
+                    if (pickup != null)
+                    {
+                        pickup.OwningSlot = null;
+                    }
                 }
             }
             
-            currentlySlottedItemObject = null;
-            currentlySlottedItemData = null;
+            slottedItemObjects.Clear();
+            slottedItemsData.Clear();
+            slottedItemCorrectness.Clear(); // Also clear correctness tracking
             currentState = ItemSlotState.None;
+            isLockedAfterCompletion = false;
             UpdateSlottedSprite();
             
             // Fire removal events
@@ -246,35 +370,92 @@ namespace Interactions
             OnItemSlotRemoved?.Invoke(previousData);
         }
         
+        /// <summary>
+        /// Helper: Remove a specific item from the slot by index.
+        /// </summary>
+        private void RemoveItemAtIndex(int index)
+        {
+            if (index < 0 || index >= CurrentSlottedCount)
+                return;
+            
+            var itemObj = slottedItemObjects[index];
+            var removedItemData = slottedItemsData[index];
+            
+            // Clear the pickup's OwningSlot reference
+            if (itemObj != null)
+            {
+                var pickup = itemObj.GetComponent<Pickup>();
+                if (pickup != null)
+                {
+                    pickup.OwningSlot = null;
+                }
+            }
+            
+            slottedItemObjects.RemoveAt(index);
+            slottedItemsData.RemoveAt(index);
+            slottedItemCorrectness.RemoveAt(index); // Also remove correctness tracking
+            
+            if (CurrentSlottedCount == 0)
+            {
+                currentState = ItemSlotState.None;
+                isLockedAfterCompletion = false;
+            }
+            
+            UpdateSlottedSprite();
+            
+            // Fire removal events
+            onItemSlotRemoved?.Invoke();
+            OnItemSlotRemoved?.Invoke(removedItemData);
+        }
+        
         #endregion
         
         #region Visual Updates
 
         /// <summary>
-        /// Updates the sprite and scale for the currently slotted item.
+        /// Updates the sprite and scale for all slotted items.
         /// </summary>
         private void UpdateSlottedSprite()
         {
-            if (slottedItemRenderer != null && currentlySlottedItemData != null && currentlySlottedItemData.mapSprite != null)
+            if (slottedItemRenderers == null || slottedItemRenderers.Length == 0)
+                return;
+            
+            // Update each renderer based on slotted items
+            for (int i = 0; i < slottedItemRenderers.Length; i++)
             {
-                slottedItemRenderer.sprite = currentlySlottedItemData.mapSprite;
-                // Scale sprite to desired height, preserve aspect ratio, compensate for parent scale
-                float desiredHeight = playerFollowerSettings?.HeldIconDisplayHeight ?? 2.0f;
-                var sprite = currentlySlottedItemData.mapSprite;
-                float spriteHeight = sprite.bounds.size.y;
-                Vector3 parentScale = slottedItemRenderer.transform.parent != null
-                    ? slottedItemRenderer.transform.parent.localScale
-                    : Vector3.one;
-                if (spriteHeight > 0f)
+                var slotRenderer = slottedItemRenderers[i];
+                if (slotRenderer == null)
+                    continue;
+                
+                // If we have an item at this index, show it
+                if (i < slottedItemsData.Count && slottedItemsData[i] != null)
                 {
-                    float uniformScale = desiredHeight / spriteHeight;
-                    float scale = uniformScale / Mathf.Max(parentScale.x, parentScale.y);
-                    slottedItemRenderer.transform.localScale = new Vector3(scale, scale, 1f);
+                    var slottedData = slottedItemsData[i];
+                    if (slottedData.mapSprite != null)
+                    {
+                        slotRenderer.sprite = slottedData.mapSprite;
+                        
+                        // Scale sprite to desired height, preserve aspect ratio, compensate for parent scale
+                        float desiredHeight = playerFollowerSettings?.HeldIconDisplayHeight ?? 2.0f;
+                        var sprite = slottedData.mapSprite;
+                        float spriteHeight = sprite.bounds.size.y;
+                        Vector3 parentScale = slotRenderer.transform.parent != null
+                            ? slotRenderer.transform.parent.localScale
+                            : Vector3.one;
+                        
+                        if (spriteHeight > 0f)
+                        {
+                            float uniformScale = desiredHeight / spriteHeight;
+                            float scale = uniformScale / Mathf.Max(parentScale.x, parentScale.y);
+                            slotRenderer.transform.localScale = new Vector3(scale, scale, 1f);
+                        }
+                    }
+                }
+                else
+                {
+                    // Clear renderer if no item at this index
+                    slotRenderer.sprite = null;
                 }
-            }
-            else if (slottedItemRenderer != null)
-            {
-                slottedItemRenderer.sprite = null;
             }
         }
         
@@ -297,31 +478,47 @@ namespace Interactions
 
         protected override object GetSerializableState()
         {
-            // Get slotted item save ID if there's a slotted item
-            string slottedSaveId = "";
-            string slottedDataId = "";
-            
-            if (currentlySlottedItemObject != null)
+            var saveData = new ItemSlotSaveData
             {
-                var slottedPickup = currentlySlottedItemObject.GetComponent<Pickup>();
-                if (slottedPickup is SaveableInteractable saveablePickup)
+                slotState = currentState,
+                isLocked = isLockedAfterCompletion
+            };
+            
+            // Save all slotted items
+            foreach (var itemObj in slottedItemObjects)
+            {
+                if (itemObj != null)
                 {
-                    slottedSaveId = saveablePickup.SaveId;
+                    var slottedPickup = itemObj.GetComponent<Pickup>();
+                    if (slottedPickup is SaveableInteractable saveablePickup)
+                    {
+                        saveData.slottedItemSaveIds.Add(saveablePickup.SaveId);
+                    }
+                    else
+                    {
+                        saveData.slottedItemSaveIds.Add("");
+                    }
+                }
+                else
+                {
+                    saveData.slottedItemSaveIds.Add("");
                 }
             }
             
-            // Also save the itemData ID for verification
-            if (currentlySlottedItemData != null)
+            // Save all item data IDs for verification
+            foreach (var slottedData in slottedItemsData)
             {
-                slottedDataId = currentlySlottedItemData.itemId;
+                if (slottedData != null)
+                {
+                    saveData.slottedItemDataIds.Add(slottedData.itemId);
+                }
+                else
+                {
+                    saveData.slottedItemDataIds.Add("");
+                }
             }
 
-            return new ItemSlotSaveData
-            {
-                slotState = currentState,
-                slottedItemSaveId = slottedSaveId,
-                slottedItemDataId = slottedDataId
-            };
+            return saveData;
         }
 
         protected override void ApplySerializableState(string serializedData)
@@ -335,13 +532,26 @@ namespace Interactions
 
             // Restore slot state
             currentState = data.slotState;
+            isLockedAfterCompletion = data.isLocked;
 
-            // Restore slotted item if there was one
-            if (!string.IsNullOrEmpty(data.slottedItemSaveId))
+            // Restore all slotted items if there were any
+            if (data.slottedItemSaveIds != null && data.slottedItemSaveIds.Count > 0)
             {
-                Logging.Debug($"[ItemSlot] Restoring slotted item: {data.slottedItemSaveId} (itemId: {data.slottedItemDataId})");
-                RestoreSlottedItem(data.slottedItemSaveId, data.slottedItemDataId);
+                for (int i = 0; i < data.slottedItemSaveIds.Count; i++)
+                {
+                    string saveId = data.slottedItemSaveIds[i];
+                    string dataId = i < data.slottedItemDataIds.Count ? data.slottedItemDataIds[i] : "";
+                    
+                    if (!string.IsNullOrEmpty(saveId))
+                    {
+                        Logging.Debug($"[ItemSlot] Restoring slotted item {i}: {saveId} (itemId: {dataId})");
+                        RestoreSlottedItem(saveId, dataId);
+                    }
+                }
             }
+            
+            // Update all renderers after restoration
+            UpdateSlottedSprite();
         }
 
         /// <summary>
@@ -411,118 +621,107 @@ namespace Interactions
                 return;
             }
 
-            // Silently slot the item (no events, no interaction completion)
+            // Add to slotted items list (no events, no interaction completion)
             // Follower state is managed separately during save/load restoration
-            ApplySlottedItemState(slottedObject, slottedData, triggerEvents: false);
+            slottedItemObjects.Add(slottedObject);
+            slottedItemsData.Add(slottedData);
             
-            Logging.Debug($"[ItemSlot] Successfully restored slotted item: {slottedData.itemName} (itemId: {slottedData.itemId})");
-        }
-
-        /// <summary>
-        /// Core logic for slotting an item. Can be used both for normal slotting and silent restoration.
-        /// NOTE: Does NOT call CompleteInteraction - the template method handles that via DoInteraction return value.
-        /// NOTE: Does NOT manage follower state - caller is responsible for clearing follower's hand if needed.
-        /// </summary>
-        /// <param name="itemToSlot">The item GameObject to slot (or null to clear)</param>
-        /// <param name="itemToSlotData">The PickupItemData for the item</param>
-        /// <param name="triggerEvents">Whether to fire events</param>
-        private void ApplySlottedItemState(GameObject itemToSlot, PickupItemData itemToSlotData, bool triggerEvents)
-        {
-            if (itemToSlot == null)
+            // Determine if this item is correct for correctness tracking
+            var config = interactionSettings?.GetSlotItemConfig(itemData);
+            var allowed = config?.allowedItems ?? new List<PickupItemData>();
+            bool isCorrectItem = PickupItemData.ListContainsEquivalent(allowed, slottedData);
+            slottedItemCorrectness.Add(isCorrectItem);
+            
+            // Deactivate the item and set pickup state
+            slottedObject.SetActive(false);
+            if (pickup != null)
             {
-                // Clear slot - also clear the pickup's OwningSlot reference
-                if (currentlySlottedItemObject != null)
-                {
-                    var oldPickup = currentlySlottedItemObject.GetComponent<Pickup>();
-                    if (oldPickup != null)
-                    {
-                        oldPickup.OwningSlot = null;
-                    }
-                }
-                
-                var previousData = currentlySlottedItemData;
-                currentlySlottedItemObject = null;
-                currentlySlottedItemData = null;
-                currentState = ItemSlotState.None;
-                
-                // Fire native event for slot clearing (only if triggering events)
-                if (previousData != null && triggerEvents)
-                {
-                    onItemSlotRemoved?.Invoke();
-                    OnItemSlotRemoved?.Invoke(previousData);
-                }
-            }
-            else
-            {
-                // Slot the item
-                itemToSlot.SetActive(false);
-                itemToSlot.transform.SetParent(null);
-                SetSlottedObject(itemToSlot);
-                currentlySlottedItemData = itemToSlotData;
-                
-                // Mark the pickup as picked up and track slot ownership for save/load
-                var pickup = itemToSlot.GetComponent<Pickup>();
-                if (pickup != null)
-                {
-                    pickup.IsPickedUp = true;
-                    pickup.OwningSlot = this;
-                }
-                
-                // Determine if correct
-                var config = interactionSettings?.GetSlotItemConfig(itemData);
-                var allowed = config?.allowedItems ?? new List<PickupItemData>();
-                
-                if (itemToSlotData != null && PickupItemData.ListContainsEquivalent(allowed, itemToSlotData))
-                {
-                    currentState = ItemSlotState.Correct;
-                    
-                    // Fire events if requested
-                    if (triggerEvents)
-                    {
-                        DebugUIMessage.Show($"You correctly slotted {itemToSlotData.itemName} into: {itemData.itemName}", Color.green);
-                        onCorrectItemSlotted?.Invoke();
-                        OnCorrectItemSlotted?.Invoke(itemData, currentlySlottedItemData);
-                    }
-                }
-                else
-                {
-                    currentState = ItemSlotState.Incorrect;
-                    
-                    // Fire events if requested
-                    if (triggerEvents)
-                    {
-                        DebugUIMessage.Show("I'm not sure this works.", Color.yellow);
-                        onIncorrectItemSlotted?.Invoke();
-                        OnIncorrectItemSlotted?.Invoke(itemData, currentlySlottedItemData);
-                    }
-                }
+                pickup.IsPickedUp = true;
+                pickup.OwningSlot = this;
             }
             
-            UpdateSlottedSprite();
+            Logging.Debug($"[ItemSlot] Successfully restored slotted item: {slottedData.itemName} (itemId: {slottedData.itemId}, correct: {isCorrectItem})");
         }
 
         /// <summary>
         /// Public API for slotting items during gameplay.
+        /// Adds item to the slot (multi-slot support).
         /// Caller is responsible for managing follower's held item state.
         /// </summary>
         public void SlotItem(GameObject itemToSlot, PickupItemData itemToSlotData)
         {
-            ApplySlottedItemState(itemToSlot, itemToSlotData, triggerEvents: true);
+            if (itemToSlot == null || itemToSlotData == null)
+            {
+                Logging.Warning($"[ItemSlot] Attempted to slot null item or data");
+                return;
+            }
+            
+            // Determine if this item is correct (allowed)
+            var config = interactionSettings?.GetSlotItemConfig(itemData);
+            var allowed = config?.allowedItems ?? new List<PickupItemData>();
+            bool isCorrectItem = PickupItemData.ListContainsEquivalent(allowed, itemToSlotData);
+            
+            // Add to lists
+            slottedItemObjects.Add(itemToSlot);
+            slottedItemsData.Add(itemToSlotData);
+            slottedItemCorrectness.Add(isCorrectItem); // Track correctness
+            
+            // Deactivate item and set pickup state
+            itemToSlot.SetActive(false);
+            itemToSlot.transform.SetParent(null);
+            
+            var pickup = itemToSlot.GetComponent<Pickup>();
+            if (pickup != null)
+            {
+                pickup.IsPickedUp = true;
+                pickup.OwningSlot = this;
+            }
+            
+            // Update visuals
+            UpdateSlottedSprite();
+            
+            // Fire events based on correctness
+            if (isCorrectItem)
+            {
+                DebugUIMessage.Show($"You slotted {itemToSlotData.itemName} into: {itemData.itemName}", Color.green);
+                
+                // Fire generic slot event
+                onItemSlotted?.Invoke();
+                OnItemSlotted?.Invoke(itemData, itemToSlotData);
+                
+                // Only fire correct completion event if ALL required CORRECT items are now slotted
+                if (IsComplete)
+                {
+                    currentState = ItemSlotState.Correct;
+                    DebugUIMessage.Show($"Completed: {itemData.itemName}", Color.green);
+                    onCorrectItemSlotted?.Invoke();
+                    OnCorrectItemSlotted?.Invoke(itemData, itemToSlotData);
+                }
+            }
+            else
+            {
+                // Incorrect item slotted
+                DebugUIMessage.Show($"Slotted {itemToSlotData.itemName}, but it might not be right...", Color.yellow);
+                onItemSlotted?.Invoke(); // Still fire generic event
+                OnItemSlotted?.Invoke(itemData, itemToSlotData);
+                onIncorrectItemSlotted?.Invoke();
+                OnIncorrectItemSlotted?.Invoke(itemData, itemToSlotData);
+            }
         }
 
         /// <summary>
         /// Bilateral restoration entry point: Pickup calls this to offer itself to the Slot.
-        /// Returns true if claim was successful, false if slot already has an item or wrong pickup.
+        /// Returns true if claim was successful, false if slot is full or wrong pickup.
         /// </summary>
         public bool TryClaimSlottedItem(Pickup pickup)
         {
             if (pickup == null)
                 return false;
 
-            // If slot already has an item, reject the claim
-            if (currentlySlottedItemObject != null)
+            // If slot is full, reject the claim
+            if (!HasSpace)
             {
-                Logging.Warning($"[ItemSlot] Already has a slotted item, rejecting claim from {pickup.gameObject.name}");
+                Logging.Warning($"[ItemSlot] Slot is full, rejecting claim from {pickup.gameObject.name}");
                 return false;
             }
 
@@ -530,10 +729,21 @@ namespace Interactions
             // Note: We don't have easy access to the expected SaveId here, so we just accept it
             // The Pickup's bilateral restoration ensures it only claims the correct slot
 
-            // Claim the pickup
-            ApplySlottedItemState(pickup.gameObject, pickup.itemData, triggerEvents: false);
+            // Add the item to lists
+            slottedItemObjects.Add(pickup.gameObject);
+            slottedItemsData.Add(pickup.itemData);
             
-            Logging.Debug($"[ItemSlot] Successfully claimed slotted item: {pickup.itemData?.itemName}");
+            // Determine correctness for tracking
+            var config = interactionSettings?.GetSlotItemConfig(itemData);
+            var allowed = config?.allowedItems ?? new List<PickupItemData>();
+            bool isCorrectItem = PickupItemData.ListContainsEquivalent(allowed, pickup.itemData);
+            slottedItemCorrectness.Add(isCorrectItem);
+            
+            pickup.gameObject.SetActive(false);
+            pickup.IsPickedUp = true;
+            pickup.OwningSlot = this;
+            
+            Logging.Debug($"[ItemSlot] Successfully claimed slotted item: {pickup.itemData?.itemName} (correct: {isCorrectItem})");
             return true;
         }
 

Assets/Scripts/Minigames/StatueDressup.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5596931aef9448a3b369f7917af07797
+timeCreated: 1763745490

Assets/Scripts/Minigames/StatueDressup/Controllers.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 34525368248b48e0b271537891123818
+timeCreated: 1763745579

Assets/Scripts/Minigames/StatueDressup/Controllers/DecorationMenuController.cs

@@ -0,0 +1,247 @@
+using System.Collections.Generic;
+using Core;
+using Minigames.StatueDressup.Data;
+using Minigames.StatueDressup.DragDrop;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Minigames.StatueDressup.Controllers
+{
+    /// <summary>
+    /// Manages the side menu with decoration items and pagination
+    /// </summary>
+    public class DecorationMenuController : MonoBehaviour
+    {
+        [Header("References")]
+        [SerializeField] private DecorationItem itemPrefab;
+        [SerializeField] private Transform itemsContainer;
+        [SerializeField] private Button nextPageButton;
+        [SerializeField] private Button previousPageButton;
+        
+        [Header("Configuration")]
+        [SerializeField] private List<DecorationData> allDecorations = new List<DecorationData>();
+        [SerializeField] private int itemsPerPage = 10; // 2 columns x 5 rows
+        
+        [Header("Layout")]
+        [SerializeField] private GridLayoutGroup gridLayout;
+        
+        private int _currentPage = 0;
+        private int _totalPages = 0;
+        private List<DecorationItem> _spawnedItems = new List<DecorationItem>();
+        private Dictionary<DecorationItem, DecorationData> _itemDataMapping = new Dictionary<DecorationItem, DecorationData>();
+        
+        // Properties
+        public int CurrentPage => _currentPage;
+        public int TotalPages => _totalPages;
+        
+        private void Start()
+        {
+            Initialize();
+        }
+        
+        private void Initialize()
+        {
+            Logging.Debug($"[DecorationMenuController] Initializing with {allDecorations.Count} decorations");
+            
+            // Calculate total pages
+            _totalPages = Mathf.CeilToInt((float)allDecorations.Count / itemsPerPage);
+            Logging.Debug($"[DecorationMenuController] Total pages: {_totalPages}");
+            
+            // Setup buttons
+            if (nextPageButton != null)
+            {
+                nextPageButton.onClick.AddListener(OnNextPage);
+            }
+            
+            if (previousPageButton != null)
+            {
+                previousPageButton.onClick.AddListener(OnPreviousPage);
+            }
+            
+            // Subscribe to drag events for all items
+            // (will be handled per-item when spawned)
+            
+            // Populate first page
+            PopulateCurrentPage();
+        }
+        
+        /// <summary>
+        /// Populate the current page with decoration items
+        /// </summary>
+        private void PopulateCurrentPage()
+        {
+            Logging.Debug($"[DecorationMenuController] Populating page {_currentPage + 1}/{_totalPages}");
+            
+            // Clear existing items
+            ClearItems();
+            
+            // Calculate range for current page
+            int startIndex = _currentPage * itemsPerPage;
+            int endIndex = Mathf.Min(startIndex + itemsPerPage, allDecorations.Count);
+            
+            Logging.Debug($"[DecorationMenuController] Spawning items {startIndex} to {endIndex - 1}");
+            
+            // Spawn items for this page
+            for (int i = startIndex; i < endIndex; i++)
+            {
+                SpawnDecorationItem(allDecorations[i]);
+            }
+            
+            // Update button states
+            UpdateNavigationButtons();
+        }
+        
+        /// <summary>
+        /// Spawn a decoration item in the menu
+        /// </summary>
+        private void SpawnDecorationItem(DecorationData data)
+        {
+            if (itemPrefab == null || itemsContainer == null)
+            {
+                Logging.Warning("[DecorationMenuController] Missing prefab or container");
+                return;
+            }
+            
+            DecorationItem item = Instantiate(itemPrefab, itemsContainer);
+            item.SetDecorationData(data);
+            
+            // Store original position for return animation
+            if (item.RectTransform != null)
+            {
+                // Force layout update to get correct position
+                Canvas.ForceUpdateCanvases();
+                item.SetOriginalMenuPosition(item.RectTransform.anchoredPosition);
+            }
+            
+            // Subscribe to drag events
+            item.OnDragStarted += HandleItemPickedUp;
+            item.OnDragEnded += HandleItemDropped;
+            
+            _spawnedItems.Add(item);
+            _itemDataMapping[item] = data;
+            
+            Logging.Debug($"[DecorationMenuController] Spawned: {data.DecorationName} at position {item.RectTransform?.anchoredPosition}");
+        }
+        
+        /// <summary>
+        /// Handle item picked up from menu
+        /// </summary>
+        private void HandleItemPickedUp(DraggableObject draggable)
+        {
+            if (draggable is DecorationItem item && _itemDataMapping.ContainsKey(item))
+            {
+                Logging.Debug($"[DecorationMenuController] Item picked up: {item.Data?.DecorationName}");
+                
+                // Spawn replacement in menu slot
+                // This ensures menu always shows available items
+                DecorationData data = _itemDataMapping[item];
+                // We'll spawn replacement only if item is actually placed, not on pickup
+            }
+        }
+        
+        /// <summary>
+        /// Handle item dropped (either placed on statue or returned to menu)
+        /// </summary>
+        private void HandleItemDropped(DraggableObject draggable)
+        {
+            if (draggable is DecorationItem item && _itemDataMapping.ContainsKey(item))
+            {
+                Logging.Debug($"[DecorationMenuController] Item dropped: {item.Data?.DecorationName}, slot={item.CurrentSlot?.name}");
+                
+                // If item was placed on statue, spawn replacement in menu
+                if (item.CurrentSlot != null && !item.IsInMenu)
+                {
+                    DecorationData data = _itemDataMapping[item];
+                    
+                    // Remove original from tracking
+                    _spawnedItems.Remove(item);
+                    _itemDataMapping.Remove(item);
+                    
+                    // Spawn replacement
+                    SpawnDecorationItem(data);
+                    
+                    Logging.Debug($"[DecorationMenuController] Spawned replacement for: {data.DecorationName}");
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Clear all spawned items
+        /// </summary>
+        private void ClearItems()
+        {
+            foreach (var item in _spawnedItems)
+            {
+                if (item != null)
+                {
+                    item.OnDragStarted -= HandleItemPickedUp;
+                    item.OnDragEnded -= HandleItemDropped;
+                    Destroy(item.gameObject);
+                }
+            }
+            
+            _spawnedItems.Clear();
+            _itemDataMapping.Clear();
+        }
+        
+        /// <summary>
+        /// Navigate to next page
+        /// </summary>
+        private void OnNextPage()
+        {
+            if (_currentPage < _totalPages - 1)
+            {
+                _currentPage++;
+                PopulateCurrentPage();
+                Logging.Debug($"[DecorationMenuController] Next page: {_currentPage + 1}/{_totalPages}");
+            }
+        }
+        
+        /// <summary>
+        /// Navigate to previous page
+        /// </summary>
+        private void OnPreviousPage()
+        {
+            if (_currentPage > 0)
+            {
+                _currentPage--;
+                PopulateCurrentPage();
+                Logging.Debug($"[DecorationMenuController] Previous page: {_currentPage + 1}/{_totalPages}");
+            }
+        }
+        
+        /// <summary>
+        /// Update navigation button interactability
+        /// </summary>
+        private void UpdateNavigationButtons()
+        {
+            if (previousPageButton != null)
+            {
+                previousPageButton.interactable = _currentPage > 0;
+            }
+            
+            if (nextPageButton != null)
+            {
+                nextPageButton.interactable = _currentPage < _totalPages - 1;
+            }
+        }
+        
+        private void OnDestroy()
+        {
+            // Cleanup button listeners
+            if (nextPageButton != null)
+            {
+                nextPageButton.onClick.RemoveListener(OnNextPage);
+            }
+            
+            if (previousPageButton != null)
+            {
+                previousPageButton.onClick.RemoveListener(OnPreviousPage);
+            }
+            
+            // Cleanup item listeners
+            ClearItems();
+        }
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/Controllers/DecorationMenuController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: acbd542762b44e719326dff6c3a69e6e
+timeCreated: 1763745579

Assets/Scripts/Minigames/StatueDressup/Controllers/StatueDecorationController.cs

@@ -0,0 +1,267 @@
+using System.Collections.Generic;
+using Core;
+using Minigames.StatueDressup.DragDrop;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Minigames.StatueDressup.Controllers
+{
+    /// <summary>
+    /// Main controller for the Mr. Cement statue decoration minigame
+    /// </summary>
+    public class StatueDecorationController : MonoBehaviour
+    {
+        [Header("References")]
+        [SerializeField] private StatueDecorationSlot[] statueSlots;
+        [SerializeField] private DecorationMenuController menuController;
+        [SerializeField] private Button takePhotoButton;
+        [SerializeField] private GameObject statue;
+        
+        [Header("UI Elements to Hide for Photo")]
+        [SerializeField] private GameObject[] uiElementsToHideForPhoto;
+        
+        [Header("Photo Settings")]
+        [SerializeField] private RectTransform photoArea; // Area to capture
+        [SerializeField] private string photoSaveKey = "MrCementStatuePhoto";
+        
+        private Dictionary<StatueDecorationSlot, DecorationItem> _placedDecorations = new Dictionary<StatueDecorationSlot, DecorationItem>();
+        private bool _minigameCompleted = false;
+        
+        private void Start()
+        {
+            Initialize();
+        }
+        
+        private void Initialize()
+        {
+            Logging.Debug("[StatueDecorationController] Initializing minigame");
+            
+            // Setup photo button
+            if (takePhotoButton != null)
+            {
+                takePhotoButton.onClick.AddListener(OnTakePhoto);
+            }
+            
+            // Subscribe to slot occupation events
+            foreach (var slot in statueSlots)
+            {
+                if (slot != null)
+                {
+                    slot.OnOccupied += HandleDecorationPlaced;
+                }
+            }
+            
+            // Load saved state if exists
+            LoadStatueState();
+        }
+        
+        /// <summary>
+        /// Handle decoration placed in slot
+        /// </summary>
+        private void HandleDecorationPlaced(DraggableObject draggable)
+        {
+            if (draggable is DecorationItem decoration)
+            {
+                var slot = decoration.CurrentSlot as StatueDecorationSlot;
+                if (slot != null)
+                {
+                    _placedDecorations[slot] = decoration;
+                    Logging.Debug($"[StatueDecorationController] Decoration placed: {decoration.Data?.DecorationName} in slot {slot.name}");
+                    
+                    // Auto-save state
+                    SaveStatueState();
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Take photo of decorated statue
+        /// </summary>
+        private void OnTakePhoto()
+        {
+            if (_minigameCompleted)
+            {
+                Logging.Debug("[StatueDecorationController] Minigame already completed");
+                return;
+            }
+            
+            Logging.Debug("[StatueDecorationController] Taking photo of statue");
+            
+            // Hide UI elements
+            HideUIForPhoto(true);
+            
+            // Wait a frame for UI to hide, then capture
+            StartCoroutine(CapturePhotoCoroutine());
+        }
+        
+        /// <summary>
+        /// Capture photo after UI is hidden
+        /// </summary>
+        private System.Collections.IEnumerator CapturePhotoCoroutine()
+        {
+            yield return new WaitForEndOfFrame();
+            
+            // Capture the photo area
+            Texture2D photo = CaptureScreenshotArea();
+            
+            if (photo != null)
+            {
+                // Save photo to album
+                SavePhotoToAlbum(photo);
+                
+                // Award cards
+                AwardCards();
+                
+                // Update town icon
+                UpdateTownIcon(photo);
+                
+                // Show completion feedback
+                ShowCompletionFeedback();
+                
+                _minigameCompleted = true;
+            }
+            
+            // Restore UI
+            HideUIForPhoto(false);
+        }
+        
+        /// <summary>
+        /// Capture screenshot of specific area
+        /// </summary>
+        private Texture2D CaptureScreenshotArea()
+        {
+            if (photoArea == null)
+            {
+                Logging.Warning("[StatueDecorationController] No photo area specified, capturing full screen");
+                
+                // Capture full screen
+                Texture2D screenshot = new Texture2D(Screen.width, Screen.height, TextureFormat.RGB24, false);
+                screenshot.ReadPixels(new Rect(0, 0, Screen.width, Screen.height), 0, 0);
+                screenshot.Apply();
+                return screenshot;
+            }
+            
+            // Get world corners of the rect
+            Vector3[] corners = new Vector3[4];
+            photoArea.GetWorldCorners(corners);
+            
+            // Convert to screen space
+            Vector2 min = RectTransformUtility.WorldToScreenPoint(Camera.main, corners[0]);
+            Vector2 max = RectTransformUtility.WorldToScreenPoint(Camera.main, corners[2]);
+            
+            int width = (int)(max.x - min.x);
+            int height = (int)(max.y - min.y);
+            
+            Logging.Debug($"[StatueDecorationController] Capturing area: {width}x{height} at ({min.x}, {min.y})");
+            
+            // Capture the specified area
+            Texture2D screenshot = new Texture2D(width, height, TextureFormat.RGB24, false);
+            screenshot.ReadPixels(new Rect(min.x, min.y, width, height), 0, 0);
+            screenshot.Apply();
+            
+            return screenshot;
+        }
+        
+        /// <summary>
+        /// Save photo to card album
+        /// </summary>
+        private void SavePhotoToAlbum(Texture2D photo)
+        {
+            // TODO: Integrate with existing album save system
+            // For now, save to PlayerPrefs as base64
+            byte[] bytes = photo.EncodeToPNG();
+            string base64 = System.Convert.ToBase64String(bytes);
+            PlayerPrefs.SetString(photoSaveKey, base64);
+            PlayerPrefs.Save();
+            
+            Logging.Debug("[StatueDecorationController] Photo saved to album");
+        }
+        
+        /// <summary>
+        /// Award Blokkemon cards to player
+        /// </summary>
+        private void AwardCards()
+        {
+            // TODO: Integrate with MinigameBoosterGiver
+            // MinigameBoosterGiver.GiveBooster();
+            
+            Logging.Debug("[StatueDecorationController] Cards awarded (TODO: implement)");
+        }
+        
+        /// <summary>
+        /// Update town menu icon with decorated statue
+        /// </summary>
+        private void UpdateTownIcon(Texture2D photo)
+        {
+            // TODO: Integrate with town system
+            // TownIconUpdater.SetStatueIcon(photo);
+            
+            Logging.Debug("[StatueDecorationController] Town icon updated (TODO: implement)");
+        }
+        
+        /// <summary>
+        /// Show completion feedback to player
+        /// </summary>
+        private void ShowCompletionFeedback()
+        {
+            // TODO: Show success message/animation
+            DebugUIMessage.Show("Photo captured! Mr. Cement looks amazing!", Color.green);
+            Logging.Debug("[StatueDecorationController] Minigame completed!");
+        }
+        
+        /// <summary>
+        /// Hide/show UI elements for photo
+        /// </summary>
+        private void HideUIForPhoto(bool hide)
+        {
+            foreach (var element in uiElementsToHideForPhoto)
+            {
+                if (element != null)
+                {
+                    element.SetActive(!hide);
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Save current statue decoration state
+        /// </summary>
+        private void SaveStatueState()
+        {
+            // TODO: Implement save system
+            // Save slot ID -> decoration ID mapping
+            
+            Logging.Debug("[StatueDecorationController] State saved (TODO: implement persistence)");
+        }
+        
+        /// <summary>
+        /// Load saved statue decoration state
+        /// </summary>
+        private void LoadStatueState()
+        {
+            // TODO: Implement load system
+            // Restore decorations to slots
+            
+            Logging.Debug("[StatueDecorationController] State loaded (TODO: implement persistence)");
+        }
+        
+        private void OnDestroy()
+        {
+            // Cleanup button listener
+            if (takePhotoButton != null)
+            {
+                takePhotoButton.onClick.RemoveListener(OnTakePhoto);
+            }
+            
+            // Cleanup slot listeners
+            foreach (var slot in statueSlots)
+            {
+                if (slot != null)
+                {
+                    slot.OnOccupied -= HandleDecorationPlaced;
+                }
+            }
+        }
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/Controllers/StatueDecorationController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 19e312ceaffa40ae90ac87b8209319cb
+timeCreated: 1763745610

Assets/Scripts/Minigames/StatueDressup/Data.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a6e7dfb0a39c441fb8ac888a5e58a91e
+timeCreated: 1763745500

Assets/Scripts/Minigames/StatueDressup/Data/DecorationData.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+
+namespace Minigames.StatueDressup.Data
+{
+    /// <summary>
+    /// ScriptableObject data definition for statue decorations
+    /// </summary>
+    [CreateAssetMenu(fileName = "DecorationData", menuName = "AppleHills/Minigames/Decoration Data", order = 1)]
+    public class DecorationData : ScriptableObject
+    {
+        [Header("Identity")]
+        [SerializeField] private string decorationId;
+        [SerializeField] private string decorationName;
+        
+        [Header("Visual")]
+        [SerializeField] private Sprite decorationSprite;
+        
+        [Header("Size Configuration")]
+        [Tooltip("Full size when placed on statue (actual sprite size)")]
+        [SerializeField] private Vector2 authoredSize = new Vector2(128f, 128f);
+        
+        [Tooltip("Small size in menu icon")]
+        [SerializeField] private Vector2 iconSize = new Vector2(64f, 64f);
+        
+        [Header("Progression (Optional)")]
+        [SerializeField] private bool isUnlocked = true;
+        
+        // Properties
+        public string DecorationId => decorationId;
+        public string DecorationName => decorationName;
+        public Sprite DecorationSprite => decorationSprite;
+        public DecorationCategory Category => category;
+        public Vector2 AuthoredSize => authoredSize;
+        public Vector2 IconSize => iconSize;
+        public bool IsUnlocked => isUnlocked;
+        
+        private void OnValidate()
+        {
+            // Auto-generate ID from name if empty
+            if (string.IsNullOrEmpty(decorationId) && !string.IsNullOrEmpty(decorationName))
+            {
+                decorationId = decorationName.Replace(" ", "_").ToLower();
+            }
+        }
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/Data/DecorationData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 74c6ae9aa803480c8fb918dd58cfb809
+timeCreated: 1763745511

Assets/Scripts/Minigames/StatueDressup/DragDrop.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4c3389a935534b7b86800516ffa42acb
+timeCreated: 1763745531

Assets/Scripts/Minigames/StatueDressup/DragDrop/DecorationItem.cs

@@ -0,0 +1,146 @@
+using Core;
+using Minigames.StatueDressup.Data;
+using Minigames.StatueDressup.Utils;
+using UI.DragAndDrop.Core;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Minigames.StatueDressup.DragDrop
+{
+    /// <summary>
+    /// Individual decoration item that can be dragged from menu to statue slots
+    /// </summary>
+    public class DecorationItem : DraggableObject
+    {
+        [Header("Decoration Data")]
+        [SerializeField] private DecorationData decorationData;
+        [SerializeField] private Image decorationImage;
+        
+        private Vector2 _iconSize;
+        private Vector2 _authoredSize;
+        private Vector2 _originalMenuPosition;
+        private bool _isInMenu = true;
+        
+        // Properties
+        public DecorationData Data => decorationData;
+        public DecorationCategory Category => decorationData?.Category ?? DecorationCategory.Hats;
+        public bool IsInMenu => _isInMenu;
+        
+        protected override void Initialize()
+        {
+            base.Initialize();
+            
+            if (decorationData != null)
+            {
+                _iconSize = decorationData.IconSize;
+                _authoredSize = decorationData.AuthoredSize;
+                
+                // Set initial icon size
+                if (RectTransform != null)
+                {
+                    RectTransform.sizeDelta = _iconSize;
+                }
+                
+                // Set sprite
+                if (decorationImage != null && decorationData.DecorationSprite != null)
+                {
+                    decorationImage.sprite = decorationData.DecorationSprite;
+                }
+            }
+            
+            // Store original menu position
+            if (RectTransform != null)
+            {
+                _originalMenuPosition = RectTransform.anchoredPosition;
+            }
+        }
+        
+        /// <summary>
+        /// Set decoration data (for spawned instances)
+        /// </summary>
+        public void SetDecorationData(DecorationData data)
+        {
+            decorationData = data;
+            
+            if (data != null)
+            {
+                _iconSize = data.IconSize;
+                _authoredSize = data.AuthoredSize;
+                
+                // Update visual
+                if (decorationImage != null && data.DecorationSprite != null)
+                {
+                    decorationImage.sprite = data.DecorationSprite;
+                }
+                
+                // Set icon size
+                if (RectTransform != null)
+                {
+                    RectTransform.sizeDelta = _iconSize;
+                }
+                
+                Logging.Debug($"[DecorationItem] Set data: {data.DecorationName}, iconSize={_iconSize}, authoredSize={_authoredSize}");
+            }
+        }
+        
+        protected override void OnDragStartedHook()
+        {
+            Logging.Debug($"[DecorationItem] OnDragStarted: {decorationData?.DecorationName}");
+            
+            // Scale to authored size when dragging starts
+            if (RectTransform != null)
+            {
+                TweenAnimationUtility.AnimateScale(transform, Vector3.one, 0.2f);
+                
+                // Animate size delta to authored size
+                RectTransform.sizeDelta = _authoredSize;
+            }
+        }
+        
+        protected override void OnDragEndedHook()
+        {
+            Logging.Debug($"[DecorationItem] OnDragEnded: {decorationData?.DecorationName}, currentSlot={CurrentSlot?.name}");
+            
+            // If not placed in a slot, return to menu
+            if (CurrentSlot == null)
+            {
+                ReturnToMenu();
+            }
+            else
+            {
+                _isInMenu = false;
+            }
+        }
+        
+        /// <summary>
+        /// Return item to menu with animation
+        /// </summary>
+        private void ReturnToMenu()
+        {
+            Logging.Debug($"[DecorationItem] Returning to menu: {decorationData?.DecorationName}");
+            
+            _isInMenu = true;
+            
+            if (RectTransform != null)
+            {
+                // Animate back to icon size
+                RectTransform.sizeDelta = _iconSize;
+                TweenAnimationUtility.AnimateScale(transform, Vector3.one, 0.2f);
+                
+                // Animate back to original position
+                TweenAnimationUtility.AnimateAnchoredPosition(RectTransform, _originalMenuPosition, 0.3f);
+            }
+        }
+        
+
+        
+        /// <summary>
+        /// Set original menu position (called by menu controller)
+        /// </summary>
+        public void SetOriginalMenuPosition(Vector2 position)
+        {
+            _originalMenuPosition = position;
+        }
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/DragDrop/DecorationItem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 31a82dde0ffb439e86b79499b9daa92b
+timeCreated: 1763745531

Assets/Scripts/Minigames/StatueDressup/DragDrop/StatueDecorationSlot.cs

@@ -0,0 +1,125 @@
+using Core;
+using Minigames.StatueDressup.Data;
+using Minigames.StatueDressup.Utils;
+using UI.DragAndDrop.Core;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace Minigames.StatueDressup.DragDrop
+{
+    /// <summary>
+    /// Slot on the statue where decorations can be placed
+    /// </summary>
+    public class StatueDecorationSlot : DraggableSlot, IPointerEnterHandler, IPointerExitHandler
+    {
+        [Header("Slot Configuration")]
+        [SerializeField] private DecorationCategory allowedCategory;
+        [SerializeField] private bool isPermanent = true; // Can't remove once placed
+        
+        [Header("Glow Effect")]
+        [SerializeField] private GameObject glowEffect;
+        [SerializeField] private float glowPulseAmount = 1.1f;
+        [SerializeField] private float glowPulseDuration = 0.8f;
+        
+        private bool _isGlowing;
+        private Pixelplacement.TweenSystem.TweenBase _glowTween;
+        
+        // Properties
+        public DecorationCategory AllowedCategory => allowedCategory;
+        public bool IsPermanent => isPermanent;
+        
+        private void Start()
+        {
+            // Hide glow effect initially
+            if (glowEffect != null)
+            {
+                glowEffect.SetActive(false);
+            }
+        }
+        
+        public new void OnPointerEnter(PointerEventData eventData)
+        {
+            // Only glow when dragging a matching decoration
+            if (eventData.pointerDrag != null)
+            {
+                var decoration = eventData.pointerDrag.GetComponent<DecorationItem>();
+                if (decoration != null && decoration.Category == allowedCategory && !IsOccupied)
+                {
+                    StartGlow();
+                }
+            }
+        }
+        
+        public new void OnPointerExit(PointerEventData eventData)
+        {
+            StopGlow();
+        }
+        
+        /// <summary>
+        /// Start glow effect
+        /// </summary>
+        private void StartGlow()
+        {
+            if (_isGlowing || glowEffect == null)
+                return;
+            
+            _isGlowing = true;
+            glowEffect.SetActive(true);
+            
+            Logging.Debug($"[StatueDecorationSlot] Starting glow on {name}");
+            
+            // Pulse animation
+            _glowTween = TweenAnimationUtility.StartGlowPulse(glowEffect.transform, glowPulseAmount, glowPulseDuration);
+        }
+        
+        /// <summary>
+        /// Stop glow effect
+        /// </summary>
+        private void StopGlow()
+        {
+            if (!_isGlowing || glowEffect == null)
+                return;
+            
+            _isGlowing = false;
+            
+            Logging.Debug($"[StatueDecorationSlot] Stopping glow on {name}");
+            
+            // Stop pulse animation
+            if (_glowTween != null)
+            {
+                TweenAnimationUtility.StopTweens(glowEffect.transform);
+                _glowTween = null;
+            }
+            
+            glowEffect.SetActive(false);
+        }
+        
+        /// <summary>
+        /// Override to check category matching (uses base CanAccept)
+        /// </summary>
+        public new bool CanAccept(DraggableObject draggable)
+        {
+            // First check base conditions
+            if (!base.CanAccept(draggable))
+                return false;
+            
+            // Then check category matching
+            if (draggable is DecorationItem decoration)
+            {
+                bool matches = decoration.Category == allowedCategory;
+                Logging.Debug($"[StatueDecorationSlot] CanAccept: {decoration.Data?.DecorationName}, " +
+                             $"category={decoration.Category}, allowed={allowedCategory}, matches={matches}");
+                return matches;
+            }
+            
+            return false;
+        }
+        
+        private void OnDisable()
+        {
+            // Clean up glow on disable
+            StopGlow();
+        }
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/DragDrop/StatueDecorationSlot.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f68e3749518141b6bc818938dd8dc57d
+timeCreated: 1763745550

Assets/Scripts/Minigames/StatueDressup/Utils.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fe03648f638e4872abafaf49234a3f55
+timeCreated: 1763745490

Assets/Scripts/Minigames/StatueDressup/Utils/TweenAnimationUtility.cs

@@ -0,0 +1,151 @@
+using Pixelplacement;
+using Pixelplacement.TweenSystem;
+using UnityEngine;
+using System;
+
+namespace Minigames.StatueDressup.Utils
+{
+    /// <summary>
+    /// Common animation utilities extracted from CardAnimator pattern.
+    /// Provides reusable tween animations for UI elements.
+    /// </summary>
+    public static class TweenAnimationUtility
+    {
+        #region Scale Animations
+        
+        /// <summary>
+        /// Animate scale to target value with ease in-out
+        /// </summary>
+        public static TweenBase AnimateScale(Transform transform, Vector3 targetScale, float duration, Action onComplete = null)
+        {
+            return Tween.LocalScale(transform, targetScale, duration, 0f, Tween.EaseInOut, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Pulse scale animation (scale up then back to original)
+        /// </summary>
+        public static void PulseScale(Transform transform, float pulseAmount = 1.1f, float duration = 0.2f, Action onComplete = null)
+        {
+            Vector3 originalScale = transform.localScale;
+            Vector3 pulseScale = originalScale * pulseAmount;
+            
+            Tween.LocalScale(transform, pulseScale, duration, 0f, Tween.EaseOutBack,
+                completeCallback: () =>
+                {
+                    Tween.LocalScale(transform, originalScale, duration, 0f, Tween.EaseInBack, completeCallback: onComplete);
+                });
+        }
+        
+        /// <summary>
+        /// Pop-in animation (scale from 0 to target with overshoot)
+        /// </summary>
+        public static TweenBase PopIn(Transform transform, Vector3 targetScale, float duration = 0.5f, Action onComplete = null)
+        {
+            transform.localScale = Vector3.zero;
+            return Tween.LocalScale(transform, targetScale, duration, 0f, Tween.EaseOutBack, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Pop-out animation (scale from current to 0)
+        /// </summary>
+        public static TweenBase PopOut(Transform transform, float duration = 0.3f, Action onComplete = null)
+        {
+            return Tween.LocalScale(transform, Vector3.zero, duration, 0f, Tween.EaseInBack, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Smooth scale transition with bounce
+        /// </summary>
+        public static TweenBase ScaleWithBounce(Transform transform, Vector3 targetScale, float duration, Action onComplete = null)
+        {
+            return Tween.LocalScale(transform, targetScale, duration, 0f, Tween.EaseOutBack, completeCallback: onComplete);
+        }
+        
+        #endregion
+        
+        #region Position Animations
+        
+        /// <summary>
+        /// Animate anchored position (for RectTransform UI elements)
+        /// </summary>
+        public static TweenBase AnimateAnchoredPosition(RectTransform rectTransform, Vector2 targetPosition, float duration, Action onComplete = null)
+        {
+            return Tween.AnchoredPosition(rectTransform, targetPosition, duration, 0f, Tween.EaseInOut, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Animate local position (for regular transforms)
+        /// </summary>
+        public static TweenBase AnimateLocalPosition(Transform transform, Vector3 targetPosition, float duration, Action onComplete = null)
+        {
+            return Tween.LocalPosition(transform, targetPosition, duration, 0f, Tween.EaseInOut, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Move with bounce effect
+        /// </summary>
+        public static TweenBase MoveWithBounce(RectTransform rectTransform, Vector2 targetPosition, float duration, Action onComplete = null)
+        {
+            return Tween.AnchoredPosition(rectTransform, targetPosition, duration, 0f, Tween.EaseOutBack, completeCallback: onComplete);
+        }
+        
+        #endregion
+        
+        #region Combined Hover Animations
+        
+        /// <summary>
+        /// Hover enter animation (lift and scale) for RectTransform
+        /// </summary>
+        public static void HoverEnter(RectTransform rectTransform, Vector2 originalPosition, float liftAmount = 20f, 
+            float scaleMultiplier = 1.05f, float duration = 0.2f, Action onComplete = null)
+        {
+            Vector2 targetPos = originalPosition + Vector2.up * liftAmount;
+            
+            Tween.AnchoredPosition(rectTransform, targetPos, duration, 0f, Tween.EaseOutBack);
+            Tween.LocalScale(rectTransform, Vector3.one * scaleMultiplier, duration, 0f, Tween.EaseOutBack, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Hover exit animation (return to original position and scale) for RectTransform
+        /// </summary>
+        public static void HoverExit(RectTransform rectTransform, Vector2 originalPosition, float duration = 0.2f, Action onComplete = null)
+        {
+            Tween.AnchoredPosition(rectTransform, originalPosition, duration, 0f, Tween.EaseInBack);
+            Tween.LocalScale(rectTransform, Vector3.one, duration, 0f, Tween.EaseInBack, completeCallback: onComplete);
+        }
+        
+        /// <summary>
+        /// Glow pulse effect (scale up/down repeatedly)
+        /// </summary>
+        public static TweenBase StartGlowPulse(Transform transform, float pulseAmount = 1.1f, float duration = 0.8f)
+        {
+            Vector3 originalScale = transform.localScale;
+            Vector3 pulseScale = originalScale * pulseAmount;
+            
+            return Tween.LocalScale(transform, pulseScale, duration, 0f, Tween.EaseInOutSine, Tween.LoopType.PingPong);
+        }
+        
+        /// <summary>
+        /// Stop any active tweens on transform
+        /// </summary>
+        public static void StopTweens(Transform transform)
+        {
+            Tween.Cancel(transform.GetInstanceID());
+        }
+        
+        #endregion
+        
+        #region Fade Animations
+        
+        /// <summary>
+        /// Fade CanvasGroup alpha
+        /// </summary>
+        public static TweenBase FadeCanvasGroup(CanvasGroup canvasGroup, float targetAlpha, float duration, Action onComplete = null)
+        {
+            return Tween.CanvasGroupAlpha(canvasGroup, targetAlpha, duration, 0f, Tween.EaseInOut, completeCallback: onComplete);
+        }
+        
+        #endregion
+    }
+}
+

Assets/Scripts/Minigames/StatueDressup/Utils/TweenAnimationUtility.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: abd48147eff149508890fe2fa87b8421
+timeCreated: 1763745490