ScriptableObject: Создание инвентаря в Unity

// Base... в названии используется специально для указания того, что этот класс является 
//   базовым, общим для всех остальных предметов.
// Здесь мы описываем общие свойства всех категорий предметов. 
// Если, например, потребуется добавить информацию о стоимости предмета 
//   или об уровне качества, то это самое лучшее место
public abstract class BaseItemData : ScriptableObject {
    // Иконка
    public Sprite Icon;
    // Имя предмета
    public string Title;
    // Описание
    public string Description;
}

[CreateMenuItem(fileName = "newItem", menuName = "Data/Items/Simple", order = 51)]
public class SimpleItemData : BaseItemData {
    // Простой предмет не содержит дополнительной информации, 
    //   но в будущем может содержать
}

[CreateMenuItem(fileName = "newItem", menuName = "Data/Items/Collectable", order = 51]
public class CollectableItemData : BaseItemData {
    // Коллекционируемые предметы, это те, 
    //   которые складываются в одну ячейку инвентаря 
    //   и постепенно увеличивается счетчик предметов в ячейке
    
    // Максимальное кол-во предметов в одной пачке
    public int MaxCollectionCount;
}

// Этот класс отвечает за хранение состояния ячейки инвентаря с предметом
[Serializable]
public class ItemState {
    // Информация о хранимом предмете
    public BaseItemData Data;
    
    // Кол-во предметов определенного типа в ячейке
    public int Count;
}

// Класс отвечающий за логику работы инвентаря
public class InventoryController : MonoBehaviour {
    // Размер инвентаря по ширине
    public const int Width = 10;
    // Размер инвентаря по высоте
    public const int Height = 10;
    // Список состояний ячеек в инвентаре
    public ItemState[] Items;
    
    // Метод для добавления определенного кол-ва предметов в инвентарь
    public void AddItem(BaseItemData item, int count) {
        // Вызовем метод предмета, чтобы он мог использовать
        //     свою логику добавления предмета в инвентарь.
        // Здесь мы передаем в метод ссылку на инвентарь, 
        //    для того, чтобы предмет мог анализировать состояние инвентаря.
        // Также передаем информацию о том, сколько предметов было подобрано
        // И функцию для реального размещения предмета в инвентаре
        // Подробная реализация будет описана ниже
        item.PutToInventory(this, count, (countToPut) => PutNewItem(item, countToPut));
    }
    
    // Внутренний метод для заполнения свободной ячейки инвентаря
    private ItemState PutNewItem(BaseItemData item, int count) {
        var state = FindEmptyState();
        if (state == null) {
            // Если не смогли получить свободную ячейку, значит инвентарь заполнен
            // Вы можете обрабатывать ошибки любым другим способом
            // Но для упрощения мы просто выведем информацию в лог
            Debug.Log("Inventory is full");
            return null;
        }
        
        state.Data = item;
        state.Count = count;
        
        return state;
    }
    
    // ...
}

// ...
// Добавим метод добавления предмета в базовый класс описания

// Func<int, ItemState> - это описание параметра, который требует, 
//    чтобы передавалась функция принимающая параметр типа int, 
//    и возвращала ItemState.
//  В качестве параметра этого метода мы передаем только информацию 
//     о кол-ве добавляемых предметов, 
//     информация о том, какой фактически предмет добавляется уже содержится внутри.
//  Это сделано для того, чтобы предостеречь разработчика от случайно ошибки, 
//     когда он случайно передаст информацию о другом предмете,
//     в таком случае будет выполнена неверная логика для размещения предмета в инвентаре.
//  Если же разработчик захочет добавить предмет другого типа в инвентарь, 
//     то необходимо будет воспользоваться основным методом инвентаря - AddItem,
//     которая обеспечит правильную логику добавления предмета в инвентарь.
// Здесь virtual означает, что данный метод может быть изменен в дочерних классах, 
//    и дальше мы увидим как это происходит.
public virtual void PutToInventory(InventoryController inventory, int count, Func<int, ItemState> putNewItem) {
    // Большинство предметов имеет стандартную логику поведения при добавлении в инвентарь,
    //    поэтому просто добавляем объект в инвентарь.
    // Добавляем предметы, раздельно
    for (int i = 0; i < count; i++) {
        // Добавляем каждый предмет в отдельные ячейки
        var state = putNewItem(1);
        
        // Если мы не смогли добавить предмет в инвентарь, 
        //    то завершаем логику добавления предмета в инвентарь
        if (state == null) {
            return;
        }
    }
}

// ...

// ...

// Обратите внимание на override - это специальный модификатор метода, 
//    который говорит о том, что мы хотим переопределить логику 
//    выполнения метода в базовом классе.
// Тем самым, когда мы будем добавлять предметы, 
//     созданные на основе CollectableItemData, 
//     они будут добавляться по логике представленной ниже, 
//     а все остальные по логике описанной в классе BaseItemData, 
//     если это было не определено иначе.
public override void PutToInventory(InventoryController inventory, int count, Func<BaseItemData, int, ItemState> putNewItem) {
    // Сперва попробуем найти все незаполненные коллекции нужного типа
    // Вас может удивить почему это мы сравниваем типы объектов? 
    // Как было замечено в предыдущей статье,
    //    ссылки на один и тот же ScriptableObject могут быть разные 
    //    в зависимости от того, как они были загружены в сцену
    //  Поэтому надежнее будет сравнивать конкретные типы и идентификаторы предметов
    var notFullCollections = inventory.Items.Where(
    	state => state.Data.GetType() == GetType() 
    	&& state.Data.name == Data.name
    	&& state.Count < MaxCollectionCount
    ).ToList();
    var remainingCount = count;
    
    foreach (var state in notFullCollections) {
        // Сколько максимальное кол-во предметов мы можем добавить 
        //     в незаполненную ячейку инвентаря:
        //  Это может быть либо фактически оставшееся кол-во предметов для добавления
        //     или кол-во свободных слотов в коллекции предметов
        var countToPut = Math.Min(remainingCount, MaxCollectionCount - state.Count);
        
        // Добавляем предметы в коллекцию
        state.Count += countToPut;
        // Уменьшаем кол-во предметов, которые осталось распределить по ячейкам
        remainingCount -= countToPut;
        
        if (remainingCount <= 0) {
            // Завершаем логику, если все предметы были распределены
            return;
        }
    }
    
    // Если есть еще что распределять то, добавляем предметы, как новые в инвентарь
    while (remainingCount > 0) {
        var countToPut = Math.Min(remainingCount, MaxCollectionCount);
        var state = putNewItem(this, countToPut);
        
        // Если не смогли добавить предмет в инвентарь, завершаем логику добавления
        if (state == null) {
            return;
        }
        
        // Уменьшаем кол-во предметов, которые осталось распределить по ячейкам
        remainingCount -= countToPut;
    }
}

// ...

public override PutToInventory(InventoryController inventory, int count, Func<int, ItemState> putNewItem) {
    // Мы не вызвали метод putNewItem и предмет не будет фактически добавлен в инвентарь
    Debug.Log("Муха-ха-ха! Ты никогда не завладеешь предметом " + Title);
}

public class BaseItemData : ScriptableObject {
    // ...
    
    // Данные объявлены с модификатором public, что позволяет других объектам обращаться к этим данным для чтения или изменения.
    // Это может приводить к странным ситуациям, которые очень сложно отследить.
    public string Title;
    
    // ...
}

// ...

public void Update() {
    var state = GetRandomSlot();
    if (state != null) {
        // Подменяем имя у случайного предмета в инвентаре,
        //  а на самом деле полностью подменяем данные во всей игре D:
        state.Data.Title = "Без имени";
    }
}

public class UnitData : ScriptableObject {
    // Разрешаем редактирование этого поля из редактора Unity и делаем возможноть сохранения этих данных
    [SerializeField]
    // C помощью модификатора доступа private разрешаем доступ к этому полю только внутри этого класса
    private string _title;
    
    // Создаем свойство, доступное для всех остальных только для чтения
    // Для этого используется свойство, только с методом get
    public string Title { get { return _title; } }
}

// Создаем данные о новом предмете
var item = ScriptableObject.CreateInstance<SimpleItemData>();
item.Title = "New random Item #" + Random.Next().ToString();
item.Description = "Some description";

// Спустя какое-то время удаляем из памяти информацию об этом предмете
Object.Destroy(item);

public class DynamicScriptableObjectsManager : MonoBehaviour {
    private static List<ScriptableObject> _objects = new List<ScriptableObject>();
    
    public static T CreateInstance<T>()
        where T: ScriptableObject
    {
        var instance = ScriptableObject.CreateInstance<T>();
        
        _objects.Add(instance);
        
        return instance;
    }
    
    private void OnDisable() {
        foreach (var instance in _objects) {
            Object.Destroy(instance);
        }
        _objects.Clear();
    }
}