ItemSystem.cs

using UnityEngine;
using Mirror;

public class ItemSystem : NetworkBehaviour
{
    public Transform ItemPos; // Assign in Inspector (Empty GameObject for holding items)
    
    // Track the held items (up to 3)
    private NetworkItem[] heldItems = new NetworkItem[3];
    
    [SyncVar(hook = nameof(OnHeldItem1IdChanged))]
    private uint heldItem1NetworkId = 0;
    [SyncVar(hook = nameof(OnHeldItem2IdChanged))]
    private uint heldItem2NetworkId = 0;
    [SyncVar(hook = nameof(OnHeldItem3IdChanged))]
    private uint heldItem3NetworkId = 0;
    
    [SyncVar(hook = nameof(OnActiveItemChanged))]
    private int activeItemIndex = -1; // -1 means no item is active
    
    // Debug visualization
    public bool debugMode = true;
    
    [Header("UI Integration")]
    public InventoryUI inventoryUI; // Assign in inspector if you want direct integration
    

    private void OnHeldItem1IdChanged(uint oldValue, uint newValue)
    {
        UpdateHeldItemReference(0, newValue);
    }

    private void OnHeldItem2IdChanged(uint oldValue, uint newValue)
    {
        UpdateHeldItemReference(1, newValue);
    }

    private void OnHeldItem3IdChanged(uint oldValue, uint newValue)
    {
        UpdateHeldItemReference(2, newValue);
    }

    private void UpdateHeldItemReference(int slot, uint newValue)
    {
        if (debugMode)
        {
            Debug.Log($"[Client] Player {netId} held item slot {slot} ID changed to: {newValue}");
        }
    
        // Update heldItem reference based on the new network ID
        if (newValue != 0 && NetworkClient.spawned.ContainsKey(newValue))
        {
            NetworkIdentity itemIdentity = NetworkClient.spawned[newValue];
            if (itemIdentity != null)
            {
                heldItems[slot] = itemIdentity.GetComponent<NetworkItem>();
            }
        }
        else
        {
            heldItems[slot] = null;
        }
    
        // Update visibility based on active item
        UpdateItemVisibility();
    
        // Notify UI of change
        NotifyInventoryChanged();
    }

    private void OnActiveItemChanged(int oldValue, int newValue)
    {
        if (debugMode)
        {
            Debug.Log($"[Client] Player {netId} active item changed: {oldValue} -> {newValue}");
        }
    
        UpdateItemVisibility();
    
        // Notify UI of change
        NotifyInventoryChanged();
    }

    private void UpdateItemVisibility()
    {
        for (int i = 0; i < heldItems.Length; i++)
        {
            if (heldItems[i] != null)
            {
                bool shouldBeVisible = (i == activeItemIndex);
                heldItems[i].SetVisibility(shouldBeVisible);
            }
        }
    }

    private void Update()
    {
        if (!isOwned) return;

        // Handle item pickup/drop
        if (Input.GetKeyDown(KeyCode.E))
        {
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} E pressed - attempting pickup");
            }
            
