Merge remote-tracking branch 'origin/master-1.21-lts' into master-1.21

Author: rubensworks

CHANGELOG-1.20.1.md

@@ -1,8 +1,24 @@
 # Changelog for Minecraft 1.20.1
 All notable changes to this project will be documented in this file.
 
+<a name="1.20.1-1.4.0"></a>
+## [1.20.1-1.4.0](/compare/1.20.1-1.3.3...1.20.1-1.4.0) - 2025-12-31 14:42:03
+
+
+### Changed
+* 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.
+
+This also improves overall performance, as it is not necessary to run synchronous observers anymore.
+
+Closes #112
+
 <a name="1.20.1-1.3.3"></a>
-## [1.20.1-1.3.3](/compare/1.20.1-1.3.2...1.20.1-1.3.3) - 2025-11-21 19:51:37
+## [1.20.1-1.3.3](/compare/1.20.1-1.3.2...1.20.1-1.3.3) - 2025-11-21 19:51:37 +0100
 
 
 ### Changed

CHANGELOG-1.21.1.md

@@ -1,8 +1,24 @@
 # Changelog for Minecraft 1.21.1
 All notable changes to this project will be documented in this file.
 
+<a name="1.21.1-1.4.0"></a>
+## [1.21.1-1.4.0](https://github.com/CyclopsMC/IntegratedCrafting/compare/1.21.1-1.3.4...1.21.1-1.4.0) - 2025-12-31 14:44:30
+
+
+### Changed
+* 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.
+
+This also improves overall performance, as it is not necessary to run synchronous observers anymore.
+
+Closes #112
+
 <a name="1.21.1-1.3.4"></a>
-## [1.21.1-1.3.4](https://github.com/CyclopsMC/IntegratedCrafting/compare/1.21.1-1.3.3...1.21.1-1.3.4) - 2025-11-21 19:52:19
+## [1.21.1-1.3.4](https://github.com/CyclopsMC/IntegratedCrafting/compare/1.21.1-1.3.3...1.21.1-1.3.4) - 2025-11-21 19:52:19 +0100
 
 
 ### Added

gradle.properties

@@ -32,6 +32,6 @@ org.gradle.caching=true
 
 # Dependencies
 cyclopscore_version=1.25.5-871
-integrateddynamics_version=1.24.1-1419
+integrateddynamics_version=1.24.1-1455
 commoncapabilities_version=2.9.7-303
 integratedtunnels_version=1.8.30-534

resources/changelog/1.20.1-1.4.0.txt

@@ -0,0 +1,15 @@
+As always, don't forget to backup your world before updating!
+Requires CyclopsCore version 1.18.4 or higher.
+
+Changes:
+* 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.
+
+This also improves overall performance, as it is not necessary to run synchronous observers anymore.
+
+Closes #112
+

resources/changelog/1.21.1-1.4.0.txt

@@ -0,0 +1,15 @@
+As always, don't forget to backup your world before updating!
+Requires CyclopsCore version 1.26.2 or higher.
+
+Changes:
+* 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.
+
+This also improves overall performance, as it is not necessary to run synchronous observers anymore.
+
+Closes #112
+

src/main/java/org/cyclops/integratedcrafting/api/crafting/CraftingJob.java

@@ -5,13 +5,20 @@
 import it.unimi.dsi.fastutil.ints.IntList;
 import net.minecraft.world.level.storage.ValueInput;
 import net.minecraft.world.level.storage.ValueOutput;
+import org.apache.commons.compress.utils.Lists;
 import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
+import org.cyclops.commoncapabilities.api.ingredient.IIngredientMatcher;
 import org.cyclops.commoncapabilities.api.ingredient.IMixedIngredients;
 import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
+import org.cyclops.commoncapabilities.api.ingredient.MixedIngredients;
+import org.cyclops.cyclopscore.ingredient.collection.IngredientList;
+import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageSlottedCollectionWrapper;
 import org.cyclops.integratedcrafting.core.CraftingHelpers;
 import org.cyclops.integratedcrafting.core.MissingIngredients;
 
 import javax.annotation.Nullable;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
