我想开始限制项目插槽，然后按 M 更新扩展插槽

Question

我已经完成了库存槽位，并且想锁定和解锁一些槽位以便在......之后进行扩展（按 m 进行测试）

我现在按M，解锁槽增加，但增加解锁槽数量后不能使用扩展槽。

已完成所有库存槽和物品以在槽之间移动

public abstract class ItemContainer : MonoBehaviour, IItemContainer
{
    public List<ItemSlot> ItemSlots;

    public int unlockSlot = 1;

    public event Action<BaseItemSlot> OnPointerEnterEvent;
    public event Action<BaseItemSlot> OnPointerExitEvent;
    public event Action<BaseItemSlot> OnRightClickEvent;
    public event Action<BaseItemSlot> OnBeginDragEvent;
    public event Action<BaseItemSlot> OnEndDragEvent;
    public event Action<BaseItemSlot> OnDragEvent;
    public event Action<BaseItemSlot> OnDropEvent;

    protected virtual void OnValidate()
    {
        GetComponentsInChildren(includeInactive: true, result: ItemSlots);
    }

    protected virtual void Start()
    {
        for (int i = 0; i < ItemSlots.Count/5* unlockSlot; i++)
        {
            ItemSlots[i].OnPointerEnterEvent += slot => EventHelper(slot, OnPointerEnterEvent);
            ItemSlots[i].OnPointerExitEvent += slot => EventHelper(slot, OnPointerExitEvent);
            ItemSlots[i].OnRightClickEvent += slot => EventHelper(slot, OnRightClickEvent);
            ItemSlots[i].OnBeginDragEvent += slot => EventHelper(slot, OnBeginDragEvent);
            ItemSlots[i].OnEndDragEvent += slot => EventHelper(slot, OnEndDragEvent);
            ItemSlots[i].OnDragEvent += slot => EventHelper(slot, OnDragEvent);
            ItemSlots[i].OnDropEvent += slot => EventHelper(slot, OnDropEvent);
        }
    }

    private void EventHelper(BaseItemSlot itemSlot, Action<BaseItemSlot> action)
    {
        if (action != null)
            action(itemSlot);
    }

    public virtual bool CanAddItem(Item item, int amount = 1)
    {
        int freeSpaces = 0;

        foreach (ItemSlot itemSlot in ItemSlots)
        {
            if (itemSlot.Item == null || itemSlot.Item.ID == item.ID)
            {
                freeSpaces += item.MaxStacks - itemSlot.Amount;
            }
        }
        return freeSpaces >= amount;
    }

    public virtual bool AddItem(Item item)
    {
        for (int i = 0; i < ItemSlots.Count; i++)
        {
            if (ItemSlots[i].CanAddStack(item))
            {
                ItemSlots[i].Item = item;             
                ItemSlots[i].Amount++;               
                return true;
            }
        }

        for (int i = 0; i < ItemSlots.Count; i++)
        {
            if (ItemSlots[i].Item == null)
            {
                if (item.ID == item.ID)
                {
                    ItemSlots[i].Item = item;
                    ItemSlots[i].Amount++;
                    return true;
                }

            }
        }
        return false;
    }

    public virtual bool RemoveItem(Item item)
    {
        for (int i = 0; i < ItemSlots.Count; i++)
        {
            if (ItemSlots[i].Item == item)
            {
                ItemSlots[i].Amount--;
                return true;
            }
        }
        return false;
    }

    public virtual Item RemoveItem(string itemID)
    {
        for (int i = 0; i < ItemSlots.Count; i++)
        {
            Item item = ItemSlots[i].Item;
            if (item != null && item.ID == itemID)
            {
                ItemSlots[i].Amount--;
                return item;
            }
        }
        return null;
    }

    public virtual int ItemCount(string itemID)
    {
        int number = 0;

        for (int i = 0; i < ItemSlots.Count; i++)
        {
            Item item = ItemSlots[i].Item;
            if (item != null && item.ID == itemID)
            {
                number += ItemSlots[i].Amount;
            }
        }
        return number;
    }


    private void Update()
    {
        if (Input.GetKeyUp(KeyCode.M))
        {
            unlockSlot++;
            Debug.Log(unlockSlot);
        }
    }
}    

解锁槽不增加（调试不显示），其余槽禁用使用

Answer 1

固定：只需将启动功能复制到固定更新。

不要！

1. 这听起来对资源很不利...为什么一直设置这个？而是将其移至您实际更改unlockSlot 的那一刻，并且只在该处执行一次。

2. 此外，您还可以使用 lambda 表达式执行 +=。所以事件将被添加额外的增量，所以下次回调执行两次......然后是 3 次等等。 由于它是一个 lambda 表达式，因此您也不能使用 -= 来删除回调。

为了让它自动化一点，我会使用 property with backing field 之类的

private int unlockSlot = 1;
public int UnlockSlot
{
    get
    {
        return unlockSlot;
    }
    // you can additionally make the setter private so only this class
    // can change the value while other classes have only read permissions
    /*private*/
    set
    {
        unlockSlot = value;

        UpdateItemSlots();
    }
}

那么你可以避免你的EventHelper .. 这可以简单地写成

private void UpdateItemSlots()
{
    for (var i = 0; i < ItemSlots.Count / 5 * unlockSlot; i++)
    {
        // Before adding callbacks remove them
        // this is valid even if they were not added before
        // but makes sure they are added only exactly once
        ItemSlots[i].OnPointerEnterEvent -= OnPointerEnterEvent;
        ItemSlots[i].OnPointerExitEvent -= OnPointerExitEvent;
        ItemSlots[i].OnRightClickEvent -= OnRightClickEvent;
        ItemSlots[i].OnBeginDragEvent -= OnBeginDragEvent;
        ItemSlots[i].OnEndDragEvent -= OnEndDragEvent;
        ItemSlots[i].OnDragEvent -= OnDragEvent;
        ItemSlots[i].OnDropEvent -= OnDropEvent;

        // add your callback events .. no need for this complex lambda construct
        ItemSlots[i].OnPointerEnterEvent += OnPointerEnterEvent;
        ItemSlots[i].OnPointerExitEvent += OnPointerExitEvent;
        ItemSlots[i].OnRightClickEvent += OnRightClickEvent;
        ItemSlots[i].OnBeginDragEvent += OnBeginDragEvent;
        ItemSlots[i].OnEndDragEvent += OnEndDragEvent;
        ItemSlots[i].OnDragEvent += OnDragEvent;
        ItemSlots[i].OnDropEvent += OnDropEvent;
    }
}

Afaik 你不需要null 检查event Action 你可以确定并以它们永远不会为空的方式声明它们，例如

public event Action<BaseItemSlot> OnPointerEnterEvent = slot => {};

这会添加一个空回调，如前所述，由于是 lambda 表达式而无法删除 => 可以确保 OnPointerEnterEvent 永远不会是 null。

现在只需更改

protected virtual void Start()
{
    UpdateItemSlots();
}

记住不要使用unlockSlot 而是使用UnlockSlot 来更改其值，以便属性自动更新插槽

private void Update()
{
    if (Input.GetKeyUp(KeyCode.M))
    {
        UnlockSlot++;
        // for reading in this case it doesn't matter
        // but for being consequent I would also use the property here
        Debug.Log(UnlockSlot);
    }
}