            TryPickupItem();
        }
        else if (Input.GetKeyDown(KeyCode.G))
        {
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} G pressed - attempting drop");
            }
            
            if (HasActiveItem()) // Only drop if there's actually an item in the active slot
            {
                TryDropItem();
            }
            else if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} cannot drop - no item in active slot {activeItemIndex}");
            }
        }

        // Handle item switching
        if (Input.GetKeyDown(KeyCode.Alpha1))
        {
            SwitchToItem(0);
        }
        else if (Input.GetKeyDown(KeyCode.Alpha2))
        {
            SwitchToItem(1);
        }
        else if (Input.GetKeyDown(KeyCode.Alpha3))
        {
            SwitchToItem(2);
        }
    }

    private void SwitchToItem(int itemIndex)
    {
        if (activeItemIndex == itemIndex)
        {
            // If pressing the same number as active item, deactivate it (empty hand)
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} deactivating item slot {itemIndex} (empty hand)");
            }
            
            CmdSetActiveItem(-1);
        }
        else
        {
            // Switch to this slot regardless of whether it has an item or not
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} switching to slot {itemIndex} (item: {(heldItems[itemIndex] != null ? "yes" : "no")})");
            }
            
            CmdSetActiveItem(itemIndex);
        }
    }

    [Command]
    private void CmdSetActiveItem(int itemIndex)
    {
        if (itemIndex >= -1 && itemIndex < 3)
        {
            // Allow switching to any slot (even empty ones) or deactivating
            activeItemIndex = itemIndex;
            
            if (debugMode)
            {
                string itemStatus = itemIndex == -1 ? "none (empty hand)" : 
                    (GetHeldItemNetworkId(itemIndex) != 0 ? "with item" : "empty slot");
                Debug.Log($"[Server] Player {netId} active item set to slot {itemIndex} ({itemStatus})");
            }
            
            // Update visibility for all held items
            UpdateAllItemsVisibility();
        }
    }
    
    private void UpdateAllItemsVisibility()
    {
        if (!isServer) return;
        
        for (int i = 0; i < 3; i++)
        {
            uint itemNetId = GetHeldItemNetworkId(i);
            if (itemNetId != 0 && NetworkClient.spawned.ContainsKey(itemNetId))
            {
                NetworkItem item = NetworkClient.spawned[itemNetId].GetComponent<NetworkItem>();
                if (item != null)
                {
                    bool shouldBeVisible = (i == activeItemIndex);
                    item.SetServerVisibility(shouldBeVisible);
                }
            }
        }
    }

    private void TryPickupItem()
    {
        // Find first empty slot
        int emptySlot = -1;
        for (int i = 0; i < heldItems.Length; i++)
        {
            if (heldItems[i] == null)
            {
                emptySlot = i;
                break;
            }
        }

        if (emptySlot == -1)
        {
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} inventory is full");
            }
            return; // No empty slots
        }

        Collider[] colliders = Physics.OverlapSphere(transform.position, 2f);
        foreach (var col in colliders)
        {
            NetworkItem item = col.GetComponent<NetworkItem>();
            if (item != null && item.IsAvailable())
            {
                if (debugMode)
                {
                    Debug.Log($"[Client] Player {netId} requesting pickup of item {item.netId} to slot {emptySlot}");
                }
                
                // Request pickup from the server
                heldItems[emptySlot] = item;
                item.CmdRequestPickup(netIdentity, ItemPos.position, ItemPos.rotation, emptySlot);
                break;
            }
        }
    }

    private void TryDropItem()
    {
        if (HasActiveItem())
        {
            NetworkItem itemToDrop = heldItems[activeItemIndex];
            
            if (debugMode)
            {
                Debug.Log($"[Client] Player {netId} trying to drop item {itemToDrop.netId} from slot {activeItemIndex}");
            }
            
            // Always use the Command approach for clients to ensure the server gets the message
            CmdRequestDropItem(itemToDrop.netId, activeItemIndex);
            
            // Clear reference locally immediately for responsive UI
            heldItems[activeItemIndex] = null;
        }
    }

    [Command]
    private void CmdRequestDropItem(uint itemNetworkId, int slot)
    {
        // Find the actual NetworkIdentity by ID
        if (NetworkClient.spawned.ContainsKey(itemNetworkId))
        {
            NetworkIdentity networkIdentity = NetworkClient.spawned[itemNetworkId];
            NetworkItem item = networkIdentity.GetComponent<NetworkItem>();
            if (item != null)
            {
                if (debugMode)
                {
                    Debug.Log($"[Server] Player {netId} requesting drop of item {itemNetworkId} from slot {slot}");
                }
                
                // The server handles the actual drop
                item.ServerDropItem(netIdentity);
                
                // Clear holding state for this slot
                SetHeldItemNetworkId(slot, 0);
                
                // Keep the same active slot (now empty) instead of deactivating
                // This allows the player to stay on the same slot but with empty hands
                if (debugMode)
                {
                    Debug.Log($"[Server] Slot {slot} is now empty but remains active");
                }
            }
        }
    }

    public void AssignHeldItem(NetworkItem item, int slot)
    {
        if (slot < 0 || slot >= heldItems.Length) return;
        
        heldItems[slot] = item;
        
        if (isServer)
        {
            SetHeldItemNetworkId(slot, item != null ? item.netId : 0);
            
            // If no item is currently active, make this the active item
            if (activeItemIndex == -1 && item != null)
            {
                activeItemIndex = slot;
            }
            
            // Update visibility immediately
            UpdateAllItemsVisibility();
        }
        else
        {
            CmdUpdateHoldingState(slot, item != null ? item.netId : 0);
        }
        
        if (debugMode)
        {
            Debug.Log($"[{(isServer ? "Server" : "Client")}] Player {netId} assigned held item {(item != null ? item.netId.ToString() : "null")} to slot {slot}");
        }
    }

    [Command]
    private void CmdUpdateHoldingState(int slot, uint itemNetworkId)
    {
        SetHeldItemNetworkId(slot, itemNetworkId);
        
        // If no item is currently active and we just added an item, make it active
        if (activeItemIndex == -1 && itemNetworkId != 0)
        {
            activeItemIndex = slot;
        }
        
        // Update visibility for all items
        UpdateAllItemsVisibility();
    }

    private void SetHeldItemNetworkId(int slot, uint networkId)
    {
        switch (slot)
        {
            case 0:
                heldItem1NetworkId = networkId;
                break;
            case 1:
                heldItem2NetworkId = networkId;
                break;
            case 2:
                heldItem3NetworkId = networkId;
                break;
        }
    }

    private uint GetHeldItemNetworkId(int slot)
    {
        switch (slot)
        {
            case 0:
                return heldItem1NetworkId;
            case 1:
                return heldItem2NetworkId;
            case 2:
                return heldItem3NetworkId;
            default:
                return 0;
        }
    }

    // Helper method to clear held item (can be called by NetworkItem when dropping)
    public void ClearHeldItem(NetworkItem item)
    {
        for (int i = 0; i < heldItems.Length; i++)
        {
            if (heldItems[i] == item)
            {
                heldItems[i] = null;
                
                if (isServer)
                {
                    SetHeldItemNetworkId(i, 0);
                    
                    // Keep the slot active if it was the active slot, just make it empty
                    // Don't change activeItemIndex - let the player keep their selected slot
                }
                else if (isOwned)
                {
                    CmdUpdateHoldingState(i, 0);
                }
                break;
            }
        }
    }

    // Public getter to check if player is holding any items
    public bool IsHoldingAnyItem()
    {
        for (int i = 0; i < heldItems.Length; i++)
        {
            if (heldItems[i] != null) return true;
        }
        return false;
    }

    // Public getter to check if a specific slot has an item
    public bool IsHoldingItemInSlot(int slot)
    {
        if (slot < 0 || slot >= heldItems.Length) return false;
        return heldItems[slot] != null;
    }

    // Public getter for the active held item
    public NetworkItem GetActiveHeldItem()
    {
        if (activeItemIndex >= 0 && activeItemIndex < heldItems.Length)
        {
            return heldItems[activeItemIndex];
        }
        return null; // Returns null if no slot is active or if active slot is empty
    }

    // Check if player has an active slot selected (even if empty)
    public bool HasActiveSlot()
    {
        return activeItemIndex >= 0 && activeItemIndex < heldItems.Length;
    }

    // Check if the active slot actually contains an item
    public bool HasActiveItem()
    {
        return GetActiveHeldItem() != null;
    }

    // Public getter for a specific slot's item
    public NetworkItem GetHeldItem(int slot)
    {
        if (slot >= 0 && slot < heldItems.Length)
        {
            return heldItems[slot];
        }
        return null;
    }

    // Get the active item index
    public int GetActiveItemIndex()
    {
        return activeItemIndex;
    }
    
    private void NotifyInventoryChanged()
    {
        if (inventoryUI != null && isOwned)
        {
            inventoryUI.RefreshDisplay();
        }
    }
    
    public string GetItemName(int slot)
    {
        if (slot >= 0 && slot < heldItems.Length && heldItems[slot] != null)
        {
            return heldItems[slot].name;
        }
        return "";
    }
}