@@ -26,7 +33,8 @@ public class CraftingJob {
     private final IntList dependencyCraftingJobs;
     private final IntList dependentCraftingJobs;
     private int amount;
-    private IMixedIngredients ingredientsStorage;
+    private IMixedIngredients ingredientsStorage; // Total to extract from storage (simulated and immutable)
+    private IMixedIngredients ingredientsStorageBuffer; // The actual ingredients from storage, which are consumed over time.
     private Map<IngredientComponent<?, ?>, MissingIngredients<?, ?>> lastMissingIngredients;
     private long startTick;
     private boolean invalidInputs;
@@ -40,6 +48,7 @@ public CraftingJob(int id, int channel, IRecipeDefinition recipe, int amount, IM
         this.recipe = recipe;
         this.amount = amount;
         this.ingredientsStorage = ingredientsStorage;
+        this.ingredientsStorageBuffer = new MixedIngredients(Maps.newIdentityHashMap());
         this.lastMissingIngredients = Maps.newIdentityHashMap();
         this.dependencyCraftingJobs = new IntArrayList();
         this.dependentCraftingJobs = new IntArrayList();
@@ -97,6 +106,85 @@ public void setIngredientsStorage(IMixedIngredients ingredientsStorage) {
         this.ingredientsStorage = ingredientsStorage;
     }
 
+    public IMixedIngredients getIngredientsStorageBuffer() {
+        return ingredientsStorageBuffer;
+    }
+
+    public void setIngredientsStorageBuffer(IMixedIngredients ingredientsStorageBuffer) {
+        this.ingredientsStorageBuffer = ingredientsStorageBuffer;
+    }
+
+    public <T, M> long getMissingIngredientQuantity(IngredientComponent<T, M> ingredientComponent, T instance) {
+        long quantityMissing = 0;
+        MissingIngredients<?, ?> missingIngredients = this.lastMissingIngredients.get(ingredientComponent);
+        if (missingIngredients != null) {
+            IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
+            for (MissingIngredients.Element<?, ?> element : missingIngredients.getElements()) {
+                for (MissingIngredients.PrototypedWithRequested<?, ?> alternative : element.getAlternatives()) {
+                    if (matcher.matches(instance, (T) alternative.getRequestedPrototype().getPrototype(), matcher.withoutCondition((M) alternative.getRequestedPrototype().getCondition(), ingredientComponent.getPrimaryQuantifier().getMatchCondition()))) {
+                        quantityMissing += alternative.getQuantityMissing();
+                    }
+                }
+            }
+        }
+        return quantityMissing;
+    }
+
+    public <T, M> void addToIngredientsStorageBuffer(IngredientComponent<T, M> ingredientComponent, T instance) {
+        // Add instance to the buffer
+        IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();
+        IMixedIngredients buffer = this.getIngredientsStorageBuffer();
+        if (!buffer.getComponents().contains(ingredientComponent)) {
+            Map<IngredientComponent<?, ?>, List<?>> mixedIngredientsRaw = Maps.newIdentityHashMap();
+            for (IngredientComponent<?, ?> component : buffer.getComponents()) {
+                mixedIngredientsRaw.put(component, buffer.getInstances(component));
+            }
+            List<T> list = Lists.newArrayList();
+            mixedIngredientsRaw.put(ingredientComponent, list);
+            list.add(instance);
+            buffer = new MixedIngredients(mixedIngredientsRaw);
+            this.setIngredientsStorageBuffer(buffer);
+        } else {
+            List<T> instances = buffer.getInstances(ingredientComponent);
+            if (!instances.stream().anyMatch(matcher::isEmpty)) {
+                // Make sure we have at least one empty slot available, to guarantee insertion can succeed.
+                instances.add(matcher.getEmptyInstance());
+            }
+            T remaining = new IngredientComponentStorageSlottedCollectionWrapper<>(new IngredientList<>(ingredientComponent, instances), Integer.MAX_VALUE, Integer.MAX_VALUE).insert(instance, false);
+            if (!matcher.isEmpty(remaining)) {
+                throw new IllegalStateException(String.format("Unable to insert %s into the crafting job buffer, remaining: ", instances, remaining));
+            }
+        }
+
+        // If the instance was a missing ingredient, remove it
+        long instanceQuantity = matcher.getQuantity(instance);
+        MissingIngredients<?, ?> missingIngredients = this.lastMissingIngredients.get(ingredientComponent);
+        if (missingIngredients != null) {
+            Iterator<? extends MissingIngredients.Element<?, ?>> it = missingIngredients.getElements().iterator();
+            boolean removed = false;
+            while (it.hasNext() && instanceQuantity > 0) {
+                MissingIngredients.Element<?, ?> element = it.next();
+                for (MissingIngredients.PrototypedWithRequested<?, ?> alternative : element.getAlternatives()) {
+                    if (matcher.matches(instance, (T) alternative.getRequestedPrototype().getPrototype(), matcher.withoutCondition((M) alternative.getRequestedPrototype().getCondition(), ingredientComponent.getPrimaryQuantifier().getMatchCondition()))) {
+                        long missingQuantityToConsume = Math.min(alternative.getQuantityMissing(), instanceQuantity);
+                        alternative.setQuantityMissing(alternative.getQuantityMissing() - missingQuantityToConsume);
+                        instanceQuantity -= missingQuantityToConsume;
+                        if (alternative.getQuantityMissing() == 0) {
+                            removed = true;
+                            it.remove();
+                        }
+                        break;
+                    }
+                }
+            }
+            if (removed) {
+                if (missingIngredients.getElements().isEmpty()) {
+                    this.lastMissingIngredients.remove(ingredientComponent);
+                }
+            }
+        }
+    }
+
     /**
      * @return The ingredients that were missing for 1 job amount. This will mostly be an empty map.
      */
@@ -149,6 +237,7 @@ public static void serialize(ValueOutput valueOutput, CraftingJob craftingJob) {
         valueOutput.putIntArray("dependents", craftingJob.getDependentCraftingJobs().toIntArray());
         valueOutput.putInt("amount", craftingJob.amount);
         IMixedIngredients.serialize(valueOutput.child("ingredientsStorage"), craftingJob.ingredientsStorage);
+        IMixedIngredients.serialize(valueOutput.child("ingredientsStorageBuffer"), craftingJob.ingredientsStorageBuffer);
         MissingIngredients.serialize(valueOutput.child("lastMissingIngredients"), craftingJob.lastMissingIngredients);
         valueOutput.putLong("startTick", craftingJob.startTick);
         valueOutput.putBoolean("invalidInputs", craftingJob.invalidInputs);
@@ -164,6 +253,7 @@ public static CraftingJob deserialize(ValueInput valueInput) {
         IRecipeDefinition recipe = IRecipeDefinition.deserialize(valueInput.child("recipe").orElseThrow());
         int amount = valueInput.getInt("amount").orElseThrow();
         IMixedIngredients ingredientsStorage = IMixedIngredients.deserialize(valueInput.child("ingredientsStorage").orElseThrow());
+        IMixedIngredients ingredientsStorageBuffer = valueInput.child("ingredientsStorageBuffer").map(IMixedIngredients::deserialize).orElseGet(() -> new MixedIngredients(Maps.newIdentityHashMap())); // TODO: rm backwards-compat in nextmajor (use orElseThrow)
         CraftingJob craftingJob = new CraftingJob(id, channel, recipe, amount, ingredientsStorage);
         for (int dependency : valueInput.getIntArray("dependencies").orElseThrow()) {
             craftingJob.dependencyCraftingJobs.add(dependency);
@@ -178,6 +268,7 @@ public static CraftingJob deserialize(ValueInput valueInput) {
         craftingJob.setInvalidInputs(valueInput.getBooleanOr("invalidInputs", false));
         valueInput.getString("initiatorUuid").ifPresent(craftingJob::setInitiatorUuid);
         craftingJob.setIgnoreDependencyCheck(valueInput.getBooleanOr("ignoreDependencyCheck", false));
+        craftingJob.setIngredientsStorageBuffer(ingredientsStorageBuffer);
         return craftingJob;
     }
 
@@ -203,6 +294,9 @@ public boolean equals(Object obj) {
     }
 
     public CraftingJob clone(CraftingHelpers.IIdentifierGenerator identifierGenerator) {
+        if (!this.getIngredientsStorageBuffer().isEmpty()) {
+            throw new IllegalStateException("Cloning a job with an ingredient buffer is illegal");
+        }
         return new CraftingJob(
                 identifierGenerator.getNext(),
                 getChannel(),

src/main/java/org/cyclops/integratedcrafting/api/crafting/ICraftingInterface.java

@@ -3,14 +3,12 @@
 import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
 import org.cyclops.commoncapabilities.api.ingredient.IPrototypedIngredient;
 import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
+import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
 import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
 import org.cyclops.integrateddynamics.api.part.PrioritizedPartPos;
 
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.function.Function;
 
 /**
  * A handler for invoking crafting recipes.
@@ -34,6 +32,13 @@ public interface ICraftingInterface {
      */
     public void scheduleCraftingJob(CraftingJob craftingJob);
 
+    /**
+     * Extract the required ingredients from storage and store them in the job.
+     * @param craftingJob The crafting job.
+     * @param storageGetter The storage getter.
+     */
+    public void fillCraftingJobBufferFromStorage(CraftingJob craftingJob, Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter);
+
     /**
      * @return Get the number of scheduled and running crafting jobs in this interface.
      */
@@ -80,5 +85,4 @@ public interface ICraftingInterface {
     public static Comparator<ICraftingInterface> createComparator() {
         return Comparator.comparing(ICraftingInterface::getPosition);
     }
-
 }

src/main/java/org/cyclops/integratedcrafting/api/crafting/ICraftingProcessOverride.java

@@ -28,10 +28,11 @@ public interface ICraftingProcessOverride {
      * @param recipe       The recipe from which the ingredients were derived.
      * @param resultsSink  A sink where the ingredients can optionally be inserted into.
      *                     This should only be used if the processor does not have an internal storage.
+     * @param craftingJob  The running crafting job (or pending job if simulating).
      * @param simulate     If insertion should be simulated.
      * @return If all instances could be inserted.
      */
     public boolean craft(Function<IngredientComponent<?, ?>, PartPos> targetGetter, IMixedIngredients ingredients,
-                         IRecipeDefinition recipe, ICraftingResultsSink resultsSink, boolean simulate);
+                         IRecipeDefinition recipe, ICraftingResultsSink resultsSink, CraftingJob craftingJob, boolean simulate);
 
 }

src/main/java/org/cyclops/integratedcrafting/api/network/ICraftingNetwork.java

@@ -3,6 +3,7 @@
 import com.google.common.collect.Multimap;
 import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
 import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
+import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
 import org.cyclops.integratedcrafting.api.crafting.CraftingJob;
 import org.cyclops.integratedcrafting.api.crafting.CraftingJobDependencyGraph;
 import org.cyclops.integratedcrafting.api.crafting.ICraftingInterface;
@@ -12,6 +13,7 @@
 import javax.annotation.Nullable;
 import java.util.Iterator;
 import java.util.Set;
+import java.util.function.Function;
 
 /**
  * A network capability for crafting.
@@ -89,11 +91,13 @@ public interface ICraftingNetwork {
 
     /**
      * Add the given crafting job to the list of crafting jobs.
-     * @param craftingJob The crafting job.
+     *
+     * @param craftingJob       The crafting job.
      * @param allowDistribution If the crafting job is allowed to be split over multiple crafting interfaces.
+     * @param storageGetter     The storage getter.
      * @throws UnavailableCraftingInterfacesException If no crafting interfaces were available.
      */
-    public void scheduleCraftingJob(CraftingJob craftingJob, boolean allowDistribution) throws UnavailableCraftingInterfacesException;
+    public void scheduleCraftingJob(CraftingJob craftingJob, boolean allowDistribution, Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter) throws UnavailableCraftingInterfacesException;
 
     /**
      * Called by crafting interfaces when the crafting job is finished and should be removed from all lists.