Show ingredient alternatives in flat crafting plan, Closes #189

Author: rubensworks

src/main/java/org/cyclops/integratedterminals/api/terminalstorage/crafting/ITerminalCraftingPlanFlat.java

@@ -68,9 +68,16 @@ public static interface IEntry {
 
         /**
          * @return The entry instance.
+         * @deprecated Use {@link #getInstances()} instead. TODO: rm in next major
          */
+        @Deprecated
         public IPrototypedIngredient<?, ?> getInstance();
 
+        /**
+         * @return The alternative entry instances for this entry. Never empty.
+         */
+        public List<IPrototypedIngredient<?, ?>> getInstances();
+
         /**
          * @return The number of instances to craft.
          */

src/main/java/org/cyclops/integratedterminals/api/terminalstorage/crafting/TerminalCraftingPlanFlatStatic.java

@@ -210,27 +210,44 @@ public static <I> TerminalCraftingPlanFlatStatic<I> deserialize(CompoundTag tag,
 
     public static class Entry implements ITerminalCraftingPlanFlat.IEntry {
 
-        private final IPrototypedIngredient<?, ?> instance;
+        private final List<IPrototypedIngredient<?, ?>> instances;
         private long quantityToCraft;
         private long quantityCrafting;
         private long quantityInStorage;
         private long quantityMissing;
 
-        public Entry(IPrototypedIngredient<?, ?> instance, long quantityToCraft, long quantityCrafting, long quantityInStorage, long quantityMissing) {
-            this.instance = instance;
+        public Entry(List<IPrototypedIngredient<?, ?>> instances, long quantityToCraft, long quantityCrafting, long quantityInStorage, long quantityMissing) {
+            this.instances = instances;
             this.quantityToCraft = quantityToCraft;
             this.quantityCrafting = quantityCrafting;
             this.quantityInStorage = quantityInStorage;
             this.quantityMissing = quantityMissing;
         }
 
+        public Entry(List<IPrototypedIngredient<?, ?>> instances) {
+            this(instances, 0, 0, 0, 0);
+        }
+
+        /**
+         * @deprecated Use {@link #Entry(List)} instead. TODO: rm in next major
+         */
+        @Deprecated
         public Entry(IPrototypedIngredient<?, ?> instance) {
-            this(instance, 0, 0, 0, 0);
+            this(List.of(instance), 0, 0, 0, 0);
         }
 
+        /**
+         * @deprecated Use {@link #getInstances()} instead. TODO: rm in next major
+         */
         @Override
+        @Deprecated
         public IPrototypedIngredient<?, ?> getInstance() {
-            return instance;
+            return instances.get(0);
+        }
+
+        @Override
+        public List<IPrototypedIngredient<?, ?>> getInstances() {
+            return instances;
         }
 
         @Override
@@ -271,7 +288,13 @@ public void setQuantityMissing(long quantityMissing) {
 
         public static CompoundTag serialize(TerminalCraftingPlanFlatStatic.Entry entry) {
             CompoundTag tag = new CompoundTag();
-            tag.put("instance", IPrototypedIngredient.serialize(entry.getInstance()));
+
+            // New multi-instance field for alternatives
+            ListTag instancesTag = new ListTag();
+            for (IPrototypedIngredient<?, ?> instance : entry.getInstances()) {
+                instancesTag.add(IPrototypedIngredient.serialize((PrototypedIngredient) instance));
+            }
+            tag.put("instances", instancesTag);
             tag.putLong("quantityToCraft", entry.getQuantityToCraft());
             tag.putLong("quantityCrafting", entry.getQuantityCrafting());
             tag.putLong("quantityInStorage", entry.getQuantityInStorage());
@@ -296,13 +319,22 @@ public static TerminalCraftingPlanFlatStatic.Entry deserialize(CompoundTag tag)
                 throw new IllegalArgumentException("Could not find a quantityMissing entry in the given tag");
             }
 
-            IPrototypedIngredient<?, ?> instance = IPrototypedIngredient.deserialize(tag.getCompound("instance"));
+            // Prefer the new \"instances\" list if present, otherwise fall back to the legacy single instance.
+            List<IPrototypedIngredient<?, ?>> instances = Lists.newArrayList();
+            if (tag.contains("instances", Tag.TAG_LIST)) {
+                ListTag instancesTag = tag.getList("instances", Tag.TAG_COMPOUND);
+                for (Tag base : instancesTag) {
+                    instances.add(IPrototypedIngredient.deserialize((CompoundTag) base));
+                }
+            } else {
+                instances.add(IPrototypedIngredient.deserialize(tag.getCompound("instance"))); // TODO: rm in next major
+            }
             long quantityToCraft = tag.getLong("quantityToCraft");
             long quantityCrafting = tag.getLong("quantityCrafting");
             long quantityInStorage = tag.getLong("quantityInStorage");
             long quantityMissing = tag.getLong("quantityMissing");
 
-            return new TerminalCraftingPlanFlatStatic.Entry(instance, quantityToCraft, quantityCrafting, quantityInStorage, quantityMissing);
+            return new TerminalCraftingPlanFlatStatic.Entry(instances, quantityToCraft, quantityCrafting, quantityInStorage, quantityMissing);
         }
 
     }

src/main/java/org/cyclops/integratedterminals/api/terminalstorage/crafting/TerminalCraftingPlanStatic.java

@@ -176,25 +176,64 @@ public ITerminalCraftingPlanFlat<I> flatten() {
     }
 
     public static class IndexedEntries {
-        private final Map<IPrototypedIngredient<?, ?>, TerminalCraftingPlanFlatStatic.Entry> indexedEntries;
+        /**
+         * Entries indexed by a canonical list of prototype ingredients.
+         * <p>
+         * Each key is a list of {@link IPrototypedIngredient} where:
+         * <ul>
+         *     <li>Every element has quantity 1.</li>
+         *     <li>Every element uses the exact-match-no-quantity condition.</li>
+         * </ul>
+         * The original (possibly non-normalized) alternatives list is stored inside the
+         * {@link TerminalCraftingPlanFlatStatic.Entry} for rendering purposes.
+         */
+        private final Map<List<IPrototypedIngredient<?, ?>>, TerminalCraftingPlanFlatStatic.Entry> indexedEntries;
 
         public IndexedEntries() {
             this.indexedEntries = Maps.newHashMap();
         }
 
-        public TerminalCraftingPlanFlatStatic.Entry get(IPrototypedIngredient<?, ?> prototypedIngredient) {
-            IPrototypedIngredient<?, ?> prototype = getPrototype(prototypedIngredient);
-            return indexedEntries.computeIfAbsent(prototype, k -> new TerminalCraftingPlanFlatStatic.Entry(new PrototypedIngredient(prototypedIngredient.getComponent(), prototype.getPrototype(), prototypedIngredient.getCondition())));
-        }
-
-        protected <T, M> IPrototypedIngredient<T, M> getPrototype(IPrototypedIngredient<T, M> prototypedIngredient) {
-            IIngredientMatcher<T, M> matcher = prototypedIngredient.getComponent().getMatcher();
-            return new PrototypedIngredient(prototypedIngredient.getComponent(), matcher.withQuantity(prototypedIngredient.getPrototype(), 1L), matcher.getExactMatchNoQuantityCondition());
-        }
-
-        public static long getQuantity(IPrototypedIngredient<?, ?> prototypedIngredient) {
-            IIngredientMatcher matcher = prototypedIngredient.getComponent().getMatcher();
-            return matcher.getQuantity(prototypedIngredient.getPrototype());
+        /**
+         * Get (or create) the entry corresponding to the given list of alternative ingredients.
+         *
+         * @param prototypedIngredients A non-empty list of alternatives.
+         * @return The corresponding flat plan entry.
+         */
+        public TerminalCraftingPlanFlatStatic.Entry get(List<IPrototypedIngredient<?, ?>> prototypedIngredients) {
+            List<IPrototypedIngredient<?, ?>> key = getPrototypes(prototypedIngredients);
+            return indexedEntries.computeIfAbsent(key,
+                    k -> new TerminalCraftingPlanFlatStatic.Entry(k));
+        }
+
+        /**
+         * Build a canonical list of prototype ingredients for the given alternatives.
+         * Quantities are normalized to 1 and the exact-match-no-quantity condition is used.
+         */
+        protected List<IPrototypedIngredient<?, ?>> getPrototypes(List<IPrototypedIngredient<?, ?>> prototypedIngredients) {
+            List<IPrototypedIngredient<?, ?>> result = new ArrayList<>(prototypedIngredients.size());
+            for (IPrototypedIngredient<?, ?> ingredient : prototypedIngredients) {
+                IIngredientMatcher matcher = ingredient.getComponent().getMatcher();
+                result.add(new PrototypedIngredient(
+                        ingredient.getComponent(),
+                        matcher.withQuantity(ingredient.getPrototype(), 1L),
+                        matcher.getExactMatchNoQuantityCondition()));
+            }
+            return result;
+        }
+
+        /**
+         * Get the quantity associated with the given alternatives list.
+         * <p>
+         * This is derived from the first element, which is consistent with prior behaviour
+         * when only a single prototype was available.
+         */
+        public static long getQuantity(List<IPrototypedIngredient<?, ?>> prototypedIngredients) {
+            if (prototypedIngredients.isEmpty()) {
+                return 0;
+            }
+            IPrototypedIngredient<?, ?> first = prototypedIngredients.get(0);
+            IIngredientMatcher matcher = first.getComponent().getMatcher();
+            return matcher.getQuantity(first.getPrototype());
         }
 
         public Collection<TerminalCraftingPlanFlatStatic.Entry> getEntries() {
@@ -211,8 +250,9 @@ protected static <I> void groupDependenciesByPrototype(IndexedEntries indexedEnt
 
         // Determine outputs that are invalid or will be crafted
         for (IPrototypedIngredient<?, ?> output : plan.getOutputs()) {
-            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(output);
-            long quantity = IndexedEntries.getQuantity(output);
+            List<IPrototypedIngredient<?, ?>> outputs = List.of(output);
+            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(outputs);
+            long quantity = IndexedEntries.getQuantity(outputs);
 
             if (plan.getStatus() == TerminalCraftingJobStatus.ERROR
                     || plan.getStatus() == TerminalCraftingJobStatus.INVALID
@@ -237,16 +277,16 @@ protected static <I> void groupDependenciesByPrototype(IndexedEntries indexedEnt
 
         // Determine storage ingredients
         for (IPrototypedIngredient<?, ?> output : plan.getStorageIngredients()) {
-            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(output);
-            long quantity = IndexedEntries.getQuantity(output);
+            List<IPrototypedIngredient<?, ?>> outputs = List.of(output);
+            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(outputs);
+            long quantity = IndexedEntries.getQuantity(outputs);
             entry.setQuantityInStorage(entry.getQuantityInStorage() + quantity);
         }
 
         // Determine missing ingredients
         for (List<IPrototypedIngredient<?, ?>> outputVariants : plan.getLastMissingIngredients()) {
-            IPrototypedIngredient<?, ?> output = outputVariants.stream().findFirst().get();
-            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(output);
-            long quantity = IndexedEntries.getQuantity(output);
+            TerminalCraftingPlanFlatStatic.Entry entry = indexedEntries.get(outputVariants);
+            long quantity = IndexedEntries.getQuantity(outputVariants);
             entry.setQuantityMissing(entry.getQuantityMissing() + quantity * plan.getCraftingQuantity());
         }
 

src/main/java/org/cyclops/integratedterminals/client/gui/container/component/GuiCraftingPlanFlat.java

@@ -102,6 +102,10 @@ public void setFirstRow(int firstRow) {
         this.firstRow = Math.max(0, firstRow);
     }
 
+    protected int getTick() {
+        return (int) Minecraft.getInstance().level.getGameTime() / TICK_DELAY;
+    }
+
     @Override
     public void render(PoseStack matrixStack, int mouseX, int mouseY, float partialTicks) {
 
@@ -133,15 +137,19 @@ private void drawElement(PoseStack matrixStack, Element element, int x, int y, i
 
         int xOriginal = x;
 
-        // Draw instance
-        IPrototypedIngredient<?, ?> output = element.getInstance();
-        IngredientComponent<?, ?> ingredientComponent = output.getComponent();
-        long quantity = ((IngredientComponent) ingredientComponent).getMatcher().getQuantity(output.getPrototype());
-        int finalX = x;
-        int finalY = y;
-        ingredientComponent.getCapability(IngredientComponentTerminalStorageHandlerConfig.CAPABILITY)
-                .ifPresent(h -> h.drawInstance(matrixStack, output.getPrototype(), quantity,
-                        "", this.parentGui, layer, partialTick, finalX, finalY, mouseX, mouseY, null));
+        // Draw instance (rotate over alternatives if present)
+        List<IPrototypedIngredient<?, ?>> instances = element.getInstances();
+        if (!instances.isEmpty()) {
+            int tick = getTick();
+            IPrototypedIngredient<?, ?> output = instances.get(tick % instances.size());
+            IngredientComponent<?, ?> ingredientComponent = output.getComponent();
+            long quantity = ((IngredientComponent) ingredientComponent).getMatcher().getQuantity(output.getPrototype());
+            int finalX = x;
+            int finalY = y;
+            ingredientComponent.getCapability(IngredientComponentTerminalStorageHandlerConfig.CAPABILITY)
+                    .ifPresent(h -> h.drawInstance(matrixStack, output.getPrototype(), quantity,
+                            "", this.parentGui, layer, partialTick, finalX, finalY, mouseX, mouseY, null));
+        }
 
         x = xOriginal + width - 50;
         if (layer == ContainerScreenTerminalStorage.DrawLayer.BACKGROUND) {
@@ -264,7 +272,7 @@ public static List<GuiCraftingPlanFlat.Element> getElements(ITerminalCraftingPla
 
     protected static void addElements(ITerminalCraftingPlanFlat.IEntry craftingPlan, List<GuiCraftingPlanFlat.Element> elements) {
         elements.add(new Element(
-                craftingPlan.getInstance(),
+                craftingPlan.getInstances(),
                 craftingPlan.getQuantityInStorage(),
                 craftingPlan.getQuantityToCraft(),
                 craftingPlan.getQuantityCrafting(),
@@ -283,23 +291,23 @@ public void updateNarration(NarrationElementOutput p_169152_) {
 
     public static class Element {
 
-        private final IPrototypedIngredient<?, ?> instance;
+        private final List<IPrototypedIngredient<?, ?>> instances;
         private final long storageQuantity;
         private final long toCraftQuantity;
         private final long craftingQuantity;
         private final long missingQuantity;
 
-        public Element(IPrototypedIngredient<?, ?> instance,
+        public Element(List<IPrototypedIngredient<?, ?>> instances,
                        long storageQuantity, long toCraftQuantity, long craftingQuantity, long missingQuantity) {
-            this.instance = instance;
+            this.instances = instances;
             this.storageQuantity = storageQuantity;
             this.toCraftQuantity = toCraftQuantity;
             this.craftingQuantity = craftingQuantity;
             this.missingQuantity = missingQuantity;
         }
 
-        public IPrototypedIngredient<?, ?> getInstance() {
-            return instance;
+        public List<IPrototypedIngredient<?, ?>> getInstances() {
+            return instances;
         }
 
         public long getStorageQuantity() {