Система крафта, схема проверки и хранения "чертежей"

[CreateAssetMenu(fileName = "NewItem", menuName = "Crafting/Item")]
public class Item : ScriptableObject
{
    public string ID;
    public string itemName;
    public Sprite icon;
    public int maxStackSize = 64;
    public GameObject prefab; // для дропа в мире
}

[CreateAssetMenu(fileName = "NewRecipe", menuName = "Crafting/Recipe")]
public class Recipe : ScriptableObject
{
    [Header("Рецепт 3x3")]
    public Item[] ingredients = new Item[9]; // как в Minecraft
    
    [Header("Результат")]
    public Item result;
    public int resultAmount = 1;
    
    public bool CanCraft(Item[] grid) // grid - это содержимое рабочего стола этот метод вызывается в окне крафта
    {
        for (int i = 0; i < 9; i++)
        {
            if (grid[i] != ingredients[i])
                return false;
        }
        return true;
    }
}

public class CraftingSystem : MonoBehaviour
{
    public Item[] craftingGrid = new Item[9]; // текущая сетка крафта
    public List<Recipe> allRecipes = new List<Recipe>();
    public PlayerInventory inventory;
    
    // Добавить предмет в сетку крафта
    public void AddToCraftingGrid(int slotIndex, Item item)
    {
        if (slotIndex < 0 || slotIndex >= 9) return;
        
        craftingGrid[slotIndex] = item;
        CheckForRecipe();
    }
    
    // Проверить рецепт
    private void CheckForRecipe()
    {
        foreach (var recipe in allRecipes)
        {
            if (recipe.CanCraft(craftingGrid))
            {
                CraftItem(recipe);
                return;
            }
        }
    }
    
    // Создать предмет
    private void CraftItem(Recipe recipe)
    {
        // Проверяем инвентарь
        if (inventory.RemoveItemsForCrafting(recipe.ingredients))
        {
            // Добавляем результат
            inventory.AddItem(recipe.result, recipe.resultAmount);
            
            // Очищаем сетку крафта
            ClearCraftingGrid();
        }
    }
    
    // Очистить сетку
    private void ClearCraftingGrid()
    {
        for (int i = 0; i < craftingGrid.Length; i++)
        {
            craftingGrid[i] = null;
        }
    }
}

using System.Linq;
using UnityEngine;
 
public class ItemSorter : MonoBehaviour
{
    public List<Item> items = new List<Item>();
    
    // Сортировка по возрастанию
    public void SortItemsAscending()
    {
        items = items.OrderBy(item => item.ID).ToList();
    }
    
    // Сортировка по убыванию
    public void SortItemsDescending()
    {
        items = items.OrderByDescending(item => item.ID).ToList();
    }
}

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
 
public class CraftContainer : MonoBehaviour
{
    [SerializeField] ItemBase [] itemsCraft = new ItemBase[5];
    [Space, Header("Список рецептов")]
    [SerializeField] Recipe[] recipes = new Recipe[5];
 
    [Header("Возвращаем ообъект")]
    [SerializeField] List<ItemBase> itemsResult;
 
    [System.Serializable]
    public class Recipe
    {
        [SerializeField] public string nameRecipe;
        [SerializeField]
        ItemBase[] ingredients = new ItemBase[5];
        public
        ItemBase[] Ingredients => ingredients;
 
        [Header("Создаваемый префаб")]
        public
        ItemBase prefab;
    }
 
    [ContextMenu("Проверить рецепты")]
    void RecipeCalculate()
    {
        int indexTrue = 0;
 
        for (int i = 0; i < recipes.Length; i++)
        {
            if (recipes[i].Ingredients.Length == itemsCraft.Length) // если колличество ингредиентов равно положенным 
            {
                if (recipes[i].Ingredients.SequenceEqual(itemsCraft))
                {
                    itemsResult.Add(recipes[i].prefab);
                    print($"Возвращаем объект ''{recipes[i].nameRecipe}''");
                }
            }
            else
            {
                for (int j = 0; j < itemsCraft.Length; j++)
                {
                    if (itemsCraft[j].ItemName == recipes[i].Ingredients[j].ItemName)
                    {
                        indexTrue++;
                        if (/*j == recipes[i].Ingredients.Length - 1 && */indexTrue == recipes[i].Ingredients.Length - 1)
                        {
                            print($"Возвращаем объект ''{recipes[i].nameRecipe}''");
                            itemsResult.Add(recipes[i].prefab);
                            indexTrue = 0;
                            //continue;
                        }
                    }
                    //else
                    //{
                    //    indexTrue = 0;
                    //    continue;
                    //}
                }
            }
        }
    }
}

    public class Recipe
    {
        ItemBase[] ingredients = new ItemBase[5];
        public bool CanCraft(IEnumerable<ItemBase> items) => !ingredients.Except(items).Any();
    }

ItemBase[] ingredients = new ItemBase[5];

public bool CanCraft(IEnumerable<ItemBase> items) => !ingredients.Except(items).Any();

    void ExaminationRecipes()
    {
        for (int i = 0; i < _recipes.Length; i++)
        {
            if (_recipes[i].Ingredients.Length <= _craftItems.Length)
            {
                if (_recipes[i].CanCraft(_craftItems))
                {
                    print($"Рецепт ''{_recipes[i].nameRecipe}'': {_recipes[i].CanCraft(_craftItems)}");
                    _resultItems.Add(_recipes[i].GetCraftItem());
                }               
            }
            else
            {
                print($"Рецепт ''{_recipes[i].nameRecipe} недостаточно ингредиентов");
            }
        }
    }

ItemBase[] ingredients = new ItemBase[5];
public bool CanCraft(IEnumerable<ItemBase> items){
      //заполняем словарь хранящий число использований от типа
      var ingredientCount = new Dictionary<ItemBase, int>():
      foreach(var ingredient in ingredients) 
      {
             ingredientCount.TryGetValue(ingredient, out var count);  //если нет - то count = 0        
             ingredientCount[ingredient] = ++count; //обновляем/добавляем количество в словаре
      }
      foreach(var item in items)
      {
             if (!ingredients.TryGetValue(item, out var count)) continue;
             //если ингредиент есть, то уменьшаем число использований или удаляем из словаря
             count--;
             if (count > 0) ingredientCount[item] = count;
             else ingredientCount.Remove(item);
       }
       return ingredientCount.Count == 0;
}

using System;
using UnityEngine;
 
[Serializable]
public abstract class ItemBase : MonoBehaviour
{
    /// <summary>
    /// Тип распространенности айтема
    /// </summary>
    public enum ItemPrevalenceType
    { 
        LEGENDARY,
        RARE,
        ORDINARY,
        COMMON
    };
 
    [Space]
    [SerializeField] private ItemPrevalenceType _prevalenceType;
 
    public ItemPrevalenceType PrevalenceType => _prevalenceType;
 
    [Space]
    [SerializeField] protected string _itemName;
    public string ItemName => _itemName;
 
    [SerializeField] protected string Description;
    [Space]
    [SerializeField] protected int _prise;
 
    public static event Action<ItemBase> OnCreateEndAddItem;
 
 
    public void RegistrationItem() // добавляем себя при создании в коллекцию
    {
        print($"{gameObject.name}, Добаляюсь в список ");
        OnCreateEndAddItem?.Invoke(this);    
    }
}

    void ExaminationRecipes()
    {
        SortItemCraft();
 
        for (int i = 0; i < _recipes.Count; i++) // проход по рецептам
        {
            if (_craftItems.Count >= _recipes[i].Ingredients.Count)
            {
                if (_recipes[i].CanCraft(_craftItems))
                {
                    _resultItems.Add(_recipes[i].GetPrefab());
                }
            }
            else print($"''{_recipes[i].RecipeName}'' не хватает ингредиентов");
        }
    }

    private void RecipesExamination(int i)
    {
        for (int j = 0; j < _recipes[i].Ingredients.Count; j++) // проход по конкретному рецепту
        {
            if (_recipes[i].Ingredients[j].ItemName == _craftItems[j].ItemName)
            {
                if (j == _recipes[i].Ingredients.Count - 1)
                {
                    print($"Рецепт ''{_recipes[i].RecipeName}'' сощелся");
                    _resultItems.Add(_recipes[i].GetPrefab());
 
                    if(j < _craftItems.Count - _recipes[i].Ingredients.Count)
                    {
                        print($"Итераций достаточно для продолжения {_craftItems.Count - _recipes[i].Ingredients.Count}");
                        RecipesExamination(j); 
                        // после этого вызова комп задумался на секунды и выдал 7 с лишним тысяч префабов ))
                    }
                }
            }
            else
            {
                print($"Ингредиент ''{_recipes[i].RecipeName}'' не совпал");
            }
        }
    }

//число крафтов от набора
public int CraftCount(IEnumerable<ItemBase> items){
      if (ingredients.Count == 0) throw new Exception("ХЗ что выводить");
      //заполняем словарь хранящий число необходимых ингредиентов от типа
      var ingredientCount = new Dictionary<ItemBase, int>():
      foreach(var ingredient in ingredients) 
      {
             ingredientCount.TryGetValue(ingredient, out var count);  //если нет - то count = 0        
             ingredientCount[ingredient] = ++count; //обновляем/добавляем количество в словаре
      }
      //заполняем словарь хранящий число имеющихся ингредиентов от типа
      var itemCount= new Dictionary<ItemBase, int>():
      foreach(var ingredient in items) 
      {             
             itemCount.TryGetValue(ingredient, out var count);  //если нет - то count = 0        
             itemCount[ingredient] = ++count; //обновляем/добавляем количество в словаре
      }
      var totalCount = int.MaxValue;
      foreach(var pair in ingredientCount)
      {               
            //для каждого требуемого ингредиента, берем число имеющихся, если их нет - возвращаем 0
            if (!itemCount.TryGetValue(pair.Key, out var hasCount)) return 0;
            var count = hasCount / pair.Value; //число собранных по ингредиенту, если hasCount < pair.Value - то 0
            if (count == 0) return 0;
            totalCount = Math.Min(totalCount, count);
      }
      return totalCount;
}

//число крафтов от набора
public int CraftCount(IEnumerable<ItemBase> items){
      if (ingredients.Count == 0) throw new Exception("ХЗ что выводить");
      //заполняем словарь хранящий число необходимых ингредиентов от типа
      var ingredientCount = new Dictionary<ItemBase, int>():
      foreach(var ingredient in ingredients) 
      {
             ingredientCount.TryGetValue(ingredient, out var count);  //если нет - то count = 0        
             ingredientCount[ingredient] = ++count; //обновляем/добавляем количество в словаре
      }
      //заполняем словарь хранящий число имеющихся ингредиентов от типа
      var itemCount= new Dictionary<ItemBase, int>():
      foreach(var ingredient in items) 
      {             
             itemCount.TryGetValue(ingredient, out var count);  //если нет - то count = 0        
             itemCount[ingredient] = ++count; //обновляем/добавляем количество в словаре
      }
      var totalCount = int.MaxValue;
      foreach(var pair in ingredientCount)
      {               
            //для каждого требуемого ингредиента, берем число имеющихся, если их нет - возвращаем 0
            if (!itemCount.TryGetValue(pair.Key, out var hasCount)) return 0;
            var count = hasCount / pair.Value; //число собранных по ингредиенту, если hasCount < pair.Value - то 0
            if (count == 0) return 0;
            totalCount = Math.Min(totalCount, count);
      }
      return totalCount;
}