Inventory.cs

using UnityEngine;

namespace uMMORPG
{
    // not abstract because for example Monster only needs just this class
    [DisallowMultipleComponent]
    public class Inventory : ItemContainer
    {
        // helper function to count the free slots
        public int SlotsFree()
        {
            // count manually. Linq is HEAVY(!) on GC and performance
            int free = 0;
            foreach (ItemSlot slot in slots)
                if (slot.amount == 0)
                    ++free;
            return free;
        }

        // helper function to calculate the occupied slots
        public int SlotsOccupied()
        {
            // count manually. Linq is HEAVY(!) on GC and performance
            int occupied = 0;
            foreach (ItemSlot slot in slots)
                if (slot.amount > 0)
                    ++occupied;
            return occupied;
        }

        // helper function to calculate the total amount of an item type in inventory
        // note: .Equals because name AND dynamic variables matter (petLevel etc.)
        public int Count(Item item)
        {
            // count manually. Linq is HEAVY(!) on GC and performance
            int amount = 0;
            foreach (ItemSlot slot in slots)
                if (slot.amount > 0 && slot.item.Equals(item))
                    amount += slot.amount;
            return amount;
        }

        // helper function to remove 'n' items from the inventory
        public bool Remove(Item item, int amount)
        {
            for (int i = 0; i < slots.Count; ++i)
            {
                ItemSlot slot = slots[i];
                // note: .Equals because name AND dynamic variables matter (petLevel etc.)
                if (slot.amount > 0 && slot.item.Equals(item))
                {
                    // take as many as possible
                    amount -= slot.DecreaseAmount(amount);
                    slots[i] = slot;

                    // are we done?
                    if (amount == 0) return true;
                }
            }

            // if we got here, then we didn't remove enough items
            return false;
        }

        // helper function to check if the inventory has space for 'n' items of type
        // -> the easiest solution would be to check for enough free item slots
        // -> it's better to try to add it onto existing stacks of the same type
        //    first though
        // -> it could easily take more than one slot too
        // note: this checks for one item type once. we can't use this function to
        //       check if we can add 10 potions and then 10 potions again (e.g. when
        //       doing player to player trading), because it will be the same result
        public bool CanAdd(Item item, int amount)
        {
            // go through each slot
            for (int i = 0; i < slots.Count; ++i)
            {
                // empty? then subtract maxstack
                if (slots[i].amount == 0)
                    amount -= item.maxStack;
                // not empty. same type too? then subtract free amount (max-amount)
                // note: .Equals because name AND dynamic variables matter (petLevel etc.)
                else if (slots[i].item.Equals(item))
                    amount -= (slots[i].item.maxStack - slots[i].amount);

                // were we able to fit the whole amount already?
                if (amount <= 0) return true;
            }

            // if we got here than amount was never <= 0
            return false;
        }

        // helper function to put 'n' items of a type into the inventory, while
        // trying to put them onto existing item stacks first
        // -> this is better than always adding items to the first free slot
        // -> function will only add them if there is enough space for all of them
        public bool Add(Item item, int amount)
        {
            // we only want to add them if there is enough space for all of them, so
            // let's double check
            if (CanAdd(item, amount))
            {
                // add to same item stacks first (if any)
                // (otherwise we add to first empty even if there is an existing
                //  stack afterwards)
                for (int i = 0; i < slots.Count; ++i)
                {
                    // not empty and same type? then add free amount (max-amount)
                    // note: .Equals because name AND dynamic variables matter (petLevel etc.)
                    if (slots[i].amount > 0 && slots[i].item.Equals(item))
                    {
                        ItemSlot temp = slots[i];
                        amount -= temp.IncreaseAmount(amount);
                        slots[i] = temp;
                    }

                    // were we able to fit the whole amount already? then stop loop
                    if (amount <= 0) return true;
                }

                // add to empty slots (if any)
                for (int i = 0; i < slots.Count; ++i)
                {
                    // empty? then fill slot with as many as possible
                    if (slots[i].amount == 0)
                    {
                        int add = Mathf.Min(amount, item.maxStack);
                        slots[i] = new ItemSlot(item, add);
                        amount -= add;
                    }

                    // were we able to fit the whole amount already? then stop loop
                    if (amount <= 0) return true;
                }
                // we should have been able to add all of them
                if (amount != 0) Debug.LogError("inventory add failed: " + item.name + " " + amount);
            }
            return false;
        }
    }
}