#479011822

Committed 29 Dec 2025 01:56PM UTC coverage: 24.23% (-0.6%) from 24.876%

Build # #479011822

Build Type

push

github

Committed by

rubensworks

Commit Message

Add dedicated storage per crafting job

When a crafting job is started, ingredients are immediately moved from
general storage to the new storage buffers per crafting job. This avoids
issues where ingredients can be consumed elsewhere (e.g. exporters or
other crafting jobs) before it is used by the crafting job.

Closes #112

Run Details

3 of 104 new or added lines in 7 files covered. (2.88%)

3 existing lines in 3 files now uncovered.

755 of 3116 relevant lines covered (24.23%)

0.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.01

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

package org.cyclops.integratedcrafting.core;

import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import net.minecraft.core.Direction;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.common.util.LazyOptional;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.logging.log4j.Level;
import org.cyclops.commoncapabilities.api.capability.recipehandler.IPrototypedIngredientAlternatives;
import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
import org.cyclops.commoncapabilities.api.ingredient.*;
import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
import org.cyclops.commoncapabilities.api.ingredient.storage.IngredientComponentStorageEmpty;
import org.cyclops.cyclopscore.helper.BlockEntityHelpers;
import org.cyclops.cyclopscore.ingredient.collection.*;
import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageSlottedCollectionWrapper;
import org.cyclops.integratedcrafting.Capabilities;
import org.cyclops.integratedcrafting.IntegratedCrafting;
import org.cyclops.integratedcrafting.api.crafting.*;
import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
import org.cyclops.integratedcrafting.api.recipe.IRecipeIndex;
import org.cyclops.integratedcrafting.capability.network.CraftingNetworkConfig;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.PartStateException;
import org.cyclops.integrateddynamics.api.ingredient.capability.IPositionedAddonsNetworkIngredientsHandler;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetworkIngredients;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.core.network.IngredientChannelAdapter;
import org.cyclops.integrateddynamics.core.network.IngredientChannelIndexed;

import javax.annotation.Nullable;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * Helpers related to handling crafting jobs.
 * @author rubensworks
 */
public class CraftingHelpers {

    /**
     * Get the network at the given position,
     * or throw a PartStateException if it is null.
     * @param pos A position.
     * @return A network.
     * @throws PartStateException If the network could not be found.
     */
    public static INetwork getNetworkChecked(PartPos pos) throws PartStateException {
        INetwork network = NetworkHelpers.getNetwork(pos.getPos().getLevel(true), pos.getPos().getBlockPos(), pos.getSide()).orElse(null);
        if (network == null) {
            IntegratedDynamics.clog(Level.ERROR, "Could not get the network for transfer as no network was found.");
            throw new PartStateException(pos.getPos(), pos.getSide());
        }
        return network;
    }

    /**
     * Get the crafting network in the given network.
     * @param network A network.
     * @return The crafting network.
     */
    public static LazyOptional<ICraftingNetwork> getCraftingNetwork(@Nullable INetwork network) {
        if (network != null) {
            return network.getCapability(CraftingNetworkConfig.CAPABILITY);
        }
        return null;
    }

    /**
     * Get the crafting network in the given network.
     * @param network A network.
     * @return The crafting network.
     */
    public static ICraftingNetwork getCraftingNetworkChecked(@Nullable INetwork network) {
        return getCraftingNetwork(network)
                .orElseThrow(() -> new IllegalStateException("Could not find a crafting network"));
    }

    /**
     * Get the storage network of the given type in the given network.
     * @param network A network.
     * @param ingredientComponent The ingredient component type of the network.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The storage network.
     */
    public static <T, M> LazyOptional<IPositionedAddonsNetworkIngredients<T, M>> getIngredientsNetwork(INetwork network,
                                                                                                       IngredientComponent<T, M> ingredientComponent) {
        IPositionedAddonsNetworkIngredientsHandler<T, M> ingredientsHandler = ingredientComponent.getCapability(Capabilities.POSITIONED_ADDONS_NETWORK_INGREDIENTS_HANDLER).orElse(null);
        if (ingredientsHandler != null) {
            return ingredientsHandler.getStorage(network);
        }
        return LazyOptional.empty();
    }

    /**
     * Get the storage network of the given type in the given network.
     * @param network A network.
     * @param ingredientComponent The ingredient component type of the network.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The storage network.
     */
    public static <T, M> IPositionedAddonsNetworkIngredients<T, M> getIngredientsNetworkChecked(INetwork network,
                                                                                                IngredientComponent<T, M> ingredientComponent) {
        return getIngredientsNetwork(network, ingredientComponent)
                .orElseThrow(() -> new IllegalStateException("Could not find an ingredients network"));
    }

    /**
     * Get the storage of the given ingredient component type from the network.
     * @param network The network.
     * @param channel A network channel.
     * @param ingredientComponent The ingredient component type of the network.
     * @param scheduleObservation If an observation inside the ingredients network should be scheduled.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The storage.
     */
    public static <T, M> IIngredientComponentStorage<T, M> getNetworkStorage(INetwork network, int channel,
                                                                             IngredientComponent<T, M> ingredientComponent,
                                                                             boolean scheduleObservation) {
        IPositionedAddonsNetworkIngredients<T, M> ingredientsNetwork = getIngredientsNetwork(network, ingredientComponent).orElse(null);
        if (ingredientsNetwork != null) {
            if (scheduleObservation) {
                ingredientsNetwork.scheduleObservation();
            }
            return ingredientsNetwork.getChannel(channel);
        }
        return new IngredientComponentStorageEmpty<>(ingredientComponent);
    }

    /**
     * If the network is guaranteed to have uncommitted changes (such as the one in #48),
     * forcefully run observers synchronously, so that we can calculate the job in a consistent network state.
     * @param network The network.
     * @param channel A network channel.
     */
    public static void beforeCalculateCraftingJobs(INetwork network, int channel) {
        for (IngredientComponent<?, ?> ingredientComponent : IngredientComponent.REGISTRY.getValues()) {
            IPositionedAddonsNetworkIngredients<?, ?> ingredientsNetwork = getIngredientsNetwork(network, ingredientComponent).orElse(null);
            if (ingredientsNetwork != null && (ingredientsNetwork.isObservationForcedPending(channel))) {
                ingredientsNetwork.runObserverSync();
            }
        }
    }

    /**
     * Calculate the required crafting jobs and their dependencies for the given instance in the given network.
     * @param network The target network.
     * @param channel The target channel.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to craft.
     * @param matchCondition The match condition of the instance.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param identifierGenerator identifierGenerator An ID generator for crafting jobs.
     * @param craftingJobsGraph The target graph where all dependencies will be stored.
     * @param collectMissingRecipes If the missing recipes should be collected inside
     *                              {@link UnknownCraftingRecipeException}.
     *                              This may slow down calculation for deeply nested recipe graphs.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The crafting job for the given instance.
     * @throws UnknownCraftingRecipeException If the recipe for a (sub)ingredient is unavailable.
     * @throws RecursiveCraftingRecipeException If an infinite recursive recipe was detected.
     */
    public static <T, M> CraftingJob calculateCraftingJobs(INetwork network, int channel,
                                                           IngredientComponent<T, M> ingredientComponent,
                                                           T instance, M matchCondition, boolean craftMissing,
                                                           IIdentifierGenerator identifierGenerator,
                                                           CraftingJobDependencyGraph craftingJobsGraph,
                                                           boolean collectMissingRecipes)
            throws UnknownCraftingRecipeException, RecursiveCraftingRecipeException {
        ICraftingNetwork craftingNetwork = getCraftingNetworkChecked(network);
        IRecipeIndex recipeIndex = craftingNetwork.getRecipeIndex(channel);
        Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter = getNetworkStorageGetter(network, channel, true);
        beforeCalculateCraftingJobs(network, channel);

        CraftingJob craftingJob = calculateCraftingJobs(recipeIndex, channel, storageGetter, ingredientComponent, instance, matchCondition,
                craftMissing, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), identifierGenerator, craftingJobsGraph, Sets.newHashSet(),
                collectMissingRecipes);
        craftingJobsGraph.addCraftingJobId(craftingJob);
        return craftingJob;
    }

    /**
     * Calculate the required crafting jobs and their dependencies for the given instance in the given network.
     * @param network The target network.
     * @param channel The target channel.
     * @param recipe The recipe to calculate a job for.
     * @param amount The amount of times the recipe should be crafted.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param identifierGenerator identifierGenerator An ID generator for crafting jobs.
     * @param craftingJobsGraph The target graph where all dependencies will be stored.
     * @param collectMissingRecipes If the missing recipes should be collected inside
     *                              {@link FailedCraftingRecipeException}.
     *                              This may slow down calculation for deeply nested recipe graphs.
     * @return The crafting job for the given instance.
     * @throws FailedCraftingRecipeException If the recipe could not be crafted due to missing sub-dependencies.
     * @throws RecursiveCraftingRecipeException If an infinite recursive recipe was detected.
     */
    public static CraftingJob calculateCraftingJobs(INetwork network, int channel,
                                                    IRecipeDefinition recipe, int amount, boolean craftMissing,
                                                    IIdentifierGenerator identifierGenerator,
                                                    CraftingJobDependencyGraph craftingJobsGraph,
                                                    boolean collectMissingRecipes)
            throws FailedCraftingRecipeException, RecursiveCraftingRecipeException {
        ICraftingNetwork craftingNetwork = getCraftingNetworkChecked(network);
        IRecipeIndex recipeIndex = craftingNetwork.getRecipeIndex(channel);
        Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter = getNetworkStorageGetter(network, channel, true);
        beforeCalculateCraftingJobs(network, channel);

        PartialCraftingJobCalculation result = calculateCraftingJobs(recipeIndex, channel, storageGetter, recipe, amount,
                craftMissing, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), identifierGenerator, craftingJobsGraph, Sets.newHashSet(),
                collectMissingRecipes);
        if (result.getCraftingJob() == null) {
            throw new FailedCraftingRecipeException(recipe, amount, result.getMissingDependencies(),
                    compressMixedIngredients(new MixedIngredients(result.getIngredientsStorage())), result.getPartialCraftingJobs());
        } else {
            craftingJobsGraph.addCraftingJobId(result.getCraftingJob());
            return result.getCraftingJob();
        }
    }

    /**
     * @return An identifier generator for crafting jobs.
     */
    public static IIdentifierGenerator getGlobalCraftingJobIdentifier() {
        return () -> IntegratedCrafting.globalCounters.getNext("craftingJob");
    }

    /**
     * Calculate the effective quantity for the given instance in the output of the given recipe.
     * @param recipe A recipe.
     * @param ingredientComponent The ingredient component.
     * @param instance An instance.
     * @param matchCondition A match condition.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The effective quantity.
     */
    public static <T, M> long getOutputQuantityForRecipe(IRecipeDefinition recipe,
                                                         IngredientComponent<T, M> ingredientComponent,
                                                         T instance, M matchCondition) {
        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
        return recipe.getOutput().getInstances(ingredientComponent)
                .stream()
                .filter(i -> matcher.matches(i, instance, matchCondition))
                .mapToLong(matcher::getQuantity)
                .sum();
    }

    /**
     * Calculate a crafting job for the given instance.
     *
     * This method is merely an easily-stubbable implementation for the method above,
     * to simplify unit testing.
     *
     * @param recipeIndex The recipe index.
     * @param channel The target channel that will be stored in created crafting jobs.
     * @param storageGetter A callback function to get a storage for the given ingredient component.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to craft.
     * @param matchCondition The match condition of the instance.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param simulatedExtractionMemory This map remembers all extracted instances in simulation mode.
     *                                  This is to make sure that instances can not be extracted multiple times
     *                                  when simulating.
     * @param extractionMemoryReusable Like simulatedExtractionMemory, but it stores the reusable ingredients.
     * @param identifierGenerator An ID generator for crafting jobs.
     * @param craftingJobsGraph The target graph where all dependencies will be stored.
     * @param parentDependencies A set of parent recipe dependencies that are pending.
     *                           This is used to check for infinite recursion in recipes.
     * @param collectMissingRecipes If the missing recipes should be collected inside
     *                              {@link UnknownCraftingRecipeException}.
     *                              This may slow down calculation for deeply nested recipe graphs.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The crafting job for the given instance.
     * @throws UnknownCraftingRecipeException If the recipe for a (sub)ingredient is unavailable.
     * @throws RecursiveCraftingRecipeException If an infinite recursive recipe was detected.
     */
    protected static <T, M> CraftingJob calculateCraftingJobs(IRecipeIndex recipeIndex, int channel,
                                                              Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
                                                              IngredientComponent<T, M> ingredientComponent,
                                                              T instance, M matchCondition, boolean craftMissing,
                                                              Map<IngredientComponent<?, ?>,
                                                                      IngredientCollectionPrototypeMap<?, ?>> simulatedExtractionMemory,
                                                              Map<IngredientComponent<?, ?>,
                                                                      IIngredientCollectionMutable<?, ?>> extractionMemoryReusable,
                                                              IIdentifierGenerator identifierGenerator,
                                                              CraftingJobDependencyGraph craftingJobsGraph,
                                                              Set<IPrototypedIngredient> parentDependencies,
                                                              boolean collectMissingRecipes)
            throws UnknownCraftingRecipeException, RecursiveCraftingRecipeException {
        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
        // This matching condition makes it so that the recipe output does not have to match with the requested input by quantity.
        M quantifierlessCondition = matcher.withoutCondition(matchCondition,
                ingredientComponent.getPrimaryQuantifier().getMatchCondition());
        long instanceQuantity = matcher.getQuantity(instance);

        // Loop over all available recipes, and return the first valid one.
        Iterator<IRecipeDefinition> recipes = recipeIndex.getRecipes(ingredientComponent, instance, quantifierlessCondition);
        List<UnknownCraftingRecipeException> firstMissingDependencies = Lists.newArrayList();
        Map<IngredientComponent<?, ?>, List<?>> firstIngredientsStorage = Collections.emptyMap();
        List<CraftingJob> firstPartialCraftingJobs = Lists.newArrayList();
        RecursiveCraftingRecipeException firstRecursiveException = null;
        while (recipes.hasNext()) {
            IRecipeDefinition recipe = recipes.next();

            // Calculate the quantity for the given instance that the recipe outputs
            long recipeOutputQuantity = getOutputQuantityForRecipe(recipe, ingredientComponent, instance, quantifierlessCondition);
            // Based on the quantity of the recipe output, calculate the amount of required recipe jobs.
            int amount = (int) Math.ceil(((float) instanceQuantity) / (float) recipeOutputQuantity);

            // Calculate jobs for the given recipe
            try {
                PartialCraftingJobCalculation result = calculateCraftingJobs(recipeIndex, channel,
                        storageGetter, recipe, amount, craftMissing,
                        simulatedExtractionMemory, extractionMemoryReusable, identifierGenerator, craftingJobsGraph, parentDependencies,
                        collectMissingRecipes && firstMissingDependencies.isEmpty());
                if (result.getCraftingJob() == null) {
                    firstMissingDependencies = result.getMissingDependencies();
                    firstIngredientsStorage = result.getIngredientsStorage();
                    if (result.getPartialCraftingJobs() != null) {
                        firstPartialCraftingJobs = result.getPartialCraftingJobs();
                    }
                } else {
                    return result.getCraftingJob();
                }
            } catch (RecursiveCraftingRecipeException e) {
                if (firstRecursiveException == null) {
                    firstRecursiveException = e;
                }
                continue;
            }
        }

        if (firstRecursiveException != null) {
            throw firstRecursiveException;
        }

        // No valid recipes were available, so we error or collect the missing instance.
        throw new UnknownCraftingRecipeException(new PrototypedIngredient<>(ingredientComponent, instance, matchCondition),
                matcher.getQuantity(instance), firstMissingDependencies, compressMixedIngredients(new MixedIngredients(firstIngredientsStorage)),
                firstPartialCraftingJobs);
    }

    /**
     * Calculate a crafting job for the given recipe.
     *
     * This method is merely an easily-stubbable implementation for the method above,
     * to simplify unit testing.
     *
     * @param recipeIndex The recipe index.
     * @param channel The target channel that will be stored in created crafting jobs.
     * @param storageGetter A callback function to get a storage for the given ingredient component.
     * @param recipe The recipe to calculate a job for.
     * @param amount The amount of times the recipe should be crafted.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param simulatedExtractionMemory This map remembers all extracted instances in simulation mode.
     *                                  This is to make sure that instances can not be extracted multiple times
     *                                  when simulating.
     * @param extractionMemoryReusable Like simulatedExtractionMemory, but it stores the reusable ingredients.
     * @param identifierGenerator An ID generator for crafting jobs.
     * @param craftingJobsGraph The target graph where all dependencies will be stored.
     * @param parentDependencies A set of parent recipe dependencies that are pending.
     *                           This is used to check for infinite recursion in recipes.
     * @param collectMissingRecipes If the missing recipes should be collected inside
     *                              {@link UnknownCraftingRecipeException}.
     *                              This may slow down calculation for deeply nested recipe graphs.
     * @return The crafting job for the given instance.
     * @throws RecursiveCraftingRecipeException If an infinite recursive recipe was detected.
     */
    protected static PartialCraftingJobCalculation calculateCraftingJobs(
            IRecipeIndex recipeIndex, int channel,
            Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
            IRecipeDefinition recipe, int amount, boolean craftMissing,
            Map<IngredientComponent<?, ?>,
                    IngredientCollectionPrototypeMap<?, ?>> simulatedExtractionMemory,
            Map<IngredientComponent<?, ?>,
                    IIngredientCollectionMutable<?, ?>> extractionMemoryReusable,
            IIdentifierGenerator identifierGenerator,
            CraftingJobDependencyGraph craftingJobsGraph,
            Set<IPrototypedIngredient> parentDependencies,
            boolean collectMissingRecipes)
            throws RecursiveCraftingRecipeException {
        List<UnknownCraftingRecipeException> missingDependencies = Lists.newArrayList();
        List<CraftingJob> partialCraftingJobs = Lists.newArrayList();

        // Check if all requirements are met for this recipe, if so return directly (don't schedule yet)
        Pair<Map<IngredientComponent<?, ?>, List<?>>, Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>>> simulation =
                getRecipeInputs(storageGetter, recipe, true, simulatedExtractionMemory, extractionMemoryReusable,
                        true, amount);
        Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>> missingIngredients = simulation.getRight();
        if (!craftMissing && !missingIngredients.isEmpty()) {
            if (collectMissingRecipes) {
                // Collect missing ingredients as missing recipes when we don't want to craft sub-components,
                // but they are missing.
                for (Map.Entry<IngredientComponent<?, ?>, MissingIngredients<?, ?>> entry : missingIngredients.entrySet()) {
                    for (MissingIngredients.Element<?, ?> element : entry.getValue().getElements()) {
                        MissingIngredients.PrototypedWithRequested<?, ?> alternative = element.getAlternatives().get(0);

                        // Calculate the instance that was available in storage
                        IngredientComponent<?, ?> component = alternative.getRequestedPrototype().getComponent();
                        IIngredientMatcher matcher = component.getMatcher();
                        long storedQuantity = matcher.getQuantity(alternative.getRequestedPrototype().getPrototype()) - alternative.getQuantityMissing();
                        Map<IngredientComponent<?, ?>, List<?>> storageMap;
                        if (storedQuantity > 0) {
                            storageMap = Maps.newIdentityHashMap();
                            storageMap.put(component, Collections.singletonList(
                                    matcher.withQuantity(alternative.getRequestedPrototype().getPrototype(), storedQuantity)
                            ));
                        } else {
                            storageMap = Collections.emptyMap();
                        }

                        missingDependencies.add(new UnknownCraftingRecipeException(
                                alternative.getRequestedPrototype(), alternative.getQuantityMissing(),
                                Collections.emptyList(), compressMixedIngredients(new MixedIngredients(storageMap)), Lists.newArrayList()));
                    }
                }
            }
            return new PartialCraftingJobCalculation(null, missingDependencies, simulation.getLeft(), null);
        }

        // For all missing ingredients, recursively call this method for all missing items, and add as dependencies
        // We store dependencies as a mapping from recipe to job,
        // so that only one job exist per unique recipe,
        // so that a job amount can be incremented once another equal recipe is found.
        Map<IRecipeDefinition, CraftingJob> dependencies = Maps.newHashMapWithExpectedSize(missingIngredients.size());
        Map<IngredientComponent<?, ?>, IngredientCollectionPrototypeMap<?, ?>> dependenciesOutputSurplus = Maps.newIdentityHashMap();
        // We must be able to find crafting jobs for all dependencies
        for (IngredientComponent dependencyComponent : missingIngredients.keySet()) {
            try {
                // TODO: if we run into weird simulated extraction bugs, we may have to scope simulatedExtractionMemory, but I'm not sure about this (yet)
                PartialCraftingJobCalculationDependency resultDependency = calculateCraftingJobDependencyComponent(
                        dependencyComponent, dependenciesOutputSurplus, missingIngredients.get(dependencyComponent), parentDependencies,
                        dependencies, recipeIndex, channel, storageGetter, simulatedExtractionMemory, extractionMemoryReusable,
                        identifierGenerator, craftingJobsGraph, collectMissingRecipes);
                // Don't check the other components once we have an invalid dependency.
                if (!resultDependency.isValid()) {
                    missingDependencies.addAll(resultDependency.getUnknownCrafingRecipes());
                    partialCraftingJobs.addAll(resultDependency.getPartialCraftingJobs());
                    if (!collectMissingRecipes) {
                        break;
                    }
                }
            } catch (RecursiveCraftingRecipeException e) {
                e.addRecipe(recipe);
                throw e;
            }
        }
        // Add remaining surplus as negatives to simulated extraction
        for (IngredientComponent<?, ?> surplusComponent : dependenciesOutputSurplus.keySet()) {
            IngredientCollectionPrototypeMap<?, ?> surplusInstances = dependenciesOutputSurplus.get(surplusComponent);
            if (surplusInstances != null) {
                for (Object instance : surplusInstances) {
                    IngredientCollectionPrototypeMap<?, ?> simulatedExtractionMemoryInstances = simulatedExtractionMemory.get(surplusComponent);
                    if (simulatedExtractionMemoryInstances == null) {
                        simulatedExtractionMemoryInstances = new IngredientCollectionPrototypeMap<>(surplusComponent, true);
                        simulatedExtractionMemory.put(surplusComponent, simulatedExtractionMemoryInstances);
                    }
                    ((IngredientCollectionPrototypeMap) simulatedExtractionMemoryInstances).remove(instance);
                }
            }
        }

        // If at least one of our dependencies does not have a valid recipe or is not available,
        // go check the next recipe.
        if (!missingDependencies.isEmpty()) {
            return new PartialCraftingJobCalculation(null, missingDependencies, simulation.getLeft(), partialCraftingJobs);
        }

        CraftingJob craftingJob = new CraftingJob(identifierGenerator.getNext(), channel, recipe, amount,
                compressMixedIngredients(new MixedIngredients(simulation.getLeft())));
        for (CraftingJob dependency : dependencies.values()) {
            craftingJob.addDependency(dependency);
            craftingJobsGraph.addDependency(craftingJob, dependency);
        }
        return new PartialCraftingJobCalculation(craftingJob, null, simulation.getLeft(), null);
    }

    // Helper function for calculateCraftingJobs, returns a list of non-craftable ingredients and craftable ingredients.
    protected static <T, M> PartialCraftingJobCalculationDependency calculateCraftingJobDependencyComponent(
            IngredientComponent<T, M> dependencyComponent,
            Map<IngredientComponent<?, ?>, IngredientCollectionPrototypeMap<?, ?>> dependenciesOutputSurplus,
            MissingIngredients<T, M> missingIngredients,
            Set<IPrototypedIngredient> parentDependencies,
            Map<IRecipeDefinition, CraftingJob> dependencies,
            IRecipeIndex recipeIndex,
            int channel,
            Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
            Map<IngredientComponent<?, ?>,
                    IngredientCollectionPrototypeMap<?, ?>> simulatedExtractionMemory,
            Map<IngredientComponent<?, ?>,
                    IIngredientCollectionMutable<?, ?>> extractionMemoryReusable,
            IIdentifierGenerator identifierGenerator,
            CraftingJobDependencyGraph craftingJobsGraph,
            boolean collectMissingRecipes)
            throws RecursiveCraftingRecipeException {
        IIngredientMatcher<T, M> dependencyMatcher = dependencyComponent.getMatcher();
        List<UnknownCraftingRecipeException> missingDependencies = Lists.newArrayList();
        for (MissingIngredients.Element<T, M> missingElement : missingIngredients.getElements()) {
            CraftingJob dependency = null;
            T dependencyInstance = null;
            boolean skipDependency = false;
            UnknownCraftingRecipeException firstError = null;
            // Loop over all prototype alternatives, at least one has to match.
            for (MissingIngredients.PrototypedWithRequested<T, M> prototypedAlternative : missingElement.getAlternatives()) {
                // Check if the missing element is reusable, and was triggered for craft earlier.
                if (missingElement.isInputReusable() && ((IIngredientCollectionMutable<T, M>) extractionMemoryReusable.get(dependencyComponent))
                        .contains(prototypedAlternative.getRequestedPrototype().getPrototype())) {
                    // Nothing has to be crafted anymore, jump to next dependency
                    skipDependency = true;
                    break;
                }

                IPrototypedIngredient<T, M> prototype = new PrototypedIngredient<>(
                        dependencyComponent,
                        dependencyMatcher.withQuantity(prototypedAlternative.getRequestedPrototype().getPrototype(), prototypedAlternative.getQuantityMissing()),
                        prototypedAlternative.getRequestedPrototype().getCondition()
                );
                // First check if we can grab it from previous surplus
                IngredientCollectionPrototypeMap<T, M> dependencyComponentSurplusOld = (IngredientCollectionPrototypeMap<T, M>) dependenciesOutputSurplus.get(dependencyComponent);
                IngredientCollectionPrototypeMap<T, M> dependencyComponentSurplus = null;
                if (dependencyComponentSurplusOld != null) {
                    // First create a copy of the given surplus store,
                    // and only once we see that the prototype is valid,
                    // save this copy again.
                    // This is because if this prototype is invalid,
                    // then we don't want these invalid surpluses.
                    dependencyComponentSurplus = new IngredientCollectionPrototypeMap<>(dependencyComponentSurplusOld.getComponent(), true);
                    dependencyComponentSurplus.addAll(dependencyComponentSurplusOld);

                    long remainingQuantity = dependencyMatcher.getQuantity(prototype.getPrototype());
                    IIngredientMatcher<T, M> prototypeMatcher = prototype.getComponent().getMatcher();
                    // Check all instances in the surplus that match with the given prototype
                    // For each match, we subtract its quantity from the required quantity.
                    Iterator<T> surplusIt = dependencyComponentSurplus.iterator(prototype.getPrototype(),
                            prototypeMatcher.withoutCondition(prototype.getCondition(), prototype.getComponent().getPrimaryQuantifier().getMatchCondition()));
                    boolean updatedRemainingQuantity = false;
                    while (remainingQuantity > 0 && surplusIt.hasNext()) {
                        updatedRemainingQuantity = true;
                        T matchingInstance = surplusIt.next();
                        long matchingInstanceQuantity = dependencyMatcher.getQuantity(matchingInstance);
                        if (matchingInstanceQuantity <= remainingQuantity) {
                            // This whole surplus instance can be consumed
                            remainingQuantity -= matchingInstanceQuantity;
                            surplusIt.remove();
                        } else {
                            // Only part of this surplus instance can be consumed.
                            matchingInstanceQuantity -= remainingQuantity;
                            remainingQuantity = 0;
                            surplusIt.remove();
                            dependencyComponentSurplus.setQuantity(matchingInstance, matchingInstanceQuantity);
                        }
                    }
                    if (updatedRemainingQuantity) {
                        if (remainingQuantity == 0) {
                            // The prototype is valid,
                            // so we can finally store our temporary surplus
                            dependenciesOutputSurplus.put(dependencyComponent, dependencyComponentSurplus);

                            // Nothing has to be crafted anymore, jump to next dependency
                            skipDependency = true;
                            break;
                        } else {
                            // Partial availability, other part needs to be crafted still.
                            prototype = new PrototypedIngredient<>(dependencyComponent,
                                    dependencyMatcher.withQuantity(prototype.getPrototype(), remainingQuantity),
                                    prototype.getCondition());
                        }
                    }
                }

                // Try to craft the given prototype
                try {
                    Set<IPrototypedIngredient> childDependencies = Sets.newHashSet(parentDependencies);
                    IPrototypedIngredient<T, M> dependencyPrototype = prototype;
                    if (dependencyMatcher.getQuantity(dependencyPrototype.getPrototype()) != 1) {
                        // Ensure 1-quantity is stored, for proper comparisons in future calls.
                        dependencyPrototype = new PrototypedIngredient<>(dependencyComponent,
                                dependencyMatcher.withQuantity(prototype.getPrototype(), 1),
                                prototype.getCondition());
                    }
                    if (!childDependencies.add(dependencyPrototype)) {
                        throw new RecursiveCraftingRecipeException(prototype);
                    }

                    dependency = calculateCraftingJobs(recipeIndex, channel, storageGetter,
                            dependencyComponent, prototype.getPrototype(),
                            prototype.getCondition(), true, simulatedExtractionMemory, extractionMemoryReusable,
                            identifierGenerator, craftingJobsGraph, childDependencies, collectMissingRecipes);
                    dependencyInstance = prototype.getPrototype();

                    // The prototype is valid,
                    // so we can finally store our temporary surplus
                    if (dependencyComponentSurplus != null) {
                        dependenciesOutputSurplus.put(dependencyComponent, dependencyComponentSurplus);
                    }

                    // Add the auxiliary recipe outputs that are not requested to the surplus
                    Object dependencyQuantifierlessCondition = dependencyMatcher.withoutCondition(prototype.getCondition(),
                            dependencyComponent.getPrimaryQuantifier().getMatchCondition());
                    long requestedQuantity = dependencyMatcher.getQuantity(prototype.getPrototype());
                    for (IngredientComponent outputComponent : dependency.getRecipe().getOutput().getComponents()) {
                        IngredientCollectionPrototypeMap<?, ?> componentSurplus = dependenciesOutputSurplus.get(outputComponent);
                        if (componentSurplus == null) {
                            componentSurplus = new IngredientCollectionPrototypeMap<>(outputComponent, true);
                            dependenciesOutputSurplus.put(outputComponent, componentSurplus);
                        }
                        List<Object> instances = dependency.getRecipe().getOutput().getInstances(outputComponent);
                        long recipeAmount = dependency.getAmount();
                        if (recipeAmount > 1) {
                            IIngredientMatcher matcher = outputComponent.getMatcher();
                            // If more than one recipe amount was crafted, correctly multiply the outputs to calculate the effective surplus.
                            instances = instances
                                    .stream()
                                    .map(instance -> matcher.withQuantity(instance, matcher.getQuantity(instance) * recipeAmount))
                                    .collect(Collectors.toList());
                        }
                        addRemainderAsSurplusForComponent(outputComponent, (List) instances, componentSurplus,
                                (IngredientComponent) prototype.getComponent(), prototype.getPrototype(), dependencyQuantifierlessCondition,
                                requestedQuantity);
                    }

                    break;
                } catch (UnknownCraftingRecipeException e) {
                    // Save the first error, and check the next prototype
                    if (firstError == null) {
                        // Modify the error so that the correct missing quantity is stored
                        firstError = new UnknownCraftingRecipeException(
                                e.getIngredient(), prototypedAlternative.getQuantityMissing(),
                                e.getMissingChildRecipes(), compressMixedIngredients(e.getIngredientsStorage()), e.getPartialCraftingJobs());
                    }
                }
            }

            // Check if this dependency can be skipped
            if (skipDependency) {
                continue;
            }

            // If no valid crafting recipe was found for the current sub-instance, re-throw its error
            if (dependency == null) {
                missingDependencies.add(firstError);
                if (collectMissingRecipes) {
                    continue;
                } else {
                    break;
                }
            }

            // --- When we reach this point, a valid sub-recipe was found ---

            // Update our simulatedExtractionMemory to indicate that the dependency's
            // instance should not be extracted anymore.
            ((IngredientCollectionPrototypeMap<T, M>) simulatedExtractionMemory.get(dependencyComponent))
                    .remove(dependencyInstance);

            // If the dependency instance is reusable, mark it as available in our reusable extraction memory
            if (missingElement.isInputReusable()) {
                ((IIngredientCollectionMutable<T, M>) extractionMemoryReusable.get(dependencyComponent)).add(dependencyInstance);
            }

            // Add the valid sub-recipe it to our dependencies
            // If the recipe was already present at this level, just increment the amount of the existing job.
            CraftingJob existingJob = dependencies.get(dependency.getRecipe());
            if (existingJob == null) {
                dependencies.put(dependency.getRecipe(), dependency);
            } else {
                // Remove the standalone dependency job by merging it into the existing job
                craftingJobsGraph.mergeCraftingJobs(existingJob, dependency, true);
            }
        }

        return new PartialCraftingJobCalculationDependency(missingDependencies, dependencies.values());
    }

    // Helper function for calculateCraftingJobDependencyComponent
    protected static <T1, M1, T2, M2> void addRemainderAsSurplusForComponent(IngredientComponent<T1, M1> ingredientComponent,
                                                                             List<T1> instances,
                                                                             IngredientCollectionPrototypeMap<T1, M1> simulatedExtractionMemory,
                                                                             IngredientComponent<T2, M2> blackListComponent,
                                                                             T2 blacklistInstance, M2 blacklistCondition,
                                                                             long blacklistQuantity) {
        IIngredientMatcher<T2, M2> blacklistMatcher = blackListComponent.getMatcher();
        for (T1 instance : instances) {
            IIngredientMatcher<T1, M1> outputMatcher = ingredientComponent.getMatcher();
            long reduceQuantity = 0;
            if (blackListComponent == ingredientComponent
                    && blacklistMatcher.matches(blacklistInstance, (T2) instance, blacklistCondition)) {
                reduceQuantity = blacklistQuantity;
            }
            long quantity = simulatedExtractionMemory.getQuantity(instance) + (outputMatcher.getQuantity(instance) - reduceQuantity);
            if (quantity > 0) {
                simulatedExtractionMemory.setQuantity(instance, quantity);
            }
        }
    }

    /**
     * Schedule all crafting jobs in the given dependency graph in the given network.
     *
     * @param craftingNetwork            The target crafting network.
     * @param storageGetter              The storage getter.
     * @param craftingJobDependencyGraph The crafting job dependency graph.
     * @param allowDistribution          If the crafting jobs are allowed to be split over multiple crafting interfaces.
     * @param initiator                  Optional UUID of the initiator.
     * @throws UnavailableCraftingInterfacesException If no crafting interfaces were available.
     */
    public static void scheduleCraftingJobs(ICraftingNetwork craftingNetwork,
                                            Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
                                            CraftingJobDependencyGraph craftingJobDependencyGraph,
                                            boolean allowDistribution,
                                            @Nullable UUID initiator) throws UnavailableCraftingInterfacesException {
        List<CraftingJob> startedJobs = Lists.newArrayList();
        craftingNetwork.getCraftingJobDependencyGraph().importDependencies(craftingJobDependencyGraph);
        for (CraftingJob craftingJob : craftingJobDependencyGraph.getCraftingJobs()) {
            try {
                craftingNetwork.scheduleCraftingJob(craftingJob, allowDistribution, storageGetter);
            } catch (StorageExtractionException | UnavailableCraftingInterfacesException e) {
                // First, cancel all jobs that were already started
                for (CraftingJob startedJob : startedJobs) {
                    CraftingHelpers.insertIngredientsGuaranteed(startedJob.getIngredientsStorageBuffer(), storageGetter, (ICraftingResultsSink) Iterables.getFirst(craftingNetwork.getCraftingInterfaces(startedJob.getChannel()), null));
                    craftingNetwork.cancelCraftingJob(startedJob.getChannel(), startedJob.getId());
                }

                // Then, throw an exception for all jobs in this dependency graph
                throw new UnavailableCraftingInterfacesException(craftingJobDependencyGraph.getCraftingJobs());
            }
            startedJobs.add(craftingJob);
            if (initiator != null) {
                craftingJob.setInitiatorUuid(initiator.toString());
            }
        }
    }

    /**
     * Schedule the given crafting job  in the given network.
     *
     * @param craftingNetwork   The target crafting network.
     * @param storageGetter     The storage getter.
     * @param craftingJob       The crafting job to schedule.
     * @param allowDistribution If the crafting job is allowed to be split over multiple crafting interfaces.
     * @param initiator         Optional UUID of the initiator.
     * @return The scheduled crafting job.
     * @throws UnavailableCraftingInterfacesException If no crafting interfaces were available.
     * @throws StorageExtractionException             If storage extraction failed.
     */
    public static CraftingJob scheduleCraftingJob(ICraftingNetwork craftingNetwork,
                                                  Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
                                                  CraftingJob craftingJob,
                                                  boolean allowDistribution,
                                                  @Nullable UUID initiator) throws UnavailableCraftingInterfacesException, StorageExtractionException {
        craftingNetwork.scheduleCraftingJob(craftingJob, allowDistribution, storageGetter);
        if (initiator != null) {
            craftingJob.setInitiatorUuid(initiator.toString());
        }
        return craftingJob;
    }

    /**
     * Schedule a crafting job for the given instance in the given network.
     * @param network The target network.
     * @param channel The target channel.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to craft.
     * @param matchCondition The match condition of the instance.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param allowDistribution If the crafting job is allowed to be split over multiple crafting interfaces.
     * @param identifierGenerator An ID generator for crafting jobs.
     * @param initiator Optional UUID of the initiator.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The scheduled crafting job, or null if no recipe was found.
     */
    @Nullable
    public static <T, M> CraftingJob calculateAndScheduleCraftingJob(INetwork network, int channel,
                                                                     IngredientComponent<T, M> ingredientComponent,
                                                                     T instance, M matchCondition,
                                                                     boolean craftMissing, boolean allowDistribution,
                                                                     IIdentifierGenerator identifierGenerator,
                                                                     @Nullable UUID initiator) {
        try {
            CraftingJobDependencyGraph dependencyGraph = new CraftingJobDependencyGraph();
            CraftingJob craftingJob = calculateCraftingJobs(network, channel, ingredientComponent, instance,
                    matchCondition, craftMissing, identifierGenerator, dependencyGraph, false);

            ICraftingNetwork craftingNetwork = getCraftingNetworkChecked(network);

            scheduleCraftingJobs(craftingNetwork, getNetworkStorageGetter(network, channel, false), dependencyGraph, allowDistribution, initiator);

            return craftingJob;
        } catch (UnknownCraftingRecipeException | RecursiveCraftingRecipeException | UnavailableCraftingInterfacesException e) {
            return null;
        }
    }

    /**
     * Schedule a crafting job for the given recipe in the given network.
     * @param network The target network.
     * @param channel The target channel.
     * @param recipe The recipe to craft.
     * @param amount The amount to craft.
     * @param craftMissing If the missing required ingredients should also be crafted.
     * @param allowDistribution If the crafting job is allowed to be split over multiple crafting interfaces.
     * @param identifierGenerator An ID generator for crafting jobs.
     * @param initiator Optional UUID of the initiator.
     * @return The scheduled crafting job, or null if no recipe was found.
     */
    @Nullable
    public static CraftingJob calculateAndScheduleCraftingJob(INetwork network, int channel,
                                                              IRecipeDefinition recipe, int amount,
                                                              boolean craftMissing, boolean allowDistribution,
                                                              IIdentifierGenerator identifierGenerator,
                                                              @Nullable UUID initiator) {
        try {
            CraftingJobDependencyGraph dependencyGraph = new CraftingJobDependencyGraph();
            CraftingJob craftingJob = calculateCraftingJobs(network, channel, recipe, amount, craftMissing,
                    identifierGenerator, dependencyGraph, false);

            ICraftingNetwork craftingNetwork = getCraftingNetworkChecked(network);

            scheduleCraftingJobs(craftingNetwork, getNetworkStorageGetter(network, channel, false), dependencyGraph, allowDistribution, initiator);

            return craftingJob;
        } catch (RecursiveCraftingRecipeException | FailedCraftingRecipeException | UnavailableCraftingInterfacesException e) {
            return null;
        }
    }

    /**
     * Check if the given network contains the given instance in any of its storages.
     * @param network The target network.
     * @param channel The target channel.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to check.
     * @param matchCondition The match condition of the instance.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return If the instance is present in the network.
     */
    public static <T, M> boolean hasStorageInstance(INetwork network, int channel,
                                                    IngredientComponent<T, M> ingredientComponent,
                                                    T instance, M matchCondition) {
        IIngredientComponentStorage<T, M> storage = getNetworkStorage(network, channel, ingredientComponent, true);
        if (storage instanceof IngredientChannelAdapter) ((IngredientChannelAdapter) storage).disableLimits();
        boolean contains;
        if (storage instanceof IngredientChannelIndexed) {
            IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
            long quantityPresent = ((IngredientChannelIndexed<T, M>) storage).getIndex().getQuantity(instance);
            contains = matcher.hasCondition(matchCondition, ingredientComponent.getPrimaryQuantifier().getMatchCondition()) ? quantityPresent >= matcher.getQuantity(instance) : quantityPresent > 0;
        } else {
            contains = !ingredientComponent.getMatcher().isEmpty(storage.extract(instance, matchCondition, true));
        }
        if (storage instanceof IngredientChannelAdapter) ((IngredientChannelAdapter) storage).enableLimits();
        return contains;
    }

    /**
     * Check the quantity of the given instance in the network.
     * @param network The target network.
     * @param channel The target channel.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to check.
     * @param matchCondition The match condition of the instance.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return The quantity in the network.
     */
    public static <T, M> long getStorageInstanceQuantity(INetwork network, int channel,
                                                         IngredientComponent<T, M> ingredientComponent,
                                                         T instance, M matchCondition) {
        IIngredientComponentStorage<T, M> storage = getNetworkStorage(network, channel, ingredientComponent, true);
        if (storage instanceof IngredientChannelAdapter) ((IngredientChannelAdapter) storage).disableLimits();
        long quantityPresent;
        if (storage instanceof IngredientChannelIndexed) {
            quantityPresent = ((IngredientChannelIndexed<T, M>) storage).getIndex().getQuantity(instance);
        } else {
            quantityPresent = ingredientComponent.getMatcher().getQuantity(storage.extract(instance, matchCondition, true));
        }
        if (storage instanceof IngredientChannelAdapter) ((IngredientChannelAdapter) storage).enableLimits();
        return quantityPresent;
    }

    /**
     * Check if there is a scheduled crafting job for the given instance.
     * @param craftingNetwork The target crafting network.
     * @param channel The target channel.
     * @param ingredientComponent The ingredient component type of the instance.
     * @param instance The instance to check.
     * @param matchCondition The match condition of the instance.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return If the instance has a crafting job.
     */
    public static <T, M> boolean isCrafting(ICraftingNetwork craftingNetwork, int channel,
                                            IngredientComponent<T, M> ingredientComponent,
                                            T instance, M matchCondition) {
        Iterator<CraftingJob> craftingJobs = craftingNetwork.getCraftingJobs(channel, ingredientComponent,
                instance, matchCondition);
        return craftingJobs.hasNext();
    }

    /**
     * Check if there is a scheduled crafting job for the given recipe.
     * @param craftingNetwork The target crafting network.
     * @param channel The target channel.
     * @param recipe The recipe to check.
     * @return If the instance has a crafting job.
     */
    public static boolean isCrafting(ICraftingNetwork craftingNetwork, int channel,
                                     IRecipeDefinition recipe) {
        Iterator<CraftingJob> it = craftingNetwork.getCraftingJobs(channel);
        while (it.hasNext()) {
            if (it.next().getRecipe().equals(recipe)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Get all required recipe input ingredients from the network for the given ingredient component.
     *
     * If multiple alternative inputs are possible,
     * then only the first possible match will be taken.
     *
     * Note: Make sure that you first call in simulation-mode
     * to see if the ingredients are available.
     * If you immediately call this non-simulated,
     * then there might be a chance that ingredients are lost
     * from the network.
     *
     * @param storage The target storage.
     * @param ingredientComponent The ingredient component to get the ingredients for.
     * @param recipe The recipe to get the inputs from.
     * @param simulate If true, then the ingredients will effectively be removed from the network, not when false.
     * @param recipeOutputQuantity The number of times the given recipe should be applied.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter, may be Void.
     * @return A list of slot-based ingredients, or null if no valid inputs could be found.
     */
    @Nullable
    public static <T, M> List<T> getIngredientRecipeInputs(IIngredientComponentStorage<T, M> storage,
                                                           IngredientComponent<T, M> ingredientComponent,
                                                           IRecipeDefinition recipe, boolean simulate,
                                                           long recipeOutputQuantity) {
        return getIngredientRecipeInputs(storage, ingredientComponent, recipe, simulate,
                simulate ? new IngredientCollectionPrototypeMap<>(ingredientComponent, true) : null,
                new IngredientHashSet<>(ingredientComponent),
                false, recipeOutputQuantity).getLeft();
    }

    /**
     * Get all required recipe input ingredients from the network for the given ingredient component,
     * and optionally, explicitly calculate the missing ingredients.
     *
     * If multiple alternative inputs are possible,
     * then only the first possible match will be taken.
     *
     * Note: Make sure that you first call in simulation-mode
     * to see if the ingredients are available.
     * If you immediately call this non-simulated,
     * then there might be a chance that ingredients are lost
     * from the network.
     *
     * @param storage The target storage.
     * @param ingredientComponent The ingredient component to get the ingredients for.
     * @param recipe The recipe to get the inputs from.
     * @param simulate If true, then the ingredients will effectively be removed from the network, not when false.
     * @param simulatedExtractionMemory This map remembers all extracted instances in simulation mode.
     *                                  This is to make sure that instances can not be extracted multiple times
     *                                  when simulating.
     *                                  The quantities can also go negatives,
     *                                  which means that a surplus of the given instance is present,
     *                                  which will be used up first before a call to the storage.
     * @param extractionMemoryReusable Like simulatedExtractionMemory, but it stores the reusable ingredients.
     * @param collectMissingIngredients If missing ingredients should be collected.
     *                                  If false, then the first returned list may be null
     *                                  if no valid matches can be found,
     *                                  and the second returned list is always null,
     * @param recipeOutputQuantity The number of times the given recipe should be applied.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter, may be Void.
     * @return A pair with two lists:
     *           1. A list of available slot-based ingredients.
     *           2. A missing ingredients object.
     */
    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) {
        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();

        // Quickly return if the storage is empty
        // We can't take this shortcut if we have a reusable ingredient AND extractionMemoryReusable is not empty
        if (storage.getMaxQuantity() == 0 &&
                extractionMemoryReusable.isEmpty() &&
                IntStream.range(0, recipe.getInputs(ingredientComponent).size())
                        .noneMatch(i -> recipe.isInputReusable(ingredientComponent, i))) {
            if (collectMissingIngredients) {
                List<IPrototypedIngredientAlternatives<T, M>> recipeInputs = recipe.getInputs(ingredientComponent);
                MissingIngredients<T, M> missing = new MissingIngredients<>(recipeInputs.stream().map(IPrototypedIngredientAlternatives::getAlternatives)
                        .map(l -> multiplyPrototypedIngredients(l, recipeOutputQuantity)) // If the input is reusable, don't multiply the expected input quantity
                        .map(ps -> new MissingIngredients.Element<>(ps
                                .stream()
                                .map(p -> new MissingIngredients.PrototypedWithRequested<>(p, matcher.getQuantity(p.getPrototype())))
                                .collect(Collectors.toList()), false)
                        )
                        .collect(Collectors.toList()));
                return Pair.of(
                        Lists.newArrayList(Collections.nCopies(recipe.getInputs(ingredientComponent).size(),
                                ingredientComponent.getMatcher().getEmptyInstance())),
                        missing);
            } else {
                return Pair.of(null, null);
            }
        }

        // Iterate over all input slots
        List<IPrototypedIngredientAlternatives<T, M>> inputAlternativePrototypes = recipe.getInputs(ingredientComponent);
        List<T> inputInstances = Lists.newArrayList();
        List<MissingIngredients.Element<T, M>> missingElements =
                collectMissingIngredients ? Lists.newArrayList() : null;
        for (int inputIndex = 0; inputIndex < inputAlternativePrototypes.size(); inputIndex++) {
            IPrototypedIngredientAlternatives<T, M> inputPrototypes = inputAlternativePrototypes.get(inputIndex);
            T firstInputInstance = null;
            boolean setFirstInputInstance = false;
            T inputInstance = null;
            boolean hasInputInstance = false;
            IngredientCollectionPrototypeMap<T, M> simulatedExtractionMemoryBufferFirst = null;
            IIngredientCollectionMutable<T, M> extractionMemoryReusableBufferFirst = null;

            // Iterate over all alternatives for this input slot, and take the first matching ingredient.
            List<MissingIngredients.PrototypedWithRequested<T, M>> missingAlternatives = Lists.newArrayList();
            IngredientCollectionPrototypeMap<T, M> simulatedExtractionMemoryAlternative = simulate ? new IngredientCollectionPrototypeMap<>(ingredientComponent, true) : null;
            if (simulate) {
                simulatedExtractionMemoryAlternative.addAll(simulatedExtractionMemory);
            }
            for (IPrototypedIngredient<T, M> inputPrototype : inputPrototypes.getAlternatives()) {
                boolean inputReusable = recipe.isInputReusable(ingredientComponent, inputIndex);
                IngredientCollectionPrototypeMap<T, M> simulatedExtractionMemoryBuffer = simulate ? new IngredientCollectionPrototypeMap<>(ingredientComponent, true) : null;
                IIngredientCollectionMutable<T, M> extractionMemoryReusableBuffer = inputReusable ? new IngredientHashSet<>(ingredientComponent) : null;
                boolean shouldBreak = false;

                // Multiply required prototype if recipe quantity is higher than one, AND if the input is NOT reusable.
                if (recipeOutputQuantity > 1 && !inputReusable) {
                    inputPrototype = multiplyPrototypedIngredient(inputPrototype, recipeOutputQuantity);
                }

                // If the prototype is empty, we can skip network extraction
                if (matcher.isEmpty(inputPrototype.getPrototype())) {
                    inputInstance = inputPrototype.getPrototype();
                    hasInputInstance = true;
                    break;
                }

                long prototypeQuantity = matcher.getQuantity(inputPrototype.getPrototype());
                if (inputReusable && extractionMemoryReusable.contains(inputPrototype.getPrototype())) {
                    // If the reusable item has been extracted before, mark as valid, and don't extract again.
                    inputInstance = inputPrototype.getComponent().getMatcher().getEmptyInstance();
                    hasInputInstance = true;
                    shouldBreak = true;
                } else {
                    long memoryQuantity;
                    if (simulate && (memoryQuantity = simulatedExtractionMemoryAlternative
                            .getQuantity(inputPrototype.getPrototype())) != 0) {
                        long newQuantity = memoryQuantity + prototypeQuantity;
                        if (newQuantity > 0) {
                            // Part of our quantity can be provided via simulatedExtractionMemory,
                            // but not all of it,
                            // so we need to extract from storage as well.
                            T newInstance = matcher.withQuantity(inputPrototype.getPrototype(), newQuantity);
                            M matchCondition = matcher.withoutCondition(inputPrototype.getCondition(),
                                    ingredientComponent.getPrimaryQuantifier().getMatchCondition());
                            if (storage instanceof IngredientChannelAdapter)
                                ((IngredientChannelAdapter) storage).disableLimits();
                            T extracted = storage.extract(newInstance, matchCondition, true);
                            if (storage instanceof IngredientChannelAdapter)
                                ((IngredientChannelAdapter) storage).enableLimits();
                            long quantityExtracted = matcher.getQuantity(extracted);
                            if (quantityExtracted == newQuantity) {
                                // All remaining could be extracted from storage, all is fine now
                                inputInstance = inputPrototype.getPrototype();
                                simulatedExtractionMemoryAlternative.add(inputInstance);
                                simulatedExtractionMemoryBuffer.add(inputInstance);
                                if (inputReusable) {
                                    extractionMemoryReusableBuffer.add(inputInstance);
                                }
                                hasInputInstance = true;
                                shouldBreak = true;
                            } else if (collectMissingIngredients) {
                                // Not everything could be extracted from storage, we *miss* the remaining ingredient.
                                long quantityMissingPrevious = Math.max(0, memoryQuantity - quantityExtracted);
                                long quantityMissingTotal = newQuantity - quantityExtracted;
                                long quantityMissingRelative = quantityMissingTotal - quantityMissingPrevious;

                                missingAlternatives.add(new MissingIngredients.PrototypedWithRequested<>(inputPrototype, quantityMissingRelative));
                                inputInstance = matcher.withQuantity(inputPrototype.getPrototype(), prototypeQuantity - quantityMissingRelative);
                                simulatedExtractionMemoryAlternative.setQuantity(inputPrototype.getPrototype(), quantityMissingTotal);
                                // Original prototype quantity because we what can be extracted from storage and what could NOT be extracted from storage should be added to the simulation extraction memory.
                                // The part that could NOT be extracted will be removed later when crafting jobs are calculated for the missing elements. (not doing so would lead to over-estimation of what is in storage)
                                simulatedExtractionMemoryBuffer.add(matcher.withQuantity(inputPrototype.getPrototype(), prototypeQuantity));
                            }
                        } else {
                            // All of our quantity can be provided via our surplus in simulatedExtractionMemory
                            simulatedExtractionMemoryAlternative.add(inputPrototype.getPrototype());
                            simulatedExtractionMemoryBuffer.add(inputPrototype.getPrototype());
                            if (inputReusable) {
                                extractionMemoryReusableBuffer.add(inputPrototype.getPrototype());
                            }
                            inputInstance = inputPrototype.getComponent().getMatcher().getEmptyInstance();
                            hasInputInstance = true;
                            shouldBreak = true;
                        }
                    } else {
                        M matchCondition = matcher.withoutCondition(inputPrototype.getCondition(),
                                ingredientComponent.getPrimaryQuantifier().getMatchCondition());
                        if (storage instanceof IngredientChannelAdapter)
                            ((IngredientChannelAdapter) storage).disableLimits();
                        T extracted = storage.extract(inputPrototype.getPrototype(), matchCondition, simulate);
                        if (storage instanceof IngredientChannelAdapter)
                            ((IngredientChannelAdapter) storage).enableLimits();
                        long quantityExtracted = matcher.getQuantity(extracted);
                        inputInstance = extracted;
                        if (simulate) {
                            simulatedExtractionMemoryAlternative.add(extracted);
                            simulatedExtractionMemoryBuffer.add(inputPrototype.getPrototype());
                        }
                        if (prototypeQuantity == quantityExtracted) {
                            hasInputInstance = true;
                            shouldBreak = true;
                            if (inputReusable) {
                                extractionMemoryReusableBuffer.add(inputPrototype.getPrototype());
                            }
                        } else if (collectMissingIngredients) {
                            long quantityMissing = prototypeQuantity - quantityExtracted;
                            missingAlternatives.add(new MissingIngredients.PrototypedWithRequested<>(inputPrototype, quantityMissing));
                        }
                    }
                }

                if (!setFirstInputInstance || shouldBreak) {
                    setFirstInputInstance = true;
                    firstInputInstance = inputInstance;
                    simulatedExtractionMemoryBufferFirst = simulatedExtractionMemoryBuffer;
                    if (inputReusable) {
                        extractionMemoryReusableBufferFirst = extractionMemoryReusableBuffer;
                    } else {
                        extractionMemoryReusableBufferFirst = null;
                    }
                }

                if (shouldBreak) {
                    break;
                }
            }

            if (simulatedExtractionMemoryBufferFirst != null) {
                for (T instance : simulatedExtractionMemoryBufferFirst) {
                    simulatedExtractionMemory.add(instance);
                }
            }
            if (extractionMemoryReusableBufferFirst != null) {
                for (T instance : extractionMemoryReusableBufferFirst) {
                    extractionMemoryReusable.add(instance);
                }
            }

            // If none of the alternatives were found, fail immediately
            if (!hasInputInstance) {
                if (!simulate) {
                    // But first, re-insert all already-extracted instances
                    for (T instance : inputInstances) {
                        T remaining = storage.insert(instance, false);
                        if (!matcher.isEmpty(remaining)) {
                            throw new IllegalStateException("Extraction for a crafting recipe failed" +
                                    "due to inconsistent insertion behaviour by destination in simulation " +
                                    "and non-simulation: " + storage + ". Lost: " + remaining);
                        }
                    }
                }

                if (!collectMissingIngredients) {
                    // This input failed, return immediately
                    return Pair.of(null, null);
                } else {
                    // Multiply missing collection if recipe quantity is higher than one
                    if (missingAlternatives.size() > 0) {
                        missingElements.add(new MissingIngredients.Element<>(missingAlternatives, recipe.isInputReusable(ingredientComponent, inputIndex)));
                    }
                }
            }

            // Otherwise, append it to the list and carry on.
            // If none of the instances were valid, we add the first partially valid instance.
            if (hasInputInstance) {
                inputInstances.add(inputInstance);
            } else if (setFirstInputInstance && !matcher.isEmpty(firstInputInstance)) {
                inputInstances.add(firstInputInstance);
            }
        }

        return Pair.of(
                inputInstances,
                collectMissingIngredients ? new MissingIngredients<>(missingElements) : null
        );
    }

    /**
     * Get all required recipe input ingredients from the network.
     *
     * If multiple alternative inputs are possible,
     * then only the first possible match will be taken.
     *
     * Note: Make sure that you first call in simulation-mode
     * to see if the ingredients are available.
     * If you immediately call this non-simulated,
     * then there might be a chance that ingredients are lost
     * from the network.
     *
     * @param network The target network.
     * @param channel The target channel.
     * @param recipe The recipe to get the inputs from.
     * @param simulate If true, then the ingredients will effectively be removed from the network, not when false.
     * @param recipeOutputQuantity The number of times the given recipe should be applied.
     * @return The found ingredients or null.
     */
    @Nullable
    public static IMixedIngredients getRecipeInputs(INetwork network, int channel,
                                                    IRecipeDefinition recipe, boolean simulate,
                                                    long recipeOutputQuantity) {
        Map<IngredientComponent<?, ?>, List<?>> inputs = getRecipeInputs(getNetworkStorageGetter(network, channel, true),
                recipe, simulate, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), false, recipeOutputQuantity).getLeft();
        return inputs == null ? null : new MixedIngredients(inputs);
    }

    /**
     * Get all required recipe input ingredients from the crafting job's buffer.
     *
     * If multiple alternative inputs are possible,
     * then only the first possible match will be taken.
     *
     * Note: Make sure that you first call in simulation-mode
     * to see if the ingredients are available.
     * If you immediately call this non-simulated,
     * then there might be a chance that ingredients are lost
     * from the buffer.
     *
     * @param craftingJob The crafting job.
     * @param recipe The recipe to get the inputs from.
     * @param simulate If true, then the ingredients will effectively be removed from the buffer, not when false.
     * @param recipeOutputQuantity The number of times the given recipe should be applied.
     * @return The found ingredients or null.
     */
    @Nullable
    public static IMixedIngredients getRecipeInputsFromCraftingJobBuffer(CraftingJob craftingJob,
                                                    IRecipeDefinition recipe, boolean simulate,
                                                    long recipeOutputQuantity) {
        Map<IngredientComponent<?, ?>, List<?>> inputs = getRecipeInputs(getCraftingJobBufferStorageGetter(craftingJob),
                recipe, simulate, Maps.newIdentityHashMap(), Maps.newIdentityHashMap(), false, recipeOutputQuantity).getLeft();
        return inputs == null ? null : new MixedIngredients(inputs);
    }

    /**
     * Create a callback function for getting a storage for an ingredient component from the given network channel.
     * @param network The target network.
     * @param channel The target channel.
     * @param scheduleObservation If an observation inside the ingredients network should be scheduled.
     * @return A callback function for getting a storage for an ingredient component.
     */
    public static Function<IngredientComponent<?, ?>, IIngredientComponentStorage> getNetworkStorageGetter(INetwork network, int channel, boolean scheduleObservation) {
        return ingredientComponent -> getNetworkStorage(network, channel, ingredientComponent, scheduleObservation);
    }

    /**
     * Create a callback function for getting a storage for an ingredient component from the given crafting job buffer.
     * @param craftingJob The crafting job.
     * @return A callback function for getting a storage for an ingredient component.
     */
    public static Function<IngredientComponent<?, ?>, IIngredientComponentStorage> getCraftingJobBufferStorageGetter(CraftingJob craftingJob) {
        return ingredientComponent -> {
            List<?> list = craftingJob.getIngredientsStorageBuffer().getInstances(ingredientComponent);
            return new IngredientComponentStorageSlottedCollectionWrapper<>(new IngredientList(ingredientComponent, list), Long.MAX_VALUE, Long.MAX_VALUE);
        };
    }

    /**
     * Get all required recipe input ingredients based on a given storage callback.
     *
     * If multiple alternative inputs are possible,
     * then only the first possible match will be taken.
     *
     * Note: Make sure that you first call in simulation-mode
     * to see if the ingredients are available.
     * If you immediately call this non-simulated,
     * then there might be a chance that ingredients are lost
     * from the network.
     *
     * @param storageGetter A callback function to get a storage for the given ingredient component.
     * @param recipe The recipe to get the inputs from.
     * @param simulate If true, then the ingredients will effectively be removed from the network, not when false.
     * @param simulatedExtractionMemories This map remembers all extracted instances in simulation mode.
     *                                    This is to make sure that instances can not be extracted multiple times
     *                                    when simulating.
     * @param extractionMemoriesReusable Like simulatedExtractionMemories, but it stores the reusable ingredients.
     * @param collectMissingIngredients If missing ingredients should be collected.
     *                                  If false, then the first returned mixed ingredients may be null
     *                                  if no valid matches can be found,
     *                                  and the second returned list is always null,
     * @param recipeOutputQuantity The number of times the given recipe should be applied.
     * @return A pair with two objects:
     *           1. The found ingredients or null.
     *           2. A mapping from ingredient component to missing ingredients (non-slot-based).
     */
    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) {
        // Determine available and missing ingredients
        Map<IngredientComponent<?, ?>, List<?>> ingredientsAvailable = Maps.newIdentityHashMap();
        Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>> ingredientsMissing = Maps.newIdentityHashMap();
        for (IngredientComponent<?, ?> ingredientComponent : recipe.getInputComponents()) {
            IIngredientComponentStorage storage = storageGetter.apply(ingredientComponent);
            IngredientCollectionPrototypeMap<?, ?> simulatedExtractionMemory = simulatedExtractionMemories.get(ingredientComponent);
            if (simulatedExtractionMemory == null) {
                simulatedExtractionMemory = new IngredientCollectionPrototypeMap<>(ingredientComponent, true);
                simulatedExtractionMemories.put(ingredientComponent, simulatedExtractionMemory);
            }
            IIngredientCollectionMutable extractionMemoryReusable = extractionMemoriesReusable.get(ingredientComponent);
            if (extractionMemoryReusable == null) {
                extractionMemoryReusable = new IngredientHashSet<>(ingredientComponent);
                extractionMemoriesReusable.put(ingredientComponent, extractionMemoryReusable);
            }
            Pair<List<?>, MissingIngredients<?, ?>> subIngredients = getIngredientRecipeInputs(storage,
                    (IngredientComponent) ingredientComponent, recipe, simulate, simulatedExtractionMemory, extractionMemoryReusable,
                    collectMissingIngredients, recipeOutputQuantity);
            List<?> subIngredientAvailable = subIngredients.getLeft();
            MissingIngredients<?, ?> subIngredientsMissing = subIngredients.getRight();
            if (subIngredientAvailable == null && !collectMissingIngredients) {
                return Pair.of(null, null);
            } else {
                if (subIngredientAvailable != null && !subIngredientAvailable.isEmpty()) {
                    ingredientsAvailable.put(ingredientComponent, subIngredientAvailable);
                }
                if (collectMissingIngredients && !subIngredientsMissing.getElements().isEmpty()) {
                    ingredientsMissing.put(ingredientComponent, subIngredientsMissing);
                }
            }
        }

        // Compress missing ingredients
        // We do this to ensure that instances missing multiple times can be easily combined
        // when triggering a crafting job for them.
        Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>> ingredientsMissingCompressed = Maps.newIdentityHashMap();
        for (IngredientComponent<?, ?> ingredientComponent : ingredientsMissing.keySet()) {
            ingredientsMissingCompressed.put(ingredientComponent, compressMissingIngredients(ingredientsMissing.get(ingredientComponent)));
        }

        return Pair.of(ingredientsAvailable, ingredientsMissingCompressed);
    }

    /**
     * Create a list of prototyped ingredients from the instances
     * of the given ingredient component type in the given mixed ingredients.
     *
     * Equal prototypes will be stacked.
     *
     * @param ingredientComponent The ingredient component type.
     * @param mixedIngredients The mixed ingredients.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return A list of prototypes.
     */
    public static <T, M> List<IPrototypedIngredient<T, M>> getCompressedIngredients(IngredientComponent<T, M> ingredientComponent,
                                                                                    IMixedIngredients mixedIngredients) {
        List<IPrototypedIngredient<T, M>> outputs = Lists.newArrayList();

        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
        for (T instance : mixedIngredients.getInstances(ingredientComponent)) {
            // Try to stack this instance with an existing prototype
            boolean stacked = false;
            ListIterator<IPrototypedIngredient<T, M>> existingIt = outputs.listIterator();
            while(existingIt.hasNext()) {
                IPrototypedIngredient<T, M> prototypedIngredient = existingIt.next();
                if (matcher.matches(instance, prototypedIngredient.getPrototype(),
                        prototypedIngredient.getCondition())) {
                    T stackedInstance = matcher.withQuantity(prototypedIngredient.getPrototype(),
                            matcher.getQuantity(prototypedIngredient.getPrototype())
                                    + matcher.getQuantity(instance));
                    existingIt.set(new PrototypedIngredient<>(ingredientComponent, stackedInstance,
                            prototypedIngredient.getCondition()));
                    stacked = true;
                    break;
                }
            }

            // If not possible, just append it to the list
            if (!stacked) {
                outputs.add(new PrototypedIngredient<>(ingredientComponent, instance,
                        matcher.getExactMatchNoQuantityCondition()));
            }
        }

        return outputs;
    }

    /**
     * Compress the given missing ingredients so that equal instances just have an incremented quantity.
     *
     * @param missingIngredients The missing ingredients.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return A new missing ingredients object.
     */
    public static <T, M> MissingIngredients<T, M> compressMissingIngredients(MissingIngredients<T, M> missingIngredients) {
        // Index identical missing ingredients in a map, to group them by quantity
        Map<MissingIngredients.Element<T, M>, Long> elementsCompressedMap = Maps.newLinkedHashMap(); // Must be a linked map to maintain our order!!!
        for (MissingIngredients.Element<T, M> element : missingIngredients.getElements()) {
            elementsCompressedMap.merge(element, 1L, Long::sum);
        }

        // Create a new missing ingredients list where we multiply the missing quantities
        List<MissingIngredients.Element<T, M>> elementsCompressed = Lists.newArrayList();
        for (Map.Entry<MissingIngredients.Element<T, M>, Long> entry : elementsCompressedMap.entrySet()) {
            Long quantity = entry.getValue();
            if (quantity == 1L || entry.getKey().isInputReusable()) {
                elementsCompressed.add(entry.getKey());
            } else {
                MissingIngredients.Element<T, M> elementOld = entry.getKey();
                MissingIngredients.Element<T, M> elementNewQuantity = new MissingIngredients.Element<>(
                        elementOld.getAlternatives().stream()
                                .map(alt -> new MissingIngredients.PrototypedWithRequested<>(alt.getRequestedPrototype(), alt.getQuantityMissing() * quantity))
                                .toList(),
                        elementOld.isInputReusable()
                );
                elementsCompressed.add(elementNewQuantity);
            }
        }
        return new MissingIngredients<>(elementsCompressed);
    }

    /**
     * Create a collection of prototypes from the given recipe's outputs.
     *
     * Equal prototypes will be stacked.
     *
     * @param recipe A recipe.
     * @return A map from ingredient component types to their list of prototypes.
     */
    public static Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> getRecipeOutputs(IRecipeDefinition recipe) {
        Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> outputs = Maps.newHashMap();

        IMixedIngredients mixedIngredients = recipe.getOutput();
        for (IngredientComponent ingredientComponent : mixedIngredients.getComponents()) {
            outputs.put(ingredientComponent, getCompressedIngredients(ingredientComponent, mixedIngredients));
        }

        return outputs;
    }

    /**
     * Creates a new recipe outputs object with all ingredient quantities multiplied by the given amount.
     * @param recipeOutputs A recipe objects holder.
     * @param amount An amount to multiply all instances by.
     * @return A new recipe objects holder.
     */
    public static Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> multiplyRecipeOutputs(
            Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> recipeOutputs, int amount) {
        if (amount == 1) {
            return recipeOutputs;
        }

        Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> newRecipeOutputs = Maps.newIdentityHashMap();
        for (Map.Entry<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> entry : recipeOutputs.entrySet()) {
            newRecipeOutputs.put(entry.getKey(), multiplyPrototypedIngredients((List) entry.getValue(), amount));
        }
        return newRecipeOutputs;
    }

    /**
     * Multiply the quantity of a given prototyped ingredient list with the given amount.
     * @param prototypedIngredients A prototyped ingredient list.
     * @param amount An amount to multiply by.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return A multiplied prototyped ingredient list.
     */
    public static <T, M> List<IPrototypedIngredient<T, M>> multiplyPrototypedIngredients(Collection<IPrototypedIngredient<T, M>> prototypedIngredients,
                                                                                         long amount) {
        return prototypedIngredients
                .stream()
                .map(p -> multiplyPrototypedIngredient(p, amount))
                .collect(Collectors.toList());
    }

    /**
     * Multiply the quantity of a given prototyped ingredient with the given amount.
     * @param prototypedIngredient A prototyped ingredient.
     * @param amount An amount to multiply by.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return A multiplied prototyped ingredient.
     */
    public static <T, M> IPrototypedIngredient<T, M> multiplyPrototypedIngredient(IPrototypedIngredient<T, M> prototypedIngredient,
                                                                                  long amount) {
        IIngredientMatcher<T, M> matcher = prototypedIngredient.getComponent().getMatcher();
        return new PrototypedIngredient<>(prototypedIngredient.getComponent(),
                matcher.withQuantity(prototypedIngredient.getPrototype(),
                        matcher.getQuantity(prototypedIngredient.getPrototype()) * amount),
                prototypedIngredient.getCondition());
    }

    /**
     * Merge two mixed ingredients in a new mixed ingredients object.
     * Instances will be stacked.
     * @param a A first mixed ingredients object.
     * @param b A second mixed ingredients object.
     * @return A merged mixed ingredients object.
     */
    public static IMixedIngredients mergeMixedIngredients(IMixedIngredients a, IMixedIngredients b) {
        // Temporarily store instances in IngredientCollectionPrototypeMaps
        Map<IngredientComponent<?, ?>, IngredientCollectionQuantitativeGrouper<?, ?, IngredientArrayList<?, ?>>> groupings = Maps.newIdentityHashMap();
        for (IngredientComponent<?, ?> component : a.getComponents()) {
            IngredientCollectionQuantitativeGrouper grouping = new IngredientCollectionQuantitativeGrouper<>(new IngredientArrayList<>(component));
            groupings.put(component, grouping);
            grouping.addAll(a.getInstances(component));
        }
        for (IngredientComponent<?, ?> component : b.getComponents()) {
            IngredientCollectionQuantitativeGrouper grouping = groupings.get(component);
            if (grouping == null) {
                grouping = new IngredientCollectionQuantitativeGrouper<>(new IngredientArrayList<>(component));
                groupings.put(component, grouping);
            }
            grouping.addAll(b.getInstances(component));
        }

        // Convert IngredientCollectionPrototypeMaps to lists
        Map<IngredientComponent<?, ?>, List<?>> ingredients = Maps.newIdentityHashMap();
        for (Map.Entry<IngredientComponent<?, ?>, IngredientCollectionQuantitativeGrouper<?, ?, IngredientArrayList<?, ?>>> entry : groupings.entrySet()) {
            ingredients.put(entry.getKey(), Lists.newArrayList(entry.getValue()));
        }
        return new MixedIngredients(ingredients);
    }

    /**
     * Stack all ingredients in the given mixed ingredients object.
     * @param mixedIngredients A mixed ingredients object.
     * @return A new mixed ingredients object.
     */
    protected static IMixedIngredients compressMixedIngredients(IMixedIngredients mixedIngredients) {
        // Temporarily store instances in IngredientCollectionPrototypeMaps
        Map<IngredientComponent<?, ?>, IngredientCollectionQuantitativeGrouper<?, ?, IngredientArrayList<?, ?>>> groupings = Maps.newIdentityHashMap();
        for (IngredientComponent<?, ?> component : mixedIngredients.getComponents()) {
            IngredientCollectionQuantitativeGrouper grouping = new IngredientCollectionQuantitativeGrouper<>(new IngredientArrayList<>(component));
            groupings.put(component, grouping);
            grouping.addAll(mixedIngredients.getInstances(component));
        }

        // Convert IngredientCollectionPrototypeMaps to lists
        Map<IngredientComponent<?, ?>, List<?>> ingredients = Maps.newIdentityHashMap();
        for (Map.Entry<IngredientComponent<?, ?>, IngredientCollectionQuantitativeGrouper<?, ?, IngredientArrayList<?, ?>>> entry : groupings.entrySet()) {
            IIngredientMatcher matcher = entry.getKey().getMatcher();
            List<?> values = entry.getValue()
                    .stream()
                    .filter(i -> !matcher.isEmpty(i))
                    .collect(Collectors.toList());
            if (!values.isEmpty()) {
                ingredients.put(entry.getKey(), values);
            }
        }
        return new MixedIngredients(ingredients);
    }

    /**
     * Insert the ingredients of the given ingredient component type into the target to make it start crafting.
     *
     * If insertion in non-simulation mode fails,
     * ingredients will be re-inserted into the network.
     *
     * @param ingredientComponent The ingredient component type.
     * @param capabilityProvider The target capability provider.
     * @param side The target side.
     * @param ingredients The ingredients to insert.
     * @param storageFallback The storage to insert any failed ingredients back into. Can be null in simulation mode.
     * @param simulate If insertion should be simulated.
     * @param <T> The instance type.
     * @param <M> The matching condition parameter.
     * @return If all instances could be inserted.
     */
    public static <T, M> boolean insertIngredientCrafting(IngredientComponent<T, M> ingredientComponent,
                                                          ICapabilityProvider capabilityProvider,
                                                          @Nullable Direction side,
                                                          IMixedIngredients ingredients,
                                                          IIngredientComponentStorage<T, M> storageFallback,
                                                          boolean simulate) {
        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
        IIngredientComponentStorage<T, M> storage = ingredientComponent.getStorage(capabilityProvider, side);
        List<T> instances = ingredients.getInstances(ingredientComponent);
        List<T> failedInstances = Lists.newArrayList();
        boolean ok = true;
        for (T instance : instances) {
            T remaining = storage.insert(instance, simulate);
            if (!matcher.isEmpty(remaining)) {
                ok = false;
                if (!simulate) {
                    failedInstances.add(remaining);
                }
            }
        }

        // If we had failed insertions, try to insert them back into the network.
        for (T instance : failedInstances) {
            T remaining = storageFallback.insert(instance, false);
            if (!matcher.isEmpty(remaining)) {
                throw new IllegalStateException("Insertion for a crafting recipe failed" +
                        "due to inconsistent insertion behaviour by destination in simulation " +
                        "and non-simulation: " + capabilityProvider + ". Lost: " + instances);
            }
        }

        return ok;
    }

    /**
     * Insert the ingredients of all applicable ingredient component types into the target to make it start crafting.
     *
     * If insertion in non-simulation mode fails,
     * ingredients will be re-inserted into the network.
     *
     * @param targetGetter A function to get the target position.
     * @param ingredients The ingredients to insert.
     * @param network The network.
     * @param channel The channel.
     * @param simulate If insertion should be simulated.
     * @return If all instances could be inserted.
     */
    public static boolean insertCrafting(Function<IngredientComponent<?, ?>, PartPos> targetGetter,
                                         IMixedIngredients ingredients,
                                         INetwork network, int channel,
                                         boolean simulate) {
        Map<IngredientComponent<?, ?>, BlockEntity> tileMap = Maps.newIdentityHashMap();

        // First, check if we can find valid tiles for all ingredient components
        for (IngredientComponent<?, ?> ingredientComponent : ingredients.getComponents()) {
            BlockEntity tile = BlockEntityHelpers.get(targetGetter.apply(ingredientComponent).getPos(), BlockEntity.class).orElse(null);
            if (tile != null) {
                tileMap.put(ingredientComponent, tile);
            } else {
                return false;
            }
        }

        // Next, insert the instances into the respective tiles
        boolean ok = true;
        for (Map.Entry<IngredientComponent<?, ?>, BlockEntity> entry : tileMap.entrySet()) {
            IIngredientComponentStorage<?, ?> storageNetwork = simulate ? null : getNetworkStorage(network, channel, entry.getKey(), false);
            if (!insertIngredientCrafting((IngredientComponent) entry.getKey(), entry.getValue(),
                    targetGetter.apply(entry.getKey()).getSide(), ingredients,
                    storageNetwork, simulate)) {
                ok = false;
            }
        }

        return ok;
    }

    /**
     * Split the given crafting job amount into new jobs with a given split factor.
     * @param craftingJob A crafting job to split.
     * @param splitFactor The number of jobs to split the job over.
     * @param dependencyGraph The dependency graph that will be updated if there are dependencies in the original job.
     * @param identifierGenerator An identifier generator for the crafting jobs ids.
     * @return The newly created crafting jobs.
     */
    public static List<CraftingJob> splitCraftingJobs(CraftingJob craftingJob, int splitFactor,
                                                      CraftingJobDependencyGraph dependencyGraph,
                                                      IIdentifierGenerator identifierGenerator) {
        splitFactor = Math.min(splitFactor, craftingJob.getAmount());
        int division = craftingJob.getAmount() / splitFactor;
        int modulus = craftingJob.getAmount() % splitFactor;

        // Clone original job into splitFactor jobs
        List<CraftingJob> newCraftingJobs = Lists.newArrayList();
        for (int i = 0; i < splitFactor; i++) {
            CraftingJob clonedJob = craftingJob.clone(identifierGenerator);
            newCraftingJobs.add(clonedJob);

            // Update amount
            int newAmount = division;
            if (modulus > 0) {
                // No amounts will be lost, as modulus is guaranteed to be smaller than splitFactor
                newAmount++;
                modulus--;
            }
            clonedJob.setAmount(newAmount);
        }

        // Collect dependency links
        Collection<CraftingJob> originalDependencies = dependencyGraph.getDependencies(craftingJob);
        Collection<CraftingJob> originalDependents = dependencyGraph.getDependents(craftingJob);

        // Remove dependency links to and from the original jobs
        for (CraftingJob dependency : originalDependencies) {
            craftingJob.removeDependency(dependency);
            dependencyGraph.removeDependency(craftingJob.getId(), dependency.getId());
        }
        for (CraftingJob dependent : originalDependents) {
            dependent.removeDependency(craftingJob);
            dependencyGraph.removeDependency(dependent.getId(), craftingJob.getId());
        }

        // Create dependency links to and from the new crafting jobs
        for (CraftingJob dependency : originalDependencies) {
            for (CraftingJob newCraftingJob : newCraftingJobs) {
                newCraftingJob.addDependency(dependency);
                dependencyGraph.addDependency(newCraftingJob, dependency);
            }
        }
        for (CraftingJob originalDependent : originalDependents) {
            for (CraftingJob newCraftingJob : newCraftingJobs) {
                originalDependent.addDependency(newCraftingJob);
                dependencyGraph.addDependency(originalDependent, newCraftingJob);
            }
        }

        return newCraftingJobs;
    }

    /**
     * Insert the given ingredients into the given storage networks.
     * @param ingredients A collection of ingredients.
     * @param storageGetter A storage network getter.
     * @param simulate If insertion should be simulated.
     * @return The remaining ingredients that were not inserted.
     */
    public static IMixedIngredients insertIngredients(IMixedIngredients ingredients,
                                                      Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
                                                      boolean simulate) {
        Map<IngredientComponent<?, ?>, List<?>> remainingIngredients = Maps.newIdentityHashMap();
        for (IngredientComponent<?, ?> component : ingredients.getComponents()) {
            IIngredientComponentStorage storage = storageGetter.apply(component);
            IIngredientMatcher matcher = component.getMatcher();
            for (Object instance : ingredients.getInstances(component)) {
                Object remainder = storage.insert(instance, simulate);
                if (!matcher.isEmpty(remainder)) {
                    List remainingInstances = remainingIngredients.get(component);
                    if (remainingInstances == null) {
                        remainingInstances = Lists.newArrayList();
                        remainingIngredients.put(component, remainingInstances);
                    }
                    remainingInstances.add(instance);
                }
            }
        }
        return new MixedIngredients(remainingIngredients);
    }

    /**
     * Insert the given ingredients into the given storage networks.
     * If something fails to be inserted, produce a warning.
     * @param ingredients A collection of ingredients.
     * @param storageGetter A storage network getter.
     * @param failureSink Ingredients that failed to be inserted will be inserted to this sink.
     */
    public static void insertIngredientsGuaranteed(IMixedIngredients ingredients,
                                                   Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter,
                                                   ICraftingResultsSink failureSink) {
        IMixedIngredients remaining = insertIngredients(ingredients, storageGetter, false);
        // If re-insertion into the network fails, insert it into the buffer of the crafting interface,
        // to avoid loss of ingredients.
        if (!remaining.isEmpty()) {
            for (IngredientComponent<?, ?> component : remaining.getComponents()) {
                for (Object instance : remaining.getInstances(component)) {
                    failureSink.addResult((IngredientComponent) component, instance);
                }
            }
        }
    }

    /**
     * Generates semi-unique IDs.
     */
    public static interface IIdentifierGenerator {
        public int getNext();
    }

}

CyclopsMC / IntegratedCrafting / #479011822

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous