Fix the reusable ingredients in chains of recipes blocking each other (#187)

If the same reusable ingredient would be used within a chain of dependent
recipes, the ingredient could be used in a dependent recipe, thereby blocking
the dependency recipe.

This change ensures that dependency-less recipes first get to use the reusable ingredients.

Closes #182

Author: rubensworks

src/main/java/org/cyclops/integratedcrafting/core/CraftingHelpers.java

@@ -985,6 +985,17 @@ public static <T, M> List<T> getIngredientRecipeInputs(IIngredientComponentStora
                               IngredientCollectionPrototypeMap<T, M> simulatedExtractionMemory,
                               IIngredientCollectionMutable<T, M> extractionMemoryReusable,
                               boolean collectMissingIngredients, long recipeOutputQuantity) {
+        return getIngredientRecipeInputs(storage, ingredientComponent, recipe, simulate, simulatedExtractionMemory,
+                extractionMemoryReusable, collectMissingIngredients, recipeOutputQuantity, false);
+    }
+
+    public static <T, M> Pair<List<T>, MissingIngredients<T, M>>
+    getIngredientRecipeInputs(IIngredientComponentStorage<T, M> storage, IngredientComponent<T, M> ingredientComponent,
+                              IRecipeDefinition recipe, boolean simulate,
+                              IngredientCollectionPrototypeMap<T, M> simulatedExtractionMemory,
+                              IIngredientCollectionMutable<T, M> extractionMemoryReusable,
+                              boolean collectMissingIngredients, long recipeOutputQuantity,
+                              boolean skipReusableIngredients) {
         IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
 
         // Quickly return if the storage is empty
@@ -1019,6 +1030,15 @@ public static <T, M> List<T> getIngredientRecipeInputs(IIngredientComponentStora
                 collectMissingIngredients ? Lists.newArrayList() : null;
         for (int inputIndex = 0; inputIndex < inputAlternativePrototypes.size(); inputIndex++) {
             IPrototypedIngredientAlternatives<T, M> inputPrototypes = inputAlternativePrototypes.get(inputIndex);
+
+            // If reusable ingredients should be skipped, treat them as empty (not needed yet).
+            // This is used when a job has dependencies, so that reusable ingredients remain available
+            // for other jobs to use, and will be extracted lazily in the update loop.
+            if (skipReusableIngredients && recipe.isInputReusable(ingredientComponent, inputIndex)) {
+                inputInstances.add(matcher.getEmptyInstance());
+                continue;
+            }
+
             T firstInputInstance = null;
             boolean setFirstInputInstance = false;
             T inputInstance = null;
@@ -1313,6 +1333,15 @@ public static IMixedIngredients getRecipeInputsFromCraftingJobBuffer(CraftingJob
                     Map<IngredientComponent<?, ?>, IngredientCollectionPrototypeMap<?, ?>> simulatedExtractionMemories,
                     Map<IngredientComponent<?, ?>, IIngredientCollectionMutable<?, ?>> extractionMemoriesReusable,
                     boolean collectMissingIngredients, long recipeOutputQuantity) {
+        return getRecipeInputs(storageGetter, recipe, simulate, simulatedExtractionMemories, extractionMemoriesReusable,
+                collectMissingIngredients, recipeOutputQuantity, false);
+    }
+
+    public static Pair<Map<IngredientComponent<?, ?>, List<?>>, Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>>>
+    getRecipeInputs(Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter, IRecipeDefinition recipe, boolean simulate,
+                    Map<IngredientComponent<?, ?>, IngredientCollectionPrototypeMap<?, ?>> simulatedExtractionMemories,
+                    Map<IngredientComponent<?, ?>, IIngredientCollectionMutable<?, ?>> extractionMemoriesReusable,
+                    boolean collectMissingIngredients, long recipeOutputQuantity, boolean skipReusableIngredients) {
         // Determine available and missing ingredients
         Map<IngredientComponent<?, ?>, List<?>> ingredientsAvailable = Maps.newIdentityHashMap();
         Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>> ingredientsMissing = Maps.newIdentityHashMap();
@@ -1330,7 +1359,7 @@ public static IMixedIngredients getRecipeInputsFromCraftingJobBuffer(CraftingJob
             }
             Pair<List<?>, MissingIngredients<?, ?>> subIngredients = getIngredientRecipeInputs(storage,
                     (IngredientComponent) ingredientComponent, recipe, simulate, simulatedExtractionMemory, extractionMemoryReusable,
-                    collectMissingIngredients, recipeOutputQuantity);
+                    collectMissingIngredients, recipeOutputQuantity, skipReusableIngredients);
             List<?> subIngredientAvailable = subIngredients.getLeft();
             MissingIngredients<?, ?> subIngredientsMissing = subIngredients.getRight();
             if (subIngredientAvailable == null && !collectMissingIngredients) {

src/main/java/org/cyclops/integratedcrafting/core/CraftingJobHandler.java

@@ -290,7 +290,10 @@ public void fillCraftingJobBufferFromStorage(CraftingJob craftingJob, Function<I
             throw new IllegalStateException("Re-filling a non-empty crafting job buffer is illegal");
         }
         // Determine the ingredients to extract. We can not reuse the ingredientsStorage value from the crafting job, as this may have been modified due to job splitting.
-        Pair<Map<IngredientComponent<?, ?>, List<?>>, Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>>> inputResult = CraftingHelpers.getRecipeInputs(storageGetter, craftingJob.getRecipe(), false, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), true, craftingJob.getAmount());
+        // If this job has dependencies, skip reusable ingredients so that they remain available for other jobs.
+        // They will be lazily extracted in the update loop once the dependencies have finished.
+        boolean skipReusableIngredients = !craftingJob.getDependencyCraftingJobs().isEmpty();
+        Pair<Map<IngredientComponent<?, ?>, List<?>>, Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>>> inputResult = CraftingHelpers.getRecipeInputs(storageGetter, craftingJob.getRecipe(), false, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), true, craftingJob.getAmount(), skipReusableIngredients);
         IMixedIngredients buffer = new MixedIngredients(inputResult.getLeft());
         craftingJob.setIngredientsStorageBuffer(CraftingHelpers.compressMixedIngredients(buffer));
         craftingJob.setLastMissingIngredients(inputResult.getRight());
@@ -503,35 +506,33 @@ public void update(INetwork network, int channel, PartPos targetPos) {
                     // trigger a crafting job for them if no job is running yet.
                     // This special case is needed because reusable ingredients are usually durability-based,
                     // and may be consumed _during_ a bulk crafting job.
-                    if (pendingCraftingJob.getLastMissingIngredients().isEmpty()) {
-                        for (IngredientComponent<?, ?> component : inputs.getRight().keySet()) {
-                            MissingIngredients<?, ?> missingIngredients = inputs.getRight().get(component);
-                            for (MissingIngredients.Element<?, ?> element : missingIngredients.getElements()) {
-                                if (element.isInputReusable()) {
-                                    IIngredientComponentStorage storage = CraftingHelpers.getNetworkStorage(network, channel, component, true);
-                                    for (MissingIngredients.PrototypedWithRequested alternative : element.getAlternatives()) {
-                                        // First check if we can extract it from storage.
-                                        Object extractedFromStorage = storage.extract(alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition(), false);
-                                        if (!((IIngredientMatcher) component.getMatcher()).isEmpty(extractedFromStorage)) {
-                                            pendingCraftingJob.addToIngredientsStorageBuffer((IngredientComponent<? super Object, ? extends Object>) component, extractedFromStorage);
-                                            break;
-                                        }
-
-                                        // Try to start crafting jobs for each alternative until one of them succeeds.
-                                        if (CraftingHelpers.isCrafting(craftingNetwork, channel,
-                                                alternative.getRequestedPrototype().getComponent(), alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition())) {
-                                            // Break loop if we have found an existing job for our dependency
-                                            // This may occur if a crafting job was triggered in a parallelized job
-                                            break;
-                                        }
-                                        CraftingJob craftingJob = CraftingHelpers.calculateAndScheduleCraftingJob(network, channel,
-                                                alternative.getRequestedPrototype().getComponent(), alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition(), true, true,
-                                                CraftingHelpers.getGlobalCraftingJobIdentifier(), null);
-                                        if (craftingJob != null) {
-                                            pendingCraftingJob.addDependency(craftingJob);
-                                            // Break loop once we have found a valid job
-                                            break;
-                                        }
+                    for (IngredientComponent<?, ?> component : inputs.getRight().keySet()) {
+                        MissingIngredients<?, ?> missingIngredients = inputs.getRight().get(component);
+                        for (MissingIngredients.Element<?, ?> element : missingIngredients.getElements()) {
+                            if (element.isInputReusable()) {
+                                IIngredientComponentStorage storage = CraftingHelpers.getNetworkStorage(network, channel, component, true);
+                                for (MissingIngredients.PrototypedWithRequested alternative : element.getAlternatives()) {
+                                    // First check if we can extract it from storage.
+                                    Object extractedFromStorage = storage.extract(alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition(), false);
+                                    if (!((IIngredientMatcher) component.getMatcher()).isEmpty(extractedFromStorage)) {
+                                        pendingCraftingJob.addToIngredientsStorageBuffer((IngredientComponent<? super Object, ? extends Object>) component, extractedFromStorage);
+                                        break;
+                                    }
+
+                                    // Try to start crafting jobs for each alternative until one of them succeeds.
+                                    if (CraftingHelpers.isCrafting(craftingNetwork, channel,
+                                            alternative.getRequestedPrototype().getComponent(), alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition())) {
+                                        // Break loop if we have found an existing job for our dependency
+                                        // This may occur if a crafting job was triggered in a parallelized job
+                                        break;
+                                    }
+                                    CraftingJob craftingJob = CraftingHelpers.calculateAndScheduleCraftingJob(network, channel,
+                                            alternative.getRequestedPrototype().getComponent(), alternative.getRequestedPrototype().getPrototype(), alternative.getRequestedPrototype().getCondition(), true, true,
+                                            CraftingHelpers.getGlobalCraftingJobIdentifier(), null);
+                                    if (craftingJob != null) {
+                                        pendingCraftingJob.addDependency(craftingJob);
+                                        // Break loop once we have found a valid job
+                                        break;
                                     }
                                 }
                